Loomworks Scoping Note — Creation-Conversation → Memory-Assertion Pathway — v0.2

Plain-language summary. When you create an engagement and commit it, the engagement comes alive with a faithful seed — but its Memory is empty. Zero assertions. The facts you stated while creating it (Fenwick is a houseplant, it sits on the west windowsill, it was watered Tuesday) were never written into the engagement's Memory. The render reads committed assertions, so with none there is nothing to render. The architecture already settles that the creation conversation is supposed to feed Memory — that pathway was simply never built. This phase builds it. Folded in: the committed seed currently lands on the shared commons rather than on the engagement it belongs to (a scoping bug), and one open design question — whether the seed-creation conversation is itself an engagement or a dedicated surface — gets settled here because it governs where the draft seed and the conversation's facts live before the engagement exists. v0.2 absorbs the Step 0 inspection brief: the pathway is confirmed unwired at code level, an adaptable analog mechanism already exists, and the three open decisions are now settled with engine code in view.

0. What changed from v0.1 (Step 0 absorption)

• Decisions A, B, C are settled (was: "to be settled at Step 0"). See §3.
• Citation correction: §16 → §13. Architecture specification v0.4 has no §16 — it ends at §15. The deferred S####-vs-surface question lives in §13 ("Seed creation as recursive engagement" and "Engagement creation conversation orphaning"). The §16 reference in v0.1 and in the walk handoff was a propagated error (source: walk handoff; corrected against the canonical spec read at Step 0).
• Count correction: 6 → 7 orphaned seeds. The dev database holds 7 unreferenced seed lineages on E0001, not 6. The handoff cited 6; the DB read at Step 0 found 7 (likely the 6 candidates plus E0061's seed). To reconcile against the cleanup provenance record before the change request — see §6.
• The pathway is confirmed genuinely unwired — zero assertion writes anywhere on the creation path (grep-confirmed). Not partial, not dead code: absent.
• An adaptable analog exists — the in-engagement remember intent already turns conversation into held assertions; it just refuses the creation conversation. This is the mechanism to adapt, not invent. See §1.

1. The problem, stated against the design (confirmed at code level)

The live walk (Fenwick → E0060) verified end to end against the engine database: an engagement commits cleanly, becomes active, carries a faithful seed — and holds zero committed assertions. Step 0 confirmed this at code level: the commit path (POST /me/engagements/from-conversation → commit_engagement[_divergent] → _create_engagement) writes only the Engagement object (a seed_ref pointer) plus a wasDerivedFrom relationship. No assertion is written anywhere on the creation path. The conversation is read exactly once — at commit, by the seed extractor — and never for assertions.

The render chain is Render ← Shaping ← Manifestation ← committed assertions. With no assertions, the chain has no input. The render machinery was never the blocker. Getting the engagement's facts into its Memory as assertions is.

What the design settles (architecture specification v0.4, confirmed verbatim at Step 0):

• Memory accumulates via contribution pathways (Spec §03, "Population — how Memory grows"). The creation conversation is named as one such pathway, verbatim. File upload is another — already built, Phases 59–60.
• The seed is NOT the Memory content (Spec §02). An engagement holds two distinct things: a seed (its frame of reference, the lens for relevance) and a Memory (accumulated knowledge as assertions). Seed v0.9 (current; v0.8 archived) confirms all three load-bearing commitments unchanged: seed-as-frame, Memory-as-assertions, corrections-preserved.
• Therefore: do not decompose the seed into assertions. That would collapse the frame-of-reference into the content it is meant to evaluate — a direct contradiction of §02. Memory is populated from the conversation, leaving the seed as the frame.

Zero assertions post-commit is an unwired pathway, not a designed resting state.

The analog mechanism that already exists (Step 0). The in-engagement remember intent (router.py:282) takes one classified fact per turn and writes a held assertion via add_assertion, committed by commit_assertion. It is the closest thing to the pathway this phase builds — but it hard-rejects engagement_id IS NULL, so it cannot run on the creation conversation (which has no engagement yet). The pathway adapts this existing mechanism rather than inventing a new one.

Corrections-preserved is revise_assertion, not a supersede op (Step 0). There is no distinct supersede operation. Corrections are handled by revise_assertion — a new held version plus a wasRevisionOf relationship, with prior versions reachable via history. This is the contract Decision B rides on.

2. What this phase covers

In scope:

1. The creation-conversation → Memory-assertion pathway. Take facts stated during engagement creation and write them into the engagement's Memory as committed assertions with provenance. Adapt the existing remember / add_assertion / commit_assertion mechanism. Headline deliverable.

1. Seed-scope fix (folded in). The committed seed must be scoped to its engagement, not commons E0001. Confirmed at code level: draft_seed writes the seed on ADMINISTRATIVE_ENGAGEMENT_ID (= E0001); the committed engagement holds only a seed_ref pointer; the seed is never re-homed. DB confirms E0060's seed 6db3f37c is physically on E0001. The fix re-homes the seed onto the engagement at commit. This also clears the orphaned-seeds residue (see §6).

1. Settle the deferred §13 scope question. Whether the seed-creation conversation is itself an engagement (S####) or a dedicated surface. Settled in this phase as Decision C (§3) — not deferred again.

Out of scope (parked, for the manifest — not this phase):

• Convergence-surface legibility ("N things need your input" names a count, not the content).
• Override chip missing on the in-engagement surface (CenterPane vs ChatView drift).
• Stale "Drafting your scoping note…" spinner on the active engagement page.
• Block-contiguity resume boundary tightening.
• "Claude Project as engagement source" investigation (deferred direction; gated on this pathway plus an unverified Project-access unknown).

3. Open design decisions — SETTLED (Step 0, code in view)

Decision A — When assertions are written. SETTLED: at commit, from the reviewed conversation. Step 0 confirmed the conversation is already read once, at commit, by the seed extractor. Assertion-writing rides the same commit boundary: when the Operator commits, the reviewed conversation's facts are extracted and written as held assertions, then committed through the held → commit ceremony — atomic with the engagement becoming active. Rationale: assertions enter Memory exactly when the engagement becomes real, from the conversation the Operator actually reviewed; no pre-engagement assertion home is needed (which simplifies Decision C). The alternative — incremental per-turn writes before commit — was set aside because it requires an assertion home before the engagement exists, pulling toward the heavier S#### path, and risks writing facts the Operator later revises away during the same creation conversation.

Decision B — Extraction grain and provenance. SETTLED.

• Grain: one stated fact = one assertion (mirrors the remember intent's one-classified-fact-per-turn grain).
• Provenance: each assertion records source_mode = creation_conversation plus the originating conversation turn id, so the assertion is traceable to the exact Operator statement.
• Corrections within the conversation: handled by revise_assertion (new held version + wasRevisionOf), not silent overwrite. If the Operator says "actually it's the east windowsill, not west" during creation, the west assertion is revised, not erased — trajectory preserved, per seed v0.9. This is a structural contract the pathway must honor, not a UI nicety.

Decision C — Seed-creation-conversation scope. SETTLED: Option 2 (dedicated surface). The creation conversation is a pre-engagement surface, not an S#### engagement. Concretely:

• Re-home the seed onto the engagement at commit (resolves the seed-scope bug, §2.2).
• Re-parent the engagement_id IS NULL creation-conversation turns onto the engagement at commit (Step 0 confirmed these turns currently live at NULL and are never re-parented — this is exactly the spec §13 "Engagement creation conversation orphaning" gap).
• Record the S####-recursive-engagement path ("Seed creation as recursive engagement," spec §13) as the deferred direction — not built now.

Rationale: Decision A (write at commit) means the conversation only needs to be readable at commit, not to host live assertions beforehand. The lighter surface is sufficient and avoids introducing a second engagement per creation plus a promotion/migration step. The S#### path remains on record as the considered-and-deferred alternative.

4. Verification discipline (carried forward from the walk)

This phase inherits the walk's methodology: verify every claimed success against the engine database — never trust the surface. Every fault the walk found reported success at the UI and passed the test suite; only reading the engine caught them.

• A green test suite does not confirm the pathway works. Test fixtures may not mirror production session behavior (the Phase 59 redundant-transaction-wrapper lesson).
• Acceptance condition, read at the engine: after creating and committing a test engagement, the engagement's Memory holds the expected committed assertions, scoped to that engagement, each carrying creation_conversation provenance + turn id; a mid-conversation correction appears as a revise_assertion chain (prior version reachable), not an overwrite; and the seed is re-homed onto the engagement, not on E0001.
• Downstream proof: with assertions present, Manifestation → Shaping → Render becomes runnable and the render the walk was heading toward is finally reachable. Reaching a render — verified by reading what the engine committed — is the phase's success signal.

5. State this phase builds on (verified at Step 0)

• Engine main = 813f13f, tag conversational-convergence-and-clean-commit. Confirmed.
• Full suite (pristine DB): 2770 passed, 33 skipped, 3 known pre-existing failures, zero new.
• E0060 — surviving clean Fenwick engagement: active, divergent, seed 6db3f37c (physically on E0001), zero assertions. Live test bed for the pathway.
• Commons E0001 (= ADMINISTRATIVE_ENGAGEMENT_ID, "Administrative") holds E0060's seed plus orphaned candidate seeds — both resolve when seed-scope is fixed.
• Highest current-status manifest = v0.48 (2026-05-31). Current seed = v0.9 (v0.8 archived).
• revise_assertion (not supersede) is the corrections mechanism; add_assertion (held) → commit_assertion is the write/commit ceremony.

6. Items to reconcile before the change request

1. Orphan-seed count: 7 vs 6. Step 0's DB read found 7 unreferenced seed lineages on E0001; the walk handoff and the cleanup provenance record (operations/loomworks-environment-cleanup-2026-06-01-orphan-engagements-v0_1.md, 77074f1) cited 6. Reconcile which is correct (likely 6 candidates + E0061's seed = 7) so the seed-scope fix targets the right set. Action: a one-line confirm against the cleanup record at change-request drafting.
2. Canonical-source items — now confirmed at Step 0: spec §02/§03 wording ✓ (creation conversation named verbatim as a pathway), seed v0.9 current with load-bearing commitments unchanged ✓, manifest v0.48 ✓, engine main 813f13f ✓. The only open canonical item is the §16→§13 citation, corrected in this v0.2.

7. Next step

Change-request drafting handoff. Step 0 has settled the mechanism, the timing, the grain, the provenance, the corrections contract, and the scope question — the change request now specifies the build:

• Adapt the remember / add_assertion / commit_assertion path to run on the creation conversation at commit, lifting the engagement_id IS NULL rejection by re-parenting turns at commit.
• Re-home the seed onto the engagement at commit.
• Write one held assertion per stated fact, provenance creation_conversation + turn id, corrections via revise_assertion.
• Re-parent NULL creation-conversation turns onto the engagement.
• Acceptance verified at the engine DB per §4, with a render reached as the success signal.

The change request is drafted in a fresh chat from a drafting handoff, per the phase methodology sequence.

Loomworks scoping note — creation-conversation → Memory-assertion pathway — v0.2 — 2026-06-01