claude-code-session-manager 0.86.0 → 0.88.0

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

@@ -0,0 +1,63 @@
+/**
+ * dispatchLoop.test.cjs — interval clamping, no overlap, throw isolation, stop(), kill switch.
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/dispatchLoop.test.cjs
+ */
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+const { startDispatchLoop, resolveIntervalMs } = require('../dispatchLoop.cjs');
+
+beforeEach(() => { vi.useFakeTimers(); delete process.env.SM_DISPATCH_LOOP_DISABLE; delete process.env.SM_DISPATCH_LOOP_INTERVAL_MS; });
+afterEach(() => { vi.useRealTimers(); delete process.env.SM_DISPATCH_LOOP_DISABLE; delete process.env.SM_DISPATCH_LOOP_INTERVAL_MS; });
+
+test('interval defaults to 30s and clamps to [10s, 300s]', () => {
+  expect(resolveIntervalMs(undefined, {})).toBe(30_000);
+  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: '1' })).toBe(10_000);
+  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: '9999999' })).toBe(300_000);
+  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: 'abc' })).toBe(30_000);
+  expect(resolveIntervalMs(45_000, {})).toBe(45_000);
+});
+
+test('ticks on the interval and stop() clears the timer', async () => {
+  const tick = vi.fn(async () => {});
+  const h = startDispatchLoop({ tick });
+  await vi.advanceTimersByTimeAsync(90_000);
+  expect(tick).toHaveBeenCalledTimes(3);
+  h.stop();
+  expect(vi.getTimerCount()).toBe(0);
+  await vi.advanceTimersByTimeAsync(90_000);
+  expect(tick).toHaveBeenCalledTimes(3);
+});
+
+test('skips a pass while the previous one is still running', async () => {
+  let release;
+  const tick = vi.fn(() => new Promise((r) => { release = r; }));
+  const h = startDispatchLoop({ tick, intervalMs: 10_000 });
+  await vi.advanceTimersByTimeAsync(50_000);
+  expect(tick).toHaveBeenCalledTimes(1);
+  release();
+  await vi.advanceTimersByTimeAsync(10_000);
+  expect(tick).toHaveBeenCalledTimes(2);
+  h.stop();
+});
+
+test('a throwing/rejecting tick is isolated, reported, and the loop keeps running', async () => {
+  const onError = vi.fn();
+  let n = 0;
+  const tick = vi.fn(async () => { n++; if (n === 1) throw new Error('boom'); if (n === 2) throw new Error('boom2'); });
+  const h = startDispatchLoop({ tick, intervalMs: 10_000, onError });
+  await vi.advanceTimersByTimeAsync(40_000);
+  expect(tick).toHaveBeenCalledTimes(4);
+  expect(onError).toHaveBeenCalledTimes(2);
+  h.stop();
+});
+
+test('SM_DISPATCH_LOOP_DISABLE=1 never arms the loop', async () => {
+  process.env.SM_DISPATCH_LOOP_DISABLE = '1';
+  const tick = vi.fn();
+  const h = startDispatchLoop({ tick });
+  expect(vi.getTimerCount()).toBe(0);
+  await vi.advanceTimersByTimeAsync(600_000);
+  expect(tick).not.toHaveBeenCalled();
+  h.stop();
+});

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

