@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/scripts/daemon/dispatcher-resume.test.mjs

@@ -1,166 +0,0 @@
-/**
- * dispatcher-resume.test.mjs — audit F11: `defaultSpawnResume` built a BARE
- * env (no router, no scrub) and a bare argv (no --output-format json, no
- * knobs). A session originally routed to a third-party backend therefore
- * resumed against api.anthropic.com with a foreign model id, and every
- * resumed run recorded $0 because nothing parsed its usage.
- *
- * The resume now goes through the SAME resolveSpawnTarget / buildChildEnv
- * path as a fresh spawnSession. The pure builder is tested directly; the
- * real defaultSpawnResume is exercised through setSpawnForTests so the argv
- * and env handed to `claude` are asserted byte-for-byte.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-async function freshDispatcher() {
-  const dir = join(tmpdir(), `dispatcher-resume-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  mkdirSync(join(dir, "state/sessions"), { recursive: true });
-  mkdirSync(join(dir, "logs/daemon"), { recursive: true });
-  process.env.AGENT_DIR = dir;
-  const url = new URL("./dispatcher.mjs", import.meta.url);
-  const mod = await import(`${url.href}?resume=${Math.random()}`);
-  return { mod, dir };
-}
-async function cleanup(dir) { try { await fsp.rm(dir, { recursive: true, force: true }); } catch { /* */ } }
-function plantMarker(dir, sessionId, marker) {
-  const d = join(dir, "state/sessions/resume-pending");
-  mkdirSync(d, { recursive: true });
-  writeFileSync(join(d, `${sessionId}.json`), JSON.stringify({
-    sessionId, claudeSessionId: `cs-${sessionId}`, source: "backlog", itemId: "BL-1", sourceFile: "q.yaml",
-    prompt: "finish the memo", modelFlag: "claude-opus-4-6", model: "opus", priority: "normal",
-    startedAt: Date.now(), recoveryAttempts: 0, ...marker,
-  }, null, 2));
-}
-function writeV2Config(dir) {
-  mkdirSync(join(dir, "config"), { recursive: true });
-  writeFileSync(join(dir, "config/model-routing.json"), JSON.stringify({
-    schema_version: 2,
-    aliases: { frontier: "anthropic/claude-opus-4-8", default: "anthropic/claude-sonnet-4-6", fast: "anthropic/claude-haiku-4-5" },
-    defaults: { needs_tool_use_for_sessions: true, data_class: "sensitive", cache_ttl: "1h" },
-    backends: { anthropic: { allowed_data_classes: ["public", "internal", "sensitive"] } },
-    routing_policy: [{ default: true, chain: ["default", "fast"] }],
-    fallback_to_anthropic: true,
-  }, null, 2));
-}
-function fakeProc() {
-  const handlers = {};
-  return { stdout: { on: () => {} }, stderr: { on: () => {} }, on: (ev, cb) => { handlers[ev] = cb; }, kill: () => {}, killed: false, _handlers: handlers };
-}
-
-const ANTHROPIC_TARGET = { modelFlag: "claude-sonnet-4-6", envForSpawn: {}, decisionId: "d-1", backend: "anthropic", transport: "anthropic-cli", maxTurns: 40, effort: null, agentsJson: { "Haiku-Explore": { model: "haiku" } } };
-const RETARGET = { modelFlag: "kimi-k2", envForSpawn: { ANTHROPIC_BASE_URL: "https://moon.example", ANTHROPIC_AUTH_TOKEN: "tok-xyz", ANTHROPIC_API_KEY: "" }, decisionId: "d-2", backend: "moonshot", transport: "anthropic-compatible", maxTurns: 40, effort: "high", agentsJson: null };
-
-test("buildResumeSpawn (Anthropic): --print --output-format json + knobs + --session-id + marker model + prompt last; legacy key strip; session id in env", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const marker = { sessionId: "s-1", claudeSessionId: "CS-1", prompt: "finish the memo", modelFlag: "claude-opus-4-6", model: "opus" };
-    const { args, env, modelFlag } = mod.buildResumeSpawn({
-      marker, target: ANTHROPIC_TARGET,
-      baseEnv: { PATH: "/usr/bin", ANTHROPIC_API_KEY: "sk-live", ANTHROPIC_AUTH_TOKEN: "at", FOO_API_KEY: "foo", CLAUDE_CODE_OAUTH_TOKEN: "oauth-1" },
-      permissionArgs: ["--dangerously-skip-permissions"], daemonArgs: ["--strict-mcp-config"], augmentedPath: () => "/aug",
-    });
-    assert.equal(args[0], "--print");
-    assert.equal(args[args.indexOf("--output-format") + 1], "json", "usage is measurable on a resumed run");
-    assert.ok(args.includes("--dangerously-skip-permissions"));
-    assert.ok(args.includes("--strict-mcp-config"));
-    assert.equal(args[args.indexOf("--max-turns") + 1], "40", "the router's knob args ride the resume");
-    assert.ok(/Haiku-Explore/.test(args[args.indexOf("--agents") + 1]));
-    assert.equal(args[args.indexOf("--session-id") + 1], "CS-1");
-    assert.equal(args[args.indexOf("--model") + 1], "claude-opus-4-6", "an Anthropic session resumes on the exact flag it used");
-    assert.equal(modelFlag, "claude-opus-4-6");
-    assert.equal(args[args.length - 1], "finish the memo");
-    assert.ok(!args.includes("--resume"));
-    // Env: the non-retarget path keeps the historical explicit-empty-key posture (keychain/OAuth fallthrough).
-    assert.equal(env.ANTHROPIC_API_KEY, "");
-    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "");
-    assert.equal(env.PATH, "/aug");
-    assert.equal(env.MAESTRO_SESSION_ID, "s-1", "delivery receipts attribute to the resumed session");
-    assert.equal(env.CLAUDE_CODE_OAUTH_TOKEN, "oauth-1", "the subscription token reaches the resumed session");
-  } finally { await cleanup(dir); }
-});
-
-test("buildResumeSpawn (retarget): env goes through buildChildEnv — base URL + token injected, foreign credentials scrubbed", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const marker = { sessionId: "s-2", claudeSessionId: "CS-2", prompt: "p", modelFlag: "kimi-k2", model: "sonnet" };
-    const { args, env } = mod.buildResumeSpawn({
-      marker, target: RETARGET,
-      baseEnv: { PATH: "/usr/bin", ANTHROPIC_API_KEY: "sk-live", FOO_API_KEY: "foo", HOME: "/h" },
-      permissionArgs: [], daemonArgs: [], augmentedPath: () => "/aug",
-    });
-    assert.equal(env.ANTHROPIC_BASE_URL, "https://moon.example", "the resumed session is retargeted like the original");
-    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "tok-xyz");
-    assert.equal(env.ANTHROPIC_API_KEY, "", "empty-string discipline: no keychain fallthrough on a retarget");
-    assert.equal(env.FOO_API_KEY, undefined, "§7.3 scrub: no foreign credential leaks");
-    assert.equal(env.HOME, "/h");
-    assert.equal(env.PATH, "/aug");
-    assert.equal(env.MAESTRO_SESSION_ID, "s-2");
-    assert.equal(args[args.indexOf("--model") + 1], "kimi-k2");
-    assert.equal(args[args.indexOf("--effort") + 1], "high");
-  } finally { await cleanup(dir); }
-});
-
-test("resumeModelFlag: a foreign model id never resumes against Anthropic (F11) — the router's current flag wins", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // Original ran on a third party; the router now resolves Anthropic (provider down / config changed).
-    assert.equal(mod.resumeModelFlag({ modelFlag: "moonshot/kimi-k2" }, ANTHROPIC_TARGET), "claude-sonnet-4-6");
-    assert.equal(mod.resumeModelFlag({ modelFlag: "kimi-k2" }, ANTHROPIC_TARGET), "claude-sonnet-4-6");
-    // Original ran on Anthropic; still Anthropic → the exact flag it used (H1 pin).
-    assert.equal(mod.resumeModelFlag({ modelFlag: "claude-opus-4-6" }, ANTHROPIC_TARGET), "claude-opus-4-6");
-    assert.equal(mod.resumeModelFlag({ modelFlag: "opus" }, ANTHROPIC_TARGET), "opus");
-    // A retarget: the router's flag for that backend.
-    assert.equal(mod.resumeModelFlag({ modelFlag: "claude-opus-4-6" }, RETARGET), "kimi-k2");
-    // No router at all (target null) → marker flag, then coarse class, then sonnet.
-    assert.equal(mod.resumeModelFlag({ modelFlag: "claude-opus-4-6" }, null), "claude-opus-4-6");
-    assert.equal(mod.resumeModelFlag({ model: "opus" }, null), "opus");
-    assert.equal(mod.resumeModelFlag({}, null), "sonnet");
-  } finally { await cleanup(dir); }
-});
-
-test("defaultSpawnResume (real path, v2 config): argv carries --output-format json + router knobs; env carries the session id and the key strip", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    writeV2Config(dir);
-    plantMarker(dir, "s-real", { claudeSessionId: "CS-FIXED", prompt: "finish drafting the board memo", modelFlag: "claude-opus-4-6" });
-    const calls = [];
-    const restore = mod.setSpawnForTests((bin, args, opts) => { calls.push({ bin, args, opts }); return fakeProc(); });
-    try {
-      const stats = mod.reconcileResumePending();
-      assert.equal(stats.resumed, 1);
-    } finally { restore(); }
-    assert.equal(calls.length, 1);
-    const { args, opts } = calls[0];
-    assert.equal(args[0], "--print");
-    assert.equal(args[args.indexOf("--output-format") + 1], "json");
-    assert.equal(args[args.indexOf("--max-turns") + 1], "40", "v2 knobs are no longer dropped on resume");
-    assert.ok(args.includes("--agents"));
-    assert.equal(args[args.indexOf("--session-id") + 1], "CS-FIXED");
-    assert.equal(args[args.indexOf("--model") + 1], "claude-opus-4-6");
-    assert.equal(args[args.length - 1], "finish drafting the board memo");
-    assert.ok(!args.includes("--resume"));
-    assert.equal(opts.env.MAESTRO_SESSION_ID, "s-real");
-    assert.equal(opts.env.ANTHROPIC_API_KEY, "");
-    assert.equal(opts.cwd, dir);
-  } finally { await cleanup(dir); }
-});
-
-test("defaultSpawnResume (no routing config): still a --print --output-format json spawn on the marker's flag", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    plantMarker(dir, "s-plain", { claudeSessionId: "CS-P", prompt: "p", modelFlag: "claude-sonnet-4-6" });
-    const calls = [];
-    const restore = mod.setSpawnForTests((bin, args, opts) => { calls.push({ args, opts }); return fakeProc(); });
-    try { mod.reconcileResumePending(); } finally { restore(); }
-    const { args } = calls[0];
-    assert.equal(args[args.indexOf("--output-format") + 1], "json");
-    assert.equal(args[args.indexOf("--model") + 1], "claude-sonnet-4-6");
-    assert.ok(!args.includes("--max-turns"), "no router → no knobs (unchanged)");
-  } finally { await cleanup(dir); }
-});

