Loomworks — Stele Phase 7 Scoping Handoff — v0.3

Version. 0.3 Date. 2026-06-19 Author. Marvin Percival (DUNIN7 Operator) with Claude.ai (scoping) on DUNIN7-M4. For. A fresh Claude.ai chat — the scoping-note authoring role. Step 0 is closed; this chat's product is the Phase 7 scoping note, whose central job is to put the §E fork to the Operator and record its resolution. Status. Scoping-note handoff. Phase 7 Step 0 (the accessor-class inventory + extraction-blocker triage) is complete and filed. The import-graph is proven clean — no de-coupling sub-arc. One open decision remains: the §E fork. Markdown primary (technical consumer / next-session orientation).

Plain-language summary

What this chat does. Authors the Phase 7 scoping note — the document that names what the Phase 7 extraction CR(s) commit to, what's in and out, and how the deliverable set sequences. Its central job is to resolve one open decision: the §E fork (below). Everything else Step 0 already settled.

What Step 0 settled (do not re-establish). Stele is a pure library today — no router of its own. The identity/auth HTTP surface lives host-side. The import-graph is clean: the service layer binds Stele downward, and onboard (the host composition) is host-pure, so no de-coupling sub-arc is needed before extraction. The Stele↔host cut line already exists — the Phase-4 mint↔onboard split. Phase 7 is a design-decision arc, not an untangling arc.

The one open decision — the §E fork. What does "mountable" mean for the stranger-clones-and-runs bar?

• (A) Stele owns signup/login orchestration. Stele ships the marquee /auth/signup/ + /auth/login/ routes. The stranger's app gets working sign-up/sign-in out of the box. Cost: Stele's signup/login functions call onboard, which is host-side — so (A) introduces a Stele→host onboard callback seam (an injected callback contract Stele defines and the host fills; not an upward import, but a new seam).
• (B) Stele ships primitive-level routes only. The me_security/auth_dev shape — direct primitive calls (ceremony, mint, session, credential, recovery). Smaller, import-pure, no callback seam. Cost: the headline signup/sign-in flows aren't in the package; the reference app wires ceremony→mint→session itself.

The Operator's lean (recorded, not yet a decision). (B) primitives-only for the first packaging CR — it ships a clean, import-pure, callback-seam-free Stele the stranger can mount and build signup over, and it defers the (A) callback contract to a later CR once the primitive surface is proven. Smaller blast radius, no new seam, and it matches the seed's "the engine is the product; Stele is a substrate primitive." (A) is a real option later. This chat puts the fork to the Operator; the Operator decides.

