feat(board): E1 implement lane split — Architect / Implementer relay (v7.30.0)

.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "doperpowers",
       "description": "Emerges by humans, Converges by Agent",
-      "version": "7.29.0",
+      "version": "7.30.0",
       "source": "./",
       "author": {
         "name": "SSFSKIM",

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "doperpowers",
   "description": "Emerges by humans, Converges by Agents",
-  "version": "7.29.0",
+  "version": "7.30.0",
   "author": {
     "name": "SSFSKIM",
     "email": "supremekim17@gmail.com"

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "doperpowers",
-  "version": "7.29.0",
+  "version": "7.30.0",
   "description": "A two-track software-development methodology for coding agents: a human-gated controlled track (brainstorm, plan, TDD, review, ship) plus an autonomous board loop for unattended, well-scoped work.",
   "author": {
     "name": "SSFSKIM",

README.md

@@ -26,7 +26,7 @@ Both tracks enforce the same non-negotiables — design before code, tests befor
 The agent refuses to jump straight to code. It interviews you (`brainstorming`), turns the conversation into a living design spec (`execspec`), breaks that into tasks small enough for an unsupervised junior to follow (`writing-plans`), then executes each one through a fresh subagent with two-stage review — spec compliance, then code quality (`subagent-driven-development`). You approve each gate.
 
 **Autonomous** — for work that's already well-scoped.
-A single self-contained plan (`execplan`) front-loads every decision so the agent can run to the letter without mid-flight questions. At larger scale, the board loop takes over: tickets live as GitHub issues (`issue-tracker`), workers pick them up and build (`implementing-tickets`), a review loop lands the PRs (`reviewing-prs`), and durable background sessions keep it all running (`orchestrating-daemons`). Product feedback can even feed the board directly (`triaging-feedback`).
+A single self-contained plan (`execplan`) front-loads every decision so the agent can run to the letter without mid-flight questions. At larger scale, the board loop takes over: tickets live as GitHub issues (`issue-tracker`), workers pick them up and build (`implementing`), a review loop lands the PRs (`reviewing-prs`), and durable background sessions keep it all running (`orchestrating-daemons`). Product feedback can even feed the board directly (`triaging-feedback`).
 
 ---
 
@@ -84,7 +84,7 @@ Twenty-one skills, grouped by what they're for. Each one auto-triggers from its
 
 **Run it unattended**
 - `issue-tracker` — the board, backed by GitHub issues
-- `implementing-tickets` — dispatch workers onto tickets, gate before building
+- `implementing` — dispatch workers onto tickets, gate before building
 - `reviewing-prs` — the autonomous PR-review and self-merge loop
 - `orchestrating-daemons` — durable background sessions that survive the session ending
 - `triaging-feedback` — turn product feedback into grounded board tickets

docs/doperpowers/plans/2026-07-31-implement-lane-split.md

@@ -133,8 +133,8 @@ pre-park) comes in later tasks — this task only renames and re-tables.
 Replace lines 19–36 (`OPEN_STATES` through `PULLABLE`) with:
 
 ```python
-# ── state vocabulary (v9: the E1 lane split — ready-for-agent split into
-#    ready-for-architect / in-design / ready-for-implementer) ──
+# ── state vocabulary (v9: the E1 lane split — the single pre-v9 agent queue
+#    split into ready-for-architect / in-design / ready-for-implementer) ──
 OPEN_STATES = ("ready-for-architect", "in-design", "ready-for-implementer",
                "in-progress", "needs-human", "needs-info",
                "interactive-preferred", "in-review", "confident-ready",
@@ -367,10 +367,13 @@ existing recovery/cancel/relay behavior. Fix any missed rename site the
 failures name (the suites are the enumerator; the grep in Step 8 is the
 proof).
 
-- [ ] **Step 8: Residual-vocabulary check (board area)**
+- [ ] **Step 8: Residual-vocabulary check (board scripts + suites)**
 
-Run: `grep -rn "ready-for-agent" skills/issue-tracker/ tests/issue-tracker/ | grep -v board-migrate-gh.sh`
-Expected: no output.
+Run: `grep -rn "ready-for-agent" skills/issue-tracker/scripts/ tests/issue-tracker/ | grep -v board-migrate-gh.sh`
+Expected: no output. (`skills/issue-tracker/SKILL.md` and
+`references/ticket-gate.md` still carry the old vocabulary at this
+point — their content rewrite is Task 13's; Task 16's repo-wide grep is
+the final proof.)
 
 - [ ] **Step 9: Commit**
 
@@ -833,7 +836,7 @@ section, after the existing RECOVER block:
 # RECOVER — lane-state split (E1): in-flight design work resumes; a dead
 # pre-verdict worker is retired so the dispatch pass re-runs it fresh
 assert_contains "$log" "resume:aaaa0020-0000-4000-8000-000000000000" "dead in-design worker gets the resume ladder (mid-design WIP is preserved)"
-assert_contains "$out" "resume attempt 1/" "in-design recovery goes through _recover's counted ladder"
+assert_contains "$out" "RECOVER: #20 worker aaaa0020-0000-4000-8000-000000000000 died mid-turn (session gone) — resume attempt 1/3" "in-design recovery goes through _recover's counted ladder"
 assert_contains "$log" "retire:aaaa0021-0000-4000-8000-000000000000" "dead ready-for-architect worker is retired, not resumed"
 assert_contains "$out" "pre-verdict worker" "retire log names the pre-verdict rule"
 assert_not_contains "$log" "resume:aaaa0021" "pre-verdict recovery never resumes"
@@ -1280,8 +1283,8 @@ Insert a new section between `## Role` and `## The Gate`:
 ```markdown
 ## Mode Selection
 
-Read your ticket's `board:meta` block first. The `plan:` field decides
-your mode — machine-read, never note prose:
+MODE SELECTION — read your ticket's `board:meta` block first. The
+`plan:` field decides your mode — machine-read, never note prose:
 
 - `plan: <path>@<sha>` → **PLAN-EXECUTION**: an Architect authored your
   plan at that immutable revision on the recorded branch. NO intake
@@ -1448,8 +1451,13 @@ VERDICT IS YOUR FIRST BOARD WRITE. Dispatch wrote nothing.
 - Fail → the park state with its required note, classified against the
   park discriminant (doperpowers:issue-tracker owns the single copy),
   plus the 3–6 line orientation summary every park carries.
-- Too big (Check-2) → decompose (below). Slices needing one continuously
-  steered human context → interactive-preferred.
+- Too big (Check-2) → take the Pass write first — `in-design` plus the
+  gate comment "[gate] pass — architect: too big, decomposing" — then
+  decompose (below). Decomposing is design work and its exit is an
+  in-design exit; the board has no `ready-for-architect →
+  ready-for-implementer` edge, so skipping this write leaves you with no
+  legal move. Slices needing one continuously steered human context →
+  interactive-preferred.
 
 ## Design
 
@@ -1658,7 +1666,9 @@ edge on one ticket converts to `needs-human` mechanically.
 7. Worker protocols section (lines 239–248): name three protocols
    (architecting SKILL.md added; implementing paths renamed).
 8. Consumer-automation edge case (line 315–319): "must track the v9
-   vocabulary (the lane states replace `status:ready-for-agent`)".
+   vocabulary (the two lane-queue labels replace the single pre-v9
+   agent-queue label)" — phrased WITHOUT the retired literal, so the
+   repo-wide grep in Task 16 needs no carve-out for live skill prose.
 
 - [ ] **Step 3: The three implementing references** — apply the rename
 decision rule: `implement-decompose.md` step 3's `ready-for-agent` →
@@ -1670,8 +1680,9 @@ to `ready-for-implementer`".
 
 - [ ] **Step 4: Verify no stale vocabulary in skills**
 
-Run: `grep -rn "ready-for-agent" skills/ | grep -v board-migrate-gh.sh`
-Expected: no output.
+Run: `grep -rn "ready-for-agent" skills/issue-tracker/ skills/implementing/ skills/architecting/ | grep -v board-migrate-gh.sh`
+Expected: no output. (Scoped to THIS task's skills — `skills/triaging-feedback/`
+is Task 14's, and Task 16's repo-wide grep is the final proof.)
 
 - [ ] **Step 5: Run the full local suites** (docs changes can break
 protocol-content assertions):
@@ -1764,10 +1775,13 @@ against the pinned plan plus the issue body together.
 paragraph (line ~159), after "the `[gate] pass` timestamp", insert:
 
 ```markdown
-On a ticket whose meta carries a `plan:` pin there is no implementer
-`[gate] pass` — the authorization time is the Architect's handoff: the
-`[board] ready-for-implementer:` comment's timestamp. Every rule in
-this audit keyed to the gate timestamp reads that comment instead.
+On a ticket whose `plan:` pin names a revision (`<path>@<sha>`, not the
+`pre-spec` sentinel) there is no implementer `[gate] pass` — that ticket
+ran in PLAN-EXECUTION mode, which posts none. The authorization time is
+the Architect's handoff: the `[board] ready-for-implementer:` comment's
+timestamp, and every rule in this audit keyed to the gate timestamp
+reads that comment instead. A `plan: pre-spec` ticket ran DIRECT and
+carries a real `[gate] pass` — anchor on it as usual.
 ```
 
 - [ ] **Step 3: Missing-section rule** (line ~205): change "only when
@@ -1791,10 +1805,27 @@ Otherwise — an impasse that needs human judgment or input — set the
 ticket to needs-human with the impasse summary and end your turn.
 ```
 
+The `ready-for-architect` branch ends the turn too — say so on that
+branch, so neither exit reads as fall-through.
+
 In AUTHORITY (line ~326), change the parenthetical to
 "(confident-ready / needs-human / ready-for-architect — notes required
 for the parks and the escalation)".
 
+- [ ] **Step 4b: The two rules the new lane makes incomplete** — both
+outside the five sites above, both load-bearing:
+
+ORIENT (line ~65) tells the worker to locate the `[gate] pass` comment
+as the authorization time. A real-pin ticket has none — add the
+handoff-comment alternative here, matching the Step 2 anchor rule, so
+the read-only pass doesn't come up empty.
+
+ESCALATE's PARKED tier (line ~332) enumerates the states over which
+confident-ready may never be granted, and names only `needs-human`.
+Extend it to cover a ticket just set to `ready-for-architect` by the
+Step 4 impasse route — without this the new escalation has no
+confidence-tier protection behind it.
+
 - [ ] **Step 5: TOO-BIG registration** (line ~236): after the
 `board-register.sh` command line, add: "Birth classification applies:
 the default is `ready-for-implementer`; a finding that is missing DESIGN
@@ -1840,10 +1871,17 @@ Expected: no output. Same for
 (`tests/review-bench/results/` is frozen benchmark output holding both
 old vocabularies — excluded, never rewritten.)
 
+Two live residuals are known to remain here, both in the third argument
+(the human-readable test description) of assertions in
+`tests/implementing/test-protocol-content.sh` — the asserted strings
+themselves are already correct. Rename the descriptions to the lane
+vocabulary they now describe, then re-run the grep to no output.
+
 - [ ] **Step 3: Version bump (minor — new states + skill split are a
 feature release)**
 
-Run: `scripts/bump-version.sh minor`
+Run: `scripts/bump-version.sh 7.30.0` (the script takes an explicit
+target version, not a bump keyword; current is 7.29.0)
 Expected: manifests updated to 7.30.0 per `.version-bump.json`.
 
 - [ ] **Step 4: Commit**

docs/doperpowers/specs/2026-07-30-implement-lane-split-design.md

@@ -726,13 +726,136 @@ route independently.
   neutral state rules survived contact with reality; cross-roadmap
   timing promises did not.
   Evidence: board state 2026-07-31; the amended sequencing paragraph.
+- Discovery: the two `plan:` pin values are not one concept with two
+  spellings. A real `<path>@<sha>` pin is an AUTHORIZATION EVENT — it
+  routes the Implementer to PLAN-EXECUTION, which posts no `[gate] pass`,
+  so the Architect's handoff comment becomes the review loop's timestamp
+  anchor. The `pre-spec` sentinel is a PLAN-NEED RULING — the ticket
+  still runs DIRECT, still gates, still posts a real `[gate] pass`. Two
+  rules written during implementation keyed on "carries a `plan:` pin"
+  and were silently wrong for the sentinel case. Any future rule reading
+  the pin must say which of the two it means.
+  Evidence: Task 15 review; skills/implementing/SKILL.md Mode Selection
+  and Verdict; plan revision d004728.
+- Discovery: the retrospective's own lesson — "generalizing a hardcode
+  means owning its accidental guarantees" — recurred during
+  implementation, twice, in the same shape. The park-return target was
+  hardcoded `in-progress`, which happens to be the one in-flight state
+  with no entry precondition; generalizing it via `PRE_PARK` routed
+  review-loop parks back to `in-review`, whose PR gate then rejected
+  every answer relay. The convergence reset was keyed to an `[answers]`
+  comment that only the inline-answer path posts; generalizing the relay
+  to the sweep's `--posted` path meant the reset marker stopped being
+  written. Neither was caught by a task-scoped review — both spanned a
+  script boundary — and both were found by the whole-branch pass. The
+  lesson generalizes further than the spec applied it: when a constant
+  becomes a lookup, enumerate what the constant's VALUE guaranteed, not
+  just what the lookup must now return.
+  Evidence: whole-branch review findings C1 and I1; commits 4f1111e,
+  21435dd, and their before/after reproductions.
 
 ## Outcomes & Retrospective
 
-Pending — written at finish.
+Shipped as v7.30.0 (17 planned tasks plus a review-driven fix pass;
+implementation plan `docs/doperpowers/plans/2026-07-31-implement-lane-split.md`).
+
+**Against the purpose.** The state-machine half of the goal landed whole.
+`ready-for-agent` is gone rather than aliased; `ready-for-architect`,
+`in-design`, and `ready-for-implementer` carry the relay; the `plan:` pin
+routes an Implementer to PLAN-EXECUTION or DIRECT without the dispatcher
+making a judgment call; and a design gap discovered downstream now has a
+named address — the Implementer's gate, the Implementer mid-build, and the
+review loop can each hand a ticket back to the architect lane instead of
+leaking it into `needs-human`. The convergence rule bounds that with no
+new bookkeeping: the comment log is the counter.
+
+**The model economics are enforced on both sides.** The architect route
+hard-pins `${ARCHITECT_MODEL:-fable}` and ignores `engine:*` labels, so
+"every dispatched plan is Fable-authored" is structural. The implement and
+spike routes pin `${IMPLEMENT_MODEL:-opus}` on the plain-Claude route.
+That second pin was raised at review time as the branch's one unclosed
+half — the route had inherited the operator's session model since #35, so
+an operator running the frontier model by default would silently pay
+frontier rates on both lanes and re-fuse the two economies this split
+exists to separate. The human resolved it in favor of the pin, and it
+landed with the branch: both lanes now pin rather than inherit, and
+acceptance criterion 2's "spawns an Opus worker" is a property of the
+dispatcher rather than an operational convention.
+
+**What the branch could not prove.** Four of the eight acceptance criteria
+are only partially verified. Dispatch wiring — which role, which model,
+which protocol file — and the protocol text a worker reads are provable
+statically, and are proven. A dispatched worker's actual runtime behavior
+is not, and no test here substitutes for the first live architect
+dispatch. Criterion 5 (the QAgent model pin and the fix-wave agent) is
+deferred to a follow-up by design.
+
+**Lessons.**
+
+1. *Generalizing a hardcode means owning its accidental guarantees* — the
+   v1.2 round's own lesson, which then recurred twice during
+   implementation, in the same shape, undetected by task-scoped review.
+   The park-return target and the convergence reset were both constants
+   whose specific values had silently satisfied a precondition elsewhere;
+   turning each into a lookup broke the precondition. Both defects spanned
+   a script boundary, which is exactly what a per-task reviewer cannot
+   see. The sharper form of the lesson: when a constant becomes a lookup,
+   enumerate what the constant's VALUE guaranteed, not just what the
+   lookup must now return.
+2. *A whole-branch review is not a formality when the change is a state
+   machine — and one whole-branch review is not enough.* Every task passed
+   its own review; the first merge blocker was found only by the pass that
+   read all 33 commits at once. Then an independent second review found
+   seven more, three of them the same class the first pass had explicitly
+   cleared — it reported "every prose-instructed edge legal, no trapped
+   states" while a spike in the architect lane had no legal move, the
+   epic pull wrote a forbidden edge, and a resumed Architect landed in a
+   state its protocol cannot exit. A reviewer's clean bill on a state
+   machine is a hypothesis, not evidence. The cheapest way to test it is
+   a reviewer that shares none of the first one's framing.
+3. *An escalation is only as real as its return path.* Every new
+   escalation edge in this design was checked for legality and for
+   convergence, and one was never checked for RESUMPTION: the review
+   loop's hand-off to the architect lane had no mechanism that could ever
+   bring a reviewer back, so it silently converted "park for the human"
+   into "abandon the PR". Adding a state transition is not the same as
+   adding a state to the machine — the new state needs an owner, an exit,
+   and something that fires the exit.
+4. *Two spellings of one field are two concepts.* The `plan:` pin's real-
+   SHA and `pre-spec` values look like variants and are not: one is an
+   authorization event, the other a plan-need ruling. Two rules written
+   during implementation keyed on "has a pin" and were wrong for the
+   sentinel. Recorded in Surprises; any future rule reading the pin must
+   say which value it means.
+5. *Prose that instructs a worker needs the same pinning as code.* The
+   new review-loop rules shipped unpinned until the acceptance pass caught
+   it, while the equivalent implementing and architecting text had
+   assertions from the start. In this repo a protocol sentence is
+   behavior, so an unpinned one is untested behavior.
 
 ## Revision Notes
 
+- 2026-07-31: v1.3.3, the implement lane pins its model. The plain-Claude
+  implement/spike route now pins `${IMPLEMENT_MODEL:-opus}` instead of
+  inheriting the operator's session model (the posture #35 set when it
+  flipped that route off the clodex gateway). Raised by the whole-branch
+  review as the branch's one unenforced half — the split's whole argument
+  is asymmetric model routing, and only the architect side was structural
+  — and resolved by the human in favor of symmetry with
+  `${ARCHITECT_MODEL:-fable}`. The codex route's own default (`fable`,
+  the gateway alias) is unchanged, and `IMPLEMENT_MODEL` still overrides
+  both. Acceptance criterion 2 becomes statically verifiable.
+- 2026-07-31: v1.3.2, implementation-pass corrections (all found by
+  review during execution, all landed on the branch): transition 6's
+  convergence note no longer promises "both sides' positions" — it
+  carries this traversal's position plus a pointer to the comment trail,
+  because the mechanical substitution only ever had one; the reset now
+  also fires on the sweep's relay path, where `--posted` previously
+  posted no `[answers]` marker at all and a human-authorized
+  re-traversal therefore re-converted to `needs-human` (a livelock);
+  transition 7's `needs-human → in-review` return is legal without
+  re-supplying `--pr`, since generalizing the old hardcoded `in-progress`
+  return had silently inherited that state's freedom from the PR gate.
 - 2026-07-31: v1.3.1, planning-pass drift fixes (implementation plan =
   `docs/doperpowers/plans/2026-07-31-implement-lane-split.md`, lands as
   v7.30.0): board-lint gains vocabulary only — edge-note enforcement is

package.json

@@ -1,6 +1,6 @@
 {
   "name": "doperpowers",
-  "version": "7.29.0",
+  "version": "7.30.0",
   "description": "Doperpowers skills and runtime bootstrap for coding agents",
   "type": "module",
   "main": ".opencode/plugins/doperpowers.js",