claude-code-session-manager 0.91.0 → 0.92.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-ju-h7BFf.js"></script>
+    <script type="module" crossorigin src="./assets/index-a2MVk8qh.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-CRPJslSA.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-D3P_jldk.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.91.0",
+  "version": "0.92.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/src/main/__tests__/chatRunner-session-flag-retry.test.cjs

@@ -47,14 +47,14 @@ function attachRecorder() {
 // 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 }) {
+function writeStub(logFile, { firstStderr, textFirst, alwaysFail }) {
   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) {
+    if (n === 1 || ${alwaysFail ? 'true' : 'false'}) {
       ${textFirst ? "process.stdout.write(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'partial' }] } }) + '\\n');" : ''}
       process.stderr.write(${JSON.stringify(firstStderr)});
       process.exit(1);
@@ -130,7 +130,7 @@ test('no retry when the failed attempt already streamed assistant text', async (
     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/);
+    expect(terminals()[0].payload.code).toBe('session_flag_exhausted');
   } finally {
     fs.rmSync(cwd, { recursive: true, force: true });
   }
@@ -157,3 +157,52 @@ test('"No conversation found" on --resume retries once with --session-id (main o
     fs.rmSync(cwd, { recursive: true, force: true });
   }
 });
+
+test('spent swap retry (both flags rejected) emits actionable session_flag_exhausted error', async () => {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `flag-sess4-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
+    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
+    alwaysFail: true,
+  });
+  try {
+    curTab = 'tab-d';
+    cr.run({ tabId: 'tab-d', sessionId, prompt: 'hello', cwd, resume: false });
+    await waitFor(() => terminals().length > 0);
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(spawns(logFile)).toHaveLength(2);
+    expect(terminals()).toHaveLength(1);
+    const { channel, payload } = terminals()[0];
+    expect(channel).toBe('chat:run:error');
+    expect(payload.code).toBe('session_flag_exhausted');
+    expect(payload.message).toContain(cwd);
+    expect(payload.message).toContain(`${sessionId}.jsonl`);
+    expect(payload.message).toContain('--resume');
+    expect(payload.message).toMatch(/App version: /);
+    expect(payload.message).toMatch(/update the app first/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('non-zero exit with unrelated stderr keeps the generic fallback message', async () => {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `flag-sess5-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: 'boom: something else broke\n' });
+  try {
+    curTab = 'tab-e';
+    cr.run({ tabId: 'tab-e', sessionId, prompt: 'hello', cwd, resume: false });
+    await waitFor(() => terminals().length > 0);
+    const { channel, payload } = terminals()[0];
+    expect(channel).toBe('chat:run:error');
+    expect(payload.code).toBeUndefined();
+    expect(payload.message).toMatch(/^process exited without a result event/);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/pty-epic-worktree-spawn-cwd.test.cjs

@@ -154,3 +154,43 @@ test("spawn() falls back to cwd unchanged when the Epic's worktree field is abse
   expect(capturedOpts.cwd).toBe(mainCwd);
   manager.kill(sessionId);
 });
+
+test('spawn() opens a merged-worktree Epic in the project cwd (dead worktree dir is never used)', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-merged-'));
+  const sessionId = 'epic-session-merged';
+  const deadDir = path.join(os.tmpdir(), 'sm-pty-dead-worktree-does-not-exist');
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-m', claudeSessionId: sessionId, worktreeDir: deadDir });
+  const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+  const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
+  idx.sessions['epic-m'].worktree.status = 'merged';
+  fs.writeFileSync(idxPath, JSON.stringify(idx));
+
+  let capturedOpts = null;
+  nodePty.spawn = (shell, args, opts) => {
+    capturedOpts = opts;
+    return fakeProc();
+  };
+  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+  expect(capturedOpts.cwd).toBe(mainCwd);
+  manager.kill(sessionId);
+});
+
+test('spawn() refuses a completed Epic without spawning and returns the plan message', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-'));
+  const sessionId = 'epic-session-closed';
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-c', claudeSessionId: sessionId, worktreeDir: mainCwd });
+  const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+  const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
+  idx.sessions['epic-c'].status = 'completed';
+  fs.writeFileSync(idxPath, JSON.stringify(idx));
+
+  let spawned = false;
+  nodePty.spawn = () => {
+    spawned = true;
+    return fakeProc();
+  };
+  const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+  expect(spawned).toBe(false);
+  expect(result.pid).toBeNull();
+  expect(result.error).toMatch(/closed/);
+});

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.91.0",
-  "gitSha": "0029caa246d6296f7f8e83a502f5351c670b269c",
-  "gitShortSha": "0029caa",
+  "version": "0.92.0",
+  "gitSha": "d0e160e50a2560620e956e6d819cb405b0423110",
+  "gitShortSha": "d0e160e",
   "gitBranch": "HEAD",