Read first (this chat's orientation)

In order, from loomworks-record (behind Cloudflare Access — if unreachable, ask CC to fetch to Downloads; or use the zip CC has prepared, see the manifest at the end of this handoff):

1. The Step 0 inspection report — phases/stele-extraction-phase-7/loomworks-stele-phase-7-step-0-inspection-report-v0_1.md. This is the ground. §A library-only; §B the 18 endpoints at three depths; §C the depth-2 binding-surface trace; §D the mint↔onboard cut line (the load-bearing finding); §E the fork (the decision); §F packaging-shape signals. The scoping note drafts from this report's facts, not from this handoff's shorthand.
2. The Step 0 brief — phases/stele-extraction-phase-7/loomworks-stele-phase-7-step-0-inspection-brief-v0_1.md. The planned trajectory the report executed against (corrections-preserved). Read it to see the seven accessor classes the inspection was structured by.
3. The seed — candidate-seeds/loomworks/loomworks-candidate-seed-v0_12.md (canonical). The §E fork is seed-adjacent: it defines what "mountable" means against the stranger-clones-and-runs bar. Verify the chosen fork contradicts no seed commitment (auth framework / identity-is-UUID / the four rooms). The "stranger clones and runs" bar is a strategic-direction commitment, not a seed clause.
4. The architecture spec — architecture/loomworks-architecture-specification-v0_5.md (v0.5 canonical — confirmed by the Operator 2026-06-19; the manifest's v0.4 pointer is stale, being corrected separately). For "the Engine is the product; the Companion is a subordinate access path." Load-bearing for the fork: the SDK/router/reference-app surfaces should reflect "engine is the product, Stele is a substrate primitive" — which is part of why the Operator leans (B).
5. The current-status manifest — current-status/current-status-manifest-v0_64.md (confirm it's still highest; CR-B closed at v0.64). Phase 7 framing + the deliverable set.
6. The CR-B completion record — phases/stele-extraction-cr-b/loomworks-stele-cr-b-completion-record-v0_1.md. The end-state Phase 7 starts from + the banked accessor-class lesson the Step 0 report validated again.

The state Phase 7 starts from (settled, do not re-open)

• engine main = fe7c3f1 (CR-B merge), alembic head 0093, suite 2928/0/46.
• record main = 2ed8d9e (Step 0 brief + report filed; manifest v0.64).
• persons is dropped; principals is the sole identity table; the reverse mirror is retired; stele/models.py is SteleBase-only.
• The Stele contract trilogy is closed: CR-A (bee2b4c) → CR-C (d0f302e) → CR-B (fe7c3f1).
• Stele is library-only — 10 .py files (__init__, actor, base, credentials, models, person_totp, recovery, registry, session, webauthn), no APIRouter, no routes.
• The import-graph is clean — no de-coupling sub-arc required (Step 0 §D/§E).
• The cut line pre-exists — Phase-4 mint↔onboard: mint_principal is Stele, onboard is host-pure.

What the scoping note must produce

1. Put the §E fork to the Operator and record the resolution. This is the note's central job. Present (A) and (B) as Step 0 framed them — (A) marquee routes + onboard callback seam; (B) primitives-only, reference app wires the flows. Carry the Operator's recorded lean ((B) first) but let the Operator settle it. The resolution drives everything below.
2. Name what the Phase 7 CR(s) commit to, given the fork resolution. The deliverable set (from the seed's strategic direction + the manifest): standalone repo, own dependency manifest + migration set, SDK surface, mountable router, docs-with-runnable-examples, reference app, thin config generator. Which of these the first CR commits to depends on the fork.
3. Decide one-CR vs sub-arc — informed, not pre-decided. Step 0 proved no de-coupling sub-arc is needed (the import-graph is clean). Whether the packaging is one CR or a sequence is still a scoping call, driven by the deliverable-set size and the fork. The deliverable set is large; a sub-arc (extract repo → migration set → SDK/router → reference app/config gen) is plausible. Name the sequencing.
4. Record the carry-forwards Step 0 surfaced for CR-drafting (not scoping blockers, but sequencing costs):

• persons/signup.py is doubly-bound — serves the signup flow and me_security's passkey-enrollment. Splitting it touches both surfaces.
• stele/webauthn is the load-bearing binding — 4 ceremony functions across both flows; whatever the fork resolves to, the ceremony engine is the core (already inside stele/, settled).
• The migration set must become Stele's own, runnable independently (Step 0's category-4 surface; the engine's alembic chain currently carries Stele's revisions).

The arc from here (standard)

1. This scoping chat authors the Phase 7 scoping note → puts the §E fork to the Operator → records the resolution.
2. A CR-drafting chat drafts the Phase 7 CR(s) from the scoping note + the Step 0 report.
3. CC executes.

Two-role division holds: scoping/CR-drafting (Claude.ai) separate from execution (CC). Fresh chat per role.

Standing disciplines to carry in

• Ground from the Step 0 report, not this handoff's shorthand.
• The fork is the Operator's call — surface it, lean (B), let the Operator settle.
• Seed-alignment check — the chosen fork must contradict no seed commitment; if it appears to, raise it before proceeding.
• Corrections preserved, not smoothed — if scoping surfaces that a deliverable-set assumption is wrong, name it.
• CC instruction blocks in fenced code blocks, commentary outside.
• Document format — operator-facing scoping note is HTML primary + Markdown source; lands in loomworks-record.

Open items riding alongside (not Phase 7 blockers)

• CR-2026-098 (engine 5472335) — four boundary findings, awaiting CC execution with the A3 privilege-model HALT. Orthogonal.
• API documentation effort — ~200 routes + ~1,000 fields. Orthogonal.
• Methodology v0.21 consolidation — manifest §2.D updated with CR-B's lessons; broader consolidation still pends. Not a gate.

Files the scoping chat needs (the zip CC has prepared)

CC has assembled these into stele-phase-7-scoping-note-inputs-v0_1.zip in Downloads, for upload into the fresh scoping chat:

1. loomworks-stele-phase-7-step-0-inspection-report-v0_1.md — the ground.
2. loomworks-stele-phase-7-step-0-inspection-brief-v0_1.md — the planned trajectory.
3. loomworks-candidate-seed-v0_12.md — the seed.
4. loomworks-architecture-specification-v0_5.md — v0.5 canonical.
5. current-status-manifest-v0_64.md — current state.
6. loomworks-stele-cr-b-completion-record-v0_1.md — the end-state Phase 7 starts from.
7. This handoff — loomworks-stele-phase-7-scoping-handoff-v0_3.md.

DUNIN7 — Done In Seven LLC — Miami, Florida Loomworks — Stele Phase 7 Scoping Handoff — v0.3 — 2026-06-19