claude-code-session-manager 0.37.2 → 0.38.0

package/src/main/__tests__/chat-exit-close-race.test.cjs

@@ -0,0 +1,140 @@
+/**
+ * chat-exit-close-race.test.cjs — regression for the exit/close race that
+ * silently dropped a pure-text-only final turn (PRD 716).
+ *
+ * Bug: the terminal-event fallback was wired to `child.on('exit', ...)`
+ * instead of `child.on('close', ...)`. Node only guarantees all buffered
+ * stdout 'data' events have been delivered by 'close', not 'exit' — 'exit'
+ * can fire before the final stdout chunk (last assistant text + terminating
+ * `result` line) reaches the parent's 'data' handler. When that happened,
+ * the exit fallback ran first, set the one-shot terminalSent latch, and
+ * broadcast a misleading chat:run:error. The real result line then parsed
+ * moments later, but emitTerminal silently no-op'd and the genuine
+ * chat:run:complete was dropped.
+ *
+ * Fix: use `child.on('close', ...)` for the fallback so it only fires once
+ * Node guarantees stdout is fully drained — a real result event that arrives
+ * (even "late", right up against process exit) always wins.
+ *
+ * This test mocks node:child_process.spawn so it can deterministically
+ * reproduce the exact race ordering (exit fires, THEN the final stdout chunk
+ * arrives, THEN close fires) rather than relying on real OS/pipe timing,
+ * which is not reliably reproducible from a real child process.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/chat-exit-close-race.test.cjs
+ */
+
+'use strict';
+
+delete process.env.SM_CHAT_CONCURRENCY;
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const EventEmitter = require('node:events');
+const cp = require('node:child_process');
+
+// Replace spawn BEFORE chatRunner.cjs is first required, so the module's
+// top-level `const { spawn } = require('node:child_process')` destructuring
+// captures this mock instead of the real implementation.
+const originalSpawn = cp.spawn;
+let nextChild = null;
+cp.spawn = () => {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.pid = 424242;
+  child.kill = () => {};
+  nextChild = child;
+  return child;
+};
+
+const cr = require('../chatRunner.cjs');
+
+const tick = () => new Promise((r) => setImmediate(r));
+
+test('a final-text-only turn whose stdout chunk lands after exit still surfaces chat:run:complete', async () => {
+  nextChild = null;
+  const events = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: {
+      isDestroyed: () => false,
+      send: (channel, payload) => events.push({ channel, payload }),
+    },
+  });
+
+  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: process.cwd(), resume: false });
+
+  for (let i = 0; i < 20 && !nextChild; i++) await tick();
+  const child = nextChild;
+  assert.ok(child, 'spawn should have been invoked');
+
+  const text = 'Here is your sample post, all in one go.';
+  const lines =
+    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text }] } }) +
+    '\n' +
+    JSON.stringify({ type: 'result', subtype: 'success', result: text }) +
+    '\n';
+
+  // The exact race: 'exit' fires first (process already gone from the OS's
+  // perspective), the final stdout chunk is delivered to the 'data' handler
+  // only after that, and 'close' — which Node guarantees fires after all
+  // stdout data has been delivered — fires last.
+  child.emit('exit', 0, null);
+  child.stdout.emit('data', Buffer.from(lines));
+  child.emit('close', 0, null);
+
+  await tick();
+  await tick();
+
+  const terminal = events.filter((e) => isTerminal(e.channel));
+  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
+  assert.equal(
+    terminal[0].channel,
+    'chat:run:complete',
+    'the real result event must win over the generic exit-fallback error',
+  );
+  assert.equal(terminal[0].payload.finalMessage, text);
+});
+
+test('a crashed process with no result event ever emitted still fires the fallback chat:run:error', async () => {
+  nextChild = null;
+  const events = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: {
+      isDestroyed: () => false,
+      send: (channel, payload) => events.push({ channel, payload }),
+    },
+  });
+
+  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: process.cwd(), resume: false });
+
+  for (let i = 0; i < 20 && !nextChild; i++) await tick();
+  const child = nextChild;
+  assert.ok(child, 'spawn should have been invoked');
+
+  // Crashes with no stdout at all — 'close' is the only event that fires.
+  child.emit('close', 1, null);
+
+  await tick();
+  await tick();
+
+  const terminal = events.filter((e) => isTerminal(e.channel));
+  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
+  assert.equal(terminal[0].channel, 'chat:run:error', 'a crash with no result surfaces as an error turn');
+  assert.match(terminal[0].payload.message, /process exited without a result event/);
+});
+
+function isTerminal(channel) {
+  return (
+    channel === 'chat:run:complete' ||
+    channel === 'chat:run:needs-input' ||
+    channel === 'chat:run:error'
+  );
+}
+
+test.after(() => {
+  cp.spawn = originalSpawn;
+  delete process.env.SM_CHAT_CONCURRENCY;
+});

