claude-code-session-manager 0.36.0 → 0.37.1

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

@@ -0,0 +1,233 @@
+/**
+ * queueHistory.test.cjs — unit tests for src/main/lib/queueHistory.cjs and
+ * scheduler.cjs's selectHistoryJobs merge.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/queueHistory.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');
+
+const RETENTION_MS = 7 * 24 * 60 * 60_000;
+const NOW = Date.parse('2026-07-24T12:00:00.000Z');
+
+function fresh(overrides = {}) {
+  return {
+    slug: '01-fresh',
+    status: 'completed',
+    runId: 'run-1',
+    finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString(), // 1h ago
+    ...overrides,
+  };
+}
+
+function old(overrides = {}) {
+  return {
+    slug: '02-old',
+    status: 'completed',
+    runId: 'run-2',
+    finishedAt: new Date(NOW - 10 * 24 * 60 * 60_000).toISOString(), // 10d ago
+    ...overrides,
+  };
+}
+
+let queueHistory;
+
+beforeEach(() => {
+  // Fresh require per test so HISTORY_PATH's target file starts clean.
+  delete require.cache[require.resolve('../lib/queueHistory.cjs')];
+  queueHistory = require('../lib/queueHistory.cjs');
+  try { fs.unlinkSync(queueHistory.HISTORY_PATH); } catch { /* ok if absent */ }
+});
+
+afterEach(() => {
+  try { fs.unlinkSync(queueHistory.HISTORY_PATH); } catch { /* ok if absent */ }
+});
+
+// ---------- partitionJobs ----------
+
+test('partitionJobs: fresh completed job stays hot', () => {
+  const { hot, toArchive } = queueHistory.partitionJobs([fresh()], NOW);
+  expect(hot.map((j) => j.slug)).toEqual(['01-fresh']);
+  expect(toArchive).toEqual([]);
+});
+
+test('partitionJobs: old completed job archives', () => {
+  const { hot, toArchive } = queueHistory.partitionJobs([old()], NOW);
+  expect(hot).toEqual([]);
+  expect(toArchive.map((j) => j.slug)).toEqual(['02-old']);
+});
+
+test('partitionJobs: old failed job archives', () => {
+  const j = old({ slug: '03-old-failed', status: 'failed', runId: 'run-3' });
+  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
+  expect(hot).toEqual([]);
+  expect(toArchive.map((x) => x.slug)).toEqual(['03-old-failed']);
+});
+
+test('partitionJobs: running and pending jobs never archive, regardless of age', () => {
+  const running = old({ slug: '04-running', status: 'running', runId: 'run-4', finishedAt: null });
+  const pending = old({ slug: '05-pending', status: 'pending', runId: null, finishedAt: null });
+  const { hot, toArchive } = queueHistory.partitionJobs([running, pending], NOW);
+  expect(toArchive).toEqual([]);
+  expect(hot.map((j) => j.slug).sort()).toEqual(['04-running', '05-pending']);
+});
+
+test('partitionJobs: needs_review jobs never archive', () => {
+  const j = old({ slug: '06-review', status: 'needs_review', runId: 'run-6' });
+  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
+  expect(toArchive).toEqual([]);
+  expect(hot.map((x) => x.slug)).toEqual(['06-review']);
+});
+
+test('partitionJobs: job with no/invalid finishedAt stays hot even if old status', () => {
+  const j = { slug: '07-nofinish', status: 'completed', runId: 'run-7', finishedAt: null };
+  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
+  expect(toArchive).toEqual([]);
+  expect(hot.map((x) => x.slug)).toEqual(['07-nofinish']);
+});
+
+test('partitionJobs: fix-plan linkage keeps an old original hot while its fix is pending', () => {
+  const original = old({ slug: '08-thing', status: 'failed', runId: 'run-8' });
+  const fixPlan = { slug: '08-fix-thing', status: 'pending', runId: null, finishedAt: null };
+  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
+  expect(toArchive).toEqual([]);
+  expect(hot.map((x) => x.slug).sort()).toEqual(['08-fix-thing', '08-thing']);
+});
+
+test('partitionJobs: fix-plan linkage keeps an old original hot while its fix is running', () => {
+  const original = old({ slug: '09-thing', status: 'failed', runId: 'run-9' });
+  const fixPlan = { slug: '09-fix-thing', status: 'running', runId: 'run-9b', finishedAt: null };
+  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
+  expect(toArchive).toEqual([]);
+  expect(hot.map((x) => x.slug).sort()).toEqual(['09-fix-thing', '09-thing']);
+});
+
+test('partitionJobs: an old original with a COMPLETED fix-plan is free to archive (no longer protected)', () => {
+  const original = old({ slug: '10-thing', status: 'completed', runId: 'run-10' });
+  const fixPlan = old({ slug: '10-fix-thing', status: 'completed', runId: 'run-10b' });
+  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
+  expect(hot).toEqual([]);
+  expect(toArchive.map((x) => x.slug).sort()).toEqual(['10-fix-thing', '10-thing']);
+});
+
+test('partitionJobs: respects opts.retentionMs override', () => {
+  const j = { slug: '11-recent', status: 'completed', runId: 'run-11', finishedAt: new Date(NOW - 2 * 60 * 60_000).toISOString() };
+  const { toArchive } = queueHistory.partitionJobs([j], NOW, { retentionMs: 60 * 60_000 }); // 1h retention
+  expect(toArchive.map((x) => x.slug)).toEqual(['11-recent']);
+});
+
+// ---------- appendHistory / readHistory ----------
+
+test('appendHistory writes entries, readHistory reads them back newest-first', async () => {
+  const a = old({ slug: 'a', runId: 'ra', finishedAt: new Date(NOW - 3 * 60 * 60_000).toISOString() });
+  const b = old({ slug: 'b', runId: 'rb', finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString() });
+  await queueHistory.appendHistory([a, b]);
+  const read = await queueHistory.readHistory({ limit: 10 });
+  // appended in file order a,b; readHistory reverses file order to newest-appended-first
+  expect(read.map((j) => j.slug)).toEqual(['b', 'a']);
+});
+
+test('appendHistory dedupes by slug+runId against what is already on disk', async () => {
+  const a = old({ slug: 'dup', runId: 'r1' });
+  const r1 = await queueHistory.appendHistory([a]);
+  expect(r1.appended).toBe(1);
+  const r2 = await queueHistory.appendHistory([a]); // replay of the same batch (crash-recovery scenario)
+  expect(r2.appended).toBe(0);
+  const read = await queueHistory.readHistory({ limit: 10 });
+  expect(read.length).toBe(1);
+});
+
+test('readHistory respects limit and returns [] when file is absent', async () => {
+  const empty = await queueHistory.readHistory({ limit: 5 });
+  expect(empty).toEqual([]);
+
+  const entries = Array.from({ length: 8 }, (_, i) => old({ slug: `s${i}`, runId: `r${i}`, finishedAt: new Date(NOW - i * 60_000).toISOString() }));
+  await queueHistory.appendHistory(entries);
+  const read = await queueHistory.readHistory({ limit: 3 });
+  expect(read.length).toBe(3);
+  // newest-appended-first == last 3 entries reversed
+  expect(read.map((j) => j.slug)).toEqual(['s7', 's6', 's5']);
+});
+
+test('readHistory tail-reads correctly when the file is larger than one chunk', async () => {
+  // Force many small appends so the file exceeds the initial 64KB read chunk.
+  const bigEntries = Array.from({ length: 2000 }, (_, i) => ({
+    slug: `bulk-${i}`,
+    status: 'completed',
+    runId: `bulk-run-${i}`,
+    finishedAt: new Date(NOW - i * 1000).toISOString(),
+    bodyPreview: 'x'.repeat(80),
+  }));
+  await queueHistory.appendHistory(bigEntries);
+  const read = await queueHistory.readHistory({ limit: 5 });
+  // appended in ascending index order; readHistory reverses to newest-appended-first
+  expect(read.map((j) => j.slug)).toEqual(['bulk-1999', 'bulk-1998', 'bulk-1997', 'bulk-1996', 'bulk-1995']);
+});
+
+// ---------- selectHistoryJobs merge (scheduler.cjs) ----------
+
+test('selectHistoryJobs merges hot jobs[] and history tail, newest-first, deduped', () => {
+  const { selectHistoryJobs } = require('../scheduler.cjs');
+  const hotJob = fresh({ slug: 'hot-1', runId: 'rh1' });
+  const historyEntry = old({ slug: 'hist-1', runId: 'rhist1' });
+  const merged = selectHistoryJobs([hotJob], 10, [historyEntry]);
+  expect(merged.map((j) => j.slug)).toEqual(['hot-1', 'hist-1']); // hot is newer
+});
+
+test('selectHistoryJobs: jobs[] entry wins over a duplicate history entry with the same slug+runId', () => {
+  const { selectHistoryJobs } = require('../scheduler.cjs');
+  const hotCopy = fresh({ slug: 'dup', runId: 'rd', bodyPreview: 'from-hot' });
+  const historyCopy = fresh({ slug: 'dup', runId: 'rd', bodyPreview: 'from-history' });
+  const merged = selectHistoryJobs([hotCopy], 10, [historyCopy]);
+  expect(merged.length).toBe(1);
+  expect(merged[0].bodyPreview).toBe('from-hot');
+});
+
+test('selectHistoryJobs: default historyEntries=[] preserves old call shape', () => {
+  const { selectHistoryJobs } = require('../scheduler.cjs');
+  const merged = selectHistoryJobs([fresh()], 10);
+  expect(merged.map((j) => j.slug)).toEqual(['01-fresh']);
+});
+
+// ---------- historyTerminalBySlug ----------
+//
+// Guards against scheduler.cjs's reconcile() resurrecting an already-
+// archived-to-history job as a fresh 'pending' entry (and the scheduler
+// then genuinely re-executing an already-completed PRD) just because its
+// job row already left jobs[]. reconcile() consults this map before
+// treating an unmatched on-disk PRD slug as brand-new.
+
+test('historyTerminalBySlug: returns status + finishedAt for every archived slug', async () => {
+  const a = old({ slug: 'term-completed', status: 'completed', runId: 'rc' });
+  const b = old({ slug: 'term-failed', status: 'failed', runId: 'rf' });
+  await queueHistory.appendHistory([a, b]);
+
+  const map = await queueHistory.historyTerminalBySlug();
+  expect(map.get('term-completed')).toEqual({ status: 'completed', finishedAt: a.finishedAt });
+  expect(map.get('term-failed')).toEqual({ status: 'failed', finishedAt: b.finishedAt });
+  expect(map.has('never-archived-slug')).toBe(false);
+});
+
+test('historyTerminalBySlug: returns an empty map when history.jsonl is absent', async () => {
+  const map = await queueHistory.historyTerminalBySlug();
+  expect(map.size).toBe(0);
+});
+
+test('historyTerminalBySlug: cache invalidates after a new appendHistory call (mtime changes)', async () => {
+  const a = old({ slug: 'cache-1', runId: 'rca' });
+  await queueHistory.appendHistory([a]);
+  const first = await queueHistory.historyTerminalBySlug();
+  expect(first.has('cache-1')).toBe(true);
+  expect(first.has('cache-2')).toBe(false);
+
+  const b = old({ slug: 'cache-2', runId: 'rcb' });
+  await queueHistory.appendHistory([b]);
+  const second = await queueHistory.historyTerminalBySlug();
+  expect(second.has('cache-1')).toBe(true);
+  expect(second.has('cache-2')).toBe(true);
+});

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

