@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/design/write.test.mjs

@@ -1,241 +0,0 @@
-/**
- * write.test.mjs — the effect edge of the design sync (WP-M7 mechanic 4).
- *
- * Real files in a temp dir, not stubs: the claims worth holding here are about
- * the FILESYSTEM — that an unchanged foundation touches no mtime, and that the
- * two markdown files land at 0644 so any tool on the seat can read them.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, writeFileSync, statSync, utimesSync, existsSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-
-import { syncDesign, writeDesignFiles, writeFoundationState, readFoundationState, filesMatch, workspaceName, DESIGN_FILE_MODE } from "./write.mjs";
-import { renderDesignBundle } from "./design-md.mjs";
-import { DESIGN_STATE_REL } from "./refresh-gate.mjs";
-
-const NOW = Date.parse("2026-09-08T12:00:00Z");
-const FIXTURE = JSON.parse(readFileSync(new URL("./fixtures/foundation.json", import.meta.url), "utf8"));
-
-/** A `branding.getFoundation` result frame's `result`. */
-const result = (over = {}) => ({
-  foundation: FIXTURE,
-  version: { id: "bv_01HQZ", seq: 7, label: "V2.7" },
-  headVersionId: "bv_01HQZ",
-  isHead: true,
-  unversioned: false,
-  history: [],
-  ...over,
-});
-
-function tmpRoot(t) {
-  const dir = mkdtempSync(join(tmpdir(), "maestro-design-write-"));
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-  return dir;
-}
-
-test("a first sync writes both files plus the state snapshot", (t) => {
-  const root = tmpRoot(t);
-  const out = syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-
-  assert.deepEqual(out.written, ["DESIGN.md", "PRODUCT.md"]);
-  assert.deepEqual(out.unchanged, []);
-  assert.equal(out.version, "bv_01HQZ");
-  assert.equal(out.outDir, root);
-
-  const design = readFileSync(join(root, "DESIGN.md"), "utf8");
-  assert.match(design, /^---\nname: "Northwind"\n/);
-  assert.match(design, /\{colors\.primary\}/);
-  assert.match(readFileSync(join(root, "PRODUCT.md"), "utf8"), /# Northwind — product voice/);
-
-  const state = JSON.parse(readFileSync(join(root, DESIGN_STATE_REL), "utf8"));
-  assert.equal(state.version, "bv_01HQZ");
-  assert.equal(state.versionLabel, "V2.7");
-  assert.equal(state.fetchedAt, "2026-09-08T12:00:00.000Z");
-  assert.deepEqual(state.foundation, FIXTURE, "the raw foundation is kept verbatim for the next gate read");
-});
-
-test("both markdown files are 0644", (t) => {
-  const root = tmpRoot(t);
-  syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-  for (const rel of ["DESIGN.md", "PRODUCT.md"]) {
-    assert.equal(statSync(join(root, rel)).mode & 0o777, DESIGN_FILE_MODE, rel);
-  }
-});
-
-test("re-syncing an unchanged foundation rewrites NOTHING — mtimes are untouched", (t) => {
-  const root = tmpRoot(t);
-  syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-
-  // Backdate both files so any rewrite is unmistakable.
-  const old = new Date(NOW - 86_400_000);
-  for (const rel of ["DESIGN.md", "PRODUCT.md"]) utimesSync(join(root, rel), old, old);
-  const before = ["DESIGN.md", "PRODUCT.md"].map((rel) => statSync(join(root, rel)).mtimeMs);
-
-  // A LATER clock, deliberately: the timestamp inside the file must not be what
-  // makes a sync a rewrite, or the interval poll would churn the tree forever.
-  const again = syncDesign({ agentRoot: root, result: result(), now: NOW + 20 * 60_000, name: "Northwind" });
-  assert.deepEqual(again.written, [], "nothing written");
-  assert.deepEqual(again.unchanged, ["DESIGN.md", "PRODUCT.md"]);
-
-  const after = ["DESIGN.md", "PRODUCT.md"].map((rel) => statSync(join(root, rel)).mtimeMs);
-  assert.deepEqual(after, before, "the files were not touched at all");
-
-  const design = readFileSync(join(root, "DESIGN.md"), "utf8");
-  assert.match(design, /\*\*Synced:\*\* 2026-09-08T12:00:00\.000Z/, "the stamp still says when the CONTENT was minted");
-
-  // The snapshot is still refreshed, so the gate knows the seat did check.
-  const state = JSON.parse(readFileSync(join(root, DESIGN_STATE_REL), "utf8"));
-  assert.equal(state.fetchedAt, "2026-09-08T12:20:00.000Z");
-  assert.equal(state.renderedAt, "2026-09-08T12:00:00.000Z");
-});
-
-test("a changed foundation rewrites the affected file and re-stamps it", (t) => {
-  const root = tmpRoot(t);
-  syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-
-  const moved = JSON.parse(JSON.stringify(FIXTURE));
-  moved.colors[2].value = "#111111";
-  const out = syncDesign({
-    agentRoot: root,
-    result: result({ foundation: moved, headVersionId: "bv_02", version: { id: "bv_02", seq: 8, label: "V2.8" } }),
-    now: NOW + 20 * 60_000,
-    name: "Northwind",
-  });
-
-  assert.ok(out.written.includes("DESIGN.md"));
-  assert.equal(out.version, "bv_02");
-  const design = readFileSync(join(root, "DESIGN.md"), "utf8");
-  assert.match(design, /primary-moss: "#111111"/);
-  assert.match(design, /\*\*Synced:\*\* 2026-09-08T12:20:00\.000Z/);
-  assert.match(design, /\*\*Version:\*\* V2\.8/);
-});
-
-test("--out sends the docs elsewhere; the snapshot always stays under the agent root", (t) => {
-  const root = tmpRoot(t);
-  const outDir = join(root, "docs", "brand");
-  const out = syncDesign({ agentRoot: root, outDir, result: result(), now: NOW, name: "Northwind" });
-
-  assert.equal(out.outDir, outDir);
-  assert.ok(existsSync(join(outDir, "DESIGN.md")));
-  assert.ok(!existsSync(join(root, "DESIGN.md")));
-  assert.ok(existsSync(join(root, DESIGN_STATE_REL)));
-});
-
-test("writeDesignFiles skips a file whose bytes already match and rewrites an unreadable one", (t) => {
-  const root = tmpRoot(t);
-  const files = renderDesignBundle(FIXTURE, { name: "Northwind" });
-  assert.deepEqual(writeDesignFiles({ files, outDir: root }).written, ["DESIGN.md", "PRODUCT.md"]);
-  assert.deepEqual(writeDesignFiles({ files, outDir: root }), { written: [], unchanged: ["DESIGN.md", "PRODUCT.md"] });
-
-  writeFileSync(join(root, "DESIGN.md"), "someone edited this by hand\n");
-  assert.deepEqual(writeDesignFiles({ files, outDir: root }).written, ["DESIGN.md"], "a hand edit is overwritten — the file is generated");
-
-  const boom = writeDesignFiles({ files, outDir: root }, { readFileImpl: () => { throw new Error("EIO"); } });
-  assert.deepEqual(boom.written, ["DESIGN.md", "PRODUCT.md"], "unreadable is treated as absent");
-});
-
-test("writeDesignFiles ignores malformed entries rather than throwing", (t) => {
-  const root = tmpRoot(t);
-  const out = writeDesignFiles({ files: [null, { rel: "A.md" }, { content: "x" }, { rel: "ok.md", content: "y" }], outDir: root });
-  assert.deepEqual(out.written, ["ok.md"]);
-  assert.deepEqual(writeDesignFiles({ files: "not a list", outDir: root }), { written: [], unchanged: [] });
-});
-
-test("readFoundationState reads back what writeFoundationState wrote; corrupt reads as never-synced", (t) => {
-  const root = tmpRoot(t);
-  assert.equal(readFoundationState(root), null, "absent → null");
-
-  const path = writeFoundationState(root, { fetchedAt: "2026-09-08T12:00:00.000Z", version: "bv_1", foundation: { colors: [] } });
-  assert.equal(path, join(root, DESIGN_STATE_REL));
-  assert.equal(readFoundationState(root).version, "bv_1");
-
-  writeFileSync(path, "{ not json");
-  assert.equal(readFoundationState(root), null, "corrupt → null → re-sync, never a wedge");
-
-  writeFileSync(path, JSON.stringify([1, 2]));
-  assert.equal(readFoundationState(root), null, "an array is not a snapshot");
-});
-
-test("filesMatch is the idempotence probe the CLI's claim rests on", (t) => {
-  const root = tmpRoot(t);
-  const files = renderDesignBundle(FIXTURE, { name: "Northwind" });
-  assert.equal(filesMatch(files, root), false, "nothing on disk yet");
-  writeDesignFiles({ files, outDir: root });
-  assert.equal(filesMatch(files, root), true);
-  writeFileSync(join(root, "PRODUCT.md"), "drift\n");
-  assert.equal(filesMatch(files, root), false);
-});
-
-test("workspaceName reads the org config and invents nothing", () => {
-  assert.equal(workspaceName({ org: { cohort: { orgName: "Northwind" } } }), "Northwind");
-  assert.equal(workspaceName({ org: { cohort: { workspace: "adaptic-hq" } } }), "adaptic-hq");
-  assert.equal(workspaceName({ org: { cohort: { orgName: "  " } } }), "Workspace");
-  assert.equal(workspaceName({}), "Workspace");
-  assert.equal(workspaceName(null), "Workspace");
-});
-
-test("a state directory that does not exist yet is created", (t) => {
-  const root = join(tmpRoot(t), "not", "made", "yet");
-  mkdirSync(root, { recursive: true });
-  const out = syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-  assert.ok(existsSync(out.statePath));
-});
-
-// ── two output directories, one state file ──────────────────────────────────
-
-test("the daemon's agent dir and a --out directory do not invalidate each other, ever", (t) => {
-  // The scenario: an operator runs `maestro design sync --out docs/brand`
-  // (advertised in the guide) on a seat whose daemon polls the agent dir every
-  // 15 minutes. With one shared render stamp, each lane re-stamped the state
-  // and the other lane then found its own files "stale" — both files rewritten
-  // on every tick, forever, with a foundation that never changed.
-  const root = tmpRoot(t);
-  const brand = join(root, "docs", "brand");
-  let now = NOW;
-  const daemon = () => syncDesign({ agentRoot: root, result: result(), now: (now += 900_000), name: "Northwind" });
-  const cli = () => syncDesign({ agentRoot: root, outDir: brand, result: result(), now: (now += 60_000), name: "Northwind" });
-
-  assert.deepEqual(daemon().written, ["DESIGN.md", "PRODUCT.md"], "first write of the agent dir");
-  assert.deepEqual(cli().written, ["DESIGN.md", "PRODUCT.md"], "first write of docs/brand");
-
-  for (let i = 0; i < 6; i++) {
-    assert.deepEqual(daemon().written, [], `daemon poll ${i + 1} rewrote nothing`);
-    assert.deepEqual(cli().written, [], `--out run ${i + 1} rewrote nothing`);
-  }
-
-  const state = readFoundationState(root);
-  assert.equal(typeof state.rendered, "object");
-  assert.equal(Object.keys(state.rendered).length, 2, "one stamp per output directory");
-  assert.equal(state.renderedAt, state.rendered[resolve(root)], "the top-level stamp still describes the agent dir");
-});
-
-test("a legacy state file with a bare renderedAt migrates without a spurious rewrite", (t) => {
-  const root = tmpRoot(t);
-  syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-  // Rewrite the snapshot in the pre-map shape, as an older SDK left it.
-  const doc = readFoundationState(root);
-  const legacy = { ...doc };
-  delete legacy.rendered;
-  writeFoundationState(root, legacy);
-  assert.equal(readFoundationState(root).rendered, undefined);
-
-  const out = syncDesign({ agentRoot: root, result: result(), now: NOW + 3_600_000, name: "Northwind" });
-  assert.deepEqual(out.written, [], "the old stamp is read as the agent dir's, so the bytes still match");
-  assert.equal(readFoundationState(root).rendered[resolve(root)], legacy.renderedAt);
-});
-
-test("both markdown files are published atomically and forced to 0644 even over a tighter file", (t) => {
-  const root = tmpRoot(t);
-  syncDesign({ agentRoot: root, result: result(), now: NOW, name: "Northwind" });
-  // Some other tool tightens the mode and truncates the content.
-  chmodSync(join(root, "DESIGN.md"), 0o600);
-  writeFileSync(join(root, "DESIGN.md"), "half a file");
-  syncDesign({ agentRoot: root, result: result(), now: NOW + 1000, name: "Northwind" });
-  assert.equal(statSync(join(root, "DESIGN.md")).mode & 0o777, DESIGN_FILE_MODE, "chmod runs on a rewrite, not only on create");
-
-  // No temp file is left behind by the atomic publish.
-  assert.deepEqual(readdirSync(root).filter((f) => f.includes(".tmp.")), []);
-});

package/lib/diagnostics/alerts.test.mjs

@@ -1,318 +0,0 @@
-/**
- * alerts.test.mjs — coverage for lib/diagnostics/alerts.mjs.
- *
- * Each behavioral rule must FIRE at/above its threshold and stay QUIET below it,
- * emitAlerts must post every alert to an injected sink (no live call), and both
- * entry points must never throw on garbage input.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  evaluateAlerts,
-  emitAlerts,
-  loadThresholds,
-  mergeThresholds,
-  DEFAULT_THRESHOLDS,
-  _internals,
-} from "./alerts.mjs";
-
-const ids = (alerts) => alerts.map((a) => a.id).sort();
-const byId = (alerts, id) => alerts.find((a) => a.id === id);
-
-// ---------------------------------------------------------------------------
-// refusal spike
-// ---------------------------------------------------------------------------
-
-test("refusal_spike: quiet below warn, warns at warn, critical at crit", () => {
-  // Defaults: warn 10, crit 25, across counters refusal/policy.refusal/classifier.refusal.
-  assert.equal(byId(evaluateAlerts({ snapshot: { refusal: 9 } }), "refusal_spike"), undefined);
-
-  const warn = byId(evaluateAlerts({ snapshot: { refusal: 10 } }), "refusal_spike");
-  assert.ok(warn, "fires at warn threshold");
-  assert.equal(warn.severity, "warning");
-
-  // Summed across the configured counters.
-  const summed = byId(
-    evaluateAlerts({ snapshot: { refusal: 12, "policy.refusal": 8, "classifier.refusal": 6 } }),
-    "refusal_spike"
-  );
-  assert.ok(summed);
-  assert.equal(summed.severity, "critical"); // 26 >= 25
-  assert.match(summed.detail, /26 refusals/);
-});
-
-// ---------------------------------------------------------------------------
-// guard fail-open spike (named + suffix match)
-// ---------------------------------------------------------------------------
-
-test("guard_fail_spike: suffix-matched counters are summed and banded", () => {
-  // Below warn (5).
-  assert.equal(
-    byId(evaluateAlerts({ snapshot: { "rate_guard.fail_open": 4 } }), "guard_fail_spike"),
-    undefined
-  );
-
-  // At warn: 5 across suffix matches.
-  const warn = byId(
-    evaluateAlerts({ snapshot: { "rate_guard.fail_open": 3, "budget_guard.persist_failed": 2 } }),
-    "guard_fail_spike"
-  );
-  assert.ok(warn);
-  assert.equal(warn.severity, "warning");
-
-  // At crit: 20.
-  const crit = byId(
-    evaluateAlerts({ snapshot: { "x.fail_open": 10, "y.degraded": 10 } }),
-    "guard_fail_spike"
-  );
-  assert.ok(crit);
-  assert.equal(crit.severity, "critical");
-
-  // A non-matching counter must NOT contribute.
-  assert.equal(
-    byId(evaluateAlerts({ snapshot: { "some.unrelated_counter": 99 } }), "guard_fail_spike"),
-    undefined
-  );
-});
-
-// ---------------------------------------------------------------------------
-// cost per session p99
-// ---------------------------------------------------------------------------
-
-test("cost_per_session_p99: uses p99 of the distribution when present", () => {
-  // 10 cheap sessions, one $4 outlier — p99 (nearest-rank) picks the outlier.
-  const perSessionUSD = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 4.0];
-  const a = byId(
-    evaluateAlerts({ ledger: { sessions: 10, spentUSD: 4.9, perSessionUSD } }),
-    "cost_per_session_p99"
-  );
-  assert.ok(a, "fires when p99 exceeds crit");
-  assert.equal(a.severity, "critical"); // 4.0 >= crit 3.0
-  assert.match(a.detail, /p99/);
-});
-
-test("cost_per_session_p99: falls back to mean when no distribution", () => {
-  // mean = 10/5 = 2.0 → warning (>=1.5, <3.0).
-  const a = byId(
-    evaluateAlerts({ ledger: { sessions: 5, spentUSD: 10 } }),
-    "cost_per_session_p99"
-  );
-  assert.ok(a);
-  assert.equal(a.severity, "warning");
-  assert.match(a.detail, /mean/);
-});
-
-test("cost_per_session_p99: stays quiet below the warn threshold", () => {
-  // mean = 5/5 = 1.0 < warn 1.5.
-  assert.equal(
-    byId(evaluateAlerts({ ledger: { sessions: 5, spentUSD: 5 } }), "cost_per_session_p99"),
-    undefined
-  );
-});
-
-test("cost_per_session_p99: does not fire on a tiny sample (minSessions)", () => {
-  // Only 4 sessions (< minSessions 5) even though per-session spend is huge.
-  assert.equal(
-    byId(evaluateAlerts({ ledger: { sessions: 4, spentUSD: 40 } }), "cost_per_session_p99"),
-    undefined
-  );
-});
-
-// ---------------------------------------------------------------------------
-// absent agent
-// ---------------------------------------------------------------------------
-
-test("absent_agent: quiet below warn, warns then crits on heartbeat age", () => {
-  // Defaults: warn 600s, crit 1800s.
-  assert.equal(
-    byId(evaluateAlerts({ presence: { heartbeatAgeSec: 300 } }), "absent_agent"),
-    undefined
-  );
-
-  const warn = byId(evaluateAlerts({ presence: { heartbeatAgeSec: 600 } }), "absent_agent");
-  assert.ok(warn);
-  assert.equal(warn.severity, "warning");
-
-  const crit = byId(evaluateAlerts({ presence: { heartbeatAgeSec: 2000 } }), "absent_agent");
-  assert.ok(crit);
-  assert.equal(crit.severity, "critical");
-
-  // No heartbeat age supplied → absent_agent does NOT fire (daemon_down covers it).
-  assert.equal(byId(evaluateAlerts({ presence: {} }), "absent_agent"), undefined);
-});
-
-// ---------------------------------------------------------------------------
-// daemon down
-// ---------------------------------------------------------------------------
-
-test("daemon_down: explicit flag is critical; stale heartbeat is banded", () => {
-  const flagged = byId(evaluateAlerts({ presence: { daemonDown: true } }), "daemon_down");
-  assert.ok(flagged);
-  assert.equal(flagged.severity, "critical");
-
-  // Defaults: warn 120s, crit 300s.
-  assert.equal(
-    byId(evaluateAlerts({ presence: { daemonHealthAgeSec: 60 } }), "daemon_down"),
-    undefined
-  );
-  const warn = byId(evaluateAlerts({ presence: { daemonHealthAgeSec: 150 } }), "daemon_down");
-  assert.ok(warn);
-  assert.equal(warn.severity, "warning");
-  const crit = byId(evaluateAlerts({ presence: { daemonHealthAgeSec: 600 } }), "daemon_down");
-  assert.ok(crit);
-  assert.equal(crit.severity, "critical");
-});
-
-// ---------------------------------------------------------------------------
-// determinism, ordering, custom thresholds
-// ---------------------------------------------------------------------------
-
-test("evaluateAlerts: deterministic, critical-first ordering", () => {
-  const args = {
-    snapshot: { refusal: 30 }, // critical refusal_spike
-    presence: { heartbeatAgeSec: 700 }, // warning absent_agent
-  };
-  const a = evaluateAlerts(args);
-  assert.deepEqual(ids(a), ["absent_agent", "refusal_spike"]);
-  // Critical sorts before warning.
-  assert.equal(a[0].severity, "critical");
-  assert.equal(a[0].id, "refusal_spike");
-  // Repeated evaluation is identical.
-  assert.deepEqual(evaluateAlerts(args), a);
-});
-
-test("evaluateAlerts: custom thresholds override defaults", () => {
-  // Lower the refusal warn to 2 so 3 refusals fires.
-  const a = byId(
-    evaluateAlerts({ snapshot: { refusal: 3 }, thresholds: { refusalSpike: { warnCount: 2, critCount: 100 } } }),
-    "refusal_spike"
-  );
-  assert.ok(a);
-  assert.equal(a.severity, "warning");
-});
-
-test("evaluateAlerts: clean inputs produce no alerts", () => {
-  const a = evaluateAlerts({
-    snapshot: { some_ok_counter: 3 },
-    ledger: { sessions: 100, spentUSD: 10 }, // mean 0.1 — fine
-    presence: { heartbeatAgeSec: 5, daemonHealthAgeSec: 5 },
-  });
-  assert.deepEqual(a, []);
-});
-
-test("evaluateAlerts: never throws on garbage input", () => {
-  assert.doesNotThrow(() => evaluateAlerts());
-  assert.doesNotThrow(() => evaluateAlerts(null));
-  assert.doesNotThrow(() => evaluateAlerts({ snapshot: 42, ledger: "x", presence: [] }));
-  assert.deepEqual(evaluateAlerts({ snapshot: 42, ledger: "x", presence: [] }), []);
-});
-
-// ---------------------------------------------------------------------------
-// emitAlerts — injected sink, never live
-// ---------------------------------------------------------------------------
-
-test("emitAlerts: posts every alert to the injected sink", async () => {
-  const posted = [];
-  const sink = (alert) => {
-    posted.push(alert);
-    return true;
-  };
-  const alerts = [
-    { id: "a", severity: "warning", detail: "x" },
-    { id: "b", severity: "critical", detail: "y" },
-  ];
-  const summary = await emitAlerts(alerts, { sink });
-  assert.equal(summary.attempted, 2);
-  assert.equal(summary.delivered, 2);
-  assert.equal(summary.failed, 0);
-  assert.deepEqual(posted.map((a) => a.id), ["a", "b"]);
-});
-
-test("emitAlerts: async sink is awaited; undefined return counts as delivered", async () => {
-  const seen = [];
-  const sink = async (alert) => {
-    await Promise.resolve();
-    seen.push(alert.id);
-    // returns undefined
-  };
-  const summary = await emitAlerts([{ id: "z", severity: "warning", detail: "d" }], { sink });
-  assert.equal(summary.delivered, 1);
-  assert.deepEqual(seen, ["z"]);
-});
-
-test("emitAlerts: a throwing sink fails that alert but not the rest", async () => {
-  const delivered = [];
-  const sink = (alert) => {
-    if (alert.id === "boom") throw new Error("sink down");
-    delivered.push(alert.id);
-    return true;
-  };
-  const summary = await emitAlerts(
-    [
-      { id: "ok1", severity: "warning", detail: "" },
-      { id: "boom", severity: "critical", detail: "" },
-      { id: "ok2", severity: "warning", detail: "" },
-    ],
-    { sink }
-  );
-  assert.equal(summary.attempted, 3);
-  assert.equal(summary.delivered, 2);
-  assert.equal(summary.failed, 1);
-  assert.deepEqual(delivered, ["ok1", "ok2"]);
-  assert.deepEqual(summary.results.find((r) => r.id === "boom"), { id: "boom", ok: false });
-});
-
-test("emitAlerts: a sink returning false is a failed delivery", async () => {
-  const summary = await emitAlerts([{ id: "a", severity: "warning", detail: "" }], {
-    sink: () => false,
-  });
-  assert.equal(summary.delivered, 0);
-  assert.equal(summary.failed, 1);
-});
-
-test("emitAlerts: no sink wired counts as failed (raised but went nowhere)", async () => {
-  const summary = await emitAlerts([{ id: "a", severity: "warning", detail: "" }], {});
-  assert.equal(summary.attempted, 1);
-  assert.equal(summary.delivered, 0);
-  assert.equal(summary.failed, 1);
-});
-
-test("emitAlerts: never throws on garbage", async () => {
-  await assert.doesNotReject(() => emitAlerts());
-  await assert.doesNotReject(() => emitAlerts(null, null));
-  const s = await emitAlerts("not-an-array", { sink: () => true });
-  assert.equal(s.attempted, 0);
-});
-
-// ---------------------------------------------------------------------------
-// thresholds config
-// ---------------------------------------------------------------------------
-
-test("loadThresholds: returns defaults when no config file present", async () => {
-  const t = await loadThresholds({ configPath: "/nonexistent/alerts.yaml" });
-  assert.equal(t.refusalSpike.warnCount, DEFAULT_THRESHOLDS.refusalSpike.warnCount);
-  assert.equal(t.daemonDown.critSec, DEFAULT_THRESHOLDS.daemonDown.critSec);
-});
-
-test("mergeThresholds: deep-merges override over defaults without mutating defaults", () => {
-  const merged = mergeThresholds(DEFAULT_THRESHOLDS, { refusalSpike: { warnCount: 1 } });
-  assert.equal(merged.refusalSpike.warnCount, 1);
-  // Sibling keys preserved.
-  assert.equal(merged.refusalSpike.critCount, DEFAULT_THRESHOLDS.refusalSpike.critCount);
-  // Defaults untouched (frozen + cloned).
-  assert.equal(DEFAULT_THRESHOLDS.refusalSpike.warnCount, 10);
-});
-
-// ---------------------------------------------------------------------------
-// internals
-// ---------------------------------------------------------------------------
-
-test("p99: nearest-rank, tolerant of junk, null on empty", () => {
-  assert.equal(_internals.p99([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 10);
-  assert.equal(_internals.p99([5]), 5);
-  assert.equal(_internals.p99([]), null);
-  assert.equal(_internals.p99("nope"), null);
-  assert.equal(_internals.p99([1, "x", 3, null, 2]), 3); // junk dropped → [1,2,3]
-});