The development lifecycle is a developer's bread and butter — the loop you actually run every day, not a once-in-a-while ritual. You sit down at a repo, turn a brief into a plan, work the plan task by task, have the work torn at adversarially, and ship it under a recoverability gate. For long-lived code, you then launch it to real users, deprecate what it replaces, and retire the dead interface. Each step is a short, isolated session with one job, and the next session picks up from durable artifacts on disk rather than a remembered conversation. This capability names those daily cycles, pins down where each begins and ends, and makes explicit how state survives between them — whether or not the agentm memory engine is mounted underneath. It is the base every other capability builds on.

The lifecycle, first to last:

Step	What it does
/setup (once)	First-time scaffold — writes the .harness/ state files and fills init.sh / AGENTS.md with real project commands.
/plan	Turns a brief into a plan of steps with per-step verification criteria, and opens the plan's tracker; writes no code; grounds against the governing design when one exists.
/work	Works the plan's steps autonomously in sequence (implement → gates → commit per step), keeping the tracker's State and Next current; stops only on a failed safety pre-check or a needed clarification.
/review	Runs the deterministic gates first, then an adversarial pass primed to assume bugs exist; reports a failing test or a file:line defect, never fixing.
/release	The pre-merge gate — plan done + gates green, wait for CI, then push / tag / ship under the recoverability gate; archives the completed plan.
/launch	The pre-launch readiness gate before first production exposure — observability, a tested rollback, a flag off-switch, a staged-rollout plan.
/deprecate	Marks an interface for removal — compulsory vs advisory, enumerate callers, migrate now or attach a notice + a published removal date.
/retire	The code-removal gate — the Beyoncé-rule audit (remove, run the suite, prove nothing breaks), then delete the proven-dead interface.

The one branch off this road is /bugfix — for defects it replaces /plan + /work with Report → Analyze → Fix → Verify (mandatory regression test, mandatory /review), then rejoins the /release path.

The daily loop and the feature's endpoints, first to retirement; /bugfix is the alternate track to plan + work; each step is a short isolated session, state carried on disk between them.

This is the loop itself: short, isolated sessions chained /plan → /work → /review → /release → /launch → /deprecate → /retire (after a one-time /setup), with /bugfix the alternate track to /plan + /work. Four properties hold across every cycle:

• Deterministic where it can be. Every cycle leans on helper scripts instead of re-deriving state in-prompt — resolve_plan.py (plan paths + mode), isolation_config.py (isolation mode), worktree_marker.py / finalize_unit.py (worktree lifecycle), worktree_shepherd.py (periodic orphan + stalled-PR reclamation, and detaching a linked worktree stranded on the integration branch), preflight_reconcile.py, and the check-all.sh gate battery. The agent supplies judgment; the scripts do the bookkeeping, so there are fewer places for drift to creep in.
• Gates before judgment. The deterministic gates (typecheck → lint → tests → build) run first and short-circuit on failure, before any LLM critique — cheap, truthful checks gate the expensive ones.
• Recoverable by default. A recoverable push / tag / release announces itself and proceeds; only a genuinely unrecoverable action stops for confirmation (the recoverability-gate doctrine, shared with developer-safety).
• Runnable one-off, in a loop, or as a goal. Each cycle is a stateless command driven by on-disk state, so it can run as a single session, looped over a set (e.g. break five designs into sub-plans in one pass), or handed a goal to pursue until done. These are the persona launch modes (see Personas); a looped or goal-driven run is just N isolated sessions sharing the same durable substrate.

Durable memory, through agentm. State lives on disk, never in the conversation — the next session reads the artifacts, not your context. agentm decides where each plan lives, and the plugin asks; with no agentm there is no plan.

• The repo's own .harness/. Tools and config that belong to the checkout: init.sh, verify.sh, project.json (the vault binding, isolation + integration config), the worktree-local active-plan marker, and, by github-projects' default, board-items.json (the board source of truth). It is gitignored. In a repo with no vault, agentm keeps that repo's plans here too: a singleton PLAN.md or flat PLAN-<slug>.md, each with progress and a tracker beside it, and features.json.
• The project's vault home. The plugin never hardcodes a path: it resolves through agentm's process seam. resolve_plan.py prints the plan, its progress log and its tracker; with no seam it exits 1, and the commands say development-lifecycle keeps its plans through agentm. In the vault, each piece of work is a task directory, <vault>/projects/<slug>/tasks/NNN-<verb-slug>/, holding plan.md, progress.md and tracker.md. Its name is a three-digit sequence number and a verb-first slug. The tracker is the plan's living head: its status, what is true now, the next steps, and the outcome at close. Only agentm's tracker.py writes it, and the commands reach it through plan_tracker.py. A larger body of work is an arc: a design with scope: arc in the project's designs/, which for agentm and crickets is the repo's wiki/designs/. The arc's parts live in designs/<design>/parts/, its place in the order of work in roadmap.md, and a generated index in arcs/<arc>.md. Each of an arc's tasks is an ordinary numbered task whose tracker names the design. features.json lives in the project's desk/, found through project_homes.py. The tracker is a plan's only status: a plan carries no **Status:** line. Reflection / recall memory lands in the vault.

So the per-workflow Artifacts lines below name paths relative to the plan's home: the task directory in a project that keeps tasks, or the repo-local .harness/<file> in a repo with no vault. Reflection / recall memory lands in the vault only; the board mirror is board-items.json (canonical; the GitHub Project is the human mirror); all .harness/ is gitignored, so state is never committed.

Session bootstrap (Claude-only). Two hooks on the development-lifecycle plugin automate session setup on Claude Code:

• harness-context-session-start (SessionStart) — surfaces .harness/PLAN.md + progress.md at session boot so the agent reads the plan before the operator's first message. No-op when no plan is active.
• compact-nudge-resume (UserPromptSubmit) — on every user prompt, injects a /clear-over-/compact nudge when context ≥ 60% full or > 400 assistant turns; silent below threshold or on a fresh session. Keeps the session context lean so the state-on-disk substrate can resume cleanly.

Both hooks are Claude-only; they do not fire on Antigravity (see Antigravity limitations).

The loop's sub-agent dispatch points — /plan's explorer, /review's adversarial + cross-model reviewers, the documenter, verification-clerk-style graders — today spawn on hardcoded agent-def frontmatter (the as-built phase-aware-model-routing: Opus for /work//bugfix, Sonnet elsewhere). This adds a routed-by-default layer on top, realizing the operator's efficiency protocol (proven manually in the Mythos readiness run) as capability rather than hand-discipline:

• Classify, then look up. Each dispatch point first resolves its own work-type via token-audit's classify_work_type classifier — a persona's already-declared tier, an ad-hoc role-name match, or an explicit UNCLASSIFIED-DEFAULT when neither applies — then consults token-audit's versioned routing table (the single home of current model ids) for that work-type's (tier, model, effort), via a new enhances: edge from token-audit + a agentm_bridge.py capability probe, and passes the resolved model per invocation. The Agent tool exposes no per-invocation effort, so the effort axis keeps binding statically via agent-def effort: frontmatter roster-wide, unchanged by this amendment. Graceful degradation to today's hardcoded behavior when the table or the capability is absent — the existing capability verb's pattern, unchanged.
• Mandatory fan-out announcement, unconditional. Before any sub-agent launch — capability present or absent — the dispatching agent prints one line per dispatch group: role · agent count · model (+ effort where bound) · tier source (table row / agent frontmatter / UNCLASSIFIED-DEFAULT / INHERITED). This is unconditional: it degrades to announcing frontmatter/inherited sources when the table isn't installed, so visibility never depends on the efficiency capability being present. The INHERITED source must explicitly cover built-in-agent inheritance alongside custom agent-defs: Explore inherits the session model starting at Claude Code 2.1.198, so once the installed CLI crosses that version the announcement has to name Explore's dispatches correctly instead of assuming the cheap-floor default still holds. The UNCLASSIFIED-DEFAULT source names the classifier's own miss case — a role the classifier couldn't match, running on the fixed safe default — so a classification gap is visible traffic, not silent success.
• Silent session-model inheritance is forbidden. Every dispatch sets its model explicitly, from the table, from frontmatter, or from the classifier's safe default. A dispatch that would otherwise fall back to inheriting the session's own model must announce it as a loud warning and pause for confirmation whenever the session model is frontier-tier (T3/T4). This is the direct fix for the Mythos incident — 112 sub-agents silently inheriting claude-fable-5 (token-audit's table names it explicitly as the recognized, unrouted, premium-priced model this exact failure defaults to), discovered only after the session limit was already exhausted.
• Staged per-task tier hints. A PLAN-<slug>.md task gains an optional per-task tier hint field, derived by the same classifier at staging time from the task's own work-type, so a staged plan carries its expected tier alongside its verification criteria without a second hand-authored judgment call.
• Session-start tier + advisor nudge. At session start, compare the live session's model against the active plan's tier hint (the classifier's staged output) and report a mismatch — nudge only, it never switches the session (the same advisory-only limit that holds wherever the frontmatter pin doesn't reach) — and state advisor availability (advisorModel, when configured), so the operator knows a stronger-model consult is one config line away without a model switch.
• Phase-close handoff packs. A phase-close briefing (the existing orchestration-briefing surface, e.g. at /release) auto-emits a model-labeled handoff pack for remaining cheap-routable work, via token-audit's /handoff command — carrying the same machine-readable tier/model label the /work escalation tripwire (model-effort-routing's Escalation section) writes its entries in, one format, two producers.

