@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/session/feed-core.test.mjs

@@ -1,198 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  PREVIEW_MAX,
-  emptySeen,
-  parseSeen,
-  isLiveInboxFile,
-  isHandoffFile,
-  inboundEvent,
-  handoffEvent,
-  computeFeedEvents,
-} from "./feed-core.mjs";
-import { inboxItemToYaml } from "../../scripts/poller/utils.mjs";
-
-const T0 = Date.parse("2026-09-08T10:00:00Z");
-
-function cohortItem(over = {}) {
-  return inboxItemToYaml({
-    id: "msg-1",
-    service: "cohort",
-    channel: "dm/casey",
-    channel_id: "ch_abc",
-    sender: "Casey Ng",
-    sender_privilege: "ceo",
-    timestamp: "2026-09-08T09:59:00.000Z",
-    subject: "Cohort message",
-    content: "Can you pull the Q3 numbers? my key is sk-ant-api03-" + "a".repeat(40),
-    thread_id: "th_1",
-    kind: "mention",
-    direct_reason: "mention",
-    channel_kind: "DM",
-    raw_ref: "cohort:ch_abc:msg-1",
-    ...over,
-  });
-}
-
-test("emptySeen / parseSeen: versioned, fail-open", () => {
-  assert.deepEqual(emptySeen(), { version: 1, seq: 0, inbox: {}, handoffs: {}, signals: {} });
-  assert.deepEqual(parseSeen("{"), emptySeen());
-  assert.deepEqual(parseSeen(JSON.stringify({ version: 99 })), emptySeen());
-  const s = { version: 1, seq: 7, inbox: { "cohort/a.yaml": T0 }, handoffs: {}, signals: { restart: 1 } };
-  assert.deepEqual(parseSeen(JSON.stringify(s)), s);
-});
-
-test("isLiveInboxFile / isHandoffFile", () => {
-  assert.equal(isLiveInboxFile("2026-09-08T09-59-00-000Z-msg-1.yaml"), true);
-  assert.equal(isLiveInboxFile("x.yaml.dispatched"), false);
-  assert.equal(isLiveInboxFile("x.yaml.processed"), false);
-  assert.equal(isLiveInboxFile("x.yaml.deferred"), false);
-  assert.equal(isLiveInboxFile(".hidden.yaml"), false);
-  assert.equal(isHandoffFile("tick-1.json"), true);
-  assert.equal(isHandoffFile("tick-1.json.tmp.1.2.ab"), false);
-  assert.equal(isHandoffFile("done"), false);
-});
-
-test("inboundEvent: the documented line, surface from kind, topic from the surface table, preview redacted + capped", () => {
-  const ev = inboundEvent({ service: "cohort", path: "/agent/state/inbox/cohort/a.yaml", body: cohortItem(), seq: 3 });
-  assert.equal(ev.type, "inbound");
-  assert.equal(ev.id, "msg-1");
-  assert.equal(ev.service, "cohort");
-  assert.equal(ev.surface, "mention");
-  assert.equal(ev.topic, "message");
-  assert.equal(ev.reason, "mention");
-  assert.equal(ev.from, "Casey Ng");
-  assert.equal(ev.channelId, "ch_abc");
-  assert.equal(ev.channelName, "dm/casey");
-  assert.equal(ev.threadId, "th_1");
-  assert.equal(ev.path, "/agent/state/inbox/cohort/a.yaml");
-  assert.equal(ev.seq, 3);
-  assert.match(ev.preview, /Q3 numbers/);
-  assert.doesNotMatch(ev.preview, /sk-ant-api03/);
-  assert.ok(ev.preview.length <= PREVIEW_MAX);
-  assert.deepEqual(Object.keys(ev), ["type", "id", "service", "surface", "topic", "reason", "from", "channelId", "channelName", "threadId", "preview", "path", "seq"]);
-});
-
-test("inboundEvent: a plain message maps to surface=message/topic=message; a task kind maps to topic=task; long previews are capped", () => {
-  const plain = inboundEvent({ service: "cohort", path: "/p", body: cohortItem({ kind: undefined, direct_reason: undefined, content: "x ".repeat(400) }), seq: 1 });
-  assert.equal(plain.surface, "message");
-  assert.equal(plain.topic, "message");
-  assert.equal(plain.reason, "");
-  assert.equal(plain.preview.length, PREVIEW_MAX);
-  const task = inboundEvent({ service: "cohort", path: "/p", body: cohortItem({ kind: "task_assigned", direct_reason: "assignee" }), seq: 2 });
-  assert.equal(task.topic, "task");
-  assert.equal(task.reason, "assignee");
-});
-
-test("inboundEvent: an unparseable body yields null (the file is skipped, not a crash)", () => {
-  assert.equal(inboundEvent({ service: "cohort", path: "/p", body: "", seq: 1 }), null);
-  assert.equal(inboundEvent({ service: "cohort", path: "/p", body: null, seq: 1 }), null);
-});
-
-test("handoffEvent: from the consumer's handoff JSON; id falls back to the file name", () => {
-  const body = JSON.stringify({ tickId: "t-9", cadence: "morning-brief", mode: "escalate", promptPath: "/agent/state/session/handoffs/t-9.prompt.md", enqueuedAt: "2026-09-08T10:00:00Z", deadlineAt: "x" });
-  const ev = handoffEvent({ path: "/agent/state/session/handoffs/t-9.json", file: "t-9.json", body, seq: 5 });
-  assert.deepEqual(ev, { type: "handoff", id: "t-9", cadence: "morning-brief", promptPath: "/agent/state/session/handoffs/t-9.prompt.md", enqueuedAt: "2026-09-08T10:00:00Z", path: "/agent/state/session/handoffs/t-9.json", seq: 5 });
-  const bare = handoffEvent({ path: "/h/tick-2.json", file: "tick-2.json", body: "{}", seq: 6 });
-  assert.equal(bare.id, "tick-2");
-  assert.equal(bare.cadence, "");
-  assert.equal(handoffEvent({ path: "/h/x.json", file: "x.json", body: "{", seq: 7 }), null);
-});
-
-function snapshot(over = {}) {
-  return {
-    inbox: { cohort: [] },
-    handoffs: [],
-    signals: { restartRequestedMtimeMs: null, upgradeNotice: null, daemonHealthMtimeMs: T0, daemonPidAlive: null },
-    ...over,
-  };
-}
-
-test("computeFeedEvents: new inbox items and handoffs are emitted once, in a stable order, with increasing seq", () => {
-  const snap = snapshot({
-    inbox: {
-      cohort: [
-        { file: "b.yaml", path: "/i/b.yaml", body: cohortItem({ id: "b" }) },
-        { file: "a.yaml", path: "/i/a.yaml", body: cohortItem({ id: "a" }) },
-        { file: "c.yaml.dispatched", path: "/i/c.yaml.dispatched", body: cohortItem({ id: "c" }) },
-      ],
-    },
-    handoffs: [{ file: "t.json", path: "/h/t.json", body: JSON.stringify({ tickId: "t", cadence: "c" }) }],
-  });
-  const r1 = computeFeedEvents(snap, emptySeen(), { now: T0 });
-  assert.deepEqual(r1.events.map((e) => [e.type, e.id, e.seq]), [["inbound", "a", 1], ["inbound", "b", 2], ["handoff", "t", 3]]);
-  assert.equal(r1.seen.seq, 3);
-  assert.deepEqual(Object.keys(r1.seen.inbox).sort(), ["cohort/a.yaml", "cohort/b.yaml"]);
-  assert.deepEqual(Object.keys(r1.seen.handoffs), ["t.json"]);
-  // Same snapshot again → nothing new.
-  const r2 = computeFeedEvents(snap, r1.seen, { now: T0 + 1_000 });
-  assert.deepEqual(r2.events, []);
-  assert.equal(r2.seen.seq, 3);
-});
-
-test("computeFeedEvents: a file that disappears leaves the seen-set; if it re-appears it is re-emitted (assurance re-open)", () => {
-  const withA = snapshot({ inbox: { cohort: [{ file: "a.yaml", path: "/i/a.yaml", body: cohortItem({ id: "a" }) }] } });
-  const r1 = computeFeedEvents(withA, emptySeen(), { now: T0 });
-  assert.equal(r1.events.length, 1);
-  const r2 = computeFeedEvents(snapshot(), r1.seen, { now: T0 + 1 });
-  assert.deepEqual(r2.seen.inbox, {});
-  const r3 = computeFeedEvents(withA, r2.seen, { now: T0 + 2 });
-  assert.equal(r3.events.length, 1);
-  assert.equal(r3.events[0].seq, 2);
-});
-
-test("computeFeedEvents: services not in the snapshot are simply absent; unparseable bodies are skipped and not marked seen", () => {
-  const snap = snapshot({ inbox: { cohort: [{ file: "bad.yaml", path: "/i/bad.yaml", body: "" }], slack: [{ file: "s.yaml", path: "/i/s.yaml", body: cohortItem({ id: "s", service: "slack" }) }] } });
-  const r = computeFeedEvents(snap, emptySeen(), { now: T0 });
-  assert.deepEqual(r.events.map((e) => e.id), ["s"]);
-  assert.equal(r.events[0].service, "slack");
-  assert.deepEqual(Object.keys(r.seen.inbox), ["slack/s.yaml"]);
-});
-
-test("computeFeedEvents: restart-requested → one directive per appearance (keyed by mtime); cleared when the file goes", () => {
-  const s1 = snapshot({ signals: { restartRequestedMtimeMs: T0, upgradeNotice: null, daemonHealthMtimeMs: T0, daemonPidAlive: null } });
-  const r1 = computeFeedEvents(s1, emptySeen(), { now: T0 });
-  assert.deepEqual(r1.events, [{ type: "directive", action: "restart", detail: { requestedAt: "2026-09-08T10:00:00.000Z" }, seq: 1 }]);
-  const r2 = computeFeedEvents(s1, r1.seen, { now: T0 + 1 });
-  assert.deepEqual(r2.events, []);
-  const r3 = computeFeedEvents(snapshot(), r2.seen, { now: T0 + 2 });
-  assert.deepEqual(r3.events, []);
-  assert.equal(r3.seen.signals.restart, undefined);
-  const s4 = snapshot({ signals: { restartRequestedMtimeMs: T0 + 5, upgradeNotice: null, daemonHealthMtimeMs: T0, daemonPidAlive: null } });
-  assert.equal(computeFeedEvents(s4, r3.seen, { now: T0 + 5 }).events.length, 1);
-});
-
-test("computeFeedEvents: upgrade-notice → directive carrying the parsed notice, once per mtime", () => {
-  const s = snapshot({ signals: { restartRequestedMtimeMs: null, upgradeNotice: { mtimeMs: T0, body: JSON.stringify({ from: "2.11.17", to: "2.12.0" }) }, daemonHealthMtimeMs: T0, daemonPidAlive: null } });
-  const r1 = computeFeedEvents(s, emptySeen(), { now: T0 });
-  assert.deepEqual(r1.events, [{ type: "directive", action: "upgrade-available", detail: { notice: { from: "2.11.17", to: "2.12.0" } }, seq: 1 }]);
-  assert.deepEqual(computeFeedEvents(s, r1.seen, { now: T0 + 1 }).events, []);
-  // Junk notice body → detail carries the raw text, still one directive.
-  const junk = snapshot({ signals: { restartRequestedMtimeMs: null, upgradeNotice: { mtimeMs: T0 + 9, body: "not json" }, daemonHealthMtimeMs: T0, daemonPidAlive: null } });
-  const rj = computeFeedEvents(junk, r1.seen, { now: T0 + 9 });
-  assert.equal(rj.events.length, 1);
-  assert.deepEqual(rj.events[0].detail, { notice: null, raw: "not json" });
-});
-
-test("computeFeedEvents: daemon-stale fires once on the transition to stale and re-arms when the daemon is fresh again", () => {
-  const stale = snapshot({ signals: { restartRequestedMtimeMs: null, upgradeNotice: null, daemonHealthMtimeMs: T0 - 10 * 60_000, daemonPidAlive: false } });
-  const r1 = computeFeedEvents(stale, emptySeen(), { now: T0 });
-  assert.equal(r1.events.length, 1);
-  assert.equal(r1.events[0].action, "daemon-stale");
-  assert.deepEqual(r1.events[0].detail, { healthAgeMs: 10 * 60_000, pidAlive: false });
-  assert.deepEqual(computeFeedEvents(stale, r1.seen, { now: T0 + 1 }).events, []);
-  const fresh = snapshot();
-  const r3 = computeFeedEvents(fresh, r1.seen, { now: T0 + 2 });
-  assert.deepEqual(r3.events, []);
-  assert.equal(r3.seen.signals.daemonStale, false);
-  assert.equal(computeFeedEvents(stale, r3.seen, { now: T0 + 3 }).events.length, 1);
-});
-
-test("computeFeedEvents: never mutates its inputs", () => {
-  const seen = emptySeen();
-  const frozen = JSON.stringify(seen);
-  const snap = snapshot({ inbox: { cohort: [{ file: "a.yaml", path: "/i/a.yaml", body: cohortItem({ id: "a" }) }] } });
-  computeFeedEvents(snap, seen, { now: T0 });
-  assert.equal(JSON.stringify(seen), frozen);
-});

