@cohortapp/agent-sdk 2.11.14 → 2.12.0

package/scripts/ci/check-durable-write-seam.test.mjs

@@ -0,0 +1,90 @@
+/**
+ * Tests for check-durable-write-seam.mjs — the durable-write effect boundary.
+ *
+ * Two things are worth testing and they are not the same thing:
+ *   1. The MATCHER's discrimination — that it fires on a direct durable-JSON
+ *      write and stays silent on the three shapes that are already safe
+ *      (temp-then-rename, injected `deps.writeFileSync`, non-JSON payloads).
+ *      A guard that flags safe code gets suppressed, so this is the property
+ *      that decides whether the guard survives contact with contributors.
+ *   2. The REGISTER's honesty against the real tree — that every sanctioned
+ *      site still exists at the line it claims. This is what stops the register
+ *      becoming a place stale names hide.
+ *
+ * @module scripts/ci/check-durable-write-seam.test
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  findDirectDurableWrites,
+  SANCTIONED_DIRECT_WRITES,
+} from "./check-durable-write-seam.mjs";
+
+const REPO_ROOT = path.resolve(fileURLToPath(new URL(".", import.meta.url)), "..", "..");
+
+/** The matcher, lifted verbatim from the guard so a line can be tested alone. */
+function flags(line) {
+  if (!line.includes("writeFileSync(")) return false;
+  if (!line.includes("JSON.stringify")) return false;
+  if (/writeFileSync\(\s*(tmp|temp|tmpPath|tmpFile|fd)\b/.test(line)) return false;
+  if (/deps\.writeFileSync/.test(line)) return false;
+  return true;
+}
+
+describe("check-durable-write-seam: what the matcher sees", () => {
+  it("flags a direct write of durable JSON to a final path", () => {
+    assert.equal(flags('writeFileSync(join(dir, "self.json"), JSON.stringify(entry, null, 2));'), true);
+  });
+
+  it("does NOT flag temp-then-rename — that IS the atomic pattern, hand-rolled", () => {
+    assert.equal(flags('writeFileSync(tmp, JSON.stringify(state, null, 2) + "\\n");'), false);
+    assert.equal(flags("writeFileSync(tmpPath, JSON.stringify(o));"), false);
+  });
+
+  it("does NOT flag the injected-dependency form — that is better than a shared helper, not worse", () => {
+    assert.equal(flags("const wr = deps.writeFileSync || writeFileSync; wr(p, JSON.stringify(o));"), false);
+  });
+
+  it("does NOT flag non-JSON payloads — audio, YAML, markdown, marker files", () => {
+    assert.equal(flags("writeFileSync(join(d, f), audio);"), false);
+    assert.equal(flags("writeFileSync(p, yaml.dump(doc));"), false);
+  });
+});
+
+describe("check-durable-write-seam: the register is honest about the real tree", () => {
+  const hits = findDirectDurableWrites();
+  const found = new Set(hits.map((h) => h.site));
+
+  it("finds at least one site — a matcher that matches nothing passes vacuously", () => {
+    assert.ok(hits.length > 0, "matcher found nothing; it is probably broken");
+  });
+
+  it("every sanctioned site still exists at the line it claims", () => {
+    for (const site of Object.keys(SANCTIONED_DIRECT_WRITES)) {
+      assert.ok(found.has(site), `stale register entry: ${site}`);
+    }
+  });
+
+  it("no unregistered direct durable write exists under lib/", () => {
+    const unregistered = [...found].filter((s) => !(s in SANCTIONED_DIRECT_WRITES)).sort();
+    assert.deepEqual(unregistered, []);
+  });
+
+  it("every sanctioned entry carries a non-empty reason", () => {
+    for (const [site, reason] of Object.entries(SANCTIONED_DIRECT_WRITES)) {
+      assert.ok(reason && reason.length > 20, `register entry ${site} needs a real reason`);
+    }
+  });
+
+  it("the sanctioned sites are all O_EXCL lock acquisition — the one shape rename would break", () => {
+    for (const site of Object.keys(SANCTIONED_DIRECT_WRITES)) {
+      const [rel, lineNo] = site.split(":");
+      const line = readFileSync(path.join(REPO_ROOT, rel), "utf8").split("\n")[Number(lineNo) - 1];
+      assert.match(line, /scheduleLock/, `${site} is not a lock write; it should not be exempt`);
+    }
+  });
+});

package/scripts/ci/check.mjs

@@ -20,6 +20,7 @@
  *   - check-no-build-artifacts  : no tracked .pyc/symlinks reach the tarball
  *   - check-docs-accuracy       : README links resolve; counts/agent-refs WARN
  *   - check-subagent-frontmatter: every agents/*.md passes the registry validator
+ *   - check-durable-write-seam  : durable JSON writes under lib/ go through fs-atomic
  *
  * Usage: `node scripts/ci/check.mjs`
  *   exit 0 → all checks passed; exit 1 → one or more failed.
@@ -38,6 +39,7 @@ import { run as runNoResidualIdentity } from "./check-no-residual-identity.mjs";
 import { run as runNoBuildArtifacts } from "./check-no-build-artifacts.mjs";
 import { run as runDocsAccuracy } from "./check-docs-accuracy.mjs";
 import { run as runSubagentFrontmatter } from "./check-subagent-frontmatter.mjs";
+import { run as runDurableWriteSeam } from "./check-durable-write-seam.mjs";
 
 /**
  * The ordered list of guards this aggregator runs.
@@ -54,6 +56,7 @@ export const CHECKS = [
   { name: "check-no-build-artifacts", run: runNoBuildArtifacts },
   { name: "check-docs-accuracy", run: runDocsAccuracy },
   { name: "check-subagent-frontmatter", run: runSubagentFrontmatter },
+  { name: "check-durable-write-seam", run: runDurableWriteSeam },
 ];
 
 /**

package/scripts/collective/hook-runner.mjs

@@ -76,8 +76,10 @@ async function main() {
   const repo = basename(cwd || "");
 
   if (event === "prime") {
-    try { presence.register(SELF_ROOT, { sessionId, cwd, repo, kind: classifyKind(input) }); } catch { /* */ }
-    if (denied) return; // never inject agent memory into a ring-fenced/client session
+    const kind = classifyKind(input);
+    try { presence.register(SELF_ROOT, { sessionId, cwd, repo, kind }); } catch { /* */ }
+    if (denied) return; // never inject agent memory (or the persona) into a ring-fenced/client session
+    const parts = [];
     try {
       const recall = await import("../../lib/collective/recall.mjs");
       const digest = recall.buildDigest(SELF_ROOT, {
@@ -86,8 +88,25 @@ async function main() {
         halfLifeDays: config.recencyHalfLifeDays,
         staleSec: config.presence && config.presence.staleSec,
       });
-      emitContext(digest);
-    } catch { /* */ }
+      if (digest) parts.push(digest);
+    } catch { /* the digest is best-effort; the primer below still runs */ }
+    // Front-door session (2026-09): the identity block + a one-line session
+    // status (main session liveness, peers, open handoffs, board-mine count
+    // from state/org/board-mine.json when the daemon has cached it). Any
+    // session on the machine — a home-dir `claude`, a peer, the main session
+    // itself — learns who it is from this. Silent when the repo has no
+    // identity yet (config/agent.json absent or unconfigured), and skipped
+    // for the daemon's own `claude --print` children (MAESTRO_DAEMON=1): their
+    // prompt-builder preamble already carries the identity, so the block
+    // would be ~400 duplicate tokens on every dispatch.
+    if (kind !== "daemon") {
+      try {
+        const primer = await buildFrontDoorPrimer(SELF_ROOT);
+        if (primer) parts.push(primer);
+      } catch { /* an unreadable state dir must never break a session start */ }
+    }
+    // ONE frame: Claude Code reads a single JSON object from a hook's stdout.
+    emitContext(parts.join("\n\n"));
     return;
   }
 
