claude-code-session-manager 0.75.3 → 0.76.0

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

@@ -6,15 +6,28 @@
  * 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,
+  probeSchedulerMcpLive,
+  clearLiveProbeCache,
+  PRD_WRITE_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 +45,81 @@ 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}` }],
         },
       ],
     },
   });
 
-  return { homeDir, cwd };
+  return { homeDir, cwd, scriptPath };
 }
 
-test('all four checks pass on a fully-configured project', async () => {
+test('all six 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(6);
   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',
   ]);
-});
+}, 15_000);
 
 test('scheduler-mcp: passes via project-scope .mcp.json even without user scope', async () => {
   const { homeDir, cwd } = await makeGreenFixtures();
@@ -80,47 +128,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 +201,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 +222,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 +235,150 @@ 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'] } },
+  });
+
+  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;
 
-test('missing cwd/.claude/settings.json entirely is treated as guard-absent, not a throw', async () => {
+  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');
 });

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

@@ -82,7 +82,7 @@ test('a non-git cwd resolves to null rather than throwing (Epic proceeds unisola
 
 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');
+  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();

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

@@ -168,8 +168,8 @@ test('[job] falls back with a reason for a non-git cwd', async () => {
   expect(result.reason).toMatch(/not a git repository/);
 });
 
-test('[job] falls back with a reason for a dirty base tree (never silently drops uncommitted human WIP)', async () => {
-  fs.writeFileSync(path.join(repoCwd, 'dirty.txt'), 'uncommitted\n', 'utf8');
+test('[job] falls back with a reason for a dirty base tree with a modified TRACKED file (never silently drops uncommitted human WIP)', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
   const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
   expect(result.ok).toBe(false);
   expect(result.reason).toMatch(/uncommitted changes/);
@@ -398,3 +398,15 @@ test('keyFromBranch strips the kind-specific prefix and returns null for a forei
 test('createWorktree throws on an unknown kind', async () => {
   await expect(gitWorktree.createWorktree({ kind: 'bogus', cwd: repoCwd, key: 'x' })).rejects.toThrow(/unknown kind/);
 });
+
+// ──────────────────────────────────────────── isBaseTreeClean (PRD 1064)
+
+test('isBaseTreeClean ignores untracked files — a single stray untracked file must not disable isolation', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'scratch_untracked.txt'), 'not tracked\n', 'utf8');
+  expect(await gitWorktree.isBaseTreeClean(repoCwd)).toBe(true);
+});
+
+test('isBaseTreeClean still reports dirty for a modified TRACKED file', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'modified tracked content\n', 'utf8');
+  expect(await gitWorktree.isBaseTreeClean(repoCwd)).toBe(false);
+});

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

@@ -0,0 +1,107 @@
+/**
+ * gitWorktreeSalvage.test.cjs — PRD 1071: a job worktree's uncommitted diff
+ * (tracked + untracked) is salvaged to a patch file before teardown, so a
+ * job killed before its finish-protocol commit doesn't lose its work when
+ * cleanupWorktree removes the checkout right after.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/gitWorktreeSalvage.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');
+const { execFileSync } = require('node:child_process');
+const gitWorktree = require('../gitWorktree.cjs');
+
+let tmpRoot;
+let repoCwd;
+// config.cjs's writeTextAtomic (used internally by salvageWorktreeDiff)
+// restricts writes to a fixed allowlist — real prod call sites write under
+// `~/.claude/session-manager/scheduled-plans/runs/...`, which is covered by
+// config.cjs's WRITE_PREFIXES. Mirror that here instead of writing under
+// os.tmpdir() (which validateWrite would reject) — same convention as
+// coldBootPromptSessionsWrite.test.cjs.
+let outDir;
+
+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);
+}
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-gitworktree-salvage-'));
+  repoCwd = path.join(tmpRoot, 'repo');
+  initRepo(repoCwd);
+  outDir = fs.mkdtempSync(path.join(os.homedir(), '.claude', 'sm-test-salvage-'));
+  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
+});
+
+afterEach(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+  fs.rmSync(outDir, { recursive: true, force: true });
+});
+
+test('dirty worktree (tracked edit + untracked file) produces a non-empty patch with the untracked file\'s contents', async () => {
+  const slug = 'salvage-dirty';
+  const created = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(created.ok).toBe(true);
+
+  fs.writeFileSync(path.join(created.dir, 'README.md'), 'hello\nedited\n', 'utf8');
+  fs.writeFileSync(path.join(created.dir, 'new-file.txt'), 'brand new untracked content\n', 'utf8');
+
+  const outFile = path.join(outDir, `${slug}.uncommitted.patch`);
+  const result = await gitWorktree.salvageWorktreeDiff({ cwd: created.dir, outFile });
+
+  expect(result.ok).toBe(true);
+  expect(result.bytes).toBeGreaterThan(0);
+  expect(fs.existsSync(outFile)).toBe(true);
+  const patch = fs.readFileSync(outFile, 'utf8');
+  expect(patch).toContain('new-file.txt');
+  expect(patch).toContain('brand new untracked content');
+  expect(patch).toContain('README.md');
+  expect(patch).toContain('edited');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: created.dir, branch: created.branch });
+});
+
+test('clean worktree produces no patch file (no 0-byte artifact)', async () => {
+  const slug = 'salvage-clean';
+  const created = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(created.ok).toBe(true);
+
+  const outFile = path.join(outDir, `${slug}.uncommitted.patch`);
+  const result = await gitWorktree.salvageWorktreeDiff({ cwd: created.dir, outFile });
+
+  expect(result.ok).toBe(false);
+  expect(fs.existsSync(outFile)).toBe(false);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: created.dir, branch: created.branch });
+});
+
+test('a git failure during salvage is swallowed (never throws) and cleanup still runs', async () => {
+  const notAGitRepo = path.join(tmpRoot, 'not-a-repo');
+  fs.mkdirSync(notAGitRepo, { recursive: true });
+  const outFile = path.join(outDir, 'salvage-failure.uncommitted.patch');
+
+  await expect(gitWorktree.salvageWorktreeDiff({ cwd: notAGitRepo, outFile })).resolves.toEqual({ ok: false });
+  expect(fs.existsSync(outFile)).toBe(false);
+
+  // Cleanup of an unrelated, never-created worktree is itself a no-op but
+  // must still resolve without throwing — mirrors the finally-block shape in
+  // scheduler.cjs where salvage failure must never block integration/cleanup.
+  await expect(
+    gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: path.join(tmpRoot, 'never-existed'), branch: 'sm-job/does-not-exist' }),
+  ).resolves.toBeUndefined();
+});

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

@@ -142,8 +142,8 @@ test('falls back with a reason for a non-git cwd', async () => {
   expect(result.reason).toMatch(/not a git repository/);
 });
 
-test('falls back with a reason for a dirty base tree (never silently drops uncommitted human WIP)', async () => {
-  fs.writeFileSync(path.join(repoCwd, 'dirty.txt'), 'uncommitted\n', 'utf8');
+test('falls back with a reason for a dirty base tree with a modified TRACKED file (never silently drops uncommitted human WIP)', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
   const result = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
   expect(result.ok).toBe(false);
   expect(result.reason).toMatch(/uncommitted changes/);