cohorte 2.9.0 → 2.10.0

package/CHANGELOG.md

@@ -7,6 +7,31 @@ 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

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
@@ -418,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)
@@ -432,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-fleet.md

@@ -14,9 +14,8 @@ nothing more.
 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 — not to be confused
-with the dashboard's multi-*project* fleet registry; this file is this repo's multi-*feature*
-flight plan).
+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

package/core/commands/cohorte-ship.md

@@ -98,8 +98,8 @@ watch, rather than letting the job go red.
 **Move the card to Shipped — required, and verify it actually moved.** Run
 `<core>/pipeline/scripts/kanban-move.sh auto $ARGUMENTS shipped --pr <num>`, which **appends the PR
 number** so the line reads `- [ ] <title> #$ARGUMENTS — PR #<num>`. Take `<num>` from the PR URL
-(`…/pull/13` ⇒ `13`); **always pass it when a PR was created** (the `gh` path) — it is what the
-dashboard turns into a PR link. If only a compare URL was emitted (no PR yet), drop `--pr`.
+(`…/pull/13` ⇒ `13`); **always pass it when a PR was created** (the `gh` path) — it is what a
+board reader turns into a PR link. If only a compare URL was emitted (no PR yet), drop `--pr`.
 
 Then **read the script's own output**, which is the verification: `moved #$ARGUMENTS -> Shipped
 (PR #<num>)` means done, and a `kanban: <reason>` line means the mirror is off and says why. Both are

package/core/hooks/gate.py

@@ -23,7 +23,7 @@ and subagents spawned by the Workflow runtime alike. Workflow subagents run in
 acceptEdits regardless of the session's permission mode (their Write/Edit calls
 are auto-approved), but acceptEdits does NOT auto-approve Bash or Task, so this
 gate still sees and can block them. In bypassPermissions (headless `claude -p`,
-dashboard actions) there is no human to answer a prompt, so every `ask` match is
+unattended workflow runs) there is no human to answer a prompt, so every `ask` match is
 escalated to a hard deny with the reason attached — a clear refusal beats a
 prompt that can never be answered.
 

package/core/workflows/review.js

@@ -395,7 +395,7 @@ const staging = await agent(
     : 'the blocking list is empty, so <FP> is the empty string "":\n') +
   `${verdictJson}\n` +
   // Per-surface verdicts (not the merged one stamped on every row — one BLOCK used to
