@cohortapp/agent-sdk 2.11.15 → 2.12.0

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");
+});

package/scripts/daemon/agent-daemon.mjs

@@ -42,6 +42,12 @@ function loadAgent() {
   return _agent;
 }
 
+// Self-echo guard (25/27/30 Aug recurrences): the poll lane re-ingested this
+// agent's OWN outbound sends as fresh inbound and fired holding acks at them.
+// The old inline check compared `sender` against "isla-roselli" while real
+// events carry "Isla Roselli" — it never matched. The match now lives in one
+// tested module and every drop is audited to logs/daemon/self-echo-drops.jsonl.
+import { isSelfSender, logSelfEchoDrop } from "./lib/self-echo.mjs";
 import { pollSlack } from "../poller/slack-poller.mjs";
 import { pollGmail } from "../poller/gmail-poller.mjs";
 import { pollCalendar } from "../poller/calendar-poller.mjs";
@@ -71,6 +77,7 @@ import {
   openObligations,
   escalate,
   closeObligation,
+  isPidAlive,
 } from "./assurance.mjs";
 import { recordPoll, recordClassification, recordSession, writeHealthDashboard } from "./health.mjs";
 import { acquireLock, releaseLock, updateLock, scanStaleLocks, acquireThreadLock, claimRequest, hasActiveClaim, sweepStaleItemClaims, sanitiseItemId } from "./session-lock.mjs";
@@ -85,7 +92,12 @@ const RUNG_MECHANISM = Object.fromEntries(RUNGS.map((r) => [r.id, r.mechanism]))
 // work and land it in the org's shared, ACL'd store so the fleet's memory
 // compounds. Fail-open + best-effort — never blocks or throws into the hot path;
 // local SQLite/interaction logs remain the fail-open cache.
-import { isEnabled as orgEnabled, loadOrgConfig, configFromAgent, electResponder, fetchSelfProfile } from "../../lib/org/client.mjs";
+import { isEnabled as orgEnabled, loadOrgConfig, configFromAgent, electResponder, fetchSelfProfile, listMineResult as orgListMineResult } from "../../lib/org/client.mjs";
+// board.mine cache (design §3.5, WP-M6): the daemon writes state/org/board-mine.json
+// every 5 min; the SessionStart primer, session_status and `maestro board mine`
+// read it. The when/what is pure (lib/org/board-mine-cache.mjs); the I/O is here.
+import { shouldRefresh as boardMineShouldRefresh, renderRefresh as renderBoardMineRefresh, cacheTs as boardMineCacheTs, BOARD_MINE_REL } from "../../lib/org/board-mine-cache.mjs";
+import { writeJsonAtomic as writeJsonAtomicFile } from "../../lib/fs-atomic.mjs";
 import { remember as orgRemember } from "../../lib/org/knowledge.mjs";
 import { sweepSessionOutcomes, resultTextFromStdout } from "./session-outcomes.mjs";
 import { recordWorkStep as orgRecordWorkStep, cohortChannelId, cohortMessageId } from "../../lib/org/work-ledger.mjs";
@@ -117,6 +129,13 @@ import { getHookBus } from "../../lib/hooks/bus.mjs";
 // classifier path below is the mechanism the ladder's `react` effect drives,
 // not a parallel universe.
 import { processOne } from "../../lib/execution/pipeline.mjs";
+// FRONT DOOR (design §3.1/§3.3). When the seat's main session is live, the
+// daemon leaves Cohort inbox items in place for the session to claim instead
+// of spawning `claude --print`; not live → today's dispatch, unchanged. The
+// gate is pure (lib/session/frontdoor.mjs); the assurance sweep reopens a
+// session claim that was neither replied nor done within 20 min.
+import { makeFrontDoorGate } from "../../lib/session/frontdoor.mjs";
+import { sweepSessionInboxForDaemon } from "../../lib/session/inbox-claims.mjs";
 import { defaultEffects, scheduleToQueue } from "../../lib/execution/effects.mjs";
 import { loadReactObligations } from "../../lib/execution/match.mjs";
 import { policyFor } from "../../lib/execution/surface-policy.mjs";
