claude-code-session-manager 0.71.0 → 0.73.0

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

@@ -0,0 +1,193 @@
+/**
+ * epicSpawnCwd.test.cjs — unit tests for resolveEpicSpawnCwd, the shared
+ * spawn-cwd resolver both pty.cjs's Terminal spawn and chatRunner.cjs's
+ * headless spawn use to point an Epic's actual child process at its
+ * isolated git worktree (PRD 1033), while every other cwd usage stays the
+ * real project cwd (see the module's own "ops-root hazard" header comment).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicSpawnCwd.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { resolveEpicSpawnCwd } = require('../epicSpawnCwd.cjs');
+
+function stubReadActiveIndex(sessions) {
+  return () => ({ sessions });
+}
+
+// resolveEpicSpawnCwd stats worktree.dir before returning it (a persisted
+// path outlives its checkout across a reboot/tmp sweep, a clone onto another
+// machine, or a manual prune). These fixtures name paths that don't exist on
+// the test host, so inject a stat stub saying they do; the "vanished dir"
+// tests at the bottom exercise the real fallback.
+const statOk = () => ({ isDirectory: () => true });
+const statGone = () => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); };
+
+test('returns worktree.dir when the matching Epic (by claudeSessionId) has one', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': {
+          id: 'epic-1',
+          claudeSessionId: 'sess-1',
+          worktree: { dir: '/tmp/sm-epic-worktrees/abc/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo', status: 'active' },
+        },
+      }),
+      statSync: statOk,
+    },
+  });
+  expect(result).toBe('/tmp/sm-epic-worktrees/abc/epic-1');
+});
+
+test('falls back to cwd unchanged when the matching Epic has no worktree field', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1' },
+      }),
+    },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+test('falls back to cwd unchanged when no session matches claudeSessionId (non-Epic tab)', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'some-other-session',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': {
+          id: 'epic-1',
+          claudeSessionId: 'sess-1',
+          worktree: { dir: '/tmp/sm-epic-worktrees/abc/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo', status: 'active' },
+        },
+      }),
+      statSync: statOk,
+    },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+test('falls back to cwd unchanged when cwd or claudeSessionId is missing', () => {
+  expect(resolveEpicSpawnCwd({ cwd: '/projects/foo', claudeSessionId: '' })).toBe('/projects/foo');
+  expect(resolveEpicSpawnCwd({ cwd: '', claudeSessionId: 'sess-1' })).toBe('');
+  expect(resolveEpicSpawnCwd({})).toBeUndefined();
+});
+
+test('returns worktree.dir for a conflicted (needs_merge_resolution) Epic too — same PTY-into-worktree path a human uses to resolve it manually (PRD 1034)', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex({
+        'epic-1': {
+          id: 'epic-1',
+          claudeSessionId: 'sess-1',
+          worktree: {
+            dir: '/tmp/sm-epic-worktrees/abc/epic-1',
+            branch: 'sm-epic/epic-1',
+            baseCwd: '/projects/foo',
+            status: 'needs_merge_resolution',
+          },
+        },
+      }),
+      statSync: statOk,
+    },
+  });
+  expect(result).toBe('/tmp/sm-epic-worktrees/abc/epic-1');
+});
+
+test('never throws when the active-index read itself throws — falls back to cwd', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: () => { throw new Error('disk read failed'); },
+    },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+// ─── persisted worktree.dir outliving its checkout (2026-08-13) ─────────────
+//
+// worktree.dir is an absolute os.tmpdir() path persisted onto the Epic record
+// in active-index.json — a git-TRACKED file. It therefore routinely names a
+// directory that no longer exists: /tmp is cleared on boot on most Linux
+// distros and macOS (this host: `D /tmp 1777 root root 30d`), Epics are
+// deliberately long-lived, and a clone on another machine carries a path built
+// from the ORIGINAL machine's tmpdir and a sha1 of its project cwd. Handing
+// that to node-pty/child_process as a spawn cwd fails the spawn outright, so
+// the resolver falls back to the shared project tree instead.
+
+const WORKTREE_SESSIONS = {
+  'epic-1': {
+    id: 'epic-1',
+    claudeSessionId: 'sess-1',
+    worktree: {
+      dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1',
+      branch: 'sm-epic/epic-1',
+      baseCwd: '/projects/foo',
+      status: 'active',
+    },
+  },
+};
+
+test('falls back to the project cwd when the persisted worktree dir no longer exists (reboot / tmp sweep)', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: { readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS), statSync: statGone },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+test('falls back when worktree.dir exists but is a FILE, not a directory', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS),
+      statSync: () => ({ isDirectory: () => false }),
+    },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+test('a stat that throws something other than ENOENT still falls back rather than propagating', () => {
+  const result = resolveEpicSpawnCwd({
+    cwd: '/projects/foo',
+    claudeSessionId: 'sess-1',
+    deps: {
+      readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS),
+      statSync: () => { throw Object.assign(new Error('EACCES'), { code: 'EACCES' }); },
+    },
+  });
+  expect(result).toBe('/projects/foo');
+});
+
+test('a real, existing directory IS returned — the check gates on disk state, not on the field being set', () => {
+  const os = require('node:os');
+  const fs = require('node:fs');
+  const realDir = fs.mkdtempSync(require('node:path').join(os.tmpdir(), 'sm-epicspawn-real-'));
+  try {
+    const result = resolveEpicSpawnCwd({
+      cwd: '/projects/foo',
+      claudeSessionId: 'sess-1',
+      deps: {
+        readActiveIndex: stubReadActiveIndex({
+          'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: realDir, branch: 'b', baseCwd: '/projects/foo', status: 'active' } },
+        }),
+        // no statSync stub — exercises the real fs.statSync default
+      },
+    });
+    expect(result).toBe(realDir);
+  } finally {
+    fs.rmSync(realDir, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,136 @@
+/**
+ * epicWorktreeBoot.test.cjs — unit tests for reconcileEpicWorktreesOnBoot
+ * (PRD 1033), which wires gitWorktree.cjs's `isLive` predicate (built but
+ * left unwired by PRD 1032) to a project's real active-index.json: a
+ * worktree survives boot reconciliation exactly when its owning Epic is
+ * still 'active' there.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicWorktreeBoot.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { reconcileEpicWorktreesOnBoot } = require('../epicWorktreeBoot.cjs');
+
+test('reaps a worktree whose owning Epic is not active (missing from the index)', async () => {
+  const calls = [];
+  const reconcileWorktreesOnBoot = async (cwds, opts) => {
+    calls.push({ cwds, kind: opts.kind });
+    // Simulate gitWorktree.cjs's real loop: it asks isLive per key found on disk.
+    expect(await opts.isLive('orphaned-epic')).toBe(false);
+  };
+  await reconcileEpicWorktreesOnBoot(['/projects/foo'], {
+    readActiveIndex: () => ({ sessions: {} }),
+    reconcileWorktreesOnBoot,
+  });
+  expect(calls).toHaveLength(1);
+  expect(calls[0].kind).toBe('epic');
+});
+
+test('a worktree belonging to a currently-active Epic survives (isLive returns true)', async () => {
+  const reconcileWorktreesOnBoot = async (cwds, opts) => {
+    expect(await opts.isLive('still-active-epic')).toBe(true);
+    expect(await opts.isLive('completed-epic')).toBe(false);
+    expect(await opts.isLive('unknown-epic')).toBe(false);
+  };
+  await reconcileEpicWorktreesOnBoot(['/projects/foo'], {
+    readActiveIndex: (cwd) => {
+      expect(cwd).toBe('/projects/foo');
+      return {
+        sessions: {
+          'still-active-epic': { id: 'still-active-epic', status: 'active' },
+          'completed-epic': { id: 'completed-epic', status: 'completed' },
+        },
+      };
+    },
+    reconcileWorktreesOnBoot,
+  });
+});
+
+test('sweeps every cwd given, each with its own active-index read', async () => {
+  const seenCwds = [];
+  await reconcileEpicWorktreesOnBoot(['/projects/a', '/projects/b'], {
+    readActiveIndex: (cwd) => {
+      seenCwds.push(cwd);
+      return { sessions: {} };
+    },
+    reconcileWorktreesOnBoot: async () => {},
+  });
+  expect(seenCwds).toEqual(['/projects/a', '/projects/b']);
+});
+
+test('never throws when a cwd has no active-index.json yet (readActiveIndex throws)', async () => {
+  const reconcileWorktreesOnBoot = async (cwds, opts) => {
+    expect(await opts.isLive('any-epic')).toBe(false);
+  };
+  await expect(
+    reconcileEpicWorktreesOnBoot(['/projects/no-index-yet'], {
+      readActiveIndex: () => { throw new Error('ENOENT'); },
+      reconcileWorktreesOnBoot,
+    }),
+  ).resolves.toBeUndefined();
+});
+
+test('ignores falsy entries in the cwd list', async () => {
+  const seenCwds = [];
+  await reconcileEpicWorktreesOnBoot([null, '/projects/a', undefined, ''], {
+    readActiveIndex: (cwd) => { seenCwds.push(cwd); return { sessions: {} }; },
+    reconcileWorktreesOnBoot: async () => {},
+  });
+  expect(seenCwds).toEqual(['/projects/a']);
+});
+
+// ─── real git repo + real active-index.json, default (unstubbed) deps ─────
+
+test('end-to-end with default deps: a worktree of a still-active Epic survives, an orphaned one is reaped', async () => {
+  const fs = require('node:fs');
+  const os = require('node:os');
+  const path = require('node:path');
+  const { execFileSync } = require('node:child_process');
+  const gitWorktree = require('../gitWorktree.cjs');
+
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-epicworktreeboot-e2e-'));
+  const repoCwd = path.join(tmpRoot, 'repo');
+  const git = (args, cwd) => execFileSync('git', args, { cwd, encoding: 'utf8' });
+  fs.mkdirSync(repoCwd, { recursive: true });
+  git(['init', '-q'], repoCwd);
+  git(['config', 'user.email', 'test@example.com'], repoCwd);
+  git(['config', 'user.name', 'Test'], repoCwd);
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'initial'], repoCwd);
+  gitWorktree._resetActiveWorktreeCountForTests('epic', 0);
+
+  try {
+    const liveEpicId = 'e2e-live-epic';
+    const orphanedEpicId = 'e2e-orphaned-epic';
+    const live = await gitWorktree.createEpicWorktree({ cwd: repoCwd, epicId: liveEpicId });
+    const orphaned = await gitWorktree.createEpicWorktree({ cwd: repoCwd, epicId: orphanedEpicId });
+    expect(live.ok).toBe(true);
+    expect(orphaned.ok).toBe(true);
+    gitWorktree._resetActiveWorktreeCountForTests('epic', 0);
+
+    const indexDir = path.join(repoCwd, 'session-manager-operations', 'prompt-sessions');
+    fs.mkdirSync(indexDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(indexDir, 'active-index.json'),
+      JSON.stringify({
+        sessions: {
+          [liveEpicId]: { id: liveEpicId, status: 'active' },
+          // orphanedEpicId deliberately absent — simulates a completed/deleted Epic.
+        },
+        events: {},
+      }),
+    );
+
+    await reconcileEpicWorktreesOnBoot([repoCwd]);
+
+    expect(fs.existsSync(live.dir)).toBe(true);
+    expect(fs.existsSync(orphaned.dir)).toBe(false);
+
+    await gitWorktree.cleanupEpicWorktree({ cwd: repoCwd, dir: live.dir, branch: live.branch });
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,130 @@
+/**
+ * epicWorktreeMerge.test.cjs — unit tests for the
+ * 'promptSessions:merge-to-main' IPC handler (lib/epicWorktreeMerge.cjs),
+ * PRD 1034: the ONLY point where an Epic's isolated git worktree branch
+ * (PRD 1032/1033) resolves back into its owning project's main tree.
+ *
+ * Exercises the handler the same way index.cjs wires it — schema validation
+ * (ipcSchemas.cjs's `validated` wrapper) in front of the business logic,
+ * mirroring epicWorktreeMint.test.cjs's pattern.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicWorktreeMerge.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { schemas, validated } = require('../../ipcSchemas.cjs');
+const { mergeEpicToMainViaIpc } = require('../epicWorktreeMerge.cjs');
+const gitWorktree = require('../gitWorktree.cjs');
+const config = require('../../config.cjs');
+
+const handler = validated(schemas.promptSessionsMergeToMain, ({ cwd, epicId, branch, dir }) =>
+  mergeEpicToMainViaIpc(cwd, epicId, branch, dir),
+);
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' });
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(['init', '-q'], dir);
+  git(['config', 'user.email', 'test@example.com'], dir);
+  git(['config', 'user.name', 'Test'], dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+const tmpDirs = [];
+afterEach(async () => {
+  gitWorktree._resetActiveWorktreeCountForTests('epic', 0);
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    try { await gitWorktree.reconcileWorktreesOnBoot([d], { kind: 'epic' }); } catch { /* ignore */ }
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkRepoCwd() {
+  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicworktreemerge-'));
+  initRepo(cwd);
+  config.addAllowedRoot(cwd);
+  tmpDirs.push(cwd);
+  return cwd;
+}
+
+test('a clean ff-only merge succeeds and cleans up the worktree checkout', async () => {
+  const cwd = await mkRepoCwd();
+  const created = await gitWorktree.createEpicWorktree({ cwd, epicId: 'epic-merge-clean' });
+  expect(created.ok).toBe(true);
+
+  fs.writeFileSync(path.join(created.dir, 'epic-note.txt'), 'epic work\n', 'utf8');
+  git(['add', '-A'], created.dir);
+  git(['commit', '-q', '-m', 'epic edits'], created.dir);
+
+  const result = await handler(null, { cwd, epicId: 'epic-merge-clean', branch: created.branch, dir: created.dir });
+
+  expect(result).toEqual({ ok: true, status: 'merged', integrated: true });
+  // Checkout removed, content landed on the main tree.
+  expect(fs.existsSync(created.dir)).toBe(false);
+  expect(fs.existsSync(path.join(cwd, 'epic-note.txt'))).toBe(true);
+  const branches = git(['branch', '--list', created.branch], cwd);
+  expect(branches.trim()).toBe('');
+});
+
+test('a real conflicting change leaves branch + worktree dir intact and returns needs_merge_resolution', async () => {
+  const cwd = await mkRepoCwd();
+  const created = await gitWorktree.createEpicWorktree({ cwd, epicId: 'epic-merge-conflict' });
+  expect(created.ok).toBe(true);
+
+  // Same line, two divergent edits — a genuine content conflict.
+  fs.writeFileSync(path.join(created.dir, 'README.md'), 'epic changed this line\n', 'utf8');
+  git(['add', '-A'], created.dir);
+  git(['commit', '-q', '-m', 'epic edits README'], created.dir);
+
+  fs.writeFileSync(path.join(cwd, 'README.md'), 'main tree changed this line\n', 'utf8');
+  git(['add', '-A'], cwd);
+  git(['commit', '-q', '-m', 'main tree edits README'], cwd);
+
+  const result = await handler(null, { cwd, epicId: 'epic-merge-conflict', branch: created.branch, dir: created.dir });
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe('needs_merge_resolution');
+  expect(result.reason).toMatch(/conflict|merge failed/i);
+
+  // Never silently discarded: the checkout and its branch both survive.
+  expect(fs.existsSync(created.dir)).toBe(true);
+  const branches = git(['branch', '--list', created.branch], cwd);
+  expect(branches.trim()).not.toBe('');
+  // The main tree itself is left clean (no half-applied merge).
+  const status = git(['status', '--porcelain'], cwd);
+  expect(status.trim()).toBe('');
+});
+
+test('a cwd outside every allowed root is rejected before anything is merged', async () => {
+  const unregistered = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicworktreemerge-unregistered-'));
+  initRepo(unregistered);
+  tmpDirs.push(unregistered);
+
+  await expect(
+    handler(null, { cwd: unregistered, epicId: 'epic-merge-x', branch: 'sm-epic/epic-merge-x', dir: '/tmp/whatever' }),
+  ).rejects.toThrow(/outside allowed boundaries/);
+});
+
+test('a request with a malformed branch name is rejected by ipcSchemas validation', async () => {
+  const cwd = await mkRepoCwd();
+  // `validated()` parses BEFORE calling the handler, so a schema rejection is
+  // a synchronous throw, not a rejected promise (ipcSchemas.cjs:851-856 —
+  // Electron's IPC harness is what turns it into a rejection at the boundary).
+  // Same assertion style as promptSessionsCreateEpicHandler.test.cjs:86-106.
+  expect(
+    () => handler(null, { cwd, epicId: 'epic-merge-y', branch: 'not-an-epic-branch', dir: '/tmp/whatever' }),
+  ).toThrow();
+});

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