-  "builtAt": "2026-09-20T19:42:50.657Z",
+  "builtAt": "2026-09-20T21:26:16.666Z",
   "dirty": false
 }

package/src/main/chatRunner.cjs

@@ -311,7 +311,7 @@ function getConcurrencyCap() {
 // after the executor is invoked (see run()/pump()) so cancel() callers can
 // await full teardown instead of firing SIGTERM and returning immediately.
 const inFlight = new Map();
-const waiting = []; // [{ tabId, sessionId, prompt, cwd, resume, silent, onSilentResult }]
+const waiting = []; // [{ tabId, sessionId, prompt, cwd, resume, silent, onSilentResult, onSilentError }]
 // tabIds picked by pump() but not yet registered in `inFlight` by executeRun.
 // Closes the microtask-wide window in which per-tab exclusivity would
 // otherwise not hold. See pump().
@@ -361,7 +361,7 @@ function broadcast(channel, payload) {
  * per-tab prompt queue in chat.ts only ever calls this once per tab at a
  * time, but the guard holds regardless).
  *
- * @param {{ tabId: string, sessionId: string, prompt: string, cwd: string, resume: boolean, silent?: boolean, onSilentResult?: (text: string) => void, promptId?: string }} opts
+ * @param {{ tabId: string, sessionId: string, prompt: string, cwd: string, resume: boolean, silent?: boolean, onSilentResult?: (text: string) => void, onSilentError?: (message: string, code?: string) => void, promptId?: string }} opts
  */
 function run(opts) {
   // Per-tab exclusivity still holds — two `claude -p --resume` against ONE
@@ -450,10 +450,10 @@ sessionSlots.subscribe(() => { try { pump(); } catch { /* defensive */ } });
  * for the run's lifetime so cancel() can reach it. Never rejects — the queue
  * pump relies on the returned promise always settling so the lane frees.
  *
- * @param {{ tabId: string, sessionId: string, prompt: string, cwd: string, resume: boolean, silent?: boolean, onSilentResult?: (text: string) => void, promptId?: string }} opts
+ * @param {{ tabId: string, sessionId: string, prompt: string, cwd: string, resume: boolean, silent?: boolean, onSilentResult?: (text: string) => void, onSilentError?: (message: string, code?: string) => void, promptId?: string }} opts
  * @returns {Promise<void>}
  */
-function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentResult, promptId }) {
+function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentResult, onSilentError, promptId }) {
   return new Promise((resolve) => {
     const startedAt = Date.now();
     // Last few tool_use blocks seen on the stream, oldest first — surfaced in
@@ -553,6 +553,11 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     const plan = planEpicSpawn({ cwd, claudeSessionId: sessionId, fallbackResume: !!resume });
     if (!plan.ok) {
       emitTerminal('chat:run:error', { tabId, sessionId, code: plan.code, message: plan.message });
+      // emitTerminal is a no-op broadcast for silent runs, so hand the refusal to the caller
+      // directly — otherwise it waits out its own timeout and reports a generic one.
+      if (silent && typeof onSilentError === 'function') {
+        try { onSilentError(plan.message, plan.code); } catch { /* caller bug must not wedge the lane */ }
+      }
       settle();
       return;
     }
@@ -846,6 +851,24 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
             sessionId,
             message: 'run cancelled',
           });
+        } else if (SESSION_IN_USE_RE.test(stderrBuffer) || NO_CONVERSATION_RE.test(stderrBuffer)) {
+          // A session-flag rejection that survived the one-shot swap (or was
+          // not eligible for it). The raw stderr dump names neither the flag,
+          // the cwd nor the transcript — a real report cost a full diagnostic
+          // session to trace to a stale app build, because flag resolution
+          // lives in main and older builds resolve it with older rules.
+          let appVersion = 'unknown';
+          try { appVersion = require('electron').app.getVersion() || 'unknown'; } catch { /* never fail the turn */ }
+          emitTerminal('chat:run:error', {
+            tabId,
+            sessionId,
+            code: 'session_flag_exhausted',
+            message: `The Claude CLI rejected the session flag (${resumeFlag ? '--resume' : '--session-id'} on this attempt; `
+              + `${attemptNo === 2 ? 'the one-shot swap retry with the other flag was already spent' : 'no swap retry was possible'}). `
+              + `Spawn cwd: ${execCwd}. Transcript: ${plan.transcriptPath ?? 'no transcript found on disk'}. `
+              + `App version: ${appVersion}. If this version is behind the published latest, update the app first — `
+              + 'the session-flag resolution logic lives in main, and a stale build resolves it with older rules.',
+          });
         } else {
           const errDetail = stderrBuffer.trim()
             ? `: ${stderrBuffer.trim().slice(0, 300)}`

package/src/main/config.cjs

@@ -129,6 +129,11 @@ function validateWrite(realAbs) {
     (p) => realAbs === p || realAbs.startsWith(p + path.sep)
   );
   if (inWritePrefix) return;
+  // The app's own userData dir (update-check.json cache).
+  try {
+    const ud = require('electron').app.getPath('userData');
+    if (realAbs === path.join(ud, 'update-check.json')) return;
+  } catch { /* electron app unavailable (unit tests) */ }
   // Also allowed inside a registered project root's .claude/ subtree.
   for (const root of allowedRoots) {
     if (root === os.homedir()) continue;

package/src/main/docEdit.cjs

@@ -157,8 +157,8 @@ function broadcast(channel, payload) {
   } catch { /* render frame may be gone */ }
 }
 
-// `chatRunner.run()`'s silent lane only ever invokes `onSilentResult` on its
-// success path (`chatRunner.cjs`'s `emitTerminal` no-ops every OTHER terminal
+// `chatRunner.run()`'s silent lane invokes `onSilentResult` on its success path and
+// `onSilentError` when planEpicSpawn refuses the run (`chatRunner.cjs`'s `emitTerminal` no-ops every OTHER terminal
 // event — error/timeout/spawn-failure/cancel — for `silent` runs, since those
 // six broadcasts are deliberately suppressed for probes). `run()` is also a
 // silent no-op if the tabId already has an active/queued run (its per-tab
@@ -208,6 +208,7 @@ function docEditViaSession({ tabId, sessionId, cwd, before, instruction, documen
     prompt,
     resume: true,
     silent: true,
+    onSilentError: (message) => settleOnce({ ok: false, error: message }),
     onSilentResult: (text) => {
       // chatRunner.cjs prepends its own stop-signal protocol instruction to
       // every prompt (including this resumed one) — unlike the isolated

package/src/main/index.cjs

@@ -491,6 +491,8 @@ function createWindow() {
 
 ipcMain.handle('app:version', () => app.getVersion());
 
+ipcMain.handle('app:update-status', () => require('./lib/updateCheck.cjs').getUpdateStatus());
+
 ipcMain.handle('app:home-dir', () => os.homedir());
 
 ipcMain.handle('app:cwd', () => process.cwd());

package/src/main/lib/__tests__/epicSpawnCwd.test.cjs

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 const { resolveEpicSpawnCwd } = require('../epicSpawnCwd.cjs');
 
 function stubReadActiveIndex(sessions) {
@@ -210,12 +210,68 @@ test('restore:true re-attaches the worktree and returns the recorded dir (transc
   expect(calls).toEqual([{ dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo' }]);
 });
 
-test('restore:true with a failed restore still returns the recorded dir — never the project cwd', () => {
+test('restore:true with a failed restore returns the project cwd — never a dead recorded dir', () => {
   const result = resolveEpicSpawnCwd({
     cwd: '/projects/foo',
     claudeSessionId: 'sess-1',
     deps: { readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS), statSync: statGone, restore: true, restoreWorktree: () => false },
   });
+  expect(result).toBe('/projects/foo');
+});
+
+test('a merged Epic with a missing dir returns the project cwd and never attempts a restore', () => {
+  const spy = vi.fn(() => true);
+  for (const status of ['merged', 'disabled']) {
+    const result = resolveEpicSpawnCwd({
+      cwd: '/projects/foo',
+      claudeSessionId: 'sess-1',
+      deps: {
+        readActiveIndex: stubReadActiveIndex({
+          'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', status } },
+        }),
+        statSync: statGone,
+        restore: true,
+        restoreWorktree: spy,
+      },
+    });
+    expect(result).toBe('/projects/foo');
+  }
+  expect(spy).not.toHaveBeenCalled();
+});
+
+test('an active Epic with a missing dir attempts a restore and returns the project cwd when it fails', () => {
+  const spy = vi.fn(() => false);
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', status: 'active' } },
+      }),
+      statSync: statGone,
+      restore: true,
+      restoreWorktree: spy,
+    },
+  });
+  expect(spy).toHaveBeenCalledTimes(1);
+  expect(result).toBe('/projects/foo');
+});
+
+test('a worktree record with no status key is restore-eligible and does not throw', () => {
+  const spy = vi.fn(() => true);
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1' } },
+      }),
+      statSync: statGone,
+      restore: true,
+      restoreWorktree: spy,
+    },
+  });
+  expect(spy).toHaveBeenCalledTimes(1);
   expect(result).toBe('/tmp/session-manager-epic-worktrees/deadbeef/epic-1');
 });
 

