@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/setup/sections/verify.test.mjs

@@ -1,175 +0,0 @@
-/**
- * verify.test.mjs — the INIT-pipeline gate in the verify section (SPEC §5.8).
- * Run: node --test lib/setup/sections/verify.test.mjs
- *
- * The four checks that decide whether the plan an agent just compiled is
- * TRUSTWORTHY:
- *   1. it compiles and its obligationsHash matches the compile lock
- *   2. no obligation cites an unreachable capability
- *   3. no OUTCOME rests on an LLM-sourced sensor
- *   4. the mandate cache is fresh (< 24h)
- *
- * All four are SOFT — an un-adopted agent legitimately has no plan and setup must
- * not exit non-zero for that — so the thing under test is that every degradation
- * is NAMED with a remedy rather than passing silently.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import yaml from "js-yaml";
-
-import verifySection, { planChecks, MANDATE_FRESH_MS } from "./verify.mjs";
-import { loadSections } from "../runner.mjs";
-
-const NOW = Date.parse("2026-08-11T12:00:00.000Z");
-
-const MANIFEST = {
-  schemaVersion: 1,
-  entries: [
-    { id: "crm_list_deals", plane: "org", reachable: true },
-    { id: "board_ready", plane: "org", reachable: true },
-    { id: "email_inbox", plane: "org", reachable: false },
-  ],
-};
-
-function planDoc(over = {}) {
-  return {
-    schemaVersion: 1,
-    obligationsHash: "HASH_OK",
-    obligations: [
-      { key: "schedule.measure.pipeline", kind: "SCHEDULE", status: "active", uses: ["crm_list_deals"] },
-      { key: "outcome.pipeline", kind: "OUTCOME", status: "active", uses: ["crm_list_deals"], sensor: { capability: "crm_list_deals", source: "method" } },
-    ],
-    ...over,
-  };
-}
-
-/**
- * A fully injected world. Nothing here touches the real filesystem — the point
- * of the deps seam is that a check can be proven without a scaffolded agent.
- */
-function deps({ plan = planDoc(), manifest = MANIFEST, lock = { obligationsHash: "HASH_OK" }, cache = { fetchedAt: "2026-08-11T09:00:00.000Z" }, planMissing = false } = {}) {
-  return {
-    yaml,
-    existsSync: (p) => (String(p).endsWith("plan.yaml") ? !planMissing : true),
-    readFileSync: (p) => {
-      if (String(p).endsWith("plan.yaml")) return yaml.dump(plan);
-      throw new Error(`unexpected read: ${p}`);
-    },
-    readManifest: () => manifest,
-    readLock: () => lock,
-    readCache: () => cache,
-  };
-}
-
-const byName = (checks, re) => checks.find((c) => re.test(c.name));
-
-test("a healthy plan passes all four checks", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps());
-  assert.ok(checks.every((c) => c.ok), `all ok, got: ${JSON.stringify(checks.filter((c) => !c.ok))}`);
-  assert.ok(byName(checks, /plan compiled/).ok);
-  assert.ok(byName(checks, /obligationsHash/).ok);
-  assert.ok(byName(checks, /unreachable capability/).ok);
-  assert.ok(byName(checks, /method sensor/).ok);
-  assert.ok(byName(checks, /mandate cache fresh/).ok);
-});
-
-test("no plan on disk is SOFT but named — it never fails setup silently", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ planMissing: true }));
-  assert.equal(checks.length, 1);
-  assert.equal(checks[0].ok, true, "an un-adopted agent is a legitimate state");
-  assert.match(checks[0].remedy, /standard \+ archetype cadences only/);
-});
-
-test("a hand-edited plan.yaml is caught by the compile-lock hash", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ lock: { obligationsHash: "SOMETHING_ELSE" } }));
-  const c = byName(checks, /obligationsHash/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /edited by hand|stale/);
-});
-
-test("a missing compile lock is reported, not treated as a pass", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ lock: null }));
-  const c = byName(checks, /obligationsHash/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /no state\/plan\/compile\.lock/);
-});
-
-test("THE LAW: an obligation citing an unreachable capability fails the check", async () => {
-  // email_inbox is reachable:false in the manifest.
-  const plan = planDoc({
-    obligations: [{ key: "schedule.inbox", kind: "SCHEDULE", status: "active", uses: ["crm_list_deals", "email_inbox"] }],
-  });
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ plan }));
-  const c = byName(checks, /unreachable capability/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /schedule\.inbox → email_inbox/);
-});
-
-test("no capability manifest → the reachability law cannot be checked, and says so", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ manifest: null }));
-  const c = byName(checks, /unreachable capability/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /capability-manifest\.json/);
-});
-
-test("an OUTCOME resting on an LLM sensor fails the honesty gate", async () => {
-  const plan = planDoc({
-    obligations: [{ key: "outcome.vibes", kind: "OUTCOME", status: "active", uses: ["crm_list_deals"], sensor: { capability: "crm_list_deals", source: "llm" } }],
-  });
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ plan }));
-  const c = byName(checks, /method sensor/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /outcome\.vibes/);
-  assert.match(c.remedy, /cannot create work/);
-});
-
-test("a stale mandate cache (>24h) fails freshness", async () => {
-  const stale = { fetchedAt: new Date(NOW - MANDATE_FRESH_MS - 60_000).toISOString() };
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ cache: stale }));
-  const c = byName(checks, /mandate cache fresh/);
-  assert.equal(c.ok, false);
-  assert.match(c.remedy, /self-directed work is suspended/);
-});
-
-test("no mandate cache is soft (un-enrolled agent) but still named", async () => {
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, deps({ cache: null }));
-  const c = byName(checks, /mandate cache present/);
-  assert.equal(c.ok, true);
-  assert.match(c.remedy, /no adopted mandate yet/);
-});
-
-test("an unreadable plan.yaml is a reported failure, not a thrown setup", async () => {
-  const d = deps();
-  d.readFileSync = () => "{{{ not yaml :::";
-  const checks = await planChecks({ agentRoot: "/agent", now: NOW }, d);
-  assert.equal(checks[0].ok, false);
-  assert.match(checks[0].remedy, /generate-plan\.mjs/);
-});
-
-test("planChecks is wired into the verify section's rows under section 'plan'", async () => {
-  const rows = [];
-  const res = await verifySection.verify({
-    agentRoot: "/agent",
-    sections: [],
-    planDeps: deps(),
-  }).catch((e) => ({ error: e }));
-  // The core probes (completeness/claude) may legitimately fail on a fake root;
-  // what must hold is that the plan rows are present and attributed.
-  const planRows = ((res && res.rows) || rows).filter((r) => r.section === "plan");
-  assert.ok(planRows.length >= 4, `expected the plan checks in the rows, got ${JSON.stringify((res && res.rows) || []).slice(0, 200)}`);
-  assert.ok(planRows.some((r) => /obligationsHash/.test(r.name)));
-});
-
-test("the verify section is registered by the directory glob at order 90", async () => {
-  const sections = await loadSections();
-  const v = sections.find((s) => s.id === "verify");
-  assert.ok(v, "verify is discovered by loadSections()");
-  assert.equal(v.order, 90);
-  // It must run AFTER the two init-pipeline sections it gates.
-  const inventory = sections.find((s) => s.id === "inventory");
-  const mandate = sections.find((s) => s.id === "mandate");
-  assert.ok(inventory.order < v.order, "inventory (55) precedes verify (90)");
-  assert.ok(mandate.order < v.order, "mandate (78) precedes verify (90)");
-});

