@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/scripts/ci/check.test.mjs

@@ -1,194 +0,0 @@
-/**
- * check.test.mjs — node:test coverage for the maestro CI guard scripts.
- *
- * Exercises the pure helpers (so logic is verified deterministically without
- * depending on repo state) and asserts the aggregator + each guard return 0
- * on the current, known-clean repo.
- *
- * Run: `node --test scripts/ci/check.test.mjs`
- *
- * @module scripts/ci/check.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import {
-  lineHasConflictMarker,
-  scanContentForMarkers,
-  findConflictMarkers,
-  run as runConflictMarkers,
-} from "./check-no-conflict-markers.mjs";
-import {
-  collectExportTargets,
-  flattenExports,
-  checkExportsExist,
-  run as runExportsExist,
-} from "./check-exports-exist.mjs";
-import {
-  isGlob,
-  checkFilesExist,
-  run as runFilesExist,
-} from "./check-files-exist.mjs";
-import {
-  scanText,
-  run as runNoConfidential,
-} from "./check-no-confidential.mjs";
-import { runAll, run as runAggregator, CHECKS } from "./check.mjs";
-
-// --- conflict markers: pure line matcher ---
-
-test("lineHasConflictMarker matches the four marker kinds", () => {
-  assert.equal(lineHasConflictMarker("<<<<<<< HEAD"), true);
-  assert.equal(lineHasConflictMarker("======="), true);
-  assert.equal(lineHasConflictMarker(">>>>>>> feature/x"), true);
-  assert.equal(lineHasConflictMarker("||||||| merged common ancestors"), true);
-  assert.equal(lineHasConflictMarker("======= \r".replace(" \r", "\r")), true); // CRLF bare marker
-});
-
-test("lineHasConflictMarker ignores look-alikes", () => {
-  assert.equal(lineHasConflictMarker("======== eight equals is a markdown rule"), false);
-  assert.equal(lineHasConflictMarker("===="), false);
-  assert.equal(lineHasConflictMarker("some =======text inline"), false);
-  assert.equal(lineHasConflictMarker(">>>>>>>>"), false);
-  assert.equal(lineHasConflictMarker(""), false);
-  assert.equal(lineHasConflictMarker(42), false);
-});
-
-test("scanContentForMarkers reports 1-based line numbers", () => {
-  const content = ["ok line", "<<<<<<< HEAD", "mine", "=======", "theirs", ">>>>>>> branch"].join("\n");
-  const hits = scanContentForMarkers(content);
-  assert.deepEqual(hits.map((h) => h.line), [2, 4, 6]);
-  assert.equal(hits[0].text, "<<<<<<< HEAD");
-});
-
-test("scanContentForMarkers clean content yields nothing", () => {
-  assert.deepEqual(scanContentForMarkers("nothing\nto\nsee\n"), []);
-  assert.deepEqual(scanContentForMarkers(""), []);
-});
-
-// --- exports flattening ---
-
-test("collectExportTargets handles string, array, nested conditions, and null", () => {
-  assert.deepEqual(collectExportTargets("./a.js", "./a"), [{ subpath: "./a", target: "./a.js" }]);
-  assert.deepEqual(collectExportTargets(null, "./blocked"), []);
-  const nested = { import: "./x.mjs", require: { default: "./x.cjs" } };
-  const got = collectExportTargets(nested, "./x").map((t) => t.target).sort();
-  assert.deepEqual(got, ["./x.cjs", "./x.mjs"]);
-  const arr = ["./first.js", { import: "./second.mjs" }];
-  const gotArr = collectExportTargets(arr, "./y").map((t) => t.target).sort();
-  assert.deepEqual(gotArr, ["./first.js", "./second.mjs"]);
-});
-
-test("flattenExports handles sugar string form and map form", () => {
-  assert.deepEqual(flattenExports("./index.js"), [{ subpath: ".", target: "./index.js" }]);
-  assert.deepEqual(flattenExports(undefined), []);
-  const pairs = flattenExports({ ".": "./i.js", "./t": "./t.js" });
-  assert.deepEqual(pairs.map((p) => p.target).sort(), ["./i.js", "./t.js"]);
-});
-
-// --- exports/files existence against a synthetic fixture repo ---
-
-async function makeFixtureRepo() {
-  const dir = await mkdtemp(path.join(tmpdir(), "maestro-ci-"));
-  await mkdir(path.join(dir, "lib"), { recursive: true });
-  await writeFile(path.join(dir, "lib", "real.js"), "export const x = 1;\n");
-  await writeFile(path.join(dir, "README.md"), "# fixture\n");
-  return dir;
-}
-
-test("checkExportsExist passes when targets exist, fails when missing", async () => {
-  const dir = await makeFixtureRepo();
-  try {
-    const good = await checkExportsExist({ cwd: dir, pkg: { exports: { ".": "./lib/real.js" } } });
-    assert.equal(good.ok, true);
-    assert.equal(good.checked, 1);
-
-    const bad = await checkExportsExist({ cwd: dir, pkg: { exports: { "./tts": "./lib/missing.mjs" } } });
-    assert.equal(bad.ok, false);
-    assert.equal(bad.missing.length, 1);
-    assert.equal(bad.missing[0].subpath, "./tts");
-
-    // null target is a deliberate block, not a missing file.
-    const blocked = await checkExportsExist({ cwd: dir, pkg: { exports: { "./x": null } } });
-    assert.equal(blocked.ok, true);
-    assert.equal(blocked.checked, 0);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-test("isGlob detects metacharacters", () => {
-  assert.equal(isGlob("lib/"), false);
-  assert.equal(isGlob("README.md"), false);
-  assert.equal(isGlob("lib/**/*.js"), true);
-  assert.equal(isGlob("file?.js"), true);
-});
-
-test("checkFilesExist passes for present entries, fails for missing, skips globs", async () => {
-  const dir = await makeFixtureRepo();
-  try {
-    const good = await checkFilesExist({ cwd: dir, pkg: { files: ["lib/", "README.md"] } });
-    assert.equal(good.ok, true);
-    assert.equal(good.checked, 2);
-
-    const bad = await checkFilesExist({ cwd: dir, pkg: { files: ["lib/", "nope/"] } });
-    assert.equal(bad.ok, false);
-    assert.equal(bad.missing[0].entry, "nope/");
-
-    const globby = await checkFilesExist({ cwd: dir, pkg: { files: ["lib/**/*.js"] } });
-    assert.equal(globby.ok, true);
-    assert.equal(globby.skipped.length, 1);
-    assert.equal(globby.checked, 0);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});
-
-// --- confidential-marker scanner: pure text matcher ---
-
-test("scanText flags denylisted markers and ignores clean text", () => {
-  const patterns = [
-    { label: "target", re: /\bAcme Capital\b/i },
-    { label: "id", re: /\bZZ9999\b/ },
-  ];
-  assert.deepEqual(scanText("nothing to see here", patterns), []);
-  assert.deepEqual(scanText("", patterns), []);
-  assert.deepEqual(scanText("some text", []), []);
-  assert.deepEqual(scanText(42, patterns), []);
-  const hits = scanText("we are pursuing acme capital (ref ZZ9999)", patterns);
-  assert.deepEqual(hits.map((h) => h.label).sort(), ["id", "target"]);
-});
-
-// --- conflict scan against a synthetic git-less dir is not possible (needs git);
-//     instead verify findConflictMarkers throws gracefully only via real repo run below.
-
-// --- live runs against the CURRENT maestro repo: must all be green ---
-
-test("each guard run() returns 0 on the current repo", async () => {
-  assert.equal(await runConflictMarkers(), 0);
-  assert.equal(await runExportsExist(), 0);
-  assert.equal(await runFilesExist(), 0);
-  assert.equal(await runNoConfidential(), 0);
-});
-
-test("findConflictMarkers finds nothing in the current repo", async () => {
-  const offenders = await findConflictMarkers();
-  assert.deepEqual(offenders, []);
-});
-
-test("aggregator runAll reports all checks passed on the current repo", async () => {
-  const { ok, results } = await runAll();
-  assert.equal(ok, true);
-  assert.equal(results.length, CHECKS.length);
-  assert.ok(results.every((r) => r.passed));
-});
-
-test("aggregator run() exits 0 on the current repo", async () => {
-  assert.equal(await runAggregator(), 0);
-});

package/scripts/ci/conformance-org-api.test.mjs

@@ -1,425 +0,0 @@
-/**
- * conformance-org-api.test.mjs — the PURE parts of the live conformance probe.
- *
- * The probe's value rests entirely on one judgement: given an hq error frame,
- * is this WIRE-CONTRACT DRIFT (fail) or a legitimate refusal (skip/warn)? Get
- * that wrong in the lenient direction and the probe is decorative; get it wrong
- * in the strict direction and nobody will keep it in CI. So `classifyFrame` and
- * `citedParams` are tested against the ACTUAL error strings hq's handlers emit
- * — including the real message from every P0 row of the 2026-08 audit.
- *
- * Hermetic: no network, no disk, no credentials. The runner is exercised through
- * injected `callImpl`/`readImpl`.
- *
- * Run: node --test scripts/ci/conformance-org-api.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  classifyFrame,
-  citedParams,
-  buildProbes,
-  parseArgs,
-  probeSelected,
-  runProbes,
-  referencesGhost,
-  wireBodyFor,
-  uncoveredContractMethods,
-  ghostId,
-  SCHEMA_PASSED_CODES,
-} from "./conformance-org-api.mjs";
-import { PARAM_CONTRACT } from "../../lib/org/param-contract.mjs";
-import { methodDef } from "../../lib/org/protocol.mjs";
-
-const err = (code, message) => ({ ok: false, error: { code, message } });
-const probe = (method) => ({ method, params: {} });
-
-// ═══════════════════════════════════════════════════════════════════════════
-// citedParams — parsing hq's four error dialects
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("citedParams: zod path prefix (the `parse()` helper's shape)", () => {
-  assert.deepEqual(citedParams("channelId: Required").cited, ["channelId"]);
-  assert.deepEqual(citedParams("itemId: itemId is required").cited, ["itemId"]);
-  // A nested path reports its ROOT — that is the key the caller controls.
-  assert.deepEqual(citedParams("participantIds.0: Expected string").cited, ["participantIds"]);
-});
-
-test("citedParams: zod .strict() unrecognized keys", () => {
-  const r = citedParams("Unrecognized key(s) in object: 'note', 'stray'");
-  assert.deepEqual(r.unrecognized.sort(), ["note", "stray"]);
-});
-
-test("citedParams: hq's hand-written guards", () => {
-  assert.ok(citedParams("title is required").cited.includes("title"));
-  assert.ok(citedParams("actionClass is required").cited.includes("actionClass"));
-  assert.ok(citedParams("memoryClass must be one of: framework, ledger").cited.includes("memoryClass"));
-  assert.ok(citedParams("payloadHash must be a sha-256 hex digest").cited.includes("payloadHash"));
-});
-
-test("citedParams: a message naming nothing yields nothing (never invents a field)", () => {
-  assert.deepEqual(citedParams("an escalation must reference a task or a channel").unrecognized, []);
-  assert.deepEqual(citedParams("").cited, []);
-  assert.deepEqual(citedParams(null).cited, []);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// classifyFrame — the discriminator
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("ok:true → pass", () => {
-  assert.equal(classifyFrame(probe("member.get"), { slug: "x" }, { ok: true, result: {} }).verdict, "pass");
-});
-
-test("every legitimate-refusal code → skip, NOT fail (the schema was accepted)", () => {
-  for (const code of SCHEMA_PASSED_CODES) {
-    const v = classifyFrame(probe("board.claim"), { itemId: "i" }, err(code, "nope"));
-    assert.equal(v.verdict, "skip", `${code} must not be reported as drift`);
-  }
-});
-
-test("a non-BAD_REQUEST failure (INTERNAL/5xx) → warn, never a silent pass", () => {
-  const v = classifyFrame(probe("board.claim"), { itemId: "i" }, err("INTERNAL", "boom"));
-  assert.equal(v.verdict, "warn");
-});
-
-test("a missing/garbled frame → warn, never a pass", () => {
-  assert.equal(classifyFrame(probe("x.y"), {}, null).verdict, "warn");
-  assert.equal(classifyFrame(probe("x.y"), {}, undefined).verdict, "warn");
-});
-
-// ── the FAIL cases: this is the drift the audit found ──────────────────────
-
-test("DRIFT: hq requires a name we never send → fail (the messaging.send P0)", () => {
-  // What hq actually returned while the SDK minted `clientMsgId`.
-  const v = classifyFrame(
-    probe("messaging.send"),
-    { channelId: "C1", body: "hi", clientMsgId: "cm-1" },
-    err("BAD_REQUEST", "idempotencyId: Required"),
-  );
-  assert.equal(v.verdict, "fail");
-  assert.match(v.reason, /idempotencyId/);
-});
-
-test("DRIFT: hq's .strict() schema rejects a key we DO send → fail (the board.complete P0)", () => {
-  const v = classifyFrame(
-    probe("board.complete"),
-    { itemId: "i-1", note: "done" },
-    err("BAD_REQUEST", "Unrecognized key(s) in object: 'note'"),
-  );
-  assert.equal(v.verdict, "fail");
-  assert.match(v.reason, /REJECTS the param name/);
-  assert.match(v.reason, /note/);
-});
-
-test("DRIFT: the registry.register P0 — a raw self-entry into a strict schema", () => {
-  const v = classifyFrame(
-    probe("registry.register"),
-    { id: "A016", name: "isla", towers: ["eng"] },
-    err("BAD_REQUEST", "Unrecognized key(s) in object: 'id', 'name', 'towers'"),
-  );
-  assert.equal(v.verdict, "fail");
-});
-
-test("DRIFT: each remaining P0 hand-written guard is caught", () => {
-  const rows = [
-    ["escalation.create", { severity: "high", subject: "s", body: "b" }, "title is required", "title"],
-    ["approval.request", { kind: "external_comms", payload_hash: "x" }, "actionClass is required", "actionClass"],
-    ["decision.comment", { decisionId: "d", body: "b" }, "text is required", "text"],
-    ["member.get", { memberId: "m" }, "slug is required", "slug"],
-    ["memory.author", { content: "c", kind: "note" }, "memoryClass must be one of: framework, ledger", "memoryClass"],
-  ];
-  for (const [method, sent, message, expect] of rows) {
-    const v = classifyFrame(probe(method), sent, err("BAD_REQUEST", message));
-    assert.equal(v.verdict, "fail", `${method} must be flagged`);
-    assert.match(v.reason, new RegExp(expect), `${method} must name ${expect}`);
-  }
-});
-
-// ── the WARN case: a value complaint is not drift ──────────────────────────
-
-test("NOT DRIFT: hq disliking the VALUE of a param we sent → warn", () => {
-  const v = classifyFrame(
-    probe("approval.request"),
-    { actionClass: "x", payloadHash: "not-a-hash" },
-    err("BAD_REQUEST", "payloadHash must be a sha-256 hex digest"),
-  );
-  assert.equal(v.verdict, "warn", "we send the right NAME; the probe's placeholder was the problem");
-  assert.match(v.reason, /probe placeholder/);
-});
-
-test("NOT DRIFT: a refine() that names no field → warn, not a false FAIL", () => {
-  const v = classifyFrame(
-    probe("escalation.create"),
-    { title: "t" },
-    err("BAD_REQUEST", "an escalation must reference a task or a channel"),
-  );
-  assert.equal(v.verdict, "warn");
-});
-
-test("a BAD_REQUEST we cannot parse is a warn — never an assumed pass", () => {
-  const v = classifyFrame(probe("x.y"), { a: 1 }, err("BAD_REQUEST", "computer says no"));
-  assert.equal(v.verdict, "warn");
-  assert.match(v.reason, /unparsed/);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// the probe table — coverage + safety
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("every probe names a real protocol method and declares its write posture", () => {
-  for (const p of buildProbes()) {
-    assert.ok(methodDef(p.method), `${p.method} is not in the vendored protocol table`);
-    assert.equal(typeof p.writes, "boolean", `${p.method} must declare writes`);
-    assert.ok(p.why && p.why.length > 8, `${p.method} must justify its safety posture`);
-    assert.ok(p.params && typeof p.params === "object", `${p.method} needs params`);
-  }
-});
-
-test("COVERAGE: every contracted method has a probe (a new contract row cannot ship unprobed)", () => {
-  assert.deepEqual(
-    uncoveredContractMethods(),
-    [],
-    "add a probe to buildProbes() for each new PARAM_CONTRACT entry",
-  );
-});
-
-test("SAFETY: every probe declares a guard, and a `ghost` guard really carries a ghost id", () => {
-  const GUARDS = new Set(["read", "ghost", "audit-only", "no-op", "write"]);
-  const offenders = [];
-  for (const p of buildProbes()) {
-    if (!GUARDS.has(p.guard)) {
-      offenders.push(`${p.method} declares no valid guard (got ${JSON.stringify(p.guard)})`);
-      continue;
-    }
-    if (p.writes && p.guard !== "write") offenders.push(`${p.method} writes but is not guarded "write"`);
-    if (!p.writes && p.guard === "write") offenders.push(`${p.method} is guarded "write" but claims writes:false`);
-    // The load-bearing one: a side-effecting method run BY DEFAULT is safe only
-    // because its target cannot exist.
-    if (p.guard === "ghost" && !referencesGhost(p.params)) {
-      offenders.push(`${p.method} claims guard "ghost" but its params carry no ghost id`);
-    }
-    // And nothing side-effecting may run by default under a "read" guard.
-    const def = methodDef(p.method);
-    if (p.guard === "read" && def && def.sideEffecting) {
-      offenders.push(`${p.method} is side-effecting but guarded "read"`);
-    }
-  }
-  assert.deepEqual(offenders, [], `unsafe probes:\n  ${offenders.join("\n  ")}`);
-});
-
-test("SAFETY: a create-or-upsert method is never guarded `ghost` — an unknown id CREATES", () => {
-  // REGRESSION. The `ghost` guard assumes the handler REQUIRES its entity to
-  // exist, so an impossible id makes a side-effecting probe harmless. That
-  // assumption inverts for create-or-upsert handlers: hq's knowledge.replace
-  // treats an unknown id as the CREATE branch and appends `knowledge.created`
-  // at version 1, so a ghost id GUARANTEES a durable row. It shipped declared
-  // `writes:false` and a read-only run created a junk fact in the live org.
-  //
-  // These methods are upserts on hq's side and must stay `--write`-gated.
-  //
-  // `board.create` is here because it shipped as `ghost` and was one line away
-  // from the same incident: its `itemId` is a caller-chosen id, so an unknown
-  // one is the CREATE branch and makes a real Task. The only thing standing
-  // between a default read-only run and a junk row in the live org was that
-  // `assertChannelVisible` happened to run before `task.create` in hq — a
-  // guarantee no probe declaration should ever rest on. Its sibling
-  // `board.createTask` makes the identical row and has always been `write`.
-  const UPSERTS = ["knowledge.replace", "contacts.upsert", "meetings.record", "board.create"];
-  const byMethod = new Map(buildProbes().map((p) => [p.method, p]));
-  for (const method of UPSERTS) {
-    const p = byMethod.get(method);
-    if (!p) continue; // coverage is asserted elsewhere
-    assert.equal(p.writes, true, `${method} is create-or-upsert: it must declare writes:true`);
-    assert.notEqual(p.guard, "ghost", `${method} is an upsert — a ghost id creates a row, it does not prevent one`);
-  }
-});
-
-test("SAFETY: no outbound-content probe is ever unguarded — a real send must be impossible", () => {
-  // messaging.send is probed, and is safe ONLY because its channel cannot exist.
-  const send = buildProbes().find((p) => p.method === "messaging.send");
-  assert.ok(send, "messaging.send IS probed — it was the worst drift row");
-  assert.equal(send.writes, false);
-  assert.equal(send.guard, "ghost");
-  assert.ok(referencesGhost(send.params), "the channel id must be a ghost or a message could be delivered");
-  // No probe touches the outbound email lane at all.
-  const emailSends = buildProbes().filter((p) => /^email\.(send|draftSend)$/.test(p.method));
-  assert.deepEqual(emailSends, [], "email sends are never probed");
-});
-
-test("SAFETY: ghost ids are unique per run, so a probe can never collide with real data", () => {
-  const a = ghostId("task");
-  const b = ghostId("task");
-  assert.notEqual(a, b);
-  assert.match(a, /^probe-task-[0-9a-f-]{36}$/, "the `probe-` marker is load-bearing for the safety test");
-  assert.equal(referencesGhost({ taskId: a }), true);
-  assert.equal(referencesGhost({ taskId: "t-real-123" }), false);
-});
-
-test("the probe payloads are already canonical — the contract rewrites nothing", () => {
-  // If a probe needed rewriting, it would be testing the contract against itself
-  // rather than against hq.
-  for (const p of buildProbes()) {
-    const sent = wireBodyFor(p.method, p.params);
-    for (const k of Object.keys(p.params)) {
-      assert.ok(k in sent, `${p.method}: probe param ${k} vanished`);
-    }
-    const c = PARAM_CONTRACT[p.method];
-    if (!c || !c.alias) continue;
-    for (const legacy of Object.keys(c.alias)) {
-      if (c.serverAccepts && c.serverAccepts.includes(legacy)) continue;
-      assert.ok(!(legacy in p.params), `${p.method}: probe uses the LEGACY name ${legacy}`);
-    }
-  }
-});
-
-test("every probe payload satisfies what hq requires (no self-inflicted BAD_REQUEST)", () => {
-  for (const p of buildProbes()) {
-    const sent = wireBodyFor(p.method, p.params);
-    const c = PARAM_CONTRACT[p.method];
-    if (!c) continue;
-    const missing = (c.required || []).filter((k) => sent[k] === undefined || sent[k] === "");
-    assert.deepEqual(missing, [], `${p.method} probe omits required ${missing.join(",")}`);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// argv + filtering
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("parseArgs: flags, --only list, --agent-root, and unknown-arg capture", () => {
-  const a = parseArgs(["--write", "--json", "-v", "--only=board, messaging", "--agent-root=/tmp/x"]);
-  assert.equal(a.write, true);
-  assert.equal(a.json, true);
-  assert.equal(a.verbose, true);
-  assert.deepEqual(a.only, ["board", "messaging"]);
-  assert.equal(a.agentRoot, "/tmp/x");
-  assert.deepEqual(a.bad, []);
-  assert.deepEqual(parseArgs(["--nope"]).bad, ["--nope"]);
-  assert.equal(parseArgs([]).write, false, "write is OFF by default");
-});
-
-test("probeSelected: no filter selects everything; a family filter narrows", () => {
-  const p = { method: "board.claim" };
-  assert.equal(probeSelected(p, []), true);
-  assert.equal(probeSelected(p, ["board"]), true);
-  assert.equal(probeSelected(p, ["messaging"]), false);
-  assert.equal(probeSelected(p, ["board.claim"]), true, "an exact method name also selects");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// the runner (injected transport)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("runProbes: row-creating probes are SKIPPED without --write, and never dispatched", async () => {
-  const dispatched = [];
-  const callImpl = async (method) => {
-    dispatched.push(method);
-    return { ok: true, result: {} };
-  };
-  const readImpl = async () => ({ ok: true, payload: {} });
-  const { results } = await runProbes({ base: "https://x", token: "t", callImpl, readImpl });
-
-  const writers = buildProbes().filter((p) => p.writes).map((p) => p.method);
-  assert.ok(writers.length > 0, "there ARE row-creating probes to gate");
-  for (const m of writers) {
-    assert.ok(!dispatched.includes(m), `${m} must not be dispatched without --write`);
-    const row = results.find((r) => r.method === m);
-    assert.equal(row.verdict, "skip");
-    assert.match(row.reason, /--write/);
-  }
-});
-
-test("runProbes: --write dispatches the row-creating probes too", async () => {
-  const dispatched = [];
-  const callImpl = async (method) => {
-    dispatched.push(method);
-    return { ok: true, result: {} };
-  };
-  const readImpl = async () => ({ ok: true, payload: {} });
-  await runProbes({ base: "https://x", token: "t", write: true, callImpl, readImpl });
-  for (const p of buildProbes()) assert.ok(dispatched.includes(p.method), `${p.method} dispatched`);
-});
-
-test("runProbes: a BAD_REQUEST naming an unsent param surfaces as a failure", async () => {
-  // Simulates FUTURE drift: hq starts requiring a name this SDK does not send.
-  // (The historical bug was the mirror image — hq wanted `idempotencyId` while we
-  // sent `clientMsgId` — and the probe would have caught it identically.)
-  const callImpl = async (method) =>
-    method === "messaging.send" ? err("BAD_REQUEST", "conversationId: Required") : { ok: true, result: {} };
-  const readImpl = async () => ({ ok: true, payload: {} });
-  const { failures } = await runProbes({
-    base: "https://x",
-    token: "t",
-    only: ["messaging"],
-    callImpl,
-    readImpl,
-  });
-  assert.equal(failures.length, 1);
-  assert.equal(failures[0].method, "messaging.send");
-});
-
-test("runProbes: NOT_FOUND everywhere is a clean run — that is the expected shape", async () => {
-  const callImpl = async () => err("NOT_FOUND", "no such thing");
-  const readImpl = async () => ({ ok: true, payload: {} });
-  const { failures, results } = await runProbes({ base: "https://x", token: "t", callImpl, readImpl });
-  assert.deepEqual(failures, []);
-  assert.ok(results.every((r) => r.verdict === "skip"));
-});
-
-test("runProbes: a transport throw is contained as a warn, never an unhandled rejection", async () => {
-  const callImpl = async () => {
-    throw new Error("socket hang up");
-  };
-  const readImpl = async () => ({ ok: true, payload: {} });
-  const { results, failures } = await runProbes({
-    base: "https://x",
-    token: "t",
-    only: ["messaging"],
-    callImpl,
-    readImpl,
-  });
-  assert.deepEqual(failures, []);
-  assert.ok(results.every((r) => r.verdict === "warn"));
-});
-
-test("runProbes: a BAD_REQUEST on a GET read path is drift too", async () => {
-  const callImpl = async () => ({ ok: true, result: {} });
-  const readImpl = async (path) =>
-    path === "snapshot" ? { ok: false, error: { code: "BAD_REQUEST", message: "bad" }, status: 400 } : { ok: true, payload: {} };
-  const { reads, failures } = await runProbes({ base: "https://x", token: "t", only: ["reads"], callImpl, readImpl });
-  assert.ok(reads.length >= 12, "every read path probed");
-  assert.equal(failures.length, 1);
-  assert.equal(failures[0].path, "snapshot");
-});
-
-// ---------------------------------------------------------------------------
-// A run that proved nothing must not report success
-// ---------------------------------------------------------------------------
-
-test("UNAUTHORIZED is a CREDENTIAL verdict, never a pass or a skip", () => {
-  // hq returns UNAUTHORIZED for a bad bearer key on every method and every GET
-  // read. It used to sit in SCHEMA_PASSED_CODES, so a rotated/revoked token made
-  // all 36 method probes `skip`, all 12 read paths `pass`, and the run print
-  // "No wire-contract drift." and exit 0 — green forever while probing nothing.
-  const v = classifyFrame(
-    { method: "board.createTask" },
-    {},
-    { ok: false, error: { code: "UNAUTHORIZED", message: "bad key" } },
-  );
-  assert.equal(v.verdict, "credential");
-  assert.match(v.reason, /nothing was tested/i);
-});
-
-test("a genuinely declined handler is still a skip (we did test the schema)", () => {
-  const v = classifyFrame(
-    { method: "board.createTask" },
-    {},
-    { ok: false, error: { code: "NOT_FOUND", message: "no such item" } },
-  );
-  assert.equal(v.verdict, "skip");
-});