@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/daemon/responder.mjs

@@ -28,7 +28,13 @@ import { spawn } from "child_process";
 import { join } from "path";
 import { randomUUID } from "crypto";
 import { checkRecentlySent, registerSent } from "./session-lock.mjs";
-import { routingKey as deriveRoutingKey, createRouter } from "./lib/session-router.mjs";
+import {
+  routingKey as deriveRoutingKey,
+  createRouter,
+  routerItemFromDaemonItem,
+  claimSession,
+  releaseSession,
+} from "./lib/session-router.mjs";
 // Permission scoping (security CRITICAL / audit H1). sessionPermissionArgs()
 // preserves the historical "--dangerously-skip-permissions" by default and only
 // scopes tools when the operator opts in (MAESTRO_SCOPED_PERMISSIONS=1), so the
@@ -66,11 +72,22 @@ import { generateAck } from "./assurance.mjs";
 // This path never renders the persona block, which is why the doctrine is a
 // separately-exported constant rather than part of voiceRules().
 import { MESSAGE_CRAFT } from "../../lib/identity/persona.mjs";
+// A human's roll-call to the whole room. The reply-shaping block (≤ 5 lines,
+// about myself only, no @mentions, no ack) lives with the vocabulary in
+// broadcast.mjs so the session path (prompt-builder) says the same thing this
+// path does. What the seat is DOING is not read from here: the one renderer of
+// "what am I doing" is lib/session/current-work (loadCurrentWork below), and
+// responder-single-source.test.mjs pins that no second one is imported again.
+import { isRollCallItem, collectiveInstructions } from "../../lib/org/inbound/broadcast.mjs";
+import { itemCollectiveIntent } from "../../lib/org/inbound/collective.mjs";
 
 const AGENT_REPO_DIR = process.env.AGENT_DIR || join(new URL(".", import.meta.url).pathname, "../..");
 const SONNET_MODEL = "claude-sonnet-4-6";
 // Resolve claude against the agent's PATH (not launchd's bare env).
-import { resolveClaudeBin, augmentedPath, daemonClaudeArgs } from "../../lib/claude-bin.mjs";
+import { resolveClaudeBin } from "../../lib/claude-bin.mjs";
+import { buildSpawn } from "../../lib/runtime/adapter.mjs";
+import { resolveSeatSpawn } from "../../lib/runtime/seat-engine.mjs";
+import { isPrivateConversation, interactionWriteDirNames } from "../../lib/context/history-scope.mjs";
 const CLAUDE_BIN = resolveClaudeBin();
 const CLAUDE_CLI_TIMEOUT_MS = 60_000;
 const SESSION_REGISTRY_PATH = join(AGENT_REPO_DIR, "state", "daemon", "session-router-registry.json");
@@ -101,45 +118,15 @@ function getRouter() {
 }
 
 /**
- * Translate a daemon-shaped item into the source/channel/thread_ts shape
- * that session-router's routingKey() expects.
+ * Translate a daemon-shaped item into the `{source, channel, …}` shape
+ * `session-router`'s `routingKey()` expects.
  *
- * Daemon items use {service, channel, thread_id, sender_email, ...}; the
- * router's pure key fn was specced against {source, channel, thread_ts,
- * thread_id, ...} per memo §4.2. This adapter is the seam between them.
- *
- * Returns null for items the router can't key (e.g. service we don't yet
- * support, or missing required fields). Caller falls back to a fresh
- * pre-minted UUID + EPHEMERAL semantics.
+ * The adapter itself now lives in `lib/session-router.mjs` beside the key
+ * function, because `dispatcher.mjs` needs the SAME translation: two copies
+ * would let one room be keyed two ways, which is the same thing as having no
+ * router. Exported here for the responder's own tests.
  */