package/lib/setup/sot.test.mjs

@@ -1,81 +0,0 @@
-/**
- * sot.test.mjs — single-source-of-truth helper tests (lib/setup/sot.mjs).
- * Covers wrapper generation idempotency + agent.json merge keeping unrelated keys.
- * Run: `node --test lib/setup/sot.test.mjs`
- * @module lib/setup/sot.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  readAgentJson, writeAgentJson, mergeAgentJson, deepMergeByKey,
-  ensureSotWrapper, isWrapper, agentTsPath, WRAPPER_TEMPLATE,
-} from "./sot.mjs";
-
-function tmpRoot() {
-  const r = mkdtempSync(join(tmpdir(), "maestro-sot-"));
-  mkdirSync(join(r, "config"), { recursive: true });
-  return r;
-}
-
-test("readAgentJson returns null when missing, object when present", () => {
-  const root = tmpRoot();
-  assert.equal(readAgentJson(root), null);
-  writeAgentJson(root, { firstName: "Jo" });
-  assert.deepEqual(readAgentJson(root), { firstName: "Jo" });
-});
-
-test("deepMergeByKey preserves unrelated keys and deep-merges objects", () => {
-  const base = { a: 1, nested: { x: 1, y: 2 }, arr: [1, 2] };
-  const patch = { nested: { y: 9, z: 3 }, arr: [3] };
-  const out = deepMergeByKey(base, patch);
-  assert.deepEqual(out, { a: 1, nested: { x: 1, y: 9, z: 3 }, arr: [3] });
-  // inputs not mutated
-  assert.deepEqual(base.nested, { x: 1, y: 2 });
-});
-
-test("mergeAgentJson keeps unrelated fields (split-brain guard)", () => {
-  const root = tmpRoot();
-  writeAgentJson(root, {
-    firstName: "OLD", title: "Role",
-    principal: { fullName: "P One", email: "p@x.com" },
-    responsibilities: ["a"],
-  });
-  mergeAgentJson(root, { firstName: "NEW", principal: { email: "p2@x.com" } });
-  const back = readAgentJson(root);
-  assert.equal(back.firstName, "NEW");
-  assert.equal(back.title, "Role", "unrelated key preserved");
-  assert.equal(back.principal.fullName, "P One", "nested unrelated key preserved");
-  assert.equal(back.principal.email, "p2@x.com", "nested key updated");
-  assert.deepEqual(back.responsibilities, ["a"], "array preserved");
-});
-
-test("isWrapper distinguishes wrapper from standalone literal", () => {
-  assert.equal(isWrapper(WRAPPER_TEMPLATE), true);
-  const standalone = `export const agent = {\n  firstName: 'Ravi',\n} as const;\n`;
-  assert.equal(isWrapper(standalone), false);
-  assert.equal(isWrapper("nonsense"), false);
-});
-
-test("ensureSotWrapper writes wrapper when absent and is idempotent", () => {
-  const root = tmpRoot();
-  const first = ensureSotWrapper(root);
-  assert.equal(first.wrote, true);
-  assert.ok(existsSync(agentTsPath(root)));
-  assert.ok(isWrapper(readFileSync(agentTsPath(root), "utf-8")));
-  const second = ensureSotWrapper(root);
-  assert.equal(second.wrote, false, "second call is a no-op");
-});
-
-test("ensureSotWrapper replaces a standalone literal .ts", () => {
-  const root = tmpRoot();
-  writeFileSync(agentTsPath(root), `export const agent = { firstName: 'Ravi' } as const;\n`);
-  const r = ensureSotWrapper(root);
-  assert.equal(r.wrote, true);
-  assert.ok(isWrapper(readFileSync(agentTsPath(root), "utf-8")));
-});

package/lib/setup/state.test.mjs

@@ -1,115 +0,0 @@
-/**
- * state.test.mjs — checkpoint round-trip / resume tests for lib/setup/state.mjs.
- * Run: `node --test lib/setup/state.test.mjs`
- * @module lib/setup/state.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  loadProgress, saveProgress, markSection, markEnrich, mergeAnswers,
-  hashAnswers, progressPath, emptyProgress,
-} from "./state.mjs";
-
-function tmpRoot() {
-  return mkdtempSync(join(tmpdir(), "maestro-state-"));
-}
-
-test("loadProgress returns empty progress for a fresh root", () => {
-  const root = tmpRoot();
-  const p = loadProgress(root);
-  assert.equal(p.version, 1);
-  assert.deepEqual(p.sections, {});
-  assert.deepEqual(p.answers, {});
-});
-
-test("saveProgress + loadProgress round-trip with atomic write", () => {
-  const root = tmpRoot();
-  const p = emptyProgress();
-  p.answers.firstName = "Jacob";
-  saveProgress(root, p);
-  assert.ok(existsSync(progressPath(root)), "progress.json must exist");
-  const back = loadProgress(root);
-  assert.equal(back.answers.firstName, "Jacob");
-  assert.ok(back.updatedAt, "updatedAt stamped");
-});
-
-test("markSection records status + applied_at and persists", () => {
-  const root = tmpRoot();
-  markSection(root, "identity", { status: "complete", answersHash: "abc123", verify: { ok: true } });
-  const p = loadProgress(root);
-  assert.equal(p.sections.identity.status, "complete");
-  assert.equal(p.sections.identity.answersHash, "abc123");
-  assert.deepEqual(p.sections.identity.verify, { ok: true });
-  assert.ok(p.sections.identity.applied_at);
-});
-
-test("markSection merges durable answers", () => {
-  const root = tmpRoot();
-  markSection(root, "identity", { status: "complete", answers: { firstName: "Mara" } });
-  markSection(root, "company", { status: "complete", answers: { company: "Acme" } });
-  const p = loadProgress(root);
-  assert.equal(p.answers.firstName, "Mara");
-  assert.equal(p.answers.company, "Acme");
-});
-
-test("hashAnswers is order-independent and changes with content", () => {
-  const a = hashAnswers({ x: 1, y: 2 });
-  const b = hashAnswers({ y: 2, x: 1 });
-  const c = hashAnswers({ x: 1, y: 3 });
-  assert.equal(a, b, "key order must not matter");
-  assert.notEqual(a, c, "content change must change hash");
-});
-
-test("markEnrich records ledger entries", () => {
-  const root = tmpRoot();
-  markEnrich(root, "agent.persona", { status: "pending", reason: "llm failed" });
-  const p = loadProgress(root);
-  assert.equal(p.enrich["agent.persona"].status, "pending");
-  assert.equal(p.enrich["agent.persona"].reason, "llm failed");
-});
-
-test("corrupt progress file falls back to empty (never throws)", () => {
-  const root = tmpRoot();
-  mkdirSync(join(root, "state/setup"), { recursive: true });
-  writeFileSync(progressPath(root), "{ not json ");
-  const p = loadProgress(root);
-  assert.deepEqual(p.sections, {});
-});
-
-test("mergeAnswers updates without disturbing sections", () => {
-  const root = tmpRoot();
-  markSection(root, "identity", { status: "complete" });
-  mergeAnswers(root, { tone: "warm" });
-  const p = loadProgress(root);
-  assert.equal(p.answers.tone, "warm");
-  assert.equal(p.sections.identity.status, "complete");
-});
-
-test("redactSecretAnswers recurses: a credential nested under a section bag never reaches progress.json", () => {
-  const root = mkdtempSync(join(tmpdir(), "setup-state-nested-"));
-  try {
-    mergeAnswers(root, {
-      claudeOauthToken: "sk-ant-oat01-FLAT",
-      model: { provider: "oauth-token", oauthToken: "sk-ant-oat01-NESTED", apiKey: "sk-ant-api03-NESTED", routing: false },
-      deep: { a: { b: { apiKey: "sk-deep" } }, keep: "yes" },
-      list: [{ token: "in-a-list" }, "plain"],
-    });
-    const raw = readFileSync(progressPath(root), "utf-8");
-    assert.doesNotMatch(raw, /FLAT|NESTED|sk-deep|in-a-list/, "no credential value on disk at any depth");
-    const p = loadProgress(root);
-    assert.equal(p.answers.model.provider, "oauth-token", "non-secret siblings survive");
-    assert.equal(p.answers.model.routing, false);
-    assert.equal(p.answers.deep.keep, "yes");
-    assert.deepEqual(p.answers.list, [{}, "plain"]);
-    assert.ok(p.answers._redacted.includes("claudeOauthToken"));
-    assert.ok(p.answers._redacted.includes("model.oauthToken"));
-    assert.ok(p.answers._redacted.includes("model.apiKey"));
-    assert.ok(p.answers._redacted.includes("deep.a.b.apiKey"));
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});

package/lib/singleton.test.mjs

@@ -1,151 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, existsSync, rmSync, readFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// singleton.js now resolves the locks dir per call from AGENT_ROOT (then
-// AGENT_DIR, then cwd). Set AGENT_ROOT to a throwaway dir before importing so
-// the default suite operates inside it; individual tests that exercise the
-// AGENT_DIR fallback save/restore the environment themselves.
-const root = mkdtempSync(join(tmpdir(), "maestro-singleton-"));
-process.env.AGENT_ROOT = root;
-delete process.env.AGENT_DIR;
-const { acquireLock, releaseLock, checkLock } = await import("./singleton.js");
-
-const LOCKS = join(root, "state", "locks", "process");
-
-test("first acquire succeeds; second (live holder) is refused", () => {
-  assert.equal(acquireLock("a"), true);
-  // Our own PID is the holder and is alive, so re-acquire must fail.
-  assert.equal(acquireLock("a"), false);
-  releaseLock("a");
-});
-
-test("release frees the lock so it can be re-acquired", () => {
-  assert.equal(acquireLock("b"), true);
-  releaseLock("b");
-  assert.equal(acquireLock("b"), true);
-  releaseLock("b");
-});
-
-test("a stale lock (dead PID) is reclaimed atomically", () => {
-  const pidFile = join(LOCKS, "c.pid");
-  writeFileSync(pidFile, "2147483646"); // effectively never a live PID
-  assert.equal(acquireLock("c"), true);
-  // The reclaimed lock now records our PID on line 1 (identity may follow).
-  assert.equal(readFileSync(pidFile, "utf8").split("\n")[0].trim(), String(process.pid));
-  releaseLock("c");
-});
-
-test("a corrupt lock file is reclaimed", () => {
-  const pidFile = join(LOCKS, "d.pid");
-  writeFileSync(pidFile, "not-a-pid");
-  assert.equal(acquireLock("d"), true);
-  releaseLock("d");
-});
-
-test("acquire writes our own pid into the lock file", () => {
-  assert.equal(acquireLock("e"), true);
-  assert.equal(readFileSync(join(LOCKS, "e.pid"), "utf8").split("\n")[0].trim(), String(process.pid));
-  releaseLock("e");
-  assert.ok(!existsSync(join(LOCKS, "e.pid")));
-});
-
-test("checkLock reports running state for a held lock", () => {
-  assert.equal(acquireLock("f"), true);
-  const status = checkLock("f");
-  assert.equal(status.running, true);
-  assert.equal(status.pid, process.pid);
-  releaseLock("f");
-  assert.equal(checkLock("f").running, false);
-});
-
-// L5/L23: locks dir resolution honours AGENT_DIR when AGENT_ROOT is unset, and
-// is computed per call rather than memoised at import.
-test("locks dir honours AGENT_DIR when AGENT_ROOT is unset", () => {
-  const savedRoot = process.env.AGENT_ROOT;
-  const savedDir = process.env.AGENT_DIR;
-  const altRoot = mkdtempSync(join(tmpdir(), "maestro-singleton-agentdir-"));
-  try {
-    delete process.env.AGENT_ROOT;
-    process.env.AGENT_DIR = altRoot;
-    const altLocks = join(altRoot, "state", "locks", "process");
-
-    // Acquire under AGENT_DIR — the lock file must land under altRoot, proving
-    // per-call resolution picked up AGENT_DIR (not the import-time AGENT_ROOT).
-    assert.equal(acquireLock("agentdir"), true);
-    assert.ok(existsSync(join(altLocks, "agentdir.pid")));
-    // And it must NOT have been written under the original AGENT_ROOT tree.
-    assert.ok(!existsSync(join(LOCKS, "agentdir.pid")));
-    releaseLock("agentdir");
-    assert.ok(!existsSync(join(altLocks, "agentdir.pid")));
-  } finally {
-    if (savedRoot === undefined) delete process.env.AGENT_ROOT;
-    else process.env.AGENT_ROOT = savedRoot;
-    if (savedDir === undefined) delete process.env.AGENT_DIR;
-    else process.env.AGENT_DIR = savedDir;
-    rmSync(altRoot, { recursive: true, force: true });
-  }
-});
-
-// L2: PID-reuse false positive. A lock whose PID is alive (our own PID) but
-// whose recorded identity token does NOT match the real process identity is a
-// recycled PID, and must be reclaimed rather than treated as a live holder.
-test("a stale lock with alive-but-different identity is reclaimed", () => {
-  const pidFile = join(LOCKS, "g.pid");
-  mkdirSync(LOCKS, { recursive: true });
-  // Our own PID (alive) + a bogus identity token that cannot match the real
-  // `ps -o lstart=` start time for this process.
-  writeFileSync(pidFile, `${process.pid}\nBOGUS-IDENTITY-TOKEN-NEVER-MATCHES`);
-
-  // checkLock must see this as not running (identity mismatch -> stale).
-  assert.equal(checkLock("g").running, false);
-
-  // And acquire must succeed by reclaiming the stale lock.
-  writeFileSync(pidFile, `${process.pid}\nBOGUS-IDENTITY-TOKEN-NEVER-MATCHES`);
-  assert.equal(acquireLock("g"), true);
-  // The reclaimed lock now records our PID on line 1.
-  assert.equal(readFileSync(pidFile, "utf8").split("\n")[0].trim(), String(process.pid));
-  releaseLock("g");
-});
-
-// Identity match path: a lock written by acquire (real identity recorded) for
-// our own live PID is correctly treated as a live holder.
-test("a lock with matching identity for a live PID is treated as held", () => {
-  assert.equal(acquireLock("h"), true);
-  // Re-acquire must fail: same PID, identity recomputed and matches.
-  assert.equal(acquireLock("h"), false);
-  assert.equal(checkLock("h").running, true);
-  releaseLock("h");
-});
-
-// Legacy compatibility: an old single-line (PID-only) lock for a live PID is
-// still honoured as a live holder (no worse than historical behaviour).
-test("a legacy pid-only lock for a live PID is honoured", () => {
-  const pidFile = join(LOCKS, "i.pid");
-  mkdirSync(LOCKS, { recursive: true });
-  writeFileSync(pidFile, String(process.pid)); // legacy format, no identity
-  assert.equal(checkLock("i").running, true);
-  // Re-acquire must be refused since the PID is alive and no identity was set.
-  assert.equal(acquireLock("i"), false);
-  rmSync(pidFile, { force: true });
-});
-
-test.after(() => rmSync(root, { recursive: true, force: true }));
-
-test("acquireLock(name, {signals:false}) installs no SIGTERM/SIGINT handlers — the caller owns shutdown; exit cleanup stays", () => {
-  const term = process.listenerCount("SIGTERM");
-  const int = process.listenerCount("SIGINT");
-  const exit = process.listenerCount("exit");
-  assert.equal(acquireLock("owned", { signals: false }), true);
-  assert.equal(process.listenerCount("SIGTERM"), term, "no SIGTERM handler");
-  assert.equal(process.listenerCount("SIGINT"), int, "no SIGINT handler");
-  assert.equal(process.listenerCount("exit"), exit + 1, "the exit cleanup is still registered");
-  releaseLock("owned");
-  // Default behaviour unchanged: signal handlers are installed.
-  assert.equal(acquireLock("default"), true);
-  assert.equal(process.listenerCount("SIGTERM"), term + 1);
-  assert.equal(process.listenerCount("SIGINT"), int + 1);
-  releaseLock("default");
-});