package/src/main/lib/__tests__/epicSpawnPlan.test.cjs

@@ -74,6 +74,46 @@ test('transcript under the project encoding, no worktree => ok, resume from proj
   expect(plan).toMatchObject({ ok: true, useResume: true, execCwd: PROJECT });
 });
 
+test('merged worktree (dir gone), transcript only under project encoding => ok, resume from project cwd (reported incident)', () => {
+  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
+  try {
+    const sid = SID;
+    const d = path.join(home, '.claude', 'projects', encodeCwd(proj));
+    fs.mkdirSync(d, { recursive: true });
+    fs.writeFileSync(path.join(d, `${sid}.jsonl`), '{"type":"user"}\n');
+    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
+    const deps = { homeDir: home, readActiveIndex: () => ({ sessions: merged }) };
+    const first = planEpicSpawn({ cwd: proj, claudeSessionId: sid, deps });
+    expect(first).toMatchObject({ ok: true, execCwd: proj, useResume: true });
+    // No circuit-breaker entry from the fallback: a second call is also ok.
+    expect(planEpicSpawn({ cwd: proj, claudeSessionId: sid, deps })).toMatchObject({ ok: true, execCwd: proj, useResume: true });
+  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
+});
+
+test('merged worktree, no transcript anywhere => ok, real directory, no resume', () => {
+  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
+  try {
+    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
+    const plan = planEpicSpawn({ cwd: proj, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: merged }) } });
+    expect(plan.ok).toBe(true);
+    expect(plan.useResume).toBe(false);
+    expect(fs.statSync(plan.execCwd).isDirectory()).toBe(true);
+  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
+});
+
+test('merged worktree, transcript only under dead encoding => refused, no git worktree add command', () => {
+  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
+  try {
+    transcriptUnder(DEAD);
+    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
+    const plan = planEpicSpawn({ cwd: proj, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: merged }) } });
+    expect(plan).toMatchObject({ ok: false, code: 'session_unreachable' });
+    expect(plan.message).toMatch(/merged to main/);
+    expect(plan.message).not.toMatch(/git worktree add/);
+    expect(plan.message).not.toMatch(/swept from \/tmp/);
+  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
+});
+
 test('closed (completed) Epic is refused with its own message', () => {
   const plan = planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: epic({ status: 'completed' }) }) } });
   expect(plan).toMatchObject({ ok: false, code: 'epic_closed' });