@@ -0,0 +1,142 @@
+/**
+ * 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
+ * exercised only via its kill-switch / no-op branches, since archiveMany
+ * targets the real ~/.claude/session-manager/scheduled-plans/prds-archived
+ * directory (not test-injectable) — mutating that from a test run would be
+ * an unwanted side effect on the developer's real filesystem.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/queueOpsAutoArchive.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+
+const RETENTION_MS = 7 * 24 * 60 * 60_000;
+const NOW = Date.parse('2026-07-24T12:00:00.000Z');
+
+const { selectAutoArchivable, autoArchiveCompleted } = 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);
+});

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

@@ -0,0 +1,259 @@
+/**
+ * rcaFeedbackHook.test.cjs — unit tests for src/main/lib/rcaFeedbackHook.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/rcaFeedbackHook.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 rcaFeedbackHook;
+
+// config.cjs and rcaFeedbackHook.cjs both bake os.homedir() into top-level
+// consts at first require (allowedRoots/WRITE_PREFIXES, PRDS_DIR/SM_REPO_ROOT).
+// 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/rcaFeedbackHook.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-feedback-hook-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_RCA_DISABLE;
+  purgeRequireCache();
+  rcaFeedbackHook = require('../lib/rcaFeedbackHook.cjs');
+  // The session-manager-repo fallback destination must exist as a real dir.
+  fs.mkdirSync(path.join(tmpHome, 'Projects', 'session-manager', 'session-manager-operations', 'feedback'), { recursive: true });
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_RCA_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeProjectWithInbox(name = 'proj') {
+  const cwd = path.join(tmpHome, name);
+  fs.mkdirSync(path.join(cwd, 'session-manager-operations', 'feedback'), { recursive: true });
+  return cwd;
+}
+
+function makeProjectWithoutInbox(name = 'bare-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(slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
+  const prdsDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', '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 };
+}
+
+// ─── dedupe / new-runId ───────────────────────────────────────────────────────
+
+test('fileRcaFeedback: second call with same (slug, runId) is a no-op', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+
+  const second = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(second.filed).toBe(false);
+  expect(second.reason).toBe('duplicate');
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(1);
+});
+
+test('fileRcaFeedback: new runId for the same slug files a new RCA', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir1 = path.join(tmpHome, 'run1');
+  const runDir2 = path.join(tmpHome, 'run2');
+  writeRun(runDir1, 'testslug');
+  writeRun(runDir2, 'testslug');
+  writePrd('testslug');
+
+  const r1 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-aaa' }), runDir: runDir1, verdict: 'transcript_errors' });
+  const r2 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-bbb' }), runDir: runDir2, verdict: 'transcript_errors' });
+
+  expect(r1.filed).toBe(true);
+  expect(r2.filed).toBe(true);
+  expect(r1.path).not.toBe(r2.path);
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(2);
+});
+
+// ─── failure-class matching ───────────────────────────────────────────────────
+
+test('classifyFailure: detects stuck-loop from an until/while-true/sleep tail', () => {
+  const logTail = ['doing work', 'until curl -s http://x | jq .uptime; do sleep 5; done', 'still waiting'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('stuck-loop');
+});
+
+test('classifyFailure: detects post-ac-overrun when work continues well past the last AC checkbox with no PASS', () => {
+  const lines = ['- [x] first AC item done', '- [x] last AC item done'];
+  for (let i = 0; i < 30; i++) lines.push(`extra post-AC work line ${i}`);
+  const logTail = lines.join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('post-ac-overrun');
+});
+
+test('classifyFailure: falls back to uncommitted-changes for that verdict', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'uncommitted_changes', logTail: 'no special markers here' })).toBe('uncommitted-changes');
+});
+
+test('classifyFailure: falls back to no-sentinel for no_verdict_sentinel/pass_no_commit', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
+});
+
+test('classifyFailure: falls back to transcript-errors for transcript_errors/verify_unavailable', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'transcript_errors', logTail: 'Traceback (most recent call last)' })).toBe('transcript-errors');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'verify_unavailable', logTail: 'verifier threw' })).toBe('transcript-errors');
+});
+
+test('classifyFailure: unknown verdict with no matching markers falls back to unknown', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'halt', logTail: 'nothing special' })).toBe('unknown');
+});
+
+// ─── AC extraction ─────────────────────────────────────────────────────────────
+
+test('extractAcceptanceCriteria: pulls the section body between the heading and the next heading', () => {
+  const body = ['# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', '- [ ] one', '- [ ] two', '', '# Out of scope', '', '- N/A'].join('\n');
+  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBe('- [ ] one\n- [ ] two');
+});
+
+test('extractAcceptanceCriteria: returns null when no such heading exists', () => {
+  const body = ['# Goal', '', 'Do the thing.'].join('\n');
+  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBeNull();
+});
+
+// ─── investigation <RCA> block extraction ──────────────────────────────────────
+
+test('extractRcaBlock: pulls plain-text block content', () => {
+  const log = 'preamble\n<RCA>\nForgot to bound the poll loop.\n</RCA>\npostamble';
+  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.');
+});
+
+test('extractRcaBlock: unescapes JSON-escaped newlines from a stream-json transcript', () => {
+  const log = '{"text":"<RCA>\\nForgot to bound the poll loop.\\nSee scheduler.cjs:1509.\\n</RCA>"}';
+  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.\nSee scheduler.cjs:1509.');
+});
+
+test('extractRcaBlock: returns null when no block is present', () => {
+  expect(rcaFeedbackHook.extractRcaBlock('no block here')).toBeNull();
+});
+
+// ─── destination resolution ────────────────────────────────────────────────────
+
+test('resolveDestination: uses the job cwd inbox when it exists', () => {
+  const cwd = makeProjectWithInbox();
+  const dest = rcaFeedbackHook.resolveDestination({ cwd });
+  expect(dest.dir).toBe(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(dest.targetProjectNote).toBeNull();
+});
+
+test('resolveDestination: falls back to the session-manager repo inbox when the target has none', () => {
+  const cwd = makeProjectWithoutInbox();
+  const dest = rcaFeedbackHook.resolveDestination({ cwd });
+  expect(dest.dir).toBe(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR);
+  expect(dest.targetProjectNote).toContain(cwd);
+});
+
+test('fileRcaFeedback: actually writes into the fallback dir when the target inbox is missing', async () => {
+  const cwd = makeProjectWithoutInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(true);
+  expect(res.path.startsWith(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR)).toBe(true);
+  const content = fs.readFileSync(res.path, 'utf8');
+  expect(content).toContain(cwd);
+});
+
+test('fileRcaFeedback: rejects a slug containing path-traversal segments', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  fs.mkdirSync(runDir, { recursive: true });
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, slug: '../../etc/passwd' }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('unsafe-slug');
+});
+
+// ─── kill-switch ────────────────────────────────────────────────────────────────
+
+test('fileRcaFeedback: SM_RCA_DISABLE=1 skips without writing', async () => {
+  process.env.SM_RCA_DISABLE = '1';
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('disabled');
+  expect(fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback')).length).toBe(0);
+});
+
+// ─── investigation-text enrichment ──────────────────────────────────────────────
+
+test('fileRcaFeedback: investigationText updates the existing RCA instead of duplicating it', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+  const before = fs.readFileSync(first.path, 'utf8');
+  expect(before).not.toContain('## Investigation analysis');
+
+  const second = await rcaFeedbackHook.fileRcaFeedback({
+    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
+  });
+  expect(second.filed).toBe(true);
+  expect(second.updated).toBe(true);
+  expect(second.path).toBe(first.path);
+
+  const after = fs.readFileSync(second.path, 'utf8');
+  expect(after).toContain('## Investigation analysis');
+  expect(after).toContain('forgot to bound the poll loop');
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(1);
+});