claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-starve-escalation.test.cjs

@@ -1,154 +0,0 @@
-/**
- * scheduler-starve-escalation.test.cjs — the `project_starved` audit event
- * (scheduler.cjs ~line 8888) used to be emit-only: it fired every sweep
- * forever with zero consequence. The 2026-09-12 audit log showed
- * /home/bilko/Projects/Bilko emitting it ~115 times over a 19h starve with
- * nothing acting on it. runStarveEscalationSweep is the bounded, automated
- * consequence: a starve outliving STARVE_ESCALATION_MS gets a DISTINCT
- * 'project_starve_escalated' audit event (once per starve stretch, latched
- * per cwd) plus a toast-channel error via the existing 'schedule:stall'
- * push (already wired to toast.error on the renderer side).
- *
- * Exercises selectStarveEscalations() (pure) directly, and
- * runStarveEscalationSweep() (the side-effecting wrapper) against a real,
- * scratch audit-log.jsonl and a fake attached window — matching
- * pollLoop-dispatch-on-failure.test.cjs's pattern of setting HOME before
- * require() (beforeAll runs AFTER module evaluation) since every state path
- * is baked from os.homedir() at load, and restoring it in afterAll.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-starve-escalation.test.cjs
- */
-
-'use strict';
-
-import { test, beforeEach, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const originalHome = process.env.HOME;
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-escalation-test-'));
-process.env.HOME = tmpHome;
-fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-
-const {
-  selectStarveEscalations,
-  runStarveEscalationSweep,
-  STARVE_ESCALATION_MS,
-  attachWindow,
-} = require('../scheduler.cjs');
-const { auditLogPath } = require('../lib/auditLog.cjs');
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-const CWD_A = '/home/bilko/Projects/Bilko';
-const CWD_B = '/home/bilko/Projects/session-manager';
-
-function readAuditKind(kind) {
-  let lines;
-  try {
-    lines = fs.readFileSync(auditLogPath(), 'utf8').split('\n').filter(Boolean);
-  } catch {
-    return [];
-  }
-  return lines.map((l) => JSON.parse(l)).filter((r) => r.kind === kind);
-}
-
-function fakeWindow() {
-  const sent = [];
-  return {
-    sent,
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      isCrashed: () => false,
-      send: (channel, payload) => sent.push({ channel, payload }),
-    },
-  };
-}
-
-beforeEach(() => {
-  // Fresh scratch audit log per test so escalation counts never bleed across
-  // tests in this file.
-  fs.mkdirSync(path.dirname(auditLogPath()), { recursive: true });
-  fs.writeFileSync(auditLogPath(), '');
-  attachWindow(null);
-});
-
-test('selectStarveEscalations: escalates a row past threshold not already latched', () => {
-  const starved = [{ cwd: CWD_A, pendingCount: 3, oldestPendingSlug: 'x', ageMs: STARVE_ESCALATION_MS + 1 }];
-  const { toEscalate, toClear } = selectStarveEscalations(starved, new Set(), STARVE_ESCALATION_MS);
-  assert.equal(toEscalate.length, 1);
-  assert.equal(toEscalate[0].cwd, CWD_A);
-  assert.deepEqual(toClear, []);
-});
-
-test('selectStarveEscalations: never re-escalates a cwd already latched', () => {
-  const starved = [{ cwd: CWD_A, pendingCount: 3, oldestPendingSlug: 'x', ageMs: STARVE_ESCALATION_MS + 60_000 }];
-  const { toEscalate } = selectStarveEscalations(starved, new Set([CWD_A]), STARVE_ESCALATION_MS);
-  assert.deepEqual(toEscalate, []);
-});
-
-test('selectStarveEscalations: a latched cwd no longer starved is returned for latch-clear', () => {
-  const { toEscalate, toClear } = selectStarveEscalations([], new Set([CWD_A]), STARVE_ESCALATION_MS);
-  assert.deepEqual(toEscalate, []);
-  assert.deepEqual(toClear, [CWD_A]);
-});
-
-test('selectStarveEscalations: below-threshold starve is neither escalated nor cleared', () => {
-  const starved = [{ cwd: CWD_A, pendingCount: 1, oldestPendingSlug: 'x', ageMs: STARVE_ESCALATION_MS - 1 }];
-  const { toEscalate, toClear } = selectStarveEscalations(starved, new Set(), STARVE_ESCALATION_MS);
-  assert.deepEqual(toEscalate, []);
-  assert.deepEqual(toClear, []);
-});
-
-test('runStarveEscalationSweep: emits project_starve_escalated exactly once per starve stretch, plus a toast', () => {
-  const win = fakeWindow();
-  attachWindow(win);
-  const sp = { cwd: CWD_A, pendingCount: 4, oldestPendingSlug: 'oldest-a', ageMs: STARVE_ESCALATION_MS + 60_000 };
-
-  runStarveEscalationSweep([sp]);
-  assert.equal(readAuditKind('project_starve_escalated').length, 1);
-  assert.equal(win.sent.length, 1);
-  assert.equal(win.sent[0].channel, 'schedule:stall');
-  assert.match(win.sent[0].payload.message, /Bilko/);
-
-  const record = readAuditKind('project_starve_escalated')[0];
-  assert.equal(record.cwd, CWD_A);
-  assert.equal(record.pendingCount, 4);
-  assert.equal(record.oldestPendingSlug, 'oldest-a');
-  assert.equal(record.ageMs, sp.ageMs);
-  assert.ok(
-    ['slots-exhausted', 'memory-deferred', 'load-deferred', 'held', 'unknown'].includes(record.holdReason),
-    `unexpected holdReason: ${record.holdReason}`,
-  );
-
-  // Same still-starved stretch on the NEXT sweep must not escalate again.
-  runStarveEscalationSweep([sp]);
-  assert.equal(readAuditKind('project_starve_escalated').length, 1);
-  assert.equal(win.sent.length, 1);
-});
-
-test('runStarveEscalationSweep: the latch resets once the starve clears, so a later stretch escalates again', () => {
-  const win = fakeWindow();
-  attachWindow(win);
-  const sp = { cwd: CWD_B, pendingCount: 2, oldestPendingSlug: 'oldest-b', ageMs: STARVE_ESCALATION_MS + 1 };
-
-  runStarveEscalationSweep([sp]);
-  assert.equal(readAuditKind('project_starve_escalated').length, 1);
-
-  // Starve clears: this cwd is no longer reported by findStarvedProjects at all.
-  runStarveEscalationSweep([]);
-  assert.equal(readAuditKind('project_starve_escalated').length, 1); // no new escalation on a clear pass
-
-  // A NEW starve stretch on the same cwd must escalate again — the latch
-  // must not have been permanently burned by the first stretch.
-  runStarveEscalationSweep([sp]);
-  assert.equal(readAuditKind('project_starve_escalated').length, 2);
-  assert.equal(win.sent.length, 2);
-});

