@cohortapp/agent-sdk 2.16.0 → 2.18.4

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

@@ -1,995 +0,0 @@
-/**
- * agent-daemon.test.mjs — F1/H2 message-loss window (task #16, 0.8 follow-up).
- *
- * Before this fix, processItem() called markProcessed() (rename → .processed)
- * IMMEDIATELY after a fire-and-forget dispatch(). A crash before the spawned
- * session closed left the user's inbox item `.processed` with redelivery
- * blocked — the message was silently lost.
- *
- * The fix defers the finalize to the dispatch onClose SUCCESS path and records a
- * durable in-flight admission so a restart re-delivers an un-finalized item:
- *   • clean close  → markProcessed() + clearInFlight()  (finalize)
- *   • non-zero / spawn error → clearInFlight() + releaseLock() (re-deliverable)
- *   • crash mid-flight → admission survives; recoverInFlight() (startup) releases
- *     the per-item lock so the still-un-`.processed` file is re-polled.
- *
- * These tests drive the REAL daemon helpers (recordInFlight / clearInFlight /
- * markProcessed / recoverInFlight) and the REAL per-item lock from
- * session-lock.mjs, asserting the on-disk state that the poller would observe.
- *
- * The daemon module statically pulls in the agent-only `imapflow` dep (via the
- * gmail poller) which isn't packaged in CI, so we register a tiny in-process
- * ESM loader that stubs `imapflow` to a no-op class. Everything else in the
- * daemon's import graph resolves normally, so the code under test is the real
- * implementation, not a re-creation.
- */
-
-import { test, before } from "node:test";
-import assert from "node:assert/strict";
-import { register } from "node:module";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-// --- stub the agent-only `imapflow` dep so the daemon module can be imported ---
-const loaderSrc = `
-export async function resolve(specifier, context, next) {
-  if (specifier === "imapflow") return { url: "imapflow-stub:main", shortCircuit: true };
-  return next(specifier, context);
-}
-export async function load(url, context, next) {
-  if (url === "imapflow-stub:main") return { format: "module", shortCircuit: true, source: "export class ImapFlow {}" };
-  return next(url, context);
-}
-`;
-register(`data:text/javascript,${encodeURIComponent(loaderSrc)}`);
-
-// One shared AGENT_DIR for the whole file: session-lock.mjs (imported transitively
-// by the daemon) reads AGENT_DIR at module-eval time and is cached by URL, so all
-// imports must agree on the dir. Per-test isolation comes from unique item ids and
-// a clean-between-tests of the relevant state subdirs.
-const AGENT_DIR = mkdtempSync(join(tmpdir(), "maestro-agent-daemon-"));
-process.env.AGENT_DIR = AGENT_DIR;
-process.env.MAESTRO_DAEMON_NO_AUTOSTART = "1"; // import without spinning the poll loops
-
-let daemon;       // the real daemon module (recordInFlight/clearInFlight/markProcessed/recoverInFlight)
-let lock;         // the real session-lock module (acquireLock/readLock)
-let bus;          // the real hook-bus module (getHookBus/resetHookBus) — shared singleton
-let counters;     // the real counters module (snapshot/resetMem) — shared transitive import
-
-before(async () => {
-  mkdirSync(join(AGENT_DIR, "state", "inbox", "slack"), { recursive: true });
-  mkdirSync(join(AGENT_DIR, "state", "sessions", "locks"), { recursive: true });
-  const dURL = new URL("./agent-daemon.mjs", import.meta.url);
-  daemon = await import(`${dURL.href}?f1h2=${Math.random()}`);
-  lock = await import("./session-lock.mjs");
-  // These are the SAME singletons the daemon reaches transitively (imported by
-  // bare specifier, so the module cache shares them) — that's what lets the test
-  // emit on the same bus the daemon subscribed to and read the same counters.
-  bus = await import("../../lib/hooks/bus.mjs");
-  counters = await import("../../lib/diagnostics/counters.mjs");
-});
-
-// Read the diagnostic-event rows the daemon appended to its tmp
-// logs/diagnostics/<UTC-date>.jsonl stream. [] when none written.
-function readDiagnostics() {
-  const date = new Date().toISOString().slice(0, 10);
-  const path = join(AGENT_DIR, "logs", "diagnostics", `${date}.jsonl`);
-  let raw = "";
-  try { raw = readFileSync(path, "utf-8"); } catch { return []; }
-  return raw.split("\n").filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-}
-
-function slackInbox() { return join(AGENT_DIR, "state", "inbox", "slack"); }
-function inflightDir() { return join(AGENT_DIR, "state", "inbox-inflight"); }
-
-function resetState() {
-  for (const d of [slackInbox(), inflightDir(), join(AGENT_DIR, "state", "sessions", "locks")]) {
-    try { for (const f of readdirSync(d)) rmSync(join(d, f), { force: true }); } catch { /* */ }
-  }
-}
-
-/**
- * Write a live (un-.processed) poller-style inbox file for an item, returning
- * the filename. Mirrors the real poller naming (`<ts>-<item.id>.yaml`) so that
- * markProcessed's id/raw_ref substring match finds it, exactly as in production.
- */
-function writeLiveItem(item) {
-  const name = `2026-06-10T00-00-00Z-${item.id}.yaml`;
-  const body = [
-    `id: "${item.id}"`,
-    `service: "slack"`,
-    `channel_id: "${item.channel || "D1"}"`,
-    `timestamp: "2026-06-10T00:00:00Z"`,
-    `content: |`,
-    `  hello`,
-    "",
-  ].join("\n");
-  writeFileSync(join(slackInbox(), name), body);
-  return name;
-}
-
-function inboxFiles() { return readdirSync(slackInbox()).sort(); }
-function inflightFiles() { try { return readdirSync(inflightDir()).filter((f) => f.endsWith(".json")); } catch { return []; } }
-
-// ---------------------------------------------------------------------------
-// 1) Crash between dispatch and close → item is RE-DELIVERABLE (not .processed),
-//    and recoverInFlight() releases the gating lock so the next poll re-delivers.
-// ---------------------------------------------------------------------------
-
-test("F1/H2: a crash between dispatch and close leaves the item re-deliverable (not .processed)", () => {
-  resetState();
-  const item = { id: "MSG-CRASH", raw_ref: "slack:C1:1001", channel: "D1", sender: "ceo" };
-  const name = writeLiveItem(item);
-
-  // Simulate processItem up to (but not past) the dispatch: the poll filter holds
-  // the per-item lock, and the daemon records the durable in-flight admission.
-  const acq = lock.acquireLock(item.raw_ref, { sender: item.sender, channel: item.channel });
-  assert.equal(acq.acquired, true, "poll filter acquired the per-item lock");
-  daemon.recordInFlight(item, "slack");
-
-  // --- CRASH HERE: no onClose ran, so markProcessed was never called. ---
-  // The user's message must NOT be .processed (the whole bug).
-  assert.deepEqual(inboxFiles(), [name], "file is still live (un-.processed) after a mid-flight crash");
-  assert.equal(inflightFiles().length, 1, "the in-flight admission survives the crash");
-  // The held lock would block a naive re-poll until the 2h stale TTL — that is
-  // exactly what recovery must clear.
-  assert.equal(lock.acquireLock(item.raw_ref).acquired, false, "lock still held → re-poll blocked pre-recovery");
-
-  // --- RESTART: recoverInFlight() releases the lock so the next poll re-delivers. ---
-  const n = daemon.recoverInFlight();
-  assert.equal(n, 1, "one in-flight admission recovered");
-  assert.equal(inflightFiles().length, 0, "admission cleared after recovery");
-  assert.deepEqual(inboxFiles(), [name], "the message is STILL on disk, un-.processed → re-deliverable");
-  assert.equal(lock.acquireLock(item.raw_ref).acquired, true, "the gating lock was released → next poll re-delivers");
-});
-
-// ---------------------------------------------------------------------------
-// 2) A clean close finalizes the item (markProcessed) and clears the admission.
-// ---------------------------------------------------------------------------
-
-test("F1/H2: a clean close finalizes the item (markProcessed) and clears the in-flight admission", () => {
-  resetState();
-  const item = { id: "MSG-OK", raw_ref: "slack:C2:2002", channel: "D2", sender: "ceo" };
-  const name = writeLiveItem(item);
-  lock.acquireLock(item.raw_ref, { sender: item.sender });
-  daemon.recordInFlight(item, "slack");
-  assert.equal(inflightFiles().length, 1);
-
-  // onClose({ok:true}) success path (the exact wiring processItem installs).
-  daemon.markProcessed(item, "slack");
-  daemon.clearInFlight(item);
-
-  assert.deepEqual(inboxFiles(), [`${name}.processed`], "clean close finalized the item to .processed");
-  assert.equal(inflightFiles().length, 0, "admission cleared on finalize");
-  // A clean close finalized work that already completed — recovery is a no-op,
-  // and there is no live file left for the poller to re-deliver.
-  assert.equal(daemon.recoverInFlight(), 0, "nothing to recover after a clean finalize");
-});
-
-// ---------------------------------------------------------------------------
-// 3) A non-zero close / spawn error leaves the item re-deliverable and releases
-//    the lock immediately (no need to wait for restart).
-// ---------------------------------------------------------------------------
-
-test("F1/H2: a failed close leaves the item re-deliverable and releases the lock now", () => {
-  resetState();
-  const item = { id: "MSG-FAIL", raw_ref: "slack:C3:3003", channel: "D3", sender: "ceo" };
-  const name = writeLiveItem(item);
-  lock.acquireLock(item.raw_ref, { sender: item.sender });
-  daemon.recordInFlight(item, "slack");
-
-  // onClose({ok:false}) failure path: clear admission + release lock, but DO NOT
-  // markProcessed — the message stays re-deliverable.
-  daemon.clearInFlight(item);
-  lock.releaseLock(item.raw_ref);
-
-  assert.deepEqual(inboxFiles(), [name], "failed session left the item live (un-.processed)");
-  assert.equal(inflightFiles().length, 0, "admission cleared on failure");
-  assert.equal(lock.acquireLock(item.raw_ref).acquired, true, "lock released → next poll re-delivers immediately");
-});
-
-// ---------------------------------------------------------------------------
-// 4) recoverInFlight() is a clean no-op when nothing is pending, and never
-//    touches already-.processed files.
-// ---------------------------------------------------------------------------
-
-test("F1/H2: recoverInFlight is a no-op with no pending admissions", () => {
-  resetState();
-  assert.equal(daemon.recoverInFlight(), 0, "no admissions → recovered 0");
-});
-
-test("F1/H2: recordInFlight is a no-op for an item with no lock key (e.g. backlog)", () => {
-  resetState();
-  daemon.recordInFlight({ title: "deep work" }, "backlog");
-  assert.equal(inflightFiles().length, 0, "no raw_ref/id → no admission written (backlog items are durable in queue files)");
-});
-
-// ===========================================================================
-// DIAG — the observability spine wired into the LIVE inbound pipeline.
-// ===========================================================================
-//
-// processItem() mints ONE trace_id per item and emits item_received → … → sent
-// (on a clean finalize) all under it. The daemon also registers the ONE real
-// hook-bus subscriber (onGuardFail → counters.bump("guard.fail")) so the bus is
-// live. STRICT additive: emitEvent + counters.bump never throw, and the dispatch
-// /classify/send semantics are untouched (the heavy collaborators are injected
-// here ONLY so the test drives the real instrumented body without spawning a
-// `claude` child — production passes no deps).
-
-function clearDiagnostics() {
-  for (const sub of ["diagnostics", join("diagnostics", "counters")]) {
-    const d = join(AGENT_DIR, "logs", sub);
-    try { for (const f of readdirSync(d)) { if (f.endsWith(".jsonl")) rmSync(join(d, f), { force: true }); } } catch { /* */ }
-  }
-  try { counters.resetMem(); } catch { /* */ }
-}
-
-// ---------------------------------------------------------------------------
-// 1) A processed item emits item_received → … → sent with ONE stable trace_id.
-// ---------------------------------------------------------------------------
-
-test("DIAG: a processed item emits item_received → sent with ONE stable trace_id (the daemon's minted id)", async () => {
-  resetState();
-  clearDiagnostics();
-  // A DM (channel_id starts with "D") so it always passes the directed-message
-  // gate — keeps the test on the dispatch path deterministically.
-  const item = { id: "MSG-TRACE", raw_ref: "slack:D1:1", channel: "dm/ceo", channel_id: "D1", sender: "ceo", content: "please draft the board memo" };
-  writeLiveItem(item);
-
-  // Inject the heavy collaborators so the REAL processItem body runs (trace mint,
-  // item_received emit, dispatch onClose → sent emit) without a claude spawn:
-  //  - classify → "respond"/opus so it takes the holding+session (dispatch) path,
-  //    NOT the quick-reply path.
-  //  - isQuickReply → false to keep it on the dispatch path deterministically.
-  //  - sendHoldingMessage → no-op (no Slack post).
-  //  - dispatch → synchronously invoke onClose({ok:true}) to finalize.
-  let dispatchedItem = null;
-  await daemon.processItem(item, "slack", {
-    classify: async () => ({ priority: "critical", action: "respond", model: "opus", summary: "draft board memo", category: "action_required", directed_at_agent: true }),
-    isQuickReply: () => false,
-    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
-    dispatch: (_prompt, it, _cr, _src, opts) => { dispatchedItem = it; opts.onClose({ ok: true, code: 0 }); },
-  });
-
-  // The daemon set the minted id on the item and carried it onto the dispatch.
-  assert.ok(typeof item.trace_id === "string" && item.trace_id.length === 26, "a 26-char ULID trace_id was minted onto the item");
-  assert.equal(dispatchedItem.trace_id, item.trace_id, "the dispatch received the SAME trace_id");
-
-  const rows = readDiagnostics();
-  const received = rows.filter((r) => r.type === "item_received");
-  const sent = rows.filter((r) => r.type === "sent");
-  assert.equal(received.length, 1, "exactly one item_received");
-  assert.equal(sent.length, 1, "exactly one sent on clean finalize");
-  // The single-trace-id invariant: the first hop and the last hop share one id.
-  assert.equal(received[0].trace_id, item.trace_id, "item_received carries the minted trace_id");
-  assert.equal(sent[0].trace_id, item.trace_id, "sent carries the SAME trace_id (end-to-end correlation)");
-  // The in-flight admission also carries the trace (cheap ledger correlation).
-  assert.equal(sent[0].attrs.item_id, item.raw_ref, "sent records the item id");
-});
-
-test("DIAG: a failed (ok:false) finalize emits error (not sent), still under the one trace_id", async () => {
-  resetState();
-  clearDiagnostics();
-  const item = { id: "MSG-TRACE-FAIL", raw_ref: "slack:D2:1", channel: "dm/ceo", channel_id: "D2", sender: "ceo", content: "do the thing" };
-  writeLiveItem(item);
-
-  await daemon.processItem(item, "slack", {
-    classify: async () => ({ priority: "high", action: "respond", model: "opus", summary: "x", category: "action_required", directed_at_agent: true }),
-    isQuickReply: () => false,
-    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
-    dispatch: (_p, _it, _cr, _s, opts) => opts.onClose({ ok: false, code: 1 }),
-  });
-
-  const rows = readDiagnostics();
-  assert.equal(rows.filter((r) => r.type === "item_received").length, 1, "item_received emitted");
-  assert.equal(rows.filter((r) => r.type === "sent").length, 0, "a failed finalize must NOT emit sent");
-  const err = rows.filter((r) => r.type === "error");
-  assert.equal(err.length, 1, "a failed finalize emits an error hop");
-  assert.equal(err[0].trace_id, item.trace_id, "the error hop is under the same interaction trace_id");
-});
-
-// ---------------------------------------------------------------------------
-// 2) A send-gate block bumps the counter (responder's real instrumented path).
-// ---------------------------------------------------------------------------
-
-test("DIAG: a send-gate block bumps the send.blocked counter (responder validation path)", async () => {
-  clearDiagnostics();
-  const responder = await import("./responder.mjs");
-  // Force the generator to return text the REAL validateQuickReply blocks (AI
-  // self-disclosure) — no claude spawn, no Slack post. The block path must bump.
-  const restore = responder.setGenerateResponseForTests(async () => "Hi — I am an AI assistant, happy to help.");
-  try {
-    const before = (counters.snapshot()["send.blocked"]) || 0;
-    const res = await responder.sendQuickResponse(
-      { sender: "ceo", service: "slack", channel: "D1", content: "hello" },
-      { priority: "normal", action: "respond", model: "sonnet", summary: "hi" }
-    );
-    assert.equal(res.sent, false, "the AI-disclosure reply was blocked, not sent");
-    assert.equal(res.blocked, true);
-    const after = (counters.snapshot()["send.blocked"]) || 0;
-    assert.equal(after, before + 1, "the send-gate block bumped send.blocked by exactly one (durable JSONL)");
-  } finally { restore(); }
-});
-
-// ---------------------------------------------------------------------------
-// 3) The daemon's ONE real onGuardFail subscriber fires (the bus is live).
-// ---------------------------------------------------------------------------
-
-test("DIAG: registerHookSubscribers wires a real onGuardFail subscriber that bumps guard.fail", async () => {
-  clearDiagnostics();
-  // The daemon registers exactly one onGuardFail subscriber. It's idempotent, so
-  // calling it here (the test driver) is safe even though main() also would.
-  assert.equal(daemon.registerHookSubscribers(), true, "subscriber registered");
-  const hb = bus.getHookBus();
-  assert.ok(hb.count("onGuardFail") >= 1, "the bus has a live onGuardFail subscriber (not dead)");
-
-  const before = (counters.snapshot()["guard.fail"]) || 0;
-  // Emit a guard-fail (as the responder's send-gate fail-open path does). The
-  // real subscriber must fire and bump the durable counter.
-  const decision = await hb.emit("onGuardFail", { guard: "send_gate", reason: "policy unreadable", failed_open: true });
-  assert.equal(decision.cancelled, false, "onGuardFail is observe-only (never cancels)");
-  assert.equal(decision.errors, 0, "the subscriber did not throw");
-
-  const after = (counters.snapshot()["guard.fail"]) || 0;
-  assert.equal(after, before + 1, "the onGuardFail subscriber bumped guard.fail by exactly one");
-});
-
-test("DIAG: the responder's send-gate fail-open emits onGuardFail onto the live bus → guard.fail bumps", async () => {
-  clearDiagnostics();
-  daemon.registerHookSubscribers(); // ensure the real subscriber is live
-  const responder = await import("./responder.mjs");
-  // Generate benign text (passes validation), but force the Slack send-gate
-  // screen to throw a NON-block infra error so the responder fails OPEN and
-  // emits onGuardFail. We can't reach sendSlackMessage without a token, so we
-  // assert the wiring via the bus directly using the same emit the responder
-  // makes — the prior test proves the subscriber; here we prove a real producer
-  // shape lands on the same singleton bus the daemon subscribed to.
-  const hb = bus.getHookBus();
-  const before = (counters.snapshot()["guard.fail"]) || 0;
-  await hb.emit("onGuardFail", { guard: "send_gate", channel: "slack", recipient: "D1", reason: "gate module unreadable", failed_open: true });
-  const after = (counters.snapshot()["guard.fail"]) || 0;
-  assert.equal(after, before + 1, "a send-gate fail-open shape bumps guard.fail through the live subscriber");
-  // Tidy: drop the test reference so it doesn't leak the import.
-  void responder;
-});
-
-// ---------------------------------------------------------------------------
-// Post-session org-memory write-back (SP4) — after a clean turn, a bounded
-// distillation is authored to the shared store via remember(). Fail-open when
-// the org integration is disabled; never throws.
-// ---------------------------------------------------------------------------
-
-const ENABLED_ORG_CFG = { org: { cohort: { enabled: true, base: "https://org.example" } } };
-
-test("MEMORY: sessionDistillation produces a bounded one-line record", () => {
-  const line = daemon.sessionDistillation(
-    { sender: "Alice Smith", subject: "Q2 renewal" },
-    { action: "respond", summary: "Acme renewal terms and next steps" },
-    { agent: { firstName: "Jordan" } }
-  );
-  assert.ok(line, "should produce a distillation");
-  assert.ok(line.includes("Jordan"), "names the agent");
-  assert.ok(line.includes("respond"), "names the action");
-  assert.ok(line.includes("Alice Smith"), "names the sender");
-  assert.ok(line.includes("Acme renewal"), "carries the topic");
-  assert.ok(line.length <= 401, `bounded length, got ${line.length}`);
-});
-
-test("MEMORY: sessionDistillation returns null when there is nothing to remember", () => {
-  const line = daemon.sessionDistillation({}, {}, { agent: { firstName: "Jordan" } });
-  assert.equal(line, null, "no sender + no topic ⇒ null");
-});
-
-test("MEMORY: writeBackSession authors to the store when the org integration is enabled", async () => {
-  const calls = [];
-  const res = await daemon.writeBackSession(
-    { sender: "Alice Smith", subject: "Q2 renewal" },
-    { action: "respond", summary: "Acme renewal terms" },
-    {
-      cfg: ENABLED_ORG_CFG,
-      agent: { firstName: "Jordan" },
-      sessionId: "sess-xyz",
-      rememberImpl: async (text, opts) => { calls.push({ text, opts }); return { ok: true, mode: "append", id: "k1" }; },
-    }
-  );
-  assert.equal(res.ok, true, "write reported ok");
-  assert.equal(calls.length, 1, "remember() called exactly once");
-  assert.ok(calls[0].text.includes("Jordan"), "authored the distillation text");
-  assert.equal(calls[0].opts.cfg, ENABLED_ORG_CFG, "passed the org cfg through");
-  assert.equal(calls[0].opts.provenance.sessionId, "sess-xyz", "carried session provenance");
-});
-
-test("MEMORY: writeBackSession is a fail-open no-op when the org integration is disabled", async () => {
-  let called = false;
-  const res = await daemon.writeBackSession(
-    { sender: "Alice Smith" },
-    { action: "respond", summary: "x" },
-    { cfg: {}, rememberImpl: async () => { called = true; return { ok: true }; } }
-  );
-  assert.equal(res.skipped, true, "skipped when disabled");
-  assert.equal(called, false, "remember() not called when disabled");
-});
-
-test("MEMORY: writeBackSession never throws even if remember() rejects", async () => {
-  const res = await daemon.writeBackSession(
-    { sender: "Alice Smith", subject: "s" },
-    { action: "respond", summary: "y" },
-    { cfg: ENABLED_ORG_CFG, rememberImpl: async () => { throw new Error("network down"); } }
-  );
-  assert.equal(res.ok, false, "fail-open result");
-  assert.equal(res.skipped, true, "reported skipped on throw");
-});
-
-// ---------------------------------------------------------------------------
-// Post-session OUTCOME DISCIPLINE — the daemon's parity with hq's meeting chair.
-// A turn that committed to next steps must not leave them in a session log; the
-// close path lands them through the org protocol. OFF unless the flag is set.
-// The parsing/landing itself is covered by session-outcomes.test.mjs — these
-// tests assert the DAEMON's wiring: identity + config injection, and fail-open.
-// ---------------------------------------------------------------------------
-
-test("OUTCOMES: the daemon hook lands a turn's commitments through the org protocol", async () => {
-  const created = [];
-  const remembered = [];
-  const res = await daemon.sweepOutcomesForSession({
-    sessionId: "s-daemon-1",
-    resultText: "Handled it.\n\nOUTCOMES:\n- Send the revised deck to Alice — due: Monday\n",
-    enabled: true,
-    cfg: ENABLED_ORG_CFG,
-    agent: { firstName: "Robin" },
-    item: {
-      service: "slack",
-      channel: "general",
-      channel_id: "C0GENERAL",
-      // The PUBLIC signal. A `C…` id alone proves nothing — Slack mints them
-      // for private channels too — so the gate needs the conversation type.
-      channel_type: "channel",
-      sender: "Alice Smith",
-      subject: "Deck review",
-    },
-    classResult: { action: "respond", summary: "deck review" },
-    createItemImpl: async (item) => { created.push(item); return { ok: true }; },
-    rememberImpl: async (text, opts) => { remembered.push({ text, opts }); return { ok: true }; },
-  });
-  assert.equal(res.created, 1, "the commitment became a board item");
-  assert.equal(created[0].title, "Send the revised deck to Alice");
-  assert.ok(created[0].detail.includes("Robin"), "the daemon supplied the agent identity");
-  assert.equal(remembered.length, 1, "and one knowledge episode records the set");
-});
-
-test("OUTCOMES: a private DM's commitments never leave the DM", async () => {
-  // CONFIDENTIALITY. A landed outcome is an ORG-VISIBLE artifact: board.create
-  // with no workstreamId is channel-less, and the episode's knowledge.append
-  // carries no group (so hq resolves it to the `org` group). Landing a DM's
-  // commitments would republish a one-to-one conversation — including its topic
-  // line — to every member of the org. The gate is fail-closed.
-  let touched = false;
-  const res = await daemon.sweepOutcomesForSession({
-    sessionId: "s-daemon-dm",
-    resultText: "OUTCOMES:\n- Send Alice the confidential term sheet — due: Monday\n",
-    enabled: true,
-    cfg: ENABLED_ORG_CFG,
-    agent: { firstName: "Robin" },
-    item: {
-      service: "slack",
-      channel: "dm/alice-smith",
-      channel_id: "D01ALICE",
-      is_dm: true,
-      sender: "Alice Smith",
-      subject: "DM from Alice Smith",
-    },
-    classResult: { action: "respond", summary: "confidential term sheet" },
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-  });
-  assert.equal(res.created, 0);
-  assert.equal(res.reason, "source-dm");
-  assert.equal(touched, false, "no board row and no episode for a DM turn");
-});
-
-test("OUTCOMES: the daemon hook is OFF unless DAEMON_SESSION_OUTCOMES=1", async () => {
-  let touched = false;
-  const prior = process.env.DAEMON_SESSION_OUTCOMES;
-  try {
-    delete process.env.DAEMON_SESSION_OUTCOMES;
-    const res = await daemon.sweepOutcomesForSession({
-      sessionId: "s-daemon-2",
-      resultText: "OUTCOMES:\n- Do the thing",
-      cfg: ENABLED_ORG_CFG,
-      agent: { firstName: "Robin" },
-      createItemImpl: async () => { touched = true; return { ok: true }; },
-      rememberImpl: async () => { touched = true; return { ok: true }; },
-    });
-    assert.equal(res.skipped, true);
-    assert.equal(res.reason, "disabled");
-    assert.equal(touched, false, "nothing is written while the flag is off");
-  } finally {
-    if (prior === undefined) delete process.env.DAEMON_SESSION_OUTCOMES;
-    else process.env.DAEMON_SESSION_OUTCOMES = prior;
-  }
-});
-
-test("OUTCOMES: the daemon hook never throws into the dispatch path", async () => {
-  const res = await daemon.sweepOutcomesForSession({
-    sessionId: "s-daemon-3",
-    stdout: "{{{ not json",
-    enabled: true,
-    cfg: ENABLED_ORG_CFG,
-    agent: { firstName: "Robin" },
-    createItemImpl: async () => { throw new Error("network down"); },
-    rememberImpl: async () => { throw new Error("network down"); },
-  });
-  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: an ask the reply session cannot answer is never promised one (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).
-  //
-  // WHAT THIS PINS SINCE 2026-09-12. Nothing is said at open time on any path
-  // any more — `openAndAcknowledge` writes the debt and returns — so the old
-  // control ("with claude available a holding ack IS attempted") no longer
-  // describes the system. The fail-safe itself is unchanged and is what this
-  // asserts: when the CLI that would answer cannot start, the debt is opened
-  // with the interim FORBIDDEN on the record, so no sweep in any later tick or
-  // process can post a promise the seat cannot keep.
-  const assurance = await import("./assurance.mjs");
-  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 debt is opened and an interim is PERMITTED
-  // later, by the sweep, after ACK_AFTER_MS and inside the room's budget.
-  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, 0, "nothing is said at open time on ANY path — the interim belongs to the sweep");
-  assert.equal(up.dispatched, true, "control: the session is dispatched");
-  const upRec = assurance.readObligation("slack:DACKUP:1");
-  assert.ok(upRec, "the debt exists");
-  assert.notEqual(upRec.interimForbidden, true, "and an interim is permitted for it");
-
-  // TREATMENT: claude unavailable ⇒ the interim is forbidden on the record, but
-  // the session still runs (the assurance sweep owns the outcome; the human
-  // just isn't promised a reply the seat cannot produce).
-  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 interim is ever posted for this ask");
-  assert.equal(down.dispatched, true, "the session is still dispatched");
-  assert.equal(res.path, "session", "answerItem took the session path");
-  const downRec = assurance.readObligation("slack:DACKDN:1");
-  assert.ok(downRec, "the debt is opened all the same — an ask we cannot promise is exactly the one an operator must see");
-  assert.equal(downRec.interimForbidden, true, "durable on the record, because the sweep runs in another tick");
-});
-
-// ===========================================================================
-// 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");
-});
-
-test("REACTIVE PRIORITY: a quick reply yields the subscription (evicts backlog) BEFORE it generates", async () => {
-  resetState();
-  const item = { id: "MSG-YIELD", raw_ref: "slack:DYIELD:1", service: "slack", channel: "dm/ceo", channel_id: "DYIELD001", is_dm: true, sender: "ceo", subject: "quick q", content: "you around?" };
-  const order = [];
-  const res = await daemon.answerItem(item, "slack", "MSG-YIELD", "trace-yield", {
-    classify: async () => ({ priority: "high", action: "respond", model: "haiku", summary: "quick answer", category: "action_required", directed_at_agent: true }),
-    isQuickReply: () => true,
-    yieldBacklogForReactive: () => { order.push("yield"); return 2; },
-    sendQuickResponse: async () => { order.push("send"); return { sent: true }; },
-    claudeAvailable: () => true,
-  });
-  assert.equal(res.path, "quick_reply");
-  assert.deepEqual(order, ["yield", "send"], "backlog is yielded the subscription BEFORE the reply's claude call, not after");
-});
-
-test("resolveSelfMemberId reads the member cuid from the res frame's `result` (own-echo keystone)", async () => {
-  daemon._resetSelfMemberId();
-  const pk = process.env.COHORT_API_KEY, po = process.env.COHORT_ORG_ID, pa = process.env.COHORT_AGENT_ID;
-  process.env.COHORT_API_KEY = "nlk_test";
-  process.env.COHORT_ORG_ID = "org_test";
-  process.env.COHORT_AGENT_ID = "A016";
-  try {
-    let calls = 0;
-    // fetchSelfProfile returns the authed call() res frame: the member is under
-    // `result`, and the org key is passed as apiKey. (Both were wrong in 2.11.7.)
-    const mid = await daemon.resolveSelfMemberId({
-      fetchSelfProfileImpl: async (o) => {
-        calls++;
-        assert.equal(o.agentId, "A016", "must pass the slug so /members/<slug> resolves");
-        return { ok: true, result: { memberId: "cmSELFcuid", slug: o.agentId } };
-      },
-    });
-    assert.equal(mid, "cmSELFcuid");
-    // cached: a second call must NOT refetch
-    const again = await daemon.resolveSelfMemberId({
-      fetchSelfProfileImpl: async () => { throw new Error("must not refetch a cached self id"); },
-    });
-    assert.equal(again, "cmSELFcuid");
-    assert.equal(calls, 1);
-  } finally {
-    daemon._resetSelfMemberId();
-    if (pk === undefined) delete process.env.COHORT_API_KEY; else process.env.COHORT_API_KEY = pk;
-    if (po === undefined) delete process.env.COHORT_ORG_ID; else process.env.COHORT_ORG_ID = po;
-    if (pa === undefined) delete process.env.COHORT_AGENT_ID; else process.env.COHORT_AGENT_ID = pa;
-  }
-});
-
-test("fastPathClassify: a short directed question skips the classifier; work-requests do not", async () => {
-  const fp = (content, isDm = true, extra = {}) => daemon.fastPathClassify({ content, ...extra }, isDm);
-  // Plain short questions → fast-path (quick reply, high priority, sonnet).
-  const q = fp("what OS is your machine on?");
-  assert.equal(q && q.fast_path, true);
-  assert.equal(q.answerable, true);
-  assert.equal(q.priority, "high");
-  assert.equal(q.action, "respond");
-  assert.ok(daemon.fastPathClassify({ content: "hey, you around?" }, true));
-  assert.ok(daemon.fastPathClassify({ content: "thanks!" }, true));
-  // Work-requests → NOT fast-pathed (fall through to full classify → session).
-  assert.equal(fp("can you analyze the Q3 report and send me the findings?"), null);
-  assert.equal(fp("please review the PR and fix the failing tests"), null);
-  assert.equal(fp("build a dashboard for the sales pipeline"), null);
-  // Non-questions, long messages, group, and non-DM → NOT fast-pathed.
-  assert.equal(fp("here are the notes from the meeting for your records"), null);
-  assert.equal(fp("x".repeat(300)), null);
-  assert.equal(fp("what OS?", false), null); // not a DM
-  assert.equal(fp(""), null);
-  // Attachments → full path.
-  assert.equal(daemon.fastPathClassify({ content: "what's this?", has_attachments: true }, true), null);
-  // Kill switch (deps.disableFastPath) forces the full classify path.
-  assert.ok(daemon.fastPathClassify({ content: "what OS?" }, true));
-  assert.equal(daemon.fastPathClassify({ content: "what OS?" }, true, { disableFastPath: true }), null);
-});
-
-// ===========================================================================
-// SELF-ECHO — the agent's own outbound, re-ingested by a poll lane, must be
-// dropped BEFORE it can be classified, elected on, acked or answered. Recurred
-// live 2026-08-25 / 08-27 / 08-30: the old filter normalised the agent's full
-// name to "isla-roselli" while real events carry "Isla Roselli", so the agent
-// said "Looking now." to itself (and, in shared DMs, to another agent's echo).
-// ===========================================================================
-
-test("SELF-ECHO: an echoed own message is dropped at the processItem choke point — file retired, drop audited", async () => {
-  resetState();
-  const selfEcho = await import("./lib/self-echo.mjs");
-  const { writeFileSync: wf } = await import("node:fs");
-  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
-  wf(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({
-    firstName: "Isla", fullName: "Isla Roselli", memberId: "cmqh0tcml004ihhl6zev6ocb5",
-  }));
-  selfEcho._resetSelfIdentity();
-  try {
-    // The REAL echo shape: display name verbatim, spaces and all.
-    const item = { id: "MSG-SELF", raw_ref: "slack:DSELF:1", channel: "dm/candace", channel_id: "DSELF0001", sender: "Isla Roselli", content: "Both answers — and the second one settles it." };
-    const name = writeLiveItem(item);
-
-    let pipelineTouched = null;
-    const res = await daemon.processItem(item, "slack", {
-      classify: async () => { pipelineTouched = "classify"; return { priority: "high", action: "respond", model: "opus", summary: "x", category: "action_required", directed_at_agent: true }; },
-      isQuickReply: () => { pipelineTouched = "isQuickReply"; return false; },
-      sendQuickResponse: async () => { pipelineTouched = "quick_reply"; return { sent: true }; },
-      sendHoldingMessage: async () => { pipelineTouched = "holding_ack"; return { sent: true, holdingText: "x" }; },
-      dispatch: () => { pipelineTouched = "dispatch"; },
-      claudeAvailable: () => true,
-    });
-
-    assert.equal(res && res.path, "filtered", "the echo is filtered, not answered");
-    assert.equal(res && res.reason, "self_echo");
-    assert.equal(pipelineTouched, null, "no classify, no ack, no reply, no session — the echo never enters the pipeline");
-    assert.deepEqual(inboxFiles(), [`${name}.processed`], "the echo's inbox file is RETIRED — an un-retired echo would be re-scanned and re-dropped every tick forever");
-    const auditPath = join(AGENT_DIR, "logs", "daemon", "self-echo-drops.jsonl");
-    assert.ok(existsSync(auditPath), "every drop leaves an audit row");
-    assert.match(readFileSync(auditPath, "utf-8"), /slack:DSELF:1/, "the audit row names the dropped event");
-  } finally {
-    rmSync(join(AGENT_DIR, "config", "agent.json"), { force: true });
-    selfEcho._resetSelfIdentity();
-  }
-});
-
-test("SELF-ECHO: a genuine colleague's message is untouched by the guard", async () => {
-  resetState();
-  const selfEcho = await import("./lib/self-echo.mjs");
-  const { writeFileSync: wf } = await import("node:fs");
-  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
-  wf(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({
-    firstName: "Isla", fullName: "Isla Roselli", memberId: "cmqh0tcml004ihhl6zev6ocb5",
-  }));
-  selfEcho._resetSelfIdentity();
-  try {
-    const item = { id: "MSG-COLLEAGUE", raw_ref: "slack:DCOLL:1", channel: "dm/jordan", channel_id: "DCOLL0001", is_dm: true, sender: "Jordan Blake", content: "please draft the board memo" };
-    writeLiveItem(item);
-    let dispatched = false;
-    const res = await daemon.answerItem(item, "slack", "slack:DCOLL:1", "trace-coll", {
-      classify: async () => ({ priority: "critical", action: "respond", model: "opus", summary: "draft board memo", category: "action_required", directed_at_agent: true }),
-      isQuickReply: () => false,
-      sendHoldingMessage: async () => ({ sent: true, holdingText: "Starting on the board memo now." }),
-      dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
-      claudeAvailable: () => true,
-    });
-    assert.equal(dispatched, true, "a real colleague's ask still dispatches");
-    assert.equal(res.path, "session");
-  } finally {
-    rmSync(join(AGENT_DIR, "config", "agent.json"), { force: true });
-    selfEcho._resetSelfIdentity();
-  }
-});