claude-code-session-manager 0.39.1 → 0.39.2

package/dist/index.html

@@ -7,10 +7,10 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-CefVSjmm.js"></script>
+    <script type="module" crossorigin src="./assets/index-BPbLVT6E.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-B6JNrbpD.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-DVlD8N1X.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.39.1",
+  "version": "0.39.2",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -31,13 +31,13 @@
     "postinstall": "node scripts/postinstall.cjs",
     "prepublishOnly": "vite build",
     "test:unit": "vitest run",
-    "test:verify": "node src/main/__tests__/runVerify.test.cjs",
     "test:e2e": "xvfb-run -a playwright test",
     "smoke:darwin": "playwright test tests/smoke/darwin-boot.spec.ts",
     "test:e2e:mic": "xvfb-run -a playwright test e2e/mic.spec.mjs",
     "test:e2e:gen-fixture": "espeak-ng -w /tmp/sm-raw.wav -s 140 'testing one two three four five' && ffmpeg -y -i /tmp/sm-raw.wav -ar 48000 -ac 2 -sample_fmt s16 e2e/fixtures/speech.wav",
     "refresh:vad-assets": "cp node_modules/@ricky0123/vad-web/dist/silero_vad_v5.onnx node_modules/@ricky0123/vad-web/dist/vad.worklet.bundle.min.js src/renderer/public/vad/ && cp node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.wasm node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.mjs node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.jsep.wasm node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.jsep.mjs src/renderer/public/vad/",