Explicit boundaries. The main session's own model stays a human act (/model, opusplan) — this is untouched by any of the above. The single-implementer invariant is untouched: /work's implementer never fans out (ADR 0023 / the concurrency model, below); routed dispatch only ever covers the read-only/review/docs helper agents already dispatched around it, never the implementer itself. Wiring is enhances: + agentm_bridge.py capability probe now; it migrates to opinion_request('efficient') when the Wave-B opinion registry lands, consistent with this design's own already-pending hardwired→requested migration (see ### Opinions it consumes, below). Hard prerequisite: the already-shipped R0.5 find_capability fallback fix (test_find_capability.py, since merged into agentm_bridge.py — CONS-2 task 2), which the probe path above relies on.

As-built — the routing table + token-audit's side of the contract (PLAN-efficiency-automation) and the dispatch-point wiring, the mandatory announcement, and the escalation tripwire (PLAN-efficiency-dispatch) both shipped and archived 2026-07-04, verified live (a Task-8 spike dispatched a real Explore sub-agent with model="sonnet" and it self-reported claude-sonnet-5). The routing-table read later migrated from a hardcoded relative path to opinion_resolve('efficient')['implements'] (2026-07-06). The wiring covers each named dispatch category at representative sites behind a token-audit probe (graceful-skip when absent), not every literal occurrence — see the Amendment log for the honest scope note and the one open INHERITED-precision gap.

/setup is not a daily cycle — it runs once per project to lay down the substrate the cycles read.