@@ -0,0 +1,115 @@
+/**
+ * epicWorktreeMint.test.cjs — unit tests for the
+ * 'promptSessions:create-worktree' IPC handler (lib/epicWorktreeMint.cjs),
+ * PRD 1033: the main-process entry point the renderer's approveProposed
+ * fires (fire-and-forget) at the Epic proposed->active transition to create
+ * its isolated git worktree.
+ *
+ * Exercises the handler the same way index.cjs wires it — schema validation
+ * (ipcSchemas.cjs's `validated` wrapper) in front of the business logic,
+ * mirroring promptSessionsCreateEpicHandler.test.cjs's pattern.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicWorktreeMint.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { schemas, validated } = require('../../ipcSchemas.cjs');
+const { createEpicWorktreeViaIpc } = require('../epicWorktreeMint.cjs');
+const gitWorktree = require('../gitWorktree.cjs');
+const config = require('../../config.cjs');
+
+const handler = validated(schemas.promptSessionsCreateWorktree, ({ cwd, epicId }) => createEpicWorktreeViaIpc(cwd, epicId));
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' });
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(['init', '-q'], dir);
+  git(['config', 'user.email', 'test@example.com'], dir);
+  git(['config', 'user.name', 'Test'], dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+const tmpDirs = [];
+afterEach(async () => {
+  gitWorktree._resetActiveWorktreeCountForTests('epic', 0);
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    try { await gitWorktree.reconcileWorktreesOnBoot([d], { kind: 'epic' }); } catch { /* ignore */ }
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkRepoCwd() {
+  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicworktreemint-'));
+  initRepo(cwd);
+  config.addAllowedRoot(cwd);
+  tmpDirs.push(cwd);
+  return cwd;
+}
+
+test('a valid request creates the Epic worktree and returns the field shape ready to persist', async () => {
+  const cwd = await mkRepoCwd();
+  const result = await handler(null, { cwd, epicId: 'epic-mint-1' });
+
+  expect(result).not.toBeNull();
+  expect(result.branch).toBe('sm-epic/epic-mint-1');
+  expect(result.baseCwd).toBe(cwd);
+  expect(result.status).toBe('active');
+  expect(fs.existsSync(result.dir)).toBe(true);
+  expect(fs.existsSync(path.join(result.dir, 'README.md'))).toBe(true);
+});
+
+test('a non-git cwd resolves to null rather than throwing (Epic proceeds unisolated)', async () => {
+  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicworktreemint-nongit-'));
+  config.addAllowedRoot(cwd);
+  tmpDirs.push(cwd);
+
+  const result = await handler(null, { cwd, epicId: 'epic-mint-2' });
+  expect(result).toBeNull();
+});
+
+test('a dirty base tree resolves to null rather than throwing', async () => {
+  const cwd = await mkRepoCwd();
+  fs.writeFileSync(path.join(cwd, 'dirty.txt'), 'uncommitted\n', 'utf8');
+
+  const result = await handler(null, { cwd, epicId: 'epic-mint-3' });
+  expect(result).toBeNull();
+});
+
+test('SM_EPIC_WORKTREE_DISABLE=1 resolves to null rather than throwing', async () => {
+  const cwd = await mkRepoCwd();
+  const original = process.env.SM_EPIC_WORKTREE_DISABLE;
+  process.env.SM_EPIC_WORKTREE_DISABLE = '1';
+  try {
+    const result = await handler(null, { cwd, epicId: 'epic-mint-4' });
+    expect(result).toBeNull();
+  } finally {
+    if (original === undefined) delete process.env.SM_EPIC_WORKTREE_DISABLE;
+    else process.env.SM_EPIC_WORKTREE_DISABLE = original;
+  }
+});
+
+test('a cwd outside every allowed root is rejected before anything is created', async () => {
+  const unregistered = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicworktreemint-unregistered-'));
+  initRepo(unregistered);
+  tmpDirs.push(unregistered);
+
+  await expect(handler(null, { cwd: unregistered, epicId: 'epic-mint-5' })).rejects.toThrow(/outside allowed boundaries/);
+});
+
+test('a request missing epicId is rejected by ipcSchemas validation', async () => {
+  const cwd = await mkRepoCwd();
+  expect(() => handler(null, { cwd })).toThrow();
+});

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