-    "health": "node src/main/health.cjs"
+    "health": "node src/main/health.cjs",
+    "lint:selectors": "node scripts/check-unstable-selectors.cjs"
   },
   "keywords": [
     "claude",

package/scripts/lib/activeSessions.cjs

@@ -61,14 +61,18 @@ function readTailLines(filePath, maxBytes) {
  */
 function activeProjectCwds(maxAgeMin = 90, {
   projectsDir = path.join(HOME, '.claude', 'projects'),
+  maxCwds = MAX_CWDS,
 } = {}) {
+  // maxAgeMin === Infinity means "every project ever seen, no recency filter"
+  // (allProjectCwds below). Date.now() - Infinity is -Infinity, which every
+  // mtime clears — spelled out here because it reads like an accident.
   const cutoffMs = Date.now() - maxAgeMin * 60 * 1000;
   const seen = new Set();
   const result = [];
 
   function addCwd(cwd) {
     if (!cwd || typeof cwd !== 'string') return;
-    if (seen.has(cwd) || result.length >= MAX_CWDS) return;
+    if (seen.has(cwd) || result.length >= maxCwds) return;
     try { fs.statSync(cwd); } catch { return; } // must exist on disk
     seen.add(cwd);
     result.push(cwd);
@@ -79,7 +83,7 @@ function activeProjectCwds(maxAgeMin = 90, {
   try { slugs = fs.readdirSync(projectsDir); } catch { return result; }
 
   for (const slug of slugs) {
-    if (result.length >= MAX_CWDS) break;
+    if (result.length >= maxCwds) break;
     const projDir = path.join(projectsDir, slug);
     let entries;
     try {
@@ -114,4 +118,23 @@ function activeProjectCwds(maxAgeMin = 90, {
   return result;
 }
 
-module.exports = { activeProjectCwds };
+/**
+ * allProjectCwds(opts?) → string[]
+ *
+ * Every project cwd this machine has ever opened a Claude session in, with NO
+ * recency filter — the same transcript scan, minus the cutoff.
+ *
+ * Recency is the right question for "which projects should I sweep for new
+ * feedback". It is the WRONG question for "which projects own PRDs": a
+ * project that has been quiet for 90 minutes still owns its queued work, and
+ * treating its PRD dir as non-existent makes reconcile() read absence as
+ * deletion. (2026-07-31: 142 PRDs across 6 quiet projects went unscannable.)
+ *
+ * The cap is raised well above activeProjectCwds' 50 because this list is
+ * historical rather than "currently in flight".
+ */
+function allProjectCwds(opts = {}) {
+  return activeProjectCwds(Infinity, { maxCwds: 500, ...opts });
+}
+
+module.exports = { activeProjectCwds, allProjectCwds };

package/scripts/lib/watchdogHelpers.cjs

@@ -8,6 +8,7 @@ const os = require('node:os');
 const path = require('node:path');
 
 const { activeProjectCwds } = require('./activeSessions.cjs');
+const { resolvePrdWriteDir } = require('../../src/main/lib/prdLocations.cjs');
 
 // Mirrors scheduler.cjs:215 (single source of truth there; kept in sync here).
 const DEFAULT_HEARTBEAT_PATH = path.join(
@@ -101,9 +102,6 @@ function heartbeatFresh(heartbeatPath = DEFAULT_HEARTBEAT_PATH, maxAgeMs = DEFAU
 const DEFAULT_QUEUE_PATH = path.join(
   os.homedir(), '.claude', 'session-manager', 'scheduled-plans', 'queue.json',
 );
-const DEFAULT_PRDS_DIR = path.join(
-  os.homedir(), '.claude', 'session-manager', 'scheduled-plans', 'prds',
-);
 const PLUGIN_CACHE_ROOT = path.join(
   os.homedir(), '.claude', 'plugins', 'cache', 'session-manager', 'session-manager-dev',
 );
@@ -295,7 +293,7 @@ function hasOpenFeedback(cwd) {
  * Complexity: O(P) over PRD files in prdsDir + O(J) over queue jobs.
  */
 function emitFeedbackPRD(cwd, {
-  prdsDir = DEFAULT_PRDS_DIR,
+  prdsDir,
   queuePath = DEFAULT_QUEUE_PATH,
   skillPath,
   standardsPath,
@@ -303,7 +301,14 @@ function emitFeedbackPRD(cwd, {
 } = {}) {
   // Explicit overrides (used by tests) are honored verbatim and skip the
   // candidate search entirely — only resolve via candidates when the caller
-  // didn't pass a path.
+  // didn't pass a path. Same convention for prdsDir: an explicit override
+  // (tests pass a tmpdir) wins verbatim; otherwise resolve the project's own
+  // PRD dir so the sweep writer agrees with scheduler.cjs's reader (see
+  // prdLocations.cjs — PRD chain 808→811 moved PRD sources out of the legacy
+  // global dir into `<cwd>/session-manager-operations/scheduler/prds`).
+  if (prdsDir === undefined) {
+    prdsDir = resolvePrdWriteDir(cwd);
+  }
   const skillPathExplicit = skillPath !== undefined;
   const standardsPathExplicit = standardsPath !== undefined;
   if (!skillPathExplicit) {
@@ -616,7 +621,7 @@ function maybeRelaunchApp({
  */
 function sweep({
   projectsDir,
-  prdsDir = DEFAULT_PRDS_DIR,
+  prdsDir,
   queuePath = DEFAULT_QUEUE_PATH,
   skillPath,
   standardsPath,
@@ -634,6 +639,8 @@ function sweep({
     scanned++;
     if (!hasOpenFeedback(cwd)) continue;
 
+    // prdsDir unset → emitFeedbackPRD resolves per-cwd (project's own PRD
+    // dir); an explicit override (tests) is forwarded verbatim to every cwd.
     let result;
     try {
       result = emitFeedbackPRD(cwd, { prdsDir, queuePath, skillPath, standardsPath });

package/src/main/__tests__/browserView-destroyed-handler.test.cjs

@@ -0,0 +1,84 @@
+/**
+ * browserView-destroyed-handler.test.cjs — regression test for the
+ * webContents.id-after-destroy crash (see
+ * session-manager-operations/feedback/processed/
+ * 2026-07-30-rca-v0390-blank-screen-unstable-selector-185.md, item 4).
+ *
+ * The webContents `'destroyed'` handler used to read `view.webContents.id`
+ * from inside its own callback, after `view.webContents` could already be
+ * undefined — throwing "Cannot read properties of undefined (reading 'id')"
+ * on every app quit with an open Browser view. The fix captures the id at
+ * creation time, before the destroyed handler is registered.
+ *
+ * `electron` isn't installed as a runnable binary here, and browserView.cjs
+ * pulls it in via a plain CJS `require` (not vite-node's ESM graph), so
+ * `vi.mock('electron', ...)` doesn't intercept it. Instead we pre-seed
+ * Node's own require cache for the resolved `electron` path with a fake
+ * `WebContentsView`, the only export browserView.cjs actually uses.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/browserView-destroyed-handler.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach } from 'vitest';
+import { EventEmitter } from 'node:events';
+
+let nextWcId = 1;
+class FakeWebContents extends EventEmitter {
+  constructor() {
+    super();
+    this.id = nextWcId++;
+    this.session = { on() {} };
+  }
+  setZoomFactor() {}
+  setWindowOpenHandler() {}
+  isDestroyed() { return false; }
+}
+class FakeWebContentsView {
+  constructor() {
+    this.webContents = new FakeWebContents();
+  }
+}
+
+const electronPath = require.resolve('electron');
+require.cache[electronPath] = {
+  id: electronPath,
+  filename: electronPath,
+  loaded: true,
+  exports: { WebContentsView: FakeWebContentsView },
+};
+
+const { registerBrowserView, isBrowserViewContents, views } = require('../browserView.cjs');
+
+function makeFakeIpcMain() {
+  const handlers = new Map();
+  return {
+    handle: (channel, fn) => handlers.set(channel, fn),
+    on: (channel, fn) => handlers.set(channel, fn),
+    invoke: (channel, payload) => handlers.get(channel)(null, payload),
+  };
+}
+
+let ipcMain;
+beforeEach(() => {
+  ipcMain = makeFakeIpcMain();
+  registerBrowserView({ mainWindow: { isDestroyed: () => true }, ipcMain });
+});
+
+test('destroyed handler does not throw when view.webContents is already undefined', async () => {
+  const viewId = `t-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const result = await ipcMain.invoke('browser:create', { viewId, partition: 'sm-test' });
+  expect(result.ok).toBe(true);
+
+  const view = views.get(viewId);
+  const wc = view.webContents;
+  expect(isBrowserViewContents(wc.id)).toBe(true);
+
+  // Simulate the real crash precondition: webContents already gone by the
+  // time the 'destroyed' listener fires (e.g. on app quit).
+  view.webContents = undefined;
+
+  expect(() => wc.emit('destroyed')).not.toThrow();
+  expect(isBrowserViewContents(wc.id)).toBe(false);
+});

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

@@ -194,9 +194,15 @@ function validCreateBody(overrides = {}) {
 }
 
 async function startWithRemote(remote) {
+  // Force the e2e-suffixed token path so this suite never races the real
+  // ~/.claude/session-manager/admin-api.json against other test files (or a
+  // live production instance) that also call createAdminHttp() concurrently.
+  const prevE2e = process.env.SM_E2E;
+  process.env.SM_E2E = '1';
   const admin = createAdminHttp();
   registerAdminRoute(admin, remote);
   const { port, token } = await admin.start();
+  if (prevE2e === undefined) delete process.env.SM_E2E; else process.env.SM_E2E = prevE2e;
   return { admin, port, token };
 }
 

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

@@ -33,6 +33,47 @@ test('resolvePrdWriteDir throws on a missing cwd', () => {
   expect(() => resolvePrdWriteDir('')).toThrow();
 });
 
+test('resolvePrdsDirs still finds a QUIET project\'s PRDs dir (no recency filter)', async () => {
+  // Regression cover for 2026-07-31: discovery used activeProjectCwds' 90-min
+  // window, so a project nobody had touched recently became unscannable — and
+  // reconcile() reads an unscannable PRD as a deleted one and drops its queue
+  // row. 142 PRDs across 6 quiet projects were affected.
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-quiet-projects-'));
+  tmpDirs.push(projectsDir);
+  const quietCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-quiet-cwd-'));
+  tmpDirs.push(quietCwd);
+
+  // The project owns a real PRDs dir on disk...
+  fs.mkdirSync(resolvePrdWriteDir(quietCwd), { recursive: true });
+
+  const projDir = path.join(projectsDir, 'quiet-project');
+  fs.mkdirSync(projDir, { recursive: true });
+  const transcript = path.join(projDir, 'session1.jsonl');
+  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: quietCwd })}\n`);
+  // ...but its last session was a week ago, far outside the active window.
+  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+  fs.utimesSync(transcript, weekAgo, weekAgo);
+
+  const dirs = resolvePrdsDirs(90, { projectsDir });
+  expect(dirs).toContain(resolvePrdWriteDir(quietCwd));
+});
+
+test('resolvePrdsDirs skips a quiet project that owns no PRDs dir', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-nodir-projects-'));
+  tmpDirs.push(projectsDir);
+  const quietCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-nodir-cwd-'));
+  tmpDirs.push(quietCwd);
+
+  const projDir = path.join(projectsDir, 'quiet-no-prds');
+  fs.mkdirSync(projDir, { recursive: true });
+  const transcript = path.join(projDir, 'session1.jsonl');
+  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: quietCwd })}\n`);
+  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+  fs.utimesSync(transcript, weekAgo, weekAgo);
+
+  expect(resolvePrdsDirs(90, { projectsDir })).not.toContain(resolvePrdWriteDir(quietCwd));
+});
+
 test('resolvePrdsDirs maps each active project cwd to its own PRDs dir', async () => {
   const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdlocations-projects-'));
   tmpDirs.push(projectsDir);

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

@@ -103,6 +103,47 @@ test('migratePrds ignores non-.md and dotfiles, and no-ops on a missing legacy d
   expect(missing).toEqual({ moved: 0, skipped: 0, unresolved: [] });
 });
 
+test('migratePrds expands a tilde-prefixed cwd and moves the file', async () => {
+  const legacyDir = await mkLegacyDir();
+  const projectCwd = await fsp.mkdtemp(path.join(os.homedir(), '.sm-prdmigration-tilde-'));
+  tmpDirs.push(projectCwd);
+  const tildeCwd = path.join('~', path.relative(os.homedir(), projectCwd));
+  const body = `---\ntitle: Tilde cwd\ncwd: ${tildeCwd}\nestimateMinutes: 15\n---\n\nBody.\n`;
+  await fsp.writeFile(path.join(legacyDir, '07-tilde.md'), body, 'utf8');
+
+  const result = await migratePrds(legacyDir);
+
+  expect(result.moved).toBe(1);
+  expect(result.unresolved).toEqual([]);
+  const dest = path.join(resolvePrdWriteDir(projectCwd), '07-tilde.md');
+  expect(fs.existsSync(dest)).toBe(true);
+});
+
+test('migratePrds expands a tilde cwd under a temp HOME (regression: stale installs lacking expandHome leave these unresolved)', async () => {
+  const legacyDir = await mkLegacyDir();
+  const fakeHome = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-fakehome-'));
+  tmpDirs.push(fakeHome);
+  const projectCwd = path.join(fakeHome, 'Projects', 'session-manager');
+  await fsp.mkdir(projectCwd, { recursive: true });
+
+  const originalHome = process.env.HOME;
+  process.env.HOME = fakeHome;
+  try {
+    const body = `---\ntitle: Tilde under fake HOME\ncwd: ~/Projects/session-manager\nestimateMinutes: 15\n---\n\nBody.\n`;
+    await fsp.writeFile(path.join(legacyDir, '08-tilde-fakehome.md'), body, 'utf8');
+
+    const result = await migratePrds(legacyDir);
+
+    expect(result.moved).toBe(1);
+    expect(result.unresolved).toEqual([]);
+    expect(fs.existsSync(path.join(legacyDir, '08-tilde-fakehome.md'))).toBe(false);
+    const dest = path.join(resolvePrdWriteDir(projectCwd), '08-tilde-fakehome.md');
+    expect(fs.existsSync(dest)).toBe(true);
+  } finally {
+    process.env.HOME = originalHome;
+  }
+});
+
 test('migratePrds moves multiple PRDs to different projects independently', async () => {
   const legacyDir = await mkLegacyDir();
   const cwdA = await mkProjectCwd();

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

@@ -0,0 +1,106 @@
+/**
+ * promptSessionEvents.test.cjs — unit tests for appendResponseEventIfKnown
+ * (PRD 814): the scheduler's main-process counterpart to promptSessions.ts's
+ * event chain, used to route a PRD-finished notification into a known
+ * PromptSession's own event chain instead of an unrelated tab.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/promptSessionEvents.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const config = require('../config.cjs');
+const { appendResponseEventIfKnown, promptSessionActiveIndexPath } = require('../promptSessionEvents.cjs');
+
+let cwd;
+
+beforeEach(async () => {
+  cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prompt-session-events-'));
+  config.addAllowedRoot(cwd);
+});
+
+async function writeIndex(index) {
+  const indexPath = promptSessionActiveIndexPath(cwd);
+  await fsp.mkdir(path.dirname(indexPath), { recursive: true });
+  await fsp.writeFile(indexPath, JSON.stringify(index, null, 2));
+}
+
+test('returns false when no active-index.json exists for the cwd', async () => {
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-unknown', 'hi');
+  expect(routed).toBe(false);
+});
+
+test('returns false when the sourcePromptId is not in the index', async () => {
+  await writeIndex({ sessions: {}, events: {} });
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-unknown', 'hi');
+  expect(routed).toBe(false);
+});
+
+test('returns false when the session is completed (no longer active)', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'completed' } },
+    events: { 'psess-1': [{ id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' }] },
+  });
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'hi');
+  expect(routed).toBe(false);
+});
+
+test('appends a response event chained to the current tail and returns true', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+        { id: 'pevt-2', promptSessionId: 'psess-1', kind: 'prd_created', causedByEventId: 'pevt-1', at: '2026-01-01T00:01:00.000Z', prdSlug: '814-foo' },
+      ],
+    },
+  });
+
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD 814-foo finished: completed.');
+  expect(routed).toBe(true);
+
+  const onDisk = JSON.parse(await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8'));
+  const events = onDisk.events['psess-1'];
+  expect(events).toHaveLength(3);
+  expect(events[2].kind).toBe('response');
+  expect(events[2].causedByEventId).toBe('pevt-2');
+  expect(events[2].text).toBe('PRD 814-foo finished: completed.');
+});
+
+test('two different PromptSessions in the same cwd each get their own non-interleaved event appended', async () => {
+  await writeIndex({
+    sessions: {
+      'psess-a': { id: 'psess-a', cwd, status: 'active' },
+      'psess-b': { id: 'psess-b', cwd, status: 'active' },
+    },
+    events: {
+      'psess-a': [{ id: 'pevt-a1', promptSessionId: 'psess-a', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' }],
+      'psess-b': [{ id: 'pevt-b1', promptSessionId: 'psess-b', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' }],
+    },
+  });
+
+  const [routedA, routedB] = await Promise.all([
+    appendResponseEventIfKnown(cwd, 'psess-a', 'PRD A finished'),
+    appendResponseEventIfKnown(cwd, 'psess-b', 'PRD B finished'),
+  ]);
+  expect(routedA).toBe(true);
+  expect(routedB).toBe(true);
+
+  const onDisk = JSON.parse(await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8'));
+  expect(onDisk.events['psess-a']).toHaveLength(2);
+  expect(onDisk.events['psess-b']).toHaveLength(2);
+  expect(onDisk.events['psess-a'][1].text).toBe('PRD A finished');
+  expect(onDisk.events['psess-a'][1].causedByEventId).toBe('pevt-a1');
+  expect(onDisk.events['psess-b'][1].text).toBe('PRD B finished');
+  expect(onDisk.events['psess-b'][1].causedByEventId).toBe('pevt-b1');
+});
+
+test('returns false (never throws) when cwd or sourcePromptId is missing', async () => {
+  await expect(appendResponseEventIfKnown(null, 'psess-1', 'hi')).resolves.toBe(false);
+  await expect(appendResponseEventIfKnown(cwd, null, 'hi')).resolves.toBe(false);
+});

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

@@ -208,8 +208,8 @@ test('historyTerminalBySlug: returns status + finishedAt for every archived slug
   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.get('term-completed')).toEqual({ status: 'completed', finishedAt: a.finishedAt, landedCommit: null });
+  expect(map.get('term-failed')).toEqual({ status: 'failed', finishedAt: b.finishedAt, landedCommit: null });
   expect(map.has('never-archived-slug')).toBe(false);
 });
 

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

@@ -115,6 +115,62 @@ test('fileRcaFeedback: new runId for the same slug files a new RCA', async () =>
   expect(files.length).toBe(2);
 });
 
+test('fileRcaFeedback: a duplicate is still detected after /process-feedback archives the file into processed/', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+
+  const feedbackDir = path.join(cwd, 'session-manager-operations', 'feedback');
+  const processedDir = path.join(feedbackDir, 'processed');
+  fs.mkdirSync(processedDir, { recursive: true });
+  const fileName = path.basename(first.path);
+  fs.renameSync(first.path, path.join(processedDir, fileName));
+
+  const second = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(second.filed).toBe(false);
+  expect(second.reason).toBe('duplicate');
+  expect(second.path).toBe(path.join(processedDir, fileName));
+
+  expect(fs.existsSync(path.join(feedbackDir, fileName))).toBe(false);
+  const liveFiles = fs.readdirSync(feedbackDir).filter((f) => f !== 'processed');
+  expect(liveFiles.length).toBe(0);
+  expect(fs.readdirSync(processedDir).length).toBe(1);
+});
+
+test('fileRcaFeedback: investigationText updates the file in processed/ in place instead of duplicating it in the live dir', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+
+  const feedbackDir = path.join(cwd, 'session-manager-operations', 'feedback');
+  const processedDir = path.join(feedbackDir, 'processed');
+  fs.mkdirSync(processedDir, { recursive: true });
+  const fileName = path.basename(first.path);
+  const processedPath = path.join(processedDir, fileName);
+  fs.renameSync(first.path, processedPath);
+
+  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(processedPath);
+
+  const after = fs.readFileSync(processedPath, 'utf8');
+  expect(after).toContain('## Investigation analysis');
+  expect(fs.existsSync(path.join(feedbackDir, fileName))).toBe(false);
+});
+
 // ─── failure-class matching ───────────────────────────────────────────────────
 
 test('classifyFailure: detects stuck-loop from an until/while-true/sleep tail', () => {
@@ -147,6 +203,58 @@ test('classifyFailure: unknown verdict with no matching markers falls back to un
   expect(rcaFeedbackHook.classifyFailure({ verdict: 'halt', logTail: 'nothing special' })).toBe('unknown');
 });
 
+test('classifyFailure: detects self-queue from a "Launching skill: session-manager-dev:develop" tail', () => {
+  const logTail = ['doing setup', 'Launching skill: session-manager-dev:develop', 'skill running'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
+});
+
+test('classifyFailure: detects self-queue from a "Launching skill: session-manager-dev:process-feedback" tail', () => {
+  const logTail = ['doing setup', 'Launching skill: session-manager-dev:process-feedback', 'skill running'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
+});
+
+test('classifyFailure: detects self-queue from a ScheduleWakeup tool_use even when the tail also contains "sleep" (PRD 771 regression)', () => {
+  const logTail = [
+    'launching background build: eas-cli build --wait',
+    'the app will sleep between polls',
+    '{"type":"tool_use","name":"ScheduleWakeup","input":{"delaySeconds":600}}',
+  ].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
+});
+
+test('classifyFailure: detects already-shipped from a pass_no_commit tail citing a prior commit', () => {
+  const logTail = ['re-verified acceptance criteria', 'this work was already committed in 9cf0384', 'nothing left to change'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('already-shipped');
+});
+
+test('classifyFailure: detects already-shipped from a pass_no_commit tail with "nothing new to commit"', () => {
+  const logTail = ['checked the diff', 'nothing new to commit for this PRD', 'exiting clean'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('already-shipped');
+});
+
+test('classifyFailure: ALREADY_SHIPPED is checked before SELF_QUEUE, so a no_verdict_sentinel tail with both markers classifies as already-shipped', () => {
+  const logTail = [
+    'Launching skill: session-manager-dev:develop',
+    'the acceptance criteria were already implemented',
+  ].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('already-shipped');
+});
+
+test('classifyFailure: pass_no_commit tail with no already-shipped phrasing still falls back to no-sentinel (regression)', () => {
+  const logTail = ['ran the tests', 'everything looked fine', 'printed PASS'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('no-sentinel');
+});
+
+test('classifyFailure: STUCK_LOOP/POST_AC_OVERRUN reordering does not change classification when no self-queue marker is present', () => {
+  const stuckLoopTail = ['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: stuckLoopTail })).toBe('stuck-loop');
+
+  const postAcLines = ['- [x] first AC item done', '- [x] last AC item done'];
+  for (let i = 0; i < 30; i++) postAcLines.push(`extra post-AC work line ${i}`);
+  const postAcTail = postAcLines.join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: postAcTail })).toBe('post-ac-overrun');
+});
+
 // ─── AC extraction ─────────────────────────────────────────────────────────────
 
 test('extractAcceptanceCriteria: pulls the section body between the heading and the next heading', () => {