claude-code-session-manager 0.51.0 → 0.53.0

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-DPY5vv68.js"></script>
+    <script type="module" crossorigin src="./assets/index-D1v4VU6k.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-BXzDjHNE.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-BoOiJJOr.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.51.0",
+  "version": "0.53.0",
   "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",
@@ -28,6 +28,8 @@
     "dev:renderer": "vite",
     "dev:electron": "wait-on http://localhost:5173 && SM_DEV=1 electron .",
     "build": "vite build",
+    "build:project-pages": "node scripts/build-project-pages-renderer.mjs",
+    "build:project-pages-logic": "node scripts/build-project-pages-logic.mjs",
     "typecheck": "tsc --noEmit",
     "start": "electron .",
     "postinstall": "node scripts/postinstall.cjs",
@@ -124,6 +126,7 @@
     "@vitejs/plugin-react": "^4.3.3",
     "autoprefixer": "^10.4.20",
     "concurrently": "^9.1.0",
+    "esbuild": "^0.25.12",
     "jsdom": "^29.1.1",
     "postcss": "^8.4.49",
     "react": "^18.3.1",

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

@@ -200,6 +200,116 @@ test('findJoinableEpic falls through to the similarity check when preferEpicId p
   expect(joined).toEqual({ epicId: sibling.epicId, matchedBy: 'similarity', score: expect.any(Number) });
 });
 
+test('ensureEpic mints with status "proposed" by default', async () => {
+  const cwd = await mkCwd();
+
+  const minted = await ensureEpic(cwd, { goalText: 'default status epic' });
+
+  const index = readActiveIndex(cwd);
+  expect(index.sessions[minted.epicId].status).toBe('proposed');
+});
+
+test('ensureEpic throws when a mint is requested with status "active" (born-proposed law), and appends an audit event', async () => {
+  const cwd = await mkCwd();
+  const auditLog = require('../lib/auditLog.cjs');
+
+  await expect(
+    ensureEpic(cwd, { goalText: 'should never mint active', status: 'active' }),
+  ).rejects.toThrow(/born 'proposed'/);
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(0);
+
+  const records = fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line))
+    .filter((r) => r.cwd === cwd);
+  expect(records).toHaveLength(1);
+  expect(records[0].kind).toBe('epic_mint_refused');
+  expect(records[0].status).toBe('active');
+});
+
+test('ensureEpic still joins an existing active Epic via preferEpicId even when status:"active" is requested', async () => {
+  const cwd = await mkCwd();
+  const first = await ensureEpic(cwd, { goalText: 'already running epic' });
+  const index = readActiveIndex(cwd);
+  index.sessions[first.epicId].status = 'active';
+  fs.writeFileSync(
+    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
+    JSON.stringify(index, null, 2),
+  );
+
+  const second = await ensureEpic(cwd, { goalText: 'unrelated text', epicId: first.epicId, status: 'active' });
+
+  expect(second.created).toBe(false);
+  expect(second.epicId).toBe(first.epicId);
+});
+
+test('ensureEpic falls through to a "proposed" mint when explicit epicId is archived/completed, never throwing', async () => {
+  const cwd = await mkCwd();
+  const first = await ensureEpic(cwd, { goalText: 'completed epic' });
+  const index = readActiveIndex(cwd);
+  index.sessions[first.epicId].status = 'completed';
+  fs.writeFileSync(
+    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
+    JSON.stringify(index, null, 2),
+  );
+
+  const second = await ensureEpic(cwd, { goalText: 'totally unrelated goal text here', epicId: first.epicId });
+
+  expect(second.created).toBe(true);
+  expect(second.epicId).not.toBe(first.epicId);
+  const after = readActiveIndex(cwd);
+  expect(after.sessions[second.epicId].status).toBe('proposed');
+});
+
+function readAuditRecordsForCwd(auditLog, cwd) {
+  if (!fs.existsSync(auditLog.AUDIT_LOG_PATH)) return [];
+  return fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter((record) => record && record.cwd === cwd);
+}
+
+test('mintIfMissing:false refusal appends an epic_mint_refused audit event', async () => {
+  const cwd = await mkCwd();
+  const auditLog = require('../lib/auditLog.cjs');
+
+  await expect(ensureEpic(cwd, { goalText: 'no epic yet', mintIfMissing: false })).rejects.toThrow();
+
+  const records = readAuditRecordsForCwd(auditLog, cwd);
+  expect(records).toHaveLength(1);
+  expect(records[0].kind).toBe('epic_mint_refused');
+  expect(records[0].cwd).toBe(cwd);
+});
+
+test('not-open explicit-epicId fall-through appends an epic_mint_refused audit event', async () => {
+  const cwd = await mkCwd();
+  const first = await ensureEpic(cwd, { goalText: 'to be completed' });
+  const index = readActiveIndex(cwd);
+  index.sessions[first.epicId].status = 'completed';
+  fs.writeFileSync(
+    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
+    JSON.stringify(index, null, 2),
+  );
+  const auditLog = require('../lib/auditLog.cjs');
+
+  await ensureEpic(cwd, { goalText: 'unrelated fresh goal xyz', epicId: first.epicId });
+
+  const records = readAuditRecordsForCwd(auditLog, cwd);
+  const refusal = records.find((r) => r.kind === 'epic_mint_refused');
+  expect(refusal).toBeDefined();
+  expect(refusal.epicId).toBe(first.epicId);
+});
+
 test('ensureEpic with forceNewEpic:true mints even when a near-identical open Epic exists', async () => {
   const cwd = await mkCwd();
 

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

@@ -532,6 +532,11 @@ test('resolveSourcePromptIdFromClaudeSession finds the Epic whose claudeSessionI
   }
 });
 