@@ -115,3 +155,42 @@ test('chatRunner: dead-encoding transcript => zero CLI spawns, exactly one clear
     fs.rmSync(project, { recursive: true, force: true });
   }
 });
+
+test('chatRunner: silent run refused by planEpicSpawn => onSilentError with the refusal, no broadcasts, no spawn', async () => {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-proj-'));
+  const prevHome = process.env.HOME;
+  process.env.HOME = home;
+  try {
+    const idxDir = path.join(project, 'session-manager-operations', 'prompt-sessions');
+    fs.mkdirSync(idxDir, { recursive: true });
+    fs.writeFileSync(path.join(idxDir, 'active-index.json'), JSON.stringify({ sessions: epic({ status: 'completed' }) }));
+    const cp = require('node:child_process');
+    const realSpawn = cp.spawn;
+    let spawns = 0;
+    cp.spawn = () => { spawns++; throw new Error('must not spawn'); };
+    const chatRunner = require('../../chatRunner.cjs');
+    chatRunner.__resetQueueForTests();
+    const sent = [];
+    chatRunner.attachWindow({ isDestroyed: () => false, webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) } });
+    const errors = [];
+    const results = [];
+    try {
+      chatRunner.run({
+        tabId: 'silent1', sessionId: SID, prompt: 'hi', cwd: project, resume: true, silent: true,
+        onSilentResult: (t) => results.push(t),
+        onSilentError: (message, code) => errors.push({ message, code }),
+      });
+      // no timer: delivery is a few microtasks after run()
+      await Promise.resolve(); await Promise.resolve(); await Promise.resolve();
+    } finally { cp.spawn = realSpawn; }
+    expect(spawns).toBe(0);
+    expect(results).toEqual([]);
+    expect(errors.length).toBe(1);
+    expect(errors[0].code).toBe('epic_closed');
+    expect(errors[0].message).toMatch(/closed/i);
+    expect(sent.filter((e) => e.channel.startsWith('chat:run:'))).toEqual([]);
+  } finally {
+    process.env.HOME = prevHome;
+    fs.rmSync(project, { recursive: true, force: true });
+  }
+});

