claude-code-session-manager 0.71.0 → 0.73.0

package/src/main/__tests__/chatRunner-epic-worktree-execcwd.test.cjs

@@ -0,0 +1,125 @@
+/**
+ * chatRunner-epic-worktree-execcwd.test.cjs — PRD 1033, LOAD-BEARING
+ * acceptance criterion: an Epic-backed headless `claude -p` run must spawn
+ * with its `cwd` spawn option pointed at the Epic's isolated worktree dir
+ * when one is recorded, while `session-manager-operations/` for that Epic's
+ * project — the ops root — is never touched under the worktree dir. Mirrors
+ * scheduler-worktree-exec-cwd.test.cjs's stub-`claude`-binary pattern
+ * (SM_CLAUDE_BIN), which chatRunner.cjs's resolveClaudeBin also honors.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/chatRunner-epic-worktree-execcwd.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;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-execcwd-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);
+});
+
+// Writes a stub `claude` binary that records ITS OWN process.cwd() to a
+// marker file (proving where it actually ran), then emits a minimal
+// stream-json success result and exits 0 — same pattern as
+// scheduler-worktree-exec-cwd.test.cjs's writeClaudeStub.
+function writeClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-chatrunner-claude-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const path = require('path');
+    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
+    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;
+}
+
+function writeActiveIndexWithWorktree(cwd, { epicId, claudeSessionId, worktreeDir }) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  const session = {
+    id: epicId,
+    cwd,
+    goalText: 'test epic',
+    claudeSessionId,
+    status: 'active',
+    createdAt: new Date(0).toISOString(),
+    completedAt: null,
+    worktree: { dir: worktreeDir, branch: `sm-epic/${epicId}`, baseCwd: cwd, status: 'active' },
+  };
+  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { [epicId]: session }, events: {} }));
+}
+
+async function waitForFile(filePath, timeoutMs = 5000) {
+  const start = Date.now();
+  while (!fs.existsSync(filePath)) {
+    if (Date.now() - start > timeoutMs) throw new Error(`timed out waiting for ${filePath}`);
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
+test('executeRun spawns the claude child in the Epic worktree dir, while the project ops-root is never touched under it', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-main-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-worktree-'));
+  const sessionId = `epic-sess-${process.pid}`;
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-1', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+  try {
+    cr.run({ tabId: 'tab-1', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
+    await waitForFile(path.join(worktreeCwd, 'ran-here.marker'));
+
+    // 1. The child process really ran with cwd = the Epic's worktree dir.
+    expect(fs.existsSync(path.join(worktreeCwd, 'ran-here.marker'))).toBe(true);
+    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(false);
+
+    // 2. CRITICAL invariant: session-manager-operations/ for this Epic's
+    // project must never be touched under the worktree dir — only the real
+    // project cwd, which still holds exactly the active-index.json this
+    // test wrote.
+    expect(fs.existsSync(path.join(worktreeCwd, 'session-manager-operations'))).toBe(false);
+    const index = JSON.parse(
+      fs.readFileSync(path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'), 'utf8'),
+    );
+    expect(index.sessions['epic-1'].claudeSessionId).toBe(sessionId);
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+    fs.rmSync(worktreeCwd, { recursive: true, force: true });
+  }
+});
+
+test('executeRun falls back to cwd unchanged when the Epic has no worktree recorded (unchanged behaviour)', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-plain-'));
+  const sessionId = `plain-sess-${process.pid}`;
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+  try {
+    cr.run({ tabId: 'tab-2', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
+    await waitForFile(path.join(mainCwd, 'ran-here.marker'));
+    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(true);
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,156 @@
+/**
+ * pty-epic-worktree-spawn-cwd.test.cjs — PRD 1033, LOAD-BEARING acceptance
+ * criterion: an Epic-attached Terminal tab's PTY must actually launch its
+ * shell in the Epic's isolated worktree dir when one is recorded, while
+ * `cwd` itself (home-boundary validation, opsErrorLog attribution, the
+ * returned/tracked cwd) stays the real project cwd — see epicSpawnCwd.cjs's
+ * "ops-root hazard" header comment.
+ *
+ * Monkey-patches node-pty's own `spawn` export (a plain mutable property on
+ * its shared, cached module object) to capture the real spawn options
+ * without launching an actual shell — no existing test in this repo mocks a
+ * module import, so this stays a direct property override rather than
+ * introducing a new vi.mock pattern.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/pty-epic-worktree-spawn-cwd.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 manager;
+let nodePty;
+let originalSpawn;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-execcwd-home-'));
+  process.env.HOME = tmpHome;
+  ({ manager } = require('../pty.cjs'));
+  nodePty = require('node-pty');
+  originalSpawn = nodePty.spawn;
+});
+
+afterAll(() => {
+  nodePty.spawn = originalSpawn;
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  nodePty.spawn = originalSpawn;
+  manager.sessions.clear();
+  manager.buffers.clear();
+  manager.killed.clear();
+});
+
+function fakeProc() {
+  return {
+    pid: 4242,
+    exitCode: null,
+    onData: () => {},
+    onExit: () => {},
+    resize: () => {},
+    kill: () => {},
+    write: () => {},
+  };
+}
+
+function writeActiveIndexWithWorktree(cwd, { epicId, claudeSessionId, worktreeDir }) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  const session = {
+    id: epicId,
+    cwd,
+    goalText: 'test epic',
+    claudeSessionId,
+    status: 'active',
+    createdAt: new Date(0).toISOString(),
+    completedAt: null,
+    worktree: { dir: worktreeDir, branch: `sm-epic/${epicId}`, baseCwd: cwd, status: 'active' },
+  };
+  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { [epicId]: session }, events: {} }));
+}
+
+test('spawn() launches the shell at the Epic worktree dir when one is recorded, while cwd itself stays the project cwd', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-main-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-worktree-'));
+  const sessionId = 'epic-session-1';
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-1', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
+
+  let capturedOpts = null;
+  nodePty.spawn = (shell, args, opts) => {
+    capturedOpts = opts;
+    return fakeProc();
+  };
+
+  const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+
+  expect(capturedOpts).not.toBeNull();
+  // The ACTUAL spawn cwd is the worktree dir.
+  expect(capturedOpts.cwd).toBe(worktreeCwd);
+  // CRITICAL invariant: cwd used for the home-boundary check, tracked
+  // session bookkeeping, and the value handed back to the renderer is the
+  // real project cwd, never the worktree dir.
+  expect(result.cwd).toBe(mainCwd);
+  expect(manager.sessions.get(sessionId).cwd).toBe(mainCwd);
+
+  manager.kill(sessionId);
+});
+
+test('spawn() falls back to cwd unchanged when the tab has no matching Epic worktree', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-plain-'));
+  const tabId = 'plain-tab-1';
+
+  let capturedOpts = null;
+  nodePty.spawn = (shell, args, opts) => {
+    capturedOpts = opts;
+    return fakeProc();
+  };
+
+  manager.spawn({ tabId, cwd: mainCwd, cols: 80, rows: 24 });
+
+  expect(capturedOpts.cwd).toBe(mainCwd);
+  manager.kill(tabId);
+});
+
+test("spawn() falls back to cwd unchanged when the Epic's worktree field is absent from the index", () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-noworktree-'));
+  const sessionId = 'epic-session-2';
+  const dir = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, 'active-index.json'),
+    JSON.stringify({
+      sessions: {
+        'epic-2': {
+          id: 'epic-2',
+          cwd: mainCwd,
+          goalText: 'x',
+          claudeSessionId: sessionId,
+          status: 'active',
+          createdAt: new Date(0).toISOString(),
+          completedAt: null,
+        },
+      },
+      events: {},
+    }),
+  );
+
+  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);
+});

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

@@ -0,0 +1,65 @@
+/**
+ * queueOpsArchiveDestination.test.cjs — an archived PRD lands beside its OWN
+ * source, not in the machine-level scheduled-plans tree.
+ *
+ * PRD sources are per-project and per-Epic (CLAUDE.md's TAB → EPIC → PRD
+ * model): `<cwd>/session-manager-operations/scheduler/epics/<epic-id>/prds/`.
+ * `~/.claude/session-manager/scheduled-plans/` holds only run logs and
+ * PRD_AUTHORING.md. archiveOne resolved its SOURCE per-project (findPrdDir)
+ * but hardcoded its DESTINATION to the global PRDS_ARCHIVE_DIR, so a manual
+ * archive yanked a PRD out of its Epic and stranded it in the retired global
+ * tree — splitting one Epic's history across two locations.
+ *
+ * Observed 2026-08-13: archiving 1035-epic-worktree-ui-surfacing put it under
+ * scheduled-plans/prds-archived/ while its three chain siblings (1032/1033/
+ * 1034, archived by scheduler.cjs's own on-completion mover) sat correctly in
+ * the Epic's prds-archived/. Two movers, two destinations, same operation.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/queueOpsArchiveDestination.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const path = require('node:path');
+const { archiveDirForSource, PRDS_DIR, PRDS_ARCHIVE_DIR } = require('../queueOps.cjs');
+
+const EPIC_PRDS = '/home/u/Projects/proj/session-manager-operations/scheduler/epics/my-epic-abc123/prds';
+const TS = '2026-08-14T05-03-41-156Z';
+
+test('an Epic PRD archives into that Epic\'s own prds-archived/, beside its prds/', () => {
+  const dir = archiveDirForSource(EPIC_PRDS, TS);
+  expect(dir).toBe(path.join(path.dirname(EPIC_PRDS), 'prds-archived', TS));
+  // Concretely: same Epic dir, sibling of prds/.
+  expect(dir).toBe(
+    `/home/u/Projects/proj/session-manager-operations/scheduler/epics/my-epic-abc123/prds-archived/${TS}`,
+  );
+});
+
+test('an Epic PRD never lands under the machine-level scheduled-plans tree', () => {
+  const dir = archiveDirForSource(EPIC_PRDS, TS);
+  expect(dir.startsWith(PRDS_ARCHIVE_DIR)).toBe(false);
+  expect(dir).not.toContain('.claude/session-manager/scheduled-plans');
+});
+
+test('the archived PRD stays inside its own project — the ops root never changes', () => {
+  const dir = archiveDirForSource(EPIC_PRDS, TS);
+  expect(dir.startsWith('/home/u/Projects/proj/session-manager-operations/')).toBe(true);
+});
+
+test('two Epics in the same project archive to their own separate dirs', () => {
+  const other = '/home/u/Projects/proj/session-manager-operations/scheduler/epics/other-epic-def456/prds';
+  expect(archiveDirForSource(EPIC_PRDS, TS)).not.toBe(archiveDirForSource(other, TS));
+});
+
+test('a legacy flat PRD still archives to the global prds-archived/ — old behavior unchanged', () => {
+  const dir = archiveDirForSource(PRDS_DIR, TS);
+  expect(dir).toBe(path.join(PRDS_ARCHIVE_DIR, TS));
+});
+
+test('the batch timestamp is shared, so one archive call reads as one event', () => {
+  const a = archiveDirForSource(EPIC_PRDS, TS);
+  const b = archiveDirForSource('/home/u/Projects/other/session-manager-operations/scheduler/epics/e/prds', TS);
+  expect(path.basename(a)).toBe(TS);
+  expect(path.basename(b)).toBe(TS);
+});

package/src/main/__tests__/stop-signal-anchor.test.cjs

@@ -0,0 +1,75 @@
+/**
+ * stop-signal-anchor.test.cjs — drift guard between chatRunner's
+ * STOP_SENTINEL/splitStopSignal and the renderer's duplicated copy.
+ *
+ * `src/renderer/lib/stopSignal.ts` cannot import this main-process `.cjs`
+ * (CommonJS main / ESM renderer split), so it carries its own literal
+ * `STOP_SENTINEL` + a re-implementation of `splitStopSignal`. This test
+ * requires the REAL exported constant and asserts the renderer's copy is
+ * byte-identical, and that both splitters agree on `body` for the same
+ * composed sample — so a rework of either constant/function fails here
+ * loudly instead of the two forms of a stop-signal reply silently drifting
+ * back out of sync (which is exactly what caused the doubled-message bug
+ * this module exists to fix).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/stop-signal-anchor.test.cjs
+ */
+
+'use strict';
+
+const path = require('path');
+
+import { test, expect } from 'vitest';
+
+const { STOP_SENTINEL, splitStopSignal } = require('../chatRunner.cjs');
+
+async function loadRendererCopy() {
+  const mod = await import(
+    /* @vite-ignore */ path.resolve(__dirname, '..', '..', 'renderer', 'lib', 'stopSignal.ts')
+  );
+  return mod;
+}
+
+test('the renderer STOP_SENTINEL literal is byte-identical to chatRunner.cjs', async () => {
+  const rendererCopy = await loadRendererCopy();
+  expect(rendererCopy.STOP_SENTINEL).toBe(STOP_SENTINEL);
+});
+
+test('both splitters agree on body for a composed stop-signal reply', async () => {
+  const rendererCopy = await loadRendererCopy();
+  const body = 'Here is what I found and what I still need from you.';
+  const full = `${body}\n\n${STOP_SENTINEL}\n${JSON.stringify({ questions: ['Deploy to prod now?'] })}`;
+
+  const mainSplit = splitStopSignal(full);
+  const rendererSplit = rendererCopy.splitStopSignal(full);
+
+  expect(mainSplit).not.toBeNull();
+  expect(rendererSplit).not.toBeNull();
+  expect(rendererSplit.body).toBe(mainSplit.answerBody);
+  expect(rendererSplit.body).toBe(body);
+  expect(rendererSplit.questions ?? mainSplit.questions).toBeDefined();
+});
+
+test('both splitters return null for text with no sentinel', async () => {
+  const rendererCopy = await loadRendererCopy();
+  const plain = 'Just a normal reply, no protocol block.';
+  expect(splitStopSignal(plain)).toBeNull();
+  expect(rendererCopy.splitStopSignal(plain)).toBeNull();
+});
+
+test('both splitters refuse a quoted sentinel with no valid JSON tail', async () => {
+  const rendererCopy = await loadRendererCopy();
+  const quoting = `Why does chat use ${STOP_SENTINEL} internally? Not real JSON after it.`;
+  expect(splitStopSignal(quoting)).toBeNull();
+  expect(rendererCopy.splitStopSignal(quoting)).toBeNull();
+});
+
+test('both splitters anchor on the LAST sentinel occurrence', async () => {
+  const rendererCopy = await loadRendererCopy();
+  const body = 'first mention of the sentinel text, then the real one';
+  const full = `${STOP_SENTINEL} mentioned earlier in prose.\n\n${body}\n\n${STOP_SENTINEL}\n${JSON.stringify({ questions: ['q'] })}`;
+
+  const mainSplit = splitStopSignal(full);
+  const rendererSplit = rendererCopy.splitStopSignal(full);
+  expect(mainSplit.answerBody).toBe(rendererSplit.body);
+});

