claude-code-session-manager 0.89.0 → 0.91.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-BcJqLDiY.js"></script>
+    <script type="module" crossorigin src="./assets/index-ju-h7BFf.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-BHTX4OTc.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-CRPJslSA.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.89.0",
+  "version": "0.91.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",

package/scripts/README.md

@@ -10,6 +10,7 @@ scripts/lib was moved into src/main/lib (2026-09); nothing under src/ may requir
 | --- | --- | --- |
 | audit-ops-hygiene.cjs | manual; named in `ops-sweep` + `develop` SKILL.md | yes |
 | check-conditional-hooks.cjs | `npm run lint:hooks` (in `lint`) | no |
+| check-epic-transcripts.cjs | manual read-only diagnostic (`--json`); also surfaced as a non-fatal warning in `npm run health` | no |
 | check-doc-hierarchy.cjs | `npm run lint:docs` (in `lint`) | no |
 | check-unregistered-tests.cjs | `npm run lint:unregistered-tests` (in `lint`) | no |
 | check-unstable-selectors.cjs | `npm run lint:selectors` (in `lint`) | no |

package/src/main/__tests__/bilkoHost-integration.test.cjs

@@ -12,15 +12,12 @@ const bilkoHost = require('../bilkoHost.cjs');
 function makeProject() {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bilko-host-'));
   config.addAllowedRoot(root);
-  fs.mkdirSync(path.join(root, 'session-manager-operations', 'project-pages', 'output'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'session-manager-operations', 'project-pages'), { recursive: true });
   fs.writeFileSync(
     path.join(root, 'session-manager-operations', 'project-pages', 'home.html'),
     '<html><title>Demo</title>Home</html>',
   );
-  fs.writeFileSync(
-    path.join(root, 'session-manager-operations', 'project-pages', 'output', 'feature.html'),
-    '<html><title>Demo</title>Feature</html>',
-  );
+  fs.writeFileSync(path.join(root, 'feature.html'), '<html><title>Demo</title>Feature</html>');
   fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'demo-app', version: '1.2.3' }));
   return root;
 }
@@ -42,7 +39,7 @@ test('addDocument then prepareBundle writes a sub-path document at the expected
     cwd: root,
     subpath: 'special-doc/01',
     title: 'Feature deep-dive',
-    source: { kind: 'project-page-lens', lens: 'feature' },
+    source: { kind: 'file', path: 'feature.html' },
   });
   const result = await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
   assert.equal(
@@ -53,6 +50,22 @@ test('addDocument then prepareBundle writes a sub-path document at the expected
   fs.rmSync(root, { recursive: true, force: true });
 });
 
