one-verb-takes-a-single-intent-from-ready-to-delivered-witho

Frontmatter

.abcd/development/specs/open/spc-2609202134338445-one-verb-takes-a-single-intent-from.md
open on GitHub ↗ · commit history ↗

References1

• itd-2609201916151817One verb takes a READY intent to delivered, and refuses while a decision is openimplements

mentions41

• adr-2610222222326104abcd drives agents with no host session only on the person's own invocation, on the person's own account behind a wall, and hands back what it cannot finish
• adr-2610310235000654An unattended plan stands in for the sign-off only on a recorded, reviewed, unchanged draft
• dcn-26092600000000072026-09-26 — The build loop's worktree store is keyed on the FULL root sha: a lane lives at `~/.abcd/worktrees/<root-sha>/<run-id>-<lane-id>` with the 40-hex root commit, the form the history, transcript and voyage stores use and the one the store's draft (itd-2609091014076309) specifies. The lanes of autonomous run A made by hand under the abbreviated key (`~/.abcd/worktrees/488a0aa9/<name>/`) are the pre-verb convention, not a second form of the store: the loop never reads or adopts a lane under that key, and those worktrees are retired with `git worktree remove` like any other (implementer of fix round fix2-loop2, autonomous run A, on item 4 of the loop2 review; spc-2609202134338445 piece 6).
• dcn-26102823362769632026-10-28 — spc-2609202134338445 gains a file-level footprint for step 11 (--auto-plan), and step 3's no-host part becomes a new step 12 needing 3 and 11, as iss-2610230935429241's first remedy says, with step 3 marked landed at 45cdd1af7 for the runner-driven part it has delivered (facilitator-on-delegation). Grounds: the build refused the spec for having no footprint; criterion 9 (a configured runner starts the lane and the run record names it) is met by 6ce51f237 and its surface wiring 45cdd1af7; the no-host drive stays inside the intent, since decision 5 says the product thinker confirmed that reversal "for the opt-in path only", so narrowing it is theirs to rule and no agent decision may drop it; it is recorded in adr-2610222222326104, which AGENTS.md keeps unbuilt until itd-2610222215485265 ships, so step 12 waits on that intent with no marker yet (iss-2609260932372448 holds the marker's ruling); until it ships, a run ends when step 11 lands, the person releasing the reservation with abcd build --release, since the loop opens step 12's lane at once and an intent lane's hand-back does not release it. The footprint names step 11's files only, step 12's joining when it can start, and names files rather than the whole cli package because other builds hold that package's other files (iss-2610150512342464).
• dcn-26103102471238692026-10-31 — spc-2609202134338445 step 11: both --auto-plan plan reviews are started as the ruthless-reviewer agent, one brief per lens (design and feasibility, record discipline), its SHIP or FIX FIRST verdict parsed by the loop (implementer of build run-2610310228179894 lane-1, settling what the brief left open). Grounds: the adversarial-review principle names the pair by lens, not by agent; agents/ holds no record-discipline reviewer, and the security-reviewer's lens is a trust boundary, which a draft record is not; reusing the ruthless reviewer keeps the runner routing, tier routing and verdict vocabulary the loop already has for that role, and a new agent definition is a change of its own
• dcn-26103102471257552026-10-31 — spc-2609202134338445 step 11: adr-2610310235000654's criteria provenance is read as the draft carrying at least one acceptance criterion and an origin and production_mode inside the closed provenance vocabulary, and its grounds part as the most recent ground a person wrote being pursued (implementer of run-2610310228179894 lane-1). Grounds: these are the record's only machine-readable statements of where its text came from and why it is pursued; a deferred or declined conjecture is not one to plan unattended; a scope condition with no identity marker passes the claim-sections row because plan is the verb that stamps it, judged on an in-memory stamp with the probe minter so the row says exactly what plan will leave
• dcn-26103102471305802026-10-31 — spc-2609202134338445 step 11: an --auto-plan run plans in the checkout the run lives in, as a person's abcd intent plan does, and ends complete at the plan, releasing its reservation (the draft and its planned path) when its lane is done or handed back; a plan review that does not pass hands the lane back rather than opening a fix round; on an intent already planned the flag is a no-op and the run builds it; on an issue it is refused (implementer of run-2610310228179894 lane-1). Grounds: a planned intent's spec is a stub with no steps, so the build cannot continue without a spec author the spec does not name; applying a review finding would rewrite the person's record, the judgement the sign-off stands for; the plan step keeps the record writers' shared-checkout refusal at implement step
• dcn-26103104565631032026-10-31 — spc-2609202134338445 step 11, fix round 1: intent plan takes PlanOptions.ExpectDigest and compares it with the draft bytes it reads under the intent store's lock, refusing with ErrDraftChanged before anything moves or is minted. The auto-plan's plan passes the digest its reviews read, and a refusal hands the lane back. Grounds: the loop's own digest check runs before Plan takes the lock, so an edit landing between the two reads would be planned unjudged; comparing on the bytes every write is made from closes that window, and an empty value leaves every other caller unchanged.
• dcn-26103104565654512026-10-31 — spc-2609202134338445 step 11, fix round 1: the auto-plan's plan stage takes two steps. The first re-checks the substitute and marks the lane (plan_started); the second re-checks it and runs the plan. A record found in planned/ counts as this run's plan only once the mark is set, and is otherwise handed back as another act's, citing no verdict. Grounds: a second step killed after the plan and before its state write must still be recorded, and a plan made by hand at the plan stage must not be credited to reviews that judged the draft. Limit: a hand plan made between the two steps is credited too; telling it apart from a killed step would need the plan to take a spec id the loop chose beforehand, which intent plan does not offer.
• dcn-26103104565722172026-10-31 — spc-2609202134338445 step 11, fix round 1: the shared-main-checkout refusal for an auto-plan plan is passed into the loop as Options.PlanGuard and called under the run's lock immediately before intent plan, replacing the front door's unlocked pre-read of the state (PlanStageNext, removed). Grounds: judged outside the lock, two concurrent steps could let the plan run unguarded; the core stays transport-agnostic, since the guard is a function the CLI supplies.
• dcn-26103104565743342026-10-31 — spc-2609202134338445 step 11, fix round 1: an auto-plan run's reviews always run on the host's agents. Drive dispatches no runner for them and records no fallback, a --route on such a step is refused before anything is written, and DriveReview sends nothing. Grounds: the lane has no worktree to confine a Bash-granted runner to, and pointing one at the shared checkout with no base would run it unconfined; a reviewer route renders a request from a validation round and a diff, which the lane has none of.
• dcn-26103104565795632026-10-31 — spc-2609202134338445 step 11, fix round 1: the two plan reviews run one after the other, the second handed out only once the first's verdict is recorded, rather than stating the overlap as a limit in the ADR. Grounds: sequencing costs only the wall time of one review and removes the case where two reviewers are out together and one could hand in the other's return; the build's validators keep their parallel rounds, since each reviews a diff on its own lane.
• dcn-26103104565838312026-10-31 — spc-2609202134338445 step 11, fix round 1: the auto-plan start gains a plannable row (kebab-case slug, no spec_id already set, planned form under the size cap) rather than handing the lane back on any intent plan refusal. Grounds: a Plan error can be transient (a lock, an I/O fault), and a permanent hand-back on it would end a run that the next step could finish; a malformed target_release is not a refusal when no target is passed, so it needs no row.
• dcn-26103104565840562026-10-31 — spc-2609202134338445 step 11, fix round 1: the auto-plan start records a digest of the checkout (HEAD plus the tree its working tree stages to in a scratch index, the local tier removed), and a checkout that changed is handed back after the reviews and before the plan. Grounds: git status --porcelain names paths only, so a second edit to an already modified file would go unseen; a scratch index stages content as the person's git does without writing the checkout's own index. The row re-check runs before the checkout check, so a change a row names is reported by its row.
• dcn-26103110344427722026-10-31 — spc-2609202134338445 step 11, fix round 2: the auto-plan's checkout digest folds in the checkout's index, as the tree write-tree makes of a copy of it in the digest's scratch directory; a checkout with no index folds in a fixed marker, and an index git cannot write as a tree (an unmerged path) folds in its bytes. Grounds: a change staged while the working tree matches HEAD left HEAD and the working-tree digest unchanged, yet the person's next commit would carry it; write-tree caches its trees in the index file it reads, so it runs on a copy and the checkout's own index is never written. The digest still leaves out ignored files and the git directory, and leaves out the local tier by design, since the run's state and the reviewers' returns are written there.
• dcn-26103110344561522026-10-31 — spc-2609202134338445 step 11, fix round 2: a record the auto-plan's plan stage finds already in planned/ is never counted as the run's plan; the lane is handed back citing no verdict and the planned record is left as it is. This replaces the crediting of a plan found after the lane was marked as planning, and the limit dcn-2610310456565451 recorded with it. Grounds: a second step stopped after intent plan and before its state write leaves the same record another act's plan would, and the run cannot tell them apart; handing both back costs a run that ends handed back after a stopped step, which the person resolves by reading the plan, while crediting both would cite reviews for a plan they did not judge. The two plan steps stay: the mark says, in the hand-back, whether the run might have made the plan, and the stored-state check still requires it for a recorded plan.
• dcn-26103110344566612026-10-31 — spc-2609202134338445 step 11, fix round 2: no ignore rule is added for .abcd/work/.decisions.lock. Grounds: no code at this tree creates it; it was the lock of the single decision log, and its ignore line went with the log in v0.15.0, while abcd decide now flocks the decisions folder and leaves no file. A copy left by an older release is a static untracked file, the same in the start's checkout digest and every later one, so it hands nothing back; only an older release writing it during the reviews would, and every record writer's write changes the checkout anyway. An ignore rule for a file no current code writes would be configuration for nothing.
• dcn-26103113103343542026-10-31 — spc-2609202134338445 step 11, fix round 3: the auto-plan's checkout digest folds in, for the checkout's index, the SHA-256 of the copy's entries as git ls-files -z --stage -t -v lists them, next to the tree write-tree makes of the copy, and both run on the copy with core.splitIndex off. Grounds: write-tree leaves intent-to-add entries out of the tree and records no entry flags, so an intent-to-add entry or a skip-worktree flag changed the person's index with HEAD, the tree and the working tree unchanged; the listing carries each entry's mode, object, stage, path and flag tags but no cached file stats, so a stat refresh still changes nothing; -z keeps every path unambiguous. With core.splitIndex on, git writes a new shared index file into the git directory when it writes a copy, so every scratch index the shared helper runs on is written whole, inside the scratch directory.
• dcn-26103113103370462026-10-31 — spc-2609202134338445 step 11, fix round 3: the auto-plan's checkout digest copies the checkout's index only when the index path is a regular file, opened without following a link or waiting on a pipe, and at most 1 GiB; otherwise it folds in a value unique to the call, so the digest never matches again and the lane is handed back. Grounds: a link to an endless device or a named pipe at the index path would fill the scratch volume or hold the step; 1 GiB is well past the index of the largest checkouts in use, which run to hundreds of megabytes; handing the lane back is the outcome that vouches for nothing it did not read.
• iss-2609200830076665A held draft has no frontmatter state, so nothing mechanical stops a lane from planning it. A hold on an intent draft is prose (a Review or Open Questions section saying it is held and why); the intent frontmatter the loader reads carries no hold field, and abcd intent plan checks the draft's sections and the bucket, never a hold. The surface page makes plan a human sign-off act that is never run unattended, which is the convention that holds today, and a sub-agent lane that follows its own brief rather than the page has nothing in its way. Relayed from the Gropius session gropiusllm-2b on 2026-09-20, which ran five record-only lanes on held drafts with a written prohibition on planning as the only guard. Wanted: a held: <reason> frontmatter key on a draft, written by a verb and refused as free text, with plan refusing a held draft and naming the reason, and the record dispatcher (abcd <itd-N>) reporting the hold as the next move. Sibling of iss-2609170726457256 (no verb stamps judged fields on a draft): this is the state field, that one the judgement fields.
• iss-2609200830169721A managed repository is running the whole intent lifecycle through one sub-agent per record, and asks whether the pattern should become an abcd recipe. The shape, reported by the Gropius session gropiusllm-2b on 2026-09-20: a main session interviews the product thinker one decision at a time, reading the reviewer's recorded options off the draft rather than re-deriving them, records each answer as it is given, then fans out one Opus 5 sub-agent per intent or issue, each in its own worktree, which fills the draft from the answers, runs abcd intent plan, writes the spec, implements test-first, runs the security and ruthless reviewers as its own sub-agents, closes the spec in the landing pull request and arms auto-merge; record-only lanes edit exactly one record each and may not plan. The session named what abcd already gave it (quoted-text filing, capture provenance flags, intent ready --json as the gate every lane runs, the Review and Open Questions convention on a held draft) and what it lacked (recorded separately: the answer write path, the hold state, the append-lock on the decision log, the integration-branch landing, the lane worktree location). Whether abcd documents this as a recipe (a plugin page, a runbook in the brief, or a scaffolded lane brief) is the product thinker's to decide; recorded here so the decision has a record to rest on. Note that abcd's own record already plans the worktree half (itd-148) and asks the same session-per-lane question from the coordination side (itd-2609150819440345).
• iss-2609202046145653history capture has no current-session mode, so a run captures its own transcripts by listing files by hand. At v0.9.0 the verb takes one transcript path, and bare abcd history capture with no file answers "--session <id> is required when reading from stdin"; nothing discovers the session that is running or the sub-agent transcripts it spawned. The Dessau pilot (session gropiusllm-64, 2026-09-20) captured its session and seven sub-agent transcripts with eight invocations after listing ~/.claude/projects/<escaped-cwd>/<session>/subagents/agent-*.jsonl by hand, which is exactly the path knowledge the store already has (list --session reaches a session and every sub-agent it spawned on the read side). Wanted: a write-side twin of that read, history capture --session <id> --all (the main thread and every sub-agent), with the current session as the default when the harness exposes its id, so a loop captures its own run in one call. Evidence for the implement verb (itd-2609201916151817), which would call it at the end of every lane.
• iss-2609211105021406What abcd implement would have to carry to launch the pilot run without its prompt, from having run it: (1) the run file's part 1 as data: the design decisions, one per lane, that the run is not allowed to reopen, and a stop that names the decision it lacks; (2) the lane table: record ids, the files each touches, the sibling lanes touching the same files, the base sha, and the worktree path under the machine-scoped store; (3) the roles and models per role, with a fresh agent per fix round and a reviewer that never implemented; (4) the pace: window length, the pause as idle wake-ups, the agent ceiling with reviewers counted, and the tally fields written per session (lanes opened, finished, PRs, ceiling-wait minutes, agent-minutes, tokens); (5) the gate ladder per lane: preflight and fmt-check under the HOME alias where the username collides, the issue-resolution gate on the PR form, the push, the PR body re-read and lint outbound, auto-merge with the queue's method, and the rule that an armed PR is never pushed to; (6) the pre-authorised remedies, today the window recalibration, as named recipes the lane may run once; (7) the stop conditions as a list the orchestrator checks after every report; (8) the handover shape, NEXT.md's pilot section, so a crashed session is resumed from it (this run's orchestrator died once and was resumed from NEXT.md alone, the scratchpad and the run file both lost). Evidence from the sibling pilot on the same day, Dessau pilot 2 (its account is at that repository's for_abcd/pilot-2026-09-21-2-experiment.md): the outer loop ran as a script end to end in 82 minutes with zero stops for the work; every step that needed a hand was record-writing (Departures at close, captures for audit concerns, reviewers missing from the session ledger), and the pause never fired because the run fit one window, so itd-2609201925079472's pacing is untested past the first window. Implementer context peaked at 170k there against 349k in the first pilot.
• iss-2609240227236354itd-6 passes its readiness gate (intent ready itd-6: READY, all seven checks ok) but cannot be built from today's tree: its spec spc-2609211950427074 stands on four things that do not exist. (1) The build loop's validator stage the adapter implements, itd-2609201916151817 (planned, spec spc-2609202134338445 open; there is no build verb). (2) The layered oracle.review resolver the model-tier and pacing intents share, itd-2609170822093401 and itd-2609201925079472 (both planned, specs spc-2609180535002478 and spc-2609202134341288 open). (3) The command-line runner the adapters chapter entry sits beside, itd-2609201916056194 (planned, spec spc-2609221533057881 open). (4) An MCP client, which the spec's Approach names as a new dependency subject to the new-dependency sign-off; go.mod has none. itd-6 declares builds_on [itd-2] only, so the gate has no edge to refuse on and READY reads as buildable to a run that picks it.
• iss-2609260932372448A spec step that waits on another intent has no marker, so the build loop opens a lane on it: spc-2609202134338445's step 3 (the process driver) waits on itd-2609201916056194, and `build` takes the first unlanded step and briefs a lane there, which can only report the dependency. A blocked:/after: marker would change the first-unlanded-step rule and the ready row's count, which is a product design point, not an implementer's; routed to the product thinker.
• iss-2610080546203039The implement loop titles a lane's pull request from its issue's title; when that title names another record id, RS004 refuses the PR because no Refs line declares it (PR #865 named iss-2609261536147903 from its issue's title; fixed by hand by editing the body).
• iss-2610110918418459The implement loop's landing never writes a spec step's '- landed:' line, so a spec the loop landed part of still reads those steps as unlanded: a later 'spec close --remainder' carries steps that already merged into the remainder, and a fresh 'abcd build' of the same spec opens a lane for them again. Found by the fidelity audit of itd-2609212103565953 (receipt rcp-2257cc3a38d9, criterion ac-3 MET_WITH_CONCERNS); spc-2609202134338445's Progress already says the landing does not mark a non-closing lane's step.
• iss-2610230935429241spc-2609202134338445 step 3 (the process driver) is unlanded and its remaining part waits on the ADR that step 11 (--auto-plan) mints, a later step. A needs line can name only earlier steps, so the build loop can open step 3 before step 11 has minted the ADR it waits on. Its other later dependency, step 7's receipt verifier, is already landed. Found while declaring the open specs' needs lines, 2026-10-23.
• iss-2610262037066238The brief index says spc references trace the predecessor's spec store and are not delivery claims; the build chapter cites a spec of this repository for what has landed.
• itd-6RepoPrompt over MCP is one opt-in reviewer route, beside the host's own agents
• itd-50The Audit Loop Drives An Intent To Acceptance — Or Calls For A Replan
• itd-58A Real Reviewer's SHIP Verdict Reaches The Session Gate Through A Channel The Worker Cannot Forge
• itd-82`abcd drain` fixes the issues that need no decision, and hands the rest back by kind
• itd-2609091014076309Session and agent worktrees live in a machine-scoped store that abcd lists and reclaims, never beside the user's own projects
• itd-2609091416295622A session sees the records its peers hold before it mints or fixes one
• itd-2609201916056194A role runs through the command-line harness the operator chose, and every fall back to the host is recorded
• itd-2610222215485265abcd drain --drive works through the ledger from a plain terminal
• spc-2609202134341288an-autonomous-implementation-run-paces-itself-by-default-and
• spc-2609211924346308loop-toward-acceptance
• spc-2609221533057881abcd-runs-a-delegated-agent-through-a-command-line-model-run
• spc-2609301811532881The worktree store: `abcd ahoy worktree add|list|prune`, one lane primitive, and a notes archive beside it