@@ -0,0 +1,239 @@
+/**
+ * effectiveModelInfo.test.cjs — the main-process half of "what will this
+ * Epic actually run as": overlay-aware persona alias resolution plus
+ * evidence-based concrete model id (scheduler run log, then session
+ * transcript), never fabricated when there's no evidence.
+ *
+ * All fixtures live under a per-test mkdtemp'd $HOME (never the real
+ * ~/.claude) so persona lookup (which reads os.homedir()), scheduler run
+ * logs, and transcripts all resolve consistently.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/effectiveModelInfo.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { encodeCwd } = require('../encodeCwd.cjs');
+const { resolveEffectiveModelInfo, isConcreteModelId, computeEffortReachable } = require('../effectiveModelInfo.cjs');
+// config.cjs's `allowedRoots` is a module-level singleton seeded from
+// os.homedir() at FIRST require — since this test's HOME changes every test
+// (fresh mkdtemp), a persona lookup (getPersonaBody -> validatePath) would
+// only pass for whichever tmpHome happened to be active the first time
+// config.cjs got lazily required. addAllowedRoot mutates the live Set
+// instead, so every test's own tmpHome is explicitly admitted.
+const { addAllowedRoot } = require('../../config.cjs');
+
+let tmpHome;
+let originalHome;
+let cwd;
+
+beforeEach(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-effective-model-home-'));
+  process.env.HOME = tmpHome;
+  addAllowedRoot(tmpHome);
+  cwd = path.join(tmpHome, 'project');
+  fs.mkdirSync(cwd, { recursive: true });
+});
+
+afterEach(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+function writePersona(dir, name, frontmatterLines) {
+  fs.mkdirSync(dir, { recursive: true });
+  const lines = ['---', ...frontmatterLines, '---', 'Body text.'];
+  fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
+}
+
+function writeGlobalPersona(name, frontmatterLines) {
+  writePersona(path.join(tmpHome, '.claude', 'agents'), name, frontmatterLines);
+}
+
+function writeOverlayPersona(name, frontmatterLines) {
+  writePersona(path.join(cwd, '.claude', 'agents'), name, frontmatterLines);
+}
+
+function writeActiveIndex(sessions) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events: {} }, null, 2));
+}
+
+function writeQueueJobs(jobs) {
+  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
+}
+
+function writeHistoryEntries(entries) {
+  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'history.jsonl'), entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
+}
+
+function writeRunLog(runId, slug, text) {
+  const dir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${slug}.log`), text);
+}
+
+function writeTranscript(sessionId, lines) {
+  const dir = path.join(tmpHome, '.claude', 'projects', encodeCwd(cwd));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${sessionId}.jsonl`), lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+}
+
+// ---------- persona alias resolution ----------
+
+test('resolves a global persona alias with modelSource "persona" and no fabricated evidence', async () => {
+  writeGlobalPersona('writer', ['model: sonnet']);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'writer' });
+  expect(info.modelAlias).toBe('sonnet');
+  expect(info.modelSource).toBe('persona');
+  expect(info.resolvedModelId).toBeNull();
+  expect(info.resolvedFrom).toBeNull();
+});
+
+test('a persona model of "inherit" reports modelAlias null and modelSource "inherit"', async () => {
+  writeGlobalPersona('inheriting', ['model: inherit']);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'inheriting' });
+  expect(info.modelAlias).toBeNull();
+  expect(info.modelSource).toBe('inherit');
+});
+
+test('a persona with no model field at all is treated the same as inherit', async () => {
+  writeGlobalPersona('bare', []);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'bare' });
+  expect(info.modelAlias).toBeNull();
+  expect(info.modelSource).toBe('inherit');
+});
+
+test('a persona pinned to an already-concrete model id echoes it back with resolvedFrom null, ignoring conflicting evidence', async () => {
+  writeGlobalPersona('pinned', ['model: claude-opus-5-2027']);
+  // Conflicting scheduler evidence exists but must never override an
+  // already-concrete alias — no evidence lookup should even be attempted.
+  writeQueueJobs([{ slug: 'x', runId: 'r1', agentType: 'pinned', finishedAt: new Date().toISOString() }]);
+  writeRunLog('r1', 'x', '[scheduler] agentType=pinned persona=/whatever model=claude-sonnet-1\n');
+
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'pinned' });
+  expect(info.modelAlias).toBe('claude-opus-5-2027');
+  expect(info.modelSource).toBe('persona');
+  expect(info.resolvedModelId).toBe('claude-opus-5-2027');
+  expect(info.resolvedFrom).toBeNull();
+});
+
+test('a project-overlay persona wins over the global definition and reports modelSource "persona-overlay"', async () => {
+  writeGlobalPersona('shared-name', ['model: sonnet']);
+  writeOverlayPersona('shared-name', ['model: opus']);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'shared-name' });
+  expect(info.modelAlias).toBe('opus');
+  expect(info.modelSource).toBe('persona-overlay');
+});
+
+test('a dangling agentType (no persona file anywhere) resolves modelSource "fallback" without throwing', async () => {
+  await expect(resolveEffectiveModelInfo({ cwd, agentType: 'ghost-persona' })).resolves.toBeTruthy();
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'ghost-persona' });
+  expect(info.modelAlias).toBeNull();
+  expect(info.modelSource).toBe('fallback');
+  expect(info.resolvedModelId).toBeNull();
+});
+
+// ---------- concrete-model-id evidence ----------
+
+test('evidence hit via the scheduler run record: reads the model logged in the most recent matching job\'s run log', async () => {
+  writeGlobalPersona('runner', ['model: sonnet']);
+  writeQueueJobs([
+    { slug: 'older', runId: 'run-older', agentType: 'runner', finishedAt: '2026-01-01T00:00:00.000Z' },
+    { slug: 'newer', runId: 'run-newer', agentType: 'runner', finishedAt: '2026-02-01T00:00:00.000Z' },
+  ]);
+  writeRunLog('run-older', 'older', '[scheduler] agentType=runner persona=/p/runner.md model=claude-old-1\n');
+  writeRunLog('run-newer', 'newer', '[scheduler] agentType=runner persona=/p/runner.md model=claude-sonnet-5\n');
+
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'runner' });
+  expect(info.resolvedModelId).toBe('claude-sonnet-5');
+  expect(info.resolvedFrom).toBe('scheduler-run');
+});
+
+test('scheduler-run evidence also matches jobs already archived into history.jsonl', async () => {
+  writeGlobalPersona('archived-runner', ['model: opus']);
+  writeHistoryEntries([
+    { slug: 'old-hist', runId: 'run-hist', agentType: 'archived-runner', finishedAt: '2026-01-01T00:00:00.000Z' },
+  ]);
+  writeRunLog('run-hist', 'old-hist', '[scheduler] agentType=archived-runner persona=/p/x.md model=claude-opus-5\n');
+
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'archived-runner' });
+  expect(info.resolvedModelId).toBe('claude-opus-5');
+  expect(info.resolvedFrom).toBe('scheduler-run');
+});
+
+test('evidence hit via transcript when no scheduler run exists: takes the LAST "model" occurrence', async () => {
+  writeGlobalPersona('chatty', ['model: opus']);
+  writeActiveIndex({
+    'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', agentType: 'chatty', createdAt: '2026-03-01T00:00:00.000Z' },
+  });
+  writeTranscript('sess-1', [
+    { type: 'assistant', message: { model: 'claude-opus-4' } },
+    { type: 'assistant', message: { model: 'claude-opus-5' } },
+  ]);
+
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'chatty' });
+  expect(info.resolvedModelId).toBe('claude-opus-5');
+  expect(info.resolvedFrom).toBe('transcript');
+});
+
+test('transcript evidence prefers the most recently created matching Epic', async () => {
+  writeGlobalPersona('multi-epic', ['model: haiku']);
+  writeActiveIndex({
+    'epic-old': { id: 'epic-old', claudeSessionId: 'sess-old', agentType: 'multi-epic', createdAt: '2026-01-01T00:00:00.000Z' },
+    'epic-new': { id: 'epic-new', claudeSessionId: 'sess-new', agentType: 'multi-epic', createdAt: '2026-05-01T00:00:00.000Z' },
+  });
+  writeTranscript('sess-old', [{ model: 'claude-haiku-old' }]);
+  writeTranscript('sess-new', [{ model: 'claude-haiku-new' }]);
+
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'multi-epic' });
+  expect(info.resolvedModelId).toBe('claude-haiku-new');
+  expect(info.resolvedFrom).toBe('transcript');
+});
+
+test('evidence miss (no scheduler run, no transcript) reports resolvedModelId/resolvedFrom as null — never a guessed pricing-key fallback', async () => {
+  writeGlobalPersona('unseen', ['model: haiku']);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'unseen' });
+  expect(info.resolvedModelId).toBeNull();
+  expect(info.resolvedFrom).toBeNull();
+});
+
+// ---------- edge cases ----------
+
+test('never throws for a missing cwd/agentType', async () => {
+  await expect(resolveEffectiveModelInfo({})).resolves.toMatchObject({
+    modelAlias: null,
+    modelSource: 'fallback',
+    resolvedModelId: null,
+    resolvedFrom: null,
+  });
+});
+
+test('isConcreteModelId treats known CLI aliases as non-concrete and everything else as concrete', () => {
+  expect(isConcreteModelId('opus')).toBe(false);
+  expect(isConcreteModelId('sonnet')).toBe(false);
+  expect(isConcreteModelId('haiku')).toBe(false);
+  expect(isConcreteModelId('fable')).toBe(false);
+  expect(isConcreteModelId(null)).toBe(false);
+  expect(isConcreteModelId('claude-opus-5')).toBe(true);
+});
+
+test('effortReachable is always false for an app-launched session — cleanChildEnv strips CLAUDE_EFFORT and CLAUDE_CODE_* before a child ever sees them', () => {
+  expect(computeEffortReachable({})).toBe(false);
+});
+
+test('resolveEffectiveModelInfo surfaces effortReachable alongside the model fields', async () => {
+  writeGlobalPersona('any', ['model: sonnet']);
+  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'any' });
+  expect(info.effortReachable).toBe(false);
+});

package/src/main/lib/__tests__/gateFixtures.json

@@ -0,0 +1,20 @@
+[
+  "- [ ] Gate (last thing the run does, must be green): `timeout 300 npm run typecheck && timeout 300 npm run lint && timeout 600 npm run test:unit`.",
+  "- [ ] Gate (last thing the run does, must be green): `timeout 300 npm run typecheck && timeout 300 npm run lint && TMPDIR=$(mktemp -d) timeout 900 npm run test:unit`.",
+  "- [ ] Gate (last thing the run does, must be green): `timeout 300 npm run typecheck && timeout 300 npm run lint && TMPDIR=$(mktemp -d) timeout 900 npm run test:unit` — run the unit suite with a scratch TMPDIR so gitWorktree.test.cjs sweeps a throwaway root, never the live job-worktree root.",
+  "- [ ] Gate (last thing the run does, must be green): `timeout 300 npm run typecheck && timeout 300 npm run lint && TMPDIR=$(mktemp -d) timeout 900 npm run test:unit` — scratch TMPDIR so gitWorktree.test.cjs sweeps a throwaway root, never the live job-worktree root.",
+  "- [ ] No zustand selector returns a freshly-built value; `timeout 300 npm run lint:selectors` passes.",
+  "- [ ] No hook is declared below a top-level early return — `timeout 300 npm run lint:hooks` exits 0.",
+  "- [ ] Tests: `timeout 300 npm run typecheck` and `timeout 300 npm run lint` pass.",
+  "- [ ] Tests: `TMPDIR=$(mktemp -d) timeout 300 npx vitest run src/main/__tests__/activeIndexMerge.test.cjs` passes.",
+  "- [ ] Both tests pass: `timeout 900 npm run test:unit` and `TMPDIR=$(mktemp -d) timeout 900 npm run test:unit`.",
+  "- [ ] All 16 tests in `timeout 120 npx vitest run tests/unit/chatRunner.spec.ts` pass.",
+  "- [ ] `SM_CHAT_CONCURRENCY=3 timeout 120 npx vitest run tests/unit/chatRunner.spec.ts` passes",
+  "- [ ] Each handled basename is removed from the ALLOWLIST map; `timeout 120 node scripts/check-unregistered-tests.cjs` exits 0.",
+  "- [ ] `timeout 120 npm run lint:docs` exits 0 on the current tree.",
+  "- [ ] Locally, the same sequence passes: `timeout 300 npm run typecheck && timeout 300 npm run lint && timeout 600 npm run build:project-pages`.",
+  "- [ ] After the commit lands, `timeout 60 gh run list --branch main --limit 1` prints the newest run without error.",
+  "- [ ] `for i in 1 2 3; do TMPDIR=$(mktemp -d) timeout 180 npx vitest run src/main/__tests__/scheduler-tick-wedge.test.cjs; done` is green 3/3 (shell loop — not a no-shell gate).",
+  "- [ ] The gate is `timeout 300 npm run typecheck | tail -5` (pipe — needs a shell).",
+  "- [ ] Prose only, no command at all."
+]

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

@@ -24,6 +24,7 @@ let originalJobDisable;
 let originalJobMax;
 let originalEpicDisable;
 let originalEpicMax;
+let originalWorktreeRoot;
 
 function git(args, cwd) {
   return execFileSync('git', args, { cwd, encoding: 'utf8' });
@@ -43,6 +44,9 @@ beforeEach(() => {
   tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-gitworktree-'));
   repoCwd = path.join(tmpRoot, 'repo');
   initRepo(repoCwd);
+  // Every sweep below runs against THIS throwaway root, never the live job-worktree root.
+  originalWorktreeRoot = process.env.SM_WORKTREE_ROOT;
+  process.env.SM_WORKTREE_ROOT = path.join(tmpRoot, 'worktrees');
   originalJobDisable = process.env.SM_JOB_WORKTREE_DISABLE;
   originalJobMax = process.env.SM_JOB_WORKTREE_MAX;
   originalEpicDisable = process.env.SM_EPIC_WORKTREE_DISABLE;
@@ -65,6 +69,7 @@ afterEach(async () => {
   // Best-effort: prune any worktree either kind's tests created before removing the repo.
   try { await gitWorktree.reconcileWorktreesOnBoot([repoCwd], { kind: 'job' }); } catch { /* ignore */ }
   try { await gitWorktree.reconcileWorktreesOnBoot([repoCwd], { kind: 'epic' }); } catch { /* ignore */ }
