CR-2026-127 — Addressable Held-Tray Grammar + Committed-Revision — v0_1

Version. 0.1 Date. 2026-06-29 Repo. loomworks-engine (+ OL loomworks for the conversation tray UI) Branch base. main @ d32c99b (rebase onto post-CR-2026-120 head before starting) Author. Claude.ai. Executor. Claude Code (DUNIN7-M4). Operator. Marvin Percival. Room. Memory — Pipeline-walk Finding 2 of 3. Depends on. CR-2026-120 (actor-kind read contract) merged + verified — held items must render before a tray grammar over them is usable.

Plain-language summary

Today you can speak a note and it becomes a held draft, but you cannot reliably save, change, or remove it by talking normally. The only working save phrase is "commit held N" — which no one would think to say — and there is no way at all to list your held items in conversation, change one, or discard one by reference. "Save" and "yes" route to a queue that never sees your draft, so nothing commits and the Companion sometimes says "Logged" when nothing was logged.

This CR builds one consistent grammar over an addressable held tray:

• "show held items" → your held drafts, each with a stable number.
• "commit 1" / "commit all" → save those to durable memory.
• "change 1 to June 27" → correct a held draft in place; or, if the number names an already-saved fact, supersede it (the original stays in the record).
• "discard 2" → turn a held draft away (recorded, not erased).

One grammar: verb + number. You name the target; the system acts on exactly that. No magic phrases, no guessing which draft you mean, no false success.

What already exists (reused, not rebuilt)

The grounding walk found three-quarters of this already in the substrate:

• display_number — the stable, short, per-engagement handle. Assigned at held-creation (not commit), preserved across revise/discard/commit/retract. E0060's held items are 1–5 now. This is the "stable IDs that don't renumber when one leaves" the Operator asked for — already built.
• commit N / commit all — fully wired, resolving by display_number, committing as the human. One of the four motions, working today. It is the reference implementation the other motions mirror.
• Data-layer revise_assertion and discard_assertion — both exist, both append-only/recorded (discard writes a discarded version + event, never hard-deletes; revise supersedes with wasRevisionOf, prior preserved). They lack only a by-number conversational route.
• The numbered held-list UI pattern — HeldCard (Memory room) and HeldNoteCard (Dashboard) already render "Held N" lists. The conversation tray copies this pattern; it is not designed from nothing.

Seed alignment

