claude-code-session-manager 0.86.0 → 0.88.0

package/src/main/__tests__/scheduleJobTransitions.test.cjs

@@ -6,7 +6,7 @@
  */
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
 const fs = require('node:fs');
 const crypto = require('node:crypto');
 const {
@@ -17,14 +17,15 @@ const {
   _resetRefusedTransitionCountForTests,
 } = require('../lib/scheduleJobTransitions.cjs');
 const auditLog = require('../lib/auditLog.cjs');
+const queueHistory = require('../lib/queueHistory.cjs');
 
 function uniqueSlug(label) {
   return `test-${label}-${crypto.randomUUID().slice(0, 8)}`;
 }
 
 function readAuditRecordsForSlug(slug) {
-  if (!fs.existsSync(auditLog.AUDIT_LOG_PATH)) return [];
-  return fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
+  if (!fs.existsSync(auditLog.auditLogPath())) return [];
+  return fs.readFileSync(auditLog.auditLogPath(), 'utf8')
     .split('\n')
     .filter(Boolean)
     .map((line) => {
@@ -175,3 +176,102 @@ test('_resetRefusedTransitionCountForTests resets the counter', () => {
   _resetRefusedTransitionCountForTests();
   expect(getRefusedTransitionCount()).toBe(0);
 });
+
+// ---------- needs_review ledger (PRD: needs_review durability) ----------
+//
+// transitionJob is the ONE place every needs_review entry/resolution is
+// decided (this file's own header comment) — these tests exercise that
+// hook directly rather than going through scheduler.cjs's many call sites.
+// queueHistory.appendHistory is mocked so these tests never touch disk or
+// race its own fire-and-forget promise; queueHistory.test.cjs already
+// covers appendHistory's real I/O.
+
+let appendHistorySpy;
+
+beforeEach(() => {
+  appendHistorySpy = vi.spyOn(queueHistory, 'appendHistory').mockResolvedValue({ appended: 1 });
+});
+
+afterEach(() => {
+  appendHistorySpy.mockRestore();
+});
+
+test('needs_review entry: transitioning INTO needs_review appends a kind:needs_review_entry ledger line', () => {
+  const slug = uniqueSlug('nr-entry');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-abc', verifierVerdict: 'uncommitted_changes' };
+
+  transitionJob(job, 'needs_review', { reason: 'finish protocol incomplete', source: 'spawnJob:finalize' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(1);
+  const [lines] = appendHistorySpy.mock.calls[0];
+  expect(lines).toHaveLength(1);
+  expect(lines[0]).toMatchObject({
+    kind: 'needs_review_entry',
+    slug,
+    cwd: '/tmp/proj',
+    runId: 'run-abc',
+    reason: 'uncommitted_changes',
+    source: 'spawnJob:finalize',
+  });
+  expect(typeof lines[0].at).toBe('string');
+  // Episode bookkeeping stamped on the job so a later resolution can
+  // reference this SAME runId even if job.runId is reassigned meanwhile.
+  expect(job.needsReviewEntryRunId).toBe('run-abc');
+  expect(job.needsReviewEnteredAt).toBe(lines[0].at);
+});
+
+test('needs_review resolution: transitioning OUT of needs_review appends a paired line referencing the ENTRY runId, with dwellMs', () => {
+  const slug = uniqueSlug('nr-resolve');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-1' };
+
+  transitionJob(job, 'needs_review', { reason: 'park', source: 'spawnJob:finalize' });
+  const enteredAt = job.needsReviewEnteredAt;
+
+  // A resume-recovery re-dispatch (or any later attempt) mints a FRESH runId
+  // before this episode resolves — the resolution must still reference the
+  // ENTRY's runId, not whatever the job carries now.
+  job.runId = 'run-2';
+  transitionJob(job, 'completed', { reason: 'boot reverify: stale needs_review healed', source: 'reverifyNeedsReview:heal' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(2);
+  const [resolutionLines] = appendHistorySpy.mock.calls[1];
+  expect(resolutionLines).toHaveLength(1);
+  const resolution = resolutionLines[0];
+  expect(resolution.kind).toBe('needs_review_resolution');
+  expect(resolution.runId).toBe('run-1'); // the ENTRY's runId
+  expect(resolution.resolvedTo).toBe('completed');
+  expect(resolution.ladderRung).toBe('reverify');
+  expect(typeof resolution.dwellMs).toBe('number');
+  expect(resolution.dwellMs).toBeGreaterThanOrEqual(0);
+  expect(Date.parse(enteredAt) + resolution.dwellMs).toBe(Date.parse(resolution.at));
+
+  // Episode bookkeeping cleared once resolved.
+  expect(job.needsReviewEntryRunId).toBeUndefined();
+  expect(job.needsReviewEnteredAt).toBeUndefined();
+});
+
+test('a slug that parks twice produces two independent entry/resolution pairs, not one merged episode', () => {
+  const { reduceNeedsReviewLedger } = require('../lib/needsReviewLedger.cjs');
+  const slug = uniqueSlug('nr-twice');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-A' };
+
+  transitionJob(job, 'needs_review', { reason: 'park 1', source: 'spawnJob:finalize' });
+  transitionJob(job, 'pending', { reason: 'manual reset', source: 'ipc:schedule:reset-job' });
+  transitionJob(job, 'running', { reason: 'redispatched', source: 'spawnJob:dispatch' });
+  job.runId = 'run-B';
+  transitionJob(job, 'needs_review', { reason: 'park 2', source: 'spawnJob:finalize' });
+  transitionJob(job, 'completed', { reason: 'healed', source: 'reverifyNeedsReview:heal' });
+
+  const ledgerLines = appendHistorySpy.mock.calls.map((call) => call[0][0]);
+  const entries = ledgerLines.filter((l) => l.kind === 'needs_review_entry');
+  const resolutions = ledgerLines.filter((l) => l.kind === 'needs_review_resolution');
+  expect(entries).toHaveLength(2);
+  expect(resolutions).toHaveLength(2);
+  expect(entries.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+  expect(resolutions.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+
+  const rollup = reduceNeedsReviewLedger(ledgerLines);
+  expect(rollup.unresolvedCount).toBe(0);
+  expect(rollup.byLadderRung['manual-reset']).toBe(1);
+  expect(rollup.byLadderRung['reverify']).toBe(1);
+});

package/src/main/__tests__/scheduler-adopted-run-supervision.test.cjs

@@ -0,0 +1,143 @@
+/**
+ * scheduler-adopted-run-supervision.test.cjs — an executor the boot spared
+ * (`adoptedAtBoot`) is supervised like a freshly spawned one: budget, idle-tail
+ * and deadman re-armed from the durable record, quietMachine lease re-acquired,
+ * and a budget kill parks needs_review/budget_exceeded via classifyBudgetKill.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-adopted-run-supervision.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+const { superviseAdoptedRuns, evaluateAdoptedRun } = require('../lib/adoptedRunSupervisor.cjs');
+const quietMachineLease = require('../lib/quietMachineLease.cjs');
+const { classifyBudgetKill } = require('../scheduler.cjs');
+
+const MIN = 60_000;
+const T0 = Date.parse('2026-09-18T12:00:00Z');
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(T0);
+  quietMachineLease.__resetForTests();
+});
+afterEach(() => {
+  vi.useRealTimers();
+  quietMachineLease.__resetForTests();
+});
+
+function harness({ rows, records, logMtimeMs = () => Date.now(), alive = () => true }) {
+  const kills = [];
+  const stamps = [];
+  const supervised = [];
+  const registry = new Map();
+  const ctx = {
+    registry,
+    runDir: (j) => `/runs/${j.runId}`,
+    readRecord: (_dir, slug) => records[slug] ?? null,
+    lease: quietMachineLease,
+    markSupervised: async (j) => { supervised.push(j.slug); },
+    makeDeps: (j, record) => ({
+      logPath: `/runs/${j.runId}/${j.slug}.log`,
+      statLogMtimeMs: () => logMtimeMs(j.slug),
+      pidAlive: alive,
+      identityOf: () => record.identity,
+      isDifferentProcess: () => false,
+      killGroup: (pgid, signal) => { kills.push({ slug: j.slug, pgid, signal }); },
+      stampKill: async (kind, reason) => { stamps.push({ slug: j.slug, kind, reason }); },
+      checkIntervalMs: MIN,
+      sigkillAfterMs: 30_000,
+      defaultMaxDurationMs: 4 * 60 * MIN,
+    }),
+  };
+  return { ctx, kills, stamps, supervised, registry, run: () => superviseAdoptedRuns(rows, ctx) };
+}
+
+const row = (slug, extra = {}) => ({ slug, status: 'running', runId: 'r1', adoptedAtBoot: new Date(T0).toISOString(), ...extra });
+const record = (slug, extra = {}) => ({
+  slug, pid: 4242, pgid: 4242, identity: { startTicks: 1 }, startedAt: T0, budgetMs: 45 * MIN, maxDurationMs: null, idleKillMs: 20 * MIN, ...extra,
+});
+
+test('an adopted run past its budget is killed and its budget kill classifies needs_review/budget_exceeded', async () => {
+  const h = harness({ rows: [row('over')], records: { over: record('over', { startedAt: T0 - 50 * MIN }) } });
+  expect(await h.run()).toEqual(['over']);
+  await vi.advanceTimersByTimeAsync(0);
+  expect(h.stamps).toHaveLength(1);
+  expect(h.stamps[0].kind).toBe('budget');
+  expect(h.kills).toEqual([{ slug: 'over', pgid: 4242, signal: 'SIGTERM' }]);
+  // SIGKILL follows if the group survives SIGTERM.
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(h.kills.map((k) => k.signal)).toEqual(['SIGTERM', 'SIGKILL']);
+  // Same classifier as a native budget kill.
+  const outcome = classifyBudgetKill({ killedByWatchdog: h.stamps[0].kind, budgetKillReason: h.stamps[0].reason, exitCode: null }, null);
+  expect(outcome.status).toBe('needs_review');
+  expect(outcome.reason).toMatch(/wall-clock budget exceeded/);
+});
+
+test('a run within budget is untouched until the interval crosses the budget', async () => {
+  const h = harness({ rows: [row('ok')], records: { ok: record('ok', { startedAt: T0 - 10 * MIN }) } });
+  await h.run();
+  await vi.advanceTimersByTimeAsync(5 * MIN);
+  expect(h.kills).toEqual([]);
+  expect(h.stamps).toEqual([]);
+  // 10m + 36m elapsed > 45m budget: the re-armed interval now fires.
+  await vi.advanceTimersByTimeAsync(31 * MIN);
+  expect(h.stamps.map((s) => s.kind)).toEqual(['budget']);
+  expect(h.kills[0].signal).toBe('SIGTERM');
+});
+
+test('idle-tail: a stalled log past idleKillMs is SIGTERMed; deadman SIGKILLs at maxDurationMs', async () => {
+  const idle = harness({
+    rows: [row('idle')], records: { idle: record('idle', { startedAt: T0 - 5 * MIN }) },
+    logMtimeMs: () => T0 - 25 * MIN,
+  });
+  await idle.run();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(idle.stamps.map((s) => s.kind)).toEqual(['idle-tail']);
+  expect(idle.kills[0].signal).toBe('SIGTERM');
+
+  const dead = harness({
+    rows: [row('dm')], records: { dm: record('dm', { startedAt: T0 - 5 * MIN, budgetMs: null, maxDurationMs: 4 * 60 * MIN }) },
+  });
+  await dead.run();
+  await vi.advanceTimersByTimeAsync(4 * 60 * MIN);
+  expect(dead.stamps.map((s) => s.kind)).toEqual(['deadman']);
+  expect(dead.kills.map((k) => k.signal)).toEqual(['SIGKILL']);
+});
+
+test('a null record.maxDurationMs falls back to the native 4h deadman', () => {
+  const rec = record('x', { budgetMs: null, startedAt: T0 - 5 * 60 * MIN });
+  expect(evaluateAdoptedRun(rec, { now: T0, logMtimeMs: T0, defaultMaxDurationMs: 4 * 60 * MIN })?.kind).toBe('deadman');
+});
+
+test('the quietMachine lease is re-acquired, supervisedAt stamped once, and an exempt (null budget) run is not budget-killed', async () => {
+  const h = harness({
+    rows: [row('quiet', { quietMachine: true })],
+    records: { quiet: record('quiet', { budgetMs: null, startedAt: T0 - 90 * MIN }) },
+  });
+  expect(await h.run()).toEqual(['quiet']);
+  expect(quietMachineLease.holder()).toBe('quiet');
+  expect(h.supervised).toEqual(['quiet']);
+  await vi.advanceTimersByTimeAsync(10 * MIN);
+  expect(h.kills).toEqual([]);
+  // A second dispatch-loop pass does not re-arm or re-stamp.
+  expect(await h.run()).toEqual([]);
+  expect(h.supervised).toEqual(['quiet']);
+});
+
+test('a pid that is gone is never signalled; rows that stop running drop their supervisor', async () => {
+  const h = harness({
+    rows: [row('gone')], records: { gone: record('gone', { startedAt: T0 - 90 * MIN }) }, alive: () => false,
+  });
+  await h.run();
+  await vi.advanceTimersByTimeAsync(2 * MIN);
+  expect(h.kills).toEqual([]);
+  expect(h.stamps).toEqual([]);
+
+  const live = harness({ rows: [row('fin')], records: { fin: record('fin') } });
+  await live.run();
+  expect(live.registry.size).toBe(1);
+  await superviseAdoptedRuns([{ slug: 'fin', status: 'completed', runId: 'r1' }], live.ctx);
+  expect(live.registry.size).toBe(0);
+});

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -1,12 +1,12 @@
 /**
  * scheduler-autofix-select.test.cjs — unit tests for selectAutoFixTargets.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-autofix-select.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-autofix-select.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const {
   selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate,

package/src/main/__tests__/scheduler-autopromote.test.cjs

@@ -1,12 +1,12 @@
 /**
  * scheduler-autopromote.test.cjs — unit tests for isPromotableOriginal.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-autopromote.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-autopromote.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const { isPromotableOriginal, healTargetForFix } = require('../scheduler.cjs');
 

package/src/main/__tests__/scheduler-bash-timeout-env.test.cjs

@@ -26,6 +26,7 @@ import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
 
 let tmpHome;
 let originalHome;
@@ -53,8 +54,7 @@ afterEach(() => {
 // Stub `claude` binary: dumps the two env vars it received into a marker
 // file, then emits a stream-json success result and exits 0.
 function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-env-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
+  return claudeStub.writeClaudeStub({ body: `
     const fs = require('fs');
     const path = require('path');
     fs.writeFileSync(path.join(process.cwd(), 'env.marker'), JSON.stringify({
@@ -63,9 +63,7 @@ function writeClaudeStub() {
     }), 'utf8');
     process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
     process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
+  ` });
 }
 
 test('BASH_MAX_TIMEOUT_MS stays strictly below IDLE_OUTPUT_KILL_MS with real margin', () => {

package/src/main/__tests__/scheduler-boot-orphans.test.cjs

@@ -2,46 +2,108 @@
  * scheduler-boot-orphans.test.cjs — boot-time reconciliation of 'running' jobs
  * left behind by an app crash/restart (PRD 686: consolidated in from the
  * external watchdog's reconcileQueueOffline(), which is now deleted from
- * scripts/lib/watchdogHelpers.cjs).
+ * src/main/lib/watchdogHelpers.cjs).
  *
- * Covers the two behaviors most likely to drift in the move:
- *   - a still-alive orphaned pid must be DEFERRED, never classified from its
- *     (possibly still-being-written) log in the same pass (partitionBootOrphans)
+ * Covers:
+ *   - a proven-alive row is ADOPTED (left running, never signalled) and only
+ *     proven-dead / exited rows are finalized (partitionBootOrphans)
  *   - the ORPHAN_REQUEUE_CAP re-queue/exhaustion boundary (applyOrphanOutcome)
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-boot-orphans.test.cjs
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-boot-orphans.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+const { spawn } = require('node:child_process');
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
+const {
+  writeSupervisorRecord,
+} = require('../lib/jobSupervisorRecord.cjs');
 const {
   partitionBootOrphans,
   applyOrphanOutcome,
-  feedbackSweepDue,
-  FEEDBACK_SWEEP_TICK_INTERVAL,
-  sweepFeedback,
 } = require('../scheduler.cjs');
 const { ORPHAN_REQUEUE_CAP } = require('../lib/reaperHelpers.cjs');
 
-test('partitionBootOrphans defers a running job whose pid is still alive', () => {
+function spawnStub() {
+  return spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30000)'], { stdio: 'ignore' });
+}
+
+function withRunsDir(fn) {
+  const runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sched-boot-runs-'));
+  try { return fn(runsDir); } finally { fs.rmSync(runsDir, { recursive: true, force: true }); }
+}
+
+test('a running row with a live pid survives boot untouched — adopted, no kill issued', () => {
+  const child = spawnStub();
+  const killSpy = vi.spyOn(process, 'kill');
+  try {
+    const jobs = [{ slug: 'alive-orphan', status: 'running', runtime: { pid: child.pid } }];
+    const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: (pid) => pid === child.pid, runsDir: os.tmpdir() });
+    assert.deepEqual(adopted, ['alive-orphan']);
+    assert.deepEqual(immediate, []);
+    assert.equal(killSpy.mock.calls.length, 0, 'boot classification must never signal an executor');
+    assert.equal(jobs[0].status, 'running', 'the row must not transition');
+  } finally {
+    killSpy.mockRestore();
+    child.kill();
+  }
+});
+
+test('a dead-pid row and a pidless row with no liveness evidence are finalized', () => {
   const jobs = [
-    { slug: 'alive-orphan', status: 'running', runtime: { pid: 111 } },
     { slug: 'dead-orphan', status: 'running', runtime: { pid: 222 } },
     { slug: 'no-pid-orphan', status: 'running', runtime: {} },
     { slug: 'not-running', status: 'pending' },
   ];
-  const isAlive = (pid) => pid === 111;
+  const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: () => false, runsDir: os.tmpdir() });
+  assert.deepEqual(immediate.sort(), ['dead-orphan', 'no-pid-orphan']);
+  assert.deepEqual(adopted, []);
+});
 
-  const { immediate, deferred } = partitionBootOrphans(jobs, isAlive);
+test('a pidless row is adopted on any one of the reaper liveness signals', () => {
+  const job = () => ({ slug: 'p', status: 'running', runtime: {} });
+  const base = { pidAlive: (pid) => pid === 77, runsDir: os.tmpdir(), now: 1_000_000 };
+  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogMtimeMs: () => 999_000, logFreshWindowMs: 5_000 }).adopted, ['p'], 'fresh log');
+  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogPid: () => 77 }).adopted, ['p'], 'log pid alive');
+  assert.deepEqual(partitionBootOrphans([job()], { ...base, findLiveProcess: () => 88 }).adopted, ['p'], '/proc scan');
+  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogMtimeMs: () => 1_000, logFreshWindowMs: 5_000 }).immediate, ['p'], 'stale log');
+});
 
-  assert.deepEqual(deferred, ['alive-orphan']);
-  assert.deepEqual(immediate.sort(), ['dead-orphan', 'no-pid-orphan']);
+test('a row whose supervisor record says exited is finalized from its meta, not adopted', () => {
+  withRunsDir((runsDir) => {
+    const runDir = path.join(runsDir, 'run-1');
+    fs.mkdirSync(runDir, { recursive: true });
+    writeSupervisorRecord({ runDir, slug: 'exited-row', pid: 4242, runId: 'run-1', startedAt: Date.now() });
+    fs.writeFileSync(path.join(runDir, 'exited-row.meta.json'), JSON.stringify({ slug: 'exited-row', exitCode: 0 }));
+    const job = { slug: 'exited-row', status: 'running', runId: 'run-1', runtime: { pid: 4242 } };
+    // Even with the pid reported alive (recycled/lingering), the exit marker wins.
+    const { immediate, adopted } = partitionBootOrphans([job], { pidAlive: () => true, runsDir });
+    assert.deepEqual(immediate, ['exited-row']);
+    assert.deepEqual(adopted, []);
+    applyOrphanOutcome(job, 'success');
+    assert.equal(job.status, 'completed');
+  });
+});
+
+test('a record with a live, same-identity pid is adopted; a dead record without an exit marker is finalized', () => {
+  withRunsDir((runsDir) => {
+    const runDir = path.join(runsDir, 'run-2');
+    fs.mkdirSync(runDir, { recursive: true });
+    writeSupervisorRecord({ runDir, slug: 'live-rec', pid: 31337, runId: 'run-2', startedAt: Date.now() });
+    writeSupervisorRecord({ runDir, slug: 'dead-rec', pid: 31338, runId: 'run-2', startedAt: Date.now() });
+    const jobs = [
+      { slug: 'live-rec', status: 'running', runId: 'run-2', runtime: { pid: 31337 } },
+      { slug: 'dead-rec', status: 'running', runId: 'run-2', runtime: { pid: 31338 } },
+    ];
+    const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: (pid) => pid === 31337, identityOf: () => null, runsDir });
+    assert.deepEqual(adopted, ['live-rec']);
+    assert.deepEqual(immediate, ['dead-rec']);
+  });
 });
 
 test('partitionBootOrphans ignores non-running jobs entirely', () => {
@@ -49,9 +111,9 @@ test('partitionBootOrphans ignores non-running jobs entirely', () => {
     { slug: 'a', status: 'completed', runtime: { pid: 1 } },
     { slug: 'b', status: 'failed', runtime: { pid: 2 } },
   ];
-  const { immediate, deferred } = partitionBootOrphans(jobs, () => true);
+  const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: () => true, runsDir: os.tmpdir() });
   assert.deepEqual(immediate, []);
-  assert.deepEqual(deferred, []);
+  assert.deepEqual(adopted, []);
 });
 
 test('applyOrphanOutcome: success finalizes to completed, clears runtime', () => {
@@ -89,84 +151,3 @@ test('applyOrphanOutcome: no_result at the cap fails terminally instead of re-qu
   assert.match(job.error, new RegExp(`exhausted ${ORPHAN_REQUEUE_CAP} re-queue attempts`));
   assert.equal(job.runtime, undefined);
 });
-
-// ── feedback sweep moved into the 60s poll tick (PRD 686) ───────────────────
-
-test('feedbackSweepDue gates on the tick interval, not every tick', () => {
-  for (let i = 1; i < FEEDBACK_SWEEP_TICK_INTERVAL; i++) {
-    assert.equal(feedbackSweepDue(i), false, `tick ${i} should not be due yet`);
-  }
-  assert.equal(feedbackSweepDue(FEEDBACK_SWEEP_TICK_INTERVAL), true);
-  assert.equal(feedbackSweepDue(FEEDBACK_SWEEP_TICK_INTERVAL + 1), true);
-});
-
-test('scheduler.cjs reuses watchdogHelpers.sweep verbatim (no forked copy)', () => {
-  const { sweep } = require('../../../scripts/lib/watchdogHelpers.cjs');
-  assert.equal(sweepFeedback, sweep, 'scheduler.cjs must import the same sweep function, not reimplement it');
-});
-
-function makeTmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'sched-boot-sweep-'));
-}
-
-function makeQueue(base) {
-  const queuePath = path.join(base, 'queue.json');
-  fs.writeFileSync(queuePath, JSON.stringify({ version: 1, jobs: [], paused: null }, null, 2));
-  return queuePath;
-}
-
-const FAKE_SKILL = '---\nname: process-feedback\ndescription: x\n---\n\n# process-feedback\n\nbody\n';
-const FAKE_STANDARDS = '# Engineering standards\n\nbody\n';
-
-test('the poll-tick sweep call emits a PRD for an active project with open feedback, and skips one outside the 90-min window', () => {
-  const base = makeTmpDir();
-  try {
-    // Active project (10 min ago) with open feedback → should emit.
-    const activeProj = path.join(base, 'active-proj');
-    fs.mkdirSync(path.join(activeProj, 'session-manager-operations', 'feedback'), { recursive: true });
-    fs.writeFileSync(path.join(activeProj, 'session-manager-operations', 'feedback', '2026-01-01-item.md'), '# Item\n');
-
-    // Stale project (120 min ago, outside the 90-min window) with open feedback → should NOT be scanned at all.
-    const staleProj = path.join(base, 'stale-proj');
-    fs.mkdirSync(path.join(staleProj, 'session-manager-operations', 'feedback'), { recursive: true });
-    fs.writeFileSync(path.join(staleProj, 'session-manager-operations', 'feedback', '2026-01-01-item.md'), '# Item\n');
-
-    // Active project with no open feedback → scanned but not emitted.
-    const noFeedbackProj = path.join(base, 'no-feedback-proj');
-    fs.mkdirSync(noFeedbackProj, { recursive: true });
-
-    const projectsDir = path.join(base, 'projects');
-    const recent = new Date(Date.now() - 10 * 60 * 1000);
-    const stale = new Date(Date.now() - 120 * 60 * 1000);
-    for (const [slug, cwd, mtime] of [
-      ['slug-active', activeProj, recent],
-      ['slug-stale', staleProj, stale],
-      ['slug-no-feedback', noFeedbackProj, recent],
-    ]) {
-      const projDir = path.join(projectsDir, slug);
-      fs.mkdirSync(projDir, { recursive: true });
-      const fp = path.join(projDir, 'a.jsonl');
-      fs.writeFileSync(fp, JSON.stringify({ cwd }) + '\n');
-      fs.utimesSync(fp, mtime, mtime);
-    }
-
-    const prdsDir = path.join(base, 'prds');
-    fs.mkdirSync(prdsDir);
-    const queuePath = makeQueue(base);
-    const skillPath = path.join(base, 'SKILL.md');
-    const standardsPath = path.join(base, 'standards.md');
-    fs.writeFileSync(skillPath, FAKE_SKILL);
-    fs.writeFileSync(standardsPath, FAKE_STANDARDS);
-
-    const result = sweepFeedback({ projectsDir, prdsDir, queuePath, skillPath, standardsPath });
-
-    assert.equal(result.scanned, 2, 'only the two in-window projects should be scanned');
-    assert.equal(result.emitted, 1, 'only the active project with open feedback should get a PRD');
-
-    const emittedFiles = fs.readdirSync(prdsDir).filter((f) => f.endsWith('.md'));
-    assert.equal(emittedFiles.length, 1);
-    assert.match(emittedFiles[0], /feedback-active-proj\.md$/);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});