claude-code-session-manager 0.75.3 → 0.77.0

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

@@ -6,15 +6,30 @@
  * Run: timeout 300 npx vitest run src/main/lib/__tests__/delegationReadiness.test.cjs
  */
 
-import { test, expect, afterEach } from 'vitest';
+import { test, expect, afterEach, beforeEach } from 'vitest';
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
 const path = require('node:path');
-const { checkDelegationReadiness } = require('../delegationReadiness.cjs');
+const {
+  checkDelegationReadiness,
+  installPrdWriteGuard,
+  installDestructiveGitGuard,
+  probeSchedulerMcpLive,
+  clearLiveProbeCache,
+  PRD_WRITE_GUARD_SCRIPT,
+  DESTRUCTIVE_GIT_GUARD_SCRIPT,
+} = require('../delegationReadiness.cjs');
+
+const REQUIRED_TOOLS = ['scheduler_create_prd', 'session_manager_help'];
+
+beforeEach(() => {
+  clearLiveProbeCache();
+});
 
 const tmpDirs = [];
 afterEach(async () => {
+  clearLiveProbeCache();
   while (tmpDirs.length) {
     const d = tmpDirs.pop();
     await fsp.rm(d, { recursive: true, force: true });
@@ -32,46 +47,86 @@ async function writeJson(absPath, value) {
   await fsp.writeFile(absPath, JSON.stringify(value), 'utf8');
 }
 
+/** A stub stdio MCP server: answers initialize + tools/list over stdin/stdout. */
+async function writeAnsweringStub(dir, { toolNames = REQUIRED_TOOLS, countFile = null } = {}) {
+  const scriptPath = path.join(dir, 'stub-mcp-server.cjs');
+  const body = `
+    'use strict';
+    const readline = require('node:readline');
+    ${countFile ? `require('node:fs').appendFileSync(${JSON.stringify(countFile)}, 'x\\n');` : ''}
+    const rl = readline.createInterface({ input: process.stdin });
+    rl.on('line', (line) => {
+      let msg;
+      try { msg = JSON.parse(line); } catch { return; }
+      if (msg.id === 1) {
+        process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: 1, result: { protocolVersion: '2024-11-05', capabilities: {}, serverInfo: { name: 'stub', version: '1' } } }) + '\\n');
+      } else if (msg.id === 2) {
+        const tools = ${JSON.stringify(toolNames)}.map((name) => ({ name }));
+        process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: 2, result: { tools } }) + '\\n');
+      }
+    });
+  `;
+  await fsp.writeFile(scriptPath, body, 'utf8');
+  return scriptPath;
+}
+
+/** A stub that never responds to anything — exercises the timeout path. */
+async function writeSilentStub(dir) {
+  const scriptPath = path.join(dir, 'silent-mcp-server.cjs');
+  await fsp.writeFile(scriptPath, 'process.stdin.resume();\n', 'utf8');
+  return scriptPath;
+}
+
 async function makeGreenFixtures() {
   const homeDir = await mkTmp('sm-delegation-home-');
   const cwd = await mkTmp('sm-delegation-cwd-');
 
+  const scriptPath = await writeAnsweringStub(homeDir);
   await writeJson(path.join(homeDir, '.claude.json'), {
-    mcpServers: { 'session-manager-scheduler': { type: 'stdio', command: 'node', args: [] } },
+    mcpServers: { 'session-manager-scheduler': { type: 'stdio', command: 'node', args: [scriptPath] } },
   });
   await writeJson(path.join(homeDir, '.claude', 'settings.json'), {
     enabledPlugins: { 'session-manager-dev@session-manager': true },
   });
   await fsp.mkdir(path.join(homeDir, '.claude', 'agents'), { recursive: true });
   await fsp.writeFile(path.join(homeDir, '.claude', 'agents', 'dev-lead.md'), '# dev-lead', 'utf8');
+  // The canonical, sanctioned form: an ABSOLUTE path to session-manager's own
+  // guard script (installPrdWriteGuard's "reference, never vendor" decision).
   await writeJson(path.join(cwd, '.claude', 'settings.json'), {
     hooks: {
       PreToolUse: [
         {
           matcher: 'Write|Edit|NotebookEdit',
-          hooks: [{ type: 'command', command: 'node scripts/hooks/guard-prd-writes.cjs' }],
+          hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }],
+        },
+        {
+          matcher: 'Bash',
+          hooks: [{ type: 'command', command: `node ${DESTRUCTIVE_GIT_GUARD_SCRIPT}` }],
         },
       ],
     },
   });
 
-  return { homeDir, cwd };
+  return { homeDir, cwd, scriptPath };
 }
 
-test('all four checks pass on a fully-configured project', async () => {
+test('all seven checks pass on a fully-configured project', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
 
   expect(result.ok).toBe(true);
-  expect(result.checks).toHaveLength(4);
+  expect(result.checks).toHaveLength(7);
   expect(result.checks.every((c) => c.ok)).toBe(true);
   expect(result.checks.map((c) => c.id)).toEqual([
     'scheduler-mcp',
+    'scheduler-mcp-live',
+    'scheduler-mcp-project-duplicate',
     'dev-plugin',
     'agent-personas',
     'prd-write-guard',
+    'destructive-git-guard',
   ]);
-});
+}, 15_000);
 
 test('scheduler-mcp: passes via project-scope .mcp.json even without user scope', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
@@ -80,47 +135,72 @@ test('scheduler-mcp: passes via project-scope .mcp.json even without user scope'
     mcpServers: { 'session-manager-scheduler': { command: 'node', args: [] } },
   });
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'scheduler-mcp');
   expect(check.ok).toBe(true);