package/lib/session/first-run.test.mjs

@@ -1,121 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { join } from "node:path";
-
-import {
-  CLAUDE_CONFIG_FILE,
-  HEARTBEAT_GRACE_MS,
-  seedClaudeConfig,
-  ensureClaudeConfig,
-  heartbeatSilence,
-  attentionRecord,
-} from "./first-run.mjs";
-
-const ROOT = "/Users/o/olivia-ai";
-const T0 = Date.parse("2026-09-08T10:00:00Z");
-
-test("seedClaudeConfig: an absent/empty ~/.claude.json gets both acknowledgements", () => {
-  for (const text of [undefined, null, "", "   "]) {
-    const r = seedClaudeConfig(text, { agentRoot: ROOT, bypass: true });
-    assert.equal(r.ok, true);
-    assert.equal(r.changed, true);
-    assert.deepEqual(r.applied, ["bypassPermissionsModeAccepted", `projects[${ROOT}].hasTrustDialogAccepted`]);
-    assert.deepEqual(r.config, { bypassPermissionsModeAccepted: true, projects: { [ROOT]: { hasTrustDialogAccepted: true } } });
-  }
-});
-
-test("seedClaudeConfig: existing keys, other projects and project fields are preserved; only the missing flags are added", () => {
-  const existing = {
-    numStartups: 40,
-    theme: "dark",
-    projects: {
-      "/Users/o/other": { hasTrustDialogAccepted: false, allowedTools: ["Bash"] },
-      [ROOT]: { allowedTools: ["Read"], hasCompletedProjectOnboarding: true },
-    },
-  };
-  const r = seedClaudeConfig(JSON.stringify(existing), { agentRoot: ROOT, bypass: true });
-  assert.equal(r.changed, true);
-  assert.deepEqual(r.config, {
-    numStartups: 40,
-    theme: "dark",
-    bypassPermissionsModeAccepted: true,
-    projects: {
-      "/Users/o/other": { hasTrustDialogAccepted: false, allowedTools: ["Bash"] },
-      [ROOT]: { allowedTools: ["Read"], hasCompletedProjectOnboarding: true, hasTrustDialogAccepted: true },
-    },
-  });
-});
-
-test("seedClaudeConfig: already seeded → unchanged (idempotent); bypass:false leaves the bypass flag alone", () => {
-  const seeded = { bypassPermissionsModeAccepted: true, projects: { [ROOT]: { hasTrustDialogAccepted: true } } };
-  const r = seedClaudeConfig(JSON.stringify(seeded), { agentRoot: ROOT, bypass: true });
-  assert.equal(r.changed, false);
-  assert.deepEqual(r.applied, []);
-  const r2 = seedClaudeConfig("{}", { agentRoot: ROOT, bypass: false });
-  assert.deepEqual(r2.applied, [`projects[${ROOT}].hasTrustDialogAccepted`]);
-  assert.equal("bypassPermissionsModeAccepted" in r2.config, false);
-});
-
-test("seedClaudeConfig: a malformed or non-object file is NOT clobbered", () => {
-  for (const text of ["{", "[1,2]", "42", "null"]) {
-    const r = seedClaudeConfig(text, { agentRoot: ROOT, bypass: true });
-    assert.equal(r.ok, false, text);
-    assert.equal(r.changed, false);
-    assert.match(r.error, /malformed|not an object/);
-  }
-});
-
-test("ensureClaudeConfig: writes ~/.claude.json only when something changed; never throws", () => {
-  const home = "/Users/o";
-  const file = join(home, CLAUDE_CONFIG_FILE);
-  const writes = [];
-  const deps = (files) => ({
-    readFileSync: (p) => { if (!(p in files)) { const e = new Error("ENOENT"); e.code = "ENOENT"; throw e; } return files[p]; },
-    writeFileAtomic: (p, data) => { writes.push([p, String(data)]); },
-  });
-  // Absent → written.
-  let r = ensureClaudeConfig({ homeDir: home, agentRoot: ROOT, bypass: true, ...deps({}) });
-  assert.equal(r.ok, true);
-  assert.equal(r.changed, true);
-  assert.equal(r.path, file);
-  assert.equal(writes.length, 1);
-  assert.deepEqual(JSON.parse(writes[0][1]), { bypassPermissionsModeAccepted: true, projects: { [ROOT]: { hasTrustDialogAccepted: true } } });
-  // Already seeded → no write.
-  r = ensureClaudeConfig({ homeDir: home, agentRoot: ROOT, bypass: true, ...deps({ [file]: writes[0][1] }) });
-  assert.equal(r.changed, false);
-  assert.equal(writes.length, 1);
-  // Malformed → reported, untouched.
-  r = ensureClaudeConfig({ homeDir: home, agentRoot: ROOT, bypass: true, ...deps({ [file]: "{oops" }) });
-  assert.equal(r.ok, false);
-  assert.equal(writes.length, 1);
-  // A throwing writer is a result, not a throw.
-  r = ensureClaudeConfig({ homeDir: home, agentRoot: ROOT, bypass: true, readFileSync: deps({}).readFileSync, writeFileAtomic: () => { throw new Error("EROFS"); } });
-  assert.equal(r.ok, false);
-  assert.match(r.error, /EROFS/);
-  // No home → nothing to do.
-  r = ensureClaudeConfig({ homeDir: "", agentRoot: ROOT, bypass: true, ...deps({}) });
-  assert.equal(r.ok, false);
-  assert.equal(writes.length, 1);
-});
-
-test("heartbeatSilence: within grace → not silent; a beat since launch → beating; no/old beat past grace → silent", () => {
-  const started = T0;
-  assert.deepEqual(heartbeatSilence({ startedAt: started, heartbeat: null, now: T0 + 10_000 }), { silent: false, reason: "within-grace", runMs: 10_000 });
-  assert.equal(HEARTBEAT_GRACE_MS, 120_000);
-  assert.deepEqual(heartbeatSilence({ startedAt: started, heartbeat: null, now: T0 + 120_000 }), { silent: true, reason: "no-heartbeat", runMs: 120_000 });
-  const old = { ts: new Date(T0 - 60_000).toISOString() }; // from the PREVIOUS lifetime
-  assert.deepEqual(heartbeatSilence({ startedAt: started, heartbeat: old, now: T0 + 120_000 }), { silent: true, reason: "stale-heartbeat", runMs: 120_000 });
-  const fresh = { ts: new Date(T0 + 15_000).toISOString() };
-  assert.deepEqual(heartbeatSilence({ startedAt: started, heartbeat: fresh, now: T0 + 120_000 }), { silent: false, reason: "beating", runMs: 120_000 });
-  assert.equal(heartbeatSilence({ startedAt: started, heartbeat: null, now: T0 + 30_000, graceMs: 20_000 }).silent, true);
-});
-
-test("attentionRecord: what the doctor reads — reason, since, the attach command for the mux in use", () => {
-  const r = attentionRecord({ reason: "no-heartbeat", mux: { kind: "screen" }, muxName: "maestro-olivia", since: T0, runMs: 120_000 });
-  assert.equal(r.reason, "no-heartbeat");
-  assert.equal(r.since, "2026-09-08T10:00:00.000Z");
-  assert.equal(r.runMs, 120_000);
-  assert.equal(r.attach, "screen -r maestro-olivia");
-  assert.match(r.hint, /dialog|prompt/i);
-  assert.equal(attentionRecord({ reason: "no-heartbeat", mux: { kind: "tmux" }, muxName: "maestro-olivia", since: T0, runMs: 1 }).attach, "tmux attach -t =maestro-olivia");
-});

