claude-code-session-manager 0.85.0 → 0.87.0

package/src/main/__tests__/scheduler-needs-review-autoresolve.test.cjs

@@ -0,0 +1,189 @@
+/**
+ * scheduler-needs-review-autoresolve.test.cjs
+ *
+ * Covers the bounded automatic terminal decision for an EXHAUSTED
+ * needs_review row (isExhaustedAutoFix === true): selectExhaustedNeedsReviewTargets
+ * (the pure selector), applyNeedsReviewAutoResolve (the three-branch policy
+ * applier, extracted from the 10-minute interval body so it's testable
+ * without queue.json IO), needsReviewAutoResolveDisabled (its kill switch),
+ * and the dependsOn carve-out in schedulerBatch.cjs's findBlockingDep that
+ * lets a chain actually drain once this pass auto-skips a row.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
+ * under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-needs-review-autoresolve.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 tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'needs-review-autoresolve-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectExhaustedNeedsReviewTargets,
+  applyNeedsReviewAutoResolve,
+  NEEDS_REVIEW_RESOLVE_CAP,
+  needsReviewAutoResolveDisabled,
+} = require('../scheduler.cjs');
+
+const { pickForProject } = require('../lib/schedulerBatch.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 30 * MIN_MS;
+
+function exhaustedJob(overrides = {}) {
+  return {
+    slug: 'exhausted-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    autoFixAttempted: true,
+    autoFixOutcome: 'no-plan',
+    autoFixRetries: 1, // spent, per isExhaustedAutoFix
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() }],
+    ...overrides,
+  };
+}
+
+// --- selectExhaustedNeedsReviewTargets ---
+
+test('a fresh exhausted needs_review row (under threshold) is not selected', () => {
+  const job = exhaustedJob({
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
+  });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-exhausted needs_review row (still eligible for a real auto-fix investigation) is left alone', () => {
+  // autoFixRetries: 0 — isExhaustedAutoFix is false here (an unspent retry
+  // remains); this pass must never steal a row selectAutoFixTargets still owns.
+  const job = exhaustedJob({ autoFixRetries: 0 });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-needs_review status is never selected', () => {
+  const job = exhaustedJob({ status: 'failed' });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('an exhausted row past threshold, under the cap, is selected', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'exhausted-row');
+  assert.equal(found[0].attempts, 0);
+});
+
+test('an exhausted row AT the cap is still selected — this is the pass that must terminally skip it', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+});
+
+test('a row already past the cap (defensive — should never occur once skipped) is excluded', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP + 1 });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('needsReviewAutoResolveDisabled reflects SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE', () => {
+  const saved = process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+  try {
+    delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+    assert.equal(needsReviewAutoResolveDisabled(), false);
+    process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = '1';
+    assert.equal(needsReviewAutoResolveDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+    else process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = saved;
+  }
+});
+
+// --- applyNeedsReviewAutoResolve: the three policy branches ---
+
+test('branch 1: a looksDone annotation resolves the row to completed', () => {
+  const job = exhaustedJob({
+    exhaustedResolveAttempts: 1,
+    looksDone: { commits: ['abc1234'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
+  });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'completed');
+  assert.equal(job.status, 'completed');
+});
+
+test('branch 2: no looksDone, under the cap, requeues to pending and increments the attempt counter', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 1);
+});
+
+test('branch 2 again: a second requeue at attempts=1 also succeeds (cap is 2)', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 1 });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 2);
+});
+
+test('branch 3: once the cap is spent, the row is auto-skipped with the reason recorded in job.error', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+  assert.ok(typeof job.error === 'string' && job.error.length > 0, 'job.error must name the exhausted auto-fix path');
+  assert.match(job.error, /exhausted auto-fix/i);
+  assert.equal(job.needsReviewAutoResolvedSkip, true);
+});
+
+test('applyNeedsReviewAutoResolve race-guards against a row that moved off needs_review', () => {
+  const job = exhaustedJob({ status: 'completed', exhaustedResolveAttempts: 0 });
+  assert.equal(applyNeedsReviewAutoResolve(job), null);
+  assert.equal(job.status, 'completed'); // untouched
+});
+
+// --- chain drain: the actual point of this PRD ---
+
+test('a 3-row dependsOn chain drains: the exhausted middle row auto-skips and the third row becomes eligible', () => {
+  const now = Date.now();
+  const rowA = {
+    slug: 'a-first', cwd: '/home/user/project', status: 'completed',
+  };
+  const rowB = exhaustedJob({
+    slug: 'b-middle',
+    cwd: '/home/user/project',
+    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
+    dependsOn: ['a-first'],
+  });
+  const rowC = {
+    slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'],
+  };
+  const jobs = [rowA, rowB, rowC];
+
+  // Before resolution: C is blocked behind B's live needs_review row.
+  const before = pickForProject(jobs, new Set(), 5);
+  assert.equal(before.batch.length, 0, 'C must not be eligible while B still sits in needs_review');
+
+  const targets = selectExhaustedNeedsReviewTargets(jobs, now, THRESHOLD_MS);
+  assert.equal(targets.length, 1);
+  assert.equal(targets[0].slug, 'b-middle');
+  const outcome = applyNeedsReviewAutoResolve(rowB);
+  assert.equal(outcome, 'skipped');
+  assert.equal(rowB.status, 'skipped');
+
+  const after = pickForProject(jobs, new Set(), 5);
+  assert.ok(after.batch.some((j) => j.slug === 'c-last'), 'C must become eligible once B is auto-skipped');
+});
+
+test('a generic (non-auto-resolved) skipped dep still blocks forever — the carve-out is narrow', () => {
+  const rowB = { slug: 'b-middle', cwd: '/home/user/project', status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
+  const rowC = { slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'] };
+  const { batch } = pickForProject([rowB, rowC], new Set(), 5);
+  assert.equal(batch.length, 0, 'a PRD-source-vanished skip must remain a permanent block, unaffected by this carve-out');
+});

package/src/main/__tests__/scheduler-no-dead-end-status.test.cjs

@@ -0,0 +1,152 @@
+/**
+ * scheduler-no-dead-end-status.test.cjs
+ *
+ * Structural guard for the no-human-intervention guarantee (this PRD): every
+ * value in `JOB_STATUSES` (imported from scheduleJobSchema.cjs — the real
+ * array, never a hand-written copy) must either be genuinely final
+ * (completed/skipped) or have at least one AUTOMATED selector that can move
+ * a row parked in it, with no human action required.
+ *
+ * Each non-final status is asserted by CONSTRUCTING a representative parked
+ * row (a stale timestamp + a counter positioned so the row is still
+ * selectable) and showing the named selector actually returns it — not by
+ * asserting a hand-maintained status -> selector-name string map, which
+ * would pass even if the real wiring silently broke. If a future change adds
+ * a new status to JOB_STATUSES with no automated exit wired up here, this
+ * test fails loudly instead of the row becoming a new, silent dead end.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
+ * under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-no-dead-end-status.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 tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'no-dead-end-status-test-'));
+process.env.HOME = tmpHome;
+
+const { JOB_STATUSES } = require('../lib/scheduleJobSchema.cjs');
+const {
+  selectFailedAutoResetTargets,
+  FAILED_AUTORESET_CAP,
+  selectExhaustedNeedsReviewTargets,
+  NEEDS_REVIEW_RESOLVE_CAP,
+  selectQuarantineAutoResolveTargets,
+  QUARANTINE_RESOLVE_CAP,
+  findStrandedInvestigations,
+  INVESTIGATION_MAX_MS,
+} = require('../scheduler.cjs');
+const { selectReapableJobs } = require('../lib/reaperHelpers.cjs');
+const { pickForProject } = require('../lib/schedulerBatch.cjs');
+
+const MIN_MS = 60_000;
+
+// Every terminal status (no automated exit needed — nothing should ever
+// move a row out of these) and every non-terminal status's proof that a
+// row parked there is reachable by an automated selector, keyed only for
+// this test's own assertions (never treated as authoritative wiring below).
+const FINAL_STATUSES = new Set(['completed', 'skipped']);
+
+test('JOB_STATUSES contains exactly the statuses this test accounts for (fails loudly on drift)', () => {
+  // Not a hand-maintained selector map — just a manifest of what this file
+  // below actually exercises, so an entirely new, unhandled status trips
+  // this assertion instead of silently passing the loop below with zero
+  // coverage.
+  const accountedFor = new Set([
+    'pending', 'running', 'investigating', 'completed', 'skipped', 'failed', 'needs_review', 'quarantined',
+  ]);
+  const unaccounted = JOB_STATUSES.filter((s) => !accountedFor.has(s));
+  if (unaccounted.length > 0) {
+    throw new Error(
+      `HALT: JOB_STATUSES has status(es) with no automated-exit test coverage: ${unaccounted.join(', ')} — `
+      + 'add a case to scheduler-no-dead-end-status.test.cjs before shipping this status.',
+    );
+  }
+});
+
+test('every terminal status in JOB_STATUSES is genuinely final (completed/skipped only)', () => {
+  for (const status of JOB_STATUSES) {
+    if (status === 'completed' || status === 'skipped') continue;
+    assert.ok(!FINAL_STATUSES.has(status), `${status} must not be treated as final`);
+  }
+});
+
+test('pending: a fresh pending row with no blockers is picked for dispatch by pickForProject', () => {
+  assert.ok(JOB_STATUSES.includes('pending'));
+  const job = { slug: 'pending-row', cwd: '/home/user/project', status: 'pending' };
+  const { batch } = pickForProject([job], new Set(), 5);
+  assert.ok(batch.some((j) => j.slug === 'pending-row'), 'pending row must be dispatch-eligible with no blockers');
+});
+
+test('running: a running row whose pid is provably dead is reaped by selectReapableJobs', () => {
+  assert.ok(JOB_STATUSES.includes('running'));
+  const job = {
+    slug: 'dead-running-row',
+    cwd: '/home/user/project',
+    status: 'running',
+    runtime: { pid: 12345 },
+  };
+  const { reapable } = selectReapableJobs([job], Date.now(), { pidAlive: () => false, grace: 5 * MIN_MS });
+  assert.ok(reapable.some((r) => r.slug === 'dead-running-row'), 'a running row with a dead pid must be reapable');
+});
+
+test('investigating: a stranded investigation (stale, no live pid) is found by findStrandedInvestigations', () => {
+  assert.ok(JOB_STATUSES.includes('investigating'));
+  const job = {
+    slug: 'stranded-investigation',
+    cwd: '/home/user/project',
+    status: 'investigating',
+    statusHistory: [{ to: 'investigating', from: 'failed', at: new Date(Date.now() - (INVESTIGATION_MAX_MS + 5 * MIN_MS)).toISOString() }],
+  };
+  const found = findStrandedInvestigations([job], Date.now(), INVESTIGATION_MAX_MS, () => false);
+  assert.ok(found.some((f) => f.slug === 'stranded-investigation'), 'a stale investigating row with no live pid must be found');
+});
+
+test('failed: a stale failed row under its auto-reset cap is selected by selectFailedAutoResetTargets', () => {
+  assert.ok(JOB_STATUSES.includes('failed'));
+  const job = {
+    slug: 'stale-failed-row',
+    cwd: '/home/user/project',
+    status: 'failed',
+    failedAutoResetAttempts: FAILED_AUTORESET_CAP - 1,
+    statusHistory: [{ to: 'failed', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectFailedAutoResetTargets([job], Date.now(), 10 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'stale-failed-row'), 'a stale failed row under the cap must be auto-reset-selectable');
+});
+
+test('needs_review: an exhausted, stale needs_review row is selected by selectExhaustedNeedsReviewTargets', () => {
+  assert.ok(JOB_STATUSES.includes('needs_review'));
+  const job = {
+    slug: 'exhausted-needs-review-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    autoFixAttempted: true,
+    autoFixOutcome: 'no-plan',
+    autoFixRetries: 1,
+    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), 30 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'exhausted-needs-review-row'), 'an exhausted, stale needs_review row must be auto-resolve-selectable');
+});
+
+test('quarantined: a stale quarantined row under its resolve cap is selected by selectQuarantineAutoResolveTargets', () => {
+  assert.ok(JOB_STATUSES.includes('quarantined'));
+  const job = {
+    slug: 'stale-quarantined-row',
+    cwd: '/home/user/project',
+    status: 'quarantined',
+    quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP - 1,
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectQuarantineAutoResolveTargets([job], Date.now(), 30 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'stale-quarantined-row'), 'a stale quarantined row under the cap must be auto-resolve-selectable');
+});

package/src/main/__tests__/scheduler-porcelain-rename.test.cjs

@@ -0,0 +1,164 @@
+/**
+ * scheduler-porcelain-rename.test.cjs — PRD 1187/1186-follow-on: a staged
+ * rename ("R  old -> new") was parsed by `parsePorcelainEntries` as ONE fused
+ * path string `"old -> new"`. That string can never match a real path in
+ * `dirtyAfter`, `pathsCommittedDuringRun`, or an `fs.existsSync` check, so
+ * every staged rename in a shared-tree-guard baseline was structurally
+ * guaranteed to be reported reverted — even when it was cleanly committed
+ * during the run. On 2026-09-12 this flagged 45 paths and parked a clean,
+ * committed run (job `1187-autoresolve-guard-verdict-parks`):
+ *
+ *   "job discarded pre-existing state in the shared tree: 45 path(s)
+ *   reverted with no commit to explain it
+ *   (scripts/__tests__/manual-chapter-links.test.cjs ->
+ *   web/manual/__tests__/chapter-links.test.cjs, ...)" — exit 0, landedCommit
+ *   recorded, nothing actually lost.
+ *
+ * Every test below is written to FAIL against the pre-fix implementation
+ * (`path: l.slice(3)`, no rename/quote parsing at all).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-porcelain-rename.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const scheduler = require('../scheduler.cjs');
+const { parsePorcelainEntries, evaluateSharedTreeGuard } = scheduler;
+
+// --- parsePorcelainEntries: rename/copy lines split into real components ---
+
+test('parsePorcelainEntries: a plain staged rename splits into new path + oldPath, not one fused string', () => {
+  const entries = parsePorcelainEntries('R  old.txt -> new.txt\n');
+  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old.txt' }]);
+});
+
+test('parsePorcelainEntries: a rename-with-worktree-modification (RM) line still splits correctly', () => {
+  const entries = parsePorcelainEntries('RM old.txt -> new.txt\n');
+  expect(entries).toEqual([{ code: 'RM', path: 'new.txt', oldPath: 'old.txt' }]);
+});
+
+test('parsePorcelainEntries: a copy line (C) splits the same way as a rename', () => {
+  const entries = parsePorcelainEntries('C  old.txt -> copy.txt\n');
+  expect(entries).toEqual([{ code: 'C ', path: 'copy.txt', oldPath: 'old.txt' }]);
+});
+
+test('parsePorcelainEntries: a NEW path containing a space is quoted by git and must be unquoted', () => {
+  // Real `git status --porcelain` output for `git mv new.txt "renamed with space.txt"`.
+  const entries = parsePorcelainEntries('R  new.txt -> "renamed with space.txt"\n');
+  expect(entries).toEqual([{ code: 'R ', path: 'renamed with space.txt', oldPath: 'new.txt' }]);
+});
+
+test('parsePorcelainEntries: an OLD path containing a space is quoted independently of the new path', () => {
+  const entries = parsePorcelainEntries('R  "old with space.txt" -> new.txt\n');
+  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old with space.txt' }]);
+});
+
+test('parsePorcelainEntries: a non-ASCII path is quoted with per-byte octal escapes and must decode back to UTF-8', () => {
+  // Real recorded `git status --porcelain` output for a rename onto
+  // "résumé file.txt" — git's default core.quotepath escapes each raw UTF-8
+  // byte >= 0x80 as \NNN octal: 'é' is UTF-8 bytes 0xC3 0xA9 -> \303\251.
+  const line = 'R  new.txt -> "r\\303\\251sum\\303\\251 file.txt"\n';
+  const entries = parsePorcelainEntries(line);
+  expect(entries).toEqual([{ code: 'R ', path: 'résumé file.txt', oldPath: 'new.txt' }]);
+});
+
+test('parsePorcelainEntries: non-rename entries are unaffected (no oldPath, path as before)', () => {
+  const entries = parsePorcelainEntries(' M src/foo.js\n?? untracked.txt\n');
+  expect(entries).toEqual([
+    { code: ' M', path: 'src/foo.js' },
+    { code: '??', path: 'untracked.txt' },
+  ]);
+});
+
+test('parsePorcelainEntries: a quoted plain (non-rename) path is also unquoted, not left with literal quotes', () => {
+  const entries = parsePorcelainEntries('?? "plain space.txt"\n');
+  expect(entries).toEqual([{ code: '??', path: 'plain space.txt' }]);
+});
+
+// --- The exact 1187 shape: committed rename must not be flagged reverted ---
+
+test('evaluateSharedTreeGuard: a staged rename that is committed during the run is NOT reported reverted (real 1187 case)', () => {
+  const oldPath = 'scripts/__tests__/manual-chapter-links.test.cjs';
+  const newPath = 'web/manual/__tests__/chapter-links.test.cjs';
+  const dirtyBefore = parsePorcelainEntries(`R  ${oldPath} -> ${newPath}\n`);
+  // git diff --name-only <headBefore>..<headAfter> reports only the NEW path
+  // for a committed rename (verified against real git 2.43 behavior).
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore,
+    dirtyAfter: [], // fully committed, nothing left dirty
+    pathsCommittedDuringRun: [newPath],
+  });
+  expect(result.reverted).toEqual([]);
+});
+
+test('evaluateSharedTreeGuard: a batch of committed renames (the real 45-path shape) are all cleared, none reverted', () => {
+  const pairs = [
+    ['scripts/__tests__/manual-chapter-links.test.cjs', 'web/manual/__tests__/chapter-links.test.cjs'],
+    ['scripts/foo-old.js', 'src/foo-new.js'],
+    ['docs/old-name.md', 'docs/new-name.md'],
+  ];
+  const porcelain = pairs.map(([o, n]) => `R  ${o} -> ${n}`).join('\n') + '\n';
+  const dirtyBefore = parsePorcelainEntries(porcelain);
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore,
+    dirtyAfter: [],
+    pathsCommittedDuringRun: pairs.map(([, n]) => n),
+  });
+  expect(result.reverted).toEqual([]);
+});
+
+// --- The guard's real purpose survives: an UNDONE rename still parks ---
+
+test('evaluateSharedTreeGuard: a staged rename that is UNDONE (old path restored, new path gone, nothing committed) IS still reported reverted', () => {
+  // This test must FAIL if the fix is implemented as "blanket skip rename
+  // entries" (dropping every rename-coded entry from consideration would
+  // make `reverted` come back empty here, exactly like the committed case
+  // above — but here nothing was committed to explain the disappearance).
+  const dirtyBefore = parsePorcelainEntries('R  old.txt -> new.txt\n');
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore,
+    dirtyAfter: [], // clean again — reverted to HEAD, old.txt restored, new.txt gone
+    pathsCommittedDuringRun: [], // nothing committed
+  });
+  expect(result.reverted).toEqual(['new.txt']);
+});
+
+// --- The two already-fixed false-positive classes stay fixed (pinned here
+// too, using parsePorcelainEntries as the real entry point rather than
+// hand-built fixtures, so a future change to the parser can't silently
+// regress them without failing a test right next to the rename fix). ---
+
+test('evaluateSharedTreeGuard: nowIgnored still works for a real parsePorcelainEntries untracked baseline entry', () => {
+  const dirtyBefore = parsePorcelainEntries('?? session-manager-operations/logs/errors-2026-09-12.jsonl\n');
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore,
+    dirtyAfter: [],
+    pathsCommittedDuringRun: ['.gitignore'],
+    existsAfter: ['session-manager-operations/logs/errors-2026-09-12.jsonl'],
+  });
+  expect(result.reverted).toEqual([]);
+  expect(result.nowIgnored).toEqual(['session-manager-operations/logs/errors-2026-09-12.jsonl']);
+});
+
+test('evaluateSharedTreeGuard: a genuine deletion of an untracked path (from a real parsePorcelainEntries entry) is still reverted', () => {
+  const dirtyBefore = parsePorcelainEntries('?? data/scratch.txt\n');
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore,
+    dirtyAfter: [],
+    pathsCommittedDuringRun: [],
+    existsAfter: [],
+  });
+  expect(result.reverted).toEqual(['data/scratch.txt']);
+  expect(result.nowIgnored).toEqual([]);
+});

package/src/main/__tests__/scheduler-quarantine-autoresolve.test.cjs

@@ -0,0 +1,165 @@
+/**
+ * scheduler-quarantine-autoresolve.test.cjs
+ *
+ * Covers the bounded automatic exit for a quarantined row that never
+ * received a `createdVia` provenance stamp (this PRD): the pure selector
+ * `selectQuarantineAutoResolveTargets`, the async applier
+ * `autoResolveQuarantine` (which re-reads the PRD file's frontmatter fresh
+ * from disk immediately before transitioning, so it can never race
+ * reconcile()'s own adopt path), and the kill switch
+ * `quarantineAutoResolveDisabled`.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
+ * under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-quarantine-autoresolve.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 tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'quarantine-autoresolve-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectQuarantineAutoResolveTargets,
+  autoResolveQuarantine,
+  QUARANTINE_RESOLVE_CAP,
+  quarantineAutoResolveDisabled,
+} = require('../scheduler.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 60 * MIN_MS;
+
+function quarantinedJob(overrides = {}) {
+  return {
+    slug: 'quarantined-row',
+    cwd: '/home/user/project',
+    status: 'quarantined',
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 90 * MIN_MS).toISOString() }],
+    ...overrides,
+  };
+}
+
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function makeFixtureProject(prefix) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  registerActiveProject(cwd);
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-epic-1', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  return { cwd, prdsDir };
+}
+
+// --- selectQuarantineAutoResolveTargets ---
+
+test('a fresh quarantined row (under threshold) is not selected', () => {
+  const job = quarantinedJob({
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
+  });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-quarantined status is never selected', () => {
+  const job = quarantinedJob({ status: 'failed' });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a quarantined row with no statusHistory entry cannot have its age proven, and is skipped', () => {
+  const job = quarantinedJob({ statusHistory: [] });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a quarantined row past threshold, under the cap, is selected', () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: 0 });
+  const found = selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'quarantined-row');
+  assert.ok(found[0].ageMs >= 90 * MIN_MS - 1000);
+});
+
+test('a quarantined row that already spent its resolve cap is excluded', () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('quarantineAutoResolveDisabled reflects SM_QUARANTINE_AUTORESOLVE_DISABLE', () => {
+  const saved = process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+  try {
+    delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+    assert.equal(quarantineAutoResolveDisabled(), false);
+    process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = '1';
+    assert.equal(quarantineAutoResolveDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+    else process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = saved;
+  }
+});
+
+// --- autoResolveQuarantine: the applier ---
+
+test('a quarantined row whose PRD file still has no createdVia is auto-resolved to skipped', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-noprovenance-');
+  try {
+    fs.writeFileSync(
+      path.join(prdsDir, 'quarantined-row.md'),
+      `---\ntitle: Unstamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nDo the thing.\n`,
+      'utf8',
+    );
+    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
+    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+    assert.equal(outcome, 'skipped');
+    assert.equal(job.status, 'skipped');
+    assert.equal(job.quarantineResolveAttempts, 1);
+    assert.ok(typeof job.error === 'string' && /createdVia/.test(job.error));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('a quarantined row whose PRD file HAS been stamped with createdVia is left alone — reconcile owns it now', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-stamped-');
+  try {
+    fs.writeFileSync(
+      path.join(prdsDir, 'quarantined-row.md'),
+      `---\ntitle: Stamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
+      'utf8',
+    );
+    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
+    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+    assert.equal(outcome, null);
+    assert.equal(job.status, 'quarantined'); // untouched — the adopt path owns the next pass
+    assert.equal(job.quarantineResolveAttempts, 0);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('autoResolveQuarantine race-guards against a row that moved off quarantined', async () => {
+  const job = quarantinedJob({ status: 'pending', quarantineResolveAttempts: 0 });
+  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
+  assert.equal(job.status, 'pending'); // untouched
+});
+
+test('autoResolveQuarantine race-guards against a row whose resolve cap is already spent', async () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
+  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
+  assert.equal(job.status, 'quarantined'); // untouched
+});
+
+test('a quarantined row whose PRD file is missing entirely is treated as still lacking provenance and auto-resolved', async () => {
+  const job = quarantinedJob({ cwd: '/nonexistent/project/path', quarantineResolveAttempts: 0 });
+  const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+});