-  expect(result.ok).toBe(true);
-});
+}, 15_000);
 
 test('scheduler-mcp: fails with a runnable fix when absent from both scopes', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
   await writeJson(path.join(homeDir, '.claude.json'), { mcpServers: {} });
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'scheduler-mcp');
   expect(check.ok).toBe(false);
   expect(result.ok).toBe(false);
   expect(check.fix).toMatch(/^claude mcp add session-manager-scheduler --scope user/);
   expect(check.fix).toContain('scheduler-mcp-server.cjs');
-});
+}, 15_000);
+
+test('scheduler-mcp: fails when the user-scope script path is RELATIVE', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), {
+    mcpServers: { 'session-manager-scheduler': { command: 'node', args: ['scripts/scheduler-mcp-server.cjs'] } },
+  });
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp');
+  expect(check.ok).toBe(false);
+  expect(check.detail).toMatch(/non-absolute/);
+  expect(check.fix).toMatch(/^claude mcp add session-manager-scheduler --scope user/);
+  // Live probe has nothing runnable to trust, so it must not report ready either.
+  expect(result.checks.find((c) => c.id === 'scheduler-mcp-live').skipped).toBe(true);
+}, 15_000);
+
+test('scheduler-mcp: fails when the user-scope script path is absolute but MISSING', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), {
+    mcpServers: { 'session-manager-scheduler': { command: 'node', args: [path.join(homeDir, 'does-not-exist.cjs')] } },
+  });
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp');
+  expect(check.ok).toBe(false);
+  expect(check.detail).toMatch(/no longer exists/);
+}, 15_000);
 
 test('dev-plugin: fails independently when enabledPlugins is missing the key', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
   await writeJson(path.join(homeDir, '.claude', 'settings.json'), { enabledPlugins: {} });
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'dev-plugin');
   expect(check.ok).toBe(false);
   expect(result.ok).toBe(false);
   expect(check.fix).toBeTruthy();
-  // the other three checks still pass independently
+  // the other checks still pass independently
   expect(result.checks.filter((c) => c.id !== 'dev-plugin').every((c) => c.ok)).toBe(true);
-});
+}, 15_000);
 
 test('agent-personas: fails independently when ~/.claude/agents has no personas', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
   await fsp.rm(path.join(homeDir, '.claude', 'agents', 'dev-lead.md'));
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'agent-personas');
   expect(check.ok).toBe(false);
   expect(result.ok).toBe(false);
