cohorte 2.8.0 → 2.10.0

package/CHANGELOG.md

@@ -7,6 +7,78 @@ short, user-facing, most recent first. One `## <version> — <YYYY-MM-DD>` secti
 > They are history and are deliberately not rewritten — every command gained a `cohorte-` prefix
 > in 2.0.0.
 
+## 2.10.0 — 2026-08-24
+
+- **The dashboard is gone.** The local web cockpit — the `cohorte dashboard` verb, the
+  dependency-free HTTP server, the Vite/React app and the prebuilt `dashboard/dist` that shipped
+  in every tarball — is removed, along with the fleet registry, kanban and usage readers that
+  only it consumed. It was a second surface for state the CLI already reports, with its own
+  build step, its own security posture (loopback-bound because its action endpoints executed
+  code: install, update, reset, and `/cohorte-init-pipeline`·`/cohorte-update-pipeline`·`/cohorte-audit`
+  through headless Claude), and its own drift to police. `cohorte doctor`, `cohorte specs` and
+  `cohorte metrics` answer the same questions from the shell, and `doctor` exits 1 on any bad
+  check, which the browser never could.
+
+  **What did not go with it:** the four modules those verbs actually run on — the JS port of
+  `/cohorte-doctor`, the runtime-layout resolver, the version prober and the block-YAML parser —
+  moved from `dashboard/server/` to **`lib/`**. `cohorte doctor` / `specs` / `version` behave
+  exactly as before, and so do the Francois extension's `--panel` payloads. Their test suite
+  moved with them (`scripts/test-dashboard.mjs` ⇒ `scripts/test-lib.mjs`, 54 assertions), minus
+  the cases that covered deleted code.
+
+  Fallout worth naming: the package no longer has a build step at all (`prepack` and
+  `build:dashboard` are gone, npm and CI no longer build a React app to publish), the tarball
+  drops from 88 files to 73, and `~/.claude/cohorte-dashboard.json` — the tracked-project list —
+  is now dead; delete it. `--port` / `--host` / `--open` and `COHORTE_DASHBOARD_PORT` /
+  `COHORTE_DASHBOARD_HOST` no longer exist; `cohorte dashboard` prints the usage and exits 2.
+
+## 2.9.0 — 2026-08-22
+
+- **`/cohorte-intake` — the door before the doors.** Work has always entered the pipeline
+  pre-distilled by a human: a ticket became a `/cohorte-patch` paste, an email became a
+  brainstorm idea, by hand. Intake does the distillation: paste anything that arrives and it
+  triages — bug ⇒ the exact structure patch interviews for (inferred repro steps labeled as
+  such); feature ⇒ a brainstorm seed whose open-questions list is the panel's agenda, with any
+  `_decisions.md` line it contradicts named; noise ⇒ says so and stops, because inventing a
+  spec from noise costs a whole pipeline run downstream. The distillate lands on disk and on
+  the kanban's Ideas column; freezing anything stays the human's move.
+
+- **`/cohorte-retro` — the pipeline learns from its own findings.** Every review leaves
+  structured residue (verdict.json, the specs' Remediation history, the deferred backlog) that
+  nothing ever read back. Retro mines it for patterns — the same finding kind on the same
+  surface across features, a hotspot module, a recurring fix family — and turns each into ONE
+  rule-shaped §Conventions line the human ratifies. Adopted rules re-render the affected
+  surface agents (the conventions slice is baked at render time — a rule without a re-render
+  is one reviewers enforce and implementers never saw) and land in the decisions journal.
+  Findings → rules → the next build never produces the finding: cheaper than any number of
+  review rounds catching it.
+
+- **`/cohorte-fleet` — parallel features get a flight controller.** The worktree isolation
+  existed; the coordination lived in your head. `plan` builds the feature×surface overlap
+  matrix from the specs themselves (contract dependencies ⇒ merge order; same-tree writes ⇒
+  serialize or drop one), provisions the worktrees, and prints one launch line per feature.
+  `status` is one row per feature ending in the single next action. `sync` does the post-merge
+  sweep everyone forgets — rebase every survivor, report conflicts verbatim to their owner's
+  session, and say out loud that a rebase invalidates the freshness stamp. What it will never
+  do is spawn the work headless: that is the retired 2.2.0 driver's grave, and each feature's
+  loop keeps running in its own supervised session.
+
+- **`/cohorte-review --pr <num>` — the pipeline reviews incoming work.** Same reviewers, same
+  report, none of the pipeline's certifications: the PR is fetched into a throwaway worktree
+  (your checkout untouched), reviewed in audit mode (no spec to conform to), and a red
+  preflight makes the mechanical failures the review instead of wasting reviewers on code that
+  doesn't compile. Posting the report as a PR comment always asks first — it is outward-facing
+  — and declining leaves the report on disk as a complete outcome.
+
+- **What a feature costs, finally on the dashboard.** The workflow paths now stamp an
+  approximate `tokens` field into their metrics lines from the runtime's own counter
+  (`budget.spent()` deltas — the figure a conversational lead cannot read), the loop's history
+  carries cost per round, and the dashboard shows `~Nk tok` per feature and per phase. Marks
+  are placed around the review child so build/fix deltas never double-count it; token-less
+  conversational lines aggregate as absent, never as "free".
+
+
+
 ## 2.8.0 — 2026-08-22
 
 - **`/cohorte-loop` is back — as a workflow, which is the whole point.** The 2.2.0 driver was

package/README.md

@@ -24,6 +24,37 @@ Cursor, Gemini CLI or OpenCode. Install it once globally, then one command per p
   /cohorte-brainstorm → /cohorte-spec → (design) → /cohorte-build <id> → /cohorte-review → (/cohorte-fix) → /cohorte-ship
   ```
 
+<div align="center">
+  <img src="https://raw.githubusercontent.com/TheBidouilleAgency/cohorte/main/assets/demo-cli.gif" alt="cohorte doctor reporting a green pipeline, the spec board, and the gate denying a chained destructive command" width="760">
+  <br>
+  <sub><code>cohorte doctor</code> · the spec board · the gate refusing a hard-denied command chained behind a benign one.<br>
+  Recorded from the real CLI by <code>scripts/demo/record-cli.sh</code> — no output is hand-edited.</sub>
+</div>
+
+## Why a pipeline at all
+
+Your coding agent is already good at the first prompt of a feature. It gets worse at every one
+after — because what it knows lives in a conversation, and a conversation gets summarised,
+truncated, and re-sent at input price on every turn. Cohorte is the set of constraints that stop
+that degradation. Each one is a failure you have already had:
+
+| The failure | The constraint |
+| --- | --- |
+| *"It forgot what we decided."* | The spec is **frozen to disk** and re-read by every stateless agent. Nothing is remembered, so nothing is forgotten — and `/clear` between stages is always safe. |
+| *"The API and the UI don't fit."* | The **contract is authored before any implementer is dispatched**. Surfaces import it read-only and never talk to each other — which is what makes building them in parallel safe. |
+| *"It edited a file I didn't want it to."* | **One owner per tree**, enforced in the rendered agent's frontmatter — not requested politely in a prompt. |
+| *"It ran something it shouldn't have."* | `gate.py` is a **real blocking hook**, branch-aware, hard-denying destructive commands from every agent — subagents included. |
+| *"The review said it was fine."* | Review is a **separate read-only agent** that sees the spec and the diff, never the conversation that produced them. A dead reviewer's zero findings can't read as ship. |
+| *"Four agents just told me it doesn't compile."* | A **deterministic preflight** runs typecheck/lint/tests first. Red ⇒ **zero agents spawned**. |
+| *"We fixed this same thing last week."* | `/cohorte-retro` turns repeated findings into ratified conventions **baked into the implementers**, so the next build never produces them. |
+
+None of this is intelligence added to your agent — it's the opposite. It moves the decisions an
+agent makes badly under context pressure into files, hooks and ownership boundaries, where they're
+cheap and don't degrade with conversation length. Which is why it's markdown, shell and one Python
+hook: **your app code never imports anything from Cohorte.**
+
+[**The long version — including the four cases where you shouldn't use it →**](https://thebidouilleagency.github.io/cohorte/guide/why-cohorte)
+
 ## How it works — three layers
 
 | Layer | What it holds | Lives in | Scope |
@@ -206,45 +237,6 @@ decisions), surface agents are re-rendered, settings are patched additively, new
 wired. **`/cohorte-init-pipeline` is one-time per project** — after init, `/cohorte-update-pipeline` is the only
 maintenance command you ever run (`/cohorte-build` auto-grows surfaces as specs need them).
 
-## Dashboard — a local web cockpit
-
-A browser view of pipeline state, for when a checklist beats scanning files:
-
-```sh
-cohorte dashboard          # serves http://localhost:4317 (Ctrl-C to stop)
-cohorte dashboard <path>   # start focused on another project
-cohorte dashboard --port=4400 --open   # custom port, open the browser
-```
-
-**Bound to `127.0.0.1` by default** — the dashboard's actions execute code (install/update/reset,
-and `/cohorte-init-pipeline`·`/cohorte-update-pipeline`·`/cohorte-audit` via headless Claude), so it must stay on loopback. Each user
-runs their own agent and drives only their own machine. `--host=0.0.0.0` exposes it to the network
-(it prints a security warning) — only on a trusted network, since anyone who reaches the port can run
-those actions.
-
-- **Fleet overview** — the global core version vs npm latest, plus every tracked project's freshness
-  and health at a glance. Add a project by absolute path or with the **folder picker** (Browse…); the
-  set is remembered in `~/.claude/cohorte-dashboard.json`.
-- **Per-project drill-down** — Freshness (installed core vs npm), `/cohorte-doctor` rendered as a live
-  ✅/⚠️/❌ checklist (each failure with its fix), the **Surfaces ↔ agents** map from `PIPELINE.md`,
-  and one board: a **Kanban** if the project has a linked Obsidian board (columns + cards from the
-  vault, with clickable PR links + live open/merged/closed status and a ship-date-sorted Shipped
-  column, via `gh`), otherwise a **Specs board** from `specs/*.md` (by `draft · frozen · in-progress ·
-  in-review · blocked · shipped`). The Kanban supersedes the Specs board when both would apply.
-- **Actions** (stream their output live) — **Update / Install core** (the shared global core, or a
-  repo's bundled core); **Init-pipeline / Update-pipeline / Audit**, which run those Claude Code
-  commands **headless** (`claude -p`, autonomous — Init skips the interactive interview, so review
-  the result; Audit writes `specs/refactor-backlog.md`; headless runs start without any prompt and
-  have **no resume** if the session dies); and **Reset pipeline**, which backs up then wipes a
-  project's pipeline footprint and reinstalls a fresh core. Buttons render only when they apply
-  (e.g. Init only when there's no profile). The drill-down's health checklist also shows the
-  **workflows** state (scripts + profile-reader installed, which path a session will take).
-
-Runtime is **dependency-free** — node's built-in `http` server serves a prebuilt React app (the app
-source lives in `dashboard/app/`, built to `dashboard/dist/` at publish time). The `/cohorte-doctor` checks
-are reimplemented in JS, so the dashboard needs no Claude session to compute state. See
-[`dashboard/README.md`](dashboard/README.md) for the architecture.
-
 ## Reading a project without an agent
 
 The two read-only halves of the pipeline, in the shell:
@@ -260,8 +252,8 @@ extension below renders.
 
 `doctor`'s exit code makes it a CI step as-is. Add `--porcelain` for one record per line with
 `U+001F` between fields (a spec title with a space in it never misaligns a column), or `--json`
-for the native document. Both reuse the dashboard's own readers, so the board and the CLI can
-never give two answers about one repo.
+for the native document. Both read through `lib/`, so every consumer — the CLI, a Francois
+panel — answers from one implementation and the repo never gets two verdicts.
 
 `--panel` — on `specs`, `doctor` and `metrics` — emits the payload shape a
 [Francois](https://github.com/antoine-gmnz/francois) extension panel expects. It is the one
@@ -301,15 +293,18 @@ so a CLI pinned at an old version cannot quietly re-lay an old core.
 | Command              | Role                                                                                  |
 | -------------------- | ------------------------------------------------------------------------------------- |
 | `/cohorte-init-pipeline`     | Detect stack → interview → generate the profile + agents. Run once per project.       |
+| `/cohorte-intake [paste]`    | Triage anything that arrives (ticket, email, trace, thread) into a `/cohorte-patch` handoff or a brainstorm seed — staged to disk, carded in Ideas. |
 | `/cohorte-brainstorm`        | Interactive persona panel that pressure-tests a feature idea.                         |
 | `/cohorte-spec`              | Freeze the feature spec + contract into `specs/<id>.md` (UI features also get a standalone design brief at `specs/design/<id>.md`). Also applies review returns. |
 | `/cohorte-patch [bug]`       | Bug-fix entry: triage a bug and freeze a ~60-line patch spec (`specs/patch-<slug>.md`) whose regression test replaces the contract. Then the normal `/cohorte-build → review → ship`. |
 | `/cohorte-build <id>`        | Readiness gate on the frozen spec, then the lead authors the contract and dispatches one implementer per surface in parallel. |
-| `/cohorte-review <id>`       | Read-only review agents (one per touched surface, parallel) audit the diff vs the spec; out-of-scope findings go to the refactor backlog. |
+| `/cohorte-review <id>`       | Read-only review agents (one per touched surface, parallel) audit the diff vs the spec; out-of-scope findings go to the refactor backlog. `--pr <num>` reviews an **incoming** GitHub PR in a throwaway worktree and offers to post the report as a comment. |
 | `/cohorte-fix <id>`          | Apply a review report: remediation into the spec, re-dispatch only the surfaces with findings. |
+| `/cohorte-fleet plan\|status\|sync` | Fly several features in parallel: overlap matrix + merge order, one worktree per feature, live status, post-merge rebase sweep. Coordination only — never headless execution. |
 | `/cohorte-ship <id>`         | Release agent commits, pushes, opens the PR; watches CI; proposes worktree teardown.  |
 | `/cohorte-audit [path]`      | Prioritized refactor backlog for existing code.                                       |
 | `/cohorte-refactor <domain>` | Apply the backlog for one surface, TDD-first.                                         |
+| `/cohorte-retro [last n]`    | Mine the accumulated review findings for patterns; ratified ones become §Conventions rules and the surface agents are re-rendered — the next build never produces the finding. |
 | `/cohorte-align-ds`          | Align the code UI kit to the design system (no-op if none configured).                |
 | `/cohorte-update-pipeline`   | Refresh the installed core (global or bundled) to the latest published version.       |
 | `/cohorte-doctor`            | Diagnose the installation (core, agents↔surfaces, hooks, gate, retrieval, worktrees). |
@@ -415,7 +410,10 @@ See `profile/SCHEMA.md` for every field in `PIPELINE.md` and how the pipeline us
 
 ```
 package.json            # npm package (cohorte) — semver source of truth
-bin/cli.js              # the npm CLI: install / update / dashboard / specs / doctor / metrics / version (cross-platform, no deps)
+bin/cli.js              # the npm CLI: install / update / specs / doctor / metrics / version (cross-platform, no deps)
+bin/report.js           # the four renderings of `specs` / `doctor` (human, porcelain, json, panel)
+lib/                    # shared readers behind those verbs — doctor.js (the JS port of
+                        #   /cohorte-doctor) + runtime.js / versions.js / yaml.js. No deps.
 install.sh              # script installer (fresh + --update) for npm-less setups — still needs Node
 install.ps1             # same installer for Windows PowerShell (fresh + -Update)
 core/                   # copied verbatim into ~/.claude (global) or <project>/.claude (bundled)
@@ -429,7 +427,4 @@ profile/
   SCHEMA.md             # field reference
   cohorte.config.template.yaml   # seeds ~/.claude/cohorte.config.yaml (kanban)
 scripts/                # worktree-isolation templates + the shipped preflight/kanban scripts
-dashboard/              # local web cockpit (cohorte dashboard) — see dashboard/README.md
-  server/               # dependency-free node runtime (serves the built app + JSON/stream API)
-  app/                  # Vite + React source (built to dashboard/dist/ at publish time)
 ```

package/bin/cli.js

@@ -40,7 +40,6 @@ function usage(code) {
 Usage:
   cohorte install   [target] [--global] [--runtime=a,b | --all-runtimes]
   cohorte update    [target] [--global] [--runtime=a,b | --all-runtimes]
-  cohorte dashboard [target] [--port=N] [--host=ADDR] [--open]
   cohorte metrics   [target] [--days=N] [--since=ISO] [--runs] [--json]
   cohorte specs     [target] [--porcelain | --json | --panel]
   cohorte doctor    [target] [--porcelain | --json | --panel]
@@ -53,11 +52,6 @@ Commands:
   update    Refresh the stack-agnostic core only. PIPELINE.md, rendered surface
             agents, gate-config.json, settings.json and your filled
             ~/.claude/cohorte.config.yaml are never touched.
-  dashboard Serve a local web cockpit for the pipeline (freshness, /cohorte-doctor
-            health, specs board, install/update actions). Binds 127.0.0.1:4317
-            by default (loopback only — its actions execute code). --host=ADDR
-            to expose (e.g. --host=0.0.0.0, prints a security warning). --open
-            to launch the browser.
   metrics   Cost and runtime per command, reconstructed from Claude Code's own
             transcripts (tokens, USD, wall/active time, subagent count). Reads
             ~/.claude/projects — nothing to enable, and it covers runs that
@@ -90,11 +84,6 @@ const args = process.argv.slice(2);
 let mode = null;
 let scope = 'project';
 let target = process.cwd();
-let port = parseInt(process.env.COHORTE_DASHBOARD_PORT, 10) || 4317;
-// Bind to loopback by default — the dashboard's action endpoints execute code (install/update/
-// reset/claude), so it must NOT be reachable from the network unless the user explicitly opts in.
-let host = process.env.COHORTE_DASHBOARD_HOST || '127.0.0.1';
-let openBrowser = false;
 
 // Flags that belong to `metrics` and are forwarded verbatim to the collector. They are
 // listed here rather than parsed, so the collector stays the single source of truth for
@@ -112,7 +101,7 @@ let format = 'human';
 let wantRuntimes = [];
 
 for (const a of args) {
-  if (a === 'install' || a === 'update' || a === 'dashboard' || a === 'metrics'
+  if (a === 'install' || a === 'update' || a === 'metrics'
       || a === 'specs' || a === 'doctor') mode = a;
   else if (a === '--porcelain' || a === '--panel') format = a.slice(2);
   else if (isMetricsFlag(a)) { if (a === '--json') format = 'json'; metricsFlags.push(a); }
@@ -131,40 +120,18 @@ for (const a of args) {
   }
   else if (a === 'version' || a === '--version' || a === '-v') { console.log(VERSION); process.exit(0); }
   else if (a === '--global' || a === '-g') scope = 'global';
-  else if (a.startsWith('--port=')) {
-    // A bad value used to land as NaN, which http.listen() silently treats as
-    // "any free port" — the banner then printed `localhost:NaN` and nothing worked.
-    port = parseInt(a.slice(7), 10);
-    if (!Number.isInteger(port) || port < 1 || port > 65535) {
-      console.error(`error: --port must be an integer 1-65535 (got "${a.slice(7)}")`);
-      process.exit(2);
-    }
-  } else if (a.startsWith('--host=')) {
-    host = a.slice(7).trim();
-    if (!host) { console.error('error: --host= needs an address (e.g. --host=0.0.0.0)'); process.exit(2); }
-  }
-  else if (a === '--open') { openBrowser = true; }
   else if (a === 'help' || a === '--help' || a === '-h') usage(0);
   else if (a.startsWith('-')) { console.error(`error: unknown flag: ${a}`); usage(2); }
   else target = path.resolve(a);
 }
 if (!mode) usage(args.length ? 2 : 0);
 
-// --- dashboard: local web cockpit -------------------------------------------
-// Short-circuits before the install/update machinery (CommonJS wraps the module,
-// so a top-level return is valid here). Runtime is dependency-free node `http`.
-if (mode === 'dashboard') {
-  const globalDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-  require('../dashboard/server')({ projectRoot: target, globalDir, port, host, openBrowser, pkgRoot, version: VERSION });
-  return;
-}
-
 // --- specs / doctor: read-only reports on <target> ---------------------------
-// Both reuse the dashboard's own readers, so the board and the CLI can never drift
-// into two answers about the same repo. Nothing here writes or spawns anything.
+// Both read through lib/, so every consumer of the pipeline's state — the CLI, a
+// Francois panel — answers from one implementation. Nothing here writes or spawns.
 if (mode === 'specs' || mode === 'doctor') {
   const report = require('./report.js');
-  const { state, scanSpecs } = require('../dashboard/server/doctor.js');
+  const { state, scanSpecs } = require('../lib/doctor.js');
   const globalDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 
   if (mode === 'specs') {
@@ -342,8 +309,8 @@ function copyCore() {
     paths: {
       core: paths.core, commands: paths.commands,
       agents: paths.agents || path.join(paths.core, 'agents'),
-      // Where the gate registration lives. The dashboard needs it to tell a registered hook
-      // from a missing one without re-deriving each runtime's config layout itself.
+      // Where the gate registration lives. `cohorte doctor` needs it to tell a registered
+      // hook from a missing one without re-deriving each runtime's config layout itself.
       hooks_config: paths.hooks_config,
       state: adapter.stateDir(runtime), config: adapter.configPath(runtime),
     },
@@ -565,7 +532,7 @@ async function seedConfig() {
   //
   // CLAUDE_CONFIG_DIR moves the whole `~/.claude` tree (globalDir already follows it), but
   // adapter.configPath() speaks in literal `~/.claude/…` — expanding through HOME alone
-  // seeded a file at a path no reader probes (kanban-move.sh and the dashboard follow
+  // seeded a file at a path no reader probes (kanban-move.sh follows
   // CLAUDE_CONFIG_DIR), missed a filled config there (re-seeding disabled defaults beside
   // it — the exact two-file fork this function's comments forbid), and printed a banner
   // path that did not exist. Re-root the claude-shaped path onto globalDir so the seed,
@@ -705,7 +672,7 @@ async function staleVersionNotice() {
   if (process.env.COHORTE_NO_VERSION_CHECK || process.env.CI) return;
   let latest = null;
   try {
-    const v = require('../dashboard/server/versions.js');
+    const v = require('../lib/versions.js');
     latest = await v.latestNpm({ timeoutMs: 2500, fallback: false });
     if (!latest || v.cmpSemver(VERSION, latest) >= 0) return;
   } catch { return; }

package/bin/report.js

@@ -1,8 +1,8 @@
 'use strict';
 // Machine-readable reports for `cohorte specs` and `cohorte doctor`.
 //
-// Both commands read what the dashboard already computes (dashboard/server/doctor.js:
-// `scanSpecs` and `state`) and render it four ways:
+// Both commands read what lib/doctor.js computes (`scanSpecs` and `state`) and
+// render it four ways:
 //
 //   default      a human table on a terminal
 //   --porcelain  one record per line, fields separated by U+001F (the ASCII unit

package/core/commands/cohorte-brainstorm.md

@@ -31,7 +31,11 @@ Idea (may be empty): **$ARGUMENTS**
 
 If the idea is empty: when a board is configured and its **Ideas** column has cards, list them (with any
 sub-bullet notes as seed context) and let the human pick one — otherwise ask **"What are we building?"**.
-Either way, wait. If the idea is non-empty, restate it in one line and confirm you've got it.
+Either way, wait. If the idea is non-empty, restate it in one line and confirm you've got it — and
+**if `specs/reports/intake-<idea>.md` exists, read it FIRST**: it is `/cohorte-intake`'s staged seed
+(who is asking with verbatim quotes, goals/non-goals, an open-questions list that is this panel's
+agenda, prior art incl. any `_decisions.md` line the request contradicts). The panel argues against
+the distillate, never against the bare slug.
 
 ## Run the panel
 

package/core/commands/cohorte-fleet.md

@@ -0,0 +1,103 @@
+---
+model: sonnet
+description: Fly several features in parallel — overlap analysis and merge order, one isolated worktree per feature, a live status board, and the post-merge rebase sweep nobody remembers to do.
+argument-hint: plan <id> <id> [...] | status | sync
+---
+
+You are the **fleet controller**. Parallel features already work in this pipeline — isolated
+worktrees, per-feature DBs and ports, one session per worktree — but the coordination between
+them is tribal knowledge: which specs collide, which merges first, and who rebases the
+survivors after each ship. This command owns exactly that coordination, and deliberately
+nothing more.
+
+**What this command will never do: spawn the work headless.** The obvious "cool" version —
+fire a loop per worktree from here — is the 2.2.0 driver's grave: child sessions nobody
+supervises, stalling on prompts nobody sees. Each feature's build/review/loop runs in **its own
+worktree's session**, supervised like any other; the fleet plans, watches and rebases. State
+lives in `specs/reports/fleet.json` (the main checkout's gitignored buffer — this repo's
+multi-*feature* flight plan).
+
+> Read `PIPELINE.md` §`pipeline-profile` first: `surfaces` (paths — the overlap analysis keys
+> on them), `contract`, `vcs.default_branch`, and the `isolation` block. _Skip the re-read if
+> already in context and unmodified since._ **`isolation.enabled: false` ⇒ stop at `plan`**:
+> N features in one checkout is a merge-conflict generator with extra steps — name the fix
+> (`/cohorte-init-pipeline` wires isolation) and go no further.
+
+## `plan <id> <id> [...]` — collide, order, provision
+
+1. **Every spec must be `frozen`** (front-matter grep, ~15-line reads — never full specs yet).
+   Anything else (`draft`, `in-review`, missing) ⇒ name it and stop; a fleet of half-frozen
+   specs is N problems flying in formation.
+2. **Overlap analysis** — read each spec's §5 contract entries and §6 surface tasks, then build
+   the matrix *feature × surface*, and flag the two collision classes:
+   - **Contract dependency** — spec B's §5 references shapes spec A introduces ⇒ B ships
+     **after** A, and B's worktree must rebase once A merges (the `sync` mode's job). This is
+     an ordering, not a blocker.
+   - **Same-tree writes** — two specs whose §6 tasks land in the same `surfaces[].path` (worse:
+     the same module). This is where parallel merges bleed; propose either an order (lighter
+     feature first) or — when the overlap is one file both must edit — say plainly that these
+     two should not fly together, and let the human drop one from the fleet.
+3. **Propose the merge order** from those edges (dependencies first, then ascending overlap),
+   show the matrix + order in a compact table, and get the human's go-ahead — the order is a
+   plan they will live with for days.
+4. **Provision worktrees** — for each feature without one: `scripts/new-feature.sh <id>` (the
+   rendered isolation script: worktree + branch + DB + port slot). Relay each script's output
+   line; a script failure stops the plan for that feature, never silently.
+5. **Write `specs/reports/fleet.json`** (overwrite): `{"ts":"<ISO>","order":[...ids in merge
+   order...],"features":{"<id>":{"worktree":"<path>","branch":"<branch>","dependsOn":[...]}}}`.
+6. **Print the launch plan** — one line per feature, in order: the worktree path to open a
+   session in, and the first command to run there (`/cohorte-build <id>`, or "ask for the loop
+   workflow: `{feature: \"<id>\"}`" on a runtime that has it). The human launches them; the
+   fleet does not.
+
+## `status` — one table, no archaeology
+
+Read `fleet.json` (absent ⇒ say `plan` comes first, stop). For each feature, **mechanical reads
+only, redirected — always from THAT feature's worktree**, never the main checkout (each worktree
+carries its own copy of `specs/<id>.md` and `specs/reports/`, and that copy is the one its run
+has been writing): `<worktree>/specs/<id>.md` front-matter `status` · the worktree's
+`specs/reports/<id>.loop.json` (`phase`/`round`/`outcome`) and `<id>.verdict.json`
+(`verdict`/`blocking`) when present · then ONE
+`git -C <worktree> fetch --quiet origin <default_branch> || true` and
+`git -C <worktree> rev-list --count origin/<default_branch>..HEAD` and `..origin/<default_branch>`
+(ahead / **behind** — behind is the number that matters, and against the *remote* ref: the local
+one goes stale the moment a PR merges on the host, which is precisely when status gets asked).
+One row per feature, in merge order:
+
+```
+<id> · <status> · loop: <phase> r<round> | <outcome> · blocking: <n> · ↑<ahead> ↓<behind> · next: <the one action>
+```
+
+`next` is the whole point of the mode: the single action per feature (a command to run in its
+worktree, "waiting on <dep> to merge", "ready to ship — its turn in the order", or "rebase
+needed — run sync"). A worktree registered in `fleet.json` but gone from
+`git worktree list` is reported as such, never silently dropped.
+
+## `sync` — the post-merge sweep
+
+Run after every merge (the human says which feature shipped, or you detect it: spec
+`status: shipped` + branch merged into `<default_branch>`):
+
+1. Drop the shipped feature from `fleet.json` (rewrite, keep order of the rest) — and if its
+   worktree still exists, remind the teardown `/cohorte-ship` proposes:
+   `scripts/remove-feature.sh <id>` (`--drop-db` at the human's call). Never run it unasked.
+2. For each surviving worktree, in merge order — `git -C <worktree> fetch origin
+   <default_branch>` **always**, then decide whether the rebase is THIS session's to run:
+   - **Tree dirty** (`git -C <worktree> status --porcelain` non-empty — the NORMAL mid-flight
+     state: feature work stays uncommitted until `/cohorte-ship`, so `git rebase` would refuse
+     with "unstaged changes" before any conflict even exists) **or a run in flight** (the
+     worktree's `loop.json` has no `outcome`): **do not touch it.** Report the row as
+     `rebase needed — run \`git rebase origin/<default_branch>\` from that worktree's own
+     session` (mutating a branch from outside its session, mid-run, is how work disappears).
+   - **Clean and idle**: rebase it, output redirected to `specs/reports/fleet-sync.txt`. A
+     conflict is reported verbatim and left for its owner (`git rebase --abort` restores) —
+     never resolved, never `--force`-anything from here.
+3. **Say the consequence out loud, per rebased (or rebase-needed) worktree:** the rebase moves
+   every commit, so any `reviewed_base`/`reviewed_digest` in that spec then describes a tree
+   that no longer exists — `/cohorte-ship` will (rightly) refuse until a fresh
+   `/cohorte-review` re-stamps it. A clean rebase is not a re-verdict; the re-review is.
+4. Reprint the `status` table.
+
+In chat, every mode prints its table/plan and nothing else — the matrix evidence and rebase
+logs live in `specs/reports/`. **Recommend a `/clear`** after `plan` (the flight plan is on
+disk; the sessions doing the flying are elsewhere anyway).

package/core/commands/cohorte-intake.md

@@ -0,0 +1,92 @@
+---
+description: Triage anything that arrives — a ticket, a client email, a stack trace, a Slack thread — into the pipeline's entry point: a patch handoff or a brainstorm seed.
+argument-hint: [paste the raw material — ticket, email, trace, thread — or empty to be asked]
+---
+
+You are the **intake triager**. Work is arriving from OUTSIDE the pipeline — a bug report, a
+client email, a support thread, a stack trace, a half-idea — and today a human distills it by
+hand before anything can start. Your job is that distillation: read the raw material, decide
+which door it enters through, and stage a handoff the next command can consume verbatim.
+
+> Read `PIPELINE.md` §`pipeline-profile` first — `name`, `one_liner`, `surfaces` (to guess which
+> surface a symptom lives in) and `ui_language`. _Skip the re-read if it's already in your
+> context this session and unmodified since._ Read `specs/_decisions.md` §Live if it exists —
+> an incoming request that contradicts a settled decision must be flagged as such, not triaged
+> as a fresh idea.
+
+## 1. Ingest & triage
+
+The material is pasted after the command; nothing pasted ⇒ ask for it and wait (paste, file
+path, or a `gh issue view <n>` you run yourself when they name an issue number). Then decide —
+and say which signals decided it:
+
+- **Bug** — existing behavior misbehaving: a repro or trace, "used to work", an error message,
+  a version where it broke. → §2.
+- **Feature** — behavior that does not exist yet: "could we", "it should also", a workflow the
+  product doesn't cover. → §3.
+- **Both tangled together** (a bug report whose fix half describes a new feature): split it —
+  §2 for the defect, §3 for the rest — and say you split it.
+- **Neither** (a question, a config issue on their side, praise, noise): say so in one line and
+  stop. Not everything that arrives is work; inventing a spec from noise costs a whole pipeline
+  run downstream.
+
+Pick a short kebab-case **slug** from the content (`checkout-double-charge`, `csv-export`) —
+it becomes the join key for the file, the kanban card and the follow-up command.
+
+## 2. Bug → a `/cohorte-patch` handoff
+
+Distill the raw material into exactly the structure `/cohorte-patch` §1 interviews for — so the
+patch triage starts loaded instead of re-asking:
+
+- **Symptom** — one sentence, observed behavior vs expected.
+- **Repro** — numbered steps as far as the material supports them; mark every step you inferred
+  (`(inferred)`) rather than silently guessing. A trace with no steps ⇒ the trace IS the repro
+  material, say so.
+- **Environment** — version/browser/OS/role if present; `unknown` where absent.
+- **Suspected surface(s)** — map the symptom onto `surfaces[]` by what the paths/stack frames
+  name; a guess is fine, label it one.
+- **Severity signal** — who is blocked and how hard, in the reporter's own words.
+
+**Stage it** to `specs/reports/intake-<slug>.md` (overwrite; `mkdir -p specs/reports` first —
+the gitignored buffer dir, so the handoff survives a `/clear`). Then:
+
+> **Kanban** (SCHEMA.md §Kanban): run
+> `<core>/pipeline/scripts/kanban-move.sh auto patch-<slug> ideas --title "[patch] <one-line title>"`.
+> The id is **`patch-<slug>`, prefix included, and the title prefix is `[patch]`** — that is the
+> exact join key and the exact title `/cohorte-patch` §1 looks for, so its later move finds THIS
+> card instead of creating a duplicate and stranding this one in Ideas (the failure SCHEMA
+> §Kanban's "tag before you move" exists to prevent). `auto` resolves the board from the config
+> itself and exits 0 with a `kanban: <reason>` line when there is none — so **never decide "no
+> board is configured" without running it**.
+
+Close with: `→ /cohorte-patch <slug>` — `/cohorte-patch` reads the staged
+`specs/reports/intake-<slug>.md` when it exists, so the triage starts loaded. Do **not** run it
+yourself — freezing a spec is a decision the human confirms, and intake's job ends at the door.
+
+## 3. Feature → a `/cohorte-brainstorm` seed
+
+Distill into the seed the panel argues best about:
+
+- **Title + one-liner** — in the product's language (`ui_language` for user-facing wording).
+- **Who is asking & why now** — verbatim quotes where the material has them; the panel argues
+  better against a real voice than a paraphrase.
+- **Goals / explicit non-goals** — only what the material actually states; never pad.
+- **Open questions** — every ambiguity you'd otherwise have guessed at, as questions. This list
+  is the seed's real value: it is the brainstorm's agenda.
+- **Prior art in this repo** — one grep pass: existing specs/decisions touching the same area
+  (`grep -l` over `specs/*.md`, redirected — never a file read per name). Contradicts a
+  `_decisions.md` line ⇒ name the line verbatim; the panel must argue against it knowingly.
+
+**Stage it** to `specs/reports/intake-<slug>.md` (overwrite), then the kanban call with the
+bare id: `<core>/pipeline/scripts/kanban-move.sh auto <slug> ideas --title "<title>"` (same
+"never decide without running it" rule as §2). The card is the board's join key; **the seed
+itself travels in the staged file** — `/cohorte-brainstorm <slug>` reads
+`specs/reports/intake-<slug>.md` when it exists, so the panel argues against the distillate,
+not against a bare slug.
+
+Close with: `→ /cohorte-brainstorm <slug>` — the seed is on disk and on the board;
+**recommend a `/clear` first**, the handoff is complete.
+
+In chat print ONLY: the triage verdict + its signals (one line), the staged file path, the
+kanban result line, and the follow-up command. Never echo the full distillate into chat — it
+is on disk, and this session's history is re-sent at input price on every turn.

package/core/commands/cohorte-patch.md

@@ -28,7 +28,12 @@ Bug (may be empty): **$ARGUMENTS**
 
 ## 1. Get the bug
 
-If `$ARGUMENTS` is non-empty, restate it in one line and confirm you've got it.
+If `$ARGUMENTS` is non-empty, restate it in one line and confirm you've got it — and if it is
+(or names) a slug with a staged `specs/reports/intake-<slug>.md`, **read that file first**: it is
+`/cohorte-intake`'s distillate (symptom, repro with inferred steps labeled, environment, suspected
+surfaces, severity signal), so this triage starts loaded instead of re-asking. Keep intake's slug —
+its kanban card is already tagged `#patch-<slug>` and titled `[patch] …`, exactly what the move
+below joins on.
 
 If it is empty: when a board is configured and its **Ideas** column has cards, list them (with any
 sub-bullet notes as context) — **cards titled `[patch]` first**, since those are the ones a human