package/scripts/daemon/dispatcher-session-continuity.test.mjs

@@ -1,365 +0,0 @@
-/**
- * dispatcher-session-continuity.test.mjs — session continuity and effort
- * routing on the dispatch path (design §5.6, R10 + R13).
- *
- * Two defects are pinned here:
- *
- *   1. `randomUUID()` per dispatch. Every full session in a live thread started
- *      COLD — the agent re-read the room and answered a follow-up as if it were
- *      an opening. The router the responder already consults now keys the
- *      conversation, and a follow-up inside the TTL continues it.
- *   2. `taskClass = "session.responder"`, hardcoded. `effort` was therefore
- *      always null and `maxTurns` always 40, so complexity moved the model and
- *      the timeout and nothing else.
- *
- * The dispatcher is stateful and binds AGENT_DIR at import, so every test takes
- * a fresh module against its own tmpdir.
- *
- * Run: node --test scripts/daemon/dispatcher-session-continuity.test.mjs
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { replyTier } from "../../lib/assurance/tier.mjs";
-import { promises as fsp, mkdirSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-/**
- * The governor/breaker are injected ADMIT for every test here, because none of
- * these tests is about admission — and the real governor reads live machine
- * load, so under a full-suite run it can QUEUE a dispatch and the session id
- * under test is never spawned at all. (It did: these passed alone and failed in
- * `npm test`.) `dispatcher-governance.test.mjs` owns the admission decisions.
- */
-const ADMIT_ALL = {
-  governor: { admit: () => ({ decision: "ADMIT", reason: "forced-ADMIT", snapshot: {} }), defaultDeps: () => ({}) },
-  rateGuard: { checkRateLimit: () => ({ allowed: true, retryAt: null }), classifyStderr: () => false, recordRateLimit: () => {}, recordSuccess: () => {} },
-  budgetGuard: { dailyStatus: () => ({ essentialOnly: false }) },
-};
-
-/**
- * The in-flight lease lives in `lib/session-router.mjs` at MODULE scope, which
- * is correct — one daemon process, one set of child processes — but it means a
- * dispatch whose fake proc never closes leaves its key claimed for the rest of
- * the file. Reset it per test, the way the real process would by exiting.
- *
- * Imported INSIDE `freshDispatcher`, after AGENT_DIR is pointed at the tmpdir:
- * session-router pulls in `session-lock.mjs`, which binds its claim directory
- * from AGENT_DIR at ITS first import. Importing it at module scope bound that
- * to the real repo and left `.claim` files in the working tree.
- */
-async function freshDispatcher() {
-  const dir = join(tmpdir(), `dispatcher-cont-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(join(dir, "state/sessions"), { recursive: true });
-  await fsp.mkdir(join(dir, "state/daemon"), { recursive: true });
-  await fsp.mkdir(join(dir, "logs/daemon"), { recursive: true });
-  process.env.AGENT_DIR = dir;
-  const { _resetInFlightForTests } = await import("./lib/session-router.mjs");
-  _resetInFlightForTests();
-  const url = new URL("./dispatcher.mjs", import.meta.url);
-  const mod = await import(`${url.href}?test=${Math.random()}`);
-  mod.setGovernanceForTests(ADMIT_ALL);
-  return { mod, dir };
-}
-
-async function cleanup(dir) {
-  try { await fsp.rm(dir, { recursive: true, force: true }); } catch { /* */ }
-}
-
-function writeV2Config(dir) {
-  mkdirSync(join(dir, "config"), { recursive: true });
-  writeFileSync(join(dir, "config/model-routing.json"), JSON.stringify({
-    schema_version: 2,
-    aliases: { frontier: "anthropic/claude-opus-4-8", default: "anthropic/claude-sonnet-4-6", fast: "anthropic/claude-haiku-4-5" },
-    defaults: { needs_tool_use_for_sessions: true, data_class: "sensitive", cache_ttl: "1h" },
-    backends: { anthropic: { allowed_data_classes: ["public", "internal", "sensitive"] } },
-    routing_policy: [{ default: true, chain: ["default", "fast"] }],
-    fallback_to_anthropic: true,
-  }, null, 2));
-}
-
-function fakeProc() {
-  const handlers = {};
-  return { stdout: { on: () => {} }, stderr: { on: () => {} }, on: (ev, cb) => { handlers[ev] = cb; }, kill: () => {}, killed: false, _handlers: handlers };
-}
-
-const COHORT_ITEM = {
-  id: "i-1",
-  service: "cohort",
-  channel: "engineering",          // the display label
-  channel_id: "chan-eng",          // the real room
-  sender: "Dana",
-  content: "pick up where we left off",
-};
-const WORK = { priority: "normal", action: "respond", model: "sonnet", summary: "follow-up in the engineering room", answerable: false };
-
-/** Dispatch once and return the argv + the captured child process. */
-function dispatchOnce(mod, item, classResult) {
-  const calls = [];
-  const procs = [];
-  const restore = mod.setSpawnForTests((bin, args) => { calls.push(args); const p = fakeProc(); procs.push(p); return p; });
-  try {
-    mod.dispatch("do the thing", item, classResult, "inbox");
-  } finally { restore(); }
-  assert.equal(calls.length, 1, "the dispatch did not spawn — admission, not session routing");
-  return { args: calls[0], proc: procs[0] };
-}
-
-const sessionIdOf = (args) => args[args.indexOf("--session-id") + 1];
-
-// ---------------------------------------------------------------------------
-// the tier → task class
-// ---------------------------------------------------------------------------
-
-test("replyTier: answerable alone is NOT the answer tier — the rung is required", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // The five rules of lib/assurance/tier.mjs#replyTier, in its order.
-    assert.equal(replyTier({ answerable: true, rung: 0 }), "answer");
-    assert.equal(replyTier({ answerable: true, rung: 1 }), "answer");
-    assert.equal(replyTier({ willSpawnSession: false }), "answer");
-
-    // THE BUG THIS PINS. `resolveSpawnTarget` runs only for items isQuickReply()
-    // REFUSED, and execution-ladder pins that a rung-3 answerable ask is exactly
-    // such an item. Reading `answerable` alone gave it 6 turns at low effort
-    // where the real module gives 60 at high.
-    assert.equal(replyTier({ answerable: true, rung: 3 }), "plan");
-    assert.equal(replyTier({ answerable: true, action: "respond", priority: "normal" }), "work",
-      "an unrouted answerable ask is work, never answer — unknown buys nothing");
-
-    assert.equal(replyTier({ rung: 4 }), "plan");
-    assert.equal(replyTier({ action: "research", priority: "critical" }), "plan");
-    assert.equal(replyTier({ action: "draft", priority: "high" }), "plan");
-    // …but only at the priorities the design names.
-    assert.equal(replyTier({ action: "research", priority: "normal" }), "work");
-    assert.equal(replyTier({ action: "respond", priority: "critical" }), "work");
-    // A stale or malformed rung is not a rung.
-    assert.equal(replyTier({ answerable: true, rung: "1" }), "work");
-    assert.equal(replyTier({ rung: 9 }), "work");
-    // An unrecognised classification is WORK — the historical behaviour.
-    assert.equal(replyTier({}), "work");
-    assert.equal(replyTier(), "work");
-  } finally { await cleanup(dir); }
-});
-
-/**
- * There used to be a test here asserting that dispatcher.mjs's own copy of the
- * tier table agreed with `lib/assurance/tier.mjs`. It earned its place: at the
- * merge it FAILED, because the copy predated the review fix that added
- * `willSpawnSession !== true` to rule (2) — so an item the quick path fell
- * through on would have been tiered `answer` (total silence) while a long
- * session ran. The copy is gone and the dispatcher imports the one definition,
- * which makes the agreement test tautological.
- *
- * What it was really protecting is that the dispatcher's task-class mapping is
- * driven by that module and degrades safely, so THAT is what is pinned now.
- */
-test("a tier module that throws does not stop a dispatch — it degrades to work", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // `work` is the tier the flood was made of and the one that speaks at most
-    // once: the right thing to land on when the decision is unavailable.
-    assert.equal(mod.taskClassFor({ rung: 4 }), "session.plan");
-    assert.equal(mod.taskClassFor({ answerable: true, rung: 0 }), "session.answer");
-    assert.equal(mod.taskClassFor({}), "session.responder");
-    assert.equal(mod.taskClassFor(), "session.responder");
-  } finally { await cleanup(dir); }
-});
-
-test("rungForItem reads the ladder's decision off the item, not a field the classifier never emits", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // agent-daemon.mjs stamps `item.execution = routed`. classifier.mjs emits no
-    // `rung` at all, so reading classResult.rung finds undefined forever —
-    // which would make session.answer's knobs dead code.
-    assert.equal(mod.rungForItem({ execution: { rung: 1 } }), 1);
-    assert.equal(mod.rungForItem({ execution: { rung: 3, mechanism: "dispatcher-spawn" } }), 3);
-    assert.equal(mod.rungForItem({ rung: 0 }), 0);
-    assert.equal(mod.rungForItem({}), null);
-    assert.equal(mod.rungForItem(null), null);
-    assert.equal(mod.rungForItem({ execution: { rung: "2" } }), null);
-  } finally { await cleanup(dir); }
-});
-
-test("taskClassFor maps each tier onto the class that carries its knobs", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    assert.equal(mod.taskClassFor({ answerable: true }, { execution: { rung: 0 } }), "session.answer");
-    assert.equal(mod.taskClassFor({ action: "respond", priority: "normal" }), "session.responder");
-    assert.equal(mod.taskClassFor({ action: "research", priority: "critical" }), "session.plan");
-    assert.equal(mod.taskClassFor({ answerable: true }, { execution: { rung: 3 } }), "session.plan",
-      "the ladder said this needs a session; 6 turns at low effort is the wrong answer, fast");
-    assert.equal(mod.taskClassFor(null), "session.responder", "no classification is not an excuse to throw");
-  } finally { await cleanup(dir); }
-});
-
-test("effort finally varies with the ask — a plan spawns with high effort, an answer with low", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    writeV2Config(dir);
-    const plan = dispatchOnce(mod, { ...COHORT_ITEM, id: "i-plan" },
-      { priority: "critical", action: "research", model: "opus", summary: "work out the pricing", answerable: false });
-    assert.equal(plan.args[plan.args.indexOf("--effort") + 1], "high");
-
-    // The ladder placed this at rung 0 — a single protocol call — so the answer
-    // tier is a fact about the routed work, not an opinion about the question.
-    const answer = dispatchOnce(mod,
-      { ...COHORT_ITEM, id: "i-ans", channel_id: "chan-other", execution: { rung: 0, mechanism: "tool-surface" } },
-      { priority: "normal", action: "respond", model: "sonnet", summary: "which model are you", answerable: true });
-    assert.equal(answer.args[answer.args.indexOf("--effort") + 1], "low");
-    assert.equal(answer.args[answer.args.indexOf("--max-turns") + 1], "6", "an answerable question does not need 40 turns");
-  } finally { await cleanup(dir); }
-});
-
-test("an answerable ask the LADDER routed to a session does not get the 6-turn knobs", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    writeV2Config(dir);
-    const routed = dispatchOnce(mod,
-      { ...COHORT_ITEM, id: "i-rung3", channel_id: "chan-rung3", execution: { rung: 3, mechanism: "dispatcher-spawn" } },
-      { priority: "normal", action: "respond", model: "sonnet", summary: "reconcile the two models", answerable: true });
-    assert.notEqual(routed.args[routed.args.indexOf("--max-turns") + 1], "6",
-      "a session that runs out of turns without replying leaves its obligation open — which is the retry loop");
-    assert.equal(routed.args[routed.args.indexOf("--effort") + 1], "high");
-  } finally { await cleanup(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// session continuity
-// ---------------------------------------------------------------------------
-
-test("a follow-up in the same Cohort room CONTINUES the session instead of starting cold", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const first = dispatchOnce(mod, COHORT_ITEM, WORK);
-    const firstId = sessionIdOf(first.args);
-    assert.ok(firstId, "a session id is always passed");
-
-    // The session finishes cleanly — the key goes live in the registry.
-    first.proc._handlers.close(0);
-
-    const second = dispatchOnce(mod, { ...COHORT_ITEM, id: "i-2", content: "and the second half?" }, WORK);
-    assert.equal(sessionIdOf(second.args), firstId, "the follow-up must continue, not re-open");
-  } finally { await cleanup(dir); }
-});
-
-test("a DIFFERENT room gets a different session", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const a = dispatchOnce(mod, COHORT_ITEM, WORK);
-    a.proc._handlers.close(0);
-    const b = dispatchOnce(mod, { ...COHORT_ITEM, id: "i-3", channel_id: "chan-sales" }, WORK);
-    assert.notEqual(sessionIdOf(b.args), sessionIdOf(a.args));
-  } finally { await cleanup(dir); }
-});
-
-test("a session that exited NON-ZERO is never resumed into", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const first = dispatchOnce(mod, COHORT_ITEM, WORK);
-    first.proc._handlers.close(1);
-    const second = dispatchOnce(mod, { ...COHORT_ITEM, id: "i-4" }, WORK);
-    assert.notEqual(sessionIdOf(second.args), sessionIdOf(first.args));
-  } finally { await cleanup(dir); }
-});
-
-test("BACKLOG work is never keyed — it is not a conversation", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const calls = [];
-    const procs = [];
-    const restore = mod.setSpawnForTests((bin, args) => { calls.push(args); const p = fakeProc(); procs.push(p); return p; });
-    try {
-      const backlogItem = { id: "b-1", title: "Write the runbook", service: "cohort", channel_id: "chan-eng" };
-      mod.dispatch("p", backlogItem, { ...WORK, summary: "runbook" }, "backlog");
-      procs[0]._handlers.close(0);
-      mod.dispatch("p", { ...backlogItem, id: "b-2" }, { ...WORK, summary: "runbook again" }, "backlog");
-    } finally { restore(); }
-    assert.equal(calls.length, 2);
-    assert.notEqual(sessionIdOf(calls[1]), sessionIdOf(calls[0]), "two backlog items must not share a session");
-  } finally { await cleanup(dir); }
-});
-
-test("an item the router cannot key still dispatches, with a fresh id", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // A Cohort surface with only a DISPLAY label — no room id to key on.
-    const labelOnly = { id: "i-5", service: "cohort", channel: "doc/Pricing memo", sender: "Dana", content: "?" };
-    const a = dispatchOnce(mod, labelOnly, WORK);
-    a.proc._handlers.close(0);
-    const b = dispatchOnce(mod, { ...labelOnly, id: "i-6" }, WORK);
-    assert.ok(sessionIdOf(a.args));
-    assert.notEqual(sessionIdOf(b.args), sessionIdOf(a.args));
-  } finally { await cleanup(dir); }
-});
-
-test("crash recovery still gets a resume marker carrying the session id in play", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const first = dispatchOnce(mod, COHORT_ITEM, WORK);
-    const markers = await fsp.readdir(join(dir, "state", "sessions", "resume-pending"));
-    assert.equal(markers.length, 1, "the in-flight marker is unchanged by session routing");
-    const marker = JSON.parse(await fsp.readFile(join(dir, "state", "sessions", "resume-pending", markers[0]), "utf-8"));
-    assert.equal(marker.claudeSessionId, sessionIdOf(first.args));
-  } finally { await cleanup(dir); }
-});
-
-// ---------------------------------------------------------------------------
-// ONE CLI PROCESS PER SESSION ID
-//
-// A registry row only goes live when a session CLOSES cleanly, so the registry
-// alone cannot say "something is already running on this key". It did not have
-// to before — every dispatch minted its own UUID. Now they share a key, and the
-// room that produced 9,187 messages in 21 days is a TOP-LEVEL channel, where
-// agent-daemon's thread lock (which needs a thread id, or a DM) does not apply.
-// Without an in-flight lease a burst of three puts three
-// `claude --print --session-id <same id>` processes on ONE transcript.
-// ---------------------------------------------------------------------------
-
-test("a burst in one room never puts two processes on ONE session id", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    // Turn one completes cleanly: the key is live in the registry.
-    const first = dispatchOnce(mod, COHORT_ITEM, WORK);
-    first.proc._handlers.close(0);
-    const liveId = sessionIdOf(first.args);
-
-    // Three more land while nothing has finished.
-    const burst = [
-      dispatchOnce(mod, { ...COHORT_ITEM, id: "burst-1", content: "and the margin?" }, WORK),
-      dispatchOnce(mod, { ...COHORT_ITEM, id: "burst-2", content: "and the runway?" }, WORK),
-      dispatchOnce(mod, { ...COHORT_ITEM, id: "burst-3", content: "and the headcount?" }, WORK),
-    ];
-    const ids = burst.map((b) => sessionIdOf(b.args));
-
-    assert.equal(ids[0], liveId, "the first of the burst legitimately continues the finished session");
-    assert.equal(new Set(ids).size, 3, "every concurrent turn must have its OWN session id");
-    assert.equal(ids.filter((id) => id === liveId).length, 1, "exactly one process may hold the live id");
-
-    // …and once the room goes quiet, continuity comes back.
-    burst.forEach((b) => b.proc._handlers.close(0));
-    const later = dispatchOnce(mod, { ...COHORT_ITEM, id: "burst-4", content: "thanks — one more" }, WORK);
-    assert.equal(typeof sessionIdOf(later.args), "string");
-  } finally { await cleanup(dir); }
-});
-
-test("a spawn that ERRORS releases the room's key rather than stranding it", async () => {
-  const { mod, dir } = await freshDispatcher();
-  try {
-    const first = dispatchOnce(mod, COHORT_ITEM, WORK);
-    first.proc._handlers.close(0);
-    const liveId = sessionIdOf(first.args);
-
-    const failed = dispatchOnce(mod, { ...COHORT_ITEM, id: "e-1" }, WORK);
-    assert.equal(sessionIdOf(failed.args), liveId);
-    failed.proc._handlers.error(Object.assign(new Error("spawn ENOENT"), { code: "ENOENT" }));
-
-    // The key is free again: the next turn is routed, not permanently cold.
-    const next = dispatchOnce(mod, { ...COHORT_ITEM, id: "e-2" }, WORK);
-    assert.equal(typeof sessionIdOf(next.args), "string");
-    next.proc._handlers.close(0);
-    const after = dispatchOnce(mod, { ...COHORT_ITEM, id: "e-3" }, WORK);
-    assert.equal(sessionIdOf(after.args), sessionIdOf(next.args), "continuity works again after the failure");
-  } finally { await cleanup(dir); }
-});