+  restore('SM_WORKTREE_ROOT', originalWorktreeRoot);
   fs.rmSync(tmpRoot, { recursive: true, force: true });
 });
 
@@ -300,6 +305,95 @@ test('[job] carry-over failure (git apply cannot apply) degrades cleanly: worktr
   }
 });
 
+// ──────────────────────────────────────────── PRD: stream the base-WIP diff capture (job 1192)
+
+test('[job] a wide dirty tree (300+ changed paths incl. a multi-MB file) captures and carries over without a maxBuffer overflow', async () => {
+  const files = [];
+  for (let i = 0; i < 300; i++) {
+    const rel = `wide-${i}.txt`;
+    fs.writeFileSync(path.join(repoCwd, rel), `initial ${i}\n`, 'utf8');
+    files.push(rel);
+  }
+  const bigRel = 'big-file.bin';
+  fs.writeFileSync(path.join(repoCwd, bigRel), Buffer.alloc(1024, 1));
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'wide baseline'], repoCwd);
+
+  // Dirty every tracked file (uncommitted tracked edits) and grow the binary
+  // file well past Node's execFile default maxBuffer (1MB) — the exact shape
+  // that overflowed the old buffered capture (job 1192: ~240 dirty paths).
+  for (const rel of files) fs.appendFileSync(path.join(repoCwd, rel), 'dirtied\n', 'utf8');
+  const bigBuf = Buffer.alloc(3 * 1024 * 1024); // 3MB of NUL bytes — git detects this as binary
+  fs.writeFileSync(path.join(repoCwd, bigRel), bigBuf);
+
+  const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'wide-tree' });
+  expect(result.ok).toBe(true);
+  expect(result.carriedPaths.length).toBe(files.length + 1);
+  expect(fs.readFileSync(path.join(result.dir, files[0]), 'utf8')).toContain('dirtied');
+  expect(Buffer.compare(fs.readFileSync(path.join(result.dir, bigRel)), bigBuf)).toBe(0);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
+}, 30_000);
+
+test('[job] a renamed file and a mutated binary file survive the capture/apply round trip using the same flags as production', async () => {
+  const binRel = 'asset.bin';
+  const binInitial = Buffer.from([0, 1, 2, 3, 4, 0, 255, 254]);
+  fs.writeFileSync(path.join(repoCwd, binRel), binInitial);
+  fs.writeFileSync(path.join(repoCwd, 'to-rename.txt'), 'original name content\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'binary + rename baseline'], repoCwd);
+
+  // Dirty tree: a tracked rename plus a mutated binary file, both uncommitted.
+  git(['mv', 'to-rename.txt', 'renamed.txt'], repoCwd);
+  const binChanged = Buffer.from([9, 8, 7, 0, 6, 5, 0, 4]);
+  fs.writeFileSync(path.join(repoCwd, binRel), binChanged);
+
+  const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'rename-binary' });
+  expect(result.ok).toBe(true);
+  expect(fs.existsSync(path.join(result.dir, 'to-rename.txt'))).toBe(false);
+  expect(fs.readFileSync(path.join(result.dir, 'renamed.txt'), 'utf8')).toBe('original name content\n');
+  expect(Buffer.compare(fs.readFileSync(path.join(result.dir, binRel)), binChanged)).toBe(0);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
+});
+
+test('[job] a capture that cannot write its diff file (target dir missing) falls back with a specific reason, never the old generic maxBuffer message', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const bogusDir = path.join(tmpRoot, 'does-not-exist');
+  const result = await gitWorktree.captureAndCarryBaseDiff({ cwd: repoCwd, dir: bogusDir });
+  expect(result.ok).toBe(false);
+  expect(result.reason).toMatch(/capturing base diff failed/);
+  expect(result.reason).not.toMatch(/maxBuffer/i);
+  expect(fs.existsSync(bogusDir)).toBe(false); // nothing leaked into a directory that never existed
+});
+
+test('[job] the temp diff file is removed after carry-over on both the success and the git-apply-failure paths', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const success = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cleanup-ok' });
+  expect(success.ok).toBe(true);
+  expect(fs.readdirSync(success.dir).filter((f) => f.startsWith('.sm-worktree-carry-'))).toEqual([]);
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: success.dir, branch: success.branch });
+
+  // Force a git-apply failure on a genuine clean-base worktree by making the
+  // target file read-only before the capture/apply call, so the patch writes
+  // fine but applying it fails — the finally block must still remove the temp
+  // patch file even though apply itself errored.
+  const clean = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cleanup-fail' });
+  expect(clean.ok).toBe(true);
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'another uncommitted tracked edit\n', 'utf8');
+  const targetFile = path.join(clean.dir, 'README.md');
+  fs.chmodSync(targetFile, 0o444);
+  try {
+    const fail = await gitWorktree.captureAndCarryBaseDiff({ cwd: repoCwd, dir: clean.dir });
+    expect(fail.ok).toBe(false);
+    expect(fail.reason).toMatch(/git apply failed/);
+  } finally {
+    fs.chmodSync(targetFile, 0o644);
+  }
+  expect(fs.readdirSync(clean.dir).filter((f) => f.startsWith('.sm-worktree-carry-'))).toEqual([]);
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: clean.dir, branch: clean.branch });
+}, 30_000);
+
 test('[job] falls back once the concurrency cap is reached, and recovers after cleanup', async () => {
   process.env.SM_JOB_WORKTREE_MAX = '1';
   const first = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cap-1' });
@@ -954,7 +1048,9 @@ test('[job] sweepStaleWorktreeCheckouts does NOT remove an old-mtime checkout wi
 test('[job] sweepStaleWorktreeCheckouts removes an old-mtime checkout when there is no live holder', async () => {
   const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'stale-and-dead' });
   expect(worktree.ok).toBe(true);
-  const holders = new Set(); // nothing holds it
+  // A populated holders set (some unrelated live cwd) that does not cover this checkout —
+  // exercises the liveness gate for real instead of defeating it with an empty set.
+  const holders = new Set([path.resolve(tmpRoot, 'unrelated-live-holder')]);
 
   const result = await gitWorktree.sweepStaleWorktreeCheckouts('job', { staleAgeMs: 0, holders });
 

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

@@ -0,0 +1,151 @@
+/**
+ * guardShims.test.cjs — unit tests for the stable, app-upgrade-proof guard
+ * hook indirection (guardShims.cjs). Uses a temp "home" dir per test so the
+ * real ~/.claude is never touched.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/guardShims.test.cjs
+ */
+
+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 {
+  APP_ROOT,
+  GUARD_NAMES,
+  hooksDir,
+  pointerPath,
+  shimPath,
+  writeGuardShims,
+  guardShimsExist,
+} = require('../guardShims.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkTmp(prefix) {
+  const d = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(d);
+  return d;
+}
+
+/** Run a guard (by absolute path, e.g. a shim) as a child process, same
+ *  pattern delegationReadiness.test.cjs uses to exercise the real guards —
+ *  NEVER require() a guard/shim in-process, since its main() calls
+ *  process.exit(0) as a require-time side effect. */
+function runGuard(scriptPath, { toolName = 'Write', toolInput, cwd }) {
+  return JSON.parse(execFileSync('node', [scriptPath], {
+    input: JSON.stringify({ tool_name: toolName, tool_input: toolInput, cwd }),
+    encoding: 'utf8',
+  }));
+}
+
+test('writeGuardShims: writes the pointer file and all three shims under homeDir', async () => {
+  const homeDir = await mkTmp('sm-guard-shims-home-');
+  const r = await writeGuardShims({ homeDir });
+  expect(r.ok).toBe(true);
+
+  expect(fs.existsSync(pointerPath(homeDir))).toBe(true);
+  expect(JSON.parse(fs.readFileSync(pointerPath(homeDir), 'utf8'))).toEqual({ appRoot: APP_ROOT });
+  for (const name of GUARD_NAMES) {
+    expect(fs.existsSync(shimPath(name, homeDir))).toBe(true);
+  }
+  expect(guardShimsExist(homeDir)).toBe(true);
+});
+
+test('writeGuardShims: does NOT vendor guard logic — the shim body only references the guard by name, never copies its source', async () => {
+  const homeDir = await mkTmp('sm-guard-shims-home-');
+  await writeGuardShims({ homeDir });
+
+  const realSource = fs.readFileSync(path.join(APP_ROOT, 'scripts', 'hooks', 'guard-prd-writes.cjs'), 'utf8');
+  const shimSource = fs.readFileSync(shimPath('guard-prd-writes.cjs', homeDir), 'utf8');
+  expect(shimSource).not.toContain('SCHEDULER_SEGMENT'); // a guard-prd-writes-specific symbol
+  expect(shimSource.length).toBeLessThan(realSource.length / 2);
+  expect(shimSource).toContain("require(path.join(ptr.appRoot, 'scripts', 'hooks', 'guard-prd-writes.cjs'))");
+});
+
+test('writeGuardShims: idempotent — re-running with the same appRoot produces byte-identical files', async () => {
+  const homeDir = await mkTmp('sm-guard-shims-home-');
+  const r1 = await writeGuardShims({ homeDir });
+  expect(r1.ok).toBe(true);
+  const pointerBefore = fs.readFileSync(pointerPath(homeDir), 'utf8');
+  const shimsBefore = GUARD_NAMES.map((n) => fs.readFileSync(shimPath(n, homeDir), 'utf8'));
+
+  const r2 = await writeGuardShims({ homeDir });
+  expect(r2.ok).toBe(true);
+  expect(fs.readFileSync(pointerPath(homeDir), 'utf8')).toBe(pointerBefore);
+  GUARD_NAMES.forEach((n, i) => {
+    expect(fs.readFileSync(shimPath(n, homeDir), 'utf8')).toBe(shimsBefore[i]);
+  });
+});
+
+test('writeGuardShims: the installed shim actually resolves through the pointer and runs the real guard logic', async () => {
+  const homeDir = await mkTmp('sm-guard-shims-home-');
+  const cwd = await mkTmp('sm-guard-shims-cwd-');
+  await writeGuardShims({ homeDir });
+
+  const denied = runGuard(shimPath('guard-prd-writes.cjs', homeDir), {
+    toolInput: { file_path: path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', '1234-x.md'), content: '# x' },
+    cwd,
+  });
+  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
+
+  const allowed = runGuard(shimPath('guard-prd-writes.cjs', homeDir), {
+    toolInput: { file_path: path.join(cwd, 'src', 'x.ts'), content: 'x' },
+    cwd,
+  });
+  expect(allowed.hookSpecificOutput?.permissionDecision).not.toBe('deny');
+});
+
+test('writeGuardShims: rewriting the pointer to a DIFFERENT app root lets an already-installed shim follow an app upgrade with no re-install', async () => {
+  const homeDir = await mkTmp('sm-guard-shims-home-');
+  const cwd = await mkTmp('sm-guard-shims-cwd-');
+  await writeGuardShims({ homeDir }); // "first install", points at the real APP_ROOT
+  const shimFile = shimPath('guard-prd-writes.cjs', homeDir);
+  const shimBytesBefore = fs.readFileSync(shimFile, 'utf8');
+
+  // Simulate an app upgrade: a second "app root" at a brand-new path, with
+  // its own copy of scripts/hooks/guard-prd-writes.cjs (this is the ONLY file
+  // guardShims ever reads through the pointer at invocation time).
+  const secondAppRoot = await mkTmp('sm-guard-shims-upgraded-app-');
+  await fsp.mkdir(path.join(secondAppRoot, 'scripts', 'hooks'), { recursive: true });
+  await fsp.copyFile(
+    path.join(APP_ROOT, 'scripts', 'hooks', 'guard-prd-writes.cjs'),
+    path.join(secondAppRoot, 'scripts', 'hooks', 'guard-prd-writes.cjs'),
+  );
+
+  const r = await writeGuardShims({ homeDir, appRoot: secondAppRoot });
+  expect(r.ok).toBe(true);
+  expect(JSON.parse(fs.readFileSync(pointerPath(homeDir), 'utf8')).appRoot).toBe(secondAppRoot);
+  // The shim FILE at the already-installed path never changed.
+  expect(fs.readFileSync(shimFile, 'utf8')).toBe(shimBytesBefore);
+
+  // A project hook that already references this exact shim path keeps working.
+  const denied = runGuard(shimFile, {
+    toolInput: { file_path: path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', '1234-x.md'), content: '# x' },
+    cwd,
+  });
+  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
+});
+
+test('writeGuardShims: returns { ok:false, error } without throwing when homeDir cannot be written to', async () => {
+  const base = await mkTmp('sm-guard-shims-unwritable-');
+  const blocker = path.join(base, 'blocker-file');
+  await fsp.writeFile(blocker, 'x', 'utf8');
+  // A homeDir whose parent path segment is a plain FILE can never be mkdir'd
+  // into (ENOTDIR) — reproduces "unwritable ~/.claude" without relying on
+  // permission bits, which root would bypass.
+  const homeDir = path.join(blocker, 'home');
+
+  const r = await writeGuardShims({ homeDir });
+  expect(r.ok).toBe(false);
+  expect(r.error).toBeTruthy();
+  expect(guardShimsExist(homeDir)).toBe(false);
+});