Version. 0.1
Date. 2026-08-25
Status. Program proposal for Operator ratification. It becomes the operative plan when the Operator rules the decision sheet in §7.
Author. Claude.ai (scoping role).
Read against. dunin7-build-list-v0_95 (2026-08-16), current-status-manifest-v0_78, loomworks-candidate-seed-v0_14, memory of the 2026-08-23 agent-governance session, and this session's ingestion scoping note v0.3. The build list has moved past v0.95 — at least CR-2026-231 through 233 shipped on 2026-08-23 and the list is maintained by Claude Code as a closing duty — so every ranking here is provisional until Wave 0 refreshes it from the record.
Loomworks is close. The four rooms exist, the Companion reads all of them and writes to two, uploads work, creation works end to end, truthfulness has been fought for and mostly won, and the engine and surface both check themselves on every push. What stands between today and comprehensive testing is not one big piece. It is a thread of small pieces along the one path the finish line names, plus a handful of decisions that have been waiting for a sitting, plus the ingestion upgrade this session scoped.
This program turns that into a run Claude Code executes with as little of you as the charter allows. You are needed for four things and nothing else: one paste to start the inventory; one sitting to rule a decision sheet; one restart of the serving engine per wave; and the walks that need your passkey. Everything else — Step 0, drafting, building, testing, merging, updating the build list, appending the status brief — runs inside Claude Code under the charter you ratified on 2026-07-30.
The program has five waves. Wave 0 is the inventory and your ruling sitting. Waves 1–3 build the finish-line thread, the ingestion upgrade, and the boundary work in that order. Wave 4 makes the product testable by you: a walk script, fixtures, and the mobile and collector fixes that would otherwise be rediscovered as mysteries. Then comprehensive testing begins, and the same machinery absorbs what testing finds.
Stated from the documents named above, with each fact's source.
Built and running. The four rooms (B-1–B-7). Provenance walk (B-9). Outside contributors (B-10). Truthful answers with sources (B-11, B-61, B-67). Record search closed as already satisfied (B-12). Spreadsheets and decks ingest (B-14). Companion reads all four rooms (B-8 slice one) and produces Shaping and Rendering drafts per-action through approval cards (B-8 slice two part one, CR-2026-197). Engagement creation through conversation works to commit — E0128 committed after the arc that fixed the commit ceremony's false cause (B-95), the converse catches (B-96), the findings panel (B-98 faces 1+3, B-99), history poisoning (B-101). Personal capture no longer claims saves it did not make (B-107, B-81). CI is green on both repositories and every gate was broken on purpose before it was trusted (B-48, B-49, B-50, B-83, B-84). The seed is at v0.14, committed, with the authorization seat named by placement.
Landed 2026-08-23, not yet in the v0.95 list I hold. Agent lifecycle events (CR-2026-231), the unsessioned-agent baseline (CR-2026-232), FORAY Stage 2 forward-gap closure across 17 sites (CR-2026-233). Design rulings: agent_identity replaces the stele collision; the two-records standing note; three decisions on per-binding identity with the third scoped but pending the roster-exception ruling. (Source: memory; verify in Wave 0.)
Scoped this session. Artifact ingestion: description assertion, tag repository, folder pre-flight, scale-guard retirement — scoping-notes/loomworks-artifact-ingestion-description-and-tags-scoping-note-v0_3, ten decisions D1–D10 open. The buffer engagement ruled (closes quick-capture Q5).
Open and on the finish-line path. In the v0.95 list:
folder_manifest=None). Scope, then build — and it is a prerequisite of the ingestion pre-flight.Open and on the boundary path. CR-2026-098 (engine API boundary closure; A3 halts for you to pick a privilege model). Stele contract phase CR-B (host-column drop, FK re-target, trigger retirement, PersonRow token-level rename). B-88 (classifier-routed grant branches run extraction with no revoke check). B-90 (null discriminator that lies). Roster-exception ruling gating per-binding session minting, Decision 3, and SR-1. FORAY D10–D14.
Open and on the testing-readiness path. B-71, B-72, B-73 (a test directory never collected; nothing makes a runner say what it collected; a production file named like a test). B-89 (a perf test that re-reddens the gate at random). B-91, B-92 (message-order ruling unapplied on mobile; composer jump). B-56 (dev sign-in on the live perimeter). B-64 (the accepted-types list is wrong and nothing reads it).
Open and deliberately outside this program. B-17 (portfolio filter re-scope), B-69 (seed change after running — seed-level), B-63 (model-authored marker — a new commitment), B-39/B-40/B-62 (scoping), B-31 (investigation), B-45/B-46 (decisions that block nothing), B-65 (the foundation document's four pointers — will eventually want you), the Part 3 Operator track (marketing site, Stele packaging, security story, investor-visible FORAY), and everything in Part 4 parked.
The build list's one sentence: a firm's own document becomes a working engagement, information flows in, the summary view appears, a finished report comes out, a question gets a truthful answer with its sources shown, and an outsider can contribute without seeing anything else.
The program's membership rule follows from it. An item is in the program if and only if it touches one of those six clauses on the production perimeter, or blocks your ability to test them. Everything else waits. This rule is what lets Claude Code re-rank in Wave 0 without asking you which items matter.
Testing-readiness adds three things the sentence does not name: a written walk you can follow without re-deriving it each time; fixtures that survive a walk (a test account, a test engagement, a test contributor); and a serving perimeter that carries every merge this program produces.
The standing authorization charter (ratified 2026-07-30) is the mechanism. Under it, a session runs Step 0, builds, tests, merges, updates the build list and appends the status brief without a halt before each push — halt-on-anomaly, not halt-before-push (R-1). Decisions that would once have interrupted you go to the decision queue in the status brief (§5, §7). Your acts are the ones the charter reserves: seed commits (F-3), charter amendments (F-4), the launchd restart that deploys a merged engine to the serving perimeter, passkey-dependent walks, and rulings on the queue.
This program adds nothing to the charter. It packages what the charter permits into a sequence with a membership rule, and it batches your reserved acts so they happen a few times rather than continuously.
The two-role discipline puts scoping and CR drafting in Claude.ai and execution in Claude Code, with you carrying documents between them. That carrying is most of your involvement today. For items that already have a scoping note or a settled finding — which is nearly every item in §1 — the drafting is mechanical against material that is already in the record Claude Code can read. P-1 (§7) asks whether Claude Code may draft the CR in-session for such items, with the two-role discipline retained for anything that needs scoping. If you rule no, the program still runs; each CR simply costs you two pastes.
Each wave is one continuous Claude Code program under the kickoff block in §8, ending in a deploy and, where named, a walk. Order inside a wave is provisional until Wave 0.
Wave 0 — Inventory and rulings. You: one paste, one sitting.
Claude Code, read-only: fetch the current build list and status brief; enumerate every open item and every open decision across the list, the queue, CR-2026-098, the Stele notes, the FORAY notes, and the ingestion scoping note; apply the membership rule; produce loomworks-completion-inventory-v0_1 ranked by wave with dependencies named; drop it in Downloads. Claude.ai produces the decision sheet — every open decision, one line each, with a recommended default. You rule the sheet in one sitting. Anything you do not rule takes the default and is recorded as defaulted, not ruled.
Wave 1 — The finish-line thread. You: one restart, one walk. B-79 (ruled in Wave 0; the build is the hook registration plus the confirm naming its outputs). B-78. B-13 verify-and-close. B-52, B-37. B-100, B-94, B-97. B-108, B-103. Deploy. Walk: seed to render on a fresh engagement, every clause of the finish line once.
Wave 2 — Ingestion. You: one restart, one walk. B-74 first (the folder structure must persist before a pre-flight can count it). Then CR-A description assertion and scale-guard retirement; CR-B tag repository; CR-C folder pre-flight — per the scoping note v0.3 and the D1–D10 rulings. B-64 rides along (the accepted-types list). Deploy. Walk: one folder upload through the pre-flight; one description corrected by hand; one buffer review against a new seed.
Wave 3 — Boundaries. You: one restart. CR-2026-098 with the A3 model from the sheet. Stele CR-B. B-88, B-90. If the roster-exception ruling landed in Wave 0: per-binding session minting and Decision 3; otherwise both stay queued and the wave is shorter. FORAY D10–D14 only if ruled. Deploy.
Wave 4 — Testing readiness. You: one restart, then testing begins.
B-71, B-72, B-73, B-89. B-91, B-92. B-56. The walk script: loomworks-comprehensive-test-walk-v0_1, written by Claude Code from the finish-line sentence and the four rooms, with expected results per step. Fixtures: a test account, a test engagement, a test contributor, created on the production perimeter under the walk-audit pattern and recorded. Deploy.
After Wave 4 — Comprehensive testing. You walk. Findings file as B-items with the standard filing. The kickoff block in §8 keeps running against the list, so a finding filed on Monday can be built by Tuesday without a new plan.
| When | What | Time | |---|---|---| | Now | Paste the Wave 0 block into Claude Code | 1 minute | | After Wave 0 inventory | Read the decision sheet; rule it | One sitting | | End of each wave (4×) | Restart the serving engine (launchd) | 2 minutes each | | End of Waves 1, 2 | Walk with your passkey | 20–30 minutes each | | After Wave 4 | Comprehensive testing | As long as you like |
Nothing else. If a session needs you outside this table, it has hit an anomaly, and the halt report says what and why.
Wave 0 will produce the complete sheet from the record. The decisions already visible from here, with defaults:
| Ref | Decision | Default |
|---|---|---|
| P-1 | Claude Code drafts CRs in-session for already-scoped items | Yes; two-role retained for unscoped items |
| P-2 | Deploy cadence | Once per wave, batched |
| P-3 | Model for the program | Fable 5; Sonnet for mechanical sub-tasks at CC's discretion |
| B-79 | What "confirm" means | Confirm names its outputs before the press and enqueues exactly those |
| CR-098 A3 | Privilege model for /admin/* credit routes | Operator-only, named at the route |
| B-45 | Wrap five stand-up commands or leave visible | Leave; out of program |
| B-64 | Accepted-types list | Generate from the detection registry; nothing hand-maintained |
| D1–D10 | Ingestion (scoping note v0.3 §6) | As recommended there |
| Roster exception | The precondition on agent work | Ruled or explicitly deferred; no default — Operator's alone |
| FORAY D10–D14 | Anchor form, state vocabulary, unprovable path, F4 catalog, foreign asset naming | Deferred to after testing unless ruled |
| Q-7 | Conversational Shape confirm | Stays deferred until B-79 has shipped and been walked |
Wave 0 adds whatever the current list and queue carry beyond these.
This is the standing block a Claude Code session runs at the start of every program session after Wave 0. It is short because the charter and the build list carry the rules; the block only says which door to enter through.
Loomworks completion program — session kickoff.
Read, in order: the standing authorization charter; the highest-numbered dunin7-build-list; current-status/dunin7-status-brief; loomworks-completion-inventory (highest version); the decision sheet as ruled.
Take the highest-ranked item in the current wave whose dependencies are closed and whose decisions are ruled or defaulted.
For that item: Step 0 read against live code; draft the CR in-repo if the item is already scoped (P-1) or halt with a scoping request if not; build on a branch checked before the first commit; observe each new test failing before the fix; run the full suites; merge on green; tag; update the build list as a new sibling version; append the status brief; drop any document Claude.ai will need in /Users/dunin7/Downloads/.
Continue to the next item. Halt on anomaly only, per R-1. Halt at wave end with a deploy request naming the merged SHAs and the walk the Operator owes.
Never deploy. Never commit a seed. Never amend the charter.
=== TASK COMPLETE ===
It does not make Loomworks finished. It makes the finish-line sentence true on the production perimeter and puts you in a position to test it comprehensively. What testing finds is the next list. It does not touch the Operator track (marketing, packaging, security story, investor FORAY). It does not settle seed-level questions (B-69, B-63, the provenance-threads candidate, the Memory=recall reframe); those are yours and there is no default that respects that.
This program was asked for directly ("a build plan that is as autonomous as you can create; keep my involvement as minimal as possible"). Two things shaped it. First, the charter already exists, so the program is a packaging, not a new regime. Second, the largest remaining source of Operator involvement is not decisions — it is carrying documents between two Claude roles — which is why P-1 is the one practice change the program asks for. The alternative considered and set aside: a single long CR covering everything, which would have concentrated risk at one gate and made halt-on-anomaly meaningless.
DUNIN7 — Done In Seven LLC — Miami, Florida Loomworks — Completion program — v0.1 — 2026-08-25