@cohortapp/agent-sdk 2.11.0 → 2.11.2

package/scripts/daemon/assurance.test.mjs

@@ -135,28 +135,28 @@ describe("composeAck", () => {
     assert.equal(a, composeAck(ITEM, CLASS_COMPLEX), "same input must give the same words");
   });
 
-  test("names the actual ask and promises to come back either way", () => {
+  test("is one short human line — no filler, no promise-of-followup boilerplate", () => {
     const a = composeAck(ITEM, CLASS_COMPLEX);
-    assert.match(a, /fix the noted issues and push the fixes to git/i);
-    assert.match(a, /either way/i, "the promise the rest of the system exists to keep");
-    assert.match(a, /10-20 minutes/, "an opus/critical item is honestly framed as slow");
+    assert.ok(a.length <= 40, `an ack is one short line, got ${a.length} chars: ${a}`);
+    // The templated filler communication-style.md bans.
+    assert.doesNotMatch(a, /either way|full answer|within a few minutes|within 10-20|I want to get this right|hear from me|come back to you/i);
   });
 
   test("degrades gracefully when the classifier gave nothing to go on", () => {
     const a = composeAck(ITEM, {});
-    assert.ok(a.length > 40);
-    assert.match(a, /either way/i);
+    assert.ok(a.length > 0);
+    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside");
   });
 
-  test("REGRESSION: an acronym-initial summary keeps its casing — no 'cEO'", () => {
-    // Owner screenshot, verbatim: "Picking up: cEO checking in on work
-    // progress." — topicClause downcased the first letter of whatever the
-    // classifier wrote so it could sit mid-sentence, and "CEO…" became a typo
-    // the requester reads as the agent's own. The summary is now carried
-    // exactly as written.
-    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO checking in on work progress" });
-    assert.match(a, /CEO checking in on work progress/);
-    assert.doesNotMatch(a, /cEO/);
+  test("REGRESSION: the classifier summary NEVER reaches the human — no '(CEO …)' bleed", () => {
+    // Owner screenshot, verbatim: the ack carried the classifier's internal
+    // summary in a parenthetical aside — "(CEO asking what machine/infrastructure
+    // is being used)" reached a real human. The summary is now stored on the
+    // obligation for the board row but never shown in a message anyone reads.
+    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO asking what machine/infrastructure is being used" });
+    assert.doesNotMatch(a, /CEO asking/i);
+    assert.doesNotMatch(a, /machine\/infrastructure/i);
+    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside at all");
   });
 
   test("reads like a colleague, not a template — no internal framing shown to the human", () => {
@@ -223,10 +223,10 @@ describe("openAndAcknowledge", () => {
     assert.equal(openObligations().length, 1, "the debt must be visible to the sweep");
   });
 
-  test("the stored summary keeps the classifier's casing — every later message reads from it", async () => {
-    // `rec.summary` feeds topicAside (progress, failure, silent-success,
-    // interrupted), the sweep's compensating ack, and board-mirror's row title.
-    // A summary mangled at open time would resurface in all of them.
+  test("the stored summary keeps the classifier's casing — the board row and escalations read from it", async () => {
+    // `rec.summary` feeds board-mirror's row title and the needs-attention
+    // escalation record. A summary mangled at open time would resurface there.
+    // It must NOT, however, appear in any message the human reads.
     const t = fakeTransport();
     const r = await openAndAcknowledge({
       item: ITEM,
@@ -235,7 +235,7 @@ describe("openAndAcknowledge", () => {
     });
     const rec = readObligation(r.key);
     assert.equal(rec.summary, "CEO checking in on work progress");
-    assert.match(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /\(CEO checking in on work progress\)/);
+    assert.doesNotMatch(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /CEO checking in on work progress/, "the summary is never leaked into a progress update");
   });
 
   test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
@@ -339,7 +339,7 @@ describe("settleSession", () => {
     assert.match(r.verdict, /^retrying:timeout$/);
     const msg = t.sent.at(-1).text;
     assert.match(msg, /ran past its time limit/i);
-    assert.match(msg, /retrying it now/i);
+    assert.match(msg, /retrying now/i);
     assert.equal(readObligation(key).state, "open", "still owed — the retry has to be covered too");
   });
 
@@ -350,7 +350,7 @@ describe("settleSession", () => {
     assert.equal(r.willRetry, false);
     assert.match(r.verdict, /^failed:spawn_failed$/);
     const msg = t.sent.at(-1).text;
-    assert.match(msg, /couldn't get this done/i);
+    assert.match(msg, /couldn't finish this/i);
     assert.match(msg, /stopped retrying/i);
     assert.match(msg, /\?$/, "a dead end must end in a question, not a shrug");
     assert.equal(readObligation(key).state, "failed");
@@ -384,7 +384,7 @@ describe("sweepObligations", () => {
     const now = Date.now() + ACK_GRACE_MS + 1000;
     const stats = await sweepObligations({ now, deps: { deliverImpl: working.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.acked, 1);
-    assert.match(working.sent[0].text, /come back to you/i);
+    assert.match(working.sent[0].text, /on it|looking now|digging in/i);
     assert.equal(readObligation(r.key).acknowledged, true);
   });
 
@@ -395,7 +395,7 @@ describe("sweepObligations", () => {
     const stats = await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.progressed, 1);
     const msg = t.sent.at(-1).text;
-    assert.match(msg, /still working/i);
+    assert.match(msg, /still on this/i);
     assert.match(msg, /minutes in/i, "an interim update that omits how long it has been is not much of an update");
     // Six minutes in is INSIDE the 10-20 minute window the ack just promised
     // for opus work; claiming it here contradicts a message the same human read.
@@ -642,7 +642,7 @@ describe("attribution: which debt did that message actually discharge", () => {
     const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_MS + 1000, deps: { deliverImpl: t.impl } });
     assert.equal(stats.closed, 0, "no session of ours had run — that message was not our answer");
     assert.equal(stats.acked, 1, "instead the missing acknowledgement is finally sent");
-    assert.match(t.sent.at(-1).text, /looking into this|on it now|digging into this/i);
+    assert.match(t.sent.at(-1).text, /on it|looking now|digging in/i);
   });
 });
 
@@ -719,7 +719,7 @@ describe("a running retry is not declared dead", () => {
       now: t0 + 45 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false },
     });
     assert.equal(settled.willRetry, true);
-    assert.match(t.sent.at(-1).text, /retrying it now/i);
+    assert.match(t.sent.at(-1).text, /retrying now/i);
 
     const stats = await sweepObligations({ now: t0 + 51 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.staled, 0, "the retry is minutes old, not fifty");

package/scripts/daemon/cadence-handlers.mjs

@@ -667,16 +667,32 @@ async function guardDynamicJobs({ event, agentRoot }, opts = {}) {
 
 const MESSAGING_CURSOR_REL = join("state", "messaging", "inbound-cursor.json");
 
-/** Read the org-messaging inbound cursor (seq). Fail-open → 0 (from genesis). */
+/**
+ * Read the org-messaging inbound cursor (seq).
+ *
+ * Returns `null` when there is NO cursor on disk (or it is corrupt/unreadable) —
+ * NOT 0. The distinction is load-bearing, exactly as it is for the push channel
+ * (lib/org/push.readCursor): `cursor=0` on the events read means "replay the
+ * ENTIRE org ledger from genesis", so a fresh install that started at 0 would
+ * wake on every historical message in the workspace. `null` is the caller's cue
+ * to SEED from the push channel head instead (see guardMessagingInbound), so a
+ * (re)install starts at "now" and replays nothing. A real, persisted cursor
+ * (always > 0 in practice — see writeMessagingCursor) is returned as-is.
+ */
 function readMessagingCursor(agentRoot) {
   try {
     const p = join(agentRoot, MESSAGING_CURSOR_REL);
-    if (!existsSync(p)) return 0;
+    if (!existsSync(p)) return null;
     const obj = JSON.parse(readFileSync(p, "utf8"));
     const c = Number(obj && obj.cursor);
-    return Number.isFinite(c) ? c : 0;
+    // A non-finite / non-positive cursor is corrupt, not "from genesis" — treat it
+    // as absent (seed from head) rather than replaying all history. Aligned with
+    // lib/org/push.readCursor (`n > 0`): a persisted cursor is always > 0 (seeded
+    // from a head that is null-or->0, then only advanced forward), so 0 is never a
+    // real watermark — accepting it would replay the entire org ledger.
+    return Number.isFinite(c) && c > 0 ? c : null;
   } catch {
-    return 0;
+    return null;
   }
 }
 
@@ -764,7 +780,34 @@ async function guardMessagingInbound({ event, agentRoot, log }, opts = {}) {
       opts.toInboxImpl || (await import("../../lib/channels/inbox-item.mjs")).eventToInboxItem;
     const writeInboxItem = opts.writeImpl || (await import("../poller/utils.mjs")).writeInboxItem;
 
-    const cursor = readMessagingCursor(agentRoot);
+    let cursor = readMessagingCursor(agentRoot);
+    if (cursor == null) {
+      // FIRST RUN (or a corrupt cursor): no usable inbound cursor on disk. Do NOT
+      // start the poll lane at genesis — `events?cursor=0` replays the ENTIRE org
+      // ledger and wakes the fresh agent on every historical message. Seed from
+      // the PUSH CHANNEL HEAD instead: the SSE lane bootstraps at head and
+      // persists that seq to state/org/push-cursor.json, so it is the local
+      // "everything before this is history" watermark. Persist it as our starting
+      // cursor so a crash before the first advance cannot fall back to genesis.
+      let head = null;
+      try {
+        head = typeof opts.pushHeadImpl === "function"
+          ? opts.pushHeadImpl(agentRoot)
+          : (await import("../../lib/org/push.mjs")).readCursor(agentRoot);
+      } catch { head = null; }
+      if (head == null) {
+        // Neither lane has established a head yet (truly fresh install, push not
+        // yet connected). Replaying the backlog is the ONE thing we must not do,
+        // so hold this tick — the push channel writes a head shortly and the next
+        // tick seeds from it. Never silent: the reason says exactly why 0 routed.
+        if (typeof log === "function") {
+          log("info", "[messaging-inbound] fresh install: no inbound cursor and no push-channel head yet — holding this tick to avoid replaying the org backlog");
+        }
+        return { ok: true, decision: "inline", cadence: event.cadence, reason: "awaiting push-channel head to seed inbound cursor (fresh install)", routed: 0 };
+      }
+      cursor = Number(head);
+      writeMessagingCursor(agentRoot, cursor);
+    }
     // Pass the agent id explicitly. It is what suppresses the agent's OWN
     // outbound echoes — without it `me` is null, every echo-filter branch is
     // skipped, and the agent re-ingests its own replies as fresh inbound (a

package/scripts/daemon/cadence-handlers.test.mjs

@@ -445,6 +445,10 @@ test("messaging-inbound: pulls new directed items and routes them into the inbox
     { event: { cadence: "messaging-inbound" }, agentRoot: root, log: () => {} },
     {
       cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t", agentId: "me" } } },
+      // Fresh root → no inbound cursor. Seed from the push-channel head so the
+      // pull starts at "now" (not genesis). The stub stands in for
+      // lib/org/push.readCursor.
+      pushHeadImpl: () => 5,
       pullImpl: async () => ({ events: [ev1, ev2], nextCursor: 12 }),
       toInboxImpl: (e) => ({ id: e.message_id, service: "cohort", content: e.text }),
       writeImpl: (service, item) => written.push({ service, item }),
@@ -461,20 +465,67 @@ test("messaging-inbound: pulls new directed items and routes them into the inbox
   assert.equal(JSON.parse(readFileSync(cursorFile, "utf8")).cursor, 12);
 });
 
+test("messaging-inbound: FIRST RUN seeds the inbound cursor from the push-channel head (no backlog replay)", async () => {
+  const root = tmpRoot();
+  let pulledCursor = null;
+  const res = await guardMessagingInbound(
+    { event: { cadence: "messaging-inbound" }, agentRoot: root, log: () => {} },
+    {
+      cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t" } } },
+      // The push channel has advanced to seq 4200. A fresh install must start
+      // there, NOT at 0 (which would replay the whole org ledger).
+      pushHeadImpl: () => 4200,
+      pullImpl: async ({ cursor }) => { pulledCursor = cursor; return { events: [], nextCursor: cursor }; },
+      toInboxImpl: () => ({}),
+      writeImpl: () => { throw new Error("should not write an item"); },
+    },
+  );
+  assert.equal(res.ok, true);
+  assert.equal(res.decision, "inline");
+  assert.equal(pulledCursor, 4200, "the pull started at the push head, not at genesis");
+  const cursorFile = join(root, "state", "messaging", "inbound-cursor.json");
+  assert.ok(existsSync(cursorFile), "the seeded head is persisted so a crash cannot fall back to genesis");
+  assert.equal(JSON.parse(readFileSync(cursorFile, "utf8")).cursor, 4200);
+});
+
+test("messaging-inbound: FIRST RUN with no push head yet HOLDS the tick (never replays from genesis)", async () => {
+  const root = tmpRoot();
+  const res = await guardMessagingInbound(
+    { event: { cadence: "messaging-inbound" }, agentRoot: root, log: () => {} },
+    {
+      cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t" } } },
+      pushHeadImpl: () => null, // push channel has not established a head yet
+      pullImpl: async () => { throw new Error("must not pull before a head exists"); },
+      toInboxImpl: () => ({}),
+      writeImpl: () => { throw new Error("must not write"); },
+    },
+  );
+  assert.equal(res.ok, true);
+  assert.equal(res.decision, "inline");
+  assert.equal(res.routed, 0);
+  assert.match(res.reason, /awaiting push-channel head/);
+  assert.ok(!existsSync(join(root, "state", "messaging", "inbound-cursor.json")), "no cursor seeded while we wait for a head");
+});
+
 test("messaging-inbound: no new directed items → inline, routed 0, cursor unchanged", async () => {
   const root = tmpRoot();
+  // A cursor already exists (not a first run), so seeding is skipped and the pull
+  // starts from the persisted seq. Nothing new → the cursor must not move.
+  const cursorFile = join(root, "state", "messaging", "inbound-cursor.json");
+  mkdirSync(join(root, "state", "messaging"), { recursive: true });
+  writeFileSync(cursorFile, JSON.stringify({ cursor: 9, updatedAt: "2026-01-01T00:00:00Z" }));
   const res = await guardMessagingInbound(
     { event: { cadence: "messaging-inbound" }, agentRoot: root, log: () => {} },
     {
       cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t" } } },
-      pullImpl: async ({ cursor }) => ({ events: [], nextCursor: cursor }),
+      pullImpl: async ({ cursor }) => { assert.equal(cursor, 9, "pull starts from the persisted cursor"); return { events: [], nextCursor: cursor }; },
       toInboxImpl: () => ({}),
       writeImpl: () => { throw new Error("should not write"); },
     },
   );
   assert.equal(res.decision, "inline");
   assert.equal(res.routed, 0);
-  assert.ok(!existsSync(join(root, "state", "messaging", "inbound-cursor.json")), "no cursor write when nothing advanced");
+  assert.equal(JSON.parse(readFileSync(cursorFile, "utf8")).cursor, 9, "cursor unchanged when nothing advanced");
 });
 
 test("messaging-inbound: org not configured → inline no-op (fail-open)", async () => {
@@ -496,6 +547,7 @@ test("messaging-inbound: MESSAGING_INBOUND_ESCALATE=1 escalates when items arriv
       { event: { cadence: "messaging-inbound" }, agentRoot: tmpRoot(), log: () => {} },
       {
         cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t" } } },
+        pushHeadImpl: () => 1,
         pullImpl: async () => ({ events: [{ message_id: "m1", text: "@me" }], nextCursor: 1 }),
         toInboxImpl: (e) => ({ id: e.message_id }),
         writeImpl: () => {},
@@ -514,6 +566,7 @@ test("messaging-inbound: fully fail-open (pull throws → inline, never throws)"
     { event: { cadence: "messaging-inbound" }, agentRoot: tmpRoot(), log: () => {} },
     {
       cfg: { org: { cohort: { enabled: true, base: "https://x", token: "t" } } },
+      pushHeadImpl: () => 3,
       pullImpl: async () => { throw new Error("network down"); },
     },
   );
@@ -737,6 +790,7 @@ test("messaging-inbound (JOINT 3): the DEFAULT reader is wide — no family filt
     {
       cfg: { org: { cohort: { enabled: true, base: "https://x.test", token: "t" } } },
       agentId: ME,
+      pushHeadImpl: () => 1, // fresh root: seed past genesis so the ledger read runs
       fetchImpl,
       toInboxImpl: (e) => ({ id: e.id, service: "cohort", kind: e.kind, content: e.text }),
       writeImpl: (service, item) => written.push({ service, item }),
@@ -765,6 +819,7 @@ test("messaging-inbound (JOINT 3): MESSAGING_INBOUND_WIDE=0 falls back to the na
       {
         cfg: { org: { cohort: { enabled: true, base: "https://x.test", token: "t" } } },
         agentId: "member-me",
+        pushHeadImpl: () => 1, // fresh root: seed past genesis so the read runs
         // The narrow reader pins family=messaging,calling on its URL; assert the
         // degradation is announced rather than inferred from an empty inbox.
         fetchImpl: async () => ({ ok: true, status: 200, headers: { get: () => "application/json" }, text: async () => JSON.stringify({ events: [], nextCursor: 0 }), json: async () => ({ events: [], nextCursor: 0 }) }),

package/scripts/daemon/classifier.mjs

@@ -243,7 +243,8 @@ Your job: classify each incoming message and return a JSON object with exactly t
   "model": "opus" | "sonnet",
   "summary": "<one-line summary of the message>",
   "category": "action_required" | "fyi" | "ignore",
-  "directed_at_agent": true | false
+  "directed_at_agent": true | false,
+  "answerable": true | false
 }
 ${peerContext}
 Classification rules:
@@ -271,6 +272,10 @@ CATEGORY:
 - "fyi": Informational, no action needed
 - "ignore": No value
 
+ANSWERABLE (can ${agentName} answer this DIRECTLY, in one reply, right now?):
+- true: A question that can be answered from what ${agentName} already knows or can see, needing NO tools, NO external lookups, NO drafting, and NO multi-step work — e.g. "what machine are you running on?", "which model are you?", "are you online?", "what's your role?", a simple factual or conversational question. These get answered immediately instead of a "I'll look into it" holding message, even from the ${principalTitle}.
+- false: Anything that needs an action performed (send, schedule, file, push, draft, research, look something up), anything multi-step, or anything that is not a direct question. When unsure, use false — a wrong direct answer is worse than a brief wait.
+
 DIRECTED_AT_AGENT (CRITICAL — determines whether ${agentName} should respond. Default to false in channels/group chats.):
 - true: The message is a DM to ${agentName} (1:1)
 - true: The message explicitly mentions ${agentName} by name or @mention
@@ -300,43 +305,46 @@ Context:
 Examples:
 
 Input: CEO DM on Slack: "Can you send the board resolution to Jordan?"
-Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO requesting board resolution sent to GC Jordan","category":"action_required","directed_at_agent":true}
+Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO requesting board resolution sent to GC Jordan","category":"action_required","directed_at_agent":true,"answerable":false}
+
+Input: CEO DM on Slack: "what kind of machine are you running on?"
+Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO asking what machine/infrastructure the agent runs on","category":"action_required","directed_at_agent":true,"answerable":true}
 
 Input: GitHub notification email about a merged PR
-Output: {"priority":"ignore","action":"ignore","model":"sonnet","summary":"GitHub PR merge notification","category":"ignore","directed_at_agent":false}
+Output: {"priority":"ignore","action":"ignore","model":"sonnet","summary":"GitHub PR merge notification","category":"ignore","directed_at_agent":false,"answerable":false}
 
 Input: Leadership Slack: "We need the the regulator gap analysis updated by Thursday"
-Output: {"priority":"high","action":"draft","model":"opus","summary":"Leadership requesting the regulator gap analysis update by Thursday deadline","category":"action_required","directed_at_agent":true}
+Output: {"priority":"high","action":"draft","model":"opus","summary":"Leadership requesting the regulator gap analysis update by Thursday deadline","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Team member: "Standup notes from today's sync"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team standup notes shared","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team standup notes shared","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: External email: "Following up on our conversation about the Singapore entity"
-Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"External follow-up on Singapore entity discussion","category":"action_required","directed_at_agent":true}
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"External follow-up on Singapore entity discussion","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message from Jacob: "@${agentName} can you check the engine deployment?"
-Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"Jacob asking ${agentName} to check engine deployment","category":"action_required","directed_at_agent":true}
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"Jacob asking ${agentName} to check engine deployment","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message from CEO: "@AnotherAgent can you review the agentic libraries in this channel?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"CEO asking another agent to review agentic libraries — not directed at ${agentName}","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"CEO asking another agent to review agentic libraries — not directed at ${agentName}","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Channel message from Sam to Jordan: "Jordan, did you file the compliance response yet?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Sam asking Jordan about compliance response filing","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Sam asking Jordan about compliance response filing","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Channel thread — Jacob: "pushed the fix" / Sam: "nice, looks good"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team exchange about code fix","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team exchange about code fix","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Thread where ${agentName} previously replied — Jacob: "yeah that makes sense, I'll handle it" (responding to Sam, not ${agentName})
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jacob acknowledging Sam in thread","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jacob acknowledging Sam in thread","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Thread where ${agentName} previously replied — Sam: "${agentName}, can you send the updated doc?"
-Output: {"priority":"high","action":"respond","model":"sonnet","summary":"Sam asking ${agentName} for updated document","category":"action_required","directed_at_agent":true}
+Output: {"priority":"high","action":"respond","model":"sonnet","summary":"Sam asking ${agentName} for updated document","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message: "FYI — the Cayman entity docs are signed and filed"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"FYI: Cayman entity docs signed and filed","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"FYI: Cayman entity docs signed and filed","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Group chat — Jordan: "Sam, can we sync on the the regulator gaps tomorrow?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jordan asking Sam to sync on the regulator gaps","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jordan asking Sam to sync on the regulator gaps","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Return ONLY the JSON object. No explanation, no markdown fencing, no extra text.`;
 }
@@ -407,6 +415,10 @@ function parseClassification(text) {
     summary: typeof parsed.summary === "string" ? parsed.summary : "Unclassified message",
     category: validCategories.includes(parsed.category) ? parsed.category : "fyi",
     directed_at_agent: typeof parsed.directed_at_agent === "boolean" ? parsed.directed_at_agent : false, // default false — don't respond unless we're confident the message is for this agent
+    // A directly-answerable question gets a quick reply instead of a session +
+    // holding ack (see responder.isQuickReply). Default false — when the field
+    // is absent or non-boolean, take the session path, never guess "answerable".
+    answerable: parsed.answerable === true,
   };
 }
 
@@ -781,5 +793,6 @@ function classifiedAttrs(r) {
     model: r.model,
     category: r.category,
     directed_at_agent: r.directed_at_agent,
+    answerable: r.answerable,
   };
 }

package/scripts/daemon/execution-ladder.test.mjs

@@ -384,6 +384,29 @@ test("RUNG: the quick-reply responder accepts rungs 0-1 and refuses 2+", async (
   );
 });
 
+test("ANSWERABLE: a directly-answerable question is quick-replied, not sessioned + acked", () => {
+  // "what machine are you running on?" from the CEO classifies critical/opus,
+  // which would otherwise force a session and a robotic holding ack. Flagged
+  // answerable, it is answered in the turn instead — the defect being fixed.
+  assert.equal(
+    responder.isQuickReply({ action: "respond", priority: "critical", model: "opus", answerable: true }),
+    true,
+    "an answerable question skips the session even at critical/opus",
+  );
+  // The flag only fast-paths a `respond` — a draft/research item stays on the
+  // session path even if the classifier also (contradictorily) flags it.
+  assert.equal(responder.isQuickReply({ action: "draft", priority: "high", model: "opus", answerable: true }), false);
+  assert.equal(responder.isQuickReply({ action: "research", priority: "normal", model: "sonnet", answerable: true }), false);
+  // And the rung veto still wins over answerable.
+  assert.equal(
+    responder.isQuickReply({ action: "respond", priority: "critical", model: "opus", answerable: true }, { rung: 3 }),
+    false,
+    "a rung-3 answer needs a session even when the classifier called it answerable",
+  );
+  // Without the flag, a critical/opus item still takes the session path.
+  assert.equal(responder.isQuickReply({ action: "respond", priority: "critical", model: "opus" }), false);
+});
+
 // ---------------------------------------------------------------------------
 // 8) REGRESSION (live run): with no need estimate every DM routed to rung 3,
 //    which vetoed the quick reply and spawned a session for a two-line message.

package/scripts/daemon/inbox-deferral.mjs

@@ -199,38 +199,63 @@ export function promoteDeferred(channel, agentRoot) {
       matches.push({
         file,
         timestamp: readScalar(body, "timestamp") || "",
+        // THE SURFACE within the channel. `channel_id` names the ROOM; a single
+        // room carries several independent conversations at once — a directed 1:1
+        // DM thread AND the actor's own doc/board/decision events that resolve to
+        // the same channel_id. Bundling "latest-wins across the whole channel"
+        // folded those unrelated surfaces into one and silently dropped
+        // (`.processed-bundled`) a directed DM because a newer doc-comment event
+        // arrived in the same room. thread_context only ever carries the SAME
+        // thread's history, so bundling is sound ONLY within one surface. Key on
+        // thread_id, else the surface's own scope_id, else "" (a bare-channel
+        // burst — the original same-thread case, preserved).
+        surface:
+          readScalar(body, "thread_id") ||
+          readScalar(body, "scope_id") ||
+          "",
       });
     }
     if (matches.length === 0) continue;
 
-    // Latest-wins: lex-sort ISO timestamps, take the most recent.
-    matches.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    const latest = matches[matches.length - 1];
-    const older = matches.slice(0, -1);
-
-    // Promote the latest back to live inbox.
-    try {
-      const live = latest.file.replace(/\.deferred$/, "");
-      renameSync(join(inboxDir, latest.file), join(inboxDir, live));
-      result.promoted++;
-      result.service = service;
-    } catch {
-      // If the rename failed (race with another process), leave it
-      // as .deferred — the next session-close will retry.
+    // Group by surface within the channel, then bundle latest-wins WITHIN each
+    // group. Distinct surfaces each promote their own latest; none is dropped
+    // just because a newer message landed on a different surface in the room.
+    const groups = new Map();
+    for (const m of matches) {
+      if (!groups.has(m.surface)) groups.set(m.surface, []);
+      groups.get(m.surface).push(m);
     }
 
-    // Mark older bursts as bundled — their content is already part of
-    // the latest item's thread_context, so they don't need their own
-    // session, but we preserve the file for audit.
-    for (const m of older) {
+    for (const group of groups.values()) {
+      // Latest-wins: lex-sort ISO timestamps, take the most recent.
+      group.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+      const latest = group[group.length - 1];
+      const older = group.slice(0, -1);
+
+      // Promote the latest back to live inbox.
       try {
-        renameSync(
-          join(inboxDir, m.file),
-          join(inboxDir, m.file.replace(/\.deferred$/, ".processed-bundled"))
-        );
-        result.bundled++;
+        const live = latest.file.replace(/\.deferred$/, "");
+        renameSync(join(inboxDir, latest.file), join(inboxDir, live));
+        result.promoted++;
+        result.service = service;
       } catch {
-        // Best-effort; missing file is fine.
+        // If the rename failed (race with another process), leave it
+        // as .deferred — the next session-close will retry.
+      }
+
+      // Mark older bursts as bundled — their content is already part of
+      // the latest item's thread_context, so they don't need their own
+      // session, but we preserve the file for audit.
+      for (const m of older) {
+        try {
+          renameSync(
+            join(inboxDir, m.file),
+            join(inboxDir, m.file.replace(/\.deferred$/, ".processed-bundled"))
+          );
+          result.bundled++;
+        } catch {
+          // Best-effort; missing file is fine.
+        }
       }
     }
   }

package/scripts/daemon/inbox-deferral.test.mjs

@@ -12,11 +12,13 @@ function makeAgentRoot() {
   return root;
 }
 
-function writeInboxItem(root, name, { channel_id, timestamp, id = "test-id" }) {
+function writeInboxItem(root, name, { channel_id, timestamp, id = "test-id", thread_id, scope_id }) {
   const body = [
     `id: "${id}"`,
     `service: "slack"`,
     `channel_id: "${channel_id}"`,
+    ...(thread_id ? [`thread_id: "${thread_id}"`] : []),
+    ...(scope_id ? [`scope_id: "${scope_id}"`] : []),
     `timestamp: "${timestamp}"`,
     `content: |`,
     `  body`,
@@ -118,6 +120,42 @@ test("promoteDeferred with multiple items: keeps latest, bundles rest", () => {
   }
 });
 
+test("promoteDeferred bundles WITHIN a surface, not across the whole channel", () => {
+  // A directed 1:1 DM thread AND the actor's doc-comment events resolve to the
+  // same channel_id. Bundling latest-wins across the channel would drop the DM
+  // just because a newer doc event landed. Each surface must promote its own
+  // latest; nothing is bundled across surfaces.
+  const root = makeAgentRoot();
+  try {
+    // The directed DM (one message, thread T-DM).
+    writeInboxItem(root, "dm-1.yaml.deferred", {
+      channel_id: "room-1", thread_id: "T-DM", id: "dm-1",
+      timestamp: "2026-05-13T00:00:30Z",
+    });
+    // Two doc-comment events on the same room but a different surface (scope S-DOC),
+    // the later of which would have "won" under the old channel-wide bundling.
+    writeInboxItem(root, "doc-1.yaml.deferred", {
+      channel_id: "room-1", scope_id: "S-DOC", id: "doc-1",
+      timestamp: "2026-05-13T00:01:00Z",
+    });
+    writeInboxItem(root, "doc-2.yaml.deferred", {
+      channel_id: "room-1", scope_id: "S-DOC", id: "doc-2",
+      timestamp: "2026-05-13T00:02:00Z",
+    });
+    const r = promoteDeferred("room-1", root);
+    assert.equal(r.promoted, 2, "the DM and the latest doc event are BOTH promoted");
+    assert.equal(r.bundled, 1, "only the older doc event (same surface) is bundled");
+    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
+    assert.deepEqual(files, [
+      "dm-1.yaml",                    // the directed DM survives — NOT dropped
+      "doc-1.yaml.processed-bundled", // older doc event folded into doc-2
+      "doc-2.yaml",                   // latest doc event promoted
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("promoteDeferred ignores items in other channels", () => {
   const root = makeAgentRoot();
   try {

package/scripts/daemon/responder.mjs

@@ -901,6 +901,15 @@ export async function sendQuickResponse(item, classResult, routed = null) {
       via: delivered.via,
       ...(delivered.channel ? { channel: delivered.channel } : {}),
       ...(delivered.draft_path ? { draft_path: delivered.draft_path } : {}),
+      // PROPAGATE THE PERMANENCE. `deliver` marks a failure the send-gate refused
+      // (FORBIDDEN_SCOPE) or hq declared unroutable (NOT_FOUND/BAD_REQUEST) as
+      // `permanent` with the RPC `code`. Without carrying these up, the caller
+      // (agent-daemon.answerItem) could not tell a transient blip from an
+      // impossible send, so it fell through to a full autonomous session — which
+      // then posted UNRELATED work into a channel this seat was just told it may
+      // not write to. The daemon uses `permanent` to escalate instead of spawn.
+      ...(delivered.permanent ? { permanent: true } : {}),
+      ...(delivered.code ? { code: delivered.code } : {}),
       ...(delivered.error ? { error: delivered.error } : {}),
     };
 
@@ -1066,6 +1075,17 @@ export function isQuickReply(classResult, routed = null) {
   // place, or a caller that has no ladder) leaves the original rules untouched.
   if (!rungPermitsQuickReply(routed)) return false;
 
+  // ── directly-answerable question: answer it, don't ack it ────────────────
+  // A factual question the classifier judged answerable in one reply — no
+  // tools, no drafting, no multi-step work ("what machine are you running on?")
+  // — belongs on the quick path even from the CEO and even when the model or
+  // priority would otherwise route it to a session. Spawning a 15-minute
+  // session and posting a robotic "I'm looking into this now (CEO asking…)" to
+  // a question that could be answered in one line IS the defect being fixed.
+  // Gated to `respond` so a `draft`/`research` item that also gets flagged
+  // answerable (a classifier contradiction) still takes the session path.
+  if (classResult.answerable === true && classResult.action === "respond") return true;
+
   // These always need full sessions — never quick reply
   if (classResult.action === "research") return false;
   if (classResult.action === "draft") return false;