@cohortapp/agent-sdk 2.10.0 → 2.11.1

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

@@ -523,3 +523,310 @@ test("OUTCOMES: the daemon hook never throws into the dispatch path", async () =
   assert.ok(res && typeof res.created === "number", "benign result, no throw");
   assert.equal(res.created, 0);
 });
+
+// ===========================================================================
+// ELECTION — the multi-AI storm fix. An UNDIRECTED message in a cohort channel
+// defers the should-I-respond decision to hq's electResponder; this seat
+// answers IFF elected, and a failed/empty election FAILS SAFE (stays silent).
+// A DIRECT address (@mention / DM) skips the election entirely. And a holding
+// ack is never posted when the reply session cannot run (claude unavailable).
+//
+// These drive the REAL answerItem() with the hq election call + the claude
+// liveness probe stubbed via deps — the same injection seam the DIAG tests use.
+// ===========================================================================
+
+// An org config that configFromAgent() reads: enabled, with this seat's own
+// member slug so the verdict can tell "elected me" from "elected someone else".
+const ELECTION_ORG_CFG = {
+  org: { cohort: { enabled: true, base: "https://hq.example", orgId: "org_x", agentId: "robin" } },
+};
+
+// A cohort CHANNEL item (not a DM): service+channel_id give cohortChannelId,
+// raw_ref's third segment gives cohortMessageId. Content is deliberately generic
+// so isDirectedAtAgent() is false and the election path is taken.
+function cohortChannelItem(overrides = {}) {
+  return {
+    id: overrides.id || "MSG-EL",
+    raw_ref: overrides.raw_ref || "cohort:message:msg-el:0",
+    service: "cohort",
+    channel: "channel/roadmap",
+    channel_id: overrides.channel_id || "chan-el",
+    is_dm: false,
+    sender: "alice",
+    content: overrides.content || "what should our Q3 priorities be?",
+  };
+}
+
+const ELECTED_CLASS = {
+  priority: "high", action: "respond", model: "opus",
+  summary: "roadmap discussion", category: "action_required", directed_at_agent: false,
+};
+
+test("ELECTION: the elected seat responds (dispatches) and the hq call carried {messageId, channelId}", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID; // let the cfg's agentId be the seat's slug
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-YES", raw_ref: "cohort:message:msg-yes:0", channel_id: "chan-yes" });
+  const electionCalls = [];
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-yes", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "elected-yes topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    electResponder: async (params) => {
+      electionCalls.push(params);
+      return { ok: true, result: { election: "group", mode: "single", responders: [{ slug: "robin", dimension: "mandate" }], deferredToHuman: false } };
+    },
+  });
+
+  assert.equal(electionCalls.length, 1, "the election was consulted exactly once");
+  assert.deepEqual(electionCalls[0], { messageId: "msg-yes", channelId: "chan-yes" }, "hq got the message + channel identity");
+  assert.equal(dispatched, true, "the elected seat proceeds to dispatch a reply session");
+  assert.equal(res.path, "session", "answerItem took the session path");
+});
+
+test("ELECTION: a NON-elected seat stays silent on the same message (no dispatch)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-NO", raw_ref: "cohort:message:msg-no:0", channel_id: "chan-no" });
+  const electionCalls = [];
+  let dispatched = false;
+  let acked = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-no", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "not-elected topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => { acked = true; return { sent: true, holdingText: "on it" }; },
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    // hq elected a DIFFERENT seat — this one is not in the responders list.
+    electResponder: async (params) => {
+      electionCalls.push(params);
+      return { ok: true, result: { election: "group", mode: "single", responders: [{ slug: "kai", dimension: "mandate" }], deferredToHuman: false } };
+    },
+  });
+
+  assert.equal(electionCalls.length, 1, "the election was consulted");
+  assert.equal(dispatched, false, "a non-elected seat must NOT dispatch");
+  assert.equal(acked, false, "a non-elected seat must NOT post a holding ack");
+  assert.equal(res.path, "filtered", "answerItem filtered the item");
+  assert.equal(res.reason, "not_elected", "…because it was not elected");
+});
+
+test("ELECTION: an election ERROR fails safe — the seat stays silent (never respond-to-all)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-ERR", raw_ref: "cohort:message:msg-err:0", channel_id: "chan-err" });
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-err", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "election-error topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    // hq is unreachable / throwing — the INVERSION: this must resolve to silence.
+    electResponder: async () => { throw new Error("hq unreachable"); },
+  });
+
+  assert.equal(dispatched, false, "an unreachable election must NOT fall back to responding");
+  assert.equal(res.path, "filtered", "answerItem filtered the item");
+  assert.equal(res.reason, "not_elected", "election failure ⇒ treated as not-elected (silent)");
+});
+
+test("ELECTION: an @mention/named-address responds WITHOUT calling electResponder (fast path)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  // Give this seat a distinctive name and point isDirectedAtAgent at it.
+  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
+  writeFileSync(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({ firstName: "Zephyr", slackMemberId: "" }));
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({
+    id: "MSG-EL-MENTION", raw_ref: "cohort:message:msg-mention:0", channel_id: "chan-mention",
+    content: "hey zephyr, can you own the Q3 rollout?",
+  });
+  const electionCalls = [];
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-mention", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "mention topic", directed_at_agent: true }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    electResponder: async (params) => { electionCalls.push(params); return { ok: true, result: { responders: [] } }; },
+  });
+
+  assert.equal(electionCalls.length, 0, "a directly-addressed message does NOT hold an election");
+  assert.equal(dispatched, true, "the addressed seat answers on its local fast path");
+  assert.equal(res.path, "session", "answerItem took the session path");
+
+  // Tidy: drop the identity so later tests re-read a nameless seat.
+  rmSync(join(AGENT_DIR, "config", "agent.json"), { force: true });
+  cls._resetAgentRegistry();
+});
+
+test("FAIL-SAFE: no holding ack is posted when the reply session cannot run (claude unavailable)", async () => {
+  resetState();
+  // A slack DM — always directed, so this isolates the ack gate from the election.
+  // is_dm is normally set by enrichItem; answerItem is called directly here, so
+  // set it on the item as the poller/enrichment would.
+  // Distinct channel + subject per run so the request-claim from one run does not
+  // deny the other (the claim key is recipient + subject + action_type).
+  const mkItem = (tag) => ({ id: `MSG-ACK-${tag}`, raw_ref: `slack:DACK${tag}:1`, service: "slack", channel: "dm/ceo", channel_id: `DACK${tag}0001`, is_dm: true, sender: "ceo", content: "please draft the memo" });
+  const baseDeps = (spy, claudeUp, tag) => ({
+    classify: async () => ({ priority: "critical", action: "respond", model: "opus", summary: `draft memo ${tag}`, category: "action_required", directed_at_agent: true }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => { spy.calls++; return { sent: true, holdingText: "on it" }; },
+    dispatch: (_p, _it, _cr, _s, opts) => { spy.dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => claudeUp,
+  });
+
+  // CONTROL: claude available ⇒ the ack path runs (holding message attempted).
+  const up = { calls: 0, dispatched: false };
+  await daemon.answerItem(mkItem("UP"), "slack", "slack:DACKUP:1", "trace-ack-up", baseDeps(up, true, "UP"));
+  assert.equal(up.calls, 1, "with claude available, a holding ack IS attempted");
+  assert.equal(up.dispatched, true, "control: the session is dispatched");
+
+  // TREATMENT: claude unavailable ⇒ NO ack is emitted, but the session still runs
+  // (the assurance sweep owns the outcome; the human just isn't promised a reply).
+  const down = { calls: 0, dispatched: false };
+  const res = await daemon.answerItem(mkItem("DN"), "slack", "slack:DACKDN:1", "trace-ack-down", baseDeps(down, false, "DN"));
+  assert.equal(down.calls, 0, "with claude unavailable, NO holding ack is posted before the working session");
+  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.mjs

@@ -308,12 +308,25 @@ function variant(seed, n) {
   return h % n;
 }
 
-/** Trim the classifier's summary into a clause that reads naturally mid-sentence. */
+/**
+ * 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.
+ */
 function topicClause(classResult, item) {
   const raw = (classResult && classResult.summary) || (item && item.subject) || "";
   const t = String(raw).trim().replace(/\s+/g, " ").replace(/[.!?]+$/, "");
   if (!t || t.length > 120) return null;
-  return t.charAt(0).toLowerCase() + t.slice(1);
+  return t;
 }
 
 /** Rough, honest expectation. Derived from the measured distribution of real
@@ -327,23 +340,29 @@ export function expectedWindow(classResult) {
 }
 
 /**
- * The acknowledgement. Two or three sentences, warm, specific where it can be,
- * 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 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.
  */
 export function composeAck(item, classResult = {}) {
   const topic = topicClause(classResult, item);
+  const aside = topic ? ` (${topic})` : "";
   const v = variant(obligationKey(item) || (item && item.sender), 3);
   const openers = [
-    "No problem — let me look into this and sort it out.",
-    "Got it — I'm on this now.",
-    "Understood — let me dig into this.",
+    `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}.`,
   ];
-  const parts = [openers[v]];
-  if (topic) parts.push(`Picking up: ${topic}.`);
-  parts.push(`It needs a bit of work, so I'll come back to you here with an answer — ${expectedWindow(classResult)}, and I'll message you either way.`);
-  return parts.join(" ");
+  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.`;
 }
 
 /**
@@ -359,13 +378,17 @@ function topicAside(rec) {
   return rec && rec.summary ? ` (${rec.summary})` : "";
 }
 
-/** An interim update. Says how long it has been and that the work is live. */
+/** 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. */
 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, and it's taking longer than I expected. Nothing's stuck; I'll come back as soon as I have something worth sending.`;
+    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 `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.`;
 }

package/scripts/daemon/assurance.test.mjs

@@ -147,6 +147,26 @@ describe("composeAck", () => {
     assert.ok(a.length > 40);
     assert.match(a, /either way/i);
   });
+
+  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("reads like a colleague, not a template — no internal framing shown to the human", () => {
+    // "Picking up:" is triage vocabulary and "It needs a bit of work" is the
+    // daemon explaining its own dispatch decision. Both leaked the machinery at
+    // the person being acknowledged.
+    const a = composeAck(ITEM, CLASS_COMPLEX);
+    assert.doesNotMatch(a, /picking up:/i);
+    assert.doesNotMatch(a, /needs a bit of work/i);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -203,6 +223,21 @@ 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.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({
+      item: ITEM,
+      classResult: { ...CLASS_COMPLEX, summary: "CEO checking in on work progress" },
+      deps: { ackSender: t.ackSender },
+    });
+    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\)/);
+  });
+
   test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
     const t = fakeTransport();
     await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
@@ -362,6 +397,9 @@ describe("sweepObligations", () => {
     const msg = t.sent.at(-1).text;
     assert.match(msg, /still working/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.
+    assert.doesNotMatch(msg, /longer than I expected/i);
   });
 
   test("interim updates are CAPPED — attentive, not noisy", async () => {
@@ -604,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, /let me look into this|I'm on this now|let me dig into this/i);
+    assert.match(t.sent.at(-1).text, /looking into this|on it now|digging into this/i);
   });
 });
 

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