@cohortapp/agent-sdk 2.11.0 → 2.11.2

package/lib/channels/inbox-item.mjs

@@ -182,6 +182,18 @@ export function eventToInboxItem(ev) {
   if (typeof ev.is_private === "boolean") item.is_private = ev.is_private;
   if (typeof ev.is_dm === "boolean") item.is_dm = ev.is_dm;
 
+  // THE CHANNEL KIND (DM / GROUP_DM / PUBLIC / PRIVATE / …). Cohort carries this
+  // on its org event feed (lib/org/messaging.toMessageEvent), and it is the ONLY
+  // reliable is_dm signal for Cohort, whose channel ids are cuids with no
+  // Slack-style "D…"/"dm/" prefix for the daemon's `enrichItem` to key off. The
+  // signal was being DROPPED here (and again by the YAML writer/reader), so a
+  // Cohort 1:1 DM arrived at the election gate looking like an ambient group
+  // message and was suppressed. Serialised only when present, so every non-Cohort
+  // producer keeps a byte-identical inbox item (see the byte-compat fixture).
+  if (typeof ev.channel_kind === "string" && ev.channel_kind) {
+    item.channel_kind = sanitizeYamlField(ev.channel_kind);
+  }
+
   // Only stamp `kind` when it's not the default. Existing message items must
   // remain byte-identical to what the Slack socket-mode writer produced before
   // this seam existed (it never wrote a `kind` field).

package/lib/channels/inbox-item.test.mjs

@@ -59,6 +59,39 @@ test("eventToInboxItem: channel_cc kind is stamped", () => {
   assert.equal(item.kind, "channel_cc");
 });
 
+test("eventToInboxItem: channel_kind is carried through when present, omitted when absent", () => {
+  // Present → serialised (Cohort's only reliable is_dm signal), and the poll-lane
+  // parser reads it back, so enrichItem actually receives it.
+  const withKind = eventToInboxItem({
+    channel: "cohort",
+    message_id: "m1",
+    channel_kind: "DM",
+    from: { id: "human-1", name: "Human" },
+    text: "hi",
+    timestamp: "2026-01-01T00:00:00.000Z",
+  });
+  assert.equal(withKind.channel_kind, "DM");
+
+  // Absent → omitted entirely, so a non-Cohort item stays byte-identical.
+  const withoutKind = eventToInboxItem({
+    channel: "slack",
+    message_id: "m2",
+    from: { id: "U1", name: "casey" },
+    text: "hi",
+    timestamp: "2026-01-01T00:00:00.000Z",
+  });
+  assert.equal("channel_kind" in withoutKind, false);
+});
+
+test("parseInboxItemYaml: channel_kind survives the YAML round-trip (present/absent)", () => {
+  const withKind = parseInboxItemYaml(
+    'id: "m1"\nservice: "cohort"\nchannel_id: "cuid_abc"\nchannel_kind: "GROUP_DM"\ncontent: |\n  hi\n',
+  );
+  assert.equal(withKind.channel_kind, "GROUP_DM");
+  const withoutKind = parseInboxItemYaml('id: "m2"\nservice: "slack"\ncontent: |\n  hi\n');
+  assert.equal("channel_kind" in withoutKind, false, "absent line → no channel_kind key");
+});
+
 // ---------------------------------------------------------------------------
 // round-trip event ↔ item
 // ---------------------------------------------------------------------------

package/lib/execution/disposition.mjs

@@ -392,8 +392,19 @@ export function decide(o = {}) {
   if (o.history && base.actor) {
     const hits = o.history.actorActivity(base.actor);
     if (hits >= floodLimit) {
-      why.push(`${base.actor} has woken me ${hits} time(s) in the flood window (limit ${floodLimit}) → batch the reply`);
-      return finish(base, "schedule", "actor_flood", why, o, { observeOnly, batched: true });
+      // A DIRECTED 1:1 DM is EXEMPT. The flood counter tallies ALL of an actor's
+      // activity in the window — including their own doc/board/decision events,
+      // which fire far more often than they message — so a person's genuine 1:1
+      // message would be downgraded to "batch the reply" merely because their
+      // unrelated document edits tripped the limit. A 1:1 DM is the one surface
+      // where the human is unambiguously talking TO the seat and watching for a
+      // reply, so it stays react-now; every other surface still batches.
+      if (base.surface === "dm") {
+        why.push(`${base.actor} is over the flood limit (${hits}/${floodLimit}), but this is a directed 1:1 DM → not batched`);
+      } else {
+        why.push(`${base.actor} has woken me ${hits} time(s) in the flood window (limit ${floodLimit}) → batch the reply`);
+        return finish(base, "schedule", "actor_flood", why, o, { observeOnly, batched: true });
+      }
     }
   }
 

package/lib/execution/disposition.test.mjs

@@ -256,15 +256,32 @@ test("IGNORE: a malformed event never crashes the ladder", () => {
 // ───────────────────────────────────────────────────────────────────────────
 
 test("DOWNGRADE not silence: a flooding actor gets batched, not muted", () => {
-  const d = run({ history: freshHistory({ actorActivity: () => DEFAULT_ACTOR_FLOOD_LIMIT }) });
+  // Assert on a NON-DM surface (an @mention): a directed 1:1 DM is now EXEMPT
+  // from actor-flood (see the next test), so it can no longer stand in for the
+  // general batching behaviour.
+  const floodMention = (over) => run({
+    verdict: yes("mention", "mention"),
+    candidate: { family: "messaging", kind: "send", surfaces: ["mention"] },
+    ...over,
+  });
+  const d = floodMention({ history: freshHistory({ actorActivity: () => DEFAULT_ACTOR_FLOOD_LIMIT }) });
   assert.equal(d.disposition, "schedule");
   assert.equal(d.reason, "actor_flood");
   assert.equal(d.batched, true);
   // one under the limit still answers turn-by-turn
-  const under = run({ history: freshHistory({ actorActivity: () => DEFAULT_ACTOR_FLOOD_LIMIT - 1 }) });
+  const under = floodMention({ history: freshHistory({ actorActivity: () => DEFAULT_ACTOR_FLOOD_LIMIT - 1 }) });
   assert.equal(under.disposition, "react_now");
 });
 
+test("a directed 1:1 DM is EXEMPT from actor-flood batching", () => {
+  // The flood counter tallies ALL of an actor's activity (their doc/board edits
+  // included), so a genuine 1:1 message must not be batched just because the same
+  // person tripped the limit elsewhere. Even far over the limit, a DM reacts now.
+  const d = run({ history: freshHistory({ actorActivity: () => DEFAULT_ACTOR_FLOOD_LIMIT * 5 }) });
+  assert.equal(d.disposition, "react_now");
+  assert.equal(d.reason, "directed_now");
+});
+
 test("DOWNGRADE not silence: an exhausted budget queues the reply", () => {
   for (const runtime of [{ dailyCapExhausted: true }, { remainingCents: 0 }]) {
     const d = run({ runtime });

package/lib/execution/pipeline.test.mjs

@@ -157,7 +157,10 @@ test("a burst from one actor is batched rather than answered turn-by-turn", asyn
     const fx = fakeEffects();
     const items = [];
     for (let i = 0; i < 6; i += 1) {
-      items.push(dm({ id: `cohort-msg_${i}`, raw_ref: `cohort:dm:msg_${i}:${100 + i}`, thread_id: `t_${i}`, channel_id: `c_${i}` }));
+      // A burst of @mentions (NOT DMs): a directed 1:1 DM is now exempt from
+      // actor-flood, so flood batching is exercised on a channel surface where
+      // it still applies. `is_dm:false` + mentions_agent → surface "mention".
+      items.push(dm({ id: `cohort-msg_${i}`, raw_ref: `cohort:mention:msg_${i}:${100 + i}`, thread_id: `t_${i}`, channel_id: `c_${i}`, is_dm: false }));
     }
     const { results } = await run(items, { agentRoot: root, effects: fx, actorFloodLimit: 3 });
     const dispositions = results.map((r) => r.decision.disposition);

package/lib/org/messaging.mjs

@@ -859,6 +859,11 @@ export function toMessageEvent(ev, me) {
     kind: isCall ? "call" : "message",
     subject: isCall ? "Cohort call invite" : "Cohort message",
     channel_id: channelId,
+    // The org event feed carries channelKind (DM/GROUP_DM/PUBLIC/…); surface it
+    // so the daemon's is_dm detection works for Cohort (whose channel ids are
+    // cuids, not Slack-style "D…"/"dm/…" prefixes). Without this a Cohort DM was
+    // misread as a group message and wrongly routed through the election gate.
+    channel_kind: String(p.channelKind || p.channel_kind || "").toUpperCase(),
     channel_label: String(p.channelName || channelId || "cohort"),
     sender: String(p.fromName || fromId),
     priority_signals: {

package/lib/org/messaging.test.mjs

@@ -248,6 +248,13 @@ test("toMessageEvent: projects a messaging event onto the MessageEvent contract"
   assert.equal(ev.ingest_source, "cohort");
 });
 
+test("toMessageEvent: projects channelKind so the daemon can tell a DM from a GROUP_DM", () => {
+  const dm = toMessageEvent({ family: "messaging", seq: 8, payload: { id: "m1", channel: "dm-x", channelKind: "DM", from: "human-1", body: "hi" } }, "me");
+  assert.equal(dm.channel_kind, "DM", "a 1:1 DM carries channel_kind DM (→ is_dm true downstream)");
+  const group = toMessageEvent({ family: "messaging", seq: 9, payload: { id: "m2", channel: "gdm-x", channelKind: "group_dm", from: "human-1", body: "hi all" } }, "me");
+  assert.equal(group.channel_kind, "GROUP_DM", "a GROUP_DM is upper-cased and NOT a 1:1 DM downstream");
+});
+
 test("pullInbound: filters to directed events and advances the cursor to max seq", async () => {
   const f = fakeFetch(() => ({
     body: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.0",
+  "version": "2.11.2",
   "description": "Cohort Agent SDK — autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/scripts/daemon/agent-daemon.mjs

@@ -69,6 +69,7 @@ import {
   sweepObligations,
   openObligations,
   escalate,
+  closeObligation,
 } from "./assurance.mjs";
 import { recordPoll, recordClassification, recordSession, writeHealthDashboard } from "./health.mjs";
 import { acquireLock, releaseLock, updateLock, scanStaleLocks, acquireThreadLock, claimRequest, hasActiveClaim, sweepStaleItemClaims, sanitiseItemId } from "./session-lock.mjs";
@@ -326,7 +327,29 @@ async function processItemTraced(item, service, itemId, trace_id, deps = {}) {
 export function enrichItem(item, service) {
   const channelStr = (item.channel || "").toLowerCase();
   const channelId = item.channel_id || "";
-  const isDm = channelStr.startsWith("dm/") || channelId.startsWith("D");
+  // Cohort carries the channel kind explicitly (DM/GROUP_DM/…); its channel ids
+  // are cuids, so the Slack-style "dm/"/"D…" prefix heuristics never fire. When
+  // the kind is known it is AUTHORITATIVE:
+  //   - DM        → a 1:1 DM: is_dm true, so it skips the group election gate.
+  //   - GROUP_DM  → a multi-participant channel: is_dm FALSE, so an UNDIRECTED
+  //                 message goes through the election exactly like any other
+  //                 channel (only ONE seat should answer an ambient group DM).
+  //   - any other explicit kind (PUBLIC/PRIVATE/…) → not a 1:1 DM.
+  // When the kind is ABSENT we do NOT immediately reach for the prefix
+  // heuristics: the DEFAULT (wide) inbound reader — `lib/org/inbound/project.mjs`
+  // toMessageEvent — projects a Cohort 1:1 DM with `is_dm:true`/`channel_type:'dm'`
+  // but does NOT emit `channel_kind`. That boolean survives the whole
+  // eventToInboxItem → writeInboxItem → parseInboxItemYaml chain, so HONOR it
+  // before falling back. Overwriting it with the cuid-blind prefix heuristics
+  // (which never match a Cohort id) is exactly what sent a genuine 1:1 DM through
+  // the group election gate and suppressed it. Precedence: explicit kind →
+  // pre-existing boolean is_dm → Slack-style id/label prefix heuristics.
+  const channelKind = String(item.channel_kind || "").toUpperCase();
+  const isDm = channelKind
+    ? channelKind === "DM"
+    : typeof item.is_dm === "boolean"
+      ? item.is_dm
+      : channelStr.startsWith("dm/") || channelId.startsWith("D");
   const myFirstName = loadAgent().firstName || "Agent";
   const agentThreadRegex = new RegExp(`^${myFirstName}:`, "m");
   const agentInThread = !!(item.thread_context && agentThreadRegex.test(item.thread_context));
@@ -697,7 +720,44 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
         });
         return { ok: true, path: "quick_reply", reason: classResult.model };
       }
-      // If quick reply failed to send or was blocked by validation, fall through to dispatch a full session
+      // PERMANENT SEND FAILURE — NEVER FALL THROUGH. A permanent failure
+      // (FORBIDDEN_SCOPE from the send-gate, NOT_FOUND/BAD_REQUEST from hq) means
+      // retrying changes nothing AND that a spawned session would fail to post the
+      // very same way. Worse, that session runs AUTONOMOUSLY: denied its intended
+      // reply, it improvises and posts UNRELATED work into a channel this seat was
+      // just told it may not write to. So we stop here — open the durable debt so
+      // the ask is not lost, write a needs-attention escalation an operator can
+      // sweep, close the obligation as failed so the assurance sweep does not loop
+      // on an impossible send, and retire the item so the poll lane stops
+      // re-delivering it. The requester is not told (the only channel we had was
+      // the forbidden one); the escalation is the trace that a human must act.
+      if (result.permanent) {
+        const cause = result.code || result.error || "permanent send failure";
+        console.error(`[daemon] Quick reply PERMANENTLY failed for ${item.sender} (${cause}) — NOT spawning a session; opening obligation + escalating`);
+        let obligationKey = itemId;
+        try {
+          const opened = await openAndAcknowledge({
+            item, classResult, service, traceId: trace_id, ack: false,
+          });
+          if (opened && opened.key) obligationKey = opened.key;
+        } catch (err) {
+          console.error(`[daemon] openAndAcknowledge threw for ${itemId} on permanent send failure: ${err.message}`);
+        }
+        escalate(
+          { key: obligationKey, sender: item.sender, service,
+            channel: item.channel_id || item.channel || null,
+            summary: classResult && classResult.summary, openedAt: Date.now(),
+            attempts: 1, sessionId: null, traceId: trace_id, lastError: cause,
+            item: { content: item.content } },
+          { failure: { label: cause }, told: false },
+        );
+        try { closeObligation(obligationKey, { outcome: "failed", note: cause }); } catch { /* best-effort */ }
+        counters.bump("send.permanent_failure", { service, code: result.code || "unknown" });
+        emitEvent({ type: EVENT_TYPES.ERROR, trace_id, attrs: { item_id: itemId, service, stage: "quick_reply_permanent", error: cause } });
+        markProcessed(item, service);
+        return { ok: true, path: "quick_reply_permanent", reason: cause };
+      }
+      // If quick reply failed transiently or was blocked by validation, fall through to dispatch a full session
       const reason = result.blocked ? `validation blocked: ${result.issues?.map(i => i.rule).join(", ")}` : "send failed";
       console.warn(`[daemon] Quick reply not sent (${reason}), falling through to session dispatch`);
     }

package/scripts/daemon/agent-daemon.test.mjs

@@ -713,3 +713,120 @@ test("FAIL-SAFE: no holding ack is posted when the reply session cannot run (cla
   assert.equal(down.dispatched, true, "the session is still dispatched");
   assert.equal(res.path, "session", "answerItem took the session path");
 });
+
+// ===========================================================================
+// is_dm END-TO-END — the Cohort channel_kind is the authoritative signal.
+// ===========================================================================
+
+test("enrichItem: Cohort channel_kind decides is_dm (DM yes, GROUP_DM no)", () => {
+  // A 1:1 DM skips the election gate; a GROUP_DM is multi-participant and must
+  // go through it. Cohort ids are cuids, so the kind is the only reliable signal.
+  const dm = daemon.enrichItem({ channel: "channel/x", channel_id: "cuid_abc", channel_kind: "DM" }, "cohort");
+  assert.equal(dm.is_dm, true, "channel_kind DM → is_dm true (skips election)");
+  const group = daemon.enrichItem({ channel: "channel/x", channel_id: "cuid_abc", channel_kind: "GROUP_DM" }, "cohort");
+  assert.equal(group.is_dm, false, "channel_kind GROUP_DM → is_dm false (goes through election)");
+  const pub = daemon.enrichItem({ channel: "channel/x", channel_id: "cuid_abc", channel_kind: "public" }, "cohort");
+  assert.equal(pub.is_dm, false, "any other explicit kind → not a 1:1 DM");
+  // No kind → fall back to the Slack-style id/label prefix heuristics.
+  assert.equal(daemon.enrichItem({ channel: "dm/ceo", channel_id: "D123" }, "slack").is_dm, true);
+  assert.equal(daemon.enrichItem({ channel: "channel/roadmap", channel_id: "C123" }, "slack").is_dm, false);
+});
+
+test("enrichItem: a WIDE-path Cohort 1:1 DM (is_dm:true, NO channel_kind, cuid id) stays is_dm through the whole chain", async () => {
+  // REGRESSION. The DEFAULT inbound reader is lib/org/inbound.pullWideInbound,
+  // whose projection (lib/org/inbound/project.mjs toMessageEvent) marks a 1:1 DM
+  // with is_dm:true + channel_type:"dm" but does NOT emit channel_kind (only the
+  // non-default MESSAGING_INBOUND_WIDE=0 narrow reader sets channel_kind). Cohort
+  // channel ids are cuids, so the Slack-style "dm/"/"D…" prefix heuristics never
+  // fire on them. Before the fix, enrichItem derived is_dm ONLY from an (absent)
+  // channel_kind or those (never-matching) heuristics and CLOBBERED the true
+  // is_dm to false — routing a genuine 1:1 DM through the group election gate,
+  // which then suppressed it. This drives the real chain end to end:
+  //   toMessageEvent → eventToInboxItem → writeInboxItem → parseInboxItemYaml → enrichItem
+  // and asserts is_dm survives as true.
+  const { toMessageEvent } = await import("../../lib/org/inbound/project.mjs");
+  const { classifyEvent } = await import("../../lib/org/inbound/directedness.mjs");
+  const { eventToInboxItem } = await import("../../lib/channels/inbox-item.mjs");
+  const { writeInboxItem } = await import("../poller/utils.mjs");
+  const { parseInboxItemYaml } = await import("../poller/inbox-scan-poller.mjs");
+
+  const CUID = "clw9x7k4a0000abcd1234efgh"; // a real cuid: no "D…"/"dm/" prefix to key off
+  const cand = classifyEvent({
+    seq: 501, at: "2026-08-25T09:00:00.000Z", actor: "M-them",
+    family: "messaging", kind: "send", entity_id: "m501",
+    payload: { actor: "M-them", channelId: CUID, channelKind: "DM" },
+  });
+  const facts = { channels: new Map([[CUID, { id: CUID, kind: "DM", name: "them" }]]) };
+  const mev = toMessageEvent({
+    candidate: cand,
+    verdict: { surface: "dm", reason: "dm", directed: true },
+    hydrated: { ok: true, text: "ping", from: { id: "M-them", name: "Casey" }, channelId: CUID, channelLabel: "them" },
+    me: "M-me",
+    facts,
+  });
+
+  // The premise the regression rests on: the wide projection marks the DM but
+  // does NOT emit channel_kind.
+  assert.equal(mev.is_dm, true, "wide-path DM projects is_dm:true");
+  assert.equal(mev.channel_type, "dm");
+  assert.equal("channel_kind" in mev, false, "the DEFAULT wide reader emits NO channel_kind");
+
+  // eventToInboxItem carries is_dm through but (correctly) attaches no channel_kind.
+  const item = eventToInboxItem(mev);
+  assert.equal(item.is_dm, true);
+  assert.equal("channel_kind" in item, false);
+
+  // writeInboxItem → parseInboxItemYaml: the on-disk round-trip the poller does.
+  writeInboxItem("cohort", item, AGENT_DIR);
+  const dir = join(AGENT_DIR, "state", "inbox", "cohort");
+  const file = readdirSync(dir).find((f) => f.includes(item.id) && f.endsWith(".yaml"));
+  assert.ok(file, "the inbox item was written to disk");
+  const parsed = parseInboxItemYaml(readFileSync(join(dir, file), "utf8"));
+  assert.equal(parsed.is_dm, true, "is_dm survives the YAML round-trip");
+  assert.equal("channel_kind" in parsed, false, "and still no channel_kind on the wide path");
+
+  // enrichItem is the last hop before the election gate. It MUST honor the
+  // pre-existing boolean is_dm when channel_kind is absent, not clobber it.
+  const enriched = daemon.enrichItem(parsed, "cohort");
+  assert.equal(enriched.is_dm, true, "the wide-path 1:1 DM stays is_dm — it must SKIP the group election gate");
+});
+
+// ===========================================================================
+// NO FALLTHROUGH ON PERMANENT FAILURE — a permanent quick-reply send failure
+// (FORBIDDEN_SCOPE) must escalate, not spawn an autonomous session that would
+// post UNRELATED work into a channel the seat may not write to.
+// ===========================================================================
+
+test("NO FALLTHROUGH: a PERMANENT quick-reply failure escalates instead of spawning a session", async () => {
+  resetState();
+  const item = { id: "MSG-PERM", raw_ref: "slack:DPERM:1", service: "slack", channel: "dm/ceo-perm", channel_id: "DPERM0001", is_dm: true, sender: "ceo", subject: "forbidden send", content: "please post this" };
+  let dispatched = false;
+  const res = await daemon.answerItem(item, "slack", "MSG-PERM", "trace-perm", {
+    classify: async () => ({ priority: "high", action: "respond", model: "haiku", summary: "quick answer", category: "action_required", directed_at_agent: true }),
+    isQuickReply: () => true,
+    sendQuickResponse: async () => ({ sent: false, permanent: true, code: "FORBIDDEN_SCOPE", error: "FORBIDDEN_SCOPE: blocked by send-gate" }),
+    dispatch: () => { dispatched = true; },
+    claudeAvailable: () => true,
+  });
+  assert.equal(dispatched, false, "a permanent send failure must NOT spawn an autonomous session");
+  assert.equal(res.path, "quick_reply_permanent");
+  assert.match(res.reason, /FORBIDDEN_SCOPE/);
+  const naDir = join(AGENT_DIR, "state", "obligations", "needs-attention");
+  assert.ok(existsSync(naDir) && readdirSync(naDir).length > 0, "a durable needs-attention escalation was written for an operator");
+});
+
+test("NO FALLTHROUGH: a TRANSIENT quick-reply failure still falls through to a full session", async () => {
+  resetState();
+  const item = { id: "MSG-TRAN", raw_ref: "slack:DTRAN:1", service: "slack", channel: "dm/ceo-tran", channel_id: "DTRAN0001", is_dm: true, sender: "ceo", subject: "transient send", content: "please post this" };
+  let dispatched = false;
+  const res = await daemon.answerItem(item, "slack", "MSG-TRAN", "trace-tran", {
+    classify: async () => ({ priority: "high", action: "respond", model: "haiku", summary: "quick answer", category: "action_required", directed_at_agent: true }),
+    isQuickReply: () => true,
+    sendQuickResponse: async () => ({ sent: false, error: "hq 503 blip" }), // transient: NO permanent flag
+    sendHoldingMessage: async () => ({ sent: true, holdingText: "on it" }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+  });
+  assert.equal(dispatched, true, "a transient failure falls through to the full session, as before");
+  assert.equal(res.path, "session");
+});

package/scripts/daemon/assurance-e2e.test.mjs

@@ -190,7 +190,8 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
   const ack = transcript.find((m) => m.kind === "ack");
   assert.ok(ack, "the acknowledgement must go out");
   assert.ok(ack.ms < 1000, `acknowledged in ${ack.ms}ms — the old path budgeted 60,000ms and missed 2 times in 3`);
-  assert.match(ack.text, /either way/i);
+  assert.match(ack.text, /on it|looking now|digging in/i);
+  assert.ok(ack.text.length <= 40, "the ack is one short human line, not a templated paragraph");
 
   const key = assurance.openObligations()[0].key;
   note("obligation opened and acknowledged; session running");
@@ -248,7 +249,7 @@ test("SCENARIO 3 — a timing-out session tells the human what happened and that
   const failure = transcript.filter((m) => m.kind === "failure").at(-1);
   assert.ok(failure, "the human MUST be told; the old code emitted telemetry and nothing else");
   assert.match(failure.text, /ran past its time limit/i);
-  assert.match(failure.text, /retrying it now/i);
+  assert.match(failure.text, /retrying now/i);
   assert.equal(assurance.readObligation(key).state, "open", "still owed until the retry resolves");
   note("item left un-processed for redelivery; the debt stays open so the retry is covered too", virtual.v);
 });
@@ -278,7 +279,7 @@ test("SCENARIO 4 — a crashing session tells the human it failed, stops, and es
 
   assert.equal(r.willRetry, false, "a spawn failure is permanent — retrying burns another 45 minutes for the same outcome");
   const failure = transcript.filter((m) => m.kind === "failure").at(-1);
-  assert.match(failure.text, /couldn't get this done/i);
+  assert.match(failure.text, /couldn't finish this/i);
   assert.match(failure.text, /stopped retrying/i);
   assert.match(failure.text, /flagged it so it isn't lost/i);
   assert.match(failure.text, /\?\s*$/, "a dead end ends in a question, so the human has a move");

package/scripts/daemon/assurance.mjs

@@ -311,16 +311,13 @@ function variant(seed, n) {
 /**
  * Trim the classifier's summary into a short topic phrase — casing preserved.
  *
- * This used to lowercase the first letter so the phrase could sit mid-sentence.
- * Applied to a summary that starts with an acronym or a name, that manufactures
- * a typo the requester reads as the agent's own: "Picking up: cEO checking in
- * on work progress." went to a real human, first letter of "CEO" folded. No
- * local rule can tell "Fix" (safe to downcase) from "CEO", "Q3" or a person's
- * name (not safe), so the phrase is taken exactly as the classifier wrote it, and
- * every slot that renders it — the parentheses here and in topicAside — is one
- * where original casing reads correctly. The stored `rec.summary` flows into
- * progress/failure/interrupted messages and the board-row title too, so the
- * no-recasing rule protects all of them at once.
+ * This is NO LONGER interpolated into any message a human reads (the "(CEO
+ * asking what machine…)" bleed is gone — see composeAck). It survives only to
+ * populate `rec.summary`, which feeds the board-row title and the
+ * needs-attention escalation record. Casing is preserved because a summary that
+ * starts with an acronym or a name ("CEO", "Q3") must not be mangled in those
+ * records either; no local rule can tell "Fix" (safe to downcase) from "CEO"
+ * (not), so the phrase is stored exactly as the classifier wrote it.
  */
 function topicClause(classResult, item) {
   const raw = (classResult && classResult.summary) || (item && item.subject) || "";
@@ -329,84 +326,49 @@ function topicClause(classResult, item) {
   return t;
 }
 
-/** Rough, honest expectation. Derived from the measured distribution of real
- *  sessions, not invented: sonnet work clusters near a minute, opus work near
- *  fifteen. Phrased as a range because it IS a range. */
-export function expectedWindow(classResult) {
-  const model = classResult && classResult.model;
-  const priority = classResult && classResult.priority;
-  if (model === "opus" || priority === "critical") return "usually within 10-20 minutes";
-  return "usually within a few minutes";
-}
-
 /**
- * The acknowledgement. Two sentences, written the way a colleague would type
- * them, and — critically — it commits to coming back "either way". That clause
- * is a promise the rest of this module now actually keeps: failure notices,
- * interim updates and the stale sweep all exist so it is never a lie. The time
- * window is expectedWindow's — measured, not invented.
- *
- * The topic rides in parentheses at the end of the opener, never spliced into
- * the sentence: the summary is an arbitrary phrase in arbitrary case, and the
- * previous template — `Picking up: <lowercased summary>. It needs a bit of
- * work, …` — showed the daemon's internal framing to the requester and mangled
- * acronym-initial summaries on top (see topicClause). "Picking up:" is triage
- * vocabulary; a human answering a human does not narrate their queue.
+ * The acknowledgement — sent ONLY when genuinely long, multi-step work is about
+ * to run (a directly-answerable question is answered in the turn on the quick
+ * path, never acked). So it is one plain line, the way a colleague types it
+ * before they get to work: no aside, no filler, no promise-of-followup
+ * boilerplate. The failure notices, interim updates and stale sweep are what
+ * actually keep the human informed — the ack does not need to narrate them.
+ *
+ * The classifier's summary is DELIBERATELY not shown here. It used to ride in a
+ * parenthetical aside, which leaked the daemon's internal framing to the
+ * requester verbatim — "(CEO asking what machine/infrastructure is being used)"
+ * reached a real human. The summary is still stored on the obligation for the
+ * board row and escalations; it just never appears in a message a person reads.
  */
-export function composeAck(item, classResult = {}) {
-  const topic = topicClause(classResult, item);
-  const aside = topic ? ` (${topic})` : "";
+export function composeAck(item) {
   const v = variant(obligationKey(item) || (item && item.sender), 3);
-  const openers = [
-    `No problem — I'm looking into this now${aside}.`,
-    `Got it — I'm on it now${aside}.`,
-    `Understood — I'm digging into this now${aside}.`,
-  ];
-  return `${openers[v]} I want to get this right, so I'll come back to you here with a full answer — ${expectedWindow(classResult)} — and you'll hear from me either way.`;
-}
-
-/**
- * The topic, set off in parentheses.
- *
- * It is NOT interpolated as the object of a preposition, because the classifier's
- * summary is as often a verb phrase ("fix the issues and push them") as a noun
- * phrase ("July spend reconciliation") — and "Still working on fix the issues"
- * is the kind of sentence that tells a reader they are talking to a machine.
- * Parentheses read correctly for both.
- */
-function topicAside(rec) {
-  return rec && rec.summary ? ` (${rec.summary})` : "";
+  return ["On it.", "Looking now.", "On it — digging in now."][v];
 }
 
-/** An interim update. Says how long it has been and that the work is live.
- *  The first update no longer claims "it's taking longer than I expected": it
- *  fires at PROGRESS_AFTER_MS (5 min), squarely inside the 10-20 minute window
- *  the acknowledgement promised for opus work minutes earlier — a claim the
- *  same human could see was false. */
+/** An interim update. Says how long it has been and that the work is live —
+ *  short, no internal topic aside, no filler. */
 export function composeProgress(rec, o = {}) {
   const now = Number.isFinite(o.now) ? o.now : Date.now();
   const mins = Math.max(1, Math.round((now - (rec.openedAt || now)) / 60_000));
-  const topic = topicAside(rec);
   if ((rec.progressSent || 0) === 0) {
-    return `Still working on this${topic} — ${mins} minutes in. Nothing's stuck; I'll come back as soon as I have something worth sending.`;
+    return `Still on this — ${mins} minutes in. I'll come back as soon as I've got something.`;
   }
-  return `Quick check-in: still on this${topic}, ${mins} minutes in. I haven't forgotten it — I'll follow up the moment it's done, or tell you if I can't finish it.`;
+  return `Still going — ${mins} minutes in. I'll follow up the moment it's done.`;
 }
 
 /**
  * The failure notice. Says WHAT HAPPENED and WHAT HAPPENS NEXT, in that order,
  * because those are the two things the human is missing when a session dies.
- * Never blames the human, never hides behind "an error occurred", and never
- * ends without a next step.
+ * Terse and human: never blames the human, never hides behind "an error
+ * occurred", never ends without a next step, and never shows internal framing.
  */
 export function composeFailure(rec, o = {}) {
   const f = o.failure || {};
-  const topic = topicAside(rec);
   const cause = f.human || "the working session ended unexpectedly";
   if (o.willRetry) {
-    return `I hit a problem with this${topic} — ${cause}. I'm retrying it now (attempt ${(rec.attempts || 1) + 1} of ${RETRY_MAX + 1}); if it fails again I'll come straight back to you rather than leave you waiting.`;
+    return `Hit a problem — ${cause}. Retrying now; if it fails again I'll come straight back rather than leave you waiting.`;
   }
-  return `I couldn't get this done${topic} — ${cause}. I've stopped retrying so I'm not silently burning time on it, and I've flagged it so it isn't lost. Do you want me to try a narrower version of this, hand it to someone else, or leave it with you?`;
+  return `Couldn't finish this — ${cause}. I've stopped retrying and flagged it so it isn't lost. Want me to try a narrower version, hand it off, or leave it with you?`;
 }
 
 /**
@@ -416,20 +378,18 @@ export function composeFailure(rec, o = {}) {
  * `sent`. This message is what the human gets instead of that silence.
  */
 export function composeSilentSuccess(rec, o = {}) {
-  const topic = topicAside(rec);
   const tail = (o.finalText || "").trim();
-  const head = `I finished working on this${topic} but didn't get a reply out to you — that's my fault, not yours.`;
+  const head = `Finished this but didn't get a reply out to you — my fault.`;
   if (tail) {
     const excerpt = tail.length > 900 ? `${tail.slice(0, 900).trimEnd()}…` : tail;
-    return `${head} Here's where I got to:\n\n${excerpt}\n\nIf that doesn't answer it, say so and I'll take another run at it.`;
+    return `${head} Here's where I got to:\n\n${excerpt}`;
   }
-  return `${head} I don't have a clean result to show you, so I'd rather say that than pretend otherwise. Want me to run it again?`;
+  return `${head} I don't have a clean result to show you, though. Want me to run it again?`;
 }
 
 /** A session interrupted by the daemon itself dying/restarting. */
-export function composeInterrupted(rec) {
-  const topic = topicAside(rec);
-  return `Heads up — my working session on this${topic} was interrupted before it finished (my end restarted). I've put it back in the queue and I'm picking it up again now; I'll come back to you with the answer.`;
+export function composeInterrupted() {
+  return `Heads up — my session on this was interrupted before it finished (my end restarted). I've picked it back up; I'll come back with the answer.`;
 }
 
 // ---------------------------------------------------------------------------