package/src/main/__tests__/scheduler-stranded-autofix-park.test.cjs

@@ -1,252 +0,0 @@
-/**
- * scheduler-stranded-autofix-park.test.cjs — PRD "1218-fo-01 stranded
- * auto-fix park" (2026-09-13, findings filed at session-manager-operations/
- * reviews/2026-09-13-scheduler-stability-investigation.md, "post-run
- * adjudication" section).
- *
- * spawnInvestigation restores a job's status from 'investigating' back to
- * needs_review in ONE mutate() call (scheduler.cjs, source
- * 'spawnInvestigation:onExit') and stamps autoFixOutcome in a SEPARATE,
- * later mutate() call. A crash/restart between the two leaves a row with
- * autoFixAttempted: true and autoFixOutcome permanently undefined —
- * isExhaustedAutoFix wants autoFixRetries >= 1 (never incremented here) and
- * isGuardParkedWithoutAutoFix wants autoFixAttempted === false, so the row
- * falls through every resolving door and the periodic reverify pass just
- * re-scans the same frozen transcript forever. Job 1218-fo-01 sat exactly
- * like this with a landed commit while every dependent PRD waited.
- *
- * This file covers the new isStrandedAutoFixPark predicate and its wiring
- * into isEligibleForNeedsReviewAutoResolve / selectExhaustedNeedsReviewTargets
- * / applyNeedsReviewAutoResolve — the SAME bounded ladder the exhausted-
- * auto-fix and guard-parked doors already use, unchanged.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
- * reason as scheduler-looks-done.test.cjs (appendAuditEvent writes under
- * $HOME/.claude/session-manager/audit-log.jsonl).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-stranded-autofix-park.test.cjs
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'stranded-autofix-park-test-'));
-process.env.HOME = tmpHome;
-
-// Fixture cwd must be a REAL, writable dir: transitionJob out of needs_review
-// fire-and-forgets a history append under <cwd>/session-manager-operations. A fake
-// path made it fail EACCES AFTER the sync test returned, so its console.error hit
-// vitest mid worker-close ("Closing rpc while onUserConsoleLog was pending").
-const PROJECT_CWD = path.join(tmpHome, 'project');
-fs.mkdirSync(PROJECT_CWD, { recursive: true });
-
-const {
-  isStrandedAutoFixPark,
-  isExhaustedAutoFix,
-  isGuardParkedWithoutAutoFix,
-  isEligibleForNeedsReviewAutoResolve,
-  selectExhaustedNeedsReviewTargets,
-  applyNeedsReviewAutoResolve,
-  computeLooksDone,
-  fixSlugFor,
-  NEEDS_REVIEW_RESOLVE_CAP,
-} = require('../scheduler.cjs');
-const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
-const { bustCwdCache } = require('../lib/queueStore.cjs');
-
-const MIN_MS = 60_000;
-const THRESHOLD_MS = 30 * MIN_MS;
-
-// findPrdDir (via resolvePrdsDirs -> allProjectCwds) only discovers a PRD
-// dir under a cwd it already knows about — same registration computeLooksDone
-// needs in scheduler-looks-done.test.cjs / scheduler-guard-verdict-autoresolve.test.cjs.
-function registerActiveProject(cwd, slug) {
-  const slugDir = path.join(tmpHome, '.claude', 'projects', slug);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-  bustCwdCache();
-}
-
-// Replays the live 1218-fo-01 tuple: needs_review, verifierVerdict
-// transcript_errors, exitCode 0, a landed commit, autoFixAttempted true,
-// autoFixOutcome undefined, statusHistory ending in the exact
-// spawnInvestigation:onExit restore reason.
-function strandedJob(overrides = {}) {
-  return {
-    slug: '1218-fo-01-move-scripts-lib-into-src-main-lib',
-    cwd: PROJECT_CWD,
-    status: 'needs_review',
-    exitCode: 0,
-    verifierVerdict: 'transcript_errors',
-    landedCommit: 'd1edf15babc1234',
-    autoFixAttempted: true,
-    statusHistory: [
-      { to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() },
-      { to: 'investigating', at: new Date(Date.now() - 40 * MIN_MS).toISOString(), reason: 'spawning investigation probe' },
-      {
-        to: 'needs_review',
-        at: new Date(Date.now() - 35 * MIN_MS).toISOString(),
-        reason: 'investigation probe exited — restoring prior status',
-      },
-    ],
-    ...overrides,
-  };
-}
-
-// --- isStrandedAutoFixPark ---
-
-test('the 1218 tuple (autoFixAttempted true, autoFixOutcome undefined, no child row) is a stranded auto-fix park', () => {
-  const job = strandedJob();
-  assert.equal(isStrandedAutoFixPark(job, [job]), true);
-  assert.equal(isExhaustedAutoFix(job), false, 'never accumulated a retry — must not double-count as exhausted');
-  assert.equal(isGuardParkedWithoutAutoFix(job), false, 'autoFixAttempted is true — the guard-parked door requires false');
-});
-
-test('autoFixOutcome "error" or "no-plan" with an unspent retry is NOT stranded — selectAutoFixTargets still owns it', () => {
-  // Durably stamped (unlike the 1218 tuple's permanently-unset outcome), so
-  // its one bounded retry (autoFixRetries < 1) is still selectAutoFixTargets's
-  // to spend — pulling it into this ladder instead would race it away from
-  // that retry (see scheduler-needs-review-autoresolve.test.cjs's "a
-  // non-exhausted needs_review row … is left alone").
-  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'error' }), []), false);
-  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'no-plan' }), []), false);
-});
-
-test('autoFixOutcome "plan" is never a stranded park — that is isPlanUnqueued/isFixPlanDead territory', () => {
-  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'plan' }), []), false);
-});
-
-test('a row that never attempted auto-fix at all is not a stranded park', () => {
-  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixAttempted: undefined }), []), false);
-});
-
-test('a row not in needs_review is never a stranded park, whatever its autoFix* fields say', () => {
-  assert.equal(isStrandedAutoFixPark(strandedJob({ status: 'failed' }), []), false);
-});
-
-test('a live fix-plan child (running) means there IS something in flight — not stranded', () => {
-  const job = strandedJob();
-  const child = { slug: fixSlugFor(job), status: 'running' };
-  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
-});
-
-test('a row with a live investigating status (the fix-plan child mid-probe) is NOT selected', () => {
-  const job = strandedJob();
-  const child = { slug: fixSlugFor(job), status: 'investigating' };
-  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
-  assert.equal(selectExhaustedNeedsReviewTargets([job, child], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a queued (pending) fix-plan child also blocks the stranded-park door', () => {
-  const job = strandedJob();
-  const child = { slug: fixSlugFor(job), status: 'pending' };
-  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
-});
-
-test('a DEAD fix-plan child (needs_review/failed/quarantined/skipped) does not block it — nothing left to wait on', () => {
-  const job = strandedJob();
-  for (const deadStatus of ['needs_review', 'failed', 'quarantined', 'skipped']) {
-    const child = { slug: fixSlugFor(job), status: deadStatus };
-    assert.equal(isStrandedAutoFixPark(job, [job, child]), true, `child status ${deadStatus} must not block`);
-  }
-});
-
-test('a COMPLETED fix-plan child does not block it either', () => {
-  const job = strandedJob();
-  const child = { slug: fixSlugFor(job), status: 'completed' };
-  assert.equal(isStrandedAutoFixPark(job, [job, child]), true);
-});
-
-test('isEligibleForNeedsReviewAutoResolve admits the stranded-park door alongside the other two', () => {
-  const job = strandedJob();
-  assert.equal(isEligibleForNeedsReviewAutoResolve(job, [job]), true);
-});
-
-// --- selectExhaustedNeedsReviewTargets: age-gated selection ---
-
-test('a fresh stranded park (under threshold) is not selected', () => {
-  const job = strandedJob({
-    statusHistory: [
-      { to: 'needs_review', at: new Date(Date.now() - 2 * MIN_MS).toISOString(), reason: 'investigation probe exited — restoring prior status' },
-    ],
-  });
-  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a stranded park past NEEDS_REVIEW_RESOLVE_MS, under the cap, IS selected', () => {
-  const job = strandedJob();
-  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, job.slug);
-});
-
-// --- applyNeedsReviewAutoResolve: same bounded ladder, entered via the new door ---
-
-test('computeLooksDone evidence completes the stranded row via the existing looksDone branch', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(tmpHome, 'proj-stranded-'));
-  fs.mkdirSync(projectCwd, { recursive: true });
-  const git = (args) => execFileSync('git', args, { cwd: projectCwd, encoding: 'utf8' });
-  git(['init', '-q']);
-  git(['config', 'user.email', 'test@example.com']);
-  git(['config', 'user.name', 'Test']);
-  fs.writeFileSync(path.join(projectCwd, 'README.md'), 'hello\n');
-  git(['add', '-A']);
-  git(['commit', '-q', '-m', 'initial']);
-  registerActiveProject(projectCwd, path.basename(projectCwd));
-
-  const dir = resolvePrdWriteDir(projectCwd);
-  fs.mkdirSync(dir, { recursive: true });
-  const slug = '1218-fo-01-move-scripts-lib-into-src-main-lib';
-  fs.writeFileSync(
-    path.join(dir, `${slug}.md`),
-    `---\ntitle: Test PRD\ncwd: ${projectCwd}\nestimateMinutes: 30\n---\n# Implementation notes\nEdit \`src/thing.js\`.\n`,
-  );
-
-  const startedAt = new Date(Date.now() - 60 * MIN_MS).toISOString();
-  await new Promise((r) => setTimeout(r, 1100)); // git --since has 1s resolution
-  fs.mkdirSync(path.join(projectCwd, 'src'), { recursive: true });
-  fs.writeFileSync(path.join(projectCwd, 'src', 'thing.js'), 'module.exports = {};\n');
-  git(['add', '-A']);
-  git(['commit', '-q', '-m', `the actual fix for ${slug} landed`]);
-
-  const job = strandedJob({ slug, cwd: projectCwd, startedAt });
-  assert.equal(isStrandedAutoFixPark(job, [job]), true);
-
-  const looksDone = await computeLooksDone(job);
-  assert.ok(looksDone, 'expected computeLooksDone to find the attributable commit');
-  job.looksDone = looksDone;
-
-  const outcome = applyNeedsReviewAutoResolve(job, [job]);
-  assert.equal(outcome, 'completed');
-  assert.equal(job.status, 'completed');
-});
-
-test('with no completion evidence yet, the stranded row gets one bounded requeue, same cap/logic as the other doors', () => {
-  const job = strandedJob({ exhaustedResolveAttempts: 0 });
-  assert.equal(job.looksDone, undefined);
-  const outcome = applyNeedsReviewAutoResolve(job, [job]);
-  assert.equal(outcome, 'requeued');
-  assert.equal(job.status, 'pending');
-  assert.equal(job.exhaustedResolveAttempts, 1);
-});
-
-test('once the cap is spent, the stranded row auto-skips like every other door', () => {
-  const job = strandedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
-  const outcome = applyNeedsReviewAutoResolve(job, [job]);
-  assert.equal(outcome, 'skipped');
-  assert.equal(job.status, 'skipped');
-  assert.equal(job.needsReviewAutoResolvedSkip, true);
-});
-
-test('a live fix-plan child also blocks applyNeedsReviewAutoResolve, not just selection', () => {
-  const job = strandedJob();
-  const child = { slug: fixSlugFor(job), status: 'running' };
-  const outcome = applyNeedsReviewAutoResolve(job, [job, child]);
-  assert.equal(outcome, null, 'nothing to resolve while the fix-plan child is still live');
-  assert.equal(job.status, 'needs_review', 'must stay parked while the child is in flight');
-});

package/src/main/__tests__/scheduler-stranded-investigation.test.cjs

@@ -1,185 +0,0 @@
-/**
- * scheduler-stranded-investigation.test.cjs — findStrandedInvestigations: a
- * job left 'investigating' with nothing to restore it once the process that
- * spawned its probe is gone.
- *
- * spawnInvestigation's own restore (onExit / synchronous-throw catch) runs
- * ONLY inside the live process that spawned the probe. An app restart (or
- * crash) mid-probe leaves the row frozen at 'investigating' forever — the
- * comment at spawnInvestigation's onExit already asserts "'investigating'
- * must never be the job's resting state", but nothing enforced that across a
- * restart. Live repro (burrow, 2026-09-01): 834-session-summary-... sat
- * 'investigating' for 1653 minutes even though finishedAt+exitCode were
- * already recorded 27h earlier.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-stranded-investigation.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { findStrandedInvestigations, INVESTIGATION_MAX_MS } = require('../scheduler.cjs');
-
-const NOW = Date.parse('2026-09-01T12:00:00.000Z');
-const agoMin = (m) => new Date(NOW - m * 60_000).toISOString();
-const neverAlive = () => false;
-const alwaysAlive = () => true;
-
-test('stranded past the window is selected, with the pre-probe status as restoreStatus', () => {
-  const jobs = [
-    {
-      slug: 'a',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [
-        { from: 'failed', to: 'investigating', at: agoMin(120), reason: 'spawning investigation probe' },
-      ],
-    },
-  ];
-  const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive);
-  assert.strictEqual(out.length, 1);
-  assert.strictEqual(out[0].slug, 'a');
-  assert.strictEqual(out[0].restoreStatus, 'failed');
-  assert.ok(out[0].ageMs >= 119 * 60_000);
-});
-
-test('within the window is left alone — a live probe must not be yanked mid-flight', () => {
-  const jobs = [
-    {
-      slug: 'b',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [{ from: 'needs_review', to: 'investigating', at: agoMin(10) }],
-    },
-  ];
-  assert.deepStrictEqual(findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive), []);
-});
-
-test('a live probe process (pid alive) is never restored, even past the window', () => {
-  const jobs = [
-    {
-      slug: 'c',
-      cwd: '/p1',
-      status: 'investigating',
-      runtime: { pid: 4242 },
-      statusHistory: [{ from: 'failed', to: 'investigating', at: agoMin(120) }],
-    },
-  ];
-  assert.deepStrictEqual(findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, alwaysAlive), []);
-});
-
-test('a row with no runtime.pid past the window is still selected (dead-process default)', () => {
-  const jobs = [
-    {
-      slug: 'd',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [{ from: 'failed', to: 'investigating', at: agoMin(120) }],
-    },
-  ];
-  const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, alwaysAlive);
-  assert.strictEqual(out.length, 1);
-  assert.strictEqual(out[0].slug, 'd');
-});
-
-test('missing statusHistory transition is warn-logged and not restored — cannot prove age', () => {
-  const jobs = [{ slug: 'e', cwd: '/p1', status: 'investigating', statusHistory: [] }];
-  const warnSpy = [];
-  const origWarn = console.warn;
-  console.warn = (...args) => warnSpy.push(args.join(' '));
-  try {
-    const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive);
-    assert.deepStrictEqual(out, []);
-    assert.ok(warnSpy.some((line) => line.includes('e') && line.includes('no statusHistory entry')), `expected a warn mentioning slug 'e', got: ${JSON.stringify(warnSpy)}`);
-  } finally {
-    console.warn = origWarn;
-  }
-});
-
-test('unparseable transition timestamp is warn-logged and not restored', () => {
-  const jobs = [
-    {
-      slug: 'f',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [{ from: 'failed', to: 'investigating', at: 'not-a-date' }],
-    },
-  ];
-  const warnSpy = [];
-  const origWarn = console.warn;
-  console.warn = (...args) => warnSpy.push(args.join(' '));
-  try {
-    const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive);
-    assert.deepStrictEqual(out, []);
-    assert.ok(warnSpy.some((line) => line.includes('f') && line.includes('unparseable')), `expected a warn mentioning slug 'f', got: ${JSON.stringify(warnSpy)}`);
-  } finally {
-    console.warn = origWarn;
-  }
-});
-
-test('the burrow-834 shape: finishedAt + non-null exitCode already recorded is restored using that recorded outcome, not re-run', () => {
-  const jobs = [
-    {
-      slug: '834-session-summary-reports-planner-intent-as-outcome',
-      cwd: '/home/bilko/Projects/burrow',
-      status: 'investigating',
-      finishedAt: '2026-08-31T15:13:15.181Z',
-      exitCode: 0,
-      error: 'is_error=true in final 20% of transcript (event 91/101)',
-      estimateMinutes: 60,
-      statusHistory: [
-        { from: 'needs_review', to: 'investigating', at: '2026-08-31T15:20:00.000Z', reason: 'spawning investigation probe' },
-      ],
-    },
-  ];
-  const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive);
-  assert.strictEqual(out.length, 1);
-  assert.strictEqual(out[0].restoreStatus, 'needs_review');
-  assert.ok(out[0].ageMs / 60_000 > 1200, `expected well past the 60m threshold, got ${out[0].ageMs / 60_000}m`);
-});
-
-test('only the most recent investigating transition is used when a job was investigated more than once', () => {
-  const jobs = [
-    {
-      slug: 'g',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [
-        { from: 'failed', to: 'investigating', at: agoMin(500) },
-        { from: 'investigating', to: 'failed', at: agoMin(400) },
-        { from: 'failed', to: 'investigating', at: agoMin(10) }, // recent retry — still within the window
-      ],
-    },
-  ];
-  assert.deepStrictEqual(findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive), []);
-});
-
-test('non-investigating rows are never considered', () => {
-  const base = { cwd: '/p1', statusHistory: [{ from: 'x', to: 'investigating', at: agoMin(500) }] };
-  const jobs = [
-    { ...base, slug: 'h', status: 'failed' },
-    { ...base, slug: 'i', status: 'running' },
-    { ...base, slug: 'j', status: 'needs_review' },
-  ];
-  assert.deepStrictEqual(findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive), []);
-});
-
-test('a corrupted/illegal statusHistory `from` value falls back to failed rather than being handed to transitionJob unvalidated', () => {
-  const jobs = [
-    {
-      slug: 'k',
-      cwd: '/p1',
-      status: 'investigating',
-      statusHistory: [{ from: 'quarantined', to: 'investigating', at: agoMin(120) }],
-    },
-  ];
-  const out = findStrandedInvestigations(jobs, NOW, INVESTIGATION_MAX_MS, neverAlive);
-  assert.strictEqual(out.length, 1);
-  assert.strictEqual(out[0].restoreStatus, 'failed');
-});
-
-test('the shipped default is the documented one (60 minutes)', () => {
-  assert.strictEqual(INVESTIGATION_MAX_MS, 60 * 60_000);
-});