-function deriveRouterItem(item) {
-  if (!item || typeof item !== "object") return null;
-
-  if (item.service === "slack") {
-    const channel = item.channel || item.channel_id;
-    if (!channel) return null;
-    return {
-      source: "slack",
-      channel,
-      thread_ts: item.thread_id || item.thread_ts || null,
-      ts: item.ts || item.timestamp || null,
-    };
-  }
-
-  if (item.service === "gmail") {
-    const tid = item.thread_id || item.threadId;
-    if (!tid) return null;
-    return { source: "gmail", thread_id: tid };
-  }
-
-  if (item.service === "calendar") {
-    const eid = item.event_id || item.eventId;
-    if (!eid) return null;
-    return { source: "calendar", event_id: eid };
-  }
-
-  return null;
-}
+export const deriveRouterItem = routerItemFromDaemonItem;
 
 // Lazy token access — dotenv loads in daemon main before these are called
 function getSlackToken() {
@@ -167,6 +154,82 @@ export function unmeasuredReasonFor({ parsed, timedOut, exitCode, parseError, ti
   return "no-json-envelope";
 }
 
+/**
+ * Build the value `runClaudeCLI` resolves with, from a clean-exit close.
+ *
+ * With a parsed JSON envelope the reply text is `result`. Without one the
+ * call FAILS CLOSED: `text` is "" and `error` names why. The raw stdout is
+ * never surfaced as text — it is a whole model turn, not a reply, and the
+ * caller's empty-text guard turns it into "nothing to send" rather than a
+ * message on the wire. `withheldChars` records how much was dropped so the
+ * operator can see the size of the turn that was kept off the wire.
+ *
+ * @param {{ parsed: object|null, rawStdout: string, exitCode: number|null }} a
+ * @returns {{ text: string, jsonResult: object|null, exitCode: number|null, error?: string, withheldChars?: number }}
+ */
+export function cliResultFor({ parsed, rawStdout, exitCode }) {
+  if (parsed) {
+    return { text: parsed.result ?? "", jsonResult: parsed, exitCode };
+  }
+  return {
+    text: "",
+    jsonResult: null,
+    exitCode,
+    error: "claude CLI output was not JSON; raw stdout withheld from the wire",
+    withheldChars: (rawStdout || "").length,
+  };
+}
+
+/**
+ * The tracker argv for a finished responder spawn — PURE, so the ledger row a
+ * given envelope produces is a unit test (engine-envelope-parity.test.mjs).
+ * `args` is everything after the tracker's script path.
+ *
+ * @param {{json:object|null, model:string, durationMs:number, exitCode:number, unmeasuredReason:string|null}} o
+ * @returns {{args:string[], measured:boolean, unmeasured:string|null}}
+ */
+export function responderCostArgs({ json, model, durationMs, exitCode, unmeasuredReason }) {
+  const usage = json && typeof json.usage === "object" && json.usage ? json.usage : null;
+  const inputTokens = usage ? Number(usage.input_tokens) : NaN;
+  const outputTokens = usage ? Number(usage.output_tokens) : NaN;
+  const measured = Number.isFinite(inputTokens) && Number.isFinite(outputTokens);
+
+  // Map the CLI-resolved model id onto the tracker's coarse pricing class.
+  const resolved = json && typeof json.model === "string" ? json.model : model || "";
+  const modelClass = /opus/i.test(resolved) ? "opus" : /haiku/i.test(resolved) ? "haiku" : "sonnet";
+
+  const args = [
+    "record",
+    "--cadence", "responder",
+    "--source", "responder",
+    "--model", modelClass,
+    "--duration-ms", String(durationMs),
+    "--exit", String(exitCode),
+  ];
+
+  let unmeasured = null;
+  if (measured) {
+    args.push("--input-tokens", String(inputTokens));
+    args.push("--output-tokens", String(outputTokens));
+    const cacheRead = Number(usage.cache_read_input_tokens);
+    if (Number.isFinite(cacheRead)) args.push("--cache-read-tokens", String(cacheRead));
+    const cacheWrite = Number(usage.cache_creation_input_tokens);
+    if (Number.isFinite(cacheWrite)) args.push("--cache-creation-tokens", String(cacheWrite));
+    // A NUMBER, not anything Number() will coerce: the Cohort Engine writes
+    // `total_cost_usd: null` when not every request reported gateway cost,
+    // and `Number(null)` is 0 — which passed the finite/non-negative check
+    // and priced the session as $0.00 authoritative. Absent is the honest
+    // flag: the tracker then prices from tokens or records the row unpriced.
+    // (dispatcher.mjs#parseUsageFromText carries the same fix.)
+    const totalCost = json.total_cost_usd;
+    if (typeof totalCost === "number" && Number.isFinite(totalCost) && totalCost >= 0) args.push("--total-cost-usd", String(totalCost));
+  } else {
+    unmeasured = unmeasuredReason || (json ? "no-usage-field" : "no-json-envelope");
+    args.push("--tokens-unknown", unmeasured);
+  }
+  return { args, measured, unmeasured };
+}
+
 /**
  * Append a cost-ledger row for a responder session (source "responder").
  *
@@ -199,40 +262,12 @@ function recordResponderCost({ json, model, durationMs, exitCode, unmeasuredReas
     const trackerPath = join(AGENT_REPO_DIR, "scripts/cost/track-claude-usage.mjs");
     if (!existsSync(trackerPath)) return;
 
-    const usage = json && typeof json.usage === "object" && json.usage ? json.usage : null;
-    const inputTokens = usage ? Number(usage.input_tokens) : NaN;
-    const outputTokens = usage ? Number(usage.output_tokens) : NaN;
-    const measured = Number.isFinite(inputTokens) && Number.isFinite(outputTokens);
-
-    // Map the CLI-resolved model id onto the tracker's coarse pricing class.
-    const resolved = json && typeof json.model === "string" ? json.model : model || "";
-    const modelClass = /opus/i.test(resolved) ? "opus" : /haiku/i.test(resolved) ? "haiku" : "sonnet";
-
-    const args = [
-      trackerPath, "record",
-      "--cadence", "responder",
-      "--source", "responder",
-      "--model", modelClass,
-      "--duration-ms", String(durationMs),
-      "--exit", String(exitCode),
-    ];
-
-    if (measured) {
-      args.push("--input-tokens", String(inputTokens));
-      args.push("--output-tokens", String(outputTokens));
-      const cacheRead = Number(usage.cache_read_input_tokens);
-      if (Number.isFinite(cacheRead)) args.push("--cache-read-tokens", String(cacheRead));
-      const cacheWrite = Number(usage.cache_creation_input_tokens);
-      if (Number.isFinite(cacheWrite)) args.push("--cache-creation-tokens", String(cacheWrite));
-      const totalCost = Number(json.total_cost_usd);
-      if (Number.isFinite(totalCost) && totalCost >= 0) args.push("--total-cost-usd", String(totalCost));
-    } else {
-      const reason = unmeasuredReason || (json ? "no-usage-field" : "no-json-envelope");
-      args.push("--tokens-unknown", reason);
-      console.warn(`[responder] session usage unmeasured (${reason}) — recorded as unknown, not zero`);
+    const { args, unmeasured } = responderCostArgs({ json, model, durationMs, exitCode, unmeasuredReason });
+    if (unmeasured) {
+      console.warn(`[responder] session usage unmeasured (${unmeasured}) — recorded as unknown, not zero`);
     }
 
-    spawn(process.execPath, args, {
+    spawn(process.execPath, [trackerPath, ...args], {
       stdio: "ignore",
       env: { ...process.env, AGENT_ROOT: AGENT_REPO_DIR, AGENT_DIR: AGENT_REPO_DIR },
     }).unref();
@@ -257,37 +292,56 @@ function recordResponderCost({ json, model, durationMs, exitCode, unmeasuredReas
 // the same UUID across spawns is the resume mechanism).
 //
 // @returns {Promise<{ text: string, jsonResult: object|null, exitCode: number }>}
+/**
+ * The responder lane's spawn — binary, argv, env — from the runtime adapter
+ * (lane "responder"): --print <permissions> <bare MCP> --model <m>
+ * --append-system-prompt <sys> --output-format json [--session-id <id>].
+ * --output-format json is requested unconditionally (it is only valid with
+ * --print, which is always passed): a reply without the usage envelope cannot
+ * be priced, and the parse keeps a raw-text fallback for older CLIs. Env is the
+ * stock posture — stale ANTHROPIC_API_KEY/AUTH_TOKEN stripped so the CLI rides
+ * the seat's subscription credential; PATH augmented.
+ *
+ * W4-E1 (CF-44): `seat` is the seat's engine resolved once for this spawn
+ * (lib/runtime/seat-engine.mjs). A claude seat adds no fields, so its spawn is
+ * unchanged; an engine-cohort seat runs `cli.mjs run`, continuing --session-id.
+ * @param {{systemPrompt:string, userPrompt:string, model:string, sessionId?:string|null, env?:object, bin?:string, seat?:{fields:object}}} o
+ */
+export function responderSpawn({ systemPrompt, userPrompt, model, sessionId = null, env = process.env, bin = CLAUDE_BIN, seat = { fields: {} } }) {
+  return buildSpawn({
+    lane: "responder",
+    bin,
+    model,
+    systemPrompt,
+    prompt: userPrompt,
+    sessionId,
+    permissions: sessionPermissionArgs({ source: "responder" }),
+    mcp: { source: "responder" },
+    env,
+    ...seat.fields,
+  });
+}
+
 function runClaudeCLI(systemPrompt, userPrompt, model, opts = {}) {
+  // W4-E1: the seat's engine, once per spawn (a claude seat reads config/agent.json only).
+  return resolveSeatSpawn(AGENT_REPO_DIR).then((seat) => runSeatCLI(seat, systemPrompt, userPrompt, model, opts));
+}
+
+function runSeatCLI(seat, systemPrompt, userPrompt, model, opts = {}) {
   const { sessionId = null, router = null, routingKey = null } = opts;
   const startedAt = Date.now();
 
   return new Promise((resolvePromise, rejectPromise) => {
-    const args = [
-      "--print",
-      ...sessionPermissionArgs({ source: "responder" }),
-      ...daemonClaudeArgs(undefined, { source: "responder" }),
-      "--model", model,
-      "--append-system-prompt", systemPrompt,
-      // --output-format json is only valid in combination with --print (per b1
-      // report). We always pass --print above, so this is safe.
-      //
-      // This used to be requested ONLY when a sessionId was supplied, which
-      // meant every non-routed reply ran with no usage envelope and therefore
-      // no way to price it. Every reply this daemon sends costs real money;
-      // asking for the envelope unconditionally is what makes it measurable.
-      // The parse below already has a raw-text fallback for older CLIs.
-      "--output-format", "json",
-    ];
-    if (sessionId) {
-      args.push("--session-id", sessionId);
+    const spawnSpec = responderSpawn({ systemPrompt, userPrompt, model, sessionId, seat });
+    if (!spawnSpec.ok) {
+      rejectPromise(new Error(`claude CLI unavailable: ${spawnSpec.error.message}`));
+      return;
     }
+    const args = spawnSpec.argv;
 
-    const proc = spawn(CLAUDE_BIN, args, {
+    const proc = spawn(spawnSpec.bin, args, {
       stdio: ["pipe", "pipe", "pipe"],
-      // Force claude CLI onto keychain OAuth (Max subscription); strip any
-      // stale ANTHROPIC_API_KEY/AUTH_TOKEN inherited from the daemon env.
-      // Augment PATH so the subsession finds homebrew/nvm tools.
-      env: { ...process.env, PATH: augmentedPath(), ANTHROPIC_API_KEY: "", ANTHROPIC_AUTH_TOKEN: "" },
+      env: spawnSpec.env,
     });
 
     let stdout = "";
@@ -350,11 +404,13 @@ function runClaudeCLI(systemPrompt, userPrompt, model, opts = {}) {
         parsed = trimmed ? JSON.parse(trimmed) : null;
         if (!parsed) parseError = new Error("no stdout");
       } catch (err) {
-        // Legacy fallback (rollout-safety): older CLIs or unexpected output
-        // shapes shouldn't crash the daemon. Log a warning, surface the raw
-        // text, and let the caller decide whether to call router.touch.
+        // Fail closed: older CLIs or unexpected output shapes must not crash
+        // the daemon, but raw stdout of a failed parse is a whole model turn
+        // (tool chatter, thinking, the un-enveloped reply) and has reached the
+        // wire before. It is withheld; the caller sees empty text plus an
+        // error and treats it as nothing to send.
         parseError = err;
-        console.warn(`[responder] claude CLI JSON parse failed (sessionId=${sessionId}): ${err.message} — falling back to raw stdout`);
+        console.error(`[responder] claude CLI JSON parse failed (sessionId=${sessionId}): ${err.message} — raw stdout withheld from the wire (${trimmed.length} chars)`);
       }
 
       // Every reply this daemon sends is a paid Claude session — INCLUDING the
@@ -381,11 +437,7 @@ function runClaudeCLI(systemPrompt, userPrompt, model, opts = {}) {
         return;
       }
 
-      if (parsed) {
-        resolvePromise({ text: parsed.result ?? "", jsonResult: parsed, exitCode: code });
-      } else {
-        resolvePromise({ text: trimmed, jsonResult: null, exitCode: code });
-      }
+      resolvePromise(cliResultFor({ parsed, rawStdout: trimmed, exitCode: code }));
     });
 
     try {
@@ -438,10 +490,17 @@ function logInteraction(item, responseText, o = {}) {
     ? resolveSlackChannel(item)
     : (item.channel_id || item.channel || null);
 
-  // Write to both channel-ID and sender-slug directories
-  const dirs = [];
-  if (channelId) dirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, String(channelId)));
-  dirs.push(join(AGENT_REPO_DIR, "memory", "interactions", service, `dm-${senderSlug}`));
+  // The room always; the PERSON only when the exchange was actually private.
+  // This used to write both unconditionally, which made `dm-<slug>` a mixed
+  // store of private and public-room content — inert only for as long as
+  // nothing read it per-service. It is read now, so the gate belongs at both
+  // ends (`lib/context/history-scope.mjs`, design §5.5).
+  const dirs = interactionWriteDirNames({
+    channelId,
+    senderSlug,
+    isPrivate: isPrivateConversation(item),
+  }).map((name) => join(AGENT_REPO_DIR, "memory", "interactions", service, String(name)));
+  if (dirs.length === 0) return;
 
   const incomingEntry = {
     ts: item.ts || item.timestamp || new Date().toISOString(),
@@ -675,6 +734,7 @@ export async function loadConversationHistory(item, deps = {}) {
 // the real generator, so behaviour is unchanged. The public senders call
 // generateResponse() through this slot.
 let _generateResponse;
+
 /**
  * Test seam: replace the response generator. Pass a function
  * `(item, classResult) => Promise<string>` to force reply text; pass nothing to
@@ -699,11 +759,99 @@ export function setGenerateResponseForTests(fn) {
  * and the flag is deliberately not kept "just in case", because keeping it is
  * how it comes back.
  */
-async function realGenerateResponse(item, classResult) {
+/**
+ * The bounded "what am I doing right now" block for a quick reply.
+ *
+ * The quick path is the one that answers a DM or a channel question IN the
+ * turn, and it carried nothing about the agent's own sessions: a "what are you
+ * doing right now?" was answered from the conversation alone, i.e. from
+ * nothing. lib/session/current-work reads the front door, its peers, the
+ * daemon's live children (with the board item each is linked to), the board
+ * items in progress and — as existence only — any interactive session a
+ * person has open on the box. ≤ 8 lines; "" when there is nothing to say.
+ *
+ * SCOPED TO THE SENDER'S CONVERSATION. A live session's summary is a
+ * restatement of someone's message; it is disclosed here only when it came
+ * from this item's conversation, and what is disclosable passes the sender's
+ * information barrier — the context compiler's `forbidsTextFor`, the same
+ * predicate the spawn path applies to history. Fail-open on the block (no
+ * block, not a failed reply); fail-CLOSED on the barrier (no predicate → the
+ * audience carries none and only same-conversation work is shown, which is
+ * the narrower answer). Injectable for tests.
+ *
+ * ON A ROLL-CALL this is the whole account of the seat — the front door, its
+ * peers, the daemon's live children, the board rows in progress / blocked /
+ * queued, the open handoffs — read ONCE, through the same audience and
+ * barrier as any other reply (a room never hears a private ask restated). A
+ * roll-call asks for `explicitEmpty`: when nothing is known the block still
+ * carries the header and the one line that says so, because a roll-call
+ * composed from no block is composed from invention.
+ *
+ * THIS is the path where an absent front door means "the daemon is
+ * answering on its own" — so this caller, and only this one, supplies
+ * {@link MAIN_ABSENT_NOTE}. The renderer is shared with `maestro session
+ * status`, `session_status` and the spawned session's context, from which
+ * that sentence would be false, so it does not carry the copy itself.
+ */
+export const MAIN_ABSENT_NOTE = "this reply comes from the background responder";
+
+export async function loadCurrentWork(item, deps = {}) {
+  const rollCall = isRollCallItem(item);
+  try {
+    const mod = await import("../../lib/session/current-work.mjs");
+    const impl = deps.currentWorkBlock || mod.currentWorkBlock;
+    let forbidsText;
+    try {
+      const ff = deps.forbidsTextFor || (await import("./context-compiler.mjs")).forbidsTextFor;
+      const slug = item && item.sender ? String(item.sender).replace(/\s+/g, "-").toLowerCase() : null;
+      forbidsText = ff(slug);
+    } catch {
+      forbidsText = undefined;
+    }
+    const audience = mod.audienceForItem(item, { isPrivate: isPrivateConversation(item), forbidsText });
+    return (await impl(AGENT_REPO_DIR, { now: Date.now(), audience, explicitEmpty: rollCall, mainAbsentNote: MAIN_ABSENT_NOTE })) || "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * The quick reply's user content. PURE — exported so the shape is pinned.
+ *
+ * The current-work block goes in under its own heading with the one rule the
+ * persona needs: describe it as your own work, and never quote a session name
+ * or id (they are internal — `session_status` says the same).
+ */
+export function buildQuickReplyUserContent({ item = {}, classResult = {}, conversationHistory = null, currentWork = "", rollCall = false } = {}) {
+  return [
+    `From: ${item.sender} (${item.sender_privilege || "unknown"})`,
+    `Via: ${item.service} / ${item.channel}`,
+    item.subject ? `Subject: ${item.subject}` : null,
+    conversationHistory ? `\nRecent conversation history:\n${conversationHistory}` : null,
+    currentWork
+      ? `\n${currentWork}\n(If asked what you are doing, answer from the lines above — as your own work, in your own words, board item ids included where a person could look one up. Never quote session names or ids.)`
+      : null,
+    `\nCurrent message:\n${item.content || "(empty)"}`,
+    // A roll-call's thread context is the room's other answers — not evidence
+    // about this seat, and exactly what the reply must not summarise.
+    !rollCall && item.thread_context ? `\nThread context:\n${item.thread_context}` : null,
+    `\nClassification: ${classResult.summary}`,
+  ].filter(Boolean).join("\n");
+}
+
+/**
+ * The real, CLI-backed answer generator. `deps` are test seams only —
+ * `{runCLI, currentWorkBlock, forbidsTextFor, loadConversationHistory}` — so
+ * the user content that reaches the model can be pinned without a spawn.
+ * Exported for that pin; production calls it through the `_generateResponse`
+ * slot with no deps.
+ */
+export async function realGenerateResponse(item, classResult, deps = {}) {
   const preamble = loadPreamble();
   const profile = loadUserProfile(item.sender);
   // The classifier's recommended model (Opus for CEO, Sonnet for routine).
   const model = classResult.model === "opus" ? "claude-opus-4-6" : SONNET_MODEL;
+  const rollCall = isRollCallItem(item);
 
   const systemPrompt = `${preamble}
 
@@ -714,20 +862,20 @@ If it's informational, acknowledge appropriately.
 Keep responses focused — 1-4 sentences for simple items, up to a short paragraph for more nuanced ones.
 Match the sender's tone and urgency level.
 ${profile ? `\nSender profile:\n${profile}` : ""}
-
+${rollCall ? `\n${collectiveInstructions({ intent: itemCollectiveIntent(item, isRollCallItem), respondents: item.respondents })}\n` : ""}
 ${MESSAGE_CRAFT}`;
 
-  const conversationHistory = await loadConversationHistory(item);
+  // A roll-call is answered from what this seat KNOWS about itself — its main
+  // session, its peers and their purposes, its board items, the sessions the
+  // daemon has running — not from the room's history, which is other people's
+  // chatter and exactly what the answer must not summarise. ONE view of self:
+  // the audience-scoped current-work block (lib/session/current-work; the
+  // session registry, barrier-aware, so a room never hears a private ask
+  // restated), read once by loadCurrentWork on every path.
+  const conversationHistory = rollCall ? null : await (deps.loadConversationHistory || loadConversationHistory)(item);
+  const currentWork = await loadCurrentWork(item, deps);
 
-  const userContent = [
-    `From: ${item.sender} (${item.sender_privilege || "unknown"})`,
-    `Via: ${item.service} / ${item.channel}`,
-    item.subject ? `Subject: ${item.subject}` : null,
-    conversationHistory ? `\nRecent conversation history:\n${conversationHistory}` : null,
-    `\nCurrent message:\n${item.content || "(empty)"}`,
-    item.thread_context ? `\nThread context:\n${item.thread_context}` : null,
-    `\nClassification: ${classResult.summary}`,
-  ].filter(Boolean).join("\n");
+  const userContent = buildQuickReplyUserContent({ item, classResult, conversationHistory, currentWork, rollCall });
 
   // (b2) Session-router decision. Compute the routing key from a daemon→router
   // adapter view of the item. If the item can't be keyed (unknown service,
@@ -738,14 +886,25 @@ ${MESSAGE_CRAFT}`;
   let sessionId = null;
   if (routerItem) {
     try {
-      key = deriveRoutingKey(routerItem);
-      const decision = router.route(key);
-      if (decision.decision === "RESUME" && decision.resumeId) {
-        sessionId = decision.resumeId;
+      const candidateKey = deriveRoutingKey(routerItem);
+      const decision = router.route(candidateKey);
+      // One CLI process per key. `claimSession` is the same lease the dispatcher
+      // takes, in the same process, so a 60-second quick reply can never be
+      // handed the session id of a long agentic run that is still going — and
+      // two quick replies from one burst cannot share a transcript either.
+      if (claimSession(candidateKey)) {
+        key = candidateKey;
+        if (decision.decision === "RESUME" && decision.resumeId) {
+          sessionId = decision.resumeId;
+        } else {
+          // EPHEMERAL or EPHEMERAL_REPLACE — pre-mint a fresh UUID. Reusing
+          // the same key on next call (with a different sessionId) is fine;
+          // touch() will overwrite the registry entry.
+          sessionId = randomUUID();
+        }
       } else {
-        // EPHEMERAL or EPHEMERAL_REPLACE — pre-mint a fresh UUID. Reusing
-        // the same key on next call (with a different sessionId) is fine;
-        // touch() will overwrite the registry entry.
+        // Already in flight: spawn cold, and stay out of the registry so the
+        // running session keeps ownership of the row.
         sessionId = randomUUID();
       }
     } catch (err) {
@@ -757,30 +916,40 @@ ${MESSAGE_CRAFT}`;
     }
   }
 
-  const cliResult = await runClaudeCLI(systemPrompt, userContent, model, {
-    sessionId,
-    router: key ? router : null,
-    routingKey: key,
-  });
+  // The claim is held across the spawn AND the registry write that follows it,
+  // and released in a `finally`: a throw anywhere in between must not leave the
+  // room's key claimed forever, which would silently disable continuity for it.
+  try {
+    const cliResult = await (deps.runCLI || runClaudeCLI)(systemPrompt, userContent, model, {
+      sessionId,
+      router: key ? router : null,
+      routingKey: key,
+    });
 
-  const text = (cliResult.text || "").trim();
-  if (!text) {
-    throw new Error("claude CLI returned empty result text in generateResponse");
-  }
+    const text = (cliResult.text || "").trim();
+    if (!text) {
+      // Empty text is "nothing to send" — including the fail-closed non-JSON
+      // path, where the raw model turn was withheld. Throwing here is what
+      // keeps it off the wire; the reason rides along for the log.
+      throw new Error(`claude CLI returned empty result text in generateResponse${cliResult.error ? ` (${cliResult.error}; ${cliResult.withheldChars ?? 0} chars withheld)` : ""}`);
+    }
 
-  // (b3) On success, touch the registry with the CLI-resolved session_id so
-  // the next call routed to this key gets a RESUME decision. Skip touch on
-  // is_error responses or when JSON parsing failed (legacy fallback path).
-  if (key && cliResult.jsonResult && cliResult.jsonResult.is_error !== true) {
-    const claudeSessionId = cliResult.jsonResult.session_id || sessionId;
-    try {
-      await router.touch(key, { claudeSessionId, model });
-    } catch (err) {
-      console.warn(`[responder] router.touch failed for ${key}: ${err.message}`);
+    // (b3) On success, touch the registry with the CLI-resolved session_id so
+    // the next call routed to this key gets a RESUME decision. Skip touch on
+    // is_error responses or when JSON parsing failed (legacy fallback path).
+    if (key && cliResult.jsonResult && cliResult.jsonResult.is_error !== true) {
+      const claudeSessionId = cliResult.jsonResult.session_id || sessionId;
+      try {
+        await router.touch(key, { claudeSessionId, model });
+      } catch (err) {
+        console.warn(`[responder] router.touch failed for ${key}: ${err.message}`);
+      }
     }
-  }
 
-  return text;
+    return text;
+  } finally {
+    if (key) releaseSession(key);
+  }
 }
 
 // Default the generator slot to the real CLI-backed implementation. (Declared