@cohortapp/agent-sdk 2.16.0 → 2.17.0

package/scripts/daemon/context-compiler.test.mjs

@@ -298,3 +298,109 @@ privilege_level: ceo
     assert.ok(!result.contextBlock.includes("DO NOT mention"), "CEO should NOT see DO NOT mention block");
   });
 });
+
+// ── Per-service interaction history (design §3 R12) ────────────────
+//
+// `responder.mjs#logInteraction` files every exchange under
+// `memory/interactions/<service>/…`. This read was pinned to `…/slack/…`, so a
+// Cohort exchange was written down and then never found — the agent had the
+// record of the conversation and could not see it.
+
+describe("interaction history is read per service", () => {
+  it("finds a Cohort conversation under memory/interactions/cohort/", async () => {
+    const dir = join(TEST_DIR, "memory", "interactions", "cohort", "chan-cohort-1");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "2026-04-06.jsonl"),
+      [
+        JSON.stringify({ ts: "3001", from: "dana", content: "the retainer number is wrong on page two", received_at: "2026-04-06T10:00:00Z" }),
+        JSON.stringify({ ts: "3002", from: "agent", content: "corrected to 48,000", received_at: "2026-04-06T10:01:00Z" }),
+      ].join("\n"),
+    );
+
+    const item = { sender: "dana", service: "cohort", channel_id: "chan-cohort-1" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("retainer number is wrong"), "Cohort history must be found");
+    assert.ok(result.contextBlock.includes("corrected to 48,000"));
+  });
+
+  it("does not read another service's directory for the same channel id", async () => {
+    const dir = join(TEST_DIR, "memory", "interactions", "telegram", "chan-shared");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "2026-04-06.jsonl"),
+      JSON.stringify({ ts: "4001", from: "dana", content: "TELEGRAM ONLY SENTINEL", received_at: "2026-04-06T10:00:00Z" }) + "\n",
+    );
+
+    const result = await compileContext({ sender: "dana", service: "cohort", channel_id: "chan-shared" }, { priority: "normal" });
+    assert.ok(!result.contextBlock.includes("TELEGRAM ONLY SENTINEL"), "one service must not read another's history");
+  });
+
+  it("an item with no service still reads the Slack tree (the historical default)", async () => {
+    const dir = join(TEST_DIR, "memory", "interactions", "slack", "D00LEGACY");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "2026-04-06.jsonl"),
+      JSON.stringify({ ts: "5001", from: "dana", content: "LEGACY SLACK LINE", received_at: "2026-04-06T10:00:00Z" }) + "\n",
+    );
+
+    const result = await compileContext({ sender: "dana", channel_id: "D00LEGACY" }, { priority: "normal" });
+    assert.ok(result.contextBlock.includes("LEGACY SLACK LINE"));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// The compiled context is BUDGETED, and what it drops is SAID (design §5.4)
+//
+// The history section used to `break` out of its loop at the char budget and
+// return the survivors, so a prompt that had quietly lost thirty turns looked
+// exactly like a conversation thirty turns shorter. `lib/context/budget.mjs`
+// owns the arithmetic and the wording now.
+// ---------------------------------------------------------------------------
+
+describe("the compiled context declares what it dropped", () => {
+  beforeEach(() => setupTestDir());
+  afterEach(() => teardownTestDir());
+
+  it("says how many earlier turns did not fit, instead of dropping them silently", async () => {
+    const dir = join(TEST_DIR, "memory", "interactions", "cohort", "chan-long");
+    mkdirSync(dir, { recursive: true });
+    const lines = [];
+    for (let i = 0; i < 400; i += 1) {
+      lines.push(JSON.stringify({
+        ts: String(6000 + i),
+        from: "dana",
+        content: `turn ${i}: ${"x".repeat(400)}`,
+        received_at: `2026-04-06T10:${String(i % 60).padStart(2, "0")}:00Z`,
+      }));
+    }
+    writeFileSync(join(dir, "2026-04-06.jsonl"), lines.join("\n"));
+
+    const result = await compileContext(
+      { sender: "dana", service: "cohort", channel_id: "chan-long" },
+      { priority: "low" },
+    );
+
+    assert.match(result.contextBlock, /earlier turns not shown/,
+      "a drop the reader cannot see is the bug this budget exists to prevent");
+    assert.ok(result.contextBlock.includes("turn 399"), "the NEWEST turns are the ones kept");
+    assert.ok(!result.contextBlock.includes("turn 0:"), "the oldest are the ones dropped");
+  });
+
+  it("says nothing when nothing was dropped", async () => {
+    const dir = join(TEST_DIR, "memory", "interactions", "cohort", "chan-short");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "2026-04-06.jsonl"),
+      JSON.stringify({ ts: "7001", from: "dana", content: "just the one line", received_at: "2026-04-06T10:00:00Z" }) + "\n",
+    );
+
+    const result = await compileContext(
+      { sender: "dana", service: "cohort", channel_id: "chan-short" },
+      { priority: "normal" },
+    );
+    assert.ok(result.contextBlock.includes("just the one line"));
+    assert.ok(!result.contextBlock.includes("not shown"), "no note when there is nothing to note");
+  });
+});

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

@@ -0,0 +1,365 @@
+/**
+ * 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); }
+});