@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/scripts/daemon/health.mjs

@@ -14,7 +14,16 @@ const AGENT_REPO_DIR = process.env.AGENT_DIR || join(new URL(".", import.meta.ur
 // --verify` reads `sdk_version` off the dashboard to tell the two apart. The
 // order of trust (sdk-version.mjs): the manifest of the copied tree, then
 // node_modules, then the package this file ships in.
-const DAEMON_SDK_VERSION = resolveRunningSdkVersion({ agentDir: AGENT_REPO_DIR, ownPackagePath: join(new URL(".", import.meta.url).pathname, "../../package.json") }).version;
+//
+// The dashboard carries the INSTALLED version and the verdict beside it,
+// because the number on its own cannot be checked. A seat reported 2.18.0 to
+// the org off its manifest while node_modules already held 2.18.1: both
+// numbers true, the disagreement the only interesting fact, and nothing on the
+// seat or in the org said it. `sdk_version_agrees` is a real tri-state —
+// `unknown` when the running version was INFERRED from the installed one, so
+// equality by fallback can never be read as a clean hop.
+const SDK = resolveRunningSdkVersion({ agentDir: AGENT_REPO_DIR, ownPackagePath: join(new URL(".", import.meta.url).pathname, "../../package.json") });
+const DAEMON_SDK_VERSION = SDK.version;
 
 let stats = {
   daemon_start: new Date().toISOString(),
@@ -58,6 +67,10 @@ export function writeHealthDashboard() {
     uptime_s: Math.floor((Date.now() - new Date(stats.daemon_start).getTime()) / 1000),
     pid: process.pid,
     sdk_version: DAEMON_SDK_VERSION,
+    sdk_version_source: SDK.runningSource,
+    sdk_version_installed: SDK.installed,
+    sdk_version_agrees: SDK.agrees === null ? "unknown" : String(SDK.agrees),
+    sdk_version_drift: SDK.drift,
     ...stats,
     dispatcher,
   };

package/scripts/daemon/maestro-daemon.mjs

@@ -39,6 +39,17 @@ process.env.MAESTRO_DAEMON = "1";
 // ---------------------------------------------------------------------------
 // 0. Environment — BEFORE anything reads a credential
 // ---------------------------------------------------------------------------
+// But first: the BOOT MARKER. The wrapper appends this process's stdout to
+// logs/daemon/daemon-<start day>.log, which carries no per-line timestamps and
+// is SHARED by every incarnation that starts on the same day — a crash at
+// 09:00 and the healthy respawn at 09:01 write to the same file. This line is
+// the first thing this incarnation prints, tagged with its pid, so a reader
+// can split the file into "before this process" and "since this process":
+// scripts/local-triggers/autoupdate.sh's health gate scans for fatal lines
+// only AFTER `[DAEMON] boot pid=<its pid>`; without it a one-off crash earlier
+// the same day read as "fatal since restart" every hour until midnight. The
+// format is pinned by autoupdate.test.mjs — change both or neither.
+console.log(`[DAEMON] boot pid=${process.pid} at=${new Date().toISOString()}`);
 // The core daemon (agent-daemon.mjs, step 4) loads .env itself, but the org
 // mesh connects at step 3b' — EARLIER in this file. Under launchd the process
 // environment is bare, so the mesh was reading COHORT_API_KEY before anything

package/scripts/daemon/prompt-builder.mjs

@@ -14,6 +14,11 @@ import { recall as orgRecall } from "../../lib/org/knowledge.mjs";
 import { outcomeSourceShareable } from "./session-outcomes.mjs";
 import { withParallelism } from "../../lib/prompts/parallelism.mjs";
 import { isPrivateConversation, historyDirNames } from "../../lib/context/history-scope.mjs";
+// A human's roll-call to the whole room: the SAME reply-shaping block the
+// quick-reply responder injects, so a roll-call that fell through to a session
+// (quick reply failed transiently) is answered in the same shape.
+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, "../..");
 
@@ -1068,6 +1073,25 @@ export async function buildPrompt(item, classResult, options = {}) {
     parts.push("");
   }
 
+  // 1d. COLLECTIVE shaping — a human addressed the whole room and every seat
+  // answers for itself. Placed with the contact blocks above because it is the
+  // same kind of instruction: what may and may not be SAID, before any work.
+  //
+  // The intent (roll-call / work / ambient) comes from `collective.mjs`, the
+  // twin of hq's `work/collective.ts`, so the same message gets the same block
+  // whether the seat is driven from here or from hq. A WORK broadcast is told
+  // its board row already exists — otherwise the session's first instinct is to
+  // open a second one.
+  if (type === "inbox" && item && isRollCallItem(item)) {
+    parts.push(
+      collectiveInstructions({
+        intent: itemCollectiveIntent(item, isRollCallItem),
+        respondents: item.respondents,
+      }),
+    );
+    parts.push("");
+  }
+
   // 2. Session context
   parts.push(`Date: ${date}`);
   parts.push(`Classification: priority=${classResult.priority}, action=${action}, category=${classResult.category || "unclassified"}`);

package/scripts/daemon/responder.mjs

@@ -72,11 +72,21 @@ 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;
@@ -144,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").
  *
@@ -176,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();
@@ -234,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 = "";
@@ -327,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
@@ -358,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 {
@@ -659,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
@@ -683,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}
 
@@ -698,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,
@@ -756,7 +920,7 @@ ${MESSAGE_CRAFT}`;
   // 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 runClaudeCLI(systemPrompt, userContent, model, {
+    const cliResult = await (deps.runCLI || runClaudeCLI)(systemPrompt, userContent, model, {
       sessionId,
       router: key ? router : null,
       routingKey: key,
@@ -764,7 +928,10 @@ ${MESSAGE_CRAFT}`;
 
     const text = (cliResult.text || "").trim();
     if (!text) {
-      throw new Error("claude CLI returned empty result text in generateResponse");
+      // 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

package/scripts/daemon/sdk-version.mjs

@@ -1,22 +1,56 @@
 /**
  * scripts/daemon/sdk-version.mjs — which SDK version is the code THIS daemon
- * process is running?
+ * process is running, which one is INSTALLED beside it, and do they agree?
  *
- * The daemon runs from the agent dir's COPIED scripts/daemon, not from
- * node_modules. autoupdate installs the next version into node_modules first
- * and merges the files a minute or two later; a daemon that (re)starts inside
- * that window would report the node_modules version while executing the old
- * copies, and `maestro upgrade --verify` would go green on a lie. So the
- * order of trust is the version of the COPIED tree first:
+ * The daemon runs from the agent dir's COPIED scripts/daemon (and ../../lib),
+ * not from node_modules. `autoupdate.sh` installs the next version into
+ * node_modules FIRST and merges the files a minute or two later; a daemon that
+ * (re)starts inside that window executes the old copies while node_modules
+ * already holds the new package. So the RUNNING version is the version of the
+ * COPIED tree, and the order of trust for it is:
  *
  *   1. .maestro/shipped-manifest.json `sdkVersion` — written by the upgrade
  *      that copied the files (2.12+), i.e. the version of scripts/daemon/*;
  *   2. node_modules/@cohortapp/agent-sdk/package.json — a pre-2.12 manifest
- *      has no sdkVersion; the window above is then the only inaccuracy left;
+ *      has no sdkVersion, so this is a fallback and NOT an observation of the
+ *      copied tree (see `runningIsInferred` below);
  *   3. the package this file itself ships in (a framework checkout).
  *
+ * ── WHY IT NO LONGER RETURNS ONE STRING ──────────────────────────────────────
+ * It used to answer with `{version, source}` and nothing else, and every caller
+ * took `.version`. That is a true answer to "what am I executing" and a silent
+ * one about everything around it: this seat reported 2.18.0 to the org — read
+ * off a manifest written by the last `maestro upgrade` — while node_modules had
+ * already been moved to 2.18.1. Neither number was wrong. What was missing was
+ * that they DISAGREED, which is the only fact an operator watching a rollout
+ * actually wants, and the one the shape could not express.
+ *
+ * It matters twice over now: `autoupdate.sh`'s health gate compares the version
+ * a beat REPORTED against the version it INSTALLED, and refuses to call the hop
+ * healthy when they differ. A resolver that collapses the two teaches that gate
+ * to compare a number with itself.
+ *
+ * So the answer carries both, plus the verdict:
+ *
+ *   running           what the copied tree is, i.e. what is executing
+ *   runningSource     "manifest" | "node_modules" | "package" | "none"
+ *   runningIsInferred true when `running` did NOT come from the manifest — the
+ *                     copied tree's version was not observed, only assumed
+ *   installed         node_modules/@cohortapp/agent-sdk, independently read
+ *   agrees            true | false | null  (null = one of them is unknown, or
+ *                     `running` was inferred FROM `installed`, in which case
+ *                     equality is an artefact of the fallback and proves
+ *                     nothing — it must never read as agreement)
+ *   drift             a one-line human reason when `agrees === false`, else ""
+ *
+ * `version` and `source` stay on the object, unchanged, so existing callers
+ * keep working; `version` is `running`.
+ *
  * Read once at daemon start, never again (the dashboard must say what the
- * process IS, not what node_modules became meanwhile).
+ * process IS, not what node_modules became meanwhile). `installed` is read in
+ * the same breath for the same reason: a later read would compare this
+ * process's code against a node_modules that has moved on since, which is a
+ * different question and not this module's.
  *
  * @module scripts/daemon/sdk-version
  */
@@ -31,21 +65,69 @@ export const SDK_PACKAGE = "@cohortapp/agent-sdk";
 /**
  * Pure over an injected reader. `readJson(path)` returns the parsed file or
  * throws / returns null; every source is fail-open.
+ *
  * @param {{agentDir:string, ownPackagePath?:string, readJson?:(p:string)=>any}} o
- * @returns {{version:string, source:"manifest"|"node_modules"|"package"|"none"}}
+ * @returns {{version:string, source:"manifest"|"node_modules"|"package"|"none",
+ *            running:string, runningSource:"manifest"|"node_modules"|"package"|"none",
+ *            runningIsInferred:boolean, installed:string,
+ *            agrees:boolean|null, drift:string}}
  */
 export function resolveRunningSdkVersion(o = {}) {
   const readJson = o.readJson || ((p) => JSON.parse(readFileSync(p, "utf8")));
   const tryRead = (p) => { try { return readJson(p); } catch { return null; /* absent/corrupt → next source */ } };
-  const manifest = tryRead(join(o.agentDir, ".maestro", "shipped-manifest.json"));
-  if (manifest && typeof manifest.sdkVersion === "string" && manifest.sdkVersion) return { version: manifest.sdkVersion, source: "manifest" };
+
+  // INSTALLED — node_modules, read on its own terms and never skipped, because
+  // it is half of the comparison even when the manifest answers first.
   const dep = tryRead(join(o.agentDir, "node_modules", ...SDK_PACKAGE.split("/"), "package.json"));
-  if (dep && dep.name === SDK_PACKAGE && typeof dep.version === "string") return { version: dep.version, source: "node_modules" };
-  if (o.ownPackagePath) {
+  const installed = dep && dep.name === SDK_PACKAGE && typeof dep.version === "string" ? dep.version : "";
+
+  // RUNNING — the copied tree, in the documented order of trust.
+  let running = "";
+  let runningSource = "none";
+  const manifest = tryRead(join(o.agentDir, ".maestro", "shipped-manifest.json"));
+  if (manifest && typeof manifest.sdkVersion === "string" && manifest.sdkVersion) {
+    running = manifest.sdkVersion;
+    runningSource = "manifest";
+  } else if (installed) {
+    running = installed;
+    runningSource = "node_modules";
+  } else if (o.ownPackagePath) {
     const own = tryRead(o.ownPackagePath);
-    if (own && own.name === SDK_PACKAGE && typeof own.version === "string") return { version: own.version, source: "package" };
+    if (own && own.name === SDK_PACKAGE && typeof own.version === "string") {
+      running = own.version;
+      runningSource = "package";
+    }
   }
-  return { version: "", source: "none" };
+
+  return {
+    version: running,
+    source: runningSource,
+    running,
+    runningSource,
+    runningIsInferred: runningSource !== "manifest",
+    installed,
+    ...verdict(running, runningSource, installed),
+  };
+}
+
+/**
+ * The comparison, separated so it is testable on its own and so the three
+ * answers are exhaustive in one place.
+ *
+ * `null` is not a weaker `true`. A run whose `running` was INFERRED from
+ * `installed` has not compared anything — the two strings are equal because one
+ * was copied from the other — and reporting that as agreement is precisely the
+ * substitution ("it is running because it is installed") that let a seat stay
+ * six days behind an hourly "up to date".
+ */
+function verdict(running, runningSource, installed) {
+  if (!running || !installed) return { agrees: null, drift: "" };
+  if (runningSource !== "manifest") return { agrees: null, drift: "" };
+  if (running === installed) return { agrees: true, drift: "" };
+  return {
+    agrees: false,
+    drift: `running ${running} (copied tree) but ${installed} is installed — an upgrade installed the package and has not merged the files yet, or a merge failed`,
+  };
 }
 
 export default { resolveRunningSdkVersion, SDK_PACKAGE };