claude-code-session-manager 0.98.0 → 0.100.0

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

@@ -1,211 +0,0 @@
-/**
- * queueOpsAutoArchive.test.cjs — unit tests for queueOps.cjs's
- * selectAutoArchivable predicate + autoArchiveCompleted orchestration
- * (auto-archiving completed PRDs' .md files out of the live prds/ dir).
- *
- * selectAutoArchivable is pure (no fs) so it's fully covered here without
- * touching disk. autoArchiveCompleted's disk-mutating path (archiveMany) is
- * mostly exercised only via its kill-switch / no-op branches, since
- * archiveMany's default destination is not test-injectable — except for the
- * two retire-flag tests below, which write into PRDS_DIR (a lazy getter
- * resolved under this run's SM_SCHEDULER_HOME sandbox — see
- * tests/setup/schedulerSandbox.cjs — so they never touch a real
- * ~/.claude/session-manager tree) and stub 'electron' via require.cache so
- * registerQueueOpsHandlers' ipcMain.handle calls are no-ops outside a real
- * Electron process. 'electron' is an externalized node_modules dependency
- * under vitest, so vi.mock('electron', ...) never intercepts queueOps.cjs's
- * own require('electron') — pre-seeding require.cache for its resolved path
- * is the one hook that reaches it.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/queueOpsAutoArchive.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const path = require('node:path');
-
-const electronPath = require.resolve('electron');
-require.cache[electronPath] = {
-  id: electronPath,
-  filename: electronPath,
-  loaded: true,
-  exports: { ipcMain: { handle: () => {} } },
-};
-
-const RETENTION_MS = 7 * 24 * 60 * 60_000;
-const NOW = Date.parse('2026-07-24T12:00:00.000Z');
-
-const { selectAutoArchivable, autoArchiveCompleted, archiveMany, registerQueueOpsHandlers, PRDS_DIR } = require('../queueOps.cjs');
-
-function fresh(overrides = {}) {
-  return {
-    slug: '01-fresh',
-    status: 'completed',
-    finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString(), // 1h ago
-    ...overrides,
-  };
-}
-
-function old(overrides = {}) {
-  return {
-    slug: '02-old',
-    status: 'completed',
-    finishedAt: new Date(NOW - 10 * 24 * 60 * 60_000).toISOString(), // 10d ago
-    ...overrides,
-  };
-}
-
-afterEach(() => {
-  delete process.env.SM_PRD_AUTOARCHIVE_DISABLE;
-});
-
-// ---------- selectAutoArchivable ----------
-
-test('selectAutoArchivable: fresh completed job stays (not old enough)', () => {
-  const slugs = selectAutoArchivable([fresh()], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: old completed job archives', () => {
-  const slugs = selectAutoArchivable([old()], { nowMs: NOW });
-  expect(slugs).toEqual(['02-old']);
-});
-
-test('selectAutoArchivable: needs_review jobs never archive, regardless of age', () => {
-  const j = old({ slug: '03-review', status: 'needs_review' });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: failed jobs never archive, regardless of age', () => {
-  const j = old({ slug: '04-failed', status: 'failed' });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: pending jobs never archive', () => {
-  const j = old({ slug: '05-pending', status: 'pending', finishedAt: null });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: running jobs never archive', () => {
-  const j = old({ slug: '06-running', status: 'running', finishedAt: null });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a PENDING NN-fix-<slug> sibling is protected', () => {
-  const original = old({ slug: '07-thing', status: 'completed' });
-  const fixPlan = { slug: '07-fix-thing', status: 'pending', finishedAt: null };
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a RUNNING NN-fix-<slug> sibling is protected', () => {
-  const original = old({ slug: '08-thing', status: 'completed' });
-  const fixPlan = { slug: '08-fix-thing', status: 'running', finishedAt: null };
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a COMPLETED fix-plan sibling is free to archive (no longer protected)', () => {
-  const original = old({ slug: '09-thing', status: 'completed' });
-  const fixPlan = old({ slug: '09-fix-thing', status: 'completed' });
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW }).sort();
-  expect(slugs).toEqual(['09-fix-thing', '09-thing']);
-});
-
-test('selectAutoArchivable: job with no/invalid finishedAt never archives even if status completed', () => {
-  const j = { slug: '10-nofinish', status: 'completed', finishedAt: null };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: respects retentionMs override', () => {
-  const j = { slug: '11-recent', status: 'completed', finishedAt: new Date(NOW - 2 * 60 * 60_000).toISOString() };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW, retentionMs: 60 * 60_000 }); // 1h retention
-  expect(slugs).toEqual(['11-recent']);
-});
-
-test('selectAutoArchivable: defaults retentionMs to the shared HISTORY_RETENTION_MS constant', () => {
-  const j = { slug: '12-boundary', status: 'completed', finishedAt: new Date(NOW - RETENTION_MS - 1).toISOString() };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual(['12-boundary']);
-});
-
-// ---------- autoArchiveCompleted ----------
-
-test('autoArchiveCompleted: kill switch SM_PRD_AUTOARCHIVE_DISABLE=1 skips entirely', async () => {
-  process.env.SM_PRD_AUTOARCHIVE_DISABLE = '1';
-  const result = await autoArchiveCompleted({ jobs: [old()] }, { nowMs: NOW });
-  expect(result.archived).toBe(0);
-  expect(result.skipped).toBe('disabled');
-});
-
-test('autoArchiveCompleted: no eligible slugs returns a no-op without touching disk', async () => {
-  const result = await autoArchiveCompleted({ jobs: [fresh()] }, { nowMs: NOW });
-  expect(result.ok).toBe(true);
-  expect(result.archived).toBe(0);
-  expect(result.archivedTo).toBe(null);
-  expect(result.results).toEqual([]);
-});
-
-test('autoArchiveCompleted: tolerates a missing/malformed state.jobs', async () => {
-  const result = await autoArchiveCompleted({}, { nowMs: NOW });
-  expect(result.archived).toBe(0);
-});
-
-// ---------- archiving never strands a runnable queue job (scheduler PRD:
-// archived-prd-skip — job 822-epics-nav-rename fired ENOENT after its PRD
-// was archived out from under a still-queued job) ----------
-
-test('selectAutoArchivable never selects a slug whose job is still pending or running, so auto-archive can never leave a runnable job pointing at an archived PRD', () => {
-  const pending = old({ slug: '13-pending', status: 'pending', finishedAt: null });
-  const running = old({ slug: '14-running', status: 'running', finishedAt: null });
-  const completed = old({ slug: '15-done', status: 'completed' });
-  const slugs = selectAutoArchivable([pending, running, completed], { nowMs: NOW });
-  expect(slugs).toEqual(['15-done']);
-});
-
-// ---------- retire-flag deadlock guard (PRD 1442: reconcile() -> mutate()
-// body -> autoArchiveCompleted -> archiveMany -> retireCompletedSlugsFn ->
-// mutate() re-entered every tick, so mutateTail never settled) ----------
-
-test('autoArchiveCompleted never invokes retireCompletedSlugs', async () => {
-  const slug = 'test-auto-archive-no-retire';
-  fs.mkdirSync(PRDS_DIR, { recursive: true });
-  const src = path.join(PRDS_DIR, `${slug}.md`);
-  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
-
-  const spy = vi.fn(async () => {});
-  registerQueueOpsHandlers({ retireCompletedSlugs: spy });
-
-  const job = old({ slug, status: 'completed' });
-  const result = await autoArchiveCompleted({ jobs: [job] }, { nowMs: NOW });
-
-  expect(result.archived).toBe(1);
-  expect(fs.existsSync(src)).toBe(false);
-  expect(result.results[0].ok).toBe(true);
-  expect(fs.existsSync(result.results[0].archivedTo)).toBe(true);
-  expect(spy).not.toHaveBeenCalled();
-});
-
-test('manual archiveMany still retires', async () => {
-  const slug = 'test-manual-archive-still-retires';
-  fs.mkdirSync(PRDS_DIR, { recursive: true });
-  const src = path.join(PRDS_DIR, `${slug}.md`);
-  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
-
-  const spy = vi.fn(async () => {});
-  registerQueueOpsHandlers({ retireCompletedSlugs: spy });
-
-  const result = await archiveMany([slug]);
-
-  expect(result.archived).toBe(1);
-  expect(fs.existsSync(src)).toBe(false);
-  expect(spy).toHaveBeenCalledTimes(1);
-  expect(spy).toHaveBeenCalledWith([slug]);
-});

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

@@ -1,128 +0,0 @@
-/**
- * rateLimitPollerStreak.test.cjs — covers the fix for the silent
- * consecutiveFailures streak on the usage/rate-limit poller (scheduler.cjs
- * pollLoop): the 'meter_rate_limited' branch used to never back off and
- * never call persistSchedulerState(), letting scheduler-state.json freeze
- * stale while the loop kept failing every POLL_INTERVAL_MS underneath it.
- * This suite covers the pure pieces of the fix: the shared backoff
- * curve/cap (nextBackoffMs), the once-per-streak WARN gate
- * (shouldWarnFailureStreak), and the periodic escalation ladder that fires
- * every FAILURE_STREAK_ESCALATION_MS while a streak PERSISTS past the
- * initial WARN, re-arming once the streak clears (shouldEscalateFailureStreak).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/rateLimitPollerStreak.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  nextBackoffMs,
-  shouldWarnFailureStreak,
-  shouldEscalateFailureStreak,
-  restoreFailureStreakWarnedAt,
-  persistedStreakMinutes,
-  BACKOFF_MAX_MS,
-  FAILURE_STREAK_WARN_THRESHOLD,
-  FAILURE_STREAK_ESCALATION_MS,
-} = require('../scheduler.cjs');
-
-test('nextBackoffMs starts at 30s from a zero/falsy backoff', () => {
-  expect(nextBackoffMs(0)).toBe(30_000);
-  expect(nextBackoffMs(null)).toBe(30_000);
-});
-
-test('nextBackoffMs doubles each call', () => {
-  let ms = 0;
-  ms = nextBackoffMs(ms); // 30_000
-  ms = nextBackoffMs(ms); // 60_000
-  ms = nextBackoffMs(ms); // 120_000
-  expect(ms).toBe(120_000);
-});
-
-test('nextBackoffMs caps at BACKOFF_MAX_MS (8 minutes) and never exceeds it', () => {
-  let ms = 0;
-  for (let i = 0; i < 20; i++) ms = nextBackoffMs(ms);
-  expect(ms).toBe(BACKOFF_MAX_MS);
-  expect(BACKOFF_MAX_MS).toBe(480_000);
-  // One more doubling from an already-capped value must still be capped, not climb further.
-  expect(nextBackoffMs(ms)).toBe(BACKOFF_MAX_MS);
-});
-
-test('shouldWarnFailureStreak is false below the threshold', () => {
-  expect(shouldWarnFailureStreak(1, false)).toBe(false);
-  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD - 1, false)).toBe(false);
-});
-
-test('shouldWarnFailureStreak fires exactly once when the threshold is crossed', () => {
-  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
-});
-
-test('shouldWarnFailureStreak does not spam on every subsequent failure in the same streak', () => {
-  // Simulate a 57-failure streak: warn fires once, then `alreadyWarned` stays
-  // true for every remaining failure — this is the no-repeat property.
-  let warned = false;
-  let warnCount = 0;
-  for (let failures = 1; failures <= 57; failures++) {
-    if (shouldWarnFailureStreak(failures, warned)) {
-      warned = true;
-      warnCount++;
-    }
-  }
-  expect(warnCount).toBe(1);
-  expect(warned).toBe(true);
-});
-
-test('shouldWarnFailureStreak re-arms after a streak resets (alreadyWarned back to false)', () => {
-  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
-  // A later, independent streak crossing the threshold again must warn again.
-  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
-});
-
-test('shouldWarnFailureStreak respects a custom threshold', () => {
-  expect(shouldWarnFailureStreak(3, false, 3)).toBe(true);
-  expect(shouldWarnFailureStreak(2, false, 3)).toBe(false);
-});
-
-test('shouldEscalateFailureStreak: false below the WARN threshold, regardless of elapsed time', () => {
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD - 1, null, Date.now())).toBe(false);
-});
-
-test('shouldEscalateFailureStreak: fires immediately the first time (lastEscalatedAtMs null) once past the WARN threshold', () => {
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, Date.now())).toBe(true);
-});
-
-test('shouldEscalateFailureStreak: does not re-fire before FAILURE_STREAK_ESCALATION_MS has elapsed since the last one', () => {
-  const lastEscalatedAtMs = 1_000_000;
-  const tooSoon = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS - 1;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, tooSoon)).toBe(false);
-});
-
-test('shouldEscalateFailureStreak: fires again once FAILURE_STREAK_ESCALATION_MS has elapsed — the persisting-streak ladder', () => {
-  const lastEscalatedAtMs = 1_000_000;
-  const dueNow = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, dueNow)).toBe(true);
-});
-
-test('shouldEscalateFailureStreak: re-arms after a streak clears (lastEscalatedAtMs reset to null) — a later independent streak escalates again', () => {
-  const firstStreakNow = 1_000_000;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, firstStreakNow)).toBe(true);
-  // Streak clears (a success resets both failureStreakWarned and the
-  // escalation timestamp) — a LATER, independent streak crossing the WARN
-  // threshold again must escalate again immediately, not wait out a stale
-  // 30-minute window from the previous incident.
-  const laterStreakNow = firstStreakNow + 5 * 60_000; // well under 30 min later
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, laterStreakNow)).toBe(true);
-});
-
-test('restoreFailureStreakWarnedAt backfills now when warned=true has no numeric timestamp', () => {
-  expect(restoreFailureStreakWarnedAt(true, null, 5000)).toBe(5000);
-  expect(restoreFailureStreakWarnedAt(true, 1000, 5000)).toBe(1000);
-  expect(restoreFailureStreakWarnedAt(false, null, 5000)).toBeNull();
-});
-
-test('persistedStreakMinutes is always a number, never null', () => {
-  expect(persistedStreakMinutes(null, 5000)).toBe(0);
-  expect(persistedStreakMinutes(0, 120_000)).toBe(2);
-  expect(persistedStreakMinutes(restoreFailureStreakWarnedAt(true, undefined, 5000), 5000)).toBe(0);
-});

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

@@ -1,266 +0,0 @@
-/**
- * rcaReport.test.cjs — unit tests for src/main/lib/rcaReport.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/rcaReport.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let realHome;
-let rcaReport;
-
-// config.cjs bakes os.homedir() into top-level consts at first require
-// (allowedRoots/WRITE_PREFIXES). Node's require cache must be purged per test
-// so each test's tmpHome takes effect — vi.resetModules() only resets vitest's
-// ESM graph, not require().
-const MODULES_TO_RELOAD = ['../lib/rcaReport.cjs', '../config.cjs'];
-
-function purgeRequireCache() {
-  for (const m of MODULES_TO_RELOAD) {
-    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
-  }
-}
-
-beforeEach(() => {
-  realHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'rca-report-test-'));
-  process.env.HOME = tmpHome;
-  delete process.env.SM_RCA_DISABLE;
-  purgeRequireCache();
-  rcaReport = require('../lib/rcaReport.cjs');
-});
-
-afterEach(() => {
-  process.env.HOME = realHome;
-  delete process.env.SM_RCA_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  purgeRequireCache();
-});
-
-// ─── helpers ──────────────────────────────────────────────────────────────────
-
-function makeProject(name = 'proj') {
-  const cwd = path.join(tmpHome, name);
-  fs.mkdirSync(cwd, { recursive: true });
-  return cwd;
-}
-
-function writeRun(runDir, slug, { logLines = ['line1', 'line2'], exitCode = 1, durationMs = 1234 } = {}) {
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(path.join(runDir, `${slug}.log`), logLines.join('\n') + '\n');
-  fs.writeFileSync(path.join(runDir, `${slug}.meta.json`), JSON.stringify({ exitCode, durationMs }));
-}
-
-function writePrd(cwd, slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  const body = ['---', `title: ${slug}`, '---', '', '# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', acBody, '', '# Out of scope', '', '- N/A'].join('\n');
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
-}
-
-function baseJob(overrides = {}) {
-  return { slug: 'testslug', runId: '2026-07-24T00-00-00-000Z', exitCode: 1, error: 'something broke', ...overrides };
-}
-
-function readSessions(cwd) {
-  const p = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  if (!fs.existsSync(p)) return {};
-  return JSON.parse(fs.readFileSync(p, 'utf8')).sessions ?? {};
-}
-
-// ─── report writing ──────────────────────────────────────────────────────────
-
-test('writeRcaReport: writes root-cause-<slug>.md into the run directory', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(true);
-  expect(res.path).toBe(path.join(runDir, 'root-cause-testslug.md'));
-  const body = fs.readFileSync(res.path, 'utf8');
-  expect(body).toContain('prdSlug: testslug');
-  expect(body).toContain('# What happened');
-  expect(body).toContain('# The PRD\'s acceptance criteria');
-  expect(body).toContain('timeout 10 echo ok');
-  expect(res.summary).toContain('testslug');
-  expect(res.summary.split('\n')).toHaveLength(1);
-});
-
-test('writeRcaReport: creates no Epic — a parked job never opens work on its own', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(readSessions(cwd)).toEqual({});
-});
-
-test('writeRcaReport: a second call for the same run overwrites in place, never duplicates', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
-
-  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-  const second = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-
-  expect(second.path).toBe(first.path);
-  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(1);
-});
-
-test('writeRcaReport: investigationText enriches the report in place', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
-
-  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-  expect(fs.readFileSync(first.path, 'utf8')).not.toContain('## Investigation analysis');
-
-  const second = await rcaReport.writeRcaReport({
-    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
-  });
-
-  expect(second.path).toBe(first.path);
-  const enriched = fs.readFileSync(second.path, 'utf8');
-  expect(enriched).toContain('## Investigation analysis');
-  expect(enriched).toContain('forgot to bound the poll loop');
-});
-
-test('writeRcaReport: works for a job whose PRD cannot be read (no acceptance criteria on record)', async () => {
-  const cwd = makeProject('bare-proj');
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(true);
-  expect(fs.readFileSync(res.path, 'utf8')).toContain('acceptance criteria not found');
-});
-
-// ─── skip paths ──────────────────────────────────────────────────────────────
-
-test('writeRcaReport: rejects a slug containing path-traversal segments', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  fs.mkdirSync(runDir, { recursive: true });
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd, slug: '../../etc/passwd' }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('unsafe-slug');
-});
-
-test('writeRcaReport: skips when there is no run directory to write into', async () => {
-  const cwd = makeProject();
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('no-run-dir');
-});
-
-// ─── recovery actions ────────────────────────────────────────────────────────
-
-test('RECOVERY_ACTIONS: every FAILURE_CLASSES member has an entry from the closed set', () => {
-  const CLOSED_SET = new Set(['archive', 'resume-and-commit', 'verify-and-close', 'investigate']);
-  for (const failureClass of Object.values(rcaReport.FAILURE_CLASSES)) {
-    expect(rcaReport.RECOVERY_ACTIONS).toHaveProperty(failureClass);
-    expect(CLOSED_SET.has(rcaReport.RECOVERY_ACTIONS[failureClass])).toBe(true);
-  }
-});
-
-test('recoveryActionFor: maps each known failure class to its expected action', () => {
-  const { FAILURE_CLASSES, recoveryActionFor } = rcaReport;
-  expect(recoveryActionFor(FAILURE_CLASSES.ALREADY_SHIPPED)).toBe('archive');
-  expect(recoveryActionFor(FAILURE_CLASSES.UNCOMMITTED)).toBe('resume-and-commit');
-  expect(recoveryActionFor(FAILURE_CLASSES.NO_SENTINEL)).toBe('verify-and-close');
-  expect(recoveryActionFor(FAILURE_CLASSES.SELF_QUEUE)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.STUCK_LOOP)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.POST_AC_OVERRUN)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.TRANSCRIPT_ERRORS)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.UNKNOWN)).toBe('investigate');
-});
-
-test('recoveryActionFor: defaults to investigate for an unrecognised class', () => {
-  expect(rcaReport.recoveryActionFor('totally-made-up-class')).toBe('investigate');
-  expect(rcaReport.recoveryActionFor(undefined)).toBe('investigate');
-});
-
-test('writeRcaReport: markdown carries a machine-readable recovery-action line matching recoveryActionFor, for each failure class', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const cases = [
-    { verdict: 'pass_no_commit', logTail: 'The work was already implemented in a prior commit.', expectedClass: rcaReport.FAILURE_CLASSES.ALREADY_SHIPPED },
-    { verdict: 'transcript_errors', logTail: 'Launching skill: session-manager-dev:develop', expectedClass: rcaReport.FAILURE_CLASSES.SELF_QUEUE },
-    { verdict: 'transcript_errors', logTail: 'while true; do sleep 1; done', expectedClass: rcaReport.FAILURE_CLASSES.STUCK_LOOP },
-    { verdict: 'uncommitted_changes', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.UNCOMMITTED },
-    { verdict: 'no_verdict_sentinel', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.NO_SENTINEL },
-    { verdict: 'transcript_errors', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.TRANSCRIPT_ERRORS },
-    { verdict: 'some_other_verdict', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.UNKNOWN },
-  ];
-
-  for (const { verdict, logTail, expectedClass } of cases) {
-    writeRun(runDir, 'testslug', { logLines: logTail.split('\n') });
-    const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict });
-    expect(res.failureClass).toBe(expectedClass);
-    const expectedAction = rcaReport.recoveryActionFor(expectedClass);
-    expect(res.recoveryAction).toBe(expectedAction);
-    const body = fs.readFileSync(res.path, 'utf8');
-    expect(body).toContain(`recovery-action: ${expectedAction}`);
-  }
-});
-
-test('writeRcaReport: SM_RCA_DISABLE=1 skips without writing', async () => {
-  process.env.SM_RCA_DISABLE = '1';
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('disabled');
-  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(0);
-});
-
-test('classifyFailure: blocked_by_foreign_wip_streak verdict classifies as BLOCKED_BY_FOREIGN_WIP, never UNKNOWN', () => {
-  const failureClass = rcaReport.classifyFailure({ verdict: 'blocked_by_foreign_wip_streak', logTail: 'anything' });
-  expect(failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
-});
-
-test('writeRcaReport: a blocked_by_foreign_wip_streak verdict points at the sibling job, not "re-run the gate"', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run-blocked');
-  writeRun(runDir, 'blockedslug');
-  writePrd(cwd, 'blockedslug');
-
-  const res = await rcaReport.writeRcaReport({
-    job: baseJob({ cwd, slug: 'blockedslug' }),
-    runDir,
-    verdict: 'blocked_by_foreign_wip_streak',
-  });
-
-  expect(res.filed).toBe(true);
-  expect(res.failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
-  const body = fs.readFileSync(res.path, 'utf8');
-  expect(body).toMatch(/sibling job/i);
-  expect(body).not.toMatch(/Re-run the acceptance criteria gate/);
-});