claude-code-session-manager 0.87.0 → 0.88.1

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

@@ -0,0 +1,245 @@
+/**
+ * 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;
+
+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: '/home/user/project',
+    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-supervisor-record.test.cjs

@@ -0,0 +1,81 @@
+/**
+ * scheduler-supervisor-record.test.cjs — executeJob writes
+ * <runDir>/<slug>.supervisor.json synchronously at the `spawned pid=` point,
+ * i.e. before the child's first output and before onPid's mutate runs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-supervisor-record.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let executeJob;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-supervisor-rec-'));
+  process.env.HOME = tmpHome;
+  ({ executeJob } = require('../scheduler.cjs'));
+});
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+afterEach(() => { delete process.env.SM_CLAUDE_BIN; });
+
+function writeSlowStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-sup-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    setTimeout(() => {
+      process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
+      process.exit(0);
+    }, 500);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+test('the supervisor record exists by the time onPid fires, before the child prints anything', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-sup-main-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-sup-wt-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-sup-run-'));
+  try {
+    const slug = `sup-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
+    fs.mkdirSync(prdsDir, { recursive: true });
+    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'body', 'utf8');
+    process.env.SM_CLAUDE_BIN = writeSlowStub();
+
+    const seen = {};
+    const result = await executeJob({ slug, cwd: mainCwd }, runDir, mainCwd, (pid) => {
+      const file = path.join(runDir, `${slug}.supervisor.json`);
+      seen.exists = fs.existsSync(file);
+      seen.record = seen.exists ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+      seen.pid = pid;
+      seen.logHasOutput = fs.readFileSync(path.join(runDir, `${slug}.log`), 'utf8').includes('"type":"result"');
+      seen.metaExists = fs.existsSync(path.join(runDir, `${slug}.meta.json`));
+      return Promise.resolve();
+    }, worktreeCwd);
+
+    expect(result.exitCode).toBe(0);
+    expect(seen.exists).toBe(true);
+    expect(seen.logHasOutput).toBe(false);
+    expect(seen.metaExists).toBe(false);
+    expect(seen.record).toMatchObject({
+      kind: 'job', slug, cwd: mainCwd, runId: path.basename(runDir), pid: seen.pid, pgid: seen.pid,
+      execCwd: worktreeCwd, worktreeDir: worktreeCwd, worktreeBranch: `sm-job/${slug}`, schedulerPid: process.pid,
+    });
+    expect(typeof seen.record.startedAt).toBe('number');
+    expect(seen.record.idleKillMs).toBeGreaterThan(0);
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+    fs.rmSync(worktreeCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/scheduler-tick-cancel-token.test.cjs

@@ -8,12 +8,12 @@
  * subsequent tickQueue() call short-circuited on the stale flag forever,
  * even though queue.json's `paused` field was correctly null.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-tick-cancel-token.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-tick-cancel-token.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const { applyPauseCleared, pickNextBatch } = require('../scheduler.cjs');
 

package/src/main/__tests__/scheduler-tick-wedge.test.cjs

@@ -0,0 +1,172 @@
+/**
+ * scheduler-tick-wedge.test.cjs — tickQueue's serialized chain (tickTail) must
+ * survive a tick body that never settles: the body is bounded by a watchdog,
+ * the chain resets, and a late-resuming stale body is fenced off (no spawn, no
+ * mutate). mutateTail is never reset.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-tick-wedge.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let originalClaudeBin;
+let originalAutofix;
+let originalWatchdog;
+let originalClaudeVersion;
+let scheduler;
+let queueStore;
+let auditLog;
+let spawnMarker;
+
+function auditKinds() {
+  try {
+    return fs.readFileSync(auditLog.auditLogPath(), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l).kind);
+  } catch { return []; }
+}
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  originalClaudeBin = process.env.SM_CLAUDE_BIN;
+  originalAutofix = process.env.SM_AUTOFIX_DISABLE;
+  originalWatchdog = process.env.SM_TICK_WATCHDOG_MS;
+  // This test's spawn marker is written by the stub on ANY invocation, including the
+  // `claude --version` probe — so it needs the real probe, not the sandbox's pinned version.
+  originalClaudeVersion = process.env.SM_CLAUDE_VERSION;
+  delete process.env.SM_CLAUDE_VERSION;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-tick-wedge-'));
+  process.env.HOME = tmpHome;
+  process.env.SM_AUTOFIX_DISABLE = '1';
+  // Any spawn of the "claude" binary drops a marker file: proof spawnJob ran.
+  spawnMarker = path.join(tmpHome, 'claude-spawned.marker');
+  const stubPath = path.join(tmpHome, 'claude-stub.cjs');
+  const body = `require('node:fs').appendFileSync(${JSON.stringify(spawnMarker)}, 'x');\n`
+    + `process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');\n`
+    + 'process.exit(0);\n';
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}`, { mode: 0o755 });
+  process.env.SM_CLAUDE_BIN = stubPath;
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+  auditLog = require('../lib/auditLog.cjs');
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  for (const [k, v] of [['SM_CLAUDE_BIN', originalClaudeBin], ['SM_AUTOFIX_DISABLE', originalAutofix], ['SM_TICK_WATCHDOG_MS', originalWatchdog], ['SM_CLAUDE_VERSION', originalClaudeVersion]]) {
+    if (v === undefined) delete process.env[k]; else process.env[k] = v;
+  }
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test('a never-settling tick body is declared wedged, the chain resets, the stale body is fenced, audit fires once', async () => {
+  process.env.SM_TICK_WATCHDOG_MS = '150';
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-tick-wedge-project-'));
+  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-tick-wedge-fake-'));
+  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
+  const slug = `9003-tick-wedge-${process.pid}`;
+  await scheduler.writeQueue({
+    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
+    config: {},
+    paused: null,
+  });
+
+  // The first readMerged (the tick body's first await) hangs until released;
+  // every later call delegates to the real reader.
+  const realRead = queueStore.readMerged;
+  let release;
+  const hung = new Promise((r) => { release = r; });
+  let calls = 0;
+  queueStore.readMerged = function patched(...args) {
+    calls += 1;
+    if (calls === 1) return hung;
+    return realRead.apply(this, args);
+  };
+
+  try {
+    const wedgedResult = await scheduler.tickQueue();
+    expect(wedgedResult).toMatchObject({ fired: false, reason: 'wedged' });
+    expect(auditKinds().filter((k) => k === 'tick_wedged')).toHaveLength(1);
+
+    // A second wedge in the same episode (no normal tick between) must not re-audit.
+    calls = 0;
+    const hung2 = new Promise(() => {});
+    queueStore.readMerged = function patched2(...args) {
+      calls += 1;
+      if (calls === 1) return hung2;
+      return realRead.apply(this, args);
+    };
+    const again = await scheduler.tickQueue();
+    expect(again).toMatchObject({ reason: 'wedged' });
+    expect(auditKinds().filter((k) => k === 'tick_wedged')).toHaveLength(1);
+
+    // Next tick runs on a fresh chain (real reader, generous budget).
+    queueStore.readMerged = realRead;
+    process.env.SM_TICK_WATCHDOG_MS = '30000';
+    // Launch gates this case controls, so the dispatch assertion below does not
+    // depend on host state: the CPU load gate (loadavg1/cores > 0.85 -> 'load-deferred')
+    // via tickQueue's bypassLoadGate, and the memory gate ('memory-deferred', reads
+    // MemAvailable from /proc/meminfo) via a stubbed fs.readFileSync for that one path.
+    const realReadFileSync = fs.readFileSync;
+    fs.readFileSync = function patchedReadFileSync(file, ...rest) {
+      if (file === '/proc/meminfo') return 'MemAvailable:   67108864 kB\n';
+      return realReadFileSync.call(this, file, ...rest);
+    };
+    let fresh;
+    try {
+      fresh = await scheduler.tickQueue({ bypassLoadGate: true });
+    } finally {
+      fs.readFileSync = realReadFileSync;
+    }
+    expect(fresh.reason).not.toBe('wedged');
+
+    // Let the fresh tick's own spawn (if any) finish, then clear the marker.
+    // The fresh tick must have dispatched: wait for the stub's marker, then for
+    // the row to leave running/pending (spawnJob is fire-and-forget).
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+      const row = queueStore.readMergedSync().jobs.find((j) => j.slug === slug);
+      if (fs.existsSync(spawnMarker) && (!row || (row.status !== 'running' && row.status !== 'pending'))) break;
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    expect(fs.existsSync(spawnMarker)).toBe(true);
+    fs.rmSync(spawnMarker, { force: true });
+
+    // Late-resume the stale body with a state that WOULD dispatch a pending job.
+    const before = queueStore.readMergedSync();
+    const staleState = {
+      ...before,
+      jobs: [{ slug: `9004-tick-wedge-stale-${process.pid}`, title: 'y', cwd, status: 'pending', dependsOn: [] }],
+      config: { ...(before.config || {}) },
+    };
+    release(staleState);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(fs.existsSync(spawnMarker)).toBe(false);
+  } finally {
+    queueStore.readMerged = realRead;
+  }
+});
+
+test('a slow-but-healthy tick under the budget is not flagged as wedged', async () => {
+  process.env.SM_TICK_WATCHDOG_MS = '2000';
+  const realRead = queueStore.readMerged;
+  const before = auditKinds().filter((k) => k === 'tick_wedged').length;
+  queueStore.readMerged = async function slow(...args) {
+    await new Promise((r) => setTimeout(r, 100));
+    return realRead.apply(this, args);
+  };
+  try {
+    const r = await scheduler.tickQueue();
+    expect(r?.reason).not.toBe('wedged');
+    expect(auditKinds().filter((k) => k === 'tick_wedged').length).toBe(before);
+  } finally {
+    queueStore.readMerged = realRead;
+  }
+});

package/src/main/__tests__/scheduler-transient-failure.test.cjs

@@ -4,12 +4,12 @@
  * requeue instead of burning a whole run + an auto-fix investigation on an
  * outage that has nothing to do with the code.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-transient-failure.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-transient-failure.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');

package/src/main/__tests__/scheduler-worktree-cap-defer.test.cjs

@@ -18,6 +18,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');
 const { execFileSync } = require('node:child_process');
 
 let tmpHome;
@@ -30,6 +31,24 @@ function git(args, cwd) {
   return execFileSync('git', args, { cwd, encoding: 'utf8' });
 }
 
+// A completed job's PRD is archived immediately (archiveCompletedPrd, called
+// for EVERY job that reaches effectiveStatus:'completed' — not just a
+// retention-aged one), and the very next reconcile() pass (spawnJob's own
+// broadcast({flush:true}) right after finishing) then finds the row's PRD
+// gone and backfills+drops it from queue.json into history.jsonl in that
+// SAME pass — see scheduler-reconcile-history-backfill.test.cjs. So a job
+// that actually completed is found in EITHER queue.json OR history.jsonl,
+// never guaranteed to still be the former.
+function readTerminalRow(queuePath, projectCwd, slug) {
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  const row = jobs.find((j) => j.slug === slug);
+  if (row) return row;
+  const historyPath = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'state', 'history.jsonl');
+  if (!fs.existsSync(historyPath)) return undefined;
+  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
+  return lines.map((l) => JSON.parse(l)).reverse().find((j) => j.slug === slug);
+}
+
 function initRepo(dir) {
   fs.mkdirSync(dir, { recursive: true });
   git(['init', '-q'], dir);
@@ -61,8 +80,9 @@ function writeProjectQueue(cwd, jobs) {
 // test can prove whether — and where — it was actually spawned, then emits a
 // clean stream-json success result.
 function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-capdefer-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
+  return claudeStub.writeClaudeStub({
+    allowCommitUnder: os.tmpdir(),
+    body: `
     const fs = require('fs');
     const path = require('path');
     const { execFileSync } = require('child_process');
@@ -73,14 +93,13 @@ function writeClaudeStub() {
     // fallback case), where the run parks in needs_review instead, which is
     // fine — this test only cares whether it ran in place, not its verdict.
     try {
-      execFileSync('git', ['add', '-A'], { cwd: process.cwd() });
-      execFileSync('git', ['commit', '-q', '-m', 'stub commit'], { cwd: process.cwd() });
+      runGit(['add', '-A']);
+      runGit(['commit', '-q', '-m', 'stub commit']);
     } catch { /* not a git repo — best-effort only */ }
     process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
     process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