+test('a non-home project-page-lens document throws the retired-lens error (no output/ fallback)', async () => {
+  const root = makeProject();
+  await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
+  await bilkoHost.addDocument({
+    cwd: root,
+    subpath: 'special-doc/01',
+    title: 'Feature deep-dive',
+    source: { kind: 'project-page-lens', lens: 'feature' },
+  });
+  await assert.rejects(
+    () => bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' }),
+    /retired "feature" Project Page lens; only the single home\.html page is generated now/,
+  );
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
 test('removeDocument + prepareBundle wholesale-rebuilds dist/, leaving no trace of the removed file', async () => {
   const root = makeProject();
   await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
@@ -60,7 +73,7 @@ test('removeDocument + prepareBundle wholesale-rebuilds dist/, leaving no trace
     cwd: root,
     subpath: 'special-doc/01',
     title: 'Feature deep-dive',
-    source: { kind: 'project-page-lens', lens: 'feature' },
+    source: { kind: 'file', path: 'feature.html' },
   });
   await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
   const docId = added.documents.find((d) => d.subpath === 'special-doc/01').id;
@@ -95,10 +108,10 @@ test('addDocument refuses a duplicate sub-path', async () => {
     cwd: root,
     subpath: 'doc',
     title: 'A',
-    source: { kind: 'project-page-lens', lens: 'feature' },
+    source: { kind: 'file', path: 'feature.html' },
   });
   await assert.rejects(
-    () => bilkoHost.addDocument({ cwd: root, subpath: 'doc', title: 'B', source: { kind: 'project-page-lens', lens: 'feature' } }),
+    () => bilkoHost.addDocument({ cwd: root, subpath: 'doc', title: 'B', source: { kind: 'file', path: 'feature.html' } }),
     /already uses subpath/,
   );
   fs.rmSync(root, { recursive: true, force: true });

package/src/main/__tests__/chatRunner-session-flag-retry.test.cjs

@@ -0,0 +1,159 @@
+/**
+ * chatRunner-session-flag-retry.test.cjs — main is authoritative about
+ * --session-id vs --resume, and a CLI flag rejection is retried exactly once
+ * with the other flag without losing the turn.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/chatRunner-session-flag-retry.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let cr;
+let sent;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-flagretry-home-'));
+  process.env.HOME = tmpHome;
+  cr = require('../chatRunner.cjs');
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+  cr.__resetQueueForTests();
+  cr.attachWindow(null);
+});
+
+function attachRecorder() {
+  sent = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
+  });
+}
+
+// Stub claude: logs its argv (one JSON line per spawn) to logFile. Invocation 1
+// fails with `firstStderr` (optionally after emitting assistant text); later
+// invocations succeed.
+function writeStub(logFile, { firstStderr, textFirst }) {
+  const stubPath = path.join(os.tmpdir(), `sm-flagretry-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const log = ${JSON.stringify(logFile)};
+    fs.appendFileSync(log, JSON.stringify(process.argv.slice(2)) + '\\n');
+    const n = fs.readFileSync(log, 'utf8').trim().split('\\n').length;
+    if (n === 1) {
+      ${textFirst ? "process.stdout.write(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'partial' }] } }) + '\\n');" : ''}
+      process.stderr.write(${JSON.stringify(firstStderr)});
+      process.exit(1);
+    }
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
+    process.exit(0);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+async function waitFor(pred, timeoutMs = 8000) {
+  const start = Date.now();
+  while (!pred()) {
+    if (Date.now() - start > timeoutMs) throw new Error('timed out');
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
+const TERMINAL = ['chat:run:complete', 'chat:run:needs-input', 'chat:run:error'];
+let curTab;
+const terminals = () => sent.filter((e) => TERMINAL.includes(e.channel) && e.payload.tabId === curTab);
+const spawns = (logFile) => fs.readFileSync(logFile, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+
+test('in-use error on --session-id retries once with --resume; one terminal event; lane freed', async () => {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `flag-sess-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `Error: Session ID ${sessionId} is already in use.\n` });
+  try {
+    curTab = 'tab-a';
+    cr.run({ tabId: 'tab-a', sessionId, prompt: 'hello', cwd, resume: false });
+    await waitFor(() => terminals().length > 0);
+    await new Promise((r) => setTimeout(r, 100));
+
+    const argvs = spawns(logFile);
+    expect(argvs).toHaveLength(2);
+    expect(argvs[0]).toContain('--session-id');
+    expect(argvs[1]).toContain('--resume');
+    expect(argvs[1]).not.toContain('--session-id');
+    expect(argvs[1][argvs[1].indexOf('--model') + 1]).toBe(argvs[0][argvs[0].indexOf('--model') + 1]);
+    expect(argvs[1][1]).toBe(argvs[0][1]);
+
+    expect(terminals()).toHaveLength(1);
+    expect(terminals()[0].channel).toBe('chat:run:complete');
+    expect(sent.some((e) => e.channel === 'chat:run:notice')).toBe(true);
+
+    // Lane freed: the same tab accepts a new run immediately (not queued).
+    const again = cr.run({ tabId: 'tab-a', sessionId, prompt: 'again', cwd, resume: true });
+    expect(again.queued).toBe(false);
+    await cr.cancel('tab-a');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('no retry when the failed attempt already streamed assistant text', async () => {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `flag-sess2-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
+    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
+    textFirst: true,
+  });
+  try {
+    curTab = 'tab-b';
+    cr.run({ tabId: 'tab-b', sessionId, prompt: 'hello', cwd, resume: false });
+    await waitFor(() => terminals().length > 0);
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(spawns(logFile)).toHaveLength(1);
+    expect(terminals()).toHaveLength(1);
+    expect(terminals()[0].channel).toBe('chat:run:error');
+    expect(terminals()[0].payload.message).toMatch(/already in use/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('"No conversation found" on --resume retries once with --session-id (main overrides a wrong renderer flag only via transcript)', async () => {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `flag-sess3-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `No conversation found with session ID: ${sessionId}\n` });
+  try {
+    // No transcript exists anywhere → main computes resume=false even though
+    // the renderer said true, so the first attempt is --session-id and the
+    // stub's failure is the wrong-direction message: no retry, error surfaces.
+    curTab = 'tab-c';
+    cr.run({ tabId: 'tab-c', sessionId, prompt: 'hello', cwd, resume: true });
+    await waitFor(() => terminals().length > 0);
+    const argvs = spawns(logFile);
+    expect(argvs).toHaveLength(1);
+    expect(argvs[0]).toContain('--session-id');
+    expect(terminals()[0].channel).toBe('chat:run:error');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/health-delegation-chain.test.cjs

@@ -94,7 +94,9 @@ test('end-to-end: check() reports delegation_chain for this repo, expected to pa
   process.env.SM_ALLOW_LIVE_ROOT_READS = '1';
   let status;
   try {
-    status = await check();
+    // skipTypecheck: this test asserts on delegation_chain only; the tsc shell-out was
+    // ~15s of the ~16s idle runtime and starved to the 90s budget under CPU load.
+    status = await check({ skipTypecheck: true });
   } finally {
     delete process.env.SM_ALLOW_LIVE_ROOT_READS;
     process.env.HOME = sandboxHome;

package/src/main/__tests__/pollLoop-dispatch-on-failure.test.cjs

@@ -135,13 +135,19 @@ test('pollLoop still attempts a dispatch after a transient billing failure, usin
   await scheduler.writeQueue({ jobs: [], config: {}, paused: null });
 
   await seedOnePendingJob();
-  expect(await lastDispatchAttemptAt()).toBeNull();
+  // Baseline, not `toBeNull()`: under full-suite load a straggler tick from an
+  // earlier poll/test (spawnJob's completion tick, a slot-release pump) can
+  // stamp between the reset above and here, so the stamp is not guaranteed
+  // null. What the test proves is that THIS poll+flush advances the stamp.
+  const before = await lastDispatchAttemptAt();
 
   process.env.SM_MOCK_BILLING_KIND = 'transient';
   await scheduler.pollLoop();
   await flushPendingTick();
 
-  expect(await lastDispatchAttemptAt()).not.toBeNull();
+  const after = await lastDispatchAttemptAt();
+  expect(after).not.toBeNull();
+  expect(after).not.toBe(before);
 });
 
 test('pollLoop still attempts a dispatch after the billing poll throws, using the degraded budget (not utilization 0)', async () => {
@@ -152,7 +158,11 @@ test('pollLoop still attempts a dispatch after the billing poll throws, using th
   await scheduler.writeQueue({ jobs: [], config: {}, paused: null });
 
   await seedOnePendingJob();
-  expect(await lastDispatchAttemptAt()).toBeNull();
+  // Baseline, not `toBeNull()`: under full-suite load a straggler tick from an
+  // earlier poll/test (spawnJob's completion tick, a slot-release pump) can
+  // stamp between the reset above and here, so the stamp is not guaranteed
+  // null. What the test proves is that THIS poll+flush advances the stamp.
+  const before = await lastDispatchAttemptAt();
 
   delete process.env.SM_E2E;
   delete process.env.SM_MOCK_BILLING_KIND;
@@ -160,5 +170,7 @@ test('pollLoop still attempts a dispatch after the billing poll throws, using th
   await scheduler.pollLoop();
   await flushPendingTick();
 
-  expect(await lastDispatchAttemptAt()).not.toBeNull();
+  const after = await lastDispatchAttemptAt();
+  expect(after).not.toBeNull();
+  expect(after).not.toBe(before);
 });

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

@@ -163,3 +163,15 @@ test('bad JSON, missing/relative cwd, non-project cwd, and unknown keys are 400s
   expect(res.status).toBe(400);
   expect(res.body.error).toContain('not a Session Manager project');
 });
+
+test('one-file contract: project-pages holds exactly home.html after one write and after a regenerate', async () => {
+  const cwd = await mkProjectCwd();
+  const adminHttp = makeFakeAdminHttp();
+  registerAdminRoute(adminHttp);
+  const pagesDir = path.join(fs.realpathSync(cwd), 'session-manager-operations', 'project-pages');
+  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>first</p>' } });
+  expect(fs.readdirSync(pagesDir)).toEqual(['home.html']);
+  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>second, different</p>' } });
+  expect(fs.readdirSync(pagesDir)).toEqual(['home.html']);
+  expect(fs.readFileSync(path.join(pagesDir, 'home.html'), 'utf8')).toBe('<p>second, different</p>');
+});

package/src/main/__tests__/scheduler-default-eligible-heal.test.cjs

@@ -19,6 +19,13 @@ const path = require('node:path');
 
 process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'default-eligible-heal-test-'));
 
+// Fixture cwd must be a REAL, writable dir: transitionJob out of needs_review
+// fire-and-forgets a history append under <cwd>/session-manager-operations. A fake
+// path made it fail EACCES AFTER the sync test returned, so its console.error hit
+// vitest mid worker-close ("Closing rpc while onUserConsoleLog was pending").
+const PROJECT_CWD = path.join(process.env.HOME, 'project');
+fs.mkdirSync(PROJECT_CWD, { recursive: true });
+
 const {
   isRescanCandidate,
   isTranscriptRescannable,
@@ -39,7 +46,7 @@ const {
 } = require('../scheduler.cjs');
 const { evaluateBlockingParkHealth } = require('../health.cjs');
 
-const row = (o = {}) => ({ slug: '10-x', status: 'needs_review', runId: 'r1', cwd: '/p', ...o });
+const row = (o = {}) => ({ slug: '10-x', status: 'needs_review', runId: 'r1', cwd: PROJECT_CWD, ...o });
 
 test('shared_tree_reverted is a rescan candidate without being on any list', () => {
   assert.equal(RESCANNABLE_VERDICTS.has('shared_tree_reverted'), false);
@@ -142,8 +149,8 @@ test('auto-resolve ladder is capped: requeue attempts stop at NEEDS_REVIEW_RESOL
 describe('evaluateBlockingParkHealth', () => {
   const now = Date.parse('2026-09-18T20:00:00Z');
   const parkedAgo = (ms) => [{ to: 'needs_review', at: new Date(now - ms).toISOString() }];
-  const park = (ms, o = {}) => ({ slug: '5-park', status: 'needs_review', cwd: '/p', verifierVerdict: 'shared_tree_reverted', statusHistory: parkedAgo(ms), ...o });
-  const dep = (slug, dependsOn) => ({ slug, status: 'pending', cwd: '/p', dependsOn });
+  const park = (ms, o = {}) => ({ slug: '5-park', status: 'needs_review', cwd: PROJECT_CWD, verifierVerdict: 'shared_tree_reverted', statusHistory: parkedAgo(ms), ...o });
+  const dep = (slug, dependsOn) => ({ slug, status: 'pending', cwd: PROJECT_CWD, dependsOn });
 
   test('parked past one interval with pending dependents (transitive) is non-green, naming row + count', () => {
     const r = evaluateBlockingParkHealth([park(REVERIFY_INTERVAL_MS + 1000), dep('6-a', ['5-park']), dep('7-b', ['6-a']), dep('8-c', [])], now);

package/src/main/__tests__/scheduler-looks-done.test.cjs

@@ -210,7 +210,10 @@ test('needs_review with an in-window commit heals exactly as today (regression
     '- [ ] `npm test` passes',
   ].join('\n'));
 
-  const startedAt = new Date().toISOString();
+  // Window opens a minute back: the only commit here is initRepo's, and git's --since
+  // compares whole seconds, so `new Date()` (taken AFTER initRepo) drops it out of the
+  // window whenever the clock crosses a second boundary under load.
+  const startedAt = new Date(Date.now() - 60_000).toISOString();
   const queuePath = writeProjectQueue(projectCwd, [
     {
       slug: '20-clean-feature',
@@ -266,7 +269,6 @@ test('computeLooksDone: no declared paths on the PRD → null, never fabricates
 test('needs_review row with autoFixAttempted:true is never also stamped looksDone (PRD 1136 — mutually exclusive)', async () => {
   const projectCwd = path.join(tmpHome, 'proj-already-fix-planned');
   initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-already-fix-planned-slug');
   writePrd(projectCwd, '30-example', [
     '# Implementation notes',
     'Edit `src/thing.js`.',
@@ -301,6 +303,11 @@ test('needs_review row with autoFixAttempted:true is never also stamped looksDon
     JSON.stringify({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'still broken' }),
   ]);
 
+  // Register LAST: the project only becomes discoverable once its PRD and queue row both
+  // exist, so a straggling background reconcile from an earlier test can't see the PRD
+  // without its row and mint a 'quarantined' adopt row over this needs_review one.
+  registerActiveProject(projectCwd, 'proj-already-fix-planned-slug');
+
   commitFile(projectCwd, 'src/thing.js', 'hello', 'later commit touching the declared path');
 
   await reverifyNeedsReview();

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

@@ -26,6 +26,14 @@ const path = require('node:path');
 const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'needs-review-autoresolve-test-'));
 process.env.HOME = tmpHome;
 
+// Fixture cwd must be a REAL, writable dir: every transitionJob out of
+// needs_review fire-and-forgets a history append under <cwd>/session-manager-operations.
+// A fake path ('/home/user/project') made that append fail with EACCES *after*
+// the synchronous test returned, so its console.error landed while vitest was
+// closing the worker ("Closing rpc while onUserConsoleLog was pending" -> exit 1).
+const PROJECT_CWD = path.join(tmpHome, 'project');
+fs.mkdirSync(PROJECT_CWD, { recursive: true });
+
 const {
   selectExhaustedNeedsReviewTargets,
   applyNeedsReviewAutoResolve,
@@ -41,7 +49,7 @@ const THRESHOLD_MS = 30 * MIN_MS;
 function exhaustedJob(overrides = {}) {
   return {
     slug: 'exhausted-row',
-    cwd: '/home/user/project',
+    cwd: PROJECT_CWD,
     status: 'needs_review',
     autoFixAttempted: true,
     autoFixOutcome: 'no-plan',
@@ -153,16 +161,16 @@ test('applyNeedsReviewAutoResolve race-guards against a row that moved off needs
 test('a 3-row dependsOn chain drains: the exhausted middle row auto-skips and the third row becomes eligible', () => {
   const now = Date.now();
   const rowA = {
-    slug: 'a-first', cwd: '/home/user/project', status: 'completed',
+    slug: 'a-first', cwd: PROJECT_CWD, status: 'completed',
   };
   const rowB = exhaustedJob({
     slug: 'b-middle',
-    cwd: '/home/user/project',
+    cwd: PROJECT_CWD,
     exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
     dependsOn: ['a-first'],
   });
   const rowC = {
-    slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'],
+    slug: 'c-last', cwd: PROJECT_CWD, status: 'pending', dependsOn: ['b-middle'],
   };
   const jobs = [rowA, rowB, rowC];
 
@@ -182,8 +190,8 @@ test('a 3-row dependsOn chain drains: the exhausted middle row auto-skips and th
 });
 
 test('a generic (non-auto-resolved) skipped dep still blocks forever — the carve-out is narrow', () => {
-  const rowB = { slug: 'b-middle', cwd: '/home/user/project', status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
-  const rowC = { slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'] };
+  const rowB = { slug: 'b-middle', cwd: PROJECT_CWD, status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
+  const rowC = { slug: 'c-last', cwd: PROJECT_CWD, status: 'pending', dependsOn: ['b-middle'] };
   const { batch } = pickForProject([rowB, rowC], new Set(), 5);
   assert.equal(batch.length, 0, 'a PRD-source-vanished skip must remain a permanent block, unaffected by this carve-out');
 });

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

@@ -103,8 +103,8 @@ test('tickQueue dispatches the healthy project while the torn project is skipped
   expect(fs.existsSync(path.join(torn.cwd, 'ran-here.marker'))).toBe(false);
   expect(fs.readFileSync(torn.queueFile).equals(before)).toBe(true);
 
-  const health = await require('../health.cjs').check();
+  const health = await require('../health.cjs').check({ skipTypecheck: true });
   expect(health.components.scheduler_queue.ok).toBe(false);
   expect(health.components.scheduler_queue.quarantinedCwds).toEqual([torn.cwd]);
   expect(health.issues.some((i) => i.includes(torn.cwd))).toBe(true);
-}, 120_000); // health.check() alone can take tens of seconds
+}, 120_000); // skipTypecheck: this asserts scheduler_queue only; tsc was the tens of seconds

package/src/main/__tests__/scheduler-stranded-autofix-park.test.cjs

@@ -38,6 +38,13 @@ const { execFileSync } = require('node:child_process');
 const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'stranded-autofix-park-test-'));
 process.env.HOME = tmpHome;
 
+// Fixture cwd must be a REAL, writable dir: transitionJob out of needs_review
+// fire-and-forgets a history append under <cwd>/session-manager-operations. A fake
+// path made it fail EACCES AFTER the sync test returned, so its console.error hit
+// vitest mid worker-close ("Closing rpc while onUserConsoleLog was pending").
+const PROJECT_CWD = path.join(tmpHome, 'project');
+fs.mkdirSync(PROJECT_CWD, { recursive: true });
+
 const {
   isStrandedAutoFixPark,
   isExhaustedAutoFix,
@@ -72,7 +79,7 @@ function registerActiveProject(cwd, slug) {
 function strandedJob(overrides = {}) {
   return {
     slug: '1218-fo-01-move-scripts-lib-into-src-main-lib',
-    cwd: '/home/user/project',
+    cwd: PROJECT_CWD,
     status: 'needs_review',
     exitCode: 0,
     verifierVerdict: 'transcript_errors',

package/src/main/__tests__/transcripts-paged-reads.test.cjs

@@ -137,7 +137,9 @@ test('inode-change rotation invalidates and rebuilds the index — no stale offs
   // The chokidar watcher on the live sub picks up the rotation and rebuilds
   // the index via readDelta's inode-change reset — poll (bounded) rather
   // than assume a fixed debounce delay.
-  const deadline = Date.now() + 5000;
+  // 30s ceiling, not 5s: the watcher event is starved under heavy CPU contention; the loop
+  // exits the instant the condition holds so idle cost is unchanged.
+  const deadline = Date.now() + 30000;
   while (Date.now() < deadline) {
     page = await pageEvents(tabId, 0, 0);
     if (page.totalLines === 1 && page.events[0]?.data === 'new-a') break;
@@ -146,7 +148,7 @@ test('inode-change rotation invalidates and rebuilds the index — no stale offs
   expect(page.totalLines).toBe(1);
   expect(page.events[0].data).toBe('new-a');
   closeTab(tabId);
-}, 10000);
+}, 40000);
 
 test('a partial trailing line is not indexed until it completes', async () => {
   const sessionId = 'sess-partial';