claude-code-session-manager 0.88.1 → 0.90.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-Dp4Rc--q.js"></script>
+    <script type="module" crossorigin src="./assets/index-A9TWmB7_.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-Dh7BLxdA.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.88.1",
+  "version": "0.90.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__/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__/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-integration-failure-stamp.test.cjs

@@ -0,0 +1,41 @@
+/**
+ * scheduler-integration-failure-stamp.test.cjs — a worktree_integration_failed
+ * finalize stamps integrateBranch's failure subtype onto the job row, and the
+ * RCA report names it.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-integration-failure-stamp.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const { stampIntegrationFailure } = require('../scheduler.cjs');
+const { buildRcaMarkdown } = require('../lib/rcaReport.cjs');
+
+test('stamps content_conflict kind and conflicted paths', () => {
+  const row = { slug: 'x' };
+  stampIntegrationFailure(row, { ok: false, failureKind: 'content_conflict', conflictedPaths: ['a.md'] });
+  assert.equal(row.integrationFailureKind, 'content_conflict');
+  assert.deepEqual(row.integrationConflictPaths, ['a.md']);
+});
+
+test('blocking_paths stamps kind only; no failure clears stale fields', () => {
+  const row = { integrationConflictPaths: ['old'] };
+  stampIntegrationFailure(row, { ok: false, failureKind: 'blocking_paths', blockingPaths: { tracked: ['f'], untracked: [] } });
+  assert.equal(row.integrationFailureKind, 'blocking_paths');
+  assert.equal('integrationConflictPaths' in row, false);
+  stampIntegrationFailure(row, null);
+  assert.equal('integrationFailureKind' in row, false);
+});
+
+test('RCA markdown names the subtype and conflicted paths', () => {
+  const job = {
+    slug: 'x', runId: 'r', integrationFailureKind: 'content_conflict',
+    integrationConflictPaths: ['docs/asset-pipeline.md'],
+  };
+  const md = buildRcaMarkdown({
+    job, verdict: 'worktree_integration_failed', meta: null, logTail: '', acText: '', failureClass: 'unknown',
+  });
+  assert.ok(md.includes('Integration failure subtype: content_conflict (conflicted paths: docs/asset-pipeline.md)'));
+});

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-mechanical-recovery.test.cjs

@@ -118,6 +118,29 @@ test('selectMechanicalRecoveryTarget: kill-switch SM_MECHANICAL_RECOVERY_DISABLE
   expect(selectMechanicalRecoveryTarget(eligibleJob())).toBeNull();
 });
 
+const conflictJob = (o = {}) => eligibleJob({ integrationFailureKind: 'content_conflict', integrationBaseHeadSha: 'aaa111', ...o });
+
+test('selectMechanicalRecoveryTarget: content_conflict with unchanged HEAD is skipped', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), 'aaa111')).toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: content_conflict with a moved HEAD returns a target', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), 'bbb222')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: blocking_paths with unchanged HEAD still returns a target', () => {
+  const job = eligibleJob({ integrationFailureKind: 'blocking_paths', integrationBaseHeadSha: 'aaa111' });
+  expect(selectMechanicalRecoveryTarget(job, 'aaa111')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: a pre-mc-01 row with no integrationFailureKind still returns a target', () => {
+  expect(selectMechanicalRecoveryTarget(eligibleJob(), 'aaa111')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: null currentHeadSha never skips', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), null)).not.toBeNull();
+});
+
 test('MECHANICALLY_RESOLVABLE_VERDICTS: closed set contains exactly worktree_integration_failed', () => {
   expect(Array.from(MECHANICALLY_RESOLVABLE_VERDICTS)).toEqual(['worktree_integration_failed']);
 });

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';

package/src/main/__tests__/transcripts-worktree-epic-path.test.cjs

@@ -0,0 +1,154 @@
+/**
+ * transcripts-worktree-epic-path.test.cjs — transcriptPath()/subscribe() resolve
+ * an Epic's transcript through epicTranscriptPath (worktree encoding), while a
+ * non-Epic tab keeps the plain project encoding. Includes a parity check of the
+ * renderer's transcriptExists() (EpicTerminalPane's resume-vs-create decision)
+ * against the REAL transcriptPath instead of a constant mock.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-worktree-epic-path.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
+import { transcriptExists } from '../../renderer/lib/transcriptExists';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let tr;
+let resolver;
+let encodeCwd;
+let proj;
+const SID = 'b8a5d6f4-0092-4db0-a687-009241f2a8b2';
+const WT = '/tmp/sm-wt-test-epic-worktree-dir';
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-home-'));
+  process.env.HOME = tmpHome;
+  tr = require('../transcripts.cjs');
+  resolver = require('../lib/epicTranscriptPath.cjs');
+  ({ encodeCwd } = require('../lib/encodeCwd.cjs'));
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  resolver.__resetCacheForTests();
+  proj = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-proj-'));
+});
+
+afterEach(() => {
+  fs.rmSync(proj, { recursive: true, force: true });
+  fs.rmSync(path.join(tmpHome, '.claude'), { recursive: true, force: true });
+  vi.unstubAllGlobals();
+});
+
+const projectsDir = () => path.join(tmpHome, '.claude', 'projects');
+const plain = (cwd, id = SID) => path.join(projectsDir(), encodeCwd(cwd), `${id}.jsonl`);
+
+function writeIndex(sessionId = SID) {
+  const dir = path.join(proj, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  const s = { id: 'epic-1', cwd: proj, claudeSessionId: sessionId, status: 'active', worktree: { dir: WT, branch: 'sm-epic/epic-1', baseCwd: proj, status: 'active' } };
+  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { 'epic-1': s }, events: {} }));
+}
+
+function writeTranscript(p, body = '{"type":"user"}\n') {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, body);
+}
+
+test('worktree-present: transcript only under the worktree encoding resolves there', () => {
+  writeIndex();
+  fs.mkdirSync(WT, { recursive: true });
+  try {
+    writeTranscript(plain(WT));
+    expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
+  } finally {
+    fs.rmSync(WT, { recursive: true, force: true });
+  }
+});
+
+test('worktree-swept: worktree dir gone from disk, transcript still found', () => {
+  writeIndex();
+  expect(fs.existsSync(WT)).toBe(false);
+  writeTranscript(plain(WT));
+  expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
+});
+
+test('non-Epic tab resolves to exactly the pre-change path, even when an Epic exists', () => {
+  writeIndex();
+  writeTranscript(plain(WT));
+  const rawTab = 'raw-tab-id-123';
+  expect(tr.transcriptPath(proj, rawTab)).toBe(path.join(os.homedir(), '.claude', 'projects', encodeCwd(proj), `${rawTab}.jsonl`));
+  // no index at all
+  const other = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transcripts-wt-other-'));
+  try {
+    expect(tr.transcriptPath(other, SID)).toBe(plain(other));
+    expect(path.isAbsolute(tr.transcriptPath(other, SID))).toBe(true);
+  } finally {
+    fs.rmSync(other, { recursive: true, force: true });
+  }
+});
+
+test('zero-byte transcript counts as existing and does not break usageFor', async () => {
+  writeIndex();
+  writeTranscript(plain(WT), '');
+  expect(tr.transcriptPath(proj, SID)).toBe(plain(WT));
+  const out = await tr.usageFor(proj, [SID]);
+  expect(out).toHaveProperty(SID);
+});
+
+test('subscribe does NOT mkdir when a transcript exists elsewhere (worktree encoding)', async () => {
+  writeIndex();
+  writeTranscript(plain(WT));
+  const before = fs.readdirSync(projectsDir()).sort();
+  const res = await tr.subscribe({ tabId: 'tab-wt', cwd: proj, sessionUuid: SID });
+  try {
+    expect(res.ok).toBe(true);
+    expect(res.path).toBe(plain(WT));
+    expect(fs.readdirSync(projectsDir()).sort()).toEqual(before);
+    expect(fs.existsSync(path.dirname(plain(proj)))).toBe(false);
+  } finally {
+    tr.closeTab('tab-wt');
+  }
+});
+
+test('subscribe of a brand-new Epic watches the spawn-cwd path and creates its dir', async () => {
+  writeIndex();
+  const res = await tr.subscribe({ tabId: 'tab-new', cwd: proj, sessionUuid: SID });
+  try {
+    expect(res.ok).toBe(true);
+    // no transcript anywhere → resolver's first candidate (spawn cwd), whose dir the CLI will write
+    expect(fs.existsSync(path.dirname(res.path))).toBe(true);
+    expect(fs.existsSync(res.path)).toBe(false);
+  } finally {
+    tr.closeTab('tab-new');
+  }
+});
+
+test('parity: renderer transcriptExists (Terminal resume decision) sees a worktree-only transcript', async () => {
+  writeIndex();
+  vi.stubGlobal('window', {
+    api: {
+      transcripts: { pathFor: async (c, s) => tr.transcriptPath(c, s) },
+      config: { exists: async (p) => fs.existsSync(p) },
+    },
+  });
+  expect(await transcriptExists(proj, SID)).toBe(false);
+  writeTranscript(plain(WT));
+  expect(await transcriptExists(proj, SID)).toBe(true);
+  // zero-byte still "exists"
+  writeTranscript(plain(WT), '');
+  expect(await transcriptExists(proj, SID)).toBe(true);
+  // raw tab never resolves into the Epic's worktree encoding
+  expect(await transcriptExists(proj, 'raw-tab')).toBe(false);
+});