cohorte 1.3.3 → 1.4.0

package/profile/SCHEMA.md

@@ -162,7 +162,11 @@ Coarse first, specialize on evidence: start with one `frontend` / `backend` surf
 surface that's proven slow and cleanly separable. The evidence lives in
 the **main checkout's** `.claude/pipeline-metrics.jsonl` (gitignored) — one JSONL line per phase batch
 (`ts`/`feature`/`phase`/`seconds`/`surfaces:{key: result}`), appended by `/build`, `/review`, `/fix`
-and `/smoke`. Always the main checkout, never the feature worktree (which dies at teardown while
+and `/smoke`.
+**`surfaces` keys are surface keys, nothing else** — run-level facts go in their own top-level
+fields. Anything put inside `surfaces` is read
+as a surface: the dashboard renders it as a row in the per-surface table and scores a non-`ok`
+value as that surface failing. Always the main checkout, never the feature worktree (which dies at teardown while
 metrics must accumulate across features) — resolve from anywhere with
 `$(dirname "$(git rev-parse --git-common-dir)")/.claude/pipeline-metrics.jsonl`. Read it before
 proposing a split: split the surface that actually dominates wall-clock, not the one that feels big.
@@ -268,7 +272,9 @@ this exact procedure so a surface is always defined the same way. To add surface
      this feature also changes. The link is self-contained — no stored project id. Build with the code UI
      kit (the `design_system_project`'s materialization: `@/components/ui/*` + tokens); read a primitive
      via `get_file` only if it's missing/stale in code. Mobile-first."_
-   - `<SURFACE_TDD_STEP1>` — _"**Pull the feature design first** (skip if your dispatch's design slot
+   - `<SURFACE_TDD_STEP1>` — a **lead-in paragraph** above the TDD list (not a numbered item; it
+     renders as nothing for a non-design surface, which is why the list must not start at it):
+     _"**Pull the feature design first** (skip if your dispatch's design slot
      says `none`): `DesignSync get_file(<projectId>, <file>)` for each link in the slot and translate
      each into the code design system (`@/components/ui/*`, `cn()` + CVA), mobile-first — never ad-hoc
      CSS. Then:"_
@@ -318,14 +324,13 @@ Workflow runtime executes instead of the lead reasoning out the fan-out turn by
 `<core>/workflows/review.js`, `audit.js`, `refactor.js` (installed to `.claude/workflows/` bundled or
 `~/.claude/workflows/` global). The conversational commands (`/review`, `/audit`, `/refactor`)
 **remain the default path and the fallback** — a workflow runs only when the human explicitly asks
-for it ("run the review workflow", or via the `/cycle <id>` launcher command, which resolves
-`cycle.js` and invokes the runtime for them), and requires Claude Code ≥ **2.1.154** with workflows
+for it ("run the review workflow"), and requires Claude Code ≥ **2.1.154** with workflows
 enabled.
 `/doctor` reports which path a session will take. The interactive commands (`/init-pipeline`,
 `/brainstorm`, `/spec`) and the dispatch-only ones (`/build`, `/ship`) have **no** workflow variant on
 purpose: they're interviews or already a single parallel dispatch — a script adds nothing.
 
-Shared design, all three scripts:
+Shared design, all four scripts:
 
 - **Phase 0 is always `profile-reader`** — workflow scripts have no filesystem or shell access, so a
   dedicated agent (`core/agents/profile-reader.md`, haiku, read-only) reads `PIPELINE.md` and returns
@@ -336,6 +341,12 @@ Shared design, all three scripts:
 - **Only the verdict comes back.** Bulk (diffs, reports, backlogs) is staged to the same disk
   buffers the commands use (`specs/reports/`, `specs/refactor-backlog.md`); the workflow's return is
   counts + verdict + paths.
+- **A dead agent is never a clean result.** `agent()` resolves to `null` when a subagent dies, and a
+  dead *reviewer* returns zero findings — byte-identical to a surface that is genuinely clean. Any
+  script that derives a verdict from "how many findings came back" must first subtract the agents
+  that never answered: `review.js` names them in `unreviewedSurfaces` and refuses to score
+  `SHIP`. `scripts/test-workflows.mjs`
+  pins this — it is the one invariant the structural checks in `validate-core.mjs` cannot see.
 - **`review.js`** — preflight gate (aborts red, zero agents), one `git diff --stat` staged per
   touched surface, one reviewer per surface in parallel, then an **adversarial cross-check** phase
   that tries to refute each CRITICAL/security finding before it can trigger a fix loop.
@@ -344,27 +355,9 @@ Shared design, all three scripts:
 - **`refactor.js`** — big domains only (it skips domains with a handful of open items — the
   conversational `/refactor` is cheaper there): `shared` first and alone, then the other domains'
   implementers in parallel, each verified per-domain.
-- **`cycle.js`** — the **full dev cycle** on a frozen spec: contract → parallel build → rounds of
-  [preflight → smoke ∥ review(+cross-check) → fix on the surfaces with findings], looping until
-  **zero open findings + a PASS smoke** (`maxRounds`, default 5, and the token budget are runaway
-  protection, not targets). Since a workflow can't ask anything mid-run, the decisions move to the
-  edges: a **readiness gate** aborts up front if the spec isn't frozen (other gaps ride along as
-  deferred questions), and everything genuinely human comes back at the END in the result's
-  `questions` array — empty when `/brainstorm` + `/spec` did their job. Even a finding that implies
-  a **contract change stays inside the loop**: a lead-equivalent agent re-authors spec §5 + the
-  contract file (exactly what conversational `/fix` §1 does — implementers still never touch it),
-  the consuming surfaces re-dispatch, and the loop continues; the re-authorings are reported in the
-  result's `contractChanges` for the human to review in the diff. A clean exit ticks the DoD and
-  stamps the freshness gate so `/ship <id>` is a straight shot; a stopped run appends its open
-  findings to the spec's `## Remediation` so a rerun of the cycle — or a conversational `/fix` —
-  continues seamlessly. `/ship` itself stays outside on purpose — outward-facing and irreversible,
-  it keeps its human confirmation.
-  **Corollary — harden the spec:** the more `/brainstorm` + `/spec` pre-answer (edge cases, error
-  envelopes, role matrix, design links), the further the cycle runs and the emptier `questions`
-  comes back; a vague spec just converts into deferred questions.
 - **No input mid-run.** A workflow runs to completion without questions; anything interactive
