@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/resource-governor.test.mjs

@@ -1,488 +0,0 @@
-/**
- * resource-governor.test.mjs — node:test coverage for the admission gate.
- *
- * Every test injects a full `deps` snapshot so admit() is a pure, deterministic
- * function — no real os.* reads, no ps fork. We exercise each decision branch
- * (ADMIT / QUEUE / DEFER), the dynamicMax sizing across 8/16/32GB boxes, the
- * throttle-ceiling clamp, and essential-only mode.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { writeFileSync } from "node:fs";
-import { tmpdir, freemem as osFreemem, totalmem as totalmemBytes } from "node:os";
-import { join } from "node:path";
-
-import {
-  admit,
-  dynamicMax,
-  readThrottle,
-  PER_SESSION_MB,
-  RAM_FRACTION,
-  DECISIONS,
-  availableMemoryBytes,
-  FREEMEM_FLOOR_FRACTION,
-  etimeToMs,
-  reapStaleClaude,
-  REACTIVE_INFLIGHT_BACKLOG_MAX,
-} from "./resource-governor.mjs";
-
-test("availableMemoryBytes counts reclaimable pages, not just free ones", () => {
-  const bytes = availableMemoryBytes();
-  assert.ok(Number.isFinite(bytes) && bytes > 0, "always a usable number");
-
-  if (process.platform !== "darwin") {
-    assert.equal(bytes, osFreemem(), "non-Darwin defers to os.freemem()");
-    return;
-  }
-
-  // The regression: os.freemem() on macOS reports only "Pages free", which sits
-  // near zero on any warm box and pinned the governor at DEFER. Availability must
-  // include the inactive/speculative/purgeable pages macOS reclaims on demand,
-  // so it is always >= the raw reading and should clear the floor on an idle host.
-  assert.ok(bytes >= osFreemem(), "availability is never below raw free memory");
-  const floor = totalmemBytes() * FREEMEM_FLOOR_FRACTION;
-  assert.ok(bytes > floor, `an idle Mac must clear its own floor (${bytes} vs ${floor})`);
-});
-
-const GB = 1024 * 1024 * 1024;
-const MB = 1024 * 1024;
-
-/**
- * Build a healthy baseline deps snapshot for an N-GB / C-cpu box with `live`
- * sessions already running and `liveRssMB` total. Override any field.
- */
-function deps(over = {}) {
-  const totalmem = over.totalmem ?? 16 * GB;
-  return {
-    totalmem,
-    freemem: over.freemem ?? totalmem * 0.5, // plenty free
-    loadavg: over.loadavg ?? [0.5, 0.5, 0.5],
-    cpus: over.cpus ?? 8,
-    liveClaude: over.liveClaude ?? { count: 0, rssMB: 0 },
-    throttleCeiling: over.throttleCeiling ?? Infinity,
-    ...over,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// dynamicMax sizing
-// ---------------------------------------------------------------------------
-
-test("dynamicMax sizes by RAM, clamped to min(HARD_MAX, cpus)", () => {
-  // HARD_MAX is 7 (generous; runtime guards + stale-reaping keep it safe).
-  // 4GB: byRam=floor(4*0.6/0.75)=3 → RAM-bound, below HARD_MAX → 3.
-  assert.equal(dynamicMax({ totalmem: 4 * GB, cpus: 8 }), 3);
-  // 8GB: byRam=floor(8*0.6/0.75)=6 → RAM-bound, below HARD_MAX → 6.
-  assert.equal(dynamicMax({ totalmem: 8 * GB, cpus: 8 }), 6);
-  // 16GB with 16 cpus: byRam=12 → clamp to min(7,16)=7 (HARD_MAX-bound).
-  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 16 }), 7);
-  // cpu-bound below HARD_MAX: 16GB with 2 cpus → min(7,2)=2.
-  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 2 }), 2);
-  // Tiny box always yields at least 1.
-  assert.equal(dynamicMax({ totalmem: 1 * GB, cpus: 1 }), 1);
-});
-
-test("dynamicMax never returns 0 even on a starved box", () => {
-  assert.ok(dynamicMax({ totalmem: 512 * MB, cpus: 2 }) >= 1);
-});
-
-// ---------------------------------------------------------------------------
-// ADMIT
-// ---------------------------------------------------------------------------
-
-test("admit: healthy box with spare capacity → ADMIT", () => {
-  const r = admit({ source: "backlog" }, deps());
-  assert.equal(r.decision, DECISIONS.ADMIT);
-  assert.equal(r.snapshot.dynamicMax, 7);
-  assert.equal(r.snapshot.effectiveMax, 7);
-});
-
-test("admit: inbox on a healthy box → ADMIT", () => {
-  const r = admit({ source: "inbox", priority: "high" }, deps());
-  assert.equal(r.decision, DECISIONS.ADMIT);
-});
-
-// ---------------------------------------------------------------------------
-// QUEUE — concurrency ceiling
-// ---------------------------------------------------------------------------
-
-test("admit: backlog stops REACTIVE_RESERVE slots short of the ceiling → QUEUE", () => {
-  // effectiveMax = 7; self-directed backlog may use effectiveMax - REACTIVE_RESERVE(2)
-  // = 5. With 5 already live, backlog QUEUEs — holding 2 slots for the inbox so a
-  // reply can always be GENERATED (subscription + host headroom, not just a slot).
-  const r = admit({ source: "backlog" }, deps({ liveClaude: { count: 5, rssMB: 1200 } }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.match(r.reason, /yields 2 slots to the inbox/);
-});
-
-test("admit: inbox may use the whole envelope; the reactive reserve is for it", () => {
-  // 5 live (backlog's reserved cap) but INBOX still ADMITs — the reserve is its.
-  assert.equal(
-    admit({ source: "inbox" }, deps({ liveClaude: { count: 5, rssMB: 1200 } })).decision,
-    DECISIONS.ADMIT,
-  );
-  // Only at the full envelope (effectiveMax=7 live) does even the inbox QUEUE.
-  const r = admit({ source: "inbox" }, deps({ liveClaude: { count: 7, rssMB: 1800 } }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.match(r.reason, /concurrency ceiling/);
-});
-
-// ---------------------------------------------------------------------------
-// Reactive-in-flight: backlog yields the SUBSCRIPTION (not just a slot) to a
-// human/peer reply that is actively generating.
-// ---------------------------------------------------------------------------
-
-test("admit: while a reactive turn is in flight, backlog is capped to REACTIVE_INFLIGHT_BACKLOG_MAX → QUEUE", () => {
-  // Default cap is 1. With reactiveInFlight and even a single backlog session
-  // live, a second backlog spawn QUEUEs — the subscription is left to the reply.
-  assert.equal(REACTIVE_INFLIGHT_BACKLOG_MAX, 1);
-  const r = admit(
-    { source: "backlog" },
-    deps({ reactiveInFlight: 1, liveClaude: { count: 1, rssMB: 300 } }),
-  );
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.match(r.reason, /reactive turn in flight/);
-});
-
-test("admit: reactive-in-flight cap is HARDER than the steady-state reserve", () => {
-  // With 3 live and NO reactive turn, backlog still ADMITs (reserve leaves 5).
-  assert.equal(
-    admit({ source: "backlog" }, deps({ liveClaude: { count: 3, rssMB: 900 } })).decision,
-    DECISIONS.ADMIT,
-  );
-  // The SAME 3 live but a reply generating → QUEUE (cap 1, already exceeded).
-  assert.equal(
-    admit({ source: "backlog" }, deps({ reactiveInFlight: 1, liveClaude: { count: 3, rssMB: 900 } })).decision,
-    DECISIONS.QUEUE,
-  );
-});
-
-test("admit: a human reply is NEVER gated by reactive-in-flight (it IS the reactive turn)", () => {
-  // inbox/humanReply keeps the whole envelope even while other reactive turns run.
-  assert.equal(
-    admit({ source: "inbox" }, deps({ reactiveInFlight: 2, liveClaude: { count: 4, rssMB: 1200 } })).decision,
-    DECISIONS.ADMIT,
-  );
-  assert.equal(
-    admit({ source: "backlog", humanReply: true }, deps({ reactiveInFlight: 2, liveClaude: { count: 4, rssMB: 1200 } })).decision,
-    DECISIONS.ADMIT,
-  );
-});
-
-test("admit: one backlog session is still allowed alongside a reply (cap 1, not 0)", () => {
-  // A single trickle of backlog is fine — the cap is 1, so with 0 live it ADMITs.
-  const r = admit(
-    { source: "backlog" },
-    deps({ reactiveInFlight: 1, liveClaude: { count: 0, rssMB: 0 } }),
-  );
-  assert.equal(r.decision, DECISIONS.ADMIT);
-});
-
-// ---------------------------------------------------------------------------
-// Usage-window pacing (default-off; driven by req.windowBand from budget-guard)
-// ---------------------------------------------------------------------------
-
-test("admit: windowBand 'at' DEFERS self-directed work; a human reply is never paced", () => {
-  assert.equal(admit({ source: "backlog", windowBand: "at" }, deps()).decision, DECISIONS.DEFER);
-  assert.equal(admit({ source: "cadence", windowBand: "at" }, deps()).decision, DECISIONS.DEFER);
-  // inbox / humanReply continue at the window limit
-  assert.equal(admit({ source: "inbox", windowBand: "at" }, deps()).decision, DECISIONS.ADMIT);
-  assert.equal(admit({ source: "backlog", humanReply: true, windowBand: "at" }, deps()).decision, DECISIONS.ADMIT);
-});
-
-test("admit: windowBand 'approaching' throttles backlog to a trickle (QUEUE), inbox unaffected", () => {
-  // 1 already live → backlog capped to REACTIVE_INFLIGHT_BACKLOG_MAX(1) → QUEUE
-  const r = admit({ source: "backlog", windowBand: "approaching" }, deps({ liveClaude: { count: 1, rssMB: 300 } }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.match(r.reason, /usage window approaching/);
-  // inbox still admits at the same live count
-  assert.equal(admit({ source: "inbox", windowBand: "approaching" }, deps({ liveClaude: { count: 1, rssMB: 300 } })).decision, DECISIONS.ADMIT);
-});
-
-test("admit: windowBand default (undefined/'ok') changes nothing — pacing is off by default", () => {
-  // 3 live, no window signal → backlog still ADMITs (reserve leaves 5)
-  assert.equal(admit({ source: "backlog" }, deps({ liveClaude: { count: 3, rssMB: 900 } })).decision, DECISIONS.ADMIT);
-  assert.equal(admit({ source: "backlog", windowBand: "ok" }, deps({ liveClaude: { count: 3, rssMB: 900 } })).decision, DECISIONS.ADMIT);
-});
-
-test("admit: throttle ceiling clamps effectiveMax below dynamicMax → QUEUE earlier", () => {
-  // dynamicMax 8 but soft-throttle pinned the ceiling to 3; 3 live → QUEUE.
-  const r = admit({ source: "backlog" }, deps({ throttleCeiling: 3, liveClaude: { count: 3, rssMB: 1000 } }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.equal(r.snapshot.effectiveMax, 3);
-  assert.match(r.reason, /soft-throttle/);
-});
-
-// ---------------------------------------------------------------------------
-// QUEUE — projected RSS
-// ---------------------------------------------------------------------------
-
-test("admit: projected RSS over the RAM fraction → QUEUE", () => {
-  // 16GB → RAM fraction cap = 16*0.6*1024 ≈ 9830MB. Live RSS 9500MB + 750 > cap.
-  // Keep count below the reserved backlog ceiling (2) so concurrency passes and
-  // RSS is the trigger.
-  const r = admit({ source: "backlog" }, deps({
-    liveClaude: { count: 1, rssMB: 9500 },
-    freemem: 16 * GB * 0.5,
-  }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-  assert.match(r.reason, /projected RSS/);
-});
-
-// ---------------------------------------------------------------------------
-// DEFER — free memory
-// ---------------------------------------------------------------------------
-
-test("admit: free memory below the 15% floor → DEFER", () => {
-  const r = admit({ source: "backlog" }, deps({ freemem: 16 * GB * 0.10 }));
-  assert.equal(r.decision, DECISIONS.DEFER);
-  assert.match(r.reason, /low free memory/);
-});
-
-test("admit: free memory below the 2-session absolute headroom → DEFER", () => {
-  // Big box where 15% is generous, but absolute free < 2*750MB = 1500MB.
-  const r = admit({ source: "backlog" }, deps({ totalmem: 64 * GB, freemem: 1000 * MB }));
-  assert.equal(r.decision, DECISIONS.DEFER);
-  assert.match(r.reason, /low free memory/);
-});
-
-// ---------------------------------------------------------------------------
-// DEFER — load average
-// ---------------------------------------------------------------------------
-
-test("admit: 1-minute load above cpus*1.5 → DEFER", () => {
-  // cpus=8 → threshold 12. load 13 → DEFER. Keep memory healthy.
-  const r = admit({ source: "backlog" }, deps({ loadavg: [13, 5, 5] }));
-  assert.equal(r.decision, DECISIONS.DEFER);
-  assert.match(r.reason, /load too high/);
-});
-
-test("admit: load exactly at the threshold is still ADMIT (strict >)", () => {
-  const r = admit({ source: "backlog" }, deps({ loadavg: [12, 1, 1], cpus: 8 }));
-  assert.equal(r.decision, DECISIONS.ADMIT);
-});
-
-// ---------------------------------------------------------------------------
-// essential-only mode
-// ---------------------------------------------------------------------------
-
-test("essential-only: backlog → DEFER without burning resources", () => {
-  // The legacy mode name still maps onto the SUSPENDED rung — same behaviour it
-  // always had, so no caller loses its gate during the rollout.
-  const r = admit({ source: "backlog", mode: "essential-only" }, deps());
-  assert.equal(r.decision, DECISIONS.DEFER);
-  assert.match(r.reason, /budget suspended/);
-});
-
-test("essential-only: cadence → DEFER", () => {
-  const r = admit({ source: "cadence", mode: "essential-only" }, deps());
-  assert.equal(r.decision, DECISIONS.DEFER);
-});
-
-test("essential-only: inbox still flows through normal gating (ADMIT when healthy)", () => {
-  const r = admit({ source: "inbox", mode: "essential-only" }, deps());
-  assert.equal(r.decision, DECISIONS.ADMIT, "inbox must keep replying even at budget cap");
-});
-
-test("essential-only: inbox still QUEUEs (not DEFERs) under concurrency pressure", () => {
-  const r = admit({ source: "inbox", mode: "essential-only" }, deps({ liveClaude: { count: 8, rssMB: 2000 } }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-});
-
-// ---------------------------------------------------------------------------
-// precedence — ceiling QUEUE beats memory DEFER? No: budget→ceiling→mem→load→rss.
-// Verify the documented order is honoured.
-// ---------------------------------------------------------------------------
-
-test("decision precedence: essential-only beats everything for backlog", () => {
-  // Even with a healthy box, essential-only short-circuits to DEFER.
-  const r = admit({ source: "backlog", mode: "essential-only" }, deps({ liveClaude: { count: 0, rssMB: 0 } }));
-  assert.equal(r.decision, DECISIONS.DEFER);
-});
-
-test("decision precedence: concurrency QUEUE is checked before memory DEFER", () => {
-  // At ceiling AND low memory → spec orders ceiling first → QUEUE.
-  const r = admit({ source: "backlog" }, deps({
-    liveClaude: { count: 8, rssMB: 1000 },
-    freemem: 16 * GB * 0.05,
-  }));
-  assert.equal(r.decision, DECISIONS.QUEUE);
-});
-
-// ---------------------------------------------------------------------------
-// readThrottle — auto-expiry
-// ---------------------------------------------------------------------------
-
-test("readThrottle returns Infinity when no file present", async () => {
-  const dir = join(tmpdir(), `gov-throttle-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(join(dir, "state"), { recursive: true });
-  try {
-    assert.equal(readThrottle({ agentRoot: dir }).ceiling, Infinity);
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});
-
-test("readThrottle honours ceiling while unexpired, ignores once expired", async () => {
-  const dir = join(tmpdir(), `gov-throttle2-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(join(dir, "state"), { recursive: true });
-  try {
-    const now = 1_000_000;
-    writeFileSync(join(dir, "state", "throttle.json"), JSON.stringify({
-      ceiling: 2, reason: "SOFT", set_at: now - 1000, expires_at: now + 60_000,
-    }));
-    // Unexpired → ceiling honoured.
-    assert.equal(readThrottle({ agentRoot: dir, now: () => now }).ceiling, 2);
-    // After expiry → ignored.
-    assert.equal(readThrottle({ agentRoot: dir, now: () => now + 120_000 }).ceiling, Infinity);
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});
-
-test("governor reads the EXACT throttle.json byte-shape the watchdog SOFT tier writes", async () => {
-  // This is the contract between scripts/watchdog/memory-watchdog.sh (writer)
-  // and the governor (reader). The watchdog writes ceiling + reason + EPOCH-MS
-  // set_at/expires_at. If either side drifts, throttling silently no-ops — so
-  // pin the shape here.
-  const dir = join(tmpdir(), `gov-wd-shape-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(join(dir, "state"), { recursive: true });
-  try {
-    const nowSec = 1_700_000_000;          // arbitrary epoch seconds
-    const setMs = nowSec * 1000;
-    const expMs = (nowSec + 300) * 1000;   // THROTTLE_TTL_SECONDS = 300
-    // Byte-for-byte the printf in write_throttle():
-    writeFileSync(join(dir, "state", "throttle.json"),
-      `{"ceiling":3,"reason":"soft-tier","set_at":${setMs},"expires_at":${expMs}}\n`);
-
-    // While unexpired → ceiling honoured.
-    const t1 = readThrottle({ agentRoot: dir, now: () => setMs + 1000 });
-    assert.equal(t1.ceiling, 3);
-    assert.equal(t1.reason, "soft-tier");
-    // After TTL → ignored (governor auto-expires even if the watchdog died).
-    const t2 = readThrottle({ agentRoot: dir, now: () => expMs + 1 });
-    assert.equal(t2.ceiling, Infinity);
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});
-
-test("admit reads a real throttle.json from agentRoot and clamps", async () => {
-  const dir = join(tmpdir(), `gov-throttle3-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(join(dir, "state"), { recursive: true });
-  try {
-    const now = 2_000_000;
-    writeFileSync(join(dir, "state", "throttle.json"), JSON.stringify({
-      ceiling: 1, reason: "SOFT", expires_at: now + 60_000,
-    }));
-    // Build a deps snapshot that reads the throttle file: pass throttleCeiling
-    // from readThrottle so the integration is exercised end-to-end.
-    const t = readThrottle({ agentRoot: dir, now: () => now });
-    const r = admit({ source: "backlog" }, deps({ throttleCeiling: t.ceiling, liveClaude: { count: 1, rssMB: 500 } }));
-    assert.equal(r.snapshot.effectiveMax, 1);
-    assert.equal(r.decision, DECISIONS.QUEUE);
-  } finally { await fsp.rm(dir, { recursive: true, force: true }); }
-});
-
-// ---------------------------------------------------------------------------
-// the budget ladder (banded against the seat's hq-funded envelope)
-// ---------------------------------------------------------------------------
-
-test("degraded (>=100%): self-directed backlog is THROTTLED (not stopped), obligations + inbox continue", () => {
-  // Owner instruction (2026-08-25): throttle, don't stop. A degraded/unfunded seat
-  // runs DEGRADED_BACKLOG_MAX(1) backlog in idle gaps — with the box idle it ADMITs
-  // one so autonomous progress keeps ticking...
-  assert.equal(
-    admit({ source: "backlog", mode: "degraded" }, deps({ liveClaude: { count: 0, rssMB: 0 } })).decision,
-    "ADMIT",
-  );
-  // ...but with anything already live it QUEUEs — a trickle, never a flood.
-  const r = admit({ source: "backlog", mode: "degraded" }, deps({ liveClaude: { count: 1, rssMB: 300 } }));
-  assert.equal(r.decision, "QUEUE");
-  assert.match(r.reason, /throttled/);
-  // An obligation is not discretionary — it degrades, it does not stop.
-  assert.equal(admit({ source: "cadence", mode: "degraded" }, deps()).decision, "ADMIT",
-    "an obligation is not discretionary — it degrades, it does not stop");
-  assert.equal(admit({ source: "inbox", mode: "degraded" }, deps()).decision, "ADMIT");
-});
-
-test("suspended (>=125%): backlog + cadence DEFER, inbox continues", () => {
-  assert.equal(admit({ source: "backlog", mode: "suspended" }, deps()).decision, "DEFER");
-  assert.equal(admit({ source: "cadence", mode: "suspended" }, deps()).decision, "DEFER");
-  assert.equal(admit({ source: "inbox", mode: "suspended" }, deps()).decision, "ADMIT");
-});
-
-test("refused (>150%): everything that is not a human reply DEFERs — and it DEFERs, never refuses", () => {
-  for (const source of ["backlog", "cadence", "sweep"]) {
-    const r = admit({ source, mode: "refused" }, deps());
-    assert.equal(r.decision, "DEFER", `${source} must defer`);
-    assert.match(r.reason, /direct human replies continue/);
-  }
-  // The one thing no band may stop.
-  assert.equal(admit({ source: "inbox", mode: "refused" }, deps()).decision, "ADMIT");
-  assert.equal(admit({ source: "cadence", mode: "refused", humanReply: true }, deps()).decision, "ADMIT",
-    "an explicit human reply is admitted whatever its source");
-  // DEFER leaves the work on disk for the sweep; nothing is dropped, and the
-  // seat is never bricked (Invariant #1).
-  assert.notEqual(admit({ source: "backlog", mode: "refused" }, deps()).decision, "REFUSE");
-});
-
-test("an unrecognised budget mode is treated as normal, never as something stricter", () => {
-  assert.equal(admit({ source: "backlog", mode: "catastrophic" }, deps()).decision, "ADMIT");
-  assert.equal(admit({ source: "backlog", mode: "normal" }, deps()).decision, "ADMIT");
-});
-
-// ---------------------------------------------------------------------------
-// Stale-session accounting + reaping (idle lanes must not count / self-clean)
-// ---------------------------------------------------------------------------
-
-test("etimeToMs parses ps elapsed-time in all three shapes", () => {
-  assert.equal(etimeToMs("05:20"), (5 * 60 + 20) * 1000);            // MM:SS
-  assert.equal(etimeToMs("07:05:20"), (7 * 3600 + 5 * 60 + 20) * 1000); // HH:MM:SS
-  assert.equal(etimeToMs("08-07:05:20"), (8 * 86400 + 7 * 3600 + 5 * 60 + 20) * 1000); // DD-HH:MM:SS
-  assert.equal(etimeToMs("garbage"), 0); // fail-safe: unparseable → young
-  assert.equal(etimeToMs(""), 0);
-});
-
-test("reapStaleClaude kills ONLY daemon --print sessions for this agent — never a human's interactive session", () => {
-  const AR = "/Users/x/isla";
-  const ps = [
-    `  100 08-07:05:20 /usr/local/bin/claude --print --dangerously-skip-permissions --mcp-config ${AR}/.mcp.json old`, // daemon, 8d → reap
-    `  200 00:30 claude --print --mcp-config ${AR}/.mcp.json young`,      // daemon, 30s → keep (young)
-    `  300 50:00 claude --print --mcp-config ${AR}/.mcp.json wedged`,     // daemon, 50m → reap
-    "  310 90:00 claude --dangerously-skip-permissions --resume",         // HUMAN interactive (no --print) → NEVER reap
-    "  315 99:00 claude",                                                 // HUMAN interactive → NEVER reap
-    "  320 99:00 claude --print --mcp-config /Users/x/OTHER/.mcp.json x", // a DIFFERENT agent → not this root → keep
-    "  400 90:00 node scripts/daemon/maestro-daemon.mjs",                 // not claude → skip
-    "  500 46:00 Claude Helper (Renderer)",                              // helper → skip
-    "    1 99-00:00:00 launchd",                                         // pid 1 → skip
-  ].join("\n");
-  const killed = [];
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 45 * 60_000, agentRoot: AR });
-  assert.deepEqual(r.reaped.sort((a, b) => a - b), [100, 300]);
-  assert.deepEqual(killed.sort((a, b) => a - b), [100, 300]);
-  assert.equal(r.errors, 0);
-});
-
-test("reapStaleClaude never touches an interactive Claude Code session even when very old", () => {
-  const AR = "/Users/x/isla";
-  // A human's `claude --resume` running for 8 DAYS — must survive (no --print).
-  const ps = `  777 08-00:00:00 claude --dangerously-skip-permissions --resume\n`;
-  const killed = [];
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 45 * 60_000, agentRoot: AR });
-  assert.deepEqual(r.reaped, []);
-  assert.deepEqual(killed, []);
-});
-
-test("reapStaleClaude is a no-op when reaping is disabled (reapMs=0)", () => {
-  const AR = "/Users/x/isla";
-  const ps = `  100 08-07:05:20 claude --print --mcp-config ${AR}/.mcp.json old\n`;
-  const killed = [];
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: (p) => killed.push(p), reapMs: 0, agentRoot: AR });
-  assert.deepEqual(r.reaped, []);
-  assert.deepEqual(killed, []);
-});
-
-test("reapStaleClaude counts kill failures without throwing", () => {
-  const AR = "/Users/x/isla";
-  const ps = `  100 08-07:05:20 claude --print --mcp-config ${AR}/.mcp.json old\n`;
-  const r = reapStaleClaude({ psImpl: () => ps, killImpl: () => { throw new Error("ESRCH"); }, reapMs: 60_000, agentRoot: AR });
-  assert.deepEqual(r.reaped, []);
-  assert.equal(r.errors, 1);
-});