+  `,
+  });
 }
 
 beforeAll(() => {
@@ -111,7 +130,13 @@ test('a job held behind the worktree cap stays pending with a heldReason, is nev
   registerActiveProject(projectCwd);
 
   const slug = `1112-test-held-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  // Epic-scoped, not the legacy flat prds/ dir: the flat dir is retired and
+  // swept into prds-archived/ by consolidateFlatPrds on every reconcile()
+  // pass once a row is no longer 'pending'/'running' — which would strand
+  // this test's row the moment it completes (reconcile()'s terminal-job
+  // "PRD gone -> archived on purpose" drop, see
+  // scheduler-reconcile-history-backfill.test.cjs).
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
   fs.mkdirSync(prdsDir, { recursive: true });
   fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Held behind the worktree cap.', 'utf8');
   const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);
@@ -147,8 +172,8 @@ test('a job held behind the worktree cap stays pending with a heldReason, is nev
 
     await spawnJob({ slug, cwd: projectCwd }, `${runId}-2`, runDir, projectCwd);
 
-    jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    row = jobs.find((j) => j.slug === slug);
+    row = readTerminalRow(queuePath, projectCwd, slug);
+    expect(row).toBeTruthy();
     expect(row.status).toBe('completed');
     expect(row.heldReason).toBeUndefined();
   } finally {
@@ -163,7 +188,8 @@ test('a non-git cwd still falls back to running in place (unchanged behaviour
   registerActiveProject(projectCwd);
 
   const slug = `1112-test-nongit-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  // Epic-scoped — see the sibling test above for why not the flat prds/ dir.
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
   fs.mkdirSync(prdsDir, { recursive: true });
   fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Non-git cwd, must run in place.', 'utf8');
   const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);

package/src/main/__tests__/scheduler-worktree-exec-cwd.test.cjs

@@ -23,6 +23,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;
@@ -48,16 +49,13 @@ afterEach(() => {
 // where it actually ran), captures the '-p' prompt, then emits a stream-json
 // success result and exits 0.
 function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-${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(), 'ran-here.marker'), 'yes', '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('executeJob spawns the child in execCwd (worktree) while resolving the PRD from job.cwd (main tree)', async () => {