• Entry: operator invokes /setup; the agent inventories README, the package manifest, .github/workflows/, and any existing AGENTS.md before asking anything.
• Exit: .harness/ bootstrapped, AGENTS.md merged with a real ## This project block, init.sh verified to boot (exit 0); operator ready for /plan.
• Automated: inventory-before-interview (ask only what files can't answer); write the scaffold without clobbering existing files; populate + verify init.sh; append one line to progress.md.
• Enhancements: wiki seed pages via the documenter (wiki); a GitHub backlog Project, ask-first (github-projects).
• Artifacts: PLAN.md (seed), progress.md, features.json, init.sh, optional verify.sh, optional project.json; AGENTS.md (repo root, merged).

Each recurring cycle, with where it starts and stops, what it does on its own, what a sister capability adds, and where its artifacts land.

/plan — brief → steps, no code.

• Entry: /plan <brief> (--name / --stage / --activate modes); resolves the plan via resolve_plan.py and reads its status with plan_tracker.py status before the plan and progress.md. A bare call on a project that keeps its plans in tasks has no singleton (the resolver exits 4), so /plan proposes a verb-first task name for the operator to confirm, and points an arc-sized brief to /design.
• Exit: the plan written with steps + per-step verification criteria, and no plan-level Status line (the tracker is its only status); the tracker opened at queued after the board step (plan_tracker.py open), in a task as tracker.md or, in a repo with no vault, beside its repo-local plan as tracker-<slug>.md; features.json updated only for net-new user features; ready for /work.
• Automated: resolve path + mode (never re-derive); interview into executable per-step criteria; --activate promotes a staged plan after a pre-flight reconcile and moves its tracker to active; append one line to progress.md.
• Enhancements: design grounding — agentm_bridge.py governing-design reads the governing design's locked calls, and a grounding gate blocks an architecture-touching plan with no cited design (design, Hooks 2–3); pending-page declaration (wiki); board record + out-of-scope deferrals as backlog items (github-projects); (as-built) the explorer fan-out routes by token-audit's routing table + emits the mandatory fan-out announcement (token-audit).
• Artifacts: a task's plan.md (a queued task is staged; its queued tracker keeps it inert), or, in a repo with no vault, the repo-local PLAN.md / PLAN-<slug>.md; its progress.md; its tracker (tracker.md in a task, tracker-<slug>.md beside a repo-local plan); features.json; board-items.json.

/work — implement the tasks autonomously.

• Entry: /work [--name <slug>] [step N] (task N still works); resolves the plan's three paths, reads its steps (first [ ] or step N), runs the duplicate guard on plan_tracker.py status (done takes the close-out branch, dropped stops), checks isolation mode, and marks the start in the tracker, opening one for a plan written before trackers. A bare call on a project that keeps tasks asks which task, listing them through agentm_bridge.py plans.
• Exit: per step — implement → local check-all.sh green → push → mark [x] (gated on the previous step's PR check-suite having gone green — pipelined, one-step lag, not this step's own checks) → rewrite the tracker's State and Next (plan_tracker.py step) → log to progress.md → commit (one per step, no Co-Authored-By); the final step in the plan still waits synchronously for its own PR checks green before close-out (nothing left to pipeline against); on the final step, close the tracker with its Outcome (plan_tracker.py close), archive a flat plan, append a close-out, finalize the unit.
• Automated: per-step safety pre-check (stop mid-plan only on unrecoverable / ambiguous / scope-drifting / unverifiable / needs-clarification, else proceed), with the trigger recorded in the tracker before a stop; local gates required green before continuing to the next step; the previous step's PR check-suite confirmed green before the current step's [x] lands — wake-on-PR-checks, not wake-on-push (per-plan CI, 2026-07-06: the full matrix triggers on pull_request, not on push to main) — a red check-suite on the previous step stops the session immediately, the same trigger as any other safety-check failure, just surfaced one step later than a synchronous wait would; the plan's **Status:** line follows the tracker (plan_tracker.py rewrites it and never adds one); no tags (reserved for /release); autonomous close-out at plan end, which does wait synchronously on the final step's checks.
• Enhancements: worktree isolation + recoverability-gate finalize (developer-safety); explorer read-only fan-out for unfamiliar code (designed: routed by the table + announced, same as /plan's explorer — token-audit; the implementer itself is never routed — see the single-implementer invariant above); pending → implemented page flips (wiki); task-progress + backlog sync (github-projects); a design-divergence NOTE for /review to adjudicate (design, Hook 4).
• Artifacts: the plan ([ ]→[x]), of which a task directory never moves (its done tracker ends it; agentm's nightly job moves its records), and only a repo-local plan archives, to .harness/archive/PLAN.archive.YYYYMMDD-<slug>.md, its tracker staying in .harness/ at done; the tracker (State and Next per step, Outcome at close); progress.md (completed step N lines + close-out); board-items.json.

/review — adversarial critique, no fixes.

• Entry: /review [--name <slug>] [range / step N]; resolves the step context (default: the most-recently-completed step) and reads plan_tracker.py status — with no explicit scope a queued plan has nothing worked yet, so it says so and stops, and a bare call on a project that keeps tasks asks which task; runs the gates, probes for an adversarial reviewer + a governing design.
• Exit: gates reported (a red gate stops the run); on green, an adversarial pass returns a failing test / file:line defect / explicit NO ISSUES FOUND + design-conformance findings, triaged into recommended /work follow-ups; logged to progress.md. It never fixes — that is /work.
• Automated: gates first, short-circuit on failure; verify each finding reproduces before reporting; group + recommend follow-ups; log the outcome.
• Enhancements: a deeper adversarial pass in fresh context — assume bugs exist — and a cross-model second opinion when available (code-review); a design-conformance dimension (design, Hook 1); (designed) the adversarial + cross-model reviewer dispatch routes by token-audit's table + emits the mandatory fan-out announcement (token-audit).
• Artifacts: progress.md (the outcome — NO ISSUES FOUND or N findings — and the plan's status); reads the plan for the verification criteria.

/release — the pre-merge gate; ship.

• Entry: /release [--name <slug>]; resolves the plan the way /work does (a bare call on a project that keeps tasks asks which task), checks preconditions (plan_tracker.py status says done, which only the tracker can say — every step [x], /review resolved, clean tree, branch ahead), re-runs the full gate suite (full tests + production build).
• Exit: features.json passes: true set only on verified features; version bumped + changelog written; push → wait-on-CI green → tag-reachability check → tag → release, all under the recoverability gate; plan archived; ready for the next /plan or /bugfix. (The code itself already cleared the full-matrix PR check-suite as part of the plan's own merge to main, before /release runs — the version-bump/changelog commit's own push-triggered CI is deliberately the lighter push-to-main job, per-plan CI, 2026-07-06; /release was not moved onto a PR-check wait the way /work was.)
• Automated: precondition gate (any miss stops); full suite (not a subset); recoverable push/tag/release announce + proceed; archive + final progress.md summary (SHA, version, tag, URLs).
• Enhancements: design reconciliation of the full diff against the locked calls — divergence blocks the release (design, Hook 5); a documenter wiki sweep that blocks on unresolved OPEN QUESTIONS (wiki); the ship-release changelog + semver bump (conventions); plan + feature board closeout (github-projects); (designed) the close-out briefing auto-emits a model-labeled handoff pack for remaining cheap-routable work (token-audit's /handoff).
• Artifacts: features.json (passes: true); a repo-local plan's .harness/archive/PLAN.archive.YYYYMMDD-<slug>.md (its tracker stays in .harness/; a task directory never moves); progress.md (release summary); CHANGELOG.md (repo root).

/launch — first-production-exposure readiness gate.

• Entry: run before a feature first reaches production users (first real-traffic flag enable, staged-flag removal, a load-shifting infra change); not for routine patches.
• Exit: feature launched with a rollout plan in hand — RED metrics confirmed emitting, symptom-based alerts routing to a named owner, staged-rollout stages verified, the flag's removal scheduled within the next release cycle.
• Automated: verify observability wiring (send a test request, confirm metrics emit); test the rollback in a non-prod environment + document time-to-recovery; test the flag off-switch (< 5 min, no code change); advance the flag lifecycle created → dark → staged → full → removed; halt a ramp if RED metrics degrade.
• Enhancements: the observability deep-dive (/observe — RED instrumentation, structured logs, trace spans) (diagnostics); rollback + staged-rollout safety doctrine (developer-safety).
• Artifacts: progress.md (launch + rollout-plan summary); the rollout plan + flag schedule (in the changelog / runbook); feature flag state lives in the app, not .harness/.

/deprecate — mark an interface for retirement.

• Entry: run when an interface with callers is being removed, migrated, or sunset; not for live interfaces with no removal intent.
• Exit: the interface is marked, not removed — classified compulsory vs advisory; callers enumerated; for advisory, a deprecation notice + per-invocation log warning + a published removal date + changelog + downstream notification.
• Automated: classify (compulsory = all callers in-repo; advisory = external callers exist); enumerate callers via grep + type-checker; add the canonical deprecation notice + log warning; set a published removal date (no date = not a deprecation); update the changelog.
• Enhancements: changelog deprecation entries (conventions); a no-living-callers check (code-review).
• Artifacts: progress.md (the deprecation + removal date); CHANGELOG.md; the notice + log warning live in the code being deprecated.

/retire — prove-dead-then-delete (forward-looking — see Risks).

• Entry: run after a deprecation window (advisory) or once all callers are migrated (compulsory), to remove a previously-deprecated interface confirmed dead.
• Exit: the code + all conditional branches on the symbol deleted, zero remaining references, full suite green; the removal commit carries proof of the Beyoncé-rule audit.
• Automated: verify preconditions (notice exists / callers migrated); the Beyoncé-rule audit — grep the symbol, remove locally (no commit), run the full suite; if it fails, fix the missed caller and repeat; delete permanently; confirm an empty grep (a non-empty grep blocks the commit); changelog the removal.
• Enhancements: full-suite verification (conventions); a pre-commit removal-safety hook (developer-safety); a cross-repo reference audit for published interfaces (code-review).
• Artifacts: progress.md (the removal + audit proof); CHANGELOG.md (removal entry with deprecation + removal dates).

/bugfix — the alternate track (replaces /plan + /work for defects).

• Entry: /bugfix <report / repro>; resolves its plan via resolve_plan.py (the plan a worktree's marker binds, or, in a repo with no vault, the repo-local singleton) and captures the report verbatim into that plan's ## Report, asking first when plan_tracker.py status says the plan is queued, active or parked; on a project that keeps tasks it proposes a verb-first task name for the bug and confirms it; opens a tracking issue (announce + proceed).
• Exit: root cause pinned (file:line, a 3-why chain); a regression test written first (fails without the fix, passes with it); the minimal fix; a mandatory /review; the issue closed; one line to progress.md. A design flaw escalates to /plan rather than a symptom patch.
• Automated: reproduce → ask why 3× → pin root cause + scope; regression-test-first; gates green; the mandatory review; issue close.
• Enhancements: GitHub issue threading across all four phases (github-projects); the mandatory adversarial review (code-review); a Known-Issues page only on a durable gotcha (wiki).
• Artifacts: the resolved plan (## Report + ## Analysis); its progress.md (tracking #, root cause, regression-test path); the regression test (in the repo's test tree).

The harness is single-threaded within a unit of coherent work and fans out across units. The mechanism that makes both true is named plans + host-native git worktrees, with integration serialized at the PR merge boundary instead of an in-repo integrator script.

• The host owns worktree creation; the loop owns plan-binding. /work calls the installed host's native worktree primitive (Claude Code: EnterWorktree; Antigravity: the New-Worktree-Mode / invoke_subagent isolated option) to get an isolated checkout, then writes the worktree-local .harness/active-plan marker itself — the one piece of the retired spawn_worker.py that has no host equivalent, because neither host has a concept of "plan."
• The binding has a root-side half, so a plan outlives one session. The marker write is worktree-local, which leaves the main clone with no record of which worktree a plan is bound to; the same worktree_marker.py call therefore also writes .harness/worktree-for-<slug> in the original root, and /work step 1.5 re-enters that path on resume instead of skipping the step and running wherever the session happened to open. Per-slug by name, because more than one plan is routinely in flight. Following the pointer is a re-entry, not a spawn — it resolves only to a directory git worktree list already claims, so the authority model below is untouched — and every state-of-the-world failure (removed by hand, deregistered, unverifiable, repurposed, already inside) degrades to a visible note and carries on in place. Re-entry is a convenience layer and can never stop a plan.
• Auto-spawn is authority-gated, not autonomous-by-default. .harness/project.json's isolation.mode: worktree-per-plan is the durable operator authority (ADR 0028) that turns this on; it is set explicitly per repo, not inferred. Absent that config, /work runs in direct mode exactly as it does today. An in-worktree single-owner guard still prevents nested spawns.
• Named plans still give each unit an address. --name <slug> / --stage <slug> / --activate <slug> are unchanged. A name is a numbered task's directory name (042-build-the-brief), or, in a repo with no vault, a repo-local flat plan's slug, which the worktree marker and the tracker's task: field also carry. Each plan's status lives in its tracker, written only through plan_tracker.py, which shells out to agentm's tracker.py. agentm_bridge.py plans lists every plan agentm knows, with its progress log and tracker. /work offers that list on a bare call, and /orient renders it — by checkout, or by slug for a project with no checkout. queue_status.py remains the read-only coordinator's glance.
• Task commits land in the worktree; a PR closes the plan. Per-task commits (implement → gates → commit, one per task, no Co-Authored-By) are unchanged in shape — they just land in a host-managed worktree instead of a bespoke one. On the plan's final task, /work opens a PR from the worktree's branch instead of archiving-and-pushing-to-main directly; the PR carries the plan's close-out summary as its description.
• Integration serializes at the merge boundary, not a lock file. integrate_worker.py's exclusive integrate.lock + merge → gate → hard-reset-on-red sequence (ADR 0023) retires outright — a PR gated by a required check-all.sh status check (branch protection, ADR 0029) cannot merge red, so there is no post-merge failure state to roll back from. This is a stronger guarantee than the mechanism it replaces, not a shim of it.
• Merge is automatic on green (operator-ratified 2026-07-06). No operator-invoked merge step replaces /integrate-worker's operator-initiation carve-out — once the PR's required checks pass, it merges. See developer-safety's amendment for the recoverability-doctrine framing of this call.
• Generated-artifact single-writer (ADR 0030) is unchanged in spirit, re-homed in mechanism. Workers still write dist/ at the unbumped version; ADR 0029's require-branch-up-to-date-before-merge rule serializes the version-bump race the same way integrate.lock did. /release keeps owning the actual bump.
• Orphan-worktree lifecycle (operator-ratified 2026-07-06). A periodic sidecar (cadence: a few days) surfaces/reclaims worktrees whose branch never merged and whose session is gone; a soft doctrine reminder in /setup's scaffold is the non-blocking complement. No concurrent-worktree ceiling and no bespoke spawn-announcement — both hosts' own UI already surfaces child-session/worktree creation, and a ceiling is deferred pending evidence of an actual collision.
• Limitations. Merge conflicts now resolve as a PR-update, not an integrate_worker.py abort-and-roll-back. Submodule checkouts remain shared across worktrees per-host, same caveat as before.
• Future aspirations, narrowed. Per-task worktrees (isolation.mode: worktree-per-task) and the V5-5 orchestration split are unaffected by this change and stay designed-not-built. The async board depth-maintainer (the Planner (TPM)) is designed but unbuilt, so board depth is hand-maintained until it ships.

The loop requests done (the check battery /work and /release run — is it finished?) and how-we-engineer (the phase discipline + the plan → design → architecture sizing ladder) by name. Both are self-provider bindings (done and how-we-engineer both implements: crickets/development-lifecycle — the loop is the standard, not a consumer of it), declared via opinions: frontmatter and honesty-checked by check-opinion-self-provider-drift.py's SELF_PROVIDER_BINDINGS registry (PLAN-wave-d-personas task 3): done on work.md (the check-battery/task-marker/progress.md triad, anchored on marked `[x]` + progress.md) and how-we-engineer on bugfix.md (anchored on the verbatim "Report → Analyze → Fix → Verify" phrase the stub and the caller share — confirmed by grep across all six phase-command files before picking it, not assumed from the first hit). The prose itself stays hardwired in the phase-command markdown files (work.md, plan.md, review.md, setup.md, release.md, bugfix.md) — command/skill files are loaded verbatim as prompts with no runtime render step to splice a resolved opinion body into; the self-provider case never gets a marker, only the drift check, same as good's code-review→adversarial-reviewer.md binding.

The routed-dispatch layer is a third, narrower instance that IS wired (PLAN-wave-d-opinion-wiring task 2): escalation_tripwire.py now discovers tokens/scripts via opinion_resolve('efficient')['implements'], resolving crickets/tokens through efficient.md's frontmatter pointer instead of a hardcoded relative path. This narrow slice is real code with a real call site, unlike the two direct bindings above; the concrete tier/model/effort data still comes from classify_work_type.py/routing_table.py (the opinion's implements: artifact, not a duplicate — efficient.md's composes: [] means the routing lever isn't folded into the opinion body itself yet).

• The crickets development-lifecycle plugin carries the command specs (/setup, /plan, /work, /review, /release, /bugfix, /launch, /deprecate; /retire is forward-looking — see Risks) + the concurrency machinery.
• Sister capabilities — optional enhancements, each behind an agentm_bridge.py capability probe, graceful-skip when absent: code-review (the adversarial pass), developer-safety (worktree isolation + recoverability-gate finalize), github-projects (board-sync), design (design grounding + conformance, Hooks 1–5), wiki (the documenter), conventions (ship-release + the testing gate), diagnostics (/observe, for /launch), (as-built) token-audit (routed dispatch + the mandatory fan-out announcement + /handoff + the versioned routing table, via a new enhances: edge declared on token-audit).
• agentm keeps the plans; every other enhancement is soft — the phase loop needs agentm for its plans (with none, the commands say so), and every other enhancement graceful-skips when its capability is absent. research composes onto /plan's context-gathering (the explorer read-only fan-out), not a cycle of its own.
• Points up at the crickets HLD; the requires/enhances mechanics are in crickets-composition; requests the done + how-we-engineer opinions by name (agentm Opinions); the loop / goal launch modes are the Personas design; reads model-effort-routing's tier policy, concretized through token-audit's table, for the designed routed-dispatch layer.

• /retire is forward-looking — the lifecycle tail names it, but it is not a shipped command; its Beyoncé-rule deletion logic currently lives inside /deprecate. The design must not imply /retire is invokable today; the first build splits it out.
• The /deprecate → /retire split must be lossless — every step in today's deprecation logic lands in exactly one of /deprecate (mark) or /retire (remove).
• /observe is a sister enhancement, not a core cycle — /launch calls it; it lives in diagnostics, linked, never folded into the loop.
• The phase-loop depth is at altitude — each phase's full spec lives in its command file; this design captures the lifecycle shape, the per-workflow contract, the durable-memory wiring, and concurrency, not every internal step of every phase.
• Loop / goal modes are partly designed — running a cycle one-off works today; the looped + goal drivers are persona launch modes, some of which are designed-not-built (Personas).
• developer-safety naming — it kept the developer- prefix while this capability dropped it; developer-safety → safety is left open.
• The routed-dispatch layer is as-built — the table-driven dispatch, the mandatory fan-out announcement, the inheritance warning, staged per-task tier hints, the session-start nudge (tier + advisor availability), and the auto-emitted handoff pack all shipped via PLAN-efficiency-automation + PLAN-efficiency-dispatch (2026-07-04), acceptance-tested from fixture session output (the announcement line + the inheritance-warning pause) and confirmed live. Two honest residuals: the wiring covers each named dispatch category at representative sites, not every literal occurrence; and the announcement's INHERITED source can't yet distinguish a built-in agent's own default from true session inheritance — it stays conservative (over-warns rather than under-warns).
• Re-audit triggers: split /retire out of /deprecate; flip per-task worktrees + the orchestration split + the loop/goal drivers to as-built as they ship; settle developer-safety → safety; when persona activation ships, reconcile the routed-dispatch probe as the fallback path behind a dispatched persona's own resolved tier, rather than the primary path; migrate the routed-dispatch table read to opinion_request('efficient') when the Wave-B opinion registry lands; promote the session-start tier nudge to an actual switch if a host ever exposes enforceable in-session model control.

• Command specs: crickets src/developer-workflows/commands/ (→ development-lifecycle) — setup · plan · work · review · release · bugfix · launch · deprecate (+ retire, to author)
• Concurrency machinery: scripts/ — worktree_marker.py · worktree_shepherd.py · queue_status.py · task_isolation.py · isolation_config.py · preflight_reconcile.py · finalize_unit.py · resolve_plan.py · stage_plan.py · plan_tracker.py (the one helper the commands call for a plan's tracker — name, status, open, step, close — reading and writing the tracker only) · agentm_bridge.py's verbs (the DC-2-compliant bridge, which discovers agentm's scripts via path-fallback): process-seam (proxies state-path {plan|progress|tracker}; replaced harness_memory.py resolve-active-plan delegation in developer-workflows v0.25.0 / V5-4), tracker (agentm's tracker.py, exit codes passed through), project-brief (the opening brief) and plans (every plan with its progress log and tracker); worktree-authority + integration-lock designs in developer-safety
• Durable-memory wiring: agentm memory-storage-seam (V5-6 routing-plane — identical bytes across backends; V5-3 storage cutover — device-local canonical, vault as plugin); resolve_plan.py seam delegation
• Sisters: code-review · developer-safety · github-projects · design · wiki · conventions · diagnostics · research · token-audit (designed edge)
• Up: crickets HLD · composition · agentm Opinions (done, how-we-engineer) · agentm Personas (loop / goal launch modes) · agentm model-effort-routing (the tier policy) · crickets token-audit (the concrete routing table)

2026-09-23 — the flat plan layout retires: the commands follow agentm alone (crickets task 101, development-lifecycle 0.49.0; agentm-vault part 15, with task 100's other plugins). development-lifecycle no longer composes any plan layout of its own.

• The resolver. resolve_plan.py answers only from agentm's process seam, and with no seam it is exit 1: no plan. The standalone .harness/ pair and the vault-reachability probe are gone.
• Staging. stage_plan.py stages only a task, and a queued task is its queued tracker. queued-plans/ and the guarded flat copy are gone.
• The readers. queue_status.py is a pure bridge to agentm's reader, and harness_root_drift.py is deleted. /open and /orient list plans through agentm, by checkout or by slug (agentm_bridge.py plans --project). Their --note writes <desk>/orientation-note.md, and the gloss is the charter's What line alone.
• The desk and /setup. features.json lives in the project's desk/ through development-lifecycle's own project_homes.py. /setup seeds a plan only on agentm's exit-0 answer.
• The Status line is gone. The tracker is a plan's only status, and plan_tracker.py never writes the plan file.
• What crickets keeps. A repo with no vault still gets agentm's repo-local singleton and flat plans, each with a tracker. The commands follow those answers, and only such a plan archives at close-out; a task never moves.
• The gate. check-no-harness-paths now enforces with no exemption list.

Rulings, from the operator:

• (1–6) _harness/ goes, every plan lives in its task, a name is the task's directory name, a bare call gets exit 4, and crickets composes no layout.
• (8, 2026-09-23) Keep following agentm's repo-local answers for a repo with no vault.
• (9, 2026-09-23) /open on a project with no checkout asks agentm for each task's files by slug. That verb (resolve-active-plan --project SLUG) is an agentm prerequisite. Until it is deployed, those rows carry the plan path alone.

The ordering held: agentm's plan_graph.py reads the tracker first (agentm task 172, step 3), and a re-probe on the deployed clone confirmed it before the Status line was removed.

Why not keep a standalone floor: it was a second layout crickets composed and agentm didn't know about. Every divergence between the two, from a flat plan agentm couldn't list to a Status line agentm didn't read, was a silent wrong answer. With no agentm there is no plan to be wrong about.

Why not have crickets pair a task's sibling files for a slug-only project: that is the layout knowledge ruling 6 takes out of crickets, so the gap goes to agentm as a verb.

Re-audit triggers:

• a standalone (no-agentm) install of development-lifecycle turns up;
• agentm stops serving a repo with no vault its repo-local layout;
• ruling 9's verb ships with a different contract than the one task 101's plan specifies.

2026-09-15 — the commands write and read agentm's tracker, in both plan layouts (PLAN-tracker-commands, development-lifecycle 0.48.0; the second of agentm-vault's three paired landings). A plan now carries a tracker, which holds its status, State, Next and Outcome in agentm's one schema. Every phase command reads status from the tracker before the plan's **Status:** line. /plan opens the tracker at queued after the board step. /work marks the start, rewrites State and Next after each step and writes the Outcome at close. /review, /release and /bugfix read its status, and /orient renders agentm's opening brief and lists the project's plans through agentm. Only agentm's tracker.py writes a tracker. crickets reaches it through agentm_bridge.py's new tracker verb and one helper, plan_tracker.py. Until part 15, that helper also keeps the plan's existing Status line in step for the readers that still read it. The resolver prints a third field, the tracker path agentm names. It passes on exit 4 for a bare call on a project that keeps its plans in numbered tasks, and the commands then ask for or propose a task name. Everything works in today's flat _harness/ pairs and in the projects/<slug>/tasks/NNN-<verb-slug>/ directories agentm's plan 10 moves every project into. Nothing here composes a layout. /orient --note no longer creates a missing _harness/. Why not let crickets compose the task layout itself: numbering, lookup by name and the move all belong to agentm's resolver. A second composer in crickets would drift from it the first time either side changed. crickets follows the paths agentm returns, and tells a task by its plan.md. Why not a plans/ folder: every plan belongs to a task, and the task directory already holds its plan, progress log and tracker. A plans/ folder would be a second home for the same file. Why not nest an arc's tasks inside the arc: an arc is a design whose parts close together, not a container. Its tasks stay flat and numbered in the order of work, and each names the arc's design in its tracker's design: field. A project's task list then reads the same whether or not a task belongs to an arc. Re-audit triggers: agentm-vault part 15 lands and retires the _harness fallbacks, which is when the flat branches here go (the queued-plans/ staging tier, the flat archive rule, the Status-line mirror); a project accumulates plan documents that aren't tasks, which is this design's own trigger for bringing plans/ back.

2026-08-12 — the worktree bind gains a root-side half, and /work's resume path re-enters instead of skipping. /work step 1.5 could spawn a worktree for a plan's first task, and nothing brought a later session back to it: the bind's two writes (.harness/active-plan, the .harness/project.json copy) are both worktree-local, and --project-root was read-only there — used for the registered-worktree check and as the copy source, leaving nothing on the main-clone side. Verified against a live bind: the main clone's .harness/ held no worktree pointer of any kind. Step 1.5 then said "skip this step if resuming", so a resumed session got neither a spawn nor a re-entry and simply ran wherever it opened — the main clone, for a session launched at the repo root. On Claude Code Desktop, where launching with a subdirectory as cwd is awkward, that made every resumed multi-session plan need a hand-written "enter the existing worktree at <path> first" sentence in its opening prompt. worktree_marker.py write now also records <main-root>/.harness/worktree-for-<slug> (one line, the resolved worktree path), and gains read / clear verbs over it; step 1.5 splits into an auto-spawn branch (first run, unchanged) and a re-enter branch (resume) that reads the pointer and calls the host primitive against the existing path (EnterWorktree with path, not name).

Why per-slug and not one file: agentm routinely carries more than one active plan, so a singleton pointer would have two in-flight plans overwrite each other's binding. Why .harness/: it is gitignored, so this stays local state and never becomes a committed artifact — the same reason the worktree's own project.json has to be copied in at bind time. Why every failure collapses to one non-blocking exit code: read returns exit 1 for absent, stale, unverifiable, repurposed and already-inside alike, so no caller can turn a pointer left behind by a hand-deleted worktree into something that stops a plan; only a malformed slug (a programming error, not a state-of-the-world one) is loud. Staleness is judged by the bind's own _is_registered_worktree() rather than a second check, so the fake-slot hazard has exactly one definition. Why this is not an auto-spawn: the pointer is only ever followed to a directory git worktree list already claims — nothing here creates a worktree — and the authority that permitted the original spawn is what put the pointer there, so ADR 0028's requirement and agentm's check-no-auto-worktree gate are both untouched (the gate scans for git worktree add in automation surfaces and stays clean against this tree). Why the slug is now validated: it becomes part of a filename, so single-path-component safety went from cosmetic to load-bearing; resolve_plan's existing guard is reused so the two agree. Why step 2.5 opts out via --no-root-pointer: a per-task worktree is merged back and pruned inside one session, so recording it as the plan's worktree would aim resume at something already gone. Why resolve_plan.py does not participate: it resolves plan state paths, delegating to agentm's process seam (DC-2) which has no concept of a host worktree; the pair it returns in step 1 is absolute and stays authoritative across the re-entry, exactly as it already did across a first-run spawn — coupling worktree location into it would put an isolation-layer concern behind the seam boundary. Re-audit triggers: a host ships a native plan/worktree association that could absorb both halves of the bind (the same trigger the 2026-07-06 entry already names for active-plan); a plan is ever legitimately bound to more than one worktree at a time, which this one-line-per-slug format cannot express; /bugfix's bind grows a resume path of its own (it writes a pointer today and never reads one).

2026-08-02 — /release's close-out reaches what a release fulfilled, and coalescence item 3 becomes mechanical (PLAN-board-roadmap-reconciliation). The close-out step existed and ran correctly; its scope was the gap. Constraint 7 covered the shipping Plan and its parent Feature, so a release that satisfied a pre-existing Backlog-item — by opening a fresh Plan, shipping it, and flipping that Plan Done — left the older row describing the same work at Todo forever. Nothing anywhere closed era/Version containers either. That is how the boards accumulated roughly 35 open issues against a roadmap declaring every arc complete: the flow closed what it created and never closed what it fulfilled. Constraint 7 now also covers fulfilled backlog rows (recording a promotion to the Plan or Feature that actually shipped them, so the linkage survives instead of the row silently vanishing) and containers whose scope has landed — each needing an explicit gh issue close, because a status-flipped non-task post writes the Status field and never closes the issue. A container with still-live child scope names where that scope moved before closing, or the close orphans it. Separately, coalescence item 3 ("boards reconciled") was prose a human was trusted to honor: coalescence_checks.check_board_item_closed covers only the single --item-id shipping row and silently skips when none is passed. It now also asserts that every GH #N named in the drafted release body is a closed issue (--release-body). Why this check and not a broader one: the data was already there — v9.0.2's body opens "Plan A of 2 (GH #70)" and v9.0.3's names GH #72, and both issues stayed open for weeks; fed those real bodies with the issue states as they were, both fail, so this catches the class at the moment it is created. Why GH #N only and not a bare #123: a bare reference is nearly always a PR link, and a merged PR closes by a different mechanism than the issue it ships, so matching those would fail every release. Why an unreadable issue state skips rather than fails: an unreachable gh must not block a release. Why not a parent-closes-when-all-children-close rule instead: evaluated and rejected — "all children closed" is vacuously true of a childless container, so it reduces to close every container with no children, which would have wrongly closed a genuinely open row (agentm #10, whose PKM scope is untouched) while still leaving V6 open, since V6 has a live child. It would have fixed none of the four containers it was proposed for. Re-audit trigger: if a release ever legitimately names a GH #N it does not close — a forward reference to planned work — the check needs an explicit opt-out marker rather than the current all-or-nothing assertion.

2026-07-26 — post-work and post-release gain a second listener on agentm's side: crystallization's phase-close trigger (cross-repo, agentm PR #384). No change on this side — work.md step 9.6 and release.md step 8.5 fire phase-dispatch post-work / phase-dispatch post-release exactly as the entry directly below describes, and both keep their always-exit-0, non-blocking contract untouched. What changed is purely agentm-side: orchestration_phase.py's _main() now runs a second step on both dispatches — staging a bare crystallization candidate (a session id and transcript pointer, nothing else) under _crystallize-staging/ for a human or a future agent-side pass to pick up — alongside the reflect / skill-refresh behavior the entry below already documents. This is why the entry below is the one place in this design describing what post-work/post-release do: a second consumer joining the same two events doesn't change what fires them or their contract, only what agentm does once they land, so it belongs here as an amendment rather than a rewrite of the original entry. Why this needed recording at all: the original entry's "dedup and cooldown are entirely agentm-side, so there's nothing for the bridge verb to gate beyond discovery" is still true, but a reader of this design should not have to cross into agentm's own design to learn that these events now do two things, not one. Re-audit trigger: if a third agentm-side consumer joins these events, or if crystallization's own trigger design (agentm-experience-and-dreaming.md § Crystallization's phase-close trigger) is superseded by a narrower investigative-session event, note it here too.

2026-07-25 — the orphaned phase_dispatch bridge gets a caller (Loose Ends follow-on, cross-repo). agentm's V5-5 orchestration bridge (harness_memory.phase_dispatch, _BRIDGE_PHASES = {"post-work", "post-release"}) was built, tested, and documented — and called by nothing, since the plugin that used to call it (developer-workflows) was retired and this repo's replacement (development-lifecycle) never grew the wiring (confirmed by grep: zero references anywhere in this repo's tracked source before this landing). agentm_bridge.py gains a sixth verb, phase-dispatch, honoring this design's own 2026-07-10 re-audit trigger (extend the merged dispatcher rather than start a new bridge file) for the second time — repo-registry was the fifth. work.md fires phase-dispatch post-work after each task's commit (step 9.6); release.md fires phase-dispatch post-release after the release lands (step 8.5). Both always exit 0, matching phase_dispatch()'s own non-blocking contract — dedup and cooldown are entirely agentm-side, so there's nothing for the bridge verb to gate beyond discovery. The gap was invisible on Claude Code (the Stop hook reflects every session regardless), but on Antigravity, which has no Stop hook, this was a real behavior gap — zero session reflection at all, not redundancy-with-a-fallback.

2026-07-17 — /open (alias /orient) lands: a read-only conversational verb that absorbs wake-from-state (#11) as its successor (FRIDAY-CRICKETS lane, F1-REAUDIT goal 5 + goal 6, PLAN-open-a-project-by-name). The operator's own want, stated during F1's re-audit: "when I ask you to locate or open a file for project X, you respond with what you found or a list and ask for clarification; once confirmed, you provide a short summary of the project and where we're at with any pending plans on it so I can remember." Ships as a thin three-step composition, not a new engine: LOCATE (resolve_project.py) merges three independently graceful-skipping sources — a fifth agentm_bridge.py verb, repo-registry list (honoring this design's own 2026-07-10 re-audit trigger below, rather than a new bridge file), the vault's projects/ tree (a file-path-loaded harness_memory.py, the same in-process pattern src/research/scripts/agentm_bridge.py already uses for recall.py), and agentm recall itself — deduped by slug, classified none/one/many by plain substring/token matching (no ranking model; recall already brings semantic matching for the harder cases). CONFIRM renders the goal-5 contract's exact three cases (one match + "this one?"; a short disambiguation list; "not found"). ORIENT (orient_render.py) composes queue_status.py's existing plan-file discovery + Status: extraction (imported, not re-derived) with a new per-task ✅/⬜ checklist, a multi-line progress tail, the queued-plans/ tier, and a read-only board-items.json glance — file-only, no gh calls, the identical posture /queue-status-lite already established (surfaces, never mutates, never claims/arbitrates). The goal-6 pointer task ships alongside: an opt-in --note flag idempotently overwrites <_harness>/orientation-note.md, so a phone surface reading the vault via the Drive connector can serve the same orientation away from the machine — the base command itself never writes to disk. /open and /orient are one implementation, two command files with byte-identical process bodies (locked by a drift test), per the same constraint that inlines the recoverability-gate block verbatim across work.md/bugfix.md/release.md — command markdown has no include mechanism.

/open absorbs wake-from-state (#11) as its successor. #11's premise was a background trigger that notifies the operator when tracked state changes; /open's pull-only shape gets the operator the same orientation the moment they ask, without needing a trigger to fire first. Why not build #11 alongside or instead: a push-notification mechanism would duplicate the exact LOCATE→render machinery this amendment just shipped, for a narrower trigger-driven case — building the pull-based orientation first and proving it out is the cheaper sequencing, and #11's actual gap (being told without asking) is real but separate. Re-audit trigger: revisit #11 for real if a genuine need for push, not pull, notification surfaces — /open's shape structurally cannot notify unprompted, only answer when asked.

2026-07-10 — the four find_*.py-style bridge scripts merged into agentm_bridge.py (Consolidation arc, CONS-2 task 2). find_capability.py, find_governing_design.py, find_process_seam.py, and resolve_workflow_persona.py each independently re-implemented the same env-var/co-located/conventional-clone path-fallback cascade and subprocess-proxy contract; merged into one src/development-lifecycle/scripts/agentm_bridge.py behind a four-verb dispatcher (capability / governing-design / process-seam / workflow-persona). Every command-file call site (this design's own routed-dispatch, design-grounding, and workflow-persona probes among them) and this design's own prose references updated to the new invocation shape; no behavior change to any verb's discovery order, exit codes, or graceful-skip contract. Re-audit trigger: if a fifth agentm-facing lookup is added to development-lifecycle, extend this same dispatcher rather than starting a new standalone bridge file.

2026-09-04 — the shepherd's safety test learns what "landed" means in a squash-merge repo (development-lifecycle 0.47.0). Arming the shepherd showed it would leave 17 orphaned branches across the two repos forever: is_safe_to_reclaim proved safety by commit identity — every commit on the remote copy, or never diverged — and a branch that lands the normal way (PR squash-merged, remote branch deleted server-side) can satisfy neither, since the squashed commit carries no ancestry link to the branch's own commits. doctor_worktrees.py gains content_landed() — every path the branch changed since its fork point holds the same blob on the integration branch now, or held it at that path in some commit on it (git log --find-object), or is deleted on both — and the shepherd tries it as a third rung once the two commit-identity rungs fail; the doctor's merged-but-unpruned classification consults it too, so the two tell one story. What stays unsafe is content that never existed on main at that path — work main does not have. The "ever at that path" clause came from running the first, now-only version against the real repos: it proved 1 orphan of 17, and a per-path diagnosis showed 15 of the other 16 failing solely because main had since edited a file they touched. Why not the alternative (ask GitHub whether the PR merged): authoritative but network-bound and account-bound, and the reclaim path has been deliberately offline; a file-level test needs nothing but the repo, and answers the actual question — is anything here absent from main? — rather than a proxy for it. Re-audit triggers: a reclaimed branch turns out to have held work absent from main (the file-level test has a hole — stop the job and find it); the repos stop squash-merging (the commit-identity rungs suffice again and the third is dead weight); orphan counts stay high across several armed runs (the per-path diagnosis in the 2026-09-04 session is the template for finding out why, and a merged-PR lookup may then be worth its network dependency).

2026-09-04 — the shepherd's third duty: a linked worktree stranded on the integration branch is detected and, when clean, detached (development-lifecycle 0.46.0). gh pr merge --delete-branch run inside a worktree checks the base branch out there before deleting the PR branch, so the worktree walks off holding refs/heads/main with its own branch gone; the primary clones are kept detached at origin/main, so the ref is never held anywhere and the theft never fails loudly. The designed flow never runs that command (/work arms gh pr merge --auto at open and lets GitHub merge), but a hand merge reaches for -d by habit — twice on 2026-09-04, in two sessions. Neither existing doctor pass could see the result: diagnose() anchors on a worktree-<slug> branch that no longer exists, and scan_slots() correctly calls the slot real. doctor_worktrees.py gains stranded_worktrees() — every linked worktree checked out on origin/HEAD's branch, the main worktree exempt, a detached one never counted — and worktree_shepherd.py gains detach_stranded(): git checkout --detach in a clean stranded worktree, which releases the ref and loses nothing. A dirty tree is the best available sign of a live session, so it is reported and left alone. The operator's global doctrine gains the matching rule beside the gh pr update-branch --rebase one: arm --auto at open, or merge with plain --squash, never -d. Why not the alternative (keep local main checked out in the primary clone, so gh's checkout fails loudly): it rewrites a deliberate workflow — release commits are made on the detached primary and pushed HEAD:main — to guard against a command the rule removes outright, and a checkout that fails mid-merge leaves gh half-done (merged, remote branch deleted, local not) rather than clean. Re-audit triggers: a stranded worktree recurs despite the doctrine line (the rule is not holding; a reference-transaction hook refusing refs/heads/main updates from a linked worktree is the mechanical fallback); gh grows a remote-only delete flag; the primary clones stop being kept detached (then a stolen main would block them, and the detach duty turns from tidy-up into load-bearing).

2026-07-07 — routed dispatch flipped designed→as-built (G12 AG close-out sweep). The "Routed dispatch + mandatory fan-out announcement" section header, its [PENDING-IMPL] body note, the Risks bullet, and the two *(designed)* sister-capability markers all still framed the layer as unbuilt, but PLAN-efficiency-automation (routing table + token-audit's side) and PLAN-efficiency-dispatch (the dispatch-point wiring, the announcement, the escalation tripwire, the advisor rider, the session-start nudge, staged tier hints) both shipped and archived 2026-07-04 — the latter's Task-8 spike verified a real Explore sub-agent dispatched with model="sonnet" self-reports claude-sonnet-5, closing the empirical loop. The routing-table read later migrated to opinion_resolve('efficient') (2026-07-06, entry below). Flipped the header, the body note, the Risks bullet, and the two *(designed)* markers to as-built. Two honest residuals were carried into the Risks bullet rather than dropped: the wiring covers each named dispatch category at representative sites (not every literal occurrence — the shipping plan's own scope note), and the announcement's INHERITED source can't yet distinguish a built-in agent's own default from true session inheritance (stays conservative). Re-audit trigger: close the INHERITED-precision gap if a dispatch site gains the ability to introspect the target agent-def's frontmatter.

2026-07-07 — the loop's direct done/how-we-engineer bindings move from undeclared hardwired prose to self-provider bindings (PLAN-wave-d-personas task 3). work.md and bugfix.md now declare opinions: [done] / opinions: [how-we-engineer] respectively, and check-opinion-self-provider-drift.py's SELF_PROVIDER_BINDINGS registry gained both entries — the same self-provider class already proven on good/code-review's adversarial-reviewer.md. work.md is done's canonical site (the check-battery/task-marker/progress.md triad); bugfix.md, not plan.md/work.md as this plan's own preamble first guessed, is how-we-engineer's canonical site — confirmed by grep across all six phase-command files: "Report → Analyze → Fix → Verify" appears verbatim in the stub and in exactly one command file. No marker/interpolation for either (self-provider prose stays hardwired by design, honesty-checked only) — the "Opinions it consumes" section above and the 2026-07-06 entry below are updated to no longer claim these are undeclared or portfolio-gap examples. Re-audit trigger: if a future rewrite moves the check-battery/task-marker/progress.md prose or the bugfix pipeline's own description off work.md/bugfix.md, re-run the canonical-site grep before assuming the registry's caller paths still hold.

2026-07-06 — routed-dispatch's token-audit read migrated to opinion_resolve('efficient'), with a same-repo fallback CI caught (PLAN-wave-d-opinion-wiring task 2). escalation_tripwire.py no longer hardcodes _HERE.parent.parent / "tokens" / "scripts" to discover the routing table; it resolves opinion_resolve('efficient')['implements'] (efficient.md's implements: crickets/tokens pointer) instead — a real registry lookup replacing an ad hoc relative path. A first version of this migration made the same-repo tokens/scripts lookup transitively depend on agentm's opinion resolver being reachable at all — CI (no sibling agentm checkout) caught this as a real regression: _HAS_HANDOFF_PACK fell through to False and 2 tests failed on a missing prompts.json that pre-migration code always wrote regardless of agentm's presence. Fixed forward in the same PR: _resolve_efficient_implements_dir() now falls back to the same-repo conventional path (_FALLBACK_TA_SCRIPTS) whenever the registry is unresolvable, so a machine with no agentm sibling never regresses below the pre-migration floor; a parity test proves the registry lookup and the fallback resolve to the identical directory whenever agentm IS present, so the two paths can't silently diverge. classify_work_type.py/routing_table.py still hold the concrete tier/model/effort data (efficient.md's composes: [] means the opinion doesn't fold in the routing lever itself yet); this migration changes discovery only, not the resolved classification, proven by a fixture test asserting the announced tier/model is unchanged. fanout_announcement.py itself needed no change — it never imported routing_table/classify_work_type directly; only escalation_tripwire.py did. The loop's own direct done/how-we-engineer bindings (the two-sentence paragraph above) stay hardwired prose — command markdown has no runtime render step, the same portfolio-wide gap this plan's task 3 documents. Re-audit trigger: if agentm ever changes efficient.md's implements: target away from crickets/tokens, the fallback constant must move with it or the parity guarantee breaks silently.

2026-07-06 — spawn_worker.py / integrate_worker.py retired outright; the wiki's own command references land on the surviving scripts (PLAN-worktree-native-flow task 8, docs sweep). Both scripts and the two commands that wrapped them, /spawn-worker and /integrate-worker, are deleted from src/development-lifecycle/ and dist/ — not migrated, not renamed. The Concurrency-machinery reference list above now names worktree_marker.py (writes the worktree-local .harness/active-plan marker once the host has already created the worktree — the LC-6 preflight-reconcile guard and the LC-2 vault_project divergent-override copy that spawn_worker.py used to carry) and worktree_shepherd.py (the periodic sidecar that reclaims provably-safe orphaned worktrees/branches and rebases a BEHIND PR via gh pr update-branch) in their place. Why not keep the old mechanism as a fallback: a PR gated by a required check-all.sh status check structurally cannot merge red, so integrate_worker.py's merge-then-gate-then-hard-reset sequence had become redundant machinery duplicating a guarantee GitHub's own branch protection already provides more strongly — carrying both would be two serialization mechanisms for one invariant, not a safety net. This entry is a docs-only reconciliation of the 2026-07-06 entry below, which already narrated the retirement in the design body; it closes the reference-list drift that entry left behind.

2026-07-06 — worktree-native flow: host-native worktrees + PR-per-plan replace spawn_worker.py/integrate_worker.py (operator-ratified 2026-07-06; ROADMAP-MASTER § Ratified 2026-07-06; adjudicated via the W1 verdict memo + Fable judgment pass; PLAN-worktree-native-flow). spawn_worker.py's git-worktree creation/locking machinery retires in favor of the installed host's own worktree primitive (Claude Code EnterWorktree; Antigravity New-Worktree-Mode/invoke_subagent); /work retains only the plan-binding marker write, since neither host has a "plan" concept. integrate_worker.py's merge-then-gate-then-hard-reset (ADR 0023) retires without a replacement mechanism — a PR gated by a required status check structurally cannot merge red, so the rollback case it existed for no longer occurs. Merging is auto-on-green (no operator-invoked merge step), a deliberate one-notch loosening of the recoverability doctrine's usual posture, by explicit operator choice — armed via gh pr merge --auto at PR-open time, a build item in PLAN-worktree-native-flow, not this amendment. Worktree spawning drops its per-invocation operator-authority gate in favor of the standing isolation.mode: worktree-per-plan config opt-in, with an orphan-worktree cleanup sidecar (cadence: a few days, extended to stalled-PR shepherding per the Fable judgment pass) plus a soft /setup-scaffold reminder as the replacement safety net — no spawn-announcement (the hosts' own UI covers it) and no concurrent-worktree ceiling (deferred pending evidence). ADR 0030's single-writer defer-bump is unchanged in intent; its serialization mechanism moves from integrate.lock to ADR 0029's existing require-up-to-date-before-merge branch protection. Task commits move from direct-to-main to a PR opened at the plan's final task. Why not the alternative (keep the bespoke integrator and add host worktrees only for isolation): would run two serialization mechanisms side by side for the same invariant, and the host's own required-check gate already provides a stricter guarantee than the hand-rolled hard-reset — carrying both is duplication with no added safety. Re-audit triggers: the orphan-worktree sidecar is ever found insufficient (a stranded-fix recurs despite it); a concurrent-spawn collision is actually observed (revisit the deferred ceiling); either host ships a native "plan"/task-list concept that could absorb the .harness/active-plan marker; ADR 0029's branch-protection rules are ever weakened; GitHub's native merge queue becomes available on these repos (the Fable pass's named spike in PLAN-worktree-native-flow).

2026-07-05 — governs: frontmatter re-pointed to src/development-lifecycle/ (PLAN-wave-a-renames-1 task 3). The directory this task's rename moved (src/developer-workflows/ → src/development-lifecycle/); the design's coverage moves with it. No content change — the design already narrated the rename in the 2026-06-28 entry below; this closes the stale frontmatter path that entry left behind.

2026-07-05 — Pipelined wake-on-CI cadence: one-task lag instead of synchronous per-task blocking (PLAN-ci-walltime-diet task 2). The prior text's "gates required green before [x]" didn't distinguish local battery from remote CI, and in practice every task-commit paid a full synchronous wake-on-CI wait before its checkmark — measured across agentm+crickets, 2026-07-03..05: ~6.04 combined hours of CI-All wait in a single 2-day window, 90-94% of it Windows-leg execution time, against a push pattern of 4-10 tagged task-commits per plan. /work still pushes every task and the full matrix still runs on every push — nothing is skipped. What changes: the session doesn't block on that push's CI before starting the next task; before the next task's [x], the previous task's CI is confirmed green (cheap by then — it's usually already finished in the background). A red CI on the previous task still stops the session immediately, just one task later than today.

Why not the alternative (batch all mid-plan CI confirmation to plan-close): the same evidence window shows real per-task Windows-only regressions landing (a worktree-list path-separator bug, a Git-Bash-resolution bug, a cross-platform dist-pollution bug) — a full-plan batching window would let several such commits stack before detection, multiplying bisection cost. A one-task lag caps detection latency at a single task while still capturing nearly all of the wall-clock win.

Re-audit triggers: a Windows-only regression is ever found to have survived a full one-task lag undetected (i.e., the previous task's CI genuinely hadn't finished before the next task's local implementation completed) — revisit the lag width; or wake-on-CI itself is retired in favor of some other verification model.

2026-07-04 — P11 v2: sub-agent dispatch classifies, then routes by token-audit's versioned table, with a mandatory fan-out announcement (designed, not built). The loop's existing dispatch points (/plan explorer, /review adversarial + cross-model reviewers, the documenter, verification-clerk-style graders) first resolve their own work-type via token-audit's classify_work_type classifier (persona-declared tier → role-name match → explicit UNCLASSIFIED-DEFAULT), then consult token-audit's versioned routing table at dispatch time via a new enhances: edge + a find_capability probe, passing the resolved model per invocation (effort stays bound via roster-wide agent-def frontmatter — the Agent tool has no per-invocation effort) — graceful degradation to today's behavior when the table/capability is absent. Adds a mandatory fan-out announcement, unconditional on capability presence: one line per dispatch group (role · agent count · model · tier source — table row / frontmatter / UNCLASSIFIED-DEFAULT / INHERITED), explicitly covering built-in-agent inheritance (Explore inherits the session model at Claude Code ≥2.1.198, so the INHERITED source must name that correctly once the installed CLI crosses that version) and the classifier's own miss case. Silent session-model inheritance is forbidden — an inheriting dispatch must announce a loud warning and pause for confirmation whenever the session model is frontier-tier (T3/T4), the direct fix for the Mythos incident (112 sub-agents silently inheriting claude-fable-5, the table's one recognized-but-unrouted, premium-priced model). Adds an optional per-task tier hint to staged plans (the classifier's output at staging time), a session-start nudge that reports a tier mismatch and states advisor availability (advisory only, never switches), and phase-close auto-emission of a machine-readable handoff pack via token-audit's /handoff-pack. Adds token-audit as a new sister capability (designed enhances: edge). Explicit boundaries recorded: the main session's own model stays a human act; the single-implementer invariant is untouched (/work's implementer never fans out — routing only ever covers the read-only/review/docs helpers around it); wires via enhances:/probe now, migrates to opinion_request('efficient') at the Wave-B registry. Hard prerequisite: the already-shipped R0.5 find_capability fallback fix.

Why not the alternative: a hard block on frontier-tier inheritance (instead of warn-and-pause) would stop legitimate deliberate T4 dispatches — the Mythos failure was silence, not the choice itself, so a loud pause preserves intentional use while killing the silent case; gating the announcement on the capability being installed would re-create the exact blind spot (a bare install fans out silently) this exists to close — visibility must not depend on the table being present; routing /work's own implementer through the table too would violate the single-implementer invariant (ADR 0023 / the concurrency model above) — /work is deliberately not a fan-out surface; letting a dispatch point guess its own work-type inline (skip the classifier) would re-open exactly the ad hoc, per-session judgment call this whole amendment exists to close — the classifier's UNCLASSIFIED-DEFAULT case is what makes an unmatched role visible instead of silently absorbed into whatever the dispatch site happened to assume.

Re-audit triggers: when persona activation ships, the table-probed read becomes the fallback path behind a dispatched persona's own resolved tier, not the primary one; when the Wave-B opinion registry lands, migrate to opinion_request('efficient'); promote the session-start nudge to an actual switch if a host ever exposes enforceable in-session model control.

2026-07-04 — phase-aware-model-routing: the folded ADR 0026 re-audit trigger has fired (P14c). The host now documents model: + effort: frontmatter on skills/commands, applied for the turn the command runs (turn-scoped, not session-persistent). Consequence: the phase commands graduate from prompt-level nudge to frontmatter pin, rendered from the routing design's tier table; the nudge remains the cross-turn fallback. Corrected by P12 Task 0's live spike (same date, plan closed): command frontmatter is decorative, not enforced — three scratch commands pinned model: claude-opus-4-8/opusplan/claude-sonnet-5 all reported back the session's own baseline unchanged. The claim narrows to genuine sub-agent dispatch (the Agent tool's per-invocation model param — Task 8: Explore passed model="sonnet" self-reported claude-sonnet-5) plus the prose nudge, which stays the phase-command mechanism, not a fallback beneath a frontmatter pin that never existed. Why not leave it advisory: the host now applies the pin deterministically at the moment the work runs, and keeping a nudge where enforcement exists re-opens the silent-inheritance class (Mythos: 112 sub-agents inheriting Fable) — reasoning that held only for the sub-agent-dispatch case the correction narrows to, not for command frontmatter. Build lands in the P12 routed-dispatch plan (archived; see agentm-model-effort-routing's matching 2026-07-04 correction for the full finding). Re-audit trigger: a future CLI version demonstrably honors command-level model:/effort: frontmatter, or ships per-invocation effort on the Agent tool.

2026-06-28 — lock-down sweep (operator review). Converted the lifecycle-flow mermaid to a house-style hand-SVG (diagrams/crickets-development-lifecycle.svg). Confirmed development-lifecycle is the spine every other capability builds on — the plan→…→retire loop with /bugfix rejoining at /release (renamed developer-workflows→development-lifecycle, now owning the whole arc). The folded-ADR records and the newest-first log are unchanged. Locked as a v5–v8 guidepost.

2026-06-24 — folded ADRs 0002 / 0004 / 0023 / 0024 / 0026 / 0029 / 0030 into this design (AG Phase 4, move-and-retire).

0002 — evaluator sub-agent: read-only fresh-context grader (2026-05-13; amended 2026-05-17, 2026-05-25). Ship evaluator as a standalone agent in crickets/agents/evaluator.md with tool allowlist [Read, Glob, Grep], a PASS/NEEDS_WORK output contract, and a caller-supplied inline rubric. Coexists with adversarial-reviewer. Why not sidecar rubric.md: more machinery to maintain; inline rubric is more flexible. Why not replace adversarial-reviewer: the two agents serve different framings. Re-audit triggers: if a rubric class genuinely can't be expressed without Bash; if consumers want PASS/PARTIAL/FAIL; if reusable stored rubrics become needed.

0004 — Design skill: human-facing design pipeline → agent execution handoff (2026-05-15; amended 2026-05-16). /design ships as three sub-commands (author, translate, sequence). Stage 5 execution reuses /work + /review. One PLAN.md per part; no-Bash tool allowlist; skill lives in crickets. Why not per-stage skills: would duplicate the /work phase. Why not one shared PLAN.md: couples part lifecycles. Why not put /design in the harness: conflates customization with phase orchestration. Re-audit triggers: /design author abandoned mid-flow on first real design; part-split override rate >50%; every Claude Code release that changes phase semantics. See also: 0024 (the divergent command port of this skill).

0023 — Gate the integrated tree: merge-then-gate with hard-reset rollback (2026-06-13). /integrate-worker does: capture pre-merge HEAD → git merge --no-ff worker/<slug> → run check-all.sh → on red: git reset --hard → on conflict: git merge --abort. Never pushes. Why not gate-then-merge: proves the wrong artifact (validates against old base, not the main it's about to join). Why not leave main broken on failure: a broken main is a shared-state failure. --no-ff chosen because it records an explicit integration commit the rollback anchor and safe git branch -d prune both rely on. Re-audit triggers: /integrate-worker ever gains a push step or runs on a published branch; check-all.sh gains a step that mutates remote state.

0024 — Package /design as a command, not a skill (2026-06-13; accepted at v3.10.0). /design ships as a crickets command (developer-workflows) with three sub-verbs (author, translate, sequence). Deterministic work in tested Python helpers; sequence wires onto stage_plan.py. 0004 stays accepted — this is a divergent port, not a supersession. Why not skill packaging: crickets phase loop is uniformly commands; a skill splits the authoring step off the surface every other phase shares. Why not prompt-only: crickets leans on tested Python helpers; re-deriving harness paths in prompt prose would fork path logic. Re-audit triggers: sequencing ever writes or mutates the singleton PLAN.md; per-part naming collides with a hand-authored named plan.

0026 — Phase-aware model routing in developer-workflows (2026-06-14). Agent defs use model: frontmatter (enforced at spawn). Slash commands use a prompt-level nudge (advisory only). Routing: worker.md//work//bugfix → Opus; researcher.md/tech-lead.md//plan//review//design → Sonnet. All overridable per-session. Why not omit the nudge: makes the routing policy invisible at point-of-use. Why not route everything to Sonnet: /work//bugfix need the strong model; quality cliff on mis-route costs more than the premium. Re-audit triggers: host exposes a command-level model enforcement API; either named model is deprecated; the global ~/.claude/CLAUDE.md token-discipline block diverges from these defaults.

0029 — Concurrent-release coordination: tag-from-main, branch protection, single writer (2026-06-15). Three hardening layers: (1) check_tag_reachability.py gate in check-all.sh + CI (every tag must be reachable from main); (2) main branch protection (required CI + squash/rebase-only + no force-push + linear history); (3) /release is the sole tag creator — /work and /bugfix explicitly prohibit tag creation. Why not pre-tag guard only: defense-in-depth catches manually-created off-main tags. Why not merge-queue bot: unjustified overhead at solo/2–4-plan scale. Re-audit triggers: tag scan exceeds 1 s in practice; merge-queue bottleneck becomes observable.

0030 — Generated artifacts have a single writer: defer the version bump to the serialized integrator (2026-06-15). Workers commit src/ changes + regenerate dist/ at the current (unbumped) version — never touching group.yaml version or marketplace.json. The serialized integrator on main owns the bump + registry + final regen. dist-sync gate stays fully authoritative everywhere; version-bump gate becomes branch-aware (advisory on worker/ branches, authoritative on main). Why not per-plugin marketplace.json fragments: same-plugin concurrency still collides, adds fragment-assembly machinery. Why not merge=union driver: hides conflict by concatenating both sides, produces garbled registry entries. Why not defer regeneration too: weakens branch CI; a stale dist/ wouldn't surface a generation break until integration. Re-audit triggers: concurrency grows beyond 4–5 simultaneous landers; CI topology change makes the worker/ branch-name signal unreliable.

2026-06-23 — added a lifecycle-flow diagram (diagram backfill). Per the every-design-carries-a-diagram rule.

2026-06-23 — added an Opinions-it-consumes clause (portfolio backfill). Made explicit which opinions the loop requests by name (done + how-we-engineer) — a standard Design clause adopted across the capability designs.

2026-06-22 — authored, reviewed, and finalized.

The development-lifecycle capability — the loop a developer runs every day, plan → retirement. Formed by merging the standalone lifecycle capability into the renamed spine (developer-workflows → development-lifecycle): /launch, /deprecate, and a new /retire (which splits today's combined /deprecate into mark + remove) join the phase loop, since they are the tail of the development lifecycle, not a separate concern. The genuinely-distinct concerns still shed (/observe → diagnostics, design family → design, researcher → research; /ci-cd stays — it is pipeline authoring, part of the spine). The capability drops the -workflows suffix and the developer- prefix (the exception narrows to developer-safety).

Authored to the operator's structure and grounded against the live specs: a bread-and-butter Objective (no "spine"); a table Overview of the cycles first → retire; a Design of Development Lifecycle (four cross-cutting properties — determinism via helper scripts, gates-before-judgment, recoverable-by-default, runnable one-off/loop/goal — plus the two-layer durable-memory wiring, identical on disk with or without agentm), a separate Setup (one-time), Workflows (each cycle's entry / exit / automated / enhancements / artifacts-with-relative-paths, sisters linked), and Concurrency (operator-as-coordinator-today; named plans + worktrees; fan-out-N / integrate-single-writer; limitations; future aspirations). Built-vs-designed: /retire, per-task worktrees, the orchestration split, and the loop/goal drivers are designed-not-built; full per-phase authoring is a later pass. Re-audit triggers: split /retire out of /deprecate; flip the designed pieces as they ship; settle developer-safety → safety.