-  expect(result.checks.filter((c) => c.id !== 'agent-personas').every((c) => c.ok)).toBe(true);
-});
+}, 15_000);
 
 test('agent-personas: passes via project-scope .claude/agents/ even without global personas', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
@@ -128,31 +208,20 @@ test('agent-personas: passes via project-scope .claude/agents/ even without glob
   await fsp.mkdir(path.join(cwd, '.claude', 'agents'), { recursive: true });
   await fsp.writeFile(path.join(cwd, '.claude', 'agents', 'builder.md'), '# builder', 'utf8');
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'agent-personas');
   expect(check.ok).toBe(true);
-  expect(result.ok).toBe(true);
-});
-
-test('agent-personas: fails when the directory does not exist at all', async () => {
-  const { homeDir, cwd } = await makeGreenFixtures();
-  await fsp.rm(path.join(homeDir, '.claude', 'agents'), { recursive: true, force: true });
-
-  const result = checkDelegationReadiness({ cwd, homeDir });
-  const check = result.checks.find((c) => c.id === 'agent-personas');
-  expect(check.ok).toBe(false);
-});
+}, 15_000);
 
 test('prd-write-guard: fails independently when the hook is missing', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
   await writeJson(path.join(cwd, '.claude', 'settings.json'), { hooks: { PreToolUse: [] } });
 
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  const result = await checkDelegationReadiness({ cwd, homeDir });
   const check = result.checks.find((c) => c.id === 'prd-write-guard');
   expect(check.ok).toBe(false);
   expect(result.ok).toBe(false);
-  expect(result.checks.filter((c) => c.id !== 'prd-write-guard').every((c) => c.ok)).toBe(true);
-});
+}, 15_000);
 
 test('unparseable JSON files yield ok:false with a detail, never a throw', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
@@ -160,8 +229,8 @@ test('unparseable JSON files yield ok:false with a detail, never a throw', async
   await fs.promises.writeFile(path.join(homeDir, '.claude', 'settings.json'), '{ not valid json', 'utf8');
   await fs.promises.writeFile(path.join(cwd, '.claude', 'settings.json'), '{ not valid json', 'utf8');
 
-  expect(() => checkDelegationReadiness({ cwd, homeDir })).not.toThrow();
-  const result = checkDelegationReadiness({ cwd, homeDir });
+  await expect(checkDelegationReadiness({ cwd, homeDir })).resolves.toBeTruthy();
+  const result = await checkDelegationReadiness({ cwd, homeDir });
 
   const scheduler = result.checks.find((c) => c.id === 'scheduler-mcp');
   const devPlugin = result.checks.find((c) => c.id === 'dev-plugin');
@@ -173,13 +242,293 @@ test('unparseable JSON files yield ok:false with a detail, never a throw', async
   expect(guard.ok).toBe(false);
   expect(guard.detail).toBeTruthy();
   expect(result.ok).toBe(false);
-});
+}, 15_000);
+
+// ─────────────────────────────── scheduler-mcp-project-duplicate
+
+test('scheduler-mcp-project-duplicate: warns when both scopes register the server', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.mcp.json'), {
+    mcpServers: { 'session-manager-scheduler': { command: 'node', args: ['scripts/scheduler-mcp-server.cjs'] } },
+  });
 