package/lib/session/frontdoor.test.mjs

@@ -1,205 +0,0 @@
-/**
- * frontdoor.test.mjs — the pure front-door decision core (design §3.1, §3.4).
- *
- * Every function here is a pure decision over injected inputs: the parsed
- * heartbeat, a clock, the front-door mode and the tick shape. No disk, no
- * env reads inside the core — `readFrontDoorState` is the one edge reader and
- * it takes its fs/env/clock as parameters so the tests are hermetic.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  DEFAULT_STALE_MS,
-  DEFAULT_FRONT_DOOR_SERVICES,
-  sessionLiveFromHeartbeat,
-  resolveFrontDoor,
-  frontDoorServices,
-  shouldDaemonDispatch,
-  shouldHandOffTick,
-  readFrontDoorState,
-  makeFrontDoorGate,
-} from "./frontdoor.mjs";
-
-const T0 = Date.parse("2026-09-08T10:00:00.000Z");
-
-// ── sessionLiveFromHeartbeat ─────────────────────────────────────────────────
-
-test("liveness: a fresh heartbeat is live; a stale one is not; none is not", () => {
-  assert.deepEqual(
-    sessionLiveFromHeartbeat({ pid: 1, ts: new Date(T0 - 10_000).toISOString() }, { now: T0 }),
-    { live: true, reason: "fresh", ageMs: 10_000 },
-  );
-  const stale = sessionLiveFromHeartbeat({ ts: new Date(T0 - DEFAULT_STALE_MS - 1).toISOString() }, { now: T0 });
-  assert.equal(stale.live, false);
-  assert.equal(stale.reason, "stale");
-  assert.equal(sessionLiveFromHeartbeat(null, { now: T0 }).live, false);
-  assert.equal(sessionLiveFromHeartbeat(null, { now: T0 }).reason, "no-heartbeat");
-  assert.equal(sessionLiveFromHeartbeat({ ts: "garbage" }, { now: T0 }).reason, "bad-ts");
-});
-
-test("liveness: accepts epoch-ms ts, honours a custom staleMs, tolerates slight clock skew", () => {
-  assert.equal(sessionLiveFromHeartbeat({ ts: T0 - 5_000 }, { now: T0 }).live, true);
-  assert.equal(sessionLiveFromHeartbeat({ ts: T0 - 5_000 }, { now: T0, staleMs: 4_000 }).live, false);
-  // A heartbeat a second "in the future" (writer/reader clock skew) is fresh.
-  assert.equal(sessionLiveFromHeartbeat({ ts: T0 + 1_000 }, { now: T0 }).live, true);
-});
-
-// ── resolveFrontDoor / frontDoorServices ─────────────────────────────────────
-
-test("resolveFrontDoor: env wins over config; config string or object; default session", () => {
-  assert.equal(resolveFrontDoor(), "session");
-  assert.equal(resolveFrontDoor({ config: { frontDoor: "daemon" } }), "daemon");
-  assert.equal(resolveFrontDoor({ config: { front_door: "daemon" } }), "daemon");
-  assert.equal(resolveFrontDoor({ config: { frontDoor: { mode: "daemon" } } }), "daemon");
-  assert.equal(resolveFrontDoor({ env: { MAESTRO_FRONT_DOOR: "daemon" }, config: { frontDoor: "session" } }), "daemon");
-  // An unknown value never selects an unknown mode.
-  assert.equal(resolveFrontDoor({ env: { MAESTRO_FRONT_DOOR: "banana" } }), "session");
-  assert.equal(resolveFrontDoor({ config: { frontDoor: "banana" } }), "session");
-});
-
-test("frontDoorServices: default cohort; config may widen; junk is ignored", () => {
-  assert.deepEqual(frontDoorServices(null), [...DEFAULT_FRONT_DOOR_SERVICES]);
-  assert.deepEqual(frontDoorServices({ frontDoor: { services: ["cohort", "slack"] } }), ["cohort", "slack"]);
-  assert.deepEqual(frontDoorServices({ services: ["orgmail"] }), ["orgmail"]);
-  assert.deepEqual(frontDoorServices({ services: "nope" }), [...DEFAULT_FRONT_DOOR_SERVICES]);
-});
-
-// ── shouldDaemonDispatch ─────────────────────────────────────────────────────
-
-test("shouldDaemonDispatch: the daemon steps back only when the session is the live front door for that service", () => {
-  assert.deepEqual(
-    shouldDaemonDispatch({ frontDoor: "session", sessionLive: true, service: "cohort" }),
-    { dispatch: false, reason: "session-live" },
-  );
-  assert.deepEqual(
-    shouldDaemonDispatch({ frontDoor: "session", sessionLive: false, service: "cohort" }),
-    { dispatch: true, reason: "session-not-live" },
-  );
-  assert.deepEqual(
-    shouldDaemonDispatch({ frontDoor: "daemon", sessionLive: true, service: "cohort" }),
-    { dispatch: true, reason: "front-door-daemon" },
-  );
-  assert.deepEqual(
-    shouldDaemonDispatch({ frontDoor: "session", sessionLive: true, service: "slack" }),
-    { dispatch: true, reason: "service-not-front-door" },
-  );
-  assert.deepEqual(
-    shouldDaemonDispatch({ frontDoor: "session", sessionLive: true, service: "slack", services: ["cohort", "slack"] }),
-    { dispatch: false, reason: "session-live" },
-  );
-  // Garbage in → legacy dispatch (fail-open: nothing is ever dropped).
-  assert.equal(shouldDaemonDispatch({}).dispatch, true);
-  assert.equal(shouldDaemonDispatch(null).dispatch, true);
-});
-
-// ── shouldHandOffTick ────────────────────────────────────────────────────────
-
-test("shouldHandOffTick: escalate/guarded ticks hand off to a live session; inline never; timed-out never", () => {
-  const live = { frontDoor: "session", sessionLive: true };
-  assert.deepEqual(shouldHandOffTick({ ...live, mode: "escalate" }), { handOff: true, reason: "hand-off" });
-  assert.deepEqual(shouldHandOffTick({ ...live, mode: "guarded" }), { handOff: true, reason: "hand-off" });
-  assert.deepEqual(shouldHandOffTick({ ...live, mode: "inline" }), { handOff: false, reason: "mode-not-handoff" });
-  // An unknown cadence (no registry entry) defaults to escalate in the consumer.
-  assert.deepEqual(shouldHandOffTick({ ...live, mode: undefined }), { handOff: true, reason: "hand-off" });
-  assert.deepEqual(
-    shouldHandOffTick({ ...live, mode: "escalate", metadata: { handoffTimedOut: true } }),
-    { handOff: false, reason: "handoff-timed-out" },
-  );
-  assert.deepEqual(
-    shouldHandOffTick({ frontDoor: "session", sessionLive: false, mode: "escalate" }),
-    { handOff: false, reason: "session-not-live" },
-  );
-  assert.deepEqual(
-    shouldHandOffTick({ frontDoor: "daemon", sessionLive: true, mode: "escalate" }),
-    { handOff: false, reason: "front-door-daemon" },
-  );
-  assert.equal(shouldHandOffTick(null).handOff, false);
-});
-
-// ── readFrontDoorState (edge reader, injected fs/env/clock) ──────────────────
-
-function fakeFs(files) {
-  return {
-    existsSync: (p) => Object.prototype.hasOwnProperty.call(files, p),
-    readFileSync: (p) => {
-      if (!Object.prototype.hasOwnProperty.call(files, p)) { const e = new Error("ENOENT"); e.code = "ENOENT"; throw e; }
-      return files[p];
-    },
-  };
-}
-
-test("readFrontDoorState: reads config/session.yaml + state/session/heartbeat.json through injected fs", () => {
-  const root = "/agent";
-  const fs = fakeFs({
-    "/agent/config/session.yaml": "frontDoor: session\nservices: [cohort, slack]\n",
-    "/agent/state/session/heartbeat.json": JSON.stringify({ pid: 4, ts: new Date(T0 - 1000).toISOString() }),
-  });
-  const st = readFrontDoorState(root, { fs, env: {}, now: T0 });
-  assert.equal(st.frontDoor, "session");
-  assert.equal(st.sessionLive, true);
-  assert.deepEqual(st.services, ["cohort", "slack"]);
-  assert.equal(st.liveness.reason, "fresh");
-});
-
-test("readFrontDoorState: no config + no heartbeat → session mode, not live (legacy dispatch); env override honoured", () => {
-  const st = readFrontDoorState("/agent", { fs: fakeFs({}), env: {}, now: T0 });
-  assert.equal(st.frontDoor, "session");
-  assert.equal(st.sessionLive, false);
-  assert.deepEqual(st.services, ["cohort"]);
-  const st2 = readFrontDoorState("/agent", { fs: fakeFs({}), env: { MAESTRO_FRONT_DOOR: "daemon" }, now: T0 });
-  assert.equal(st2.frontDoor, "daemon");
-});
-
-test("readFrontDoorState: a corrupt heartbeat or config never throws — fails open to not-live", () => {
-  const fs = fakeFs({
-    "/agent/config/session.yaml": ": : not yaml [[[",
-    "/agent/state/session/heartbeat.json": "{not json",
-  });
-  const st = readFrontDoorState("/agent", { fs, env: {}, now: T0 });
-  assert.equal(st.sessionLive, false);
-  assert.equal(st.frontDoor, "session");
-});
-
-// ── makeFrontDoorGate ────────────────────────────────────────────────────────
-
-test("makeFrontDoorGate: check() reports the decision and flags transitions only once", () => {
-  let live = true;
-  const gate = makeFrontDoorGate({
-    agentRoot: "/agent",
-    readState: () => ({ frontDoor: "session", sessionLive: live, services: ["cohort"] }),
-  });
-  const a = gate.check("cohort");
-  assert.equal(a.dispatch, false);
-  assert.equal(a.changed, true, "first observation is a transition");
-  const b = gate.check("cohort");
-  assert.equal(b.changed, false, "same verdict again is not a transition");
-  live = false;
-  const c = gate.check("cohort");
-  assert.equal(c.dispatch, true);
-  assert.equal(c.changed, true, "liveness flipped → transition");
-  // A reader that throws fails open to dispatch.
-  const broken = makeFrontDoorGate({ agentRoot: "/agent", readState: () => { throw new Error("boom"); } });
-  assert.equal(broken.check("cohort").dispatch, true);
-});
-
-test("readFrontDoorState: the documented NESTED config (frontDoor.mode / frontDoor.services) and the flow form are read without an injected parser", () => {
-  const nested = readFrontDoorState("/agent", {
-    fs: fakeFs({ "/agent/config/session.yaml": "frontDoor:\n  mode: daemon\n  services: [cohort, slack]\n" }),
-    env: {}, now: T0,
-  });
-  assert.equal(nested.frontDoor, "daemon", "an operator opting a seat out via the nested form must be honoured");
-  assert.deepEqual(nested.services, ["cohort", "slack"]);
-  const flow = readFrontDoorState("/agent", {
-    fs: fakeFs({ "/agent/config/session.yaml": "frontDoor: {mode: daemon}\n" }),
-    env: {}, now: T0,
-  });
-  assert.equal(flow.frontDoor, "daemon");
-  const block = readFrontDoorState("/agent", {
-    fs: fakeFs({ "/agent/config/session.yaml": "# session runtime\nfrontDoor:\n  mode: session\n  services:\n    - cohort\n    - orgmail\n" }),
-    env: {}, now: T0,
-  });
-  assert.equal(block.frontDoor, "session");
-  assert.deepEqual(block.services, ["cohort", "orgmail"]);
-});