@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/daemon/lib/self-echo.test.mjs

@@ -1,153 +0,0 @@
-/**
- * self-echo.test.mjs — the sender==self match that three production recurrences
- * (2026-08-25 / 08-27 / 08-30) proved the old inline check could not make.
- *
- * Run: node --test scripts/daemon/lib/self-echo.test.mjs
- *
- * The load-bearing case is the REAL event shape: cohort inbox items carry the
- * display name verbatim (`sender: "Isla Roselli"`), while the old filter
- * compared against `fullName.toLowerCase().replace(/\s+/g, "-")` —
- * "isla-roselli" — so the echo sailed through and the agent acked itself.
- */
-
-import { test, describe, beforeEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { loadSelfIdentity, isSelfSender, normalizeName, logSelfEchoDrop, _resetSelfIdentity } from "./self-echo.mjs";
-
-const ROOT = mkdtempSync(join(tmpdir(), "self-echo-test-"));
-mkdirSync(join(ROOT, "config"), { recursive: true });
-writeFileSync(join(ROOT, "config", "agent.json"), JSON.stringify({
-  firstName: "Isla",
-  fullName: "Isla Roselli",
-  memberId: "cmqh0tcml004ihhl6zev6ocb5",
-  email: "isla@example.com",
-  org: { cohort: { agentId: "A016" } },
-}));
-
-beforeEach(() => _resetSelfIdentity());
-
-const me = () => loadSelfIdentity(ROOT);
-
-describe("normalizeName", () => {
-  test("folds case and the separator zoo to one comparable form", () => {
-    for (const v of ["Isla Roselli", "isla roselli", "isla-roselli", "Isla_Roselli", "isla.roselli", "  Isla   Roselli "]) {
-      assert.equal(normalizeName(v), "isla roselli", `"${v}" must normalise`);
-    }
-  });
-});
-
-describe("isSelfSender — the shapes real events actually carry", () => {
-  test("REGRESSION: the verbatim display name — the exact 25/27/30 Aug echo shape — matches", () => {
-    // Field-for-field the 30 Aug production echo (cmtfqjwvv01kype01t002t8jf):
-    const echo = {
-      id: "cohort-cmtfqjwvv01kype01t002t8jf",
-      service: "cohort",
-      channel: "dm-a016-a039",
-      sender: "Isla Roselli",
-      raw_ref: "cohort:dm:cmtfqjwvv01kype01t002t8jf:192025",
-      event_kind: "send",
-      is_dm: true,
-    };
-    assert.equal(isSelfSender(echo, me()), true);
-  });
-
-  test("the OLD filter's dashed form and other separator variants also match", () => {
-    for (const s of ["isla-roselli", "Isla_Roselli", "isla roselli"]) {
-      assert.equal(isSelfSender({ sender: s }, me()), true, `"${s}" is this agent`);
-    }
-  });
-
-  test("REGRESSION: the BARE first name alone is NOT self — it collides with every namesake", () => {
-    // "Isla" as a display name is any colleague, contact or CC'd person who
-    // shares the first name. Matching it dropped their genuine inbound.
-    assert.equal(isSelfSender({ sender: "Isla" }, me()), false);
-    assert.equal(isSelfSender({ sender: "isla" }, me()), false);
-  });
-
-  test("REGRESSION: a NON-matching id EXONERATES a colliding display name", () => {
-    // A namesake — display name "Isla Roselli", but a DIFFERENT member cuid.
-    // The id positively identifies the sender as someone else; the name rung
-    // must never be reached, so this is NOT self and must not be dropped.
-    assert.equal(
-      isSelfSender({ sender: "Isla Roselli", sender_id: "cmDIFFERENT00000000000000" }, me()),
-      false,
-      "an id that resolves to someone else outranks the name collision",
-    );
-    assert.equal(
-      isSelfSender({ sender: "isla-roselli", author_id: "cmDIFFERENT00000000000000" }, me()),
-      false,
-    );
-  });
-
-  test("REGRESSION: a NON-matching email exonerates a colliding display name too", () => {
-    assert.equal(
-      isSelfSender({ sender: "Isla Roselli", sender_email: "other.isla@example.com" }, me()),
-      false,
-    );
-    // …while the OWN email still matches regardless of the display name.
-    assert.equal(
-      isSelfSender({ sender: "totally different name", sender_email: "isla@example.com" }, me()),
-      true,
-    );
-  });
-
-  test("a member cuid on any id-ish field matches (strongest evidence)", () => {
-    for (const item of [
-      { sender: "someone", sender_id: "cmqh0tcml004ihhl6zev6ocb5" },
-      { sender: "someone", author_id: "CMQH0TCML004IHHL6ZEV6OCB5" },
-      { sender: "someone", from: { id: "cmqh0tcml004ihhl6zev6ocb5" } },
-    ]) {
-      assert.equal(isSelfSender(item, me()), true);
-    }
-  });
-
-  test("the org seat slug matches too", () => {
-    assert.equal(isSelfSender({ sender: "x", sender_id: "A016" }, me()), true);
-  });
-
-  test("own email matches (gmail/orgmail lanes)", () => {
-    assert.equal(isSelfSender({ sender: "Isla via mail", sender_email: "isla@example.com" }, me()), true);
-  });
-
-  test("genuine colleagues NEVER match — no false drops", () => {
-    for (const s of ["Jordan Blake", "Candace Wong", "Isla Fisher", "roselli", "isla2", "ceo"]) {
-      assert.equal(isSelfSender({ sender: s }, me()), false, `"${s}" must not be dropped`);
-    }
-    assert.equal(isSelfSender({ sender: "Candace Wong", sender_id: "cmOTHER000000000000000000" }, me()), false);
-  });
-
-  test("an UNCONFIGURED identity matches nothing — a half-set-up repo drops no inbound", () => {
-    const bare = mkdtempSync(join(tmpdir(), "self-echo-bare-"));
-    try {
-      const id = loadSelfIdentity(bare);
-      assert.equal(isSelfSender({ sender: "Isla Roselli" }, id), false);
-      assert.equal(isSelfSender({ sender: "Agent" }, id), false);
-    } finally {
-      rmSync(bare, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("logSelfEchoDrop — every drop is auditable", () => {
-  test("appends one JSONL row per drop under logs/daemon/", () => {
-    const item = { id: "e-1", raw_ref: "cohort:dm:e-1:42", sender: "Isla Roselli", channel: "dm-a016-a039", service: "cohort", event_kind: "send" };
-    logSelfEchoDrop(item, { stage: "poll", service: "cohort", agentRoot: ROOT });
-    logSelfEchoDrop(item, { stage: "process", service: "cohort", agentRoot: ROOT });
-    const rows = readFileSync(join(ROOT, "logs", "daemon", "self-echo-drops.jsonl"), "utf-8")
-      .split("\n").filter(Boolean).map((l) => JSON.parse(l));
-    assert.equal(rows.length, 2);
-    assert.equal(rows[0].stage, "poll");
-    assert.equal(rows[1].stage, "process");
-    assert.equal(rows[0].raw_ref, "cohort:dm:e-1:42");
-    assert.equal(rows[0].sender, "Isla Roselli");
-  });
-
-  test("never throws, even for a junk item", () => {
-    assert.doesNotThrow(() => logSelfEchoDrop(null, { agentRoot: ROOT }));
-    assert.doesNotThrow(() => logSelfEchoDrop(undefined, { agentRoot: join(ROOT, "no", "such", "deep") }));
-  });
-});

package/scripts/daemon/lib/session-router.test.mjs

@@ -1,295 +0,0 @@
-/**
- * session-router.test.mjs — node:test coverage for the session router.
- *
- * No real subprocess spawns, no real disk writes outside os.tmpdir().
- * Each test creates its own registry path under tmpdir and cleans up.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-import { routingKey, createRouter } from "./session-router.mjs";
-
-function tmpRegistryPath(suffix = "") {
-  const name = `session-router-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${suffix}.json`;
-  return join(tmpdir(), name);
-}
-
-async function safeUnlink(path) {
-  try {
-    await fsp.unlink(path);
-  } catch {
-    /* ignore */
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 1. routingKey — one assertion per row of memo §4.2.
-// ---------------------------------------------------------------------------
-
-test("routingKey — slack threaded message", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "C0123ABC",
-    thread_ts: "1777283277.000100",
-  });
-  assert.equal(k, "slack:C0123ABC:1777283277.000100");
-});
-
-test("routingKey — slack DM (no thread)", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "D099N1JGKRQ",
-  });
-  assert.equal(k, "slack:D099N1JGKRQ");
-});
-
-test("routingKey — slack channel non-DM (no thread)", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "C0123ABC",
-    ts: "1777283277.000200",
-  });
-  assert.equal(k, "slack:C0123ABC:1777283277.000200");
-});
-
-test("routingKey — gmail", () => {
-  const k = routingKey({ source: "gmail", thread_id: "1818abc" });
-  assert.equal(k, "gmail:1818abc");
-});
-
-test("routingKey — calendar", () => {
-  const k = routingKey({ source: "calendar", event_id: "evt_42" });
-  assert.equal(k, "calendar:evt_42");
-});
-
-test("routingKey — internal queue item", () => {
-  const k = routingKey({ source: "internal", id: "ar-20260427-001" });
-  assert.equal(k, "internal:ar-20260427-001");
-});
-
-test("routingKey — backlog with topic_slug", () => {
-  const k = routingKey({
-    source: "backlog",
-    topic_slug: "session-router-step2",
-    id: "as-20260427-x",
-  });
-  assert.equal(k, "backlog:session-router-step2");
-});
-
-test("routingKey — backlog without topic_slug falls back to internal:<id>", () => {
-  const k = routingKey({ source: "backlog", id: "as-20260427-fallback" });
-  assert.equal(k, "internal:as-20260427-fallback");
-});
-
-// ---------------------------------------------------------------------------
-// 2. route() — missing key returns EPHEMERAL.
-// ---------------------------------------------------------------------------
-
-test("route — missing key returns EPHEMERAL", async (t) => {
-  const path = tmpRegistryPath("-missing");
-  t.after(() => safeUnlink(path));
-  const router = await createRouter({ registryPath: path });
-  const decision = router.route("slack:CNEVERSEEN:0");
-  assert.deepEqual(decision, { decision: "EPHEMERAL", resumeId: null });
-});
-
-// ---------------------------------------------------------------------------
-// 3. route() — past-TTL entry returns EPHEMERAL_REPLACE.
-// ---------------------------------------------------------------------------
-
-test("route — past-TTL entry returns EPHEMERAL_REPLACE", async (t) => {
-  const path = tmpRegistryPath("-ttl");
-  t.after(() => safeUnlink(path));
-  let clock = 1_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 60,
-    now: () => clock,
-  });
-  await router.touch("slack:DAAA:1", { claudeSessionId: "cli-1", model: "sonnet" });
-  // Advance clock past TTL.
-  clock += 61 * 1000;
-  const decision = router.route("slack:DAAA:1");
-  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
-  assert.equal(decision.resumeId, null);
-});
-
-// ---------------------------------------------------------------------------
-// 4. route() — live, fresh, exit_code 0 returns RESUME with the stored id.
-// ---------------------------------------------------------------------------
-
-test("route — live fresh entry returns RESUME with stored claude_session_id", async (t) => {
-  const path = tmpRegistryPath("-resume");
-  t.after(() => safeUnlink(path));
-  let clock = 2_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 600,
-    now: () => clock,
-  });
-  await router.touch("slack:DRESUME:1", {
-    claudeSessionId: "cli-resume-xyz",
-    model: "sonnet",
-  });
-  clock += 30_000; // 30s — well within TTL.
-  const decision = router.route("slack:DRESUME:1");
-  assert.equal(decision.decision, "RESUME");
-  assert.equal(decision.resumeId, "cli-resume-xyz");
-});
-
-// ---------------------------------------------------------------------------
-// 5. route() — non-zero last_exit_code returns EPHEMERAL_REPLACE.
-// ---------------------------------------------------------------------------
-
-test("route — non-zero last_exit_code returns EPHEMERAL_REPLACE", async (t) => {
-  const path = tmpRegistryPath("-exitcode");
-  t.after(() => safeUnlink(path));
-  let clock = 3_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 600,
-    now: () => clock,
-  });
-  await router.touch("slack:DEXIT:1", {
-    claudeSessionId: "cli-exit",
-    model: "sonnet",
-  });
-  await router.recordExit("slack:DEXIT:1", 1);
-  clock += 5_000;
-  const decision = router.route("slack:DEXIT:1");
-  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
-  assert.equal(decision.resumeId, null);
-});
-
-// ---------------------------------------------------------------------------
-// 6. touch() — LRU cap enforced; oldest entry evicted on overflow.
-// ---------------------------------------------------------------------------
-
-test("touch — LRU cap evicts oldest when at capacity", async (t) => {
-  const path = tmpRegistryPath("-lru");
-  t.after(() => safeUnlink(path));
-  let clock = 4_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    maxLiveSessions: 3,
-    now: () => clock,
-  });
-  for (let i = 1; i <= 3; i++) {
-    await router.touch(`slack:DLRU${i}`, {
-      claudeSessionId: `cli-${i}`,
-      model: "sonnet",
-    });
-    clock += 1000;
-  }
-  // At cap. Add a fourth.
-  await router.touch("slack:DLRU4", {
-    claudeSessionId: "cli-4",
-    model: "sonnet",
-  });
-  const snap = router._readForTests();
-  assert.equal(snap.lru.length, 3, "lru should still hold 3 keys");
-  assert.ok(!("slack:DLRU1" in snap.sessions), "oldest (DLRU1) evicted");
-  assert.ok("slack:DLRU2" in snap.sessions);
-  assert.ok("slack:DLRU3" in snap.sessions);
-  assert.ok("slack:DLRU4" in snap.sessions);
-});
-
-// ---------------------------------------------------------------------------
-// 7. recordExit() — non-zero code flips status to "killed".
-// ---------------------------------------------------------------------------
-
-test("recordExit — non-zero code flips status to killed", async (t) => {
-  const path = tmpRegistryPath("-killed");
-  t.after(() => safeUnlink(path));
-  const router = await createRouter({ registryPath: path });
-  await router.touch("slack:DKILL:1", {
-    claudeSessionId: "cli-kill",
-    model: "sonnet",
-  });
-  await router.recordExit("slack:DKILL:1", 137);
-  const snap = router._readForTests();
-  assert.equal(snap.sessions["slack:DKILL:1"].status, "killed");
-  assert.equal(snap.sessions["slack:DKILL:1"].last_exit_code, 137);
-});
-
-// ---------------------------------------------------------------------------
-// 8. evictExpired() — removes only stale entries, returns count.
-// ---------------------------------------------------------------------------
-
-test("evictExpired — removes only stale entries and returns count", async (t) => {
-  const path = tmpRegistryPath("-evict");
-  t.after(() => safeUnlink(path));
-  let clock = 5_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 60,
-    now: () => clock,
-  });
-  await router.touch("slack:DEVICT:OLD", {
-    claudeSessionId: "cli-old",
-    model: "sonnet",
-  });
-  // Advance past TTL.
-  clock += 120_000;
-  await router.touch("slack:DEVICT:NEW", {
-    claudeSessionId: "cli-new",
-    model: "sonnet",
-  });
-  // Now: OLD is stale (last_used_at = clock - 120s, ttl = 60s),
-  //      NEW is fresh.
-  const evicted = await router.evictExpired();
-  assert.equal(evicted, 1, "one entry should have been evicted");
-  const snap = router._readForTests();
-  assert.ok(!("slack:DEVICT:OLD" in snap.sessions));
-  assert.ok("slack:DEVICT:NEW" in snap.sessions);
-});
-
-// ---------------------------------------------------------------------------
-// 9. Registry round-trip — touch two keys, re-create router, state restored.
-// ---------------------------------------------------------------------------
-
-test("registry round-trip — second router instance reads persisted state", async (t) => {
-  const path = tmpRegistryPath("-roundtrip");
-  t.after(() => safeUnlink(path));
-  let clock = 6_000_000_000_000;
-
-  const r1 = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    now: () => clock,
-  });
-  await r1.touch("gmail:thread-A", {
-    claudeSessionId: "cli-A",
-    model: "sonnet",
-  });
-  clock += 1000;
-  await r1.touch("gmail:thread-B", {
-    claudeSessionId: "cli-B",
-    model: "opus",
-  });
-
-  // Fresh router instance against the same path.
-  const r2 = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    now: () => clock,
-  });
-  const snap = r2._readForTests();
-  assert.equal(Object.keys(snap.sessions).length, 2);
-  assert.equal(snap.sessions["gmail:thread-A"].claude_session_id, "cli-A");
-  assert.equal(snap.sessions["gmail:thread-B"].claude_session_id, "cli-B");
-  assert.equal(snap.sessions["gmail:thread-B"].model, "opus");
-  // Both keys present in the LRU array.
-  assert.ok(snap.lru.includes("gmail:thread-A"));
-  assert.ok(snap.lru.includes("gmail:thread-B"));
-
-  // route() should return RESUME for the persisted entry.
-  const dec = r2.route("gmail:thread-A");
-  assert.equal(dec.decision, "RESUME");
-  assert.equal(dec.resumeId, "cli-A");
-});