@@ -227,8 +246,13 @@ async function poll() {
  * cohort path can run on its own fast interval (pollCohortFast) without waiting
  * on the 60s full poll. Returns the count of new items processed. Never throws.
  */
+const _frontDoorGate = makeFrontDoorGate({ agentRoot: AGENT_REPO_DIR });
 async function pollService(svc) {
   try {
+    // Front door: a live main session owns this service's inbox — leave it.
+    const fd = _frontDoorGate.check(svc.name);
+    if (fd.changed) console.log(`[daemon] front door for ${svc.name}: ${fd.dispatch ? "daemon dispatches" : "main session owns intake"} (${fd.reason})`);
+    if (!fd.dispatch) return 0;
     const result = await svc.fn();
     // Dedup by raw_ref first: the same Slack message arrives via multiple paths
     // (channel scan, thread scan, events-server JSON) with different item IDs.
@@ -236,12 +260,18 @@ async function pollService(svc) {
     // once regardless of path.
     const seenRefs = new Set();
     const newItems = result.items.filter((item) => {
-      // Skip the agent's own messages — defensive check in case intake filters miss them
-      const sender = (item.sender || "").toLowerCase();
-      const me = loadAgent();
-      const myFirst = (me.firstName || "").toLowerCase();
-      const myFull = (me.fullName || "").toLowerCase().replace(/\s+/g, "-");
-      if (myFirst && (sender === myFirst || sender === myFull)) return false;
+      // SELF-ECHO DROP (ingestion guard #1). The agent's own outbound, echoed
+      // back by a lane, is not inbound. Dropped LOUDLY (audit log) and the inbox
+      // file is retired — without the rename the same echo was re-scanned and
+      // re-considered every tick forever. The old check here compared `sender`
+      // against `fullName` with spaces folded to dashes, which never matched the
+      // real event shape ("Isla Roselli") — the exact reason the 25/27/30 Aug
+      // self-reply loops got past it.
+      if (isSelfSender(item)) {
+        logSelfEchoDrop(item, { stage: "poll", service: svc.name });
+        markProcessed(item, svc.name);
+        return false;
+      }
 
       const lockKey = item.raw_ref || item.id || `${svc.name}-${Date.now()}`;
       if (seenRefs.has(lockKey)) return false;
@@ -278,7 +308,7 @@ async function pollService(svc) {
 // against the 60s poll's own cohort scan (kept as a safety net).
 let _cohortPoller = null;
 let _cohortFastRunning = false;
-async function pollCohortFast() {
+export async function pollCohortFast() {
   if (_cohortFastRunning) return 0;
   if (!_existsSync(join(AGENT_REPO_DIR, "config/org.yaml"))) return 0;
   if (!_cohortPoller) _cohortPoller = makeInboxScanPoller("cohort", { agentRoot: AGENT_REPO_DIR });
@@ -339,6 +369,18 @@ async function processItemTraced(item, service, itemId, trace_id, deps = {}) {
   // regression-prone line in the file.
   enrichItem(item, service);
 
+  // ── SELF-ECHO DROP (guard #2, the choke point) ───────────────────────────
+  // Every entry path — the 60s poll, the fast cohort scan, crash recovery —
+  // crosses this line, so an echo that slipped past a lane's own filter is
+  // still stopped before it can be classified, elected on, acked or answered.
+  // Retiring the file is part of the drop: an un-retired echo is re-delivered
+  // next poll and re-dropped forever, which is noise pretending to be safety.
+  if (isSelfSender(item)) {
+    logSelfEchoDrop(item, { stage: "process", service });
+    markProcessed(item, service);
+    return { ok: true, path: "filtered", reason: "self_echo" };
+  }
+
   // ── THE EXECUTION LADDER, at the front of the chain ──────────────────────
   // Returns `{ handled }`. `handled:true` means the ladder took responsibility
   // for this item — it ignored it (journalled), queued it, delegated it,
@@ -899,6 +941,20 @@ export async function answerItem(item, service, itemId, trace_id, deps = {}, rou
     const ackVerdict = _claudeAvailable()
       ? shouldAcknowledge({ willSpawnSession: true, item, source: "inbox" })
       : { ack: false, reason: "claude-unavailable" };
+    // ── DISPATCH GATE: emitter-class inbound spawns NOTHING ─────────────────
+    // `emitterClass: true` means the gate read the inbound and recognised output
+    // this seat's own machinery class produces — a peer agent's ack-shaped
+    // one-liner, or another daemon's narrator line (progress/failure/terminal).
+    // Suppressing only the ack while still spawning would keep the expensive
+    // half of the 25/27/30 Aug loop: a 15-45 minute session burned answering a
+    // reflex. The gate already audited the refusal
+    // (logs/daemon/dispatch-gate-drops.jsonl); retire the item and stop here.
+    if (!ackVerdict.ack && ackVerdict.emitterClass) {
+      console.log(`[daemon] dispatch gate: no ack, no session for ${itemId} (${ackVerdict.reason})`);
+      counters.bump("dispatch.gate_refused", { service, reason: ackVerdict.reason });
+      markProcessed(item, service);
+      return { ok: true, path: "filtered", reason: ackVerdict.reason };
+    }
     try {
       // The DEBT is opened whether or not we can speak. Those are two different
       // questions and conflating them is what made a whole class of ask
@@ -1712,6 +1768,32 @@ export function _resetDaemonOrgCfgCache() {
   _cachedDaemonOrgCfg = undefined;
 }
 
+/**
+ * Refresh state/org/board-mine.json from hq `board.mine` when the cache is
+ * 5 min old (or absent). Fail-open end to end: an un-enrolled seat writes
+ * nothing; a FAILED read (hq unreachable) keeps the previous items and marks
+ * the document `stale: true` with `itemsAt` (lib/org/board-mine-cache.mjs
+ * renderRefresh) — one bad tick must not blank the primer, session_status
+ * and `maestro board mine` for five minutes. `listMineImpl` may return the
+ * `{ok, items}` shape of listMineResult or a bare array (= ok).
+ * @param {{now?:number, listMineImpl?:Function, force?:boolean}} [deps]
+ * @returns {Promise<{refreshed:boolean, reason:string, count?:number}>}
+ */
+export async function refreshBoardMineCache(deps = {}) {
+  const now = Number.isFinite(deps.now) ? deps.now : Date.now();
+  const path = join(AGENT_REPO_DIR, BOARD_MINE_REL);
+  let cur = null;
+  try { cur = JSON.parse(readFileSync(path, "utf8")); } catch { cur = null; /* absent or corrupt → refresh */ }
+  if (!deps.force && !boardMineShouldRefresh(boardMineCacheTs(cur), now)) return { refreshed: false, reason: "fresh" };
+  const cfg = daemonOrgCfg();
+  if (!orgEnabled(cfg)) return { refreshed: false, reason: "org-disabled" };
+  const conn = configFromAgent(cfg) || {};
+  const result = await (deps.listMineImpl || orgListMineResult)({ base: conn.base, token: conn.token, orgId: conn.orgId });
+  const doc = renderBoardMineRefresh(result, cur, now);
+  writeJsonAtomicFile(path, doc);
+  return { refreshed: true, reason: doc.stale ? "kept-previous" : "written", count: doc.items.length };
+}
+
 /** Longest completion note we will put on a board comment. */
 const COMPLETION_NOTE_CHARS = 1200;
 
@@ -2179,6 +2261,38 @@ async function sweepBacklog() {
 // Main
 // ---------------------------------------------------------------------------
 
+/**
+ * Daemon singleton ADVISORY — a pidfile check, deliberately not a lock.
+ *
+ * Two live daemons on one AGENT_DIR (the operator's manual run next to the
+ * launchd one) both poll, both sweep, and both narrate; the per-obligation
+ * ownership guard in assurance.sweepObligations bounds the damage, but the
+ * condition itself deserves a LOUD line the moment it starts. This only logs
+ * and counts — it never refuses to start and never exits — because launchd's
+ * KeepAlive restart may race the old process's teardown, and a pidfile that
+ * can veto startup under KeepAlive is a daemon that stays down. A recycled pid
+ * can false-positive; that costs one loud log line, nothing more.
+ */
+function advisePidfileSingleton() {
+  const pidPath = join(AGENT_REPO_DIR, "state", "daemon.pid");
+  try {
+    let prior = null;
+    try { prior = parseInt(readFileSync(pidPath, "utf-8"), 10); } catch { /* no pidfile yet */ }
+    if (Number.isFinite(prior) && prior > 0 && prior !== process.pid && isPidAlive(prior)) {
+      console.error(
+        `[daemon] ⚠ ANOTHER DAEMON MAY BE LIVE: pid ${prior} (from ${pidPath}) is running and also holds ${AGENT_REPO_DIR}. ` +
+        `Two daemons on one AGENT_DIR double-poll and race the obligation ledger — stop one unless this is deliberate.`,
+      );
+      counters.bump("daemon.singleton_advisory", { prior_pid: prior });
+    }
+    mkdirSync(join(AGENT_REPO_DIR, "state"), { recursive: true });
+    writeFileSync(pidPath, `${process.pid}\n`);
+  } catch (err) {
+    // Advisory only — an unwritable pidfile must never stop the daemon booting.
+    console.warn(`[daemon] pidfile advisory unavailable: ${err.message}`);
+  }
+}
+
 async function main() {
   console.log("╔══════════════════════════════════════════════════════════╗");
   console.log(`║          ${(loadAgent().firstName || "Agent").padEnd(8)} Daemon — Reactive Event Processor       ║`);
@@ -2205,6 +2319,11 @@ async function main() {
     // No emergency stop — continue
   }
 
+  // Two-daemon advisory: log loudly if another live daemon already holds this
+  // AGENT_DIR (pidfile check; never blocks startup — see the function's note on
+  // launchd KeepAlive semantics), then record this process as the holder.
+  advisePidfileSingleton();
+
   // Clear orphaned state from prior daemon instances
   const staleCleared = scanStaleLocks();
   if (staleCleared > 0) {
@@ -2242,6 +2361,9 @@ async function main() {
 
   // Initial poll immediately
   await poll();
+  // First board.mine cache write, so the primer has something before the
+  // first health tick (fail-open; an un-enrolled seat writes nothing).
+  refreshBoardMineCache().catch((err) => console.error("[daemon] board-mine cache error:", err.message));
 
   // Poll loop
   setInterval(async () => {
@@ -2285,6 +2407,12 @@ async function main() {
       if (claimsSwept > 0) {
         console.log(`[daemon] Swept ${claimsSwept} stale item claims`);
       }
+      // Front door: reopen session claims older than 20 min, due deferrals and
+      // (while the session is live) the daemon's own orphaned .dispatched files.
+      const reopened = sweepSessionInboxForDaemon(AGENT_REPO_DIR).reopened;
+      if (reopened.length > 0) console.log(`[daemon] reopened ${reopened.length} session-claimed inbox item(s): ${reopened.map((r) => `${r.id} (${r.reason})`).join(", ")}`);
+      // board.mine cache — the pure gate says "no" for four of every five ticks.
+      refreshBoardMineCache().catch((err) => console.error("[daemon] board-mine cache error:", err.message));
     } catch (err) {
       console.error("[daemon] Health write error:", err.message);
     }
@@ -2300,18 +2428,21 @@ async function main() {
   }, HEALTH_INTERVAL);
 
   // Graceful shutdown — clean up active.json so next startup doesn't see stale sessions
+  // Exit honours a pre-set process.exitCode: the org-mesh "restart" directive
+  // sets 1 before signalling so launchd's KeepAlive {SuccessfulExit:false}
+  // relaunches the daemon; a plain SIGTERM still exits 0 (stays down).
   process.on("SIGTERM", () => {
     console.log("[daemon] SIGTERM received, shutting down gracefully");
     resetActiveSessions();
     writeHealthDashboard();
-    process.exit(0);
+    process.exit(process.exitCode || 0);
   });
 
   process.on("SIGINT", () => {
     console.log("[daemon] SIGINT received, shutting down");
     resetActiveSessions();
     writeHealthDashboard();
-    process.exit(0);
+    process.exit(process.exitCode || 0);
   });
 
   console.log("[daemon] Running. Ctrl+C to stop.");