package/src/main/__tests__/scheduler-committed-in-window.test.cjs

@@ -61,3 +61,67 @@ test('committedInWindow returns false when the window covers no commit', async (
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// Reproduces the sigma PRD 713 incident: a commit made+pushed from an
+// isolated worktree checkout that shares the run's remote but not job.cwd's
+// local refs — e.g. `git worktree add /tmp/foo` followed by `git worktree
+// remove` clears the worktree's local branch, leaving the commit reachable
+// in job.cwd only via a remote-tracking ref that hasn't been fetched yet.
+// Modeled here as a second, independent clone of the shared remote (rather
+// than a literal `git worktree add`, which shares job.cwd's .git store and
+// so opportunistically updates job.cwd's remote-tracking ref on push,
+// masking the staleness this test needs to exercise) — the observable
+// symptom is identical: job.cwd's remote-tracking ref is stale until fetched.
+test('committedInWindow sees a commit pushed from an isolated checkout, only reachable via a stale remote-tracking ref', async () => {
+  const bareDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-bare-'));
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-cwd-'));
+  const worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-wt-'));
+  try {
+    git(bareDir, ['init', '-q', '--bare']);
+
+    const seedDir = makeRepo();
+    try {
+      git(seedDir, ['push', bareDir, 'HEAD:refs/heads/main']);
+      // Without an explicit default branch, the bare repo's symbolic HEAD can
+      // point at a nonexistent ref (e.g. 'master'), which makes the clone
+      // below check out no local branch at all — set it explicitly.
+      git(bareDir, ['symbolic-ref', 'HEAD', 'refs/heads/main']);
+    } finally {
+      fs.rmSync(seedDir, { recursive: true, force: true });
+    }
+
+    git(cwd, ['clone', '-q', bareDir, '.']);
+    git(cwd, ['config', 'user.email', 'test@example.com']);
+    git(cwd, ['config', 'user.name', 'Test']);
+
+    const startedAt = new Date().toISOString();
+
+    // Simulate the PRD's own isolated-checkout workflow: a separate clone of
+    // the same shared remote, a commit there, a push back to that remote —
+    // job.cwd never touches this checkout and never fetches after the push.
+    git(worktreeDir, ['clone', '-q', bareDir, '.']);
+    git(worktreeDir, ['config', 'user.email', 'test@example.com']);
+    git(worktreeDir, ['config', 'user.name', 'Test']);
+    git(worktreeDir, ['checkout', '-q', '-b', 'temp-merge-branch']);
+    fs.writeFileSync(path.join(worktreeDir, 'feature.txt'), 'feature\n');
+    git(worktreeDir, ['add', '.']);
+    git(worktreeDir, ['commit', '-q', '-m', 'feature commit from isolated worktree']);
+    git(worktreeDir, ['push', 'origin', 'temp-merge-branch']);
+
+    const finishedAt = new Date(Date.now() + 1000).toISOString();
+
+    // Precondition: without a fetch, job.cwd genuinely cannot see the commit —
+    // this is what made committedInWindow's old bare `git log --all` blind to it.
+    expect(() => git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']))
+      .not.toThrow();
+    const beforeFetch = git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']);
+    expect(beforeFetch).toBe('');
+
+    const result = await committedInWindow(cwd, startedAt, finishedAt);
+    expect(result).toBe(true);
+  } finally {
+    fs.rmSync(bareDir, { recursive: true, force: true });
+    fs.rmSync(cwd, { recursive: true, force: true });
+    fs.rmSync(worktreeDir, { recursive: true, force: true });
+  }
+});

package/src/main/chatRunner.cjs

@@ -18,7 +18,7 @@
  *     `silent` (PRD 470) runs still go through the CONCURRENCY_CAP FIFO lane and suppress the
  *     six turn-affecting broadcasts + recordExchange (see probeContextUsage below). Non-silent
  *     (manual) runs (PRD 493) execute immediately, uncapped, never entering the FIFO lane.
- *   cancel(tabId): void
+ *   cancel(tabId): Promise<void>  — resolves once the cancelled run fully settles
  *   parseStopSignal(finalText): { questions: string[] } | null     — exported for reuse
  *   parseContextUsageMarkdown(text): { usedTokens, totalTokens, usedPct, categories } | null
  *                                                                    — pure parser for `/context`
@@ -284,7 +284,11 @@ function getConcurrencyCap() {
   );
 }
 
-// tabId → cancel() for every ACTIVE run; FIFO list of WAITING runs; live count.
+// tabId → { cancelFn, donePromise } for every ACTIVE run; FIFO list of WAITING
+// runs; live count. `donePromise` resolves once the run's own executeRun()
+// promise settles (i.e. after settle() runs for that tabId) — attached right
+// 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 }]
 let activeCount = 0;
@@ -341,7 +345,10 @@ function run(opts) {
   // CLAUDE.md no longer strictly holds for foreground sessions (accepted
   // tradeoff). executeRun still registers in inFlight synchronously, so the
   // per-tab guard above and cancel() keep working; no activeCount, no pump.
-  executor(opts).catch(() => { /* executeRun never rejects; defensive */ });
+  const donePromise = executor(opts);
+  const entry = inFlight.get(opts.tabId);
+  if (entry) entry.donePromise = donePromise;
+  donePromise.catch(() => { /* executeRun never rejects; defensive */ });
 }
 
 // Fill open lanes FIFO up to CONCURRENCY_CAP, then announce queue positions for
@@ -351,7 +358,12 @@ function pump() {
     const job = waiting.shift();
     activeCount += 1;
     Promise.resolve()
-      .then(() => executor(job))
+      .then(() => {
+        const donePromise = executor(job);
+        const entry = inFlight.get(job.tabId);
+        if (entry) entry.donePromise = donePromise;
+        return donePromise;
+      })
       .catch(() => { /* executeRun never rejects; defensive */ })
       .finally(() => { activeCount -= 1; pump(); });
   }
@@ -483,7 +495,9 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
       setTimeout(() => doKill('SIGKILL'), 5000).unref?.();
     };
 
-    inFlight.set(tabId, cancelFn);
+    // donePromise is attached by the caller (run()/pump()) right after this
+    // executor invocation returns — see comment above the inFlight Map decl.
+    inFlight.set(tabId, { cancelFn, donePromise: null });
 
     // Hard wall-clock ceiling — SIGTERM + SIGKILL on expiry
     const killTimer = setTimeout(() => {
@@ -607,7 +621,13 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
       settle();
     });
 
-    child.on('exit', (code, signal) => {
+    // 'close' (not 'exit') so this fallback only runs after Node guarantees
+    // every buffered stdout 'data' chunk has been delivered — 'exit' can fire
+    // before the final chunk (last assistant text + terminating `result`
+    // line) reaches the 'data' handler above, which raced this fallback into
+    // firing first and dropping the real chat:run:complete behind the
+    // terminalSent latch.
+    child.on('close', (code, signal) => {
       clearTimeout(killTimer);
       // Flush any partial line that didn't end with \n
       if (lineBuffer.trim()) processLine(lineBuffer.trim());
@@ -644,12 +664,16 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
  * Cancel a run for the given tabId. An ACTIVE run is SIGTERM→SIGKILL'd (its
  * child exit funnels through settle → pump, freeing the lane). A still-WAITING
  * run is dropped from the queue and announced as cancelled. No-op otherwise.
+ *
+ * @returns {Promise<void>} resolves once the cancelled run has fully settled
+ *   (i.e. its terminal IPC event has fired) — or immediately for a waiting/
+ *   no-op cancel, since there is nothing further to await in those cases.
  */
 function cancel(tabId) {
-  const fn = inFlight.get(tabId);
-  if (fn) {
-    fn(); // settle() (on child exit) deletes from inFlight + pumps the next run
-    return;
+  const entry = inFlight.get(tabId);
+  if (entry) {
+    entry.cancelFn(); // settle() (on child exit) deletes from inFlight + pumps the next run
+    return entry.donePromise || Promise.resolve();
   }
   const idx = waiting.findIndex((w) => w.tabId === tabId);
   if (idx !== -1) {
@@ -661,6 +685,7 @@ function cancel(tabId) {
     });
     pump(); // refresh remaining queue positions
   }
+  return Promise.resolve();
 }
 
 // ─── IPC handler registration ─────────────────────────────────────────────
@@ -673,10 +698,10 @@ function registerChatHandlers() {
     return { ok: true };
   }));
 
-  ipcMain.on('chat:cancel', (_e, payload) => {
+  ipcMain.handle('chat:cancel', async (_e, payload) => {
     let tabId;
     try { tabId = schemas.chatCancel.parse(payload).tabId; } catch { return; }
-    cancel(tabId);
+    await cancel(tabId);
   });
 
   ipcMain.handle('chat:probe-context', validated(schemas.chatProbeContext, async ({ tabId, sessionId, cwd }) => {

package/src/main/ipcSchemas.cjs

@@ -26,7 +26,7 @@ const ptyTabId = z.object({ tabId: z.string().min(1).max(128) });
 const sessionSubscribe = z.object({
   // tabId becomes a transcript FILENAME (`<tabId>.jsonl`) — restrict to a
   // session-id charset (no '/', no '.', so it can't traverse out of the project
-  // transcript dir). claudeSessionId is a UUID, which satisfies this.
+  // transcript dir). sessionId is a UUID, which satisfies this.
   tabId: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/),
   cwd: z.string().min(1).max(4096),
 });
@@ -196,8 +196,7 @@ const configWatch = z.array(z.string().min(1).max(4096));
 const sessionsPayload = z.object({
   tabs: z.array(z.object({
     id: z.string().min(1).max(128),
-    claudeSessionId: z.string().min(1).max(128),
-    chatSessionId: z.string().min(1).max(128).optional(),
+    sessionId: z.string().min(1).max(128),
     cwd: z.string().min(1).max(4096),
     label: z.string().max(256),
     presetId: z.string().max(128).nullable(),

package/src/main/scheduler.cjs

@@ -208,15 +208,38 @@ function gitHead(cwd) {
   });
 }
 
+// Best-effort `git fetch --all --prune` in cwd, bounded and never throwing.
+// A PRD that does its work in a separate `git worktree add` checkout (per
+// standards.md's own recommended pattern for shared repos) commits and pushes
+// from THAT worktree, then removes it — the commit never touches job.cwd's
+// own refs, so job.cwd's remote-tracking branches can be stale relative to
+// what was actually pushed. Refreshing them here is what lets the git log
+// --all scan below see a worktree-pushed commit. Resolves once fetch settles
+// (or times out / errors) — callers don't need the result, just the refresh.
+function fetchAllRefs(cwd) {
+  return new Promise((resolve) => {
+    if (!cwd) { resolve(); return; }
+    execFile(
+      'git',
+      ['-C', cwd, 'fetch', '--all', '--prune'],
+      { timeout: 20_000, windowsHide: true },
+      () => resolve(),
+    );
+  });
+}
+
 // Returns true if ≥1 commit landed on any ref (branch, remote-tracking branch,
 // or tag) in cwd between startedAt and finishedAt (with 60s slack) — not just
 // the currently checked-out branch. Used both by the self-heal pass and by the
 // live commit-guard's fallback (see computeCommittedDuringRun) to derive
-// committedDuringRun from the recorded run window. Never throws;
-// git-unavailable → false (no override, job stays as-is).
-function committedInWindow(cwd, startedAt, finishedAt) {
+// committedDuringRun from the recorded run window. Fetches remotes first (see
+// fetchAllRefs) so a commit pushed from a separate worktree checkout that was
+// since removed is still visible via job.cwd's remote-tracking refs. Never
+// throws; git-unavailable → false (no override, job stays as-is).
+async function committedInWindow(cwd, startedAt, finishedAt) {
+  if (!cwd || !startedAt) return false;
+  await fetchAllRefs(cwd);
   return new Promise((resolve) => {
-    if (!cwd || !startedAt) { resolve(false); return; }
     const until = finishedAt
       ? new Date(Date.parse(finishedAt) + 60_000).toISOString()
       : new Date().toISOString();

package/src/main/sessionsStore.cjs

@@ -5,9 +5,9 @@
  * Storage: ~/.config/session-manager/tabs.json
  * Shape: { tabs: PersistedTab[], activeTabId: string | null, savedAt: number }
  *
- * Only serializable, durable fields are persisted: id, claudeSessionId,
- * chatSessionId, cwd, label, presetId. Runtime-only fields (pid, status,
- * startupCommand, exitCode) are recomputed on boot.
+ * Only serializable, durable fields are persisted: id, sessionId, cwd,
+ * label, presetId. Runtime-only fields (pid, status, startupCommand,
+ * exitCode) are recomputed on boot.
  */
 
 const fs = require('node:fs');
@@ -58,8 +58,7 @@ async function markFreshRestart() {
   const crypto = require('node:crypto');
   const freshTabs = tabs.map((t) => ({
     ...t,
-    claudeSessionId: crypto.randomUUID(),
-    chatSessionId: crypto.randomUUID(),
+    sessionId: crypto.randomUUID(),
   }));
   await save({ tabs: freshTabs, activeTabId, freshStart: true });
 }

package/src/main/webRemote.cjs

@@ -729,13 +729,13 @@ async function pushSessionList() {
     if (_e2e.state !== 'authenticated') return;
     const sessionsStore = require('./sessionsStore.cjs');
     const data = await sessionsStore.load();
-    // Normalize persisted tabs → SessionMeta. tabId === claudeSessionId so it
+    // Normalize persisted tabs → SessionMeta. tabId === sessionId so it
     // matches the transcript JSONL name used by cmd:session:subscribe.
     const sessions = (data?.tabs ?? []).map((t) => ({
-      tabId: t.claudeSessionId,
+      tabId: t.sessionId,
       cwd: t.cwd,
       title: t.label || t.cwd,
-      state: _sessionWatchers.get(t.claudeSessionId)?.state ?? null,
+      state: _sessionWatchers.get(t.sessionId)?.state ?? null,
     }));
     const payload = { sessions, activeTabId: data?.activeTabId ?? null };
     const json = JSON.stringify(payload);

package/src/preload/api.d.ts

@@ -163,9 +163,7 @@ export interface SubscribeResult {
 
 export interface PersistedTab {
   id: string;
-  claudeSessionId: string;
-  /** Chat mode's own session id, decoupled from claudeSessionId. Optional for backwards-compat with tabs.json written before this field existed. */
-  chatSessionId?: string;
+  sessionId: string;
   cwd: string;
   label: string;
   presetId: string | null;
@@ -1463,8 +1461,9 @@ export interface SessionManagerAPI {
   chat: {
     /** Spawn a headless `claude -p` run for a tab. Results arrive via the on* listeners. */
     run: (payload: ChatRunPayload) => Promise<{ ok: boolean }>;
-    /** Cancel the in-flight run for a tab (SIGTERM→SIGKILL). No-op when idle. */
-    cancel: (tabId: string) => void;
+    /** Cancel the in-flight run for a tab (SIGTERM→SIGKILL). Resolves once the
+     *  run has fully settled (terminal event fired). No-op when idle. */
+    cancel: (tabId: string) => Promise<void>;
     onQueued: (handler: (e: ChatRunQueuedEvent) => void) => () => void;
     onRunStarted: (handler: (e: ChatRunStartedEvent) => void) => () => void;
     onOutput: (handler: (e: ChatRunOutputEvent) => void) => () => void;

package/src/preload/index.cjs

@@ -393,8 +393,9 @@ contextBridge.exposeInMainWorld('api', {
   chat: {
     /** Spawn a headless claude -p job. Results arrive via the on* listeners. */
     run: (payload) => ipcRenderer.invoke('chat:run', payload),
-    /** Cancel an in-flight run for the given tabId. No-op if none running. */
-    cancel: (tabId) => ipcRenderer.send('chat:cancel', { tabId }),
+    /** Cancel an in-flight run for the given tabId. Resolves once the run has
+     *  fully settled (terminal event fired). No-op if none running. */
+    cancel: (tabId) => ipcRenderer.invoke('chat:cancel', { tabId }),
     onQueued: (handler) => {
       const listener = (_e, payload) => handler(payload);
       ipcRenderer.on('chat:run:queued', listener);