@@ -0,0 +1,79 @@
+/**
+ * epicWorktreeProjectConfig.test.cjs — PRD 1035: the per-project "disable
+ * Epic worktree isolation" UI toggle. Points the module at a throwaway
+ * tmpdir file via SM_EPIC_WORKTREE_PROJECT_CONFIG_PATH so it never touches
+ * the real ~/.claude/session-manager/epic-worktree-project-config.json on
+ * the machine running the tests.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicWorktreeProjectConfig.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpRoot;
+let configFile;
+let originalOverride;
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-epic-worktree-project-config-'));
+  configFile = path.join(tmpRoot, 'config.json');
+  originalOverride = process.env.SM_EPIC_WORKTREE_PROJECT_CONFIG_PATH;
+  process.env.SM_EPIC_WORKTREE_PROJECT_CONFIG_PATH = configFile;
+});
+
+afterEach(() => {
+  if (originalOverride === undefined) delete process.env.SM_EPIC_WORKTREE_PROJECT_CONFIG_PATH;
+  else process.env.SM_EPIC_WORKTREE_PROJECT_CONFIG_PATH = originalOverride;
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function freshModule() {
+  return require('../epicWorktreeProjectConfig.cjs');
+}
+
+test('defaults to not disabled for a project never touched', () => {
+  const m = freshModule();
+  expect(m.isEpicWorktreeDisabledForProject('/some/project')).toBe(false);
+});
+
+test('setEpicWorktreeDisabledForProject(true) persists across a fresh read', () => {
+  const m = freshModule();
+  m.setEpicWorktreeDisabledForProject('/proj/a', true);
+  expect(m.isEpicWorktreeDisabledForProject('/proj/a')).toBe(true);
+  expect(fs.existsSync(configFile)).toBe(true);
+  const onDisk = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  expect(onDisk).toEqual({ '/proj/a': true });
+});
+
+test('is scoped per cwd — a different project is unaffected', () => {
+  const m = freshModule();
+  m.setEpicWorktreeDisabledForProject('/proj/a', true);
+  expect(m.isEpicWorktreeDisabledForProject('/proj/b')).toBe(false);
+});
+
+test('setEpicWorktreeDisabledForProject(false) clears the entry rather than writing false', () => {
+  const m = freshModule();
+  m.setEpicWorktreeDisabledForProject('/proj/a', true);
+  m.setEpicWorktreeDisabledForProject('/proj/a', false);
+  expect(m.isEpicWorktreeDisabledForProject('/proj/a')).toBe(false);
+  const onDisk = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  expect(onDisk).toEqual({});
+});
+
+test('a missing or corrupt config file reads as not-disabled rather than throwing', () => {
+  const m = freshModule();
+  fs.mkdirSync(path.dirname(configFile), { recursive: true });
+  fs.writeFileSync(configFile, '{ not valid json');
+  expect(m.isEpicWorktreeDisabledForProject('/proj/a')).toBe(false);
+});
+
+test('isEpicWorktreeDisabledForProject rejects a non-string cwd instead of throwing', () => {
+  const m = freshModule();
+  expect(m.isEpicWorktreeDisabledForProject(null)).toBe(false);
+  expect(m.isEpicWorktreeDisabledForProject(undefined)).toBe(false);
+});