claude-code-session-manager 0.91.1 → 0.92.1

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-4dEn1t8J.js"></script>
+    <script type="module" crossorigin src="./assets/index-D5H_H5wC.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.1",
+  "version": "0.92.1",
   "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,108 @@ 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);
+});
+
+function setEpic(mainCwd, epicId, patch) {
+  const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+  const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
+  const rec = idx.sessions[epicId];
+  if (patch.status) rec.status = patch.status;
+  if (patch.worktreeStatus) rec.worktree.status = patch.worktreeStatus;
+  fs.writeFileSync(idxPath, JSON.stringify(idx));
+}
+
+function captureSpawn() {
+  const out = { opts: null, count: 0 };
+  nodePty.spawn = (shell, args, opts) => {
+    out.opts = opts;
+    out.count += 1;
+    return fakeProc();
+  };
+  return out;
+}
+
+function fakeWindow(sent) {
+  return {
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, isCrashed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
+  };
+}
+
+test('spawn() opens a completed Epic (merged worktree) as a shell in the project cwd with an informational line', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-'));
+  const sessionId = 'epic-session-closed';
+  const deadDir = path.join(os.tmpdir(), 'sm-pty-closed-dead-worktree');
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-c', claudeSessionId: sessionId, worktreeDir: deadDir });
+  setEpic(mainCwd, 'epic-c', { status: 'completed', worktreeStatus: 'merged' });
+
+  const cap = captureSpawn();
+  const sent = [];
+  manager.window = fakeWindow(sent);
+  try {
+    const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+    expect(cap.count).toBe(1);
+    expect(cap.opts.cwd).toBe(mainCwd);
+    expect(result.pid).toBe(4242);
+    expect(result.error).toBeUndefined();
+    const info = sent.find((m) => m.channel === `pty:data:${sessionId}`);
+    expect(info.payload).toMatch(/Epic is completed/);
+    expect(info.payload).toContain(mainCwd);
+  } finally {
+    manager.window = null;
+    manager.kill(sessionId);
+  }
+});
+
+test('spawn() opens a completed Epic whose worktree dir still exists in that worktree dir', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-live-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-closed-live-wt-'));
+  const sessionId = 'epic-session-closed-live';
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-cl', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
+  setEpic(mainCwd, 'epic-cl', { status: 'completed' });
+
+  const cap = captureSpawn();
+  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+  expect(cap.count).toBe(1);
+  expect(cap.opts.cwd).toBe(worktreeCwd);
+  manager.kill(sessionId);
+  fs.rmSync(worktreeCwd, { recursive: true, force: true });
+});
+
+test('spawn() still refuses session_unreachable without any node-pty spawn', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-unreachable-'));
+  const sessionId = 'epic-session-unreachable';
+  const deadDir = path.join(os.tmpdir(), 'sm-pty-unreachable-dead-worktree');
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-u', claudeSessionId: sessionId, worktreeDir: deadDir });
+  setEpic(mainCwd, 'epic-u', { worktreeStatus: 'merged' });
+  // Transcript exists only under the dead worktree's encoded project dir.
+  const enc = deadDir.replace(/[^a-zA-Z0-9]/g, '-');
+  const tdir = path.join(tmpHome, '.claude', 'projects', enc);
+  fs.mkdirSync(tdir, { recursive: true });
+  fs.writeFileSync(path.join(tdir, `${sessionId}.jsonl`), '{"type":"user"}\n');
+
+  const cap = captureSpawn();
+  const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+  expect(cap.count).toBe(0);
+  expect(result.pid).toBeNull();
+  expect(result.error).toMatch(/cannot be resumed/);
+});

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.91.1",
-  "gitSha": "4ee78cf25ac1c0f896177df4f7c13f5287ae647d",
-  "gitShortSha": "4ee78cf",
+  "version": "0.92.1",
+  "gitSha": "cc3a80b2b9933e408e8effca99e550e3409b4d42",
+  "gitShortSha": "cc3a80b",
   "gitBranch": "HEAD",
-  "builtAt": "2026-09-20T20:06:12.676Z",
+  "builtAt": "2026-09-20T22:38:10.510Z",
   "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;