@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/cadence/enqueue-cadence-tick.test.mjs

@@ -1,187 +0,0 @@
-/**
- * enqueue-cadence-tick.test.mjs — node:test coverage for the CLI enqueue
- * script (the entry point used by launchd plists).
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "fs";
-import { writeFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "os";
-import { join, resolve, dirname } from "path";
-import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ENQUEUE_SCRIPT = resolve(__dirname, "enqueue-cadence-tick.mjs");
-
-async function makeAgentRoot() {
-  const path = join(
-    tmpdir(),
-    `enqueue-cli-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-  );
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-
-async function rmRoot(path) {
-  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
-}
-
-function run(cwd, args, env = {}) {
-  return spawnSync(process.execPath, [ENQUEUE_SCRIPT, ...args], {
-    cwd,
-    env: { ...process.env, AGENT_ROOT: cwd, ...env },
-    encoding: "utf-8",
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Happy path
-// ---------------------------------------------------------------------------
-
-test("CLI enqueues a tick and writes inbox JSON", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const r = run(root, ["inbox-processor", "--source=launchd"]);
-    assert.equal(r.status, 0, r.stderr);
-    const out = JSON.parse(r.stdout.trim());
-    assert.equal(out.ok, true);
-    assert.equal(out.cadence, "inbox-processor");
-    assert.equal(out.fallback_only, false);
-    assert.ok(out.path);
-    assert.ok(existsSync(out.path));
-    const event = JSON.parse(readFileSync(out.path, "utf-8"));
-    assert.equal(event.source, "launchd");
-    assert.equal(event.cadence, "inbox-processor");
-  } finally { await rmRoot(root); }
-});
-
-test("CLI accepts metadata pairs (repeated and comma-separated)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const r = run(root, [
-      "weekly-strategic-memo",
-      "--source=manual",
-      "--metadata=note=launch",
-      "--metadata=k1=v1,k2=v2",
-    ]);
-    assert.equal(r.status, 0);
-    const out = JSON.parse(r.stdout.trim());
-    const event = JSON.parse(readFileSync(out.path, "utf-8"));
-    assert.equal(event.metadata.note, "launch");
-    assert.equal(event.metadata.k1, "v1");
-    assert.equal(event.metadata.k2, "v2");
-  } finally { await rmRoot(root); }
-});
-
-test("CLI --interval enables the at-most-once gate (duplicate fire suppressed)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    // First fire admits.
-    const r1 = run(root, ["inbox-processor", "--source=launchd", "--interval=300"]);
-    assert.equal(r1.status, 0, r1.stderr);
-    const out1 = JSON.parse(r1.stdout.trim());
-    assert.ok(out1.path, "first interval-bearing tick admits");
-    // Immediate second fire (well within the grace window) is suppressed.
-    const r2 = run(root, ["inbox-processor", "--source=launchd", "--interval=300"]);
-    assert.equal(r2.status, 0, r2.stderr);
-    const out2 = JSON.parse(r2.stdout.trim());
-    assert.equal(out2.path, null);
-    assert.equal(out2.skipped, "before-grace-window");
-    // schedule.json was created.
-    assert.ok(existsSync(join(root, "state/cadence-bus/schedule.json")));
-  } finally { await rmRoot(root); }
-});
-
-test("CLI --interval=0 / non-numeric falls back to legacy every-fire behaviour", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const a = run(root, ["inbox-processor", "--source=launchd", "--interval=0"]);
-    const b = run(root, ["inbox-processor", "--source=launchd", "--interval=oops"]);
-    assert.equal(a.status, 0);
-    assert.equal(b.status, 0);
-    assert.ok(JSON.parse(a.stdout.trim()).path);
-    assert.ok(JSON.parse(b.stdout.trim()).path);
-    // No schedule.json created when the gate is inactive.
-    assert.equal(existsSync(join(root, "state/cadence-bus/schedule.json")), false);
-  } finally { await rmRoot(root); }
-});
-
-test("CLI --quiet suppresses stdout JSON", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const r = run(root, ["inbox-processor", "--source=launchd", "--quiet"]);
-    assert.equal(r.status, 0);
-    assert.equal(r.stdout.trim(), "");
-  } finally { await rmRoot(root); }
-});
-
-test("CLI --version prints bus schema version", async () => {
-  const r = spawnSync(process.execPath, [ENQUEUE_SCRIPT, "--version"], { encoding: "utf-8" });
-  assert.equal(r.status, 0);
-  assert.match(r.stdout, /^\d+$/m);
-});
-
-test("CLI --help prints usage and exits 0", async () => {
-  const r = spawnSync(process.execPath, [ENQUEUE_SCRIPT, "--help"], { encoding: "utf-8" });
-  assert.equal(r.status, 0);
-  assert.match(r.stdout, /enqueue-cadence-tick/);
-});
-
-// ---------------------------------------------------------------------------
-// Error paths
-// ---------------------------------------------------------------------------
-
-test("CLI exits 2 with no cadence", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const r = run(root, []);
-    assert.equal(r.status, 2);
-    assert.match(r.stderr, /required/);
-  } finally { await rmRoot(root); }
-});
-
-test("CLI exits 2 on unknown flag", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const r = run(root, ["x", "--what-is-this"]);
-    assert.equal(r.status, 2);
-    assert.match(r.stderr, /unknown flag/);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Emergency stop
-// ---------------------------------------------------------------------------
-
-test("CLI returns 0 with skipped=emergency-stop when stop flag exists", async () => {
-  const root = await makeAgentRoot();
-  try {
-    writeFileSync(join(root, ".emergency-stop"), "now");
-    const r = run(root, ["weekly-strategic-memo", "--source=launchd"]);
-    assert.equal(r.status, 0);
-    const out = JSON.parse(r.stdout.trim());
-    assert.equal(out.skipped, "emergency-stop");
-    assert.equal(out.fallback_only, true);
-    assert.equal(out.path, null);
-    // No file landed in inbox/.
-    assert.ok(!existsSync(join(root, "state/cadence-bus/inbox", `${out.id}.json`)));
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Bus-handoff sanity — the CLI must finish in well under a second so launchd
-// never piles up; we don't pin a number, just a generous ceiling.
-// ---------------------------------------------------------------------------
-
-test("CLI completes in well under 2 seconds", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = Date.now();
-    const r = run(root, ["inbox-processor", "--source=launchd", "--quiet"]);
-    const dt = Date.now() - t0;
-    assert.equal(r.status, 0);
-    assert.ok(dt < 2000, `enqueue took ${dt}ms`);
-  } finally { await rmRoot(root); }
-});

package/scripts/ci/check-docs-accuracy.test.mjs

@@ -1,409 +0,0 @@
-/**
- * Tests for check-docs-accuracy.mjs — docs-accuracy guard (P1-3).
- *
- * Pure-function level: the count-claim extractors, the teams/workflows
- * structural parsers, README link extraction, and the dangling-ref +
- * broken-link finders are exercised against fixtures written to a tmp dir.
- * The fixture-tree tests prove the guard catches a planted bad count, a
- * planted dangling teams ref, and a planted broken README link — and that a
- * clean tree produces zero drift.
- *
- * @module scripts/ci/check-docs-accuracy.test
- */
-
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-import {
-  extractAgentCountClaims,
-  extractToolCountClaims,
-  parseTeamMembers,
-  parseWorkflowAgentRefs,
-  extractRelativeLinks,
-  countAgentDirs,
-  agentIdSet,
-  findDanglingAgentRefs,
-  findBrokenReadmeLinks,
-  analyzeDocsAccuracy,
-  run,
-} from "./check-docs-accuracy.mjs";
-
-// ── count-claim extraction ──────────────────────────────────────────────────
-
-describe("extractAgentCountClaims", () => {
-  it("extracts '34 agent definitions'", () => {
-    assert.deepEqual(
-      extractAgentCountClaims("…and 34 agent definitions with mandates…"),
-      [34],
-    );
-  });
-
-  it("extracts the '34 sub-agent definitions' phrasing", () => {
-    assert.deepEqual(extractAgentCountClaims("agents/ ← 34 sub-agent definitions"), [34]);
-  });
-
-  it("extracts '34 specialist agent definitions' (one adjective)", () => {
-    assert.deepEqual(
-      extractAgentCountClaims("| 34 specialist agent definitions with mandates |"),
-      [34],
-    );
-  });
-
-  it("returns every claim in order when several appear", () => {
-    assert.deepEqual(
-      extractAgentCountClaims("13 agent definitions … later 34 agent definitions"),
-      [13, 34],
-    );
-  });
-
-  it("does not misread unrelated numbers (40-60 generated range, ports)", () => {
-    assert.deepEqual(
-      extractAgentCountClaims("generates 40–60 sub-agents on port 8080"),
-      [],
-    );
-  });
-
-  it("returns [] for non-string", () => {
-    assert.deepEqual(extractAgentCountClaims(null), []);
-  });
-});
-
-describe("extractToolCountClaims", () => {
-  it("extracts '30 tools across'", () => {
-    assert.deepEqual(extractToolCountClaims("30 tools across 6 categories"), [30]);
-  });
-
-  it("ignores per-access-level counts like '29 tools' / '(24 tools)'", () => {
-    assert.deepEqual(
-      extractToolCountClaims("ceo (29 tools), leadership (24 tools)"),
-      [],
-    );
-  });
-});
-
-// ── teams members parser ────────────────────────────────────────────────────
-
-describe("parseTeamMembers", () => {
-  const yaml = [
-    "name: executive-office",
-    "lead: chief-of-staff",
-    "members:",
-    "  - chief-of-staff # lead",
-    "  - ceo-briefing",
-    "  - communications",
-    "responsibilities:",
-    "  - Morning and evening briefs",
-    "  - Follow-up management",
-    "escalation: principal",
-  ].join("\n");
-
-  it("extracts only the members block (not responsibilities)", () => {
-    assert.deepEqual(parseTeamMembers(yaml), [
-      "chief-of-staff",
-      "ceo-briefing",
-      "communications",
-    ]);
-  });
-
-  it("strips trailing comments and whitespace", () => {
-    assert.deepEqual(parseTeamMembers("members:\n  - alpha   # note\n"), ["alpha"]);
-  });
-
-  it("ignores prose list items that are not the members block", () => {
-    const out = parseTeamMembers(
-      "members:\n  - alpha\nprinciples:\n  - All actions are logged\n",
-    );
-    assert.deepEqual(out, ["alpha"]);
-  });
-
-  it("returns [] when there is no members key", () => {
-    assert.deepEqual(parseTeamMembers("name: x\nlead: y\n"), []);
-  });
-});
-
-// ── workflows agent-ref parser ──────────────────────────────────────────────
-
-describe("parseWorkflowAgentRefs", () => {
-  const yaml = [
-    "steps:",
-    "  - id: market-sweep",
-    "    agent: market-research",
-    "    action: x",
-    "  - id: triage",
-    "    agent: gmail-operator",
-    "  - id: notify",
-    "    action: notify",
-    "on_failure:",
-    "  notify: agent-self",
-  ].join("\n");
-
-  it("extracts agent: step values", () => {
-    assert.deepEqual(parseWorkflowAgentRefs(yaml), [
-      "market-research",
-      "gmail-operator",
-    ]);
-  });
-
-  it("excludes the agent-self sentinel", () => {
-    assert.deepEqual(parseWorkflowAgentRefs("  - agent: agent-self\n"), []);
-  });
-
-  it("ignores steps with no agent (action-only)", () => {
-    assert.deepEqual(parseWorkflowAgentRefs("  - action: notify\n"), []);
-  });
-});
-
-// ── README link extraction ──────────────────────────────────────────────────
-
-describe("extractRelativeLinks", () => {
-  it("returns relative links, skipping http/mailto/anchors", () => {
-    const md =
-      "see [docs](docs/a.md) and [site](https://x.com) and [mail](mailto:a@b.c) and [top](#intro)";
-    assert.deepEqual(extractRelativeLinks(md), ["docs/a.md"]);
-  });
-
-  it("strips anchors and query strings from relative links", () => {
-    assert.deepEqual(
-      extractRelativeLinks("[x](docs/a.md#section) [y](docs/b.md?v=1)"),
-      ["docs/a.md", "docs/b.md"],
-    );
-  });
-
-  it("drops a markdown link title", () => {
-    assert.deepEqual(extractRelativeLinks('[x](docs/a.md "Title")'), ["docs/a.md"]);
-  });
-
-  it("de-dupes repeated links", () => {
-    assert.deepEqual(extractRelativeLinks("[a](x.md) [b](x.md)"), ["x.md"]);
-  });
-});
-
-// ── fixture-tree integration ────────────────────────────────────────────────
-
-/** Build a minimal repo fixture under a tmp dir. */
-function makeFixture(opts = {}) {
-  const root = mkdtempSync(path.join(os.tmpdir(), "docs-acc-"));
-  // agents/ — three agent dirs by default
-  for (const a of opts.agents || ["alpha", "beta", "gamma"]) {
-    mkdirSync(path.join(root, "agents", a), { recursive: true });
-    writeFileSync(path.join(root, "agents", a, "agent.md"), "# agent\n");
-  }
-  // lib/tool-definitions.js — exports getAllToolsByCategory returning N tools
-  mkdirSync(path.join(root, "lib"), { recursive: true });
-  const toolCount = opts.tools ?? 2;
-  const toolEntries = Array.from({ length: toolCount }, (_, i) => `{name:"t${i}"}`);
-  writeFileSync(
-    path.join(root, "lib", "tool-definitions.js"),
-    `export function getAllToolsByCategory(){return {communication:[${toolEntries.join(",")}]};}\n`,
-  );
-  // docs
-  if (opts.readme != null) writeFileSync(path.join(root, "README.md"), opts.readme);
-  if (opts.claude != null) writeFileSync(path.join(root, "CLAUDE.md"), opts.claude);
-  // teams + workflows
-  for (const [name, body] of Object.entries(opts.teams || {})) {
-    mkdirSync(path.join(root, "teams"), { recursive: true });
-    writeFileSync(path.join(root, "teams", name), body);
-  }
-  for (const [rel, body] of Object.entries(opts.workflows || {})) {
-    const abs = path.join(root, "workflows", rel);
-    mkdirSync(path.dirname(abs), { recursive: true });
-    writeFileSync(abs, body);
-  }
-  // extra real files for link resolution
-  for (const [rel, body] of Object.entries(opts.files || {})) {
-    const abs = path.join(root, rel);
-    mkdirSync(path.dirname(abs), { recursive: true });
-    writeFileSync(abs, body);
-  }
-  return root;
-}
-
-describe("count helpers on a fixture", () => {
-  let root;
-  before(() => {
-    root = makeFixture({ agents: ["a", "b"], tools: 5 });
-  });
-  after(() => rmSync(root, { recursive: true, force: true }));
-
-  it("countAgentDirs counts agent subdirs", () => {
-    assert.equal(countAgentDirs(root), 2);
-  });
-
-  it("agentIdSet returns the agent dir names", () => {
-    assert.deepEqual([...agentIdSet(root)].sort(), ["a", "b"]);
-  });
-
-  it("analyzeDocsAccuracy reports actual tool count from the module", async () => {
-    const r = await analyzeDocsAccuracy({ cwd: root });
-    assert.equal(r.counts.toolsActual, 5);
-  });
-});
-
-describe("catches a planted bad count", () => {
-  let root;
-  before(() => {
-    root = makeFixture({
-      agents: ["a", "b", "c"], // actual = 3
-      tools: 4,
-      readme: "Ships with 99 agent definitions and 88 tools across categories.\n",
-      claude: "agents/ ← 99 sub-agent definitions\n",
-    });
-  });
-  after(() => rmSync(root, { recursive: true, force: true }));
-
-  it("flags the agent-count drift in README and CLAUDE.md", async () => {
-    const r = await analyzeDocsAccuracy({ cwd: root });
-    assert.equal(r.counts.agentsActual, 3);
-    const files = r.counts.agentDrift.map((d) => d.file).sort();
-    assert.deepEqual(files, ["CLAUDE.md", "README.md"]);
-    for (const d of r.counts.agentDrift) {
-      assert.equal(d.claimed, 99);
-      assert.equal(d.actual, 3);
-    }
-  });
-
-  it("flags the tool-count drift", async () => {
-    const r = await analyzeDocsAccuracy({ cwd: root });
-    assert.equal(r.counts.toolsActual, 4);
-    assert.equal(r.counts.toolDrift.length, 1);
-    assert.equal(r.counts.toolDrift[0].claimed, 88);
-    assert.equal(r.counts.toolDrift[0].actual, 4);
-  });
-
-  it("reports zero count-drift when claims match reality", async () => {
-    const clean = makeFixture({
-      agents: ["a", "b", "c"],
-      tools: 4,
-      readme: "Ships with 3 agent definitions and 4 tools across categories.\n",
-    });
-    try {
-      const r = await analyzeDocsAccuracy({ cwd: clean });
-      assert.equal(r.counts.agentDrift.length, 0);
-      assert.equal(r.counts.toolDrift.length, 0);
-    } finally {
-      rmSync(clean, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("catches a dangling teams ref", () => {
-  let root;
-  before(() => {
-    root = makeFixture({
-      agents: ["alpha", "beta"], // ghost is missing
-      teams: {
-        "core.yaml": [
-          "name: core",
-          "members:",
-          "  - alpha",
-          "  - ghost", // dangling
-          "responsibilities:",
-          "  - do things",
-        ].join("\n"),
-      },
-    });
-  });
-  after(() => rmSync(root, { recursive: true, force: true }));
-
-  it("flags the missing member but not the resolving one", () => {
-    const { teamRefs } = findDanglingAgentRefs({ cwd: root });
-    assert.equal(teamRefs.length, 1);
-    assert.equal(teamRefs[0].agent, "ghost");
-    assert.match(teamRefs[0].file, /core\.yaml$/);
-  });
-
-  it("does not treat responsibilities prose as agent refs", () => {
-    const { teamRefs } = findDanglingAgentRefs({ cwd: root });
-    assert.ok(!teamRefs.some((t) => t.agent === "do"));
-  });
-});
-
-describe("workflow refs are de-duped and WARN-classed", () => {
-  let root;
-  before(() => {
-    root = makeFixture({
-      agents: ["alpha"],
-      workflows: {
-        "daily/x.yaml": [
-          "steps:",
-          "  - agent: alpha", // resolves
-          "  - agent: phantom", // dangling
-          "  - agent: phantom", // duplicate dangling -> deduped
-        ].join("\n"),
-      },
-    });
-  });
-  after(() => rmSync(root, { recursive: true, force: true }));
-
-  it("reports each (file, agent) dangling pair exactly once", () => {
-    const { workflowRefs } = findDanglingAgentRefs({ cwd: root });
-    assert.equal(workflowRefs.length, 1);
-    assert.equal(workflowRefs[0].agent, "phantom");
-  });
-});
-
-describe("catches a broken README link and ratchets it as FAIL", () => {
-  it("findBrokenReadmeLinks flags only the missing target", () => {
-    const root = makeFixture({
-      readme: "see [real](docs/real.md) and [dead](docs/missing.md)\n",
-      files: { "docs/real.md": "# real\n" },
-    });
-    try {
-      const { checked, broken } = findBrokenReadmeLinks({ cwd: root });
-      assert.equal(checked, 2);
-      assert.deepEqual(broken, ["docs/missing.md"]);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it("run() exits 1 when a README link is broken", async () => {
-    const root = makeFixture({
-      agents: ["a"],
-      readme: "[dead](docs/missing.md)\n",
-    });
-    try {
-      const code = await run(root);
-      assert.equal(code, 1);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it("run() exits 0 when links resolve, even with count/ref WARN drift", async () => {
-    const root = makeFixture({
-      agents: ["a", "b"],
-      readme: "Ships 99 agent definitions. See [ok](docs/ok.md).\n",
-      files: { "docs/ok.md": "# ok\n" },
-      teams: { "t.yaml": "name: t\nmembers:\n  - ghost\n" },
-    });
-    try {
-      const code = await run(root);
-      assert.equal(code, 0); // drift is WARN, not FAIL
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-// ── the live repo: link invariant must hold ─────────────────────────────────
-
-describe("live repo", () => {
-  it("README relative links all resolve (the ratcheted invariant)", async () => {
-    const r = await analyzeDocsAccuracy();
-    assert.deepEqual(
-      r.links.broken,
-      [],
-      `broken README links: ${r.links.broken.join(", ")}`,
-    );
-  });
-
-  it("counts the real agent dirs and tools", async () => {
-    const r = await analyzeDocsAccuracy();
-    assert.ok(r.counts.agentsActual >= 1);
-    assert.ok(r.counts.toolsActual >= 1);
-  });
-});

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

@@ -1,90 +0,0 @@
-/**
- * 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`);
-    }
-  });
-});