package/scripts/daemon/prompt-builder-preamble.test.mjs

@@ -1,210 +0,0 @@
-/**
- * prompt-builder-preamble.test.mjs — the fallback preamble must not FABRICATE
- * authority.
- *
- * WHAT BROKE
- *   `buildFallbackPreamble()` used to hardcode an autonomy grant:
- *     "<Agent> sends autonomously: all internal messages, external operational
- *      messages, candidate comms, follow-ups, calendar coordination"
- *   read from nowhere. It fires when CLAUDE.md is unreadable OR its extracted
- *   sections total <= 200 chars — i.e. on a freshly scaffolded repo that has
- *   never had autonomy bands set — while driving a real `claude --print` session
- *   that can send real messages. It also stated "You are <name>, <title> at
- *   <company>" with `company` interpolated unconditionally.
- *
- * WHAT THESE TESTS PIN
- *   1. GROUNDED PATH — with a real config/agent.json + config/company.json + a
- *      GENERATED policies/action-classification.yaml, every band in the preamble
- *      comes from those files.
- *   2. EMPTY PATH — with the scaffold's UNCONFIGURED config and no generated
- *      policy, the preamble asserts NO employer, NO autonomy grant, and says
- *      draft-not-send. Nothing is invented.
- *   3. The hand-written TEMPLATE action-classification.yaml (which grants "fully
- *      autonomous executive operator" to every seat) is treated as ABSENT.
- *
- * Run: node --test scripts/daemon/prompt-builder-preamble.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  buildFallbackPreamble,
-  loadSeatAutonomyPolicy,
-  renderAutonomySection,
-} from "./prompt-builder.mjs";
-
-/** A repo root with whatever files the case needs. */
-function seat(files) {
-  const root = mkdtempSync(join(tmpdir(), "seat-"));
-  for (const [rel, body] of Object.entries(files)) {
-    const abs = join(root, rel);
-    mkdirSync(join(abs, ".."), { recursive: true });
-    writeFileSync(abs, body);
-  }
-  return root;
-}
-
-const SCAFFOLD_AGENT = JSON.stringify({
-  firstName: "UNCONFIGURED",
-  lastName: "AGENT",
-  fullName: "Unconfigured Agent",
-  title: "Unconfigured Role",
-  company: "",
-  principal: { firstName: "", fullName: "", title: "" },
-  responsibilities: [],
-  operatingPrinciples: [],
-});
-const SCAFFOLD_COMPANY = JSON.stringify({ name: "UNCONFIGURED", description: "", products: [] });
-
-const REAL_AGENT = JSON.stringify({
-  firstName: "Robin",
-  lastName: "Okafor",
-  fullName: "Robin Okafor",
-  title: "VP Operations",
-  altitude: "vp",
-  company: "",
-  principal: { firstName: "Dana", fullName: "Dana Lee", title: "CEO" },
-  responsibilities: ["Run the ops cadence"],
-  operatingPrinciples: ["Close the loop on every commitment"],
-});
-const REAL_COMPANY = JSON.stringify({ name: "Meridian Freight", description: "Regional logistics." });
-
-/** What scripts/setup/generate-autonomy.mjs writes — note archetype + delegation_breadth. */
-const GENERATED_POLICY = `
-archetype: operations@vp
-autonomy_default: execute
-delegation_breadth: moderate
-action_levels:
-  execute_autonomous:
-    examples:
-      - Reschedule internal meetings
-  approval_preferred:
-    examples:
-      - Send a quote to a customer
-  escalate:
-    examples:
-      - Sign a supplier contract
-    escalate_to:
-      - principal
-decision_rights:
-  - id: dr-1
-    scope: Carrier selection
-    authority: decide
-`;
-
-/** The hand-written framework TEMPLATE — no archetype, no delegation_breadth. */
-const TEMPLATE_POLICY = `
-action_levels:
-  execute_autonomous:
-    description: Operational actions the agent executes on its own authority.
-    examples:
-      - Send emails in the agent's voice to any recipient
-      - Send candidate communications (outreach, scheduling, offers, rejections)
-`;
-
-// ── 1. GROUNDED PATH ────────────────────────────────────────────────────────
-
-test("grounded: identity, employer and every autonomy band come from the real files", () => {
-  const root = seat({
-    "config/agent.json": REAL_AGENT,
-    "config/company.json": REAL_COMPANY,
-    "policies/action-classification.yaml": GENERATED_POLICY,
-  });
-  const out = buildFallbackPreamble(root);
-
-  assert.match(out, /You are Robin Okafor, VP Operations at Meridian Freight\./);
-  assert.match(out, /You report to Dana Lee, CEO\./);
-  assert.match(out, /Close the loop on every commitment/, "operating principles come from config");
-
-  assert.match(out, /generated for archetype operations@vp/);
-  assert.match(out, /You act on your own authority: Reschedule internal meetings/);
-  assert.match(out, /You get agreement first: Send a quote to a customer/);
-  assert.match(out, /You escalate and do NOT act alone: Sign a supplier contract/);
-  assert.match(out, /Escalate to: principal/);
-  assert.match(out, /Decision right — Carrier selection \(decide\)/);
-
-  // The fabricated grant is gone, verbatim.
-  assert.doesNotMatch(out, /sends autonomously/i);
-  assert.doesNotMatch(out, /all internal messages, external operational messages/i);
-  assert.doesNotMatch(out, /Full autonomy, full accountability/i);
-
-  rmSync(root, { recursive: true, force: true });
-});
-
-// ── 2. EMPTY PATH — nothing configured means nothing asserted ────────────────
-
-test("empty: an unconfigured seat gets NO employer and NO autonomy grant", () => {
-  const root = seat({
-    "config/agent.json": SCAFFOLD_AGENT,
-    "config/company.json": SCAFFOLD_COMPANY,
-  });
-  const out = buildFallbackPreamble(root);
-
-  // No invented employer anywhere — including the scaffold's own sentinel.
-  assert.doesNotMatch(out, /UNCONFIGURED/);
-  assert.doesNotMatch(out, / at \./, "no dangling 'at <blank>' clause");
-
-  // No grant of any kind.
-  assert.doesNotMatch(out, /sends autonomously/i);
-  assert.doesNotMatch(out, /You act on your own authority/);
-  assert.doesNotMatch(out, /escalates only/i);
-
-  // Fail closed, and say why.
-  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED FOR THIS SEAT/);
-  assert.match(out, /Draft, do not send/);
-  assert.match(out, /Nothing here grants that\./);
-
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("empty: a repo with NO config at all still produces a safe, non-fabricated preamble", () => {
-  const root = seat({});
-  const out = buildFallbackPreamble(root);
-  assert.doesNotMatch(out, /You are .* at /, "no identity is asserted");
-  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED/);
-  assert.match(out, /Draft, do not send/);
-  rmSync(root, { recursive: true, force: true });
-});
-
-// ── 3. The template is NOT ground truth ─────────────────────────────────────
-
-test("the framework TEMPLATE action-classification.yaml is treated as ABSENT", () => {
-  const root = seat({
-    "config/agent.json": REAL_AGENT,
-    "config/company.json": REAL_COMPANY,
-    "policies/action-classification.yaml": TEMPLATE_POLICY,
-  });
-  assert.equal(loadSeatAutonomyPolicy(root), null, "no archetype/delegation_breadth ⇒ not this seat's policy");
-
-  const out = buildFallbackPreamble(root);
-  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED FOR THIS SEAT/);
-  assert.doesNotMatch(
-    out,
-    /Send candidate communications/,
-    "the template's maximal grant must never reach a prompt",
-  );
-  rmSync(root, { recursive: true, force: true });
-});
-
-test("a GENERATED policy whose bands are all empty grants nothing", () => {
-  const section = renderAutonomySection({
-    archetype: "ops@vp",
-    delegation_breadth: "narrow",
-    action_levels: { execute_autonomous: { examples: [] }, approval_preferred: {}, escalate: {} },
-    decision_rights: [],
-  });
-  assert.match(section, /declares no bands/);
-  assert.match(section, /draft, do not send/i);
-});
-
-test("loadSeatAutonomyPolicy never throws on malformed YAML", () => {
-  const root = seat({ "policies/action-classification.yaml": "::: not: [valid" });
-  assert.equal(loadSeatAutonomyPolicy(root), null);
-  rmSync(root, { recursive: true, force: true });
-});