claude-code-session-manager 0.75.3 → 0.77.0

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

@@ -0,0 +1,40 @@
+/**
+ * fixChainDepth.test.cjs — unit tests for the pure fix-chain depth counter
+ * (PRD 1113). Run: timeout 120 npx vitest run src/main/lib/__tests__/fixChainDepth.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { fixChainDepthOf, baseSlugOf } = require('../fixChainDepth.cjs');
+
+test('fixChainDepthOf counts consecutive -fix- segments after the leading NN- prefix', () => {
+  const cases = [
+    // [slug, expected depth]
+    ['113-foo', 0],
+    ['113-fix-foo', 1],
+    ['113-fix-fix-foo', 2],
+    ['113-fix-fix-fix-foo', 3],
+    // false-positive bait: a later segment merely reading 'fix' does not
+    // extend the run once a non-'fix' segment has broken it.
+    ['113-fix-loop-extraction-and-round-trip', 1],
+    ['22-fix-loop-galaxy-round-trip', 1],
+    // false-positive bait: a segment that only contains 'fix' as a substring
+    // (not an exact 'fix' segment) is never counted at all.
+    ['113-prefix-foo', 0],
+    ['113-prefix-fix-foo', 0],
+    // no fix chain, multi-digit NN, single-segment slug.
+    ['1-widget', 0],
+  ];
+  for (const [slug, expected] of cases) {
+    expect(fixChainDepthOf(slug)).toBe(expected);
+  }
+});
+
+test('baseSlugOf strips the leading fix chain, keeping the NN prefix', () => {
+  expect(baseSlugOf('113-foo')).toBe('113-foo');
+  expect(baseSlugOf('113-fix-foo')).toBe('113-foo');
+  expect(baseSlugOf('113-fix-fix-foo')).toBe('113-foo');
+  expect(baseSlugOf('113-fix-fix-fix-foo')).toBe('113-foo');
+  expect(baseSlugOf('113-fix-loop-extraction-and-round-trip')).toBe('113-loop-extraction-and-round-trip');
+});

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

@@ -11,7 +11,7 @@
 
 'use strict';
 
-import { test, expect, beforeEach, afterEach } from 'vitest';
+import { test, expect, beforeEach, afterEach, vi } from 'vitest';
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -160,6 +160,90 @@ test('[job] merge-commit message text is byte-for-byte unchanged from the pre-ge
   await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
 });
 
+test('[job] integration is skipped (carried-wip-only) when the branch only commits the carried base WIP, and the base tree stays untouched', async () => {
+  const slug = 'test-slug-carried-wip-only';
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+  expect(worktree.carriedPaths).toEqual(['README.md']);
+
+  // The job commits exactly the carried content, doing no other work.
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'commit carried README'], worktree.dir);
+
+  const headBefore = git(['rev-parse', 'HEAD'], repoCwd).trim();
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug, carriedPaths: worktree.carriedPaths });
+  expect(outcome.ok).toBe(true);
+  expect(outcome.integrated).toBe(false);
+  expect(outcome.reason).toBe('carried-wip-only');
+
+  const headAfter = git(['rev-parse', 'HEAD'], repoCwd).trim();
+  expect(headAfter).toBe(headBefore);
+  // The base tree's own uncommitted README edit is untouched — never
+  // discarded, never re-applied.
+  expect(git(['status', '--porcelain'], repoCwd)).toContain('README.md');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
+});
+
+test('[job] a branch that commits carried paths ALONGSIDE its own work still attempts integration normally (no silent drop)', async () => {
+  const slug = 'test-slug-carried-plus-own-work';
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+  expect(worktree.carriedPaths).toEqual(['README.md']);
+
+  fs.writeFileSync(path.join(worktree.dir, 'new-file.txt'), 'job output\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit touching carried path + own work'], worktree.dir);
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug, carriedPaths: worktree.carriedPaths });
+  // The base tree still holds README.md dirty, so a real merge attempt here
+  // is expected to fail exactly like the existing worktreeIntegrationFailure
+  // path — branch preserved, not merged, not silently discarded.
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toBeTruthy();
+
+  const branches = git(['branch', '--list', worktree.branch], repoCwd);
+  expect(branches).toContain(worktree.branch.replace('sm-job/', ''));
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] a branch that ADDS its own edit on top of the carried content on the SAME path is never classified carried-wip-only (content-verify, not path-only)', async () => {
+  const slug = 'test-slug-carried-same-path-plus-edit';
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+  expect(worktree.carriedPaths).toEqual(['README.md']);
+
+  // The job's real work lands on the SAME path the base tree had WIP on —
+  // committing MORE than just the carried content. A path-only check would
+  // wrongly see "only README.md changed, and README.md was carried" and
+  // classify this as carried-wip-only, causing the caller to delete this
+  // branch (and the job's real commit with it) instead of attempting a
+  // normal merge.
+  fs.writeFileSync(path.join(worktree.dir, 'README.md'), 'uncommitted tracked edit\njob added this line\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job extends the carried README further'], worktree.dir);
+
+  const headBefore = git(['rev-parse', 'HEAD'], repoCwd).trim();
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug, carriedPaths: worktree.carriedPaths });
+  // The base tree still holds README.md dirty, so a real merge attempt here
+  // is expected to fail exactly like the existing worktreeIntegrationFailure
+  // path — branch preserved, not merged, not silently discarded.
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toBeTruthy();
+  expect(outcome.reason).not.toBe('carried-wip-only');
+
+  const headAfter = git(['rev-parse', 'HEAD'], repoCwd).trim();
+  expect(headAfter).toBe(headBefore);
+  const branches = git(['branch', '--list', worktree.branch], repoCwd);
+  expect(branches).toContain(worktree.branch.replace('sm-job/', ''));
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
 test('[job] falls back with a reason for a non-git cwd', async () => {
   const nonGitDir = path.join(tmpRoot, 'not-a-repo');
   fs.mkdirSync(nonGitDir, { recursive: true });
@@ -168,11 +252,47 @@ 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] a dirty tracked base file is carried into the worktree with identical content, and the base tree is never written to', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const statusBefore = git(['status', '--porcelain'], repoCwd);
+  const stashBefore = git(['stash', 'list'], repoCwd);
+
   const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
-  expect(result.ok).toBe(false);
-  expect(result.reason).toMatch(/uncommitted changes/);
+  expect(result.ok).toBe(true);
+  expect(result.carriedPaths).toEqual(['README.md']);
+  expect(fs.readFileSync(path.join(result.dir, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
+
+  const statusAfter = git(['status', '--porcelain'], repoCwd);
+  const stashAfter = git(['stash', 'list'], repoCwd);
+  expect(statusAfter).toBe(statusBefore);
+  expect(stashAfter).toBe(stashBefore);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
+});
+
+test('[job] an untracked-only dirty base file is NOT carried and stays on the existing clean-create path', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'scratch.txt'), 'stray scratch file\n', 'utf8');
+  const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
+  expect(result.ok).toBe(true);
+  expect(result.carriedPaths).toEqual([]);
+  expect(fs.existsSync(path.join(result.dir, 'scratch.txt'))).toBe(false);
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
+});
+
+test('[job] carry-over failure (git apply cannot apply) degrades cleanly: worktree torn down, ok:false, active count released', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
+  const spy = vi.spyOn(gitWorktree, 'captureAndCarryBaseDiff').mockResolvedValue({ ok: false, reason: 'simulated git apply failure' });
+  try {
+    const before = gitWorktree._getActiveWorktreeCountForTests('job');
+    const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
+    expect(result.ok).toBe(false);
+    expect(result.reason).toMatch(/carry-over of base WIP failed/);
+    expect(gitWorktree._getActiveWorktreeCountForTests('job')).toBe(before);
+    const list = git(['worktree', 'list', '--porcelain'], repoCwd);
+    expect(list).not.toContain('sm-job/x');
+  } finally {
+    spy.mockRestore();
+  }
 });
 
 test('[job] falls back once the concurrency cap is reached, and recovers after cleanup', async () => {
@@ -191,6 +311,46 @@ test('[job] falls back once the concurrency cap is reached, and recovers after c
   await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: third.dir, branch: third.branch });
 });
 
+test('[job] getMaxConcurrentWorktrees floors the job cap at the sessionSlots pool size (PRD 1112)', () => {
+  const originalSlots = process.env.SM_SESSION_SLOTS;
+  try {
+    process.env.SM_SESSION_SLOTS = '10';
+    expect(gitWorktree.getMaxConcurrentWorktrees('job')).toBe(10);
+
+    // The floor never drops BELOW the existing default (4) even when the
+    // slot pool is smaller — this cap only ever widens for isolation, never
+    // narrows it below what already shipped.
+    process.env.SM_SESSION_SLOTS = '3';
+    expect(gitWorktree.getMaxConcurrentWorktrees('job')).toBe(4);
+  } finally {
+    if (originalSlots === undefined) delete process.env.SM_SESSION_SLOTS;
+    else process.env.SM_SESSION_SLOTS = originalSlots;
+  }
+});
+
+test('[job] an explicit SM_JOB_WORKTREE_MAX wins verbatim over the sessionSlots floor', () => {
+  const originalSlots = process.env.SM_SESSION_SLOTS;
+  try {
+    process.env.SM_SESSION_SLOTS = '10';
+    process.env.SM_JOB_WORKTREE_MAX = '2';
+    expect(gitWorktree.getMaxConcurrentWorktrees('job')).toBe(2);
+  } finally {
+    if (originalSlots === undefined) delete process.env.SM_SESSION_SLOTS;
+    else process.env.SM_SESSION_SLOTS = originalSlots;
+  }
+});
+
+test('[epic] getMaxConcurrentWorktrees is unaffected by the sessionSlots pool size', () => {
+  const originalSlots = process.env.SM_SESSION_SLOTS;
+  try {
+    process.env.SM_SESSION_SLOTS = '10';
+    expect(gitWorktree.getMaxConcurrentWorktrees('epic')).toBe(50);
+  } finally {
+    if (originalSlots === undefined) delete process.env.SM_SESSION_SLOTS;
+    else process.env.SM_SESSION_SLOTS = originalSlots;
+  }
+});
+
 test('[job] SM_JOB_WORKTREE_DISABLE=1 restores in-place behaviour', async () => {
   process.env.SM_JOB_WORKTREE_DISABLE = '1';
   const result = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
@@ -398,3 +558,128 @@ 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);
+});
+
+// ──────────────────────────────────────────── orphaned on-disk checkouts (PRD 1108)
+
+test('[job] cleanupWorktree rmdirs the now-empty parent hash dir, but a sibling checkout in the same hash dir survives', async () => {
+  const first = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'sibling-a' });
+  const second = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'sibling-b' });
+  expect(first.ok).toBe(true);
+  expect(second.ok).toBe(true);
+  const hashDir = path.dirname(first.dir);
+  expect(path.dirname(second.dir)).toBe(hashDir);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: first.dir, branch: first.branch });
+  expect(fs.existsSync(first.dir)).toBe(false);
+  // The hash dir must survive — the sibling checkout still lives under it.
+  expect(fs.existsSync(hashDir)).toBe(true);
+  expect(fs.existsSync(second.dir)).toBe(true);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: second.dir, branch: second.branch });
+  expect(fs.existsSync(second.dir)).toBe(false);
+  // Now that the last sibling is gone, the empty hash dir is reclaimed too.
+  expect(fs.existsSync(hashDir)).toBe(false);
+});
+
+test('[job] reconcileWorktreesOnBoot reclaims an orphaned on-disk checkout for a project cwd it was never handed', async () => {
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'orphan-old' });
+  expect(worktree.ok).toBe(true);
+  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
+  // Simulate age: back-date the checkout dir's mtime well past the 1s
+  // threshold used below, without touching anything about its content.
+  const old = new Date(Date.now() - 60_000);
+  fs.utimesSync(worktree.dir, old, old);
+
+  // No cwd handed in at all — this is the "project no longer tracked" case
+  // the per-cwd loop can never reach on its own.
+  await gitWorktree.reconcileWorktreesOnBoot([], { kind: 'job', staleAgeMs: 1_000 });
+
+  expect(fs.existsSync(worktree.dir)).toBe(false);
+  // The hash dir it lived under is empty now and must be reclaimed too.
+  expect(fs.existsSync(path.dirname(worktree.dir))).toBe(false);
+  // The main tree's own worktree registration must not be left dangling.
+  const list = git(['worktree', 'list', '--porcelain'], repoCwd);
+  expect(list).not.toContain(worktree.dir);
+});
+
+test('[job] reconcileWorktreesOnBoot never reclaims a fresh, in-use checkout younger than the age threshold', async () => {
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'fresh-in-use' });
+  expect(worktree.ok).toBe(true);
+  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
+
+  await gitWorktree.reconcileWorktreesOnBoot([], { kind: 'job', staleAgeMs: 24 * 60 * 60 * 1000 });
+
+  expect(fs.existsSync(worktree.dir)).toBe(true);
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
+});
+
+test('[epic] the orphan sweep age threshold defaults much higher (7 days) than the job kind (24h)', () => {
+  expect(gitWorktree.getStaleSweepAgeMs('job')).toBe(24 * 60 * 60 * 1000);
+  expect(gitWorktree.getStaleSweepAgeMs('epic')).toBe(7 * 24 * 60 * 60 * 1000);
+});
+
+test('[epic] SM_EPIC_WORKTREE_STALE_MS overrides the epic orphan-sweep age threshold independently of the job env var', () => {
+  const original = process.env.SM_EPIC_WORKTREE_STALE_MS;
+  try {
+    process.env.SM_EPIC_WORKTREE_STALE_MS = '12345';
+    expect(gitWorktree.getStaleSweepAgeMs('epic')).toBe(12345);
+    expect(gitWorktree.getStaleSweepAgeMs('job')).toBe(24 * 60 * 60 * 1000);
+  } finally {
+    if (original === undefined) delete process.env.SM_EPIC_WORKTREE_STALE_MS;
+    else process.env.SM_EPIC_WORKTREE_STALE_MS = original;
+  }
+});
+
+test('[job] sweepStaleWorktreeCheckouts treats staleAgeMs: 0 as "reclaim immediately", not as "unset — use the default"', async () => {
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug: 'zero-age' });
+  expect(worktree.ok).toBe(true);
+  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
+
+  const result = await gitWorktree.sweepStaleWorktreeCheckouts('job', { staleAgeMs: 0 });
+
+  expect(result.checkoutsRemoved).toBe(1);
+  expect(fs.existsSync(worktree.dir)).toBe(false);
+});
+
+test('[job] sweepStaleWorktreeCheckouts never deletes anything outside its own kind root, even via a symlink shaped like a traversal', async () => {
+  const outsideDir = path.join(tmpRoot, 'outside-root');
+  fs.mkdirSync(outsideDir, { recursive: true });
+  const markerFile = path.join(outsideDir, 'do-not-delete.txt');
+  fs.writeFileSync(markerFile, 'still here\n', 'utf8');
+
+  const root = gitWorktree.worktreeRootFor('job');
+  const hashDir = path.join(root, 'traversal-hash-dir');
+  fs.mkdirSync(hashDir, { recursive: true });
+  const escapePath = path.join(hashDir, 'escape');
+  fs.symlinkSync(outsideDir, escapePath, 'dir');
+
+  const result = await gitWorktree.sweepStaleWorktreeCheckouts('job', { staleAgeMs: 0 });
+
+  expect(fs.existsSync(markerFile)).toBe(true);
+  expect(fs.existsSync(outsideDir)).toBe(true);
+  expect(result.checkoutsRemoved).toBe(0);
+
+  fs.rmSync(hashDir, { recursive: true, force: true });
+});
+
+test('[job] reconcileWorktreesOnBoot logs a one-shot report line with reclaimed counts', async () => {
+  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  try {
+    await gitWorktree.reconcileWorktreesOnBoot([repoCwd], { kind: 'job' });
+    expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/boot sweep \(kind:job\): reclaimed \d+ checkout\(s\), \d+ empty root dir\(s\)/));
+  } finally {
+    logSpy.mockRestore();
+  }
+});

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__/gitWorktreeSalvageDelta.test.cjs

@@ -0,0 +1,153 @@
+/**
+ * gitWorktreeSalvageDelta.test.cjs — PRD 1098: `salvageDirtyDelta` is the
+ * shared-tree counterpart to `salvageWorktreeDiff` (gitWorktreeSalvage.test.cjs)
+ * — it salvages an IN-PLACE job's uncommitted work without a throwaway
+ * worktree checkout to diff and discard, so it must be strictly DELTA-scoped
+ * (only the caller-supplied paths, never a whole-tree dump) and must never
+ * mutate the shared tree (no add/stash/reset/checkout/clean) the way
+ * `salvageWorktreeDiff`'s `git add -A --intent-to-add` deliberately can
+ * against a disposable checkout.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/gitWorktreeSalvageDelta.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;
+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');
+  fs.writeFileSync(path.join(dir, 'tracked-a.txt'), 'a\n', 'utf8');
+  fs.writeFileSync(path.join(dir, 'tracked-b.txt'), 'b\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-gitworktree-salvage-delta-'));
+  repoCwd = path.join(tmpRoot, 'repo');
+  initRepo(repoCwd);
+  outDir = fs.mkdtempSync(path.join(os.homedir(), '.claude', 'sm-test-salvage-delta-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+  fs.rmSync(outDir, { recursive: true, force: true });
+});
+
+test('salvages only the given delta paths (tracked edit + untracked new file), never a pre-existing dirty file outside the delta', async () => {
+  // Pre-existing WIP that must NEVER appear in the patch — the whole point
+  // of delta-scoping.
+  fs.writeFileSync(path.join(repoCwd, 'tracked-b.txt'), 'b\npre-existing human WIP\n', 'utf8');
+
+  // This job's own delta: an edit to tracked-a.txt and a new untracked file.
+  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\nedited by job\n', 'utf8');
+  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'brand new job output\n', 'utf8');
+
+  const outFile = path.join(outDir, 'delta.uncommitted.patch');
+  const result = await gitWorktree.salvageDirtyDelta({
+    cwd: repoCwd,
+    paths: ['tracked-a.txt', 'job-new-file.txt'],
+    outFile,
+  });
+
+  expect(result.ok).toBe(true);
+  expect(result.bytes).toBeGreaterThan(0);
+  const patch = fs.readFileSync(outFile, 'utf8');
+  expect(patch).toContain('tracked-a.txt');
+  expect(patch).toContain('edited by job');
+  expect(patch).toContain('job-new-file.txt');
+  expect(patch).toContain('brand new job output');
+  // The sibling/human's pre-existing dirty file is NOT in the delta list —
+  // it must never leak into this job's patch.
+  expect(patch).not.toContain('pre-existing human WIP');
+});
+
+test('applies cleanly with git apply --check against a fresh clone of the base tree', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\nedited\n', 'utf8');
+  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'new content\n', 'utf8');
+
+  const outFile = path.join(outDir, 'apply-check.uncommitted.patch');
+  const result = await gitWorktree.salvageDirtyDelta({
+    cwd: repoCwd,
+    paths: ['tracked-a.txt', 'job-new-file.txt'],
+    outFile,
+  });
+  expect(result.ok).toBe(true);
+
+  // Fresh clone of the same commit, clean, to prove the patch is
+  // self-sufficient and applies against the pristine base state.
+  const cleanCheckout = path.join(tmpRoot, 'clean-checkout');
+  git(['clone', '-q', repoCwd, cleanCheckout], tmpRoot);
+  expect(() => git(['apply', '--check', outFile], cleanCheckout)).not.toThrow();
+});
+
+test('never mutates the shared tree: git status and stash list are byte-identical before and after', async () => {
+  // A human's own pre-existing WIP, deliberately outside the delta.
+  fs.writeFileSync(path.join(repoCwd, 'tracked-b.txt'), 'b\nhuman wip\n', 'utf8');
+  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\njob edit\n', 'utf8');
+  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'job output\n', 'utf8');
+
+  const statusBefore = git(['status', '--porcelain'], repoCwd);
+  const stashBefore = git(['stash', 'list'], repoCwd);
+
+  const outFile = path.join(outDir, 'no-mutate.uncommitted.patch');
+  const result = await gitWorktree.salvageDirtyDelta({
+    cwd: repoCwd,
+    paths: ['tracked-a.txt', 'job-new-file.txt'],
+    outFile,
+  });
+  expect(result.ok).toBe(true);
+
+  const statusAfter = git(['status', '--porcelain'], repoCwd);
+  const stashAfter = git(['stash', 'list'], repoCwd);
+  expect(statusAfter).toBe(statusBefore);
+  expect(stashAfter).toBe(stashBefore);
+});
+
+test('no delta paths dirty at call time produces no patch file (no 0-byte artifact)', async () => {
+  const outFile = path.join(outDir, 'clean.uncommitted.patch');
+  const result = await gitWorktree.salvageDirtyDelta({
+    cwd: repoCwd,
+    paths: ['tracked-a.txt'],
+    outFile,
+  });
+  expect(result.ok).toBe(false);
+  expect(fs.existsSync(outFile)).toBe(false);
+});
+
+test('empty paths list is a no-op', async () => {
+  const outFile = path.join(outDir, 'empty.uncommitted.patch');
+  const result = await gitWorktree.salvageDirtyDelta({ cwd: repoCwd, paths: [], outFile });
+  expect(result.ok).toBe(false);
+  expect(fs.existsSync(outFile)).toBe(false);
+});
+
+test('a git failure (not a repo) is swallowed and never throws', async () => {
+  const notAGitRepo = path.join(tmpRoot, 'not-a-repo');
+  fs.mkdirSync(notAGitRepo, { recursive: true });
+  fs.writeFileSync(path.join(notAGitRepo, 'x.txt'), 'x\n', 'utf8');
+  const outFile = path.join(outDir, 'failure.uncommitted.patch');
+
+  await expect(
+    gitWorktree.salvageDirtyDelta({ cwd: notAGitRepo, paths: ['x.txt'], outFile }),
+  ).resolves.toEqual({ ok: false });
+  expect(fs.existsSync(outFile)).toBe(false);
+});

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

@@ -142,11 +142,13 @@ 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('a dirty tracked base file is carried into the worktree instead of disabling isolation (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/);
+  expect(result.ok).toBe(true);
+  expect(result.carriedPaths).toEqual(['README.md']);
+  expect(fs.readFileSync(path.join(result.dir, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
+  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
 });
 
 test('falls back once the concurrency cap is reached, and recovers after cleanup', async () => {