• Operator-authority — "the machine surfaces and signals; the Operator approves." The tray surfaces (show held, numbered); the Operator directs (commit/change/discard N). The addressed command is the approval — no separate "are you sure?" for commit/discard, because naming the verb and target is the approval. Aligned.
• Memory does not forget; a correction is a contribution; both preserved — change N on a committed fact supersedes (new version, prior stays in record, wasRevisionOf link). Discard is recorded, not erased. Aligned — the CR enforces these, does not bypass them.
• No false success — every motion's confirmation is composed from the engine's actual result, not scripted on intent. (Folds in Finding 3's principle for these specific motions.)
• No seed conflict.

In scope

Engine

1. Shared held-reference resolver. Generalize _route_commit_assertion's by_number map (router.py:456-463) into one helper: held-reference (number | "all") → assertion(s), keyed on display_number. All four motions call it. Single source of truth for number→assertion resolution.

1. Three net-new classifier intents + router handlers, each thin, each using the shared resolver and an existing data-layer function:

• show_held — list held assertions for the engagement with their display_numbers, returned as structured data (not prose) so the conversation surface can render an addressable tray. Add to IntentLabel + classifier prompt.
• discard_held ("discard N" / "drop N") — resolve N → assertion, call existing discard_assertion (append-only). Human-gated (companion cannot discard — CR-2026-120 closed that gate).
• change_assertion ("change N to X") — resolve N → assertion, then branch on state:
• held → call revise_assertion to edit the held draft in place. Frictionless (nothing durable changing).
• committed → supersede via revise_assertion (new version, wasRevisionOf set, prior preserved) with a confirm step: the Companion surfaces "this corrects a saved fact — 'X' becomes 'Y' — the original stays in the record. Apply?" and only proceeds on Operator yes. Consequential — durable memory changing.

1. Natural-language routing. The classifier must route natural save/commit phrasing — "save 1," "save that," "ok save it," "commit 1" — to the commit path, and a bare affirmative ("yes" / "ok") when a held tray is the active context to commit the addressed item(s). This closes the core burden: the grammar must work when the Operator talks normally, not only on exact phrases. The broken approve_draft→card-queue path is routed around, not repaired; mark it deprecated-by-this-change (do not delete in this CR).

1. Truthful confirmations. Each motion's reply is gated on the engine's confirmed result: "Saved 1" only if commit succeeded; "Updated 1" only if revise wrote; "Discarded 2" only if discard wrote; the committed-revision confirm only claims supersession after it lands. No "Logged" without a write.

OL (frontend)

1. In-conversation held tray. When show_held (or a held-context reply) returns structured held data, render the numbered tray inside the Companion conversation stream, copying the HeldCard/HeldNoteCard pattern. ConverseResponse must carry a structured held-list array (currently companion_message: string only — extend it). The "What's held for me?" chip routes here instead of to a prose bubble.

Out of scope (residue, recorded)

• Deleting/refactoring the deprecated approve_draft card queue — routed around here, removed in a later cleanup.
• The compositions.py:73 companion→contributor relabel (CR-2026-120 residue).
• Finding 3 broader false-success audit beyond these four motions — the truthful-confirmation principle is applied here to the tray motions; a system-wide pass is separate.

Step-0 inspect-first (mandatory)

Rebase onto the post-CR-2026-120 head first. Then CC reads and confirms at current HEAD, halting on any divergence:

• _route_commit_assertion / _parse_held_reference (router.py:298-340, 380, 456-468) — the resolver to generalize and the commit reference impl.
• revise_assertion (assertions.py:312) and discard_assertion (assertions.py:458) signatures + that both are append-only and human-gated.
• display_number assignment-at-add (assertions.py:124-163) and preservation across lifecycle — confirm E0060 held items still 1–5.
• IntentLabel enum + intent_classifier.md — confirm show_held/change/discard still absent, commit_assertion present with held_reference.
• ConverseResponse shape (OL lib/types.ts:142-160) and the HeldCard/HeldNoteCard components to copy.
• Confirm the committed-revision confirm-step has a place to live (how the Companion currently does any two-turn confirm — reuse that mechanism, don't invent one).

Report the chosen home for the shared resolver and the confirm-step mechanism before editing.

Execution steps (halt-before-push; suite green at each)

Stage by explicit path. Per-step commits. Push is separately authorized — do not push until the Operator says so.

Step 1 — Shared resolver. Extract commit's by_number logic into one held-reference resolver. Repoint commit_assertion to use it (no behavior change — regression-locked by existing commit tests). Commit. Suite green.

Step 2 — show_held intent + structured response. Add show_held to IntentLabel + classifier; handler returns held assertions with display_number as structured data; extend ConverseResponse to carry the held-list array. Commit. Suite green.

Step 3 — discard_held intent. Add intent + handler → resolver → discard_assertion. Human-gated. Truthful confirmation. Commit. Suite green.

Step 4 — change_assertion intent, held branch. Add intent + handler → resolver → revise_assertion for held items, in place, frictionless. Commit. Suite green.

Step 5 — change_assertion, committed branch (supersession + confirm). Extend the handler: committed target → confirm-step → supersede on yes (prior preserved, wasRevisionOf set). Reuse the existing two-turn confirm mechanism. Commit. Suite green.

Step 6 — Natural-language routing. Classifier routes "save N"/"save that"/"ok save" → commit; bare affirmative in held-tray context → commit addressed item. Truthful confirmations across all motions. Mark approve_draft deprecated-by-this-change (comment, no deletion). Commit. Suite green.

Step 7 — OL conversation tray. Render the structured held list as a numbered tray in the Companion stream (copy HeldCard pattern); route the "What's held for me?" chip here. Frontend tests. Commit. Suite green.

Step 8 — Tests. Engine: each intent resolves by display_number; held-change edits in place; committed-change supersedes-with-confirm and preserves prior; discard is recorded; natural save phrasing routes to commit; confirmations gated on real writes (no false success). Commit. Suite green.

HALT. Report terminal SHA + suite count. Await push authorization.

Verification (runtime — both probes)

Restart dev after merge. Then:

E0089 (clean loop, the headline test):

1. Speak two notes ("Fenwick watered June 28", "Fenwick moved to balcony"). Say "show held items" → tray shows 1 and 2 with content.
2. "change 1 to June 27" → item 1 updates in place; item 2 untouched. (This is the Operator's exact three-line example — it must work.)
3. "commit 1" → item 1 saves; confirm Memory room shows it committed; confirm "Saved 1" only appeared because it actually committed.
4. "discard 2" → item 2 turned away; confirm it's recorded (Memory shows discarded, not vanished), not in the held tray.
5. "commit all" when multiple held → all save.

E0060 (committed-revision):

1. With a committed assertion present, "change N to X" on its number → Companion surfaces the supersession confirm ("original stays in the record — apply?"); on "yes" → new version commits, prior preserved and still visible as trajectory.
2. Confirm a bare "yes" with a tray in view commits the addressed item; confirm "save 1" (natural phrasing) reaches commit.

Pass condition: the three-line example works end to end on E0089; commit/discard/change-held are addressable and truthful; committed-revision supersedes-with-confirm and preserves the prior; natural save phrasing reaches commit. Only then does Room 1 advance to Finding 3.

Risk notes

• The committed-revision branch (Step 5) is the load-bearing one — it changes durable memory. The confirm-step and prior-preservation are non-negotiable; the supersession must use the existing revise_assertion append-only path (proven in the Room-1b walk), never an overwrite.
• Natural-language routing (Step 6) is where the burden is removed. If it under-fires, the grammar regresses to "magic phrases." Test natural phrasing explicitly.
• commit is regression-sensitive — Step 1 refactors its resolver; existing commit tests must stay green to prove no behavior change.
• Append-only is the seed's never-forget — discard and revise must never hard-delete; confirm in tests that prior versions/discarded drafts remain queryable.