-  // mark ALL surfaces failed on the dashboard), and dead reviewers logged as "dead"
+  // mark ALL surfaces failed), and dead reviewers logged as "dead"
   // per SCHEMA.md §Dead agents — an incomplete batch is the batch worth recording.
   `3. Append one line to $(dirname "$(git rev-parse --git-common-dir)")/.claude/pipeline-metrics.jsonl: ` +
   `{"ts":"<ISO now>","feature":"${feature}","phase":"review","seconds":0,"tokens":${Math.max(0, spentNow() - spentStart)},"surfaces":{${

package/{dashboard/server → lib}/doctor.js

@@ -1,5 +1,6 @@
 'use strict';
-// Programmatic port of the /cohorte-doctor checks (core/commands/doctor.md), for the dashboard.
+// Programmatic port of the /cohorte-doctor checks (core/commands/cohorte-doctor.md), so
+// `cohorte doctor` can report without a coding agent in the loop.
 // Read-only: inspects files only. Checks that need a live process (MCP connectivity,
 // git worktree state, DesignSync) are reported as `skip` with a note — the node server
 // can't run them, and honest "not checked here" beats a false green.
@@ -247,7 +248,7 @@ function gateRegs(settingsPath, event) {
 
 function checkHooks(projectRoot, globalDir, installMode, all) {
   // A registration can exist without a discoverable core — a repo whose core lives in a global
-  // dir the dashboard was not pointed at, or one predating `runtimes.json`. Falling through to
+  // dir the caller was not pointed at, or one predating `runtimes.json`. Falling through to
   // "no runtime installed" there would hide a real double-registration, so assume the Claude
   // layout: before the adapter it was the only one, and it is the only one whose hook can be
   // registered outside its own core dir.

package/{dashboard/server → lib}/runtime.js

@@ -1,7 +1,7 @@
 'use strict';
 // Which coding agent(s) this project is wired for, and where each one keeps its files.
 //
-// Before 2.2.0 every path in the dashboard was `.claude/…`. That is now one layout of five:
+// Before 2.2.0 every path here was `.claude/…`. That is now one layout of five:
 // a repo driven from Cursor keeps its core in `.cohorte/cursor/`, its agents in
 // `.cursor/agents/` and its gate registration in `.cursor/hooks.json`. Checking the Claude
 // paths there reports a perfectly healthy install as broken — "no core", "no rendered agent",

package/{dashboard/server → lib}/versions.js

@@ -30,12 +30,12 @@ function pointerAt(projectRoot) {
 
 // Latest published version — registry fetch first, `npm view` as a fallback (it uses the
 // user's configured registry/proxy, which works where a raw fetch may be blocked). Cached
-// briefly so the dashboard's poll doesn't hammer the network. null only if both fail.
+// briefly so repeated calls don't hammer the network. null only if both fail.
 let _cache = { value: null, at: 0 };
 const CACHE_MS = 5 * 60 * 1000;
 // Failures are cached too, briefly. Without this an offline machine paid the FULL
 // 5s fetch timeout + 8s `npm view` timeout on every call — and /api/fleet calls
-// this once per tracked project, so the dashboard's 15s poll never finished.
+// this once per tracked project, so a batch of probes never finished.
 const FAIL_CACHE_MS = 60 * 1000;
 
 async function fetchRegistry(timeoutMs = 5000) {

package/package.json

@@ -1,26 +1,21 @@
 {
   "name": "cohorte",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Portable, stack-agnostic multi-agent development pipeline for Claude Code, Codex CLI, Cursor, Gemini CLI and OpenCode — install the core, run /cohorte-init-pipeline, and it adapts to your project's stack.",
   "bin": {
     "cohorte": "bin/cli.js"
   },
-  "scripts": {
-    "build:dashboard": "npm --prefix dashboard/app ci && npm --prefix dashboard/app run build",
-    "prepack": "npm run build:dashboard"
-  },
   "files": [
     "bin",
+    "lib",
     "core",
     "profile",
     "scripts",
     "!scripts/new-feature.sh",
     "!scripts/remove-feature.sh",
+    "!scripts/demo",
     "!core/hooks/__pycache__",
     "!**/*.pyc",
-    "dashboard/server",
-    "dashboard/dist",
-    "dashboard/README.md",
     "install.sh",
     "install.ps1",
     "CHANGELOG.md"

package/profile/SCHEMA.md

@@ -176,7 +176,7 @@ the **main checkout's** `<state>/pipeline-metrics.jsonl` (gitignored) — one JS
 and `/cohorte-fix`.
 **`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`
+as a surface: `cohorte doctor` 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)")/<state>/pipeline-metrics.jsonl`. Read it before
@@ -189,7 +189,7 @@ what's SLOW. Tokens are recorded only where they can be read honestly: the **wor
 (`loop.js`, `review.js`) stamp an approximate `tokens` field per batch from the runtime's own
 counter (`budget.spent()` deltas), and the loop's return carries a per-round breakdown in its
 `history`. The **conversational** commands still record none — a lead cannot reliably read a
-subagent's token count, and a guessed number is worse than a missing one. The dashboard sums
+subagent's token count, and a guessed number is worse than a missing one. `cohorte metrics` sums
 whatever is stamped (a token-less line aggregates as 0, rendered as absent, never as "free").
 For exact spend, use Claude Code's own accounting:
 
@@ -231,7 +231,7 @@ storing a bare `pnpm test` as the thing agents execute; `/cohorte-update-pipelin
 ## Spec status — the lifecycle state machine
 
 A spec's front-matter `status` is not a label, it is the pipeline's **state**: every command routes on
-it, the dashboard boards on it, and the kanban backfill maps it to a column. Six states:
+it, `cohorte specs` boards on it, and the kanban backfill maps it to a column. Six states:
 
 | status | meaning | written by | who may build it |
 | --- | --- | --- | --- |
@@ -371,7 +371,7 @@ project has *decided*. Without somewhere for those, every `/cohorte-spec` re-dis
 - **Never read by implementers or reviewers.** They work from the frozen contract, which already tells
   them what to do; shipping them the rationale would cost `surfaces × dispatches` tokens per feature
   for a fact they cannot act on. This is what keeps the journal cheap enough to be worth having.
-- The `_` prefix is load-bearing: `/cohorte-doctor`, the dashboard spec scanner and the kanban backfill all skip
+- The `_` prefix is load-bearing: `/cohorte-doctor`, the `cohorte specs` scanner and the kanban backfill all skip
   `specs/_*.md`, so the journal is never mistaken for a spec (no phantom card, no bogus stage).
 
 ## Preflight — the deterministic phase gate
@@ -626,7 +626,7 @@ notes a human writes as sub-bullets under an Ideas card are seed context for `/c
 the trailing `%% kanban:settings … %%` block or the `kanban-plugin: board` front-matter.
 
 Once shipped, `/cohorte-ship` appends the **PR number** to the card — `- [ ] <title> #<feature_id> — PR #<num>`.
-The bare `#<num>` is what the dashboard renders as a clickable link to the GitHub PR, so `/cohorte-ship` always
+The bare `#<num>` is what a board reader renders as a clickable link to the GitHub PR, so `/cohorte-ship` always
 writes it when a PR was actually created.
 
 **Move a card (the core op).** One call — the script does resolution AND the move outside the