@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/diagnostics/backup-freshness.test.mjs

@@ -1,185 +0,0 @@
-/**
- * backup-freshness.test.mjs — coverage for lib/diagnostics/backup-freshness.mjs.
- *
- * Hermetic: every case builds a tmp `.maestro/` fixture (config + marker) and
- * injects `now`, so no real backup machinery runs. Verifies the configured /
- * stale / ageHours verdict for the cases doctor + alerting depend on.
- */
-
-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 { backupFreshness, DEFAULT_STALE_HOURS } from "./backup-freshness.mjs";
-
-const HOUR = 3_600_000;
-
-/** Build a tmp agent root with optional backup-config.yaml + last-backup.json. */
-function makeAgent({ configBody, marker } = {}) {
-  const root = mkdtempSync(join(tmpdir(), "bf-test-"));
-  mkdirSync(join(root, ".maestro"), { recursive: true });
-  if (configBody !== undefined) {
-    writeFileSync(join(root, ".maestro", "backup-config.yaml"), configBody);
-  }
-  if (marker !== undefined) {
-    writeFileSync(
-      join(root, ".maestro", "last-backup.json"),
-      typeof marker === "string" ? marker : JSON.stringify(marker)
-    );
-  }
-  return root;
-}
-
-function cleanup(root) {
-  rmSync(root, { recursive: true, force: true });
-}
-
-test("unconfigured (no files) → configured:false, not stale, no age", () => {
-  const root = makeAgent();
-  try {
-    const r = backupFreshness({ agentRoot: root, now: Date.now() });
-    assert.equal(r.configured, false);
-    assert.equal(r.stale, false);
-    assert.equal(r.lastBackupAt, null);
-    assert.equal(r.ageHours, null);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("scaffold default (enabled: false) → configured:false", () => {
-  const root = makeAgent({ configBody: "enabled: false\nprovider: gcs\n" });
-  try {
-    const r = backupFreshness({ agentRoot: root });
-    assert.equal(r.configured, false);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("enabled: true with a fresh marker → configured, not stale, age computed", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const completed_at = new Date(now - 6 * HOUR).toISOString(); // 6h ago
-  const root = makeAgent({
-    configBody: "enabled: true\nprovider: gcs\nbucket: x\nprefix: y\n",
-    marker: { completed_at, provider: "gcs", size_bytes: 1234 },
-  });
-  try {
-    const r = backupFreshness({ agentRoot: root, now });
-    assert.equal(r.configured, true);
-    assert.equal(r.stale, false);
-    assert.equal(r.lastBackupAt, completed_at);
-    assert.equal(r.ageHours, 6);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("enabled with a marker older than the window → stale", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const completed_at = new Date(now - 72 * HOUR).toISOString(); // 72h ago > 48h default
-  const root = makeAgent({
-    configBody: "enabled: true\n",
-    marker: { completed_at },
-  });
-  try {
-    const r = backupFreshness({ agentRoot: root, now });
-    assert.equal(r.configured, true);
-    assert.equal(r.ageHours, 72);
-    assert.equal(r.stale, true);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("stale boundary: exactly at staleHours is fresh; just over is stale", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const atBoundary = new Date(now - DEFAULT_STALE_HOURS * HOUR).toISOString();
-  const overBoundary = new Date(now - (DEFAULT_STALE_HOURS * HOUR + 60_000)).toISOString();
-  const rootA = makeAgent({ configBody: "enabled: true\n", marker: { completed_at: atBoundary } });
-  const rootB = makeAgent({ configBody: "enabled: true\n", marker: { completed_at: overBoundary } });
-  try {
-    assert.equal(backupFreshness({ agentRoot: rootA, now }).stale, false, "exactly at window is fresh");
-    assert.equal(backupFreshness({ agentRoot: rootB, now }).stale, true, "just over window is stale");
-  } finally {
-    cleanup(rootA);
-    cleanup(rootB);
-  }
-});
-
-test("custom staleHours is honoured", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const completed_at = new Date(now - 10 * HOUR).toISOString();
-  const root = makeAgent({ configBody: "enabled: true\n", marker: { completed_at } });
-  try {
-    // 10h old: stale under an 8h window, fresh under the 48h default.
-    assert.equal(backupFreshness({ agentRoot: root, now, staleHours: 8 }).stale, true);
-    assert.equal(backupFreshness({ agentRoot: root, now }).stale, false);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("configured but NO marker → stale (a backup that never ran)", () => {
-  const root = makeAgent({ configBody: "enabled: true\n" });
-  try {
-    const r = backupFreshness({ agentRoot: root, now: Date.now() });
-    assert.equal(r.configured, true);
-    assert.equal(r.lastBackupAt, null);
-    assert.equal(r.ageHours, null);
-    assert.equal(r.stale, true);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("configured with a corrupt marker → stale, not a throw", () => {
-  const root = makeAgent({ configBody: "enabled: true\n", marker: "{not json" });
-  try {
-    const r = backupFreshness({ agentRoot: root, now: Date.now() });
-    assert.equal(r.configured, true);
-    assert.equal(r.lastBackupAt, null);
-    assert.equal(r.stale, true);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("future-dated marker (clock skew) is treated as fresh, not stale", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const completed_at = new Date(now + 2 * HOUR).toISOString(); // 2h in the future
-  const root = makeAgent({ configBody: "enabled: true\n", marker: { completed_at } });
-  try {
-    const r = backupFreshness({ agentRoot: root, now });
-    assert.equal(r.stale, false);
-    assert.ok(r.ageHours < 0, "negative age for a future marker");
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("explicit configPath + markerPath overrides agentRoot", () => {
-  const now = Date.parse("2026-06-11T12:00:00Z");
-  const root = mkdtempSync(join(tmpdir(), "bf-explicit-"));
-  const cfg = join(root, "cfg.yaml");
-  const mk = join(root, "marker.json");
-  writeFileSync(cfg, "enabled: true\n");
-  writeFileSync(mk, JSON.stringify({ completed_at: new Date(now - HOUR).toISOString() }));
-  try {
-    const r = backupFreshness({ configPath: cfg, markerPath: mk, now });
-    assert.equal(r.configured, true);
-    assert.equal(r.ageHours, 1);
-    assert.equal(r.stale, false);
-  } finally {
-    cleanup(root);
-  }
-});
-
-test("never throws on a totally bogus cfg", () => {
-  assert.doesNotThrow(() => backupFreshness(null));
-  assert.doesNotThrow(() => backupFreshness({ agentRoot: 42, now: "x" }));
-  const r = backupFreshness({ configPath: 12345 });
-  assert.equal(typeof r.configured, "boolean");
-});

package/lib/diagnostics/counters.test.mjs

@@ -1,206 +0,0 @@
-/**
- * lib/diagnostics/counters.test.mjs
- *
- * node:test coverage for the loud guard-fail-open counters:
- *  - bump increments the in-memory tally and persists a JSONL row
- *  - bump persists to the date-stamped path under the counters dir
- *  - snapshot sums today's rows per name from disk (cross-restart view)
- *  - snapshot is isolated to "today" by the injected clock
- *  - bump never throws on an un-serializable attr / bad name / failing append
- *  - snapshot never throws on a missing dir / corrupt line / unreadable file
- *  - concurrent-style appends (multiple rows) sum correctly
- *
- * Run: cd /Users/layla/maestro && node --test lib/diagnostics/counters.test.mjs
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  bump,
-  snapshot,
-  memSnapshot,
-  resetMem,
-  listStreams,
-} from "./counters.mjs";
-
-function tmpDir() {
-  return mkdtempSync(join(tmpdir(), "maestro-counters-"));
-}
-
-/** Fixed clock at 2026-06-11T12:00:00Z. */
-const FIXED = Date.parse("2026-06-11T12:00:00.000Z");
-const fixedNow = () => FIXED;
-
-test("bump increments the in-memory tally and returns the new total", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push({ p, row }); return true; };
-
-  const t1 = bump("rate_guard.persist_failed", { provider: "anthropic" }, { append, now: fixedNow });
-  const t2 = bump("rate_guard.persist_failed", { provider: "anthropic" }, { append, now: fixedNow });
-  assert.equal(t1, 1);
-  assert.equal(t2, 2);
-  assert.equal(memSnapshot()["rate_guard.persist_failed"], 2);
-  assert.equal(captured.length, 2);
-  assert.equal(captured[0].row.name, "rate_guard.persist_failed");
-  assert.equal(captured[0].row.by, 1);
-  assert.equal(captured[0].row.attrs.provider, "anthropic");
-  assert.equal(typeof captured[0].row.ts, "string");
-});
-
-test("bump honours an explicit increment amount", () => {
-  resetMem();
-  const append = () => true;
-  assert.equal(bump("budget.stale_ledger", {}, { append, by: 5, now: fixedNow }), 5);
-  assert.equal(bump("budget.stale_ledger", {}, { append, by: 3, now: fixedNow }), 8);
-});
-
-test("bump persists to a date-stamped path under the counters dir", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("g.fail", { reason: "x" }, { dir, now: fixedNow });
-    const files = readdirSync(dir);
-    assert.deepEqual(files, ["2026-06-11.jsonl"]);
-    const raw = readFileSync(join(dir, "2026-06-11.jsonl"), "utf-8").trim();
-    const row = JSON.parse(raw);
-    assert.equal(row.name, "g.fail");
-    assert.equal(row.by, 1);
-    assert.equal(row.attrs.reason, "x");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot sums today's rows per name from disk", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("a", {}, { dir, now: fixedNow });
-    bump("a", {}, { dir, now: fixedNow });
-    bump("b", {}, { dir, now: fixedNow, by: 4 });
-    const snap = snapshot({ dir, now: fixedNow });
-    assert.equal(snap.a, 2);
-    assert.equal(snap.b, 4);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot is isolated to the clock's day", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    const day1 = () => Date.parse("2026-06-11T01:00:00.000Z");
-    const day2 = () => Date.parse("2026-06-12T01:00:00.000Z");
-    bump("x", {}, { dir, now: day1 });
-    bump("x", {}, { dir, now: day1 });
-    bump("x", {}, { dir, now: day2 });
-    // Two distinct day files exist.
-    assert.deepEqual(readdirSync(dir).sort(), ["2026-06-11.jsonl", "2026-06-12.jsonl"]);
-    // Each day's snapshot only sees its own rows.
-    assert.equal(snapshot({ dir, now: day1 }).x, 2);
-    assert.equal(snapshot({ dir, now: day2 }).x, 1);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot survives across a simulated restart (reads disk, not memory)", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("survives", {}, { dir, now: fixedNow });
-    bump("survives", {}, { dir, now: fixedNow });
-    // Simulate a process restart: the in-memory tally is gone, the disk isn't.
-    resetMem();
-    assert.deepEqual(memSnapshot(), {});
-    assert.equal(snapshot({ dir, now: fixedNow }).survives, 2);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("bump never throws and still moves the in-memory tally when append fails", () => {
-  resetMem();
-  const failingAppend = () => { throw new Error("disk full"); };
-  // append throwing must NOT propagate; the in-memory tally must still advance.
-  const total = bump("resilient", {}, { append: failingAppend, now: fixedNow });
-  // append threw before returning, but the in-memory bump happened first.
-  assert.equal(total, 1);
-  assert.equal(memSnapshot().resilient, 1);
-});
-
-test("bump tolerates an un-serializable attr and a non-string name", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push(row); return true; };
-  const circular = {};
-  circular.self = circular;
-  // A circular attrs object would break naive JSON.stringify; bump must not throw.
-  assert.doesNotThrow(() => bump("circ", circular, { append, now: fixedNow }));
-  // A non-string name folds to a stable string rather than dropping the row.
-  const total = bump(12345, {}, { append, now: fixedNow });
-  assert.equal(total, 1);
-  assert.equal(captured.at(-1).name, "12345");
-});
-
-test("an empty/whitespace name folds to 'unknown'", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push(row); return true; };
-  bump("   ", {}, { append, now: fixedNow });
-  assert.equal(captured.at(-1).name, "unknown");
-});
-
-test("snapshot returns {} for a missing dir and never throws", () => {
-  resetMem();
-  const dir = join(tmpDir(), "does-not-exist");
-  assert.deepEqual(snapshot({ dir, now: fixedNow }), {});
-});
-
-test("snapshot skips corrupt lines but sums the valid ones", () => {
-  resetMem();
-  const good = JSON.stringify({ name: "ok", by: 2 });
-  const good2 = JSON.stringify({ name: "ok", by: 3 });
-  const raw = `${good}\nnot json at all\n${good2}\n{"name":123}\n`;
-  const read = () => raw;
-  const snap = snapshot({ now: fixedNow, read });
-  assert.equal(snap.ok, 5); // 2 + 3; the garbage line and the bad-name line skip
-});
-
-test("snapshot treats a row with a missing/NaN by as 1", () => {
-  resetMem();
-  const raw = `${JSON.stringify({ name: "n" })}\n${JSON.stringify({ name: "n", by: "x" })}\n`;
-  const snap = snapshot({ now: fixedNow, read: () => raw });
-  assert.equal(snap.n, 2); // both default to +1
-});
-
-test("snapshot returns {} when the reader throws (unreadable file)", () => {
-  resetMem();
-  const read = () => { throw new Error("EACCES"); };
-  assert.deepEqual(snapshot({ now: fixedNow, read }), {});
-});
-
-test("listStreams enumerates the date-stamped streams in order", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("s", {}, { dir, now: () => Date.parse("2026-06-11T00:00:00Z") });
-    bump("s", {}, { dir, now: () => Date.parse("2026-06-09T00:00:00Z") });
-    const streams = listStreams({ dir });
-    assert.equal(streams.length, 2);
-    assert.ok(streams[0].endsWith("2026-06-09.jsonl"));
-    assert.ok(streams[1].endsWith("2026-06-11.jsonl"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("listStreams returns [] for a missing dir", () => {
-  assert.deepEqual(listStreams({ dir: join(tmpdir(), "nope-counters-xyz") }), []);
-});

package/lib/diagnostics/events.test.mjs

@@ -1,290 +0,0 @@
-/**
- * events.test.mjs — node:test coverage for the diagnostic-event spine.
- *
- * Hermetic: each test writes into an isolated tmpdir and injects a fixed clock,
- * so date-stamped filenames and timestamps are deterministic. We assert the
- * on-disk JSONL is valid, carries trace_id, and that emitEvent NEVER throws —
- * including on an unwritable directory.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  emitEvent,
-  isValidEventType,
-  EVENT_TYPES,
-} from "./events.mjs";
-import { mintTraceId, withTrace } from "./trace.mjs";
-
-async function makeDir() {
-  const path = join(
-    tmpdir(),
-    `events-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-  );
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-async function rm(path) {
-  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
-}
-
-const FIXED_MS = Date.UTC(2026, 5, 11, 12, 30, 0); // 2026-06-11T12:30:00Z
-const fixedNow = () => FIXED_MS;
-
-function readRows(logDir) {
-  const file = join(logDir, "2026-06-11.jsonl");
-  const body = readFileSync(file, "utf-8");
-  return body
-    .trim()
-    .split("\n")
-    .filter(Boolean)
-    .map((l) => JSON.parse(l)); // throws if any line is not valid JSON
-}
-
-// ---------------------------------------------------------------------------
-// EVENT_TYPES contract
-// ---------------------------------------------------------------------------
-
-test("EVENT_TYPES is the closed 8-type set and is frozen", () => {
-  const values = Object.values(EVENT_TYPES).sort();
-  assert.deepEqual(values, [
-    "classified",
-    "dispatched",
-    "error",
-    "guard_fail",
-    "item_received",
-    "sent",
-    "session_closed",
-    "session_opened",
-  ]);
-  assert.ok(Object.isFrozen(EVENT_TYPES));
-});
-
-test("isValidEventType only accepts the contract types", () => {
-  assert.equal(isValidEventType("item_received"), true);
-  assert.equal(isValidEventType("sent"), true);
-  assert.equal(isValidEventType("nope"), false);
-  assert.equal(isValidEventType(""), false);
-  assert.equal(isValidEventType(null), false);
-  assert.equal(isValidEventType(42), false);
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — happy path writes valid JSONL with trace_id
-// ---------------------------------------------------------------------------
-
-test("emitEvent writes a valid JSONL row with the full contract shape", async () => {
-  const logDir = await makeDir();
-  try {
-    const traceId = mintTraceId();
-    const ok = emitEvent(
-      {
-        type: EVENT_TYPES.ITEM_RECEIVED,
-        trace_id: traceId,
-        span: "root",
-        attrs: { source: "slack", item_id: "C123.456" },
-      },
-      { now: fixedNow, logDir }
-    );
-    assert.equal(ok, true);
-
-    const rows = readRows(logDir);
-    assert.equal(rows.length, 1);
-    const row = rows[0];
-    assert.equal(row.type, "item_received");
-    assert.equal(row.trace_id, traceId);
-    assert.equal(row.span, "root");
-    assert.equal(row.ts, "2026-06-11T12:30:00.000Z");
-    assert.deepEqual(row.attrs, { source: "slack", item_id: "C123.456" });
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent appends successive rows to the same date stream", async () => {
-  const logDir = await makeDir();
-  try {
-    const t = mintTraceId();
-    emitEvent({ type: "item_received", trace_id: t }, { now: fixedNow, logDir });
-    emitEvent({ type: "classified", trace_id: t }, { now: fixedNow, logDir });
-    emitEvent({ type: "sent", trace_id: t }, { now: fixedNow, logDir });
-    const rows = readRows(logDir);
-    assert.equal(rows.length, 3);
-    assert.deepEqual(rows.map((r) => r.type), ["item_received", "classified", "sent"]);
-    // All correlate to one interaction.
-    assert.ok(rows.every((r) => r.trace_id === t));
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent names the file by UTC date of the event", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "sent" }, { now: fixedNow, logDir });
-    assert.ok(existsSync(join(logDir, "2026-06-11.jsonl")));
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — ambient trace context fills trace_id/span
-// ---------------------------------------------------------------------------
-
-test("emitEvent inherits trace_id/span from the ambient withTrace context", async () => {
-  const logDir = await makeDir();
-  try {
-    const traceId = mintTraceId();
-    withTrace({ trace_id: traceId, span: "root.classify" }, () => {
-      emitEvent({ type: "classified", attrs: { category: "action_required" } }, {
-        now: fixedNow,
-        logDir,
-      });
-    });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, traceId);
-    assert.equal(row.span, "root.classify");
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent trace_id is null when no id supplied and no ambient context", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "error", attrs: { msg: "boom" } }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, null);
-    assert.equal(row.span, "root");
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("an explicit trace_id overrides the ambient context", async () => {
-  const logDir = await makeDir();
-  try {
-    const ambient = mintTraceId();
-    const explicit = mintTraceId();
-    withTrace(ambient, () => {
-      emitEvent({ type: "sent", trace_id: explicit }, { now: fixedNow, logDir });
-    });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, explicit);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — closed type set: unknown type is coerced to error
-// ---------------------------------------------------------------------------
-
-test("an unknown event type is coerced to error and preserves the original", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "totally_made_up", attrs: { a: 1 } }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.type, "error");
-    assert.equal(row.attrs._invalid_type, "totally_made_up");
-    assert.equal(row.attrs.a, 1);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("a missing type is coerced to error with _invalid_type null", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ attrs: {} }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.type, "error");
-    assert.equal(row.attrs._invalid_type, null);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — never throws; degrades to false
-// ---------------------------------------------------------------------------
-
-test("emitEvent never throws on a bad/unwritable dir (returns false)", async () => {
-  const logDir = await makeDir();
-  try {
-    // Make the diagnostics dir a FILE so mkdir/append fails.
-    const blocker = join(logDir, "blocked");
-    await fsp.writeFile(blocker, "x");
-    // Point logDir at a path under the file → cannot create a directory there.
-    const badDir = join(blocker, "diagnostics");
-    let ok;
-    assert.doesNotThrow(() => {
-      ok = emitEvent({ type: "sent", trace_id: "T" }, { now: fixedNow, logDir: badDir });
-    });
-    assert.equal(ok, false);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent never throws on a null/garbage event argument", () => {
-  let ok;
-  assert.doesNotThrow(() => {
-    ok = emitEvent(null, { append: () => true });
-  });
-  assert.equal(ok, true); // coerced to {} → error row, write succeeds
-});
-
-test("emitEvent returns false when the injected appender fails", () => {
-  const ok = emitEvent(
-    { type: "sent", trace_id: "T" },
-    { append: () => false }
-  );
-  assert.equal(ok, false);
-});
-
-test("emitEvent never throws when the appender itself throws", () => {
-  let ok;
-  assert.doesNotThrow(() => {
-    ok = emitEvent({ type: "sent" }, {
-      append: () => { throw new Error("disk gone"); },
-    });
-  });
-  assert.equal(ok, false);
-});
-
-test("emitEvent tolerates non-object attrs by wrapping them", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "sent", trace_id: "T", attrs: "just a string" }, {
-      now: fixedNow,
-      logDir,
-    });
-    const [row] = readRows(logDir);
-    assert.deepEqual(row.attrs, { value: "just a string" });
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent uses the injected appender with the date-stamped path", () => {
-  const calls = [];
-  const ok = emitEvent(
-    { type: "dispatched", trace_id: "T" },
-    {
-      now: fixedNow,
-      logDir: "/somewhere/logs/diagnostics",
-      append: (path, record) => { calls.push({ path, record }); return true; },
-    }
-  );
-  assert.equal(ok, true);
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].path, "/somewhere/logs/diagnostics/2026-06-11.jsonl");
-  assert.equal(calls[0].record.type, "dispatched");
-});