@@ -116,6 +135,22 @@ async function main() {
   }
 }
 
+/** The identity block + status line for `prime`. "" when there is nothing to say. */
+function buildFrontDoorPrimer(agentRoot) {
+  let agentJson = null;
+  try {
+    const p = join(agentRoot, "config", "agent.json");
+    if (existsSync(p)) agentJson = JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    agentJson = null; // an unconfigured/corrupt agent.json is "no identity yet"
+  }
+  if (!agentJson || !(agentJson.fullName || agentJson.firstName)) return "";
+  // Dynamic import so a hook on a repo that predates lib/session stays silent
+  // instead of failing the session start.
+  return import("../../lib/session/status-summary.mjs").then((mod) =>
+    mod.buildPrimerContext({ agentJson, agentRoot, status: mod.readSessionStatus(agentRoot, { now: Date.now() }) }));
+}
+
 function classifyKind(input) {
   const src = String(input.source || "").toLowerCase();
   if (src.includes("daemon") || process.env.MAESTRO_DAEMON === "1") return "daemon";

package/scripts/collective/hook-runner.test.mjs

@@ -24,11 +24,14 @@ function tmpRoot() {
   mkdirSync(join(root, "config"), { recursive: true });
   return root;
 }
-function run(event, input, root) {
+function run(event, input, root, extraEnv = {}) {
+  const env = { ...process.env, MAESTRO_COLLECTIVE_ROOT: root };
+  delete env.MAESTRO_DAEMON; // never inherit a daemon marker from the runner's own environment
+  Object.assign(env, extraEnv);
   return spawnSync(process.execPath, [RUNNER, event], {
     input: JSON.stringify(input),
     encoding: "utf8",
-    env: { ...process.env, MAESTRO_COLLECTIVE_ROOT: root },
+    env,
   });
 }
 
@@ -88,3 +91,83 @@ test("disabled config → fully silent no-op", () => {
     assert.equal(r.stdout.trim(), "");
   } finally { rmSync(root, { recursive: true, force: true }); }
 });
+
+// ── WP-M4: the front-door primer (identity block + session status) ─────────
+
+test("prime: injects the identity block + one-line session status + handoff/board counts when the repo has an identity", () => {
+  const root = tmpRoot();
+  try {
+    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({
+      firstName: "Alex", fullName: "Alex Rivera", title: "Chief of Staff", company: "Acme",
+      principal: { fullName: "Jordan Lee", title: "CEO" }, repoSlug: "alex-ai",
+    }));
+    mkdirSync(join(root, "state", "session", "handoffs"), { recursive: true });
+    mkdirSync(join(root, "state", "org"), { recursive: true });
+    writeFileSync(join(root, "state", "session", "heartbeat.json"), JSON.stringify({ pid: 1, name: "alex-main", ts: Date.now() }));
+    writeFileSync(join(root, "state", "session", "handoffs", "t1.json"), "{}");
+    writeFileSync(join(root, "state", "session", "handoffs", "t2.json"), "{}");
+    writeFileSync(join(root, "state", "org", "board-mine.json"), JSON.stringify({ items: [{ itemId: "i1" }], fetchedAt: new Date().toISOString() }));
+    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
+    assert.equal(r.status, 0);
+    const payload = JSON.parse(r.stdout);
+    const ctx = payload.hookSpecificOutput.additionalContext;
+    assert.match(ctx, /maestro:identity/);
+    assert.match(ctx, /Alex Rivera/);
+    assert.match(ctx, /Chief of Staff/);
+    assert.match(ctx, /`alex-main`/);
+    assert.match(ctx, /Session status: main session alex-main live/);
+    assert.match(ctx, /2 open handoffs/);
+    assert.match(ctx, /1 board item/);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("prime: identity primer and memory digest are emitted together in ONE hook frame", () => {
+  const root = tmpRoot();
+  try {
+    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
+    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research" });
+    appendCards(root, [{ kind: "decision", title: "Shipped billing", salience: 0.9, ts: new Date().toISOString() }], { sessionId: "prev" });
+    const r = run("prime", { session_id: "me", cwd: "/x/maestro" }, root);
+    assert.equal(r.status, 0);
+    const frames = r.stdout.trim().split("\n").filter(Boolean);
+    assert.equal(frames.length, 1, "exactly one JSON frame on stdout");
+    const ctx = JSON.parse(frames[0]).hookSpecificOutput.additionalContext;
+    assert.match(ctx, /maestro:collective-digest/);
+    assert.match(ctx, /Shipped billing/);
+    assert.match(ctx, /maestro:identity/);
+    assert.match(ctx, /Session status: main session not running/);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("prime: a denylisted cwd gets neither memory nor identity", () => {
+  const root = tmpRoot();
+  try {
+    writeFileSync(join(root, "config", "collective.yaml"), "repoDenylist: [client-secret]\n");
+    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
+    const r = run("prime", { session_id: "me", cwd: "/work/client-secret" }, root);
+    assert.equal(r.status, 0);
+    assert.equal(r.stdout.trim(), "");
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("prime: the daemon's own `claude --print` children (MAESTRO_DAEMON=1) get the memory digest but NOT the identity primer", () => {
+  const root = tmpRoot();
+  try {
+    writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Rivera" }));
+    // No digest material → a daemon child is fully silent.
+    const quiet = run("prime", { session_id: "d1", cwd: "/x/maestro" }, root, { MAESTRO_DAEMON: "1" });
+    assert.equal(quiet.status, 0);
+    assert.equal(quiet.stdout.trim(), "", "no identity block for a daemon child");
+    // With digest material → the digest still flows, the identity block still does not.
+    register(root, { sessionId: "other", cwd: "/x/openclaw", intent: "research" });
+    appendCards(root, [{ kind: "decision", title: "Shipped billing", salience: 0.9, ts: new Date().toISOString() }], { sessionId: "prev" });
+    const r = run("prime", { session_id: "d2", cwd: "/x/maestro" }, root, { MAESTRO_DAEMON: "1" });
+    assert.equal(r.status, 0);
+    const ctx = JSON.parse(r.stdout).hookSpecificOutput.additionalContext;
+    assert.match(ctx, /Shipped billing/);
+    assert.ok(!/maestro:identity/.test(ctx), "identity primer is skipped for daemon children");
+    // An interactive session on the same repo still gets it.
+    const i = run("prime", { session_id: "i1", cwd: "/x/maestro" }, root);
+    assert.match(JSON.parse(i.stdout).hookSpecificOutput.additionalContext, /maestro:identity/);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});

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

@@ -0,0 +1,96 @@
+/**
+ * agent-daemon-board-mine.test.mjs — the daemon caches hq `board.mine` to
+ * state/org/board-mine.json every 5 minutes (design §3.5, WP-M6).
+ *
+ * Drives the REAL refreshBoardMineCache with an injected listMine and a fixed
+ * clock under a tmp AGENT_DIR. Same `imapflow` loader stub as the other
+ * daemon tests.
+ */
+
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import { register } from "node:module";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+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)}`);
+
+const AGENT_DIR = mkdtempSync(join(tmpdir(), "maestro-daemon-board-mine-"));
+process.env.AGENT_DIR = AGENT_DIR;
+process.env.MAESTRO_DAEMON_NO_AUTOSTART = "1";
+
+const NOW = Date.parse("2026-09-08T12:00:00Z");
+const CACHE = join(AGENT_DIR, "state", "org", "board-mine.json");
+
+let daemon;
+before(async () => {
+  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
+  mkdirSync(join(AGENT_DIR, "state", "sessions", "locks"), { recursive: true });
+  writeFileSync(join(AGENT_DIR, "config", "org.yaml"), "org:\n  cohort:\n    enabled: true\n    base: https://os.example.test\n    token: nlk_test_token\n    orgId: org_test\n");
+  writeFileSync(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({ firstName: "Nova", lastName: "Reyes" }));
+  const url = new URL("./agent-daemon.mjs", import.meta.url);
+  daemon = await import(`${url.href}?boardmine=${Math.random()}`);
+});
+
+test("first call writes state/org/board-mine.json as {ts, items} from listMine; a call inside 5 min is a no-op; one at 5 min refreshes", async () => {
+  const calls = [];
+  const listMineImpl = async (o) => { calls.push(o); return [{ itemId: "i1", title: "Do X", col: "todo" }, null, "junk"]; };
+  const first = await daemon.refreshBoardMineCache({ now: NOW, listMineImpl });
+  assert.deepEqual(first, { refreshed: true, reason: "written", count: 1 });
+  assert.ok(existsSync(CACHE));
+  const doc = JSON.parse(readFileSync(CACHE, "utf8"));
+  assert.deepEqual(doc, { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i1", title: "Do X", col: "todo" }] });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].base, "https://os.example.test", "the daemon's org.yaml connection is what listMine gets");
+  assert.equal(calls[0].orgId, "org_test");
+
+  const soon = await daemon.refreshBoardMineCache({ now: NOW + 4 * 60_000, listMineImpl });
+  assert.deepEqual(soon, { refreshed: false, reason: "fresh" });
+  assert.equal(calls.length, 1, "no hq call inside the interval");
+
+  const later = await daemon.refreshBoardMineCache({ now: NOW + 5 * 60_000, listMineImpl: async () => ({ ok: true, items: [] }) });
+  assert.deepEqual(later, { refreshed: true, reason: "written", count: 0 });
+  assert.deepEqual(JSON.parse(readFileSync(CACHE, "utf8")), { ts: "2026-09-08T12:05:00.000Z", items: [] }, "an empty board is a real answer");
+});
+
+test("hq unreachable for one tick: the last known good items are KEPT and the document is marked stale with itemsAt; the next good read clears it", async () => {
+  await daemon.refreshBoardMineCache({ now: NOW + 10 * 60_000, listMineImpl: async () => [{ itemId: "keep-me" }] });
+  const failed = await daemon.refreshBoardMineCache({ now: NOW + 15 * 60_000, listMineImpl: async () => ({ ok: false, items: [], error: "http 503" }) });
+  assert.deepEqual(failed, { refreshed: true, reason: "kept-previous", count: 1 });
+  const doc = JSON.parse(readFileSync(CACHE, "utf8"));
+  assert.deepEqual(doc, { ts: "2026-09-08T12:15:00.000Z", items: [{ itemId: "keep-me" }], stale: true, itemsAt: "2026-09-08T12:10:00.000Z", error: "http 503" });
+  const ok = await daemon.refreshBoardMineCache({ now: NOW + 20 * 60_000, listMineImpl: async () => ({ ok: true, items: [{ itemId: "fresh" }] }) });
+  assert.deepEqual(ok, { refreshed: true, reason: "written", count: 1 });
+  assert.deepEqual(JSON.parse(readFileSync(CACHE, "utf8")), { ts: "2026-09-08T12:20:00.000Z", items: [{ itemId: "fresh" }] });
+});
+
+test("a corrupt cache is refreshed; force bypasses the interval; the tick-loop call never throws when listMine rejects", async () => {
+  writeFileSync(CACHE, "{not json");
+  const r = await daemon.refreshBoardMineCache({ now: NOW + 30 * 60_000, listMineImpl: async () => [{ itemId: "z" }] });
+  assert.equal(r.refreshed, true);
+  const forced = await daemon.refreshBoardMineCache({ now: NOW + 30 * 60_000 + 1, force: true, listMineImpl: async () => [{ itemId: "y" }] });
+  assert.equal(forced.refreshed, true);
+  assert.deepEqual(JSON.parse(readFileSync(CACHE, "utf8")).items, [{ itemId: "y" }]);
+  await assert.rejects(daemon.refreshBoardMineCache({ now: NOW + 40 * 60_000, listMineImpl: async () => { throw new Error("boom"); } }), /boom/);
+  assert.deepEqual(JSON.parse(readFileSync(CACHE, "utf8")).items, [{ itemId: "y" }], "a failed refresh leaves the previous cache in place");
+});
+
+test("an un-enrolled seat (org disabled) writes nothing", async () => {
+  writeFileSync(join(AGENT_DIR, "config", "org.yaml"), "org:\n  cohort:\n    enabled: false\n");
+  daemon._resetDaemonOrgCfgCache();
+  rmSync(CACHE, { force: true });
+  const r = await daemon.refreshBoardMineCache({ now: NOW + 60 * 60_000, listMineImpl: async () => [{ itemId: "no" }] });
+  assert.deepEqual(r, { refreshed: false, reason: "org-disabled" });
+  assert.ok(!existsSync(CACHE));
+});

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

@@ -0,0 +1,60 @@
+/**
+ * agent-daemon-frontdoor.test.mjs — the daemon steps back from the Cohort
+ * inbox while the main session is live (design §3.1).
+ *
+ * Drives the REAL fast cohort scan (pollCohortFast → pollService) with a live
+ * heartbeat planted under the tmp AGENT_DIR and a fresh inbox item: the item
+ * must be left exactly as it arrived (no lock, no rename, no classification).
+ * The not-live branch is the pre-existing dispatch path, which would reach the
+ * Haiku classifier — it is covered by the pure gate tests instead.
+ *
+ * Same `imapflow` loader stub as agent-daemon.test.mjs.
+ */
+
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import { register } from "node:module";
+import { mkdtempSync, mkdirSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+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)}`);
+
+const AGENT_DIR = mkdtempSync(join(tmpdir(), "maestro-daemon-frontdoor-"));
+process.env.AGENT_DIR = AGENT_DIR;
+process.env.MAESTRO_DAEMON_NO_AUTOSTART = "1";
+
+let daemon;
+before(async () => {
+  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
+  mkdirSync(join(AGENT_DIR, "state", "inbox", "cohort"), { recursive: true });
+  mkdirSync(join(AGENT_DIR, "state", "session"), { recursive: true });
+  mkdirSync(join(AGENT_DIR, "state", "sessions", "locks"), { recursive: true });
+  writeFileSync(join(AGENT_DIR, "config", "org.yaml"), "org:\n  cohort:\n    enabled: true\n");
+  writeFileSync(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({ firstName: "Nova", lastName: "Reyes" }));
+  const url = new URL("./agent-daemon.mjs", import.meta.url);
+  daemon = await import(`${url.href}?frontdoor=${Math.random()}`);
+});
+
+test("live main session: pollCohortFast leaves a fresh cohort item untouched for the session", async () => {
+  writeFileSync(join(AGENT_DIR, "state", "session", "heartbeat.json"), JSON.stringify({ pid: process.pid, ts: new Date().toISOString() }));
+  const name = "2026-09-08T10-00-00-000Z-cohort-fd1.yaml";
+  writeFileSync(join(AGENT_DIR, "state", "inbox", "cohort", name), [
+    'id: "cohort-fd1"', 'service: "cohort"', 'channel: "dm/olivia"', 'channel_id: "ch1"', 'channel_kind: "DM"',
+    'sender: "Olivia Chen"', 'timestamp: "2026-09-08T10:00:00.000Z"', 'subject: ""', "content: |", "  hello", 'raw_ref: "cohort-fd1"', "",
+  ].join("\n"));
+  const n = await daemon.pollCohortFast();
+  assert.equal(n, 0, "nothing dispatched by the daemon");
+  assert.deepEqual(readdirSync(join(AGENT_DIR, "state", "inbox", "cohort")), [name], "the item is still a fresh .yaml");
+  assert.deepEqual(readdirSync(join(AGENT_DIR, "state", "sessions", "locks")), [], "no per-item lock taken");
+});