-  (contract changes, human decisions) belongs to the conversational path — or, for `cycle.js`, to
-  the `questions` array of its result. The gate hook still fires on workflow subagents (see
+  (contract changes, human decisions) belongs to the conversational path. The gate hook still
+  fires on workflow subagents (see
   §Preflight) — in unattended runs its asks become denies.
 - **Permissions:** `/init-pipeline` and `/update-pipeline` extend the generated `settings.json`
   `allow` list with what workflow agents need (the quiet commands, the shipped
@@ -416,7 +409,7 @@ card created in the target column if missing.
 | `/spec` opens (draft)                   | `spec`          |
 | `/spec` freezes (`status: frozen`)      | `ready`         |
 | `/build`                                | `building`      |
-| `/smoke` · `/review`                    | `review`        |
+| `/review` (owns the move — `/smoke` never moves the card) | `review`        |
 | `/fix`                                  | `fix`           |
 | `/ship` starts                          | `ship`          |
 | PR opened (`status: shipped`)           | `shipped` (+ `PR #<num>` on the card) |
@@ -457,6 +450,10 @@ see where features stall, so every stage of `idea → PR` reports and nothing el
 | `fix` | after the batch metrics line | wall-clock | `<fixed>/<found>` |
 | `ship` | the release agent succeeded | `0` | `pr` / `compare` |
 
+> Workflow-variant runs (`review.js`) report `seconds: 0` for their phases — only the
+> conversational commands measure wall-clock. `results` is a free-text summary field, so both
+> forms are valid — but read the `fix` column knowing which path produced it.
+
 `seconds: 0` marks a phase whose duration is human thinking time, not pipeline wall-clock — the
 funnel signal there is the event, not how long it took. `/doctor`, `/audit`, `/refactor`,
 `/align-ds`, `/init-pipeline` and `/update-pipeline` **never** ping: they sit outside the funnel, and

package/scripts/kanban-move.sh

@@ -28,28 +28,44 @@ done
 
 tmp="${board}.kanban-move.$$"
 ID="$id" COL="$col" PR="$pr" TITLE="${title:-$id}" awk '
+  # Emit one line, collapsing runs of blank lines to a single one. Without this
+  # every move netted +1 blank line in the target column (the card is inserted
+  # with its own separator, right after the blank that already preceded the next
+  # heading) — ten moves of one card padded a board with fifteen blank lines.
+  function emit(s) {
+    if (s == "") { if (lastblank) return; lastblank = 1 } else lastblank = 0
+    print s
+  }
+  function put_card(   k) {
+    emit(card)
+    for (k = 1; k <= sn; k++) emit(snote[k])
+  }
   BEGIN {
     id = ENVIRON["ID"]; col = tolower(ENVIRON["COL"])
     pr = ENVIRON["PR"]; title = ENVIRON["TITLE"]
-    n = 0; card = ""; incard = 0; found = 0; colseen = 0
+    n = 0; card = ""; found = 0; colseen = 0; sn = 0; lastblank = 0
   }
   { lines[++n] = $0 }
   END {
     # pass 1: extract the FIRST card block tagged #id; mark every block for removal
     for (i = 1; i <= n; i++) {
       l = lines[i]
-      if (l ~ /^- \[.\] / && index(l, "#" id) > 0) {
-        # word-boundary check: char after the tag must not extend the id
-        rest = substr(l, index(l, "#" id) + length(id) + 1, 1)
-        if (rest != "" && rest ~ /[A-Za-z0-9_-]/) continue
-        del[i] = 1
-        if (!found) { found = 1; card = l }
-        for (j = i + 1; j <= n && lines[j] ~ /^[ \t]/; j++) {
-          del[j] = 1
-          if (found && card == lines[i]) sub_notes = sub_notes lines[j] "\n"
-        }
-        i = j - 1
+      if (l !~ /^- \[.\] /) continue
+      p = index(l, "#" id)
+      if (p == 0) continue
+      # word-boundary check: char after the tag must not extend the id
+      rest = substr(l, p + length(id) + 1, 1)
+      if (rest != "" && rest ~ /[A-Za-z0-9_-]/) continue
+      # Capture the sub-notes of the FIRST match only. Testing `card == lines[i]`
+      # instead also captured a later duplicate whose text happened to match.
+      isfirst = 0
+      if (!found) { found = 1; card = l; isfirst = 1 }
+      del[i] = 1
+      for (j = i + 1; j <= n && lines[j] ~ /^[ \t]/; j++) {
+        del[j] = 1
+        if (isfirst) snote[++sn] = lines[j]
       }
+      i = j - 1
     }
     if (!found) card = "- [ ] " title "  #" id
     if (pr != "" && index(card, "PR #") == 0) card = card " — PR #" pr
@@ -63,22 +79,20 @@ ID="$id" COL="$col" PR="$pr" TITLE="${title:-$id}" awk '
       atheading = (l ~ /^## /)
       atsettings = (l ~ /^%% kanban:settings/)
       if (intarget && (atheading || atsettings)) {
-        # back up over trailing blank lines already printed is not possible;
-        # instead print card just before this boundary
-        print card
-        if (sub_notes != "") printf "%s", sub_notes
-        print ""
+        # can not back up over already-printed lines; place the card just before
+        # this boundary instead
+        put_card()
+        emit("")
         intarget = 0; placed = 1
       }
       if (atheading) {
         h = tolower(l); sub(/^## +/, "", h); gsub(/ +$/, "", h)
         if (h == col) { intarget = 1; colseen = 1 }
       }
-      print l
+      emit(l)
     }
     if (intarget && !placed) {
-      print card
-      if (sub_notes != "") printf "%s", sub_notes
+      put_card()
       placed = 1
     }
     if (!colseen) exit 3