package/src/main/lib/__tests__/updateCheck.test.cjs

@@ -0,0 +1,63 @@
+'use strict';
+import { describe, it, expect, vi } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { getUpdateStatus, isBehind } = require('../updateCheck.cjs');
+
+function mk(over = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'upd-'));
+  const fetchJson = vi.fn().mockResolvedValue({ latest: '0.91.1' });
+  const writeJson = vi.fn(async (f, data) => { fs.writeFileSync(f, JSON.stringify(data)); });
+  const deps = {
+    app: { getVersion: () => '0.89.0', getPath: () => dir },
+    env: {}, now: () => 1_000_000, packageName: () => 'pkg-x', fetchJson, writeJson, ...over,
+  };
+  return { dir, fetchJson, writeJson, deps, cache: path.join(dir, 'update-check.json') };
+}
+
+describe('getUpdateStatus', () => {
+  it('fresh fetch populates the cache and reports behind', async () => {
+    const t = mk();
+    expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: '0.91.1', behind: true });
+    expect(t.fetchJson).toHaveBeenCalledWith('https://registry.npmjs.org/-/package/pkg-x/dist-tags', 3000);
+    expect(JSON.parse(fs.readFileSync(t.cache, 'utf8'))).toEqual({ checkedAt: 1_000_000, latest: '0.91.1' });
+  });
+  it('cache hit inside 6h makes no network call', async () => {
+    const t = mk();
+    fs.writeFileSync(t.cache, JSON.stringify({ checkedAt: 1_000_000 - 1000, latest: '0.91.1' }));
+    expect((await getUpdateStatus({ deps: t.deps })).behind).toBe(true);
+    expect(t.fetchJson).not.toHaveBeenCalled();
+  });
+  it('expired cache refetches', async () => {
+    const t = mk({ now: () => 1_000_000 + 6 * 3600_000 + 1 });
+    fs.writeFileSync(t.cache, JSON.stringify({ checkedAt: 1_000_000, latest: '0.90.0' }));
+    expect((await getUpdateStatus({ deps: t.deps })).latest).toBe('0.91.1');
+    expect(t.fetchJson).toHaveBeenCalledTimes(1);
+  });
+  it('corrupt cache is a miss', async () => {
+    const t = mk();
+    fs.writeFileSync(t.cache, '{nope');
+    expect((await getUpdateStatus({ deps: t.deps })).latest).toBe('0.91.1');
+  });
+  it('offline falls back to latest null', async () => {
+    const t = mk({ fetchJson: vi.fn().mockRejectedValue(new Error('ENOTFOUND')) });
+    expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: null, behind: false });
+  });
+  it('SM_UPDATE_CHECK=0 and E2E short-circuit with no network call', async () => {
+    for (const env of [{ SM_UPDATE_CHECK: '0' }, { SM_E2E: '1' }]) {
+      const t = mk({ env });
+      expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: null, behind: false });
+      expect(t.fetchJson).not.toHaveBeenCalled();
+    }
+  });
+});
+
+describe('isBehind', () => {
+  it('compares numeric triples', () => {
+    expect(isBehind('0.89.0', '0.91.1')).toBe(true);
+    expect(isBehind('0.91.1', '0.91.1')).toBe(false);
+    expect(isBehind('0.100.0', '0.91.1')).toBe(false);
+    expect(isBehind('0.92.0', '0.91.1')).toBe(false);
+  });
+});

