cohorte 1.4.0 → 1.5.0

package/scripts/test-metrics.mjs

@@ -82,6 +82,13 @@ const lines = [
   // Case 8: a slash token that is not a command must not invent one.
   user(1800, 'look at the /usr/local/share directory and report what you find there'),
   assistant('m7', 1805, 'claude-opus-5', { input_tokens: 0, output_tokens: 10 }),
+  // Case 9: a long prompt that merely DISCUSSES a command is not an invocation of it.
+  // Without the length gate, writing about /review bills the conversation to /review —
+  // which is what happened in cohorte's own repo while the pipeline was being designed.
+  user(2400, 'I want to talk through how /review behaves when a surface has no findings at '
+    + 'all, because the verdict logic there is what produced the false green we saw last week '
+    + 'and I am not convinced the fix covers the case where every reviewer dies at once.'),
+  assistant('m8', 2405, 'claude-opus-5', { input_tokens: 0, output_tokens: 20 }),
 ];
 fs.writeFileSync(path.join(projectDir, `${SESSION}.jsonl`),
   lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
@@ -107,18 +114,20 @@ const chat = out.commands.find((c) => c.command === '(chat)');
 const review = out.commands.find((c) => c.command === '/review');
 
 console.log('test-metrics');
-check('the mid-command task-notification did not split the run', out.totals.runs, 4);
+check('the mid-command task-notification did not split the run', out.totals.runs, 5);
 check('/build is one run, not three', build.runs, 1);
 check('duplicate lines of one response are billed once', build.tokens.output, 1000 + 500 + 2000);
 check('the <synthetic> message contributed no tokens', build.tokens.output < 999999, true);
 check('cache-write tokens are kept on their own tier', build.tokens.cacheWrite5m, 1000);
 check('cache-read tokens are kept on their own tier', build.tokens.cacheRead, 10000);
 check('the subagent was attributed to the command that spawned it', build.agents.total, 1);
-check('the second prompt is a separate (chat) run', chat.runs, 2);
+check('the second prompt is a separate (chat) run', chat.runs, 3);
 check('a command named inside prose is attributed to that command', review && review.runs, 1);
 check('a short steer continues the run instead of opening a new one', review.continuations, 1);
 check('the continued turn counts toward the command it continued', review.tokens.output, 60 + 70);
-check('a non-command slash token does not invent a command', chat.tokens.output, 40 + 10);
+check('a non-command slash token does not invent a command', chat.tokens.output, 40 + 10 + 20);
+check('a long prompt that discusses a command is not counted as running it',
+  review.runs, 1);
 
 // opus-5 $5 in / $25 out per MTok; 5m cache write 1.25x input, cache read 0.1x input.
 //   m1  100*5 + 1000*25 + 1000*6.25 + 10000*0.5 = 36750

package/scripts/validate-core.mjs

@@ -22,7 +22,7 @@ const frontmatter = (text) => {
 // Mechanical commands must pin model: sonnet (otherwise the lead's
 // orchestration turn silently bills at the session model — Opus/Fable).
 // Interactive commands must stay unpinned (they inherit on purpose).
-const PINNED = ["build", "review", "fix", "smoke", "ship", "audit",
+const PINNED = ["build", "review", "fix", "ship", "audit",
   "refactor", "doctor", "align-ds", "update-pipeline"];
 const UNPINNED = ["brainstorm", "spec", "init-pipeline"];
 
@@ -43,7 +43,7 @@ for (const f of readdirSync(join(root, "core/commands"))) {
 // Every non-template agent needs name/tools/model, and must be shipped by
 // both installers (a new agent that install.sh doesn't copy never reaches
 // a global install — the exact bug that motivated this check).
-const AGENT_MODEL = { review: "sonnet", release: "haiku", smoke: "sonnet",
+const AGENT_MODEL = { review: "sonnet", release: "haiku",
   "profile-reader": "haiku" };
 const installSh = read("install.sh");
 const installPs1 = read("install.ps1");
@@ -90,7 +90,7 @@ for (const path of allDocs) {
   }
   for (const m of text.matchAll(/subagent_type:\s*(?:`|)([a-z-]+)(?:`|)/g)) {
     const t = m[1];
-    if (["review", "release", "smoke", "profile-reader"].includes(t)) continue;
+    if (["review", "release", "profile-reader"].includes(t)) continue;
     if (t.startsWith("<")) continue; // <surface.agent> placeholder
     if (!existsSync(join(root, "core/agents", `${t}.md`)))
       fail(path, `dispatches subagent_type ${t} with no core/agents/${t}.md`);
@@ -115,9 +115,9 @@ if (!existsSync(steps) || readdirSync(steps).length === 0)
 
 // ── telemetry coverage ──────────────────────────────────────────────────────
 // The funnel is only readable if every one of its stages pings — a single missing
-// one silently truncates it (that is how /smoke, /review and /fix went unreported
+// one silently truncates it (that is how /review and /fix went unreported
 // until 1.2.3). The phase list here must match SCHEMA.md §Telemetry's table.
-const FUNNEL = ["brainstorm", "spec", "build", "smoke", "review", "fix", "ship"];
+const FUNNEL = ["brainstorm", "spec", "build", "review", "fix", "ship"];
 for (const c of FUNNEL)
   if (!/usage ping/i.test(read(`core/commands/${c}.md`)))
     fail(`core/commands/${c}.md`, "funnel command with no usage ping — breaks the telemetry funnel");

package/core/agents/smoke.md

@@ -1,63 +0,0 @@
----
-name: smoke
-description: Executes the end-to-end smoke run for one feature in its worktree — infra up, migrations, contract endpoints, key UI flows, visual check vs design — then stages the SMOKE REPORT. Dispatched by /smoke. Observes honestly, never fixes anything.
-tools: Read, Write, Grep, Glob, Bash, DesignSync
-model: sonnet
----
-
-You are the **smoke** agent for one feature. You actually run the built feature — `/review` audits
-code read-only; nobody has executed it yet. You verify it *works*; you never fix it (failures go
-through `/fix`). Observe honestly: report what happened, not what should have happened.
-
-> **First action, always:** read `PIPELINE.md` §`pipeline-profile`: `commands` (migrate/dev),
-> `isolation` (worktree, slot ports, db), `contract`, `design`, `surfaces` — then the spec
-> `specs/<id>.md` (§5 contract, §8 flows, §9 acceptance).
-
-## Your inputs (supplied at dispatch — you have no memory)
-
-1. The feature id and spec path `specs/<id>.md`.
-2. The contract path `<contract.path>/<id>.<ext>`.
-3. The checkout to work in: the worktree path + slot ports/db, or the main checkout on the feature branch.
-
-## Keep your own context lean
-
-Redirect every bulky output to a file and inspect it with `grep`/`jq` — never print full curl bodies,
-server logs, or poll loops into your transcript. `curl -s … -o /tmp/resp.json -w '%{http_code}'` then
-assert on the pieces you need.
-
-## 1. Bring the feature up
-
-- Work in the checkout your dispatch names. Infra as needed: the compose stack if one is declared
-  (the gate will ask — that's expected), then `commands.migrate`, then `commands.dev` **in the
-  background**. Wait for ready (poll the ports), don't assume.
-
-## 2. Exercise the contract (the real server, not the tests)
-
-- Hit a representative set of spec §5 endpoints with `curl`: every route domain, every auth level,
-  at least one error case per class (validation `422`, unauthenticated `401`, wrong-role `403`,
-  conflict `409`). Compare status + response envelope against the contract.
-- If `rbac.enabled`: verify at least one denial per role boundary the spec declares.
-- A mismatch is a FAIL entry with the exact command, expected, and actual — precise enough for a
-  stateless `/fix` agent.
-
-## 3. Exercise the UI (only if a touched surface has `uses_design`)
-
-- Drive the spec §8 flows against the running app, **mobile viewport first** (375px), then desktop.
-- If a browser/screenshot tool is available (a project driver, playwright, an agent browser), capture
-  each §8 screen and compare against the feature's design pages: each `design_files` entry is a full
-  `https://claude.ai/design/p/<projectId>?file=<file>` link — extract its `<projectId>` (the `/p/…`
-  segment) + `<file>` (the `?file=` query) and fetch read-only via `DesignSync get_file(<projectId>,
-  <file>)`. Compare layout, states (empty/loading/error/suppressed…), copy language. Note deviations.
-- No browser tooling available ⇒ **say so and skip the visual diff** — never claim a visual check
-  you didn't perform.
-
-## 4. Stage the SMOKE REPORT, tear down, return
-
-- One line per check: ✅/❌ · what was exercised · (on ❌) command → expected vs actual.
-- **Write the full report to `specs/reports/<id>.md`** (overwrite) — the same gitignored buffer
-  `/review` uses, so a `/fix` after a `/clear` still has the failures.
-- Tear down what you started (kill the dev server); leave shared infra as you found it.
-- **Your return to the lead is ONLY:** the verdict line (`PASS` / `FAIL:<n>`), **at most 10 ❌
-  lines** — one line each (`❌ <flow/endpoint> · expected <x> got <y>`), no command output, no code
-  or body excerpts; more than 10 ⇒ keep the 10 most severe and add `+<n> more — see the report` —
-  and `Full report: specs/reports/<id>.md`. No logs, no bodies, no screenshots.

package/core/commands/smoke.md

@@ -1,55 +0,0 @@
----
-model: sonnet
-description: Exercise the built feature end-to-end in its worktree — infra up, migrations, contract endpoints, key UI flows, visual check vs design — before /review.
-argument-hint: <feature_id>
----
-
-You are the **lead**. Dispatch the smoke run for feature **$ARGUMENTS** — the `smoke` agent actually
-runs it so the bulky output (curl bodies, server logs, screenshots, design payloads) never enters
-your own context, which is re-sent every turn.
-
-> Read `PIPELINE.md` §`pipeline-profile`: `isolation` (worktree, slot ports, db), `contract.path`
-> and `commands`. _Skip the re-read if it's already in your context this session and unmodified since._
->
-> **Kanban:** none here — `/review` owns the → **Review** move (running both duplicated it).
-
-## 0. Deterministic pre-flight — no agents while red
-
-Same gate as `/review` §0, run **in the feature's checkout** (§1 resolves it — resolve first, then
-preflight): `<core>/pipeline/scripts/preflight.sh specs/reports/$ARGUMENTS.preflight.txt
-"<commands.typecheck>" "<commands.lint_quiet, else lint>" "<commands.test_quiet, else test>"`.
-Non-zero exit ⇒ the raw last-40 lines were already printed — **STOP, relay them verbatim, spawn NO
-agent**: booting infra to smoke-test code that doesn't compile wastes the whole run. Zero exit ⇒
-the `.claude/preflight.ok` stamp lets the gate hook pass your `smoke` dispatch. Script absent
-(older core) ⇒ run the commands yourself redirected to the same file, aborting on the first failure.
-Note the epoch (`date +%s`) in the same call — §3's metrics line needs it.
-
-## 1. Resolve the checkout
-
-With `isolation.enabled`: the sibling worktree (`../<slug>-$ARGUMENTS`, its slot's ports + db from
-`.worktrees/slots.tsv`); otherwise the main checkout on the feature branch.
-
-## 2. Dispatch ONE `smoke` agent
-
-Keep the prompt byte-identical across features except the variable block at the END (prompt-cache
-prefix):
-
-> `subagent_type: smoke` — "Smoke-test one feature. Read `PIPELINE.md` first. Bring it up, exercise
-> the contract and the §8 UI flows, stage the full SMOKE REPORT to the report buffer, tear down, and
-> return only the capped verdict your agent instructions define (verdict + ❌ lines, no logs). —
-> Variable slots: feature `$ARGUMENTS` · spec: `specs/$ARGUMENTS.md` · contract:
-> `<contract.path>/$ARGUMENTS.<ext>` · report: `specs/reports/$ARGUMENTS.md` · checkout: `<worktree
-> path or main checkout>` · ports/db: `<slot info, or defaults>`."
-
-The gate hooks fire on the agent's Bash calls too — compose/migrate confirmations still reach the
-human; that's expected.
-
-## 3. Relay the verdict
-
-- Print the agent's return as-is (verdict + ❌ lines + report path) — it is already minimal.
-- Append ONE metrics line to `pipeline-metrics.jsonl` (main-checkout path + rules in `/build` §4,
-  `phase: "smoke"`), chaining the opt-in usage ping in the same Bash call (results = `PASS` or
-  `FAIL:<n>` failing flows).
-- **PASS** → tell the human to run `/review $ARGUMENTS`. **FAIL** → the failures are findings: feed
-  them to `/fix $ARGUMENTS`, re-run `/smoke` after. Either way the report is on disk —
-  **recommend a `/clear`** before the next command.