+// Real-homedir-rooted like the chat-only-epic test above (see its comment at
+// line ~449): validatePath's read boundary is home-dir-wide, and this
+// exercises createPrd's real config.addAllowedRoot/writeTextAtomic path. Safe
+// because the random suffix is never a registered project the live scheduler
+// scans for PRDs, and it's removed in `finally`.
 test('createPrd resolves sourcePromptId from originClaudeSessionId when the caller omitted sourcePromptId', async () => {
   const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-epic-'));
   config.addAllowedRoot(root);
@@ -555,6 +560,7 @@ test('createPrd resolves sourcePromptId from originClaudeSessionId when the call
   }
 });
 
+// Same real-homedir rationale as the two tests above.
 test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches no known Epic (plain SessionTab chat)', async () => {
   const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-no-match-'));
   config.addAllowedRoot(root);

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

@@ -0,0 +1,152 @@
+/**
+ * prdLocationsArchived.test.cjs — unit tests for the archived-PRD discovery
+ * that backs `schedule:list-prds` including archived PRDs (PRD 926): an
+ * Epic's "PRDs" tab count must reflect its REAL historical PRD count, not
+ * just whatever is still sitting in its live `prds/` dir — a completed
+ * PRD's source .md moves to the sibling `prds-archived/` dir the instant its
+ * scheduler job finishes (scheduler.cjs's archiveCompletedPrd), which the
+ * old list-prds handler never read.
+ *
+ * Covers:
+ *   - resolveArchivedPrdsDirs finds an Epic's own `prds-archived/` dir
+ *     alongside the project's flat sibling one.
+ *   - deriveEpicIdFromPrdPath resolves an epicId for a file under
+ *     `prds-archived/`, not just the live `prds/` dir.
+ *   - scheduler.cjs's candidateArchivedPrdsDirs + candidatePrdsDirs
+ *     together surface both a still-pending PRD and an already-archived one
+ *     for the same Epic, without double-counting.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdLocationsArchived.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  resolveArchivedPrdsDirs,
+  resolvePrdsDirs,
+  resolveEpicPrdWriteDir,
+  deriveEpicIdFromPrdPath,
+} = require('../lib/prdLocations.cjs');
+const { candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus } = require('../scheduler.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+function mkEpicProject() {
+  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-cwd-'));
+}
+
+test('resolveArchivedPrdsDirs finds an Epic\'s own prds-archived/ dir for an active project', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-projects-'));
+  tmpDirs.push(projectsDir);
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-1');
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const projDir = path.join(projectsDir, 'epic-project');
+  fs.mkdirSync(projDir, { recursive: true });
+  const transcript = path.join(projDir, 'session1.jsonl');
+  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: projectCwd })}\n`);
+
+  const dirs = resolveArchivedPrdsDirs(90, { projectsDir });
+  expect(dirs).toContain(path.resolve(epicArchiveDir));
+});
+
+test('deriveEpicIdFromPrdPath resolves epicId for a file under prds-archived/, not just prds/', async () => {
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-42');
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const archivedFile = path.join(epicArchiveDir, '917-example.md');
+  fs.writeFileSync(archivedFile, '---\ntitle: example\n---\n\n# Goal\n');
+
+  expect(deriveEpicIdFromPrdPath(archivedFile)).toBe('epic-42');
+  // Still works for the live dir too — no regression.
+  const liveFile = path.join(epicPrdsDir, '918-example.md');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.writeFileSync(liveFile, '---\ntitle: example\n---\n\n# Goal\n');
+  expect(deriveEpicIdFromPrdPath(liveFile)).toBe('epic-42');
+});
+
+test('deriveEpicIdFromPrdPath returns null for an unrelated dir name', () => {
+  expect(deriveEpicIdFromPrdPath('/some/random/dir/917-example.md')).toBeNull();
+});
+
+test('resolvePrdsDirs + resolveArchivedPrdsDirs together surface a pending PRD dir and an archived PRD dir for the same Epic, with no overlap', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-both-projects-'));
+  tmpDirs.push(projectsDir);
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicId = `test-epic-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, epicId);
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const pendingSlug = `926-pending-${process.pid}`;
+  const archivedSlug = `917-archived-${process.pid}`;
+  fs.writeFileSync(path.join(epicPrdsDir, `${pendingSlug}.md`), `---\ntitle: pending\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
+  fs.writeFileSync(path.join(epicArchiveDir, `${archivedSlug}.md`), `---\ntitle: archived\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
+
+  const projDir = path.join(projectsDir, 'both-project');
+  fs.mkdirSync(projDir, { recursive: true });
+  fs.writeFileSync(path.join(projDir, 'session1.jsonl'), `${JSON.stringify({ cwd: projectCwd })}\n`);
+
+  const liveDirs = resolvePrdsDirs(90, { projectsDir });
+  const archivedDirs = resolveArchivedPrdsDirs(90, { projectsDir });
+  expect(liveDirs).toContain(epicPrdsDir);
+  expect(archivedDirs.map((d) => path.resolve(d))).toContain(path.resolve(epicArchiveDir));
+
+  // No overlap between the two dir sets for this Epic — an archived PRD's
+  // dir is never also scanned as a live one, and vice versa.
+  expect(liveDirs).not.toContain(epicArchiveDir);
+  expect(archivedDirs).not.toContain(epicPrdsDir);
+});
+
+test('resolveArchivedPrdStatus prefers the live queue.json row over history', () => {
+  const liveStatusBySlug = new Map([['917-slug', 'failed']]);
+  const histBySlug = new Map([['917-slug', { status: 'completed' }]]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
+});
+
+test('resolveArchivedPrdStatus falls back to history.jsonl when there is no live row', () => {
+  const liveStatusBySlug = new Map();
+  const histBySlug = new Map([['917-slug', { status: 'failed' }]]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
+});
+
+test('resolveArchivedPrdStatus defaults to completed when neither source has the slug', () => {
+  expect(resolveArchivedPrdStatus('917-slug', new Map(), new Map())).toBe('completed');
+});
+
+test('resolveArchivedPrdStatus normalizes any non-failed status (e.g. needs_review) to completed', () => {
+  const liveStatusBySlug = new Map([['917-slug', 'needs_review']]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, new Map())).toBe('completed');
+});
+
+test('scheduler.cjs exports candidateArchivedPrdsDirs alongside candidatePrdsDirs', () => {
+  expect(typeof candidatePrdsDirs).toBe('function');
+  expect(typeof candidateArchivedPrdsDirs).toBe('function');
+  // Both scan the real machine's projects — just assert they run without
+  // throwing and return arrays; per-Epic coverage is exercised above via
+  // the opts-injectable prdLocations functions directly.
+  expect(Array.isArray(candidatePrdsDirs())).toBe(true);
+  expect(Array.isArray(candidateArchivedPrdsDirs())).toBe(true);
+});

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

@@ -105,6 +105,11 @@ test('migratePrds ignores non-.md and dotfiles, and no-ops on a missing legacy d
 
 test('migratePrds expands a tilde-prefixed cwd and moves the file', async () => {
   const legacyDir = await mkLegacyDir();
+  // Deliberately rooted under the REAL os.homedir() (not os.tmpdir()) — the
+  // assertion under test is tilde-expansion relative to the actual home dir,
+  // so a real homedir path is load-bearing here, not incidental. Still safe:
+  // the random suffix is never a registered project the live scheduler scans
+  // for PRDs, and it's removed in afterEach via tmpDirs/fsp.rm.
   const projectCwd = await fsp.mkdtemp(path.join(os.homedir(), '.sm-prdmigration-tilde-'));
   tmpDirs.push(projectCwd);
   const tildeCwd = path.join('~', path.relative(os.homedir(), projectCwd));

package/src/main/__tests__/scheduler-find-prd-dir.test.cjs

@@ -6,20 +6,53 @@
  * `<cwd>/session-manager-operations/scheduler/prds/`) must still resolve,
  * since findPrdDir's candidatePrdsDirs() searches the legacy dir first.
  *
- * Touches the real legacy PRDS_DIR (scheduler.cjs hard-codes it from
- * os.homedir(), same as other scheduler unit tests that exercise
- * global-path-backed exports) with a unique slug, and cleans up after itself.
+ * HOME-isolated (PRD 812 incident fix): scheduler.cjs derives PRDS_DIR from
+ * os.homedir() at module load. This test used to write straight into the
+ * REAL `~/.claude/session-manager/scheduled-plans/prds/` — the live
+ * scheduler's `reconcile()` scans that dir every 60s and enqueued the
+ * fixture as a phantom job (job 812-test-legacy-only-1975929-233060) before
+ * this test's own cleanup ran. Now HOME is stubbed to a mkdtemp dir BEFORE
+ * scheduler.cjs is first required, so PRDS_DIR resolves under the temp dir
+ * and nothing here can reach the real scheduler root. The
+ * `PRDS_DIR.startsWith(tmpHome)` guard is the regression test for that
+ * incident: if module-load ordering ever changes so the real homedir gets
+ * snapshotted first, this throws loudly instead of silently poisoning the
+ * live queue again.
  *
  * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-find-prd-dir.test.cjs
  */
 
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, beforeAll, afterAll } from 'vitest';
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { findPrdDir, PRDS_DIR } = require('../scheduler.cjs');
+
+let tmpHome;
+let originalHome;
+let findPrdDir;
+let PRDS_DIR;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-find-prd-dir-'));
+  process.env.HOME = tmpHome;
+
+  // Load AFTER HOME is stubbed — scheduler.cjs snapshots os.homedir() into
+  // PRDS_DIR at module load, not lazily.
+  ({ findPrdDir, PRDS_DIR } = require('../scheduler.cjs'));
+
+  // Hard guard: never let this test write into the real scheduler root.
+  if (!PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
 
 test('findPrdDir resolves a slug that exists only in the legacy global PRDs dir', async () => {
   const slug = `812-test-legacy-only-${process.pid}-${Math.floor(Math.random() * 1e6)}`;

package/src/main/__tests__/scheduler-prd-missing-skip.test.cjs

@@ -0,0 +1,89 @@
+/**
+ * scheduler-prd-missing-skip.test.cjs — regression test for PRD 812's
+ * failure-classification fix: a queued job whose PRD source has disappeared
+ * between enqueue and dispatch (e.g. a test fixture that leaked into the
+ * live queue and was cleaned up before the job ran) must be retired as a
+ * stale row (exitCode: 0, skipped: 'prd-missing'), not treated as a hard
+ * job failure (exitCode: -1). A genuinely unreadable/unparseable PRD (a
+ * real, non-ENOENT error) must still fail with exitCode: -1.
+ *
+ * HOME-isolated per the same incident: stub HOME to a mkdtemp dir before
+ * requiring scheduler.cjs, and never write into the real scheduler root.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-missing-skip.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let executeJob;
+let PRDS_DIR;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-skip-'));
+  process.env.HOME = tmpHome;
+
+  ({ executeJob, PRDS_DIR } = require('../scheduler.cjs'));
+
+  if (!PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test('a job whose PRD source is gone everywhere is retired, not failed', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-project-'));
+  // config.cjs's writeJsonSync (used for the job's meta.json) restricts
+  // writes to WRITE_PREFIXES, which includes `<home>/.claude` — so runDir
+  // must live under the stubbed tmpHome's .claude/, not the system tmpdir.
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-missing-run-'));
+  try {
+    const slug = `812-test-missing-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const job = { slug, cwd: projectCwd };
+
+    const result = await executeJob(job, runDir, projectCwd, () => {});
+
+    expect(result.exitCode).toBe(0);
+    expect(result.skipped).toBe('prd-missing');
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});
+
+test('a job whose PRD source exists but is unreadable for a non-ENOENT reason still fails', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-toobig-project-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-toobig-run-'));
+  try {
+    const slug = `812-test-toobig-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+    fs.mkdirSync(prdsDir, { recursive: true });
+    // parsePrd rejects any PRD over 1MB with a plain Error (no .code) — this
+    // is the "found but unparseable" case, distinct from ENOENT, and must
+    // stay a real failure.
+    const oversized = '---\ntitle: too big\n---\n\n' + 'x'.repeat(1024 * 1024 + 1);
+    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), oversized, 'utf8');
+
+    const job = { slug, cwd: projectCwd };
+    const result = await executeJob(job, runDir, projectCwd, () => {});
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.skipped).toBeUndefined();
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/scheduler-reap-dead-running-jobs.test.cjs

@@ -0,0 +1,103 @@
+/**
+ * scheduler-reap-dead-running-jobs.test.cjs — regression cover for PRD 935
+ * (reapDeadRunningJobs runningSet desync).
+ *
+ * spawnJob()'s completion path can write terminal run artifacts to disk and
+ * have its child process fully exit, yet still throw between executeJob()
+ * resolving and the completion mutate() finishing (e.g. writeQueue's
+ * unreadable guard). That throw is swallowed by spawnJob()'s catch, but its
+ * `finally` unconditionally deletes the job's slug from the in-memory
+ * runningSet — leaving queue.json stuck at status:"running" with a dead pid
+ * while runningSet no longer names it. reapDeadRunningJobs() used to gate its
+ * entire body on `runningSet.size === 0`, so this exact state made it return
+ * before ever reading queue.json — permanently invisible to reconciliation.
+ *
+ * This test reproduces that desync directly: a project queue.json job row
+ * with status:"running" and a dead pid, while runningSet (freshly loaded,
+ * never populated) does not contain its slug. It asserts the job still gets
+ * reconciled to a terminal status.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, since every
+ * path this code touches (queueStore's MACHINE_STATE_PATH, activeSessions'
+ * project scan root, scheduler.cjs's ROOT/RUNS_DIR, schedulerBatch's
+ * DEFAULT_PROJECT_CWD) is baked into a top-level const from os.homedir() at
+ * require time — this test must never be able to read or write real state.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reap-dead-running-jobs.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(), 'reap-dead-running-jobs-test-'));
+process.env.HOME = tmpHome;
+
+const { reapDeadRunningJobs } = require('../scheduler.cjs');
+
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, 'fake-project-slug');
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function writeProjectQueue(cwd, jobs) {
+  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
+  return path.join(stateDir, 'queue.json');
+}
+
+function writeRunLog(runId, slug, lines) {
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+test('reapDeadRunningJobs reconciles a queue.json row stuck at status:running with a dead pid, even when runningSet does not name its slug (desync repro)', async () => {
+  const projectCwd = path.join(tmpHome, 'a-project');
+  fs.mkdirSync(projectCwd, { recursive: true });
+  registerActiveProject(projectCwd);
+
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: 'desynced-job',
+      status: 'running',
+      cwd: projectCwd,
+      runId: 'run-desynced',
+      runtime: { pid: 999999 }, // guaranteed-dead pid (see reaperHelpers tests)
+    },
+  ]);
+  writeRunLog('run-desynced', 'desynced-job', [
+    '{"type":"result","subtype":"success","result":"done","is_error":false}',
+  ]);
+
+  // runningSet is a fresh module-level Set with nothing in it — this is the
+  // exact desynced state spawnJob()'s finally block can leave behind.
+  await reapDeadRunningJobs();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed', 'job must be reconciled from disk state, not skipped via the runningSet gate');
+  assert.equal(jobs[0].exitCode, 0);
+  assert.equal(jobs[0].runtime, undefined);
+});
+
+test('reapDeadRunningJobs is a no-op when no job is actually running in queue.json', async () => {
+  const projectCwd = path.join(tmpHome, 'b-project');
+  fs.mkdirSync(projectCwd, { recursive: true });
+  registerActiveProject(projectCwd);
+  const queuePath = writeProjectQueue(projectCwd, [
+    { slug: 'already-done', status: 'completed', cwd: projectCwd, exitCode: 0 },
+  ]);
+
+  await assert.doesNotReject(() => reapDeadRunningJobs());
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed');
+});

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

@@ -6,6 +6,14 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
+// HOME stubbed BEFORE requiring scheduler.cjs (PRD 812 fix): the last
+// describe block below calls scheduler.reconcile(), which internally calls
+// ensureDirs() → fs.mkdirSync on PRDS_DIR/RUNS_DIR — paths baked from
+// os.homedir() at require time. Without this stub that mkdirSync lands in
+// the real `~/.claude/session-manager/scheduled-plans/` tree.
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-832-home-'));
+process.env.HOME = tmpHome;
+
 const prdParser = require('../scheduler/prdParser.cjs');
 const { pickForProject } = require('../lib/schedulerBatch.cjs');
 

package/src/main/index.cjs

@@ -28,6 +28,7 @@ const voiceWizard = require('./voiceWizard.cjs');
 const scheduler = require('./scheduler.cjs');
 const { createAdminHttp } = require('./lib/localAdminHttp.cjs');
 const prdCreate = require('./lib/prdCreate.cjs');
+const { appendAuditEvent } = require('./lib/auditLog.cjs');
 const chatRunner = require('./chatRunner.cjs');
 const promptSessionEvents = require('./promptSessionEvents.cjs');
 const agentLibrary = require('./agentLibrary.cjs');
@@ -58,6 +59,7 @@ const schedulerConfig = require('./lib/schedulerConfig.cjs');
 const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const { registerProjectBriefIpc } = require('./projectBrief.cjs');
+const { registerProjectPagesIpc } = require('./projectPages.cjs');
 const promptSessionTranscript = require('./promptSessionTranscript.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
@@ -789,6 +791,7 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
 registerProjectBriefIpc();
+registerProjectPagesIpc();
 ipcMain.handle('promptSessionTranscript:append', validated(schemas.promptSessionTranscriptAppend, async ({ cwd, epicId, role, text, at, eventId }) => {
   const ok = await promptSessionTranscript.appendTurn(cwd, epicId, { role, text, at, eventId });
   return { ok };
@@ -797,6 +800,12 @@ ipcMain.handle('promptSessionTranscript:read', validated(schemas.promptSessionTr
   const turns = await promptSessionTranscript.readTurns(cwd, epicId, { limit });
   return { turns };
 }));
+// Renderer Epic lifecycle trace (PRD 940) — append-only, no read/list IPC.
+// Kind allowlist enforced by schemas.auditLogAppend, not here.
+ipcMain.handle('auditLog:append', validated(schemas.auditLogAppend, async ({ kind, cwd, epicId, source }) => {
+  appendAuditEvent(kind, { cwd, epicId, source });
+  return { ok: true };
+}));
 agentMemory.registerAgentMemoryHandlers();
 git.register(ipcMain);
 filesIpc.registerFilesHandlers();