package/src/main/chatRunner.cjs

@@ -53,6 +53,7 @@ const { classifyPromptTicket } = require('./lib/classifyPromptTicket.cjs');
 const sessionSlots = require('./lib/sessionSlots.cjs');
 const opsErrorLog = require('./lib/opsErrorLog.cjs');
 const agentModelResolve = require('./lib/agentModelResolve.cjs');
+const { resolveEpicSpawnCwd } = require('./lib/epicSpawnCwd.cjs');
 
 // ─── Stop-signal protocol ──────────────────────────────────────────────────
 // Single source of truth for the sentinel and parser. The renderer (PRD 320)
@@ -548,13 +549,22 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
 
     if (!silent) broadcast('chat:run:started', { tabId, sessionId });
 
+    // sessionId IS the Epic's claudeSessionId for an Epic-backed tab (see
+    // comment above childEnv) — resolves to that Epic's isolated worktree
+    // dir when one exists (PRD 1033), else `cwd` unchanged. `cwd` itself is
+    // NEVER repointed: every ops-root/model/exchange resolution above and
+    // below keeps using it exactly as before — only this ACTUAL spawn cwd
+    // option does. See epicSpawnCwd.cjs's header comment (the ops-root
+    // hazard) and jobWorktree.cjs's own (execCwd vs job.cwd) for why.
+    const execCwd = resolveEpicSpawnCwd({ cwd, claudeSessionId: sessionId });
+
     // Spawn with stdin closed (mirrors scheduler's 'ignore' — prevents the
     // "claude -p stdin must be closed" gotcha from kg.cjs). stdout is piped for
     // real-time NDJSON streaming; stderr piped for error-message capture.
     let child;
     try {
       child = spawn(claudeBin, args, {
-        cwd,
+        cwd: execCwd,
         env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
         detached: true, // own process group so killTree can SIGTERM descendants

package/src/main/index.cjs

@@ -32,6 +32,9 @@ const chatRunner = require('./chatRunner.cjs');
 const promptSessionEvents = require('./promptSessionEvents.cjs');
 const activeIndexMerge = require('./lib/activeIndexMerge.cjs');
 const promptSessionsCreateEpic = require('./lib/promptSessionsCreateEpic.cjs');
+const epicWorktreeMint = require('./lib/epicWorktreeMint.cjs');
+const epicWorktreeMerge = require('./lib/epicWorktreeMerge.cjs');
+const epicWorktreeProjectConfig = require('./lib/epicWorktreeProjectConfig.cjs');
 const agentLibrary = require('./agentLibrary.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { resolveBuildTarget } = require('./lib/buildTarget.cjs');
@@ -784,6 +787,9 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 activeIndexMerge.registerActiveIndexMergeHandlers();
 promptSessionsCreateEpic.registerPromptSessionsCreateEpicHandlers();
+epicWorktreeMint.registerEpicWorktreeMintHandlers();
+epicWorktreeMerge.registerEpicWorktreeMergeHandlers();
+epicWorktreeProjectConfig.registerEpicWorktreeProjectConfigHandlers();
 registerMemoryAggregateIpc();
 registerProjectBriefIpc();
 registerProjectPagesIpc();
@@ -1057,7 +1063,7 @@ app.whenReady().then(async () => {
       label: 'Session Manager',
       submenu: [
         {
-          label: 'New Session',
+          label: 'Open / Start Project…',
           accelerator: 'CmdOrCtrl+N',
           click: () => {
             if (mainWindow && !mainWindow.isDestroyed()) {
@@ -1066,12 +1072,12 @@ app.whenReady().then(async () => {
           },
         },
         {
-          label: 'Restart App',
+          label: 'Restart Session Manager App',
           accelerator: 'CmdOrCtrl+Shift+R',
           click: rebootApp,
         },
         {
-          label: 'Reboot Session',
+          label: 'Restart Terminal in Active Tab',
           accelerator: 'CmdOrCtrl+Shift+S',
           click: () => {
             if (mainWindow && !mainWindow.isDestroyed()) {
@@ -1080,14 +1086,14 @@ app.whenReady().then(async () => {
           },
         },
         { type: 'separator' },
-        { label: 'Quit', accelerator: 'CmdOrCtrl+Q', role: 'quit' },
+        { label: 'Quit Session Manager', accelerator: 'CmdOrCtrl+Q', role: 'quit' },
       ],
     },
     {
       label: 'Dev',
       submenu: [
-        { label: 'Toggle DevTools', accelerator: 'F12', role: 'toggleDevTools' },
-        { label: 'Reload', accelerator: 'CmdOrCtrl+R', role: 'reload' },
+        { label: 'Toggle Developer Tools', accelerator: 'F12', role: 'toggleDevTools' },
+        { label: 'Reload App Window', accelerator: 'CmdOrCtrl+R', role: 'reload' },
         // Diagnostic-only; absent unless SM_HEAP_SNAPSHOT=1 (see heapSnapshot.cjs).
         ...(heapSnapshotMenuItem ? [heapSnapshotMenuItem] : []),
       ],

package/src/main/ipcSchemas.cjs

@@ -203,6 +203,37 @@ const promptSessionsCreateEpic = z.object({
   sections: z.array(EpicIntakeSectionSchema).max(200).optional(),
 });
 
+// Renderer entry point for creating an Epic's isolated git worktree
+// (lib/epicWorktreeMint.cjs) at the proposed->active transition — PRD 1033.
+const promptSessionsCreateWorktree = z.object({
+  cwd: z.string().min(1).max(4096),
+  epicId: z.string().regex(PROMPT_SESSION_ID_RE),
+});
+
+// Renderer entry point for folding an Epic's isolated git worktree branch
+// back into its owning project's main tree (lib/epicWorktreeMerge.cjs) — PRD
+// 1034, the ONLY point where the per-Epic isolation PRD 1033 wires resolves.
+// `branch`/`dir` are supplied by the caller (the renderer's own in-memory
+// `session.worktree`) rather than re-derived from active-index.json, since
+// markCompleted calls this while the Epic's row is about to leave that index
+// entirely for its archive.
+const promptSessionsMergeToMain = z.object({
+  cwd: z.string().min(1).max(4096),
+  epicId: z.string().regex(PROMPT_SESSION_ID_RE),
+  branch: z.string().regex(/^sm-epic\/[A-Za-z0-9_-]{1,64}$/),
+  dir: z.string().min(1).max(4096),
+});
+
+// Renderer entry points for the per-project "disable Epic worktree
+// isolation" UI toggle (lib/epicWorktreeProjectConfig.cjs) — PRD 1035.
+const promptSessionsGetWorktreeDisabled = z.object({
+  cwd: z.string().min(1).max(4096),
+});
+const promptSessionsSetWorktreeDisabled = z.object({
+  cwd: z.string().min(1).max(4096),
+  disabled: z.boolean(),
+});
+
 // ──────────────────────────────────────────── Sessions
 const sessionsPayload = z.object({
   tabs: z.array(z.object({
@@ -909,6 +940,10 @@ module.exports = {
     promptSessionTranscriptRead,
     promptSessionsMergeActiveIndex,
     promptSessionsCreateEpic,
+    promptSessionsCreateWorktree,
+    promptSessionsMergeToMain,
+    promptSessionsGetWorktreeDisabled,
+    promptSessionsSetWorktreeDisabled,
     auditLogAppend,
     agentMemoryList,
     agentMemoryGet,