-test('missing cwd/.claude/settings.json entirely is treated as guard-absent, not a throw', async () => {
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp-project-duplicate');
+  expect(check.ok).toBe(true);
+  expect(check.warn).toBe(true);
+  expect(check.detail).toMatch(/user scope is canonical/);
+  // A warning never fails the overall gate.
+  expect(result.ok).toBe(true);
+}, 15_000);
+
+test('scheduler-mcp-project-duplicate: no warning when only user scope is registered', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp-project-duplicate');
+  expect(check.ok).toBe(true);
+  expect(check.warn).toBe(false);
+}, 15_000);
+
+// ─────────────────────────────── scheduler-mcp-live
+
+test('scheduler-mcp-live: ok when the server answers tools/list with both required tools', async () => {
+  const dir = await mkTmp('sm-live-probe-');
+  const scriptPath = await writeAnsweringStub(dir);
+
+  const result = await probeSchedulerMcpLive({ command: 'node', args: [scriptPath], env: {} });
+  expect(result.ok).toBe(true);
+  expect(result.detail).toContain('scheduler_create_prd');
+}, 15_000);
+
+test('scheduler-mcp-live: fails naming the missing tool when the server answers WITHOUT it', async () => {
+  const dir = await mkTmp('sm-live-probe-');
+  const scriptPath = await writeAnsweringStub(dir, { toolNames: ['scheduler_create_prd'] });
+
+  const result = await probeSchedulerMcpLive({ command: 'node', args: [scriptPath], env: {} });
+  expect(result.ok).toBe(false);
+  expect(result.detail).toContain('session_manager_help');
+}, 15_000);
+
+test('scheduler-mcp-live: times out (bounded) against a server that never answers, and kills the child', async () => {
+  const dir = await mkTmp('sm-live-probe-');
+  const scriptPath = await writeSilentStub(dir);
+
+  const start = Date.now();
+  const result = await probeSchedulerMcpLive({ command: 'node', args: [scriptPath], env: {} });
+  const elapsed = Date.now() - start;
+
+  expect(result.ok).toBe(false);
+  expect(result.detail).toBe('timeout');
+  expect(elapsed).toBeLessThan(15_000);
+}, 20_000);
+
+test('scheduler-mcp-live: is skipped, not failed, when scheduler-mcp already failed', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), { mcpServers: {} });
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const live = result.checks.find((c) => c.id === 'scheduler-mcp-live');
+  expect(live.ok).toBe(true);
+  expect(live.skipped).toBe(true);
+  // One red row for the registration failure, not two.
+  expect(result.checks.filter((c) => !c.ok)).toHaveLength(1);
+}, 15_000);
+
+test('scheduler-mcp-live: memoizes the probe per registration signature within the TTL', async () => {
+  const dir = await mkTmp('sm-live-probe-');
+  const countFile = path.join(dir, 'spawn-count.txt');
+  const scriptPath = await writeAnsweringStub(dir, { countFile });
+
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), {
+    mcpServers: { 'session-manager-scheduler': { type: 'stdio', command: 'node', args: [scriptPath] } },
+  });
+
+  await checkDelegationReadiness({ cwd, homeDir });
+  await checkDelegationReadiness({ cwd, homeDir });
+
+  const spawnCount = (await fsp.readFile(countFile, 'utf8')).trim().split('\n').filter(Boolean).length;
+  expect(spawnCount).toBe(1);
+}, 15_000);
+
+// ─────────────────────────────── installPrdWriteGuard (unchanged behavior)
+
+test('installPrdWriteGuard: writes the canonical ABSOLUTE-path entry and turns the check green', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
   await fsp.rm(path.join(cwd, '.claude', 'settings.json'));
 
-  expect(() => checkDelegationReadiness({ cwd, homeDir })).not.toThrow();
-  const result = checkDelegationReadiness({ cwd, homeDir });
-  expect(result.checks.find((c) => c.id === 'prd-write-guard').ok).toBe(false);
+  const r = await installPrdWriteGuard({ cwd });
+  expect(r.ok).toBe(true);
+  expect(r.action).toBe('installed');
+  expect(r.command).toBe(`node ${PRD_WRITE_GUARD_SCRIPT}`);
+
+  const written = JSON.parse(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8'));
+  expect(written.hooks.PreToolUse).toEqual([
+    { matcher: 'Write|Edit|NotebookEdit', hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }] },
+  ]);
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  expect(result.checks.find((c) => c.id === 'prd-write-guard').ok).toBe(true);
+}, 15_000);
+
+test('installPrdWriteGuard: is idempotent — a healthy guard is a no-op', async () => {
+  const { cwd } = await makeGreenFixtures();
+  await installPrdWriteGuard({ cwd });
+  const before = fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8');
+
+  const again = await installPrdWriteGuard({ cwd });
+  expect(again.action).toBe('already-installed');
+  expect(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8')).toBe(before);
+});
+
+test('installPrdWriteGuard: refuses on unparseable settings rather than discarding them', async () => {
+  const { cwd } = await makeGreenFixtures();
+  await fsp.writeFile(path.join(cwd, '.claude', 'settings.json'), '{ not valid json', 'utf8');
+
+  const r = await installPrdWriteGuard({ cwd });
+  expect(r.ok).toBe(false);
+  expect(r.action).toBe('error');
+  expect(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8')).toBe('{ not valid json');
+});
+
+// The guard script is not just referenced — it is EXERCISED here, so the
+// "certifies a config that has never been proven to run" gap is closed by a
+// real end-to-end run of the exact command installPrdWriteGuard writes.
+test('the installed command actually DENIES a scheduler PRD write and allows a normal one', async () => {
+  const { cwd } = await makeGreenFixtures();
+  const { execFileSync } = require('node:child_process');
+
+  const run = (toolInput) => JSON.parse(execFileSync('node', [PRD_WRITE_GUARD_SCRIPT], {
+    input: JSON.stringify({ tool_name: 'Write', tool_input: toolInput, cwd }),
+    encoding: 'utf8',
+  }));
+
+  const denied = run({ file_path: path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', '1234-x.md'), content: '# x' });
+  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
+
+  const allowed = run({ file_path: path.join(cwd, 'src', 'x.ts'), content: 'x' });
+  expect(allowed.hookSpecificOutput?.permissionDecision).not.toBe('deny');
+});
+
+// ─────────────────────────────── destructive-git-guard / installDestructiveGitGuard
+
+test('destructive-git-guard: fails independently when the hook is missing', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Write|Edit|NotebookEdit',
+          hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }],
+        },
+      ],
+    },
+  });
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'destructive-git-guard');
+  expect(check.ok).toBe(false);
+  expect(result.ok).toBe(false);
+  // the other checks still pass independently
+  expect(result.checks.filter((c) => c.id !== 'destructive-git-guard').every((c) => c.ok)).toBe(true);
+}, 15_000);
+
+test('destructive-git-guard: fails when the hook names a script that does not exist', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Write|Edit|NotebookEdit',
+          hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }],
+        },
+        {
+          matcher: 'Bash',
+          hooks: [{ type: 'command', command: 'node /does/not/exist/guard-destructive-git.cjs' }],
+        },
+      ],
+    },
+  });
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'destructive-git-guard');
+  expect(check.ok).toBe(false);
+  expect(check.detail).toMatch(/does not exist/);
+}, 15_000);
+
+test('installDestructiveGitGuard: writes the canonical ABSOLUTE-path entry and turns the check green', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Write|Edit|NotebookEdit',
+          hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }],
+        },
+      ],
+    },
+  });
+
+  const r = await installDestructiveGitGuard({ cwd });
+  expect(r.ok).toBe(true);
+  expect(r.action).toBe('installed');
+  expect(r.command).toBe(`node ${DESTRUCTIVE_GIT_GUARD_SCRIPT}`);
+
+  const written = JSON.parse(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8'));
+  // The pre-existing Write|Edit|NotebookEdit matcher (and its hook) survives untouched.
+  expect(written.hooks.PreToolUse).toContainEqual(
+    { matcher: 'Write|Edit|NotebookEdit', hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }] },
+  );
+  expect(written.hooks.PreToolUse).toContainEqual(
+    { matcher: 'Bash', hooks: [{ type: 'command', command: `node ${DESTRUCTIVE_GIT_GUARD_SCRIPT}` }] },
+  );
+
+  const result = await checkDelegationReadiness({ cwd, homeDir });
+  expect(result.checks.find((c) => c.id === 'destructive-git-guard').ok).toBe(true);
+  expect(result.checks.find((c) => c.id === 'prd-write-guard').ok).toBe(true);
+}, 15_000);
+
+test('installDestructiveGitGuard: is idempotent — a healthy guard is a no-op', async () => {
+  const { cwd } = await makeGreenFixtures();
+  const before = fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8');
+
+  const again = await installDestructiveGitGuard({ cwd });
+  expect(again.action).toBe('already-installed');
+  expect(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8')).toBe(before);
+});
+
+test('installDestructiveGitGuard: repairs a broken entry in place rather than duplicating it', async () => {
+  const { cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Write|Edit|NotebookEdit',
+          hooks: [{ type: 'command', command: `node ${PRD_WRITE_GUARD_SCRIPT}` }],
+        },
+        {
+          matcher: 'Bash',
+          hooks: [{ type: 'command', command: 'node /does/not/exist/guard-destructive-git.cjs' }],
+        },
+      ],
+    },
+  });
+
+  const r = await installDestructiveGitGuard({ cwd });
+  expect(r.action).toBe('repaired');
+
+  const written = JSON.parse(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8'));
+  const bashMatchers = written.hooks.PreToolUse.filter((m) => m.matcher === 'Bash');
+  expect(bashMatchers).toHaveLength(1);
+  expect(bashMatchers[0].hooks).toEqual([{ type: 'command', command: `node ${DESTRUCTIVE_GIT_GUARD_SCRIPT}` }]);
+});
+
+test('installDestructiveGitGuard: refuses on unparseable settings rather than discarding them', async () => {
+  const { cwd } = await makeGreenFixtures();
+  await fsp.writeFile(path.join(cwd, '.claude', 'settings.json'), '{ not valid json', 'utf8');
+
+  const r = await installDestructiveGitGuard({ cwd });
+  expect(r.ok).toBe(false);
+  expect(r.action).toBe('error');
+  expect(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8')).toBe('{ not valid json');
+});
+
+// The guard script is EXERCISED here too, same rationale as the
+// installPrdWriteGuard end-to-end test above.
+test('the installed destructive-git command actually DENIES a shared-tree stash and allows it inside an sm-job/ worktree', async () => {
+  const { cwd } = await makeGreenFixtures();
+  const { execFileSync } = require('node:child_process');
+  const os2 = require('node:os');
+
+  const run = (command, runCwd) => JSON.parse(execFileSync('node', [DESTRUCTIVE_GIT_GUARD_SCRIPT], {
+    input: JSON.stringify({ tool_name: 'Bash', tool_input: { command }, cwd: runCwd }),
+    encoding: 'utf8',
+  }));
+
+  const denied = run('git stash', cwd);
+  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
+
+  const worktreeCwd = path.join(os2.tmpdir(), 'session-manager-job-worktrees', 'somehash', 'some-slug');
+  const allowed = run('git stash', worktreeCwd);
+  expect(allowed.hookSpecificOutput?.permissionDecision).not.toBe('deny');
 });

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

@@ -0,0 +1,91 @@
+/**
+ * ephemeralCwd.test.cjs — isEphemeralCwd(cwd) must refuse a cwd that
+ * resolves to os.tmpdir() itself, into a managed worktree root, or onto a
+ * linked git worktree's own root — and must allow an ordinary project cwd.
+ *
+ * See ephemeralCwd.cjs's header for the live incident (2026-09-01) this
+ * predicate closes: queueStore.writeSplit materializing scheduler state
+ * inside an ephemeral epic worktree, torn down with the Epic and silently
+ * losing the write.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/ephemeralCwd.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 { isEphemeralCwd } = require('../ephemeralCwd.cjs');
+const { KIND_CONFIG } = require('../gitWorktree.cjs');
+
+const tmpDirs = [];
+
+afterEach(async () => {
+  while (tmpDirs.length) {
+    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
+  }
+});
+
+// A real project must never itself live under /tmp — only ephemeral fixtures
+// (worktree checkouts) do. `test-results/` is already gitignored.
+const NON_TMP_SCRATCH_ROOT = path.join(process.cwd(), 'test-results', 'ephemeral-cwd-fixtures');
+
+async function mkNonTmpDir(prefix) {
+  fs.mkdirSync(NON_TMP_SCRATCH_ROOT, { recursive: true });
+  return fsp.mkdtemp(path.join(NON_TMP_SCRATCH_ROOT, prefix));
+}
+
+async function makeWorktreeFixture() {
+  const main = await mkNonTmpDir('sm-ephemeral-main-');
+  tmpDirs.push(main);
+  fs.mkdirSync(path.join(main, '.git'), { recursive: true });
+  const worktree = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-ephemeral-worktree-'));
+  tmpDirs.push(worktree);
+  const worktreeName = 'sm-epic-abc123';
+  const worktreeGitFile = path.join(worktree, '.git');
+  const adminDir = path.join(main, '.git', 'worktrees', worktreeName);
+  fs.mkdirSync(adminDir, { recursive: true });
+  fs.writeFileSync(path.join(adminDir, 'gitdir'), `${worktreeGitFile}\n`, 'utf8');
+  fs.writeFileSync(worktreeGitFile, `gitdir: ${adminDir}\n`, 'utf8');
+  return { main, worktree };
+}
+
+test('isEphemeralCwd refuses os.tmpdir() itself', () => {
+  expect(isEphemeralCwd(os.tmpdir())).toBe(true);
+});
+
+test('isEphemeralCwd refuses a cwd under the managed epic worktree root', () => {
+  const cwd = path.join(KIND_CONFIG.epic.root, 'some-hash', 'some-epic-slug');
+  expect(isEphemeralCwd(cwd)).toBe(true);
+});
+
+test('isEphemeralCwd refuses a cwd under the managed job worktree root', () => {
+  const cwd = path.join(KIND_CONFIG.job.root, 'some-job-id');
+  expect(isEphemeralCwd(cwd)).toBe(true);
+});
+
+test('isEphemeralCwd refuses a linked git worktree root anywhere on disk', async () => {
+  const { worktree } = await makeWorktreeFixture();
+  expect(isEphemeralCwd(worktree)).toBe(true);
+});
+
+test('isEphemeralCwd allows an ordinary project cwd (the worktree fixture\'s own main tree)', async () => {
+  const { main } = await makeWorktreeFixture();
+  expect(isEphemeralCwd(main)).toBe(false);
+});
+
+test('isEphemeralCwd allows an ordinary tmpdir-adjacent fixture used by other test suites (not os.tmpdir() itself, not a managed worktree root, not a linked worktree)', async () => {
+  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-some-other-test-fixture-'));
+  tmpDirs.push(cwd);
+  expect(isEphemeralCwd(cwd)).toBe(false);
+});
+
+test('isEphemeralCwd is false for non-absolute or missing input, never throws', () => {
+  expect(isEphemeralCwd('relative/path')).toBe(false);
+  expect(isEphemeralCwd('')).toBe(false);
+  expect(isEphemeralCwd(null)).toBe(false);
+  expect(isEphemeralCwd(undefined)).toBe(false);
+});

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

@@ -80,12 +80,14 @@ test('a non-git cwd resolves to null rather than throwing (Epic proceeds unisola
   expect(result).toBeNull();
 });
 
-test('a dirty base tree resolves to null rather than throwing', async () => {
+test('a dirty base tree still creates the worktree, carrying the uncommitted edit in rather than falling back unisolated', async () => {
   const cwd = await mkRepoCwd();
-  fs.writeFileSync(path.join(cwd, 'dirty.txt'), 'uncommitted\n', 'utf8');
+  fs.writeFileSync(path.join(cwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
 
   const result = await handler(null, { cwd, epicId: 'epic-mint-3' });
-  expect(result).toBeNull();
+  expect(result).not.toBeNull();
+  expect(fs.readFileSync(path.join(result.dir, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
+  expect(fs.readFileSync(path.join(cwd, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
 });
 
 test('SM_EPIC_WORKTREE_DISABLE=1 resolves to null rather than throwing', async () => {