package/src/main/lib/epicSpawnCwd.cjs

@@ -85,8 +85,9 @@ function restoreEpicWorktree({ dir, branch, baseCwd }) {
 
 /**
  * @param {{ cwd: string, claudeSessionId: string, deps?: object }} opts
- * @returns {string} `worktree.dir` when the matching Epic has one AND it still
- *   exists on disk, else `cwd` unchanged.
+ * @returns {string} `worktree.dir` when it exists (or was just restored), else `cwd`.
+ *   Never a nonexistent path. The transcript-split hazard is guarded by
+ *   epicSpawnPlan.cjs's reachability check, not by returning a dead path.
  */
 function resolveEpicSpawnCwd({ cwd, claudeSessionId, deps = {} } = {}) {
   if (!cwd || !claudeSessionId) return cwd;
@@ -99,19 +100,27 @@ function resolveEpicSpawnCwd({ cwd, claudeSessionId, deps = {} } = {}) {
         const dir = session.worktree?.dir;
         if (!dir) return cwd;
         if (!isUsableDir(dir, statSync)) {
-          // NEVER fall back to the project cwd: the CLI files the transcript under
-          // encodeCwd(spawn cwd), so a resumed session started in a different dir splits
-          // its transcript across two encodings ("lost session"). Instead re-attach the
-          // Epic's own branch at the SAME recorded path (encoding unchanged); if that is
-          // impossible, return the recorded dir anyway so the spawn fails loudly (ENOENT)
-          // rather than silently forking the transcript. Read-side callers (no `restore`)
-          // keep the old cwd answer — they never spawn and must never mutate git state.
-          if (deps.restore) {
+          // The checkout is gone. A merged/disabled Epic's branch was deleted with it
+          // (epicWorktreeMerge.cjs cleans up with keepBranch:false), so re-attaching can
+          // never succeed — skip the two git subprocesses. Otherwise (spawn side only)
+          // re-attach the Epic's branch at the SAME recorded path so the transcript
+          // encoding is unchanged. Read-side callers (no `restore`) never mutate git state.
+          const st = session.worktree?.status;
+          const restorable = st !== 'merged' && st !== 'disabled';
+          if (deps.restore && restorable) {
             const restored = (deps.restoreWorktree || restoreEpicWorktree)({ dir, branch: session.worktree?.branch, baseCwd: cwd });
-            console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — ${restored ? 'restored at same path' : 'restore failed; spawn will fail rather than split the transcript'}`);
-            return dir;
+            if (restored) {
+              console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — restored at same path`);
+              return dir;
+            }
+            console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — restore failed; falling back to ${cwd}`);
+          } else if (deps.restore) {
+            console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — checkout was removed on ${st}; restore correctly skipped, falling back to ${cwd}`);
+          } else {
+            console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — read-side falls back to ${cwd}`);
           }
-          console.log(`[epicSpawnCwd] worktree dir gone (${dir}) — read-side falls back to ${cwd}`);
+          // Always a REAL directory; epicSpawnPlan.cjs refuses when the transcript is not
+          // visible from this cwd, so this cannot silently fork a transcript.
           return cwd;
         }
         return dir;

package/src/main/lib/epicSpawnPlan.cjs

@@ -8,11 +8,13 @@
  * conversation found"), the flag-swap retry then hit `--session-id` ("already in use"), and both
  * doors were locked.
  *
- * Chosen fix: (a) first — resolveEpicSpawnCwd({restore:true}) re-attaches the Epic's own branch
- * at the SAME recorded path (encoding unchanged), so the CLI sees the transcript again. When that
- * is impossible, (b): refuse BEFORE spawning with an actionable message naming the missing
- * worktree path, never claim a flag that cannot work. Reachability = "some existing transcript
- * lives under encodeCwd(spawn cwd)" and the spawn cwd is a real directory.
+ * Three-way decision: (1) re-attach — resolveEpicSpawnCwd({restore:true}) re-attaches the Epic's
+ * own branch at the SAME recorded path (encoding unchanged), so the CLI sees the transcript again;
+ * (2) project-cwd fallback — when that spawn cwd cannot see the transcript but the project cwd can
+ * (transcript filed under encodeCwd(project cwd)), spawn from the project cwd; nothing forks since
+ * it writes to the directory it already occupies; (3) refuse BEFORE spawning with a message stating
+ * the real cause, never claim a flag that cannot work. Reachable = "some existing transcript lives
+ * under encodeCwd(candidate cwd)" and the candidate is a real directory.
  *
  * Also refuses requests routed to a closed (`completed`) Epic, and keeps a per-session circuit
  * breaker: once a session is found unreachable, later requests are refused after ONE stat (is the
@@ -95,19 +97,32 @@ function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {}
     useResume = !!resolved.existsAnywhere;
   } catch { /* keep the caller-supplied flag */ }
 
-  const execCwd = (deps.resolveSpawnCwd || resolveEpicSpawnCwd)({ cwd, claudeSessionId, deps: { restore: true, readActiveIndex: deps.readActiveIndex, statSync: deps.statSync, restoreWorktree: deps.restoreWorktree } });
+  let execCwd = (deps.resolveSpawnCwd || resolveEpicSpawnCwd)({ cwd, claudeSessionId, deps: { restore: true, readActiveIndex: deps.readActiveIndex, statSync: deps.statSync, restoreWorktree: deps.restoreWorktree } });
 
   if (resolved && resolved.existsAnywhere) {
     const projectsDir = path.join(deps.homeDir || os.homedir(), '.claude', 'projects');
-    const home = path.join(projectsDir, encodeCwd(execCwd));
-    const reachable = isDir(execCwd, statSync) && resolved.existingPaths.some((p) => path.dirname(p) === home);
-    if (!reachable) {
+    // O(candidates × existingPaths); both are tiny. Candidate order: chosen execCwd, then project cwd.
+    const findReachable = (dir) => {
+      if (!isDir(dir, statSync)) return null;
+      const home = path.join(projectsDir, encodeCwd(dir));
+      return resolved.existingPaths.find((p) => path.dirname(p) === home) || null;
+    };
+    let hit = findReachable(execCwd);
+    if (!hit && execCwd !== cwd) {
+      // The transcript may already live under the project encoding; spawning there writes back to
+      // the directory it occupies, so nothing forks.
+      hit = findReachable(cwd);
+      if (hit) execCwd = cwd;
+    }
+    if (!hit) {
       const missing = brokenDir || execCwd;
+      const wt = epic?.worktree;
+      const recovery = wt?.status === 'merged'
+        ? `That checkout was removed when the Epic was merged to main and its ${wt.branch || 'sm-epic/*'} branch was deleted, so it cannot be recreated. Start a new Epic.`
+        : `The checkout is gone and could not be re-attached (it may have been swept from its temp/state directory). Recreate it (git worktree add "${missing}" ${wt?.branch || '<sm-epic branch>'}) or start a new Epic.`;
       const message =
         `Session ${claudeSessionId} cannot be resumed: its transcript is at ${resolved.existingPaths[0]}, ` +
-        `which the CLI only finds when run from ${missing}, and that worktree no longer exists and could not be ` +
-        `re-attached (likely swept from /tmp). Recreate it (git worktree add "${missing}" ${epic?.worktree?.branch || '<sm-epic branch>'}) ` +
-        `or start a new Epic.`;
+        `which the CLI only finds when run from ${missing}. ${recovery}`;
       unreachable.set(claudeSessionId, { dir: missing, message });
       return { ok: false, code: 'session_unreachable', message };
     }

package/src/main/lib/epicTranscriptPath.cjs

@@ -5,8 +5,9 @@
  * transcript actually live?".
  *
  * The CLI writes `~/.claude/projects/<encodeCwd(spawn cwd)>/<id>.jsonl`, and an
- * Epic's spawn cwd is its isolated worktree dir (chatRunner.cjs via
- * resolveEpicSpawnCwd), NOT the project cwd. Turn 1 can still land under the
+ * Epic's spawn cwd is normally its isolated worktree dir (chatRunner.cjs and
+ * pty.cjs via epicSpawnPlan.cjs), falling back to the project cwd when the
+ * worktree is merged/gone. Turn 1 can still land under the
  * project encoding (the worktree mint is fire-and-forget), and the worktree dir
  * itself is routinely swept from /tmp while its transcript survives under
  * ~/.claude/projects. So candidates are built from the recorded `worktree.dir`