claude-code-session-manager 0.76.0 → 0.78.0

package/src/main/__tests__/runVerify.test.cjs

@@ -1197,6 +1197,100 @@ test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS senti
   }
 });
 
+// ─── abandoned_background_task: auto-backgrounded Bash + no sentinel/commit ─
+
+/** A run whose Bash command hit the harness's 120s foreground timeout and was
+ *  auto-backgrounded, then the run ended without ever coming back to commit
+ *  or emit the finish-protocol sentinel. */
+function abandonedBackgroundTaskRunEvents(resultText) {
+  return [
+    {
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        content: [{
+          type: 'tool_use',
+          id: 'toolu_bg_001',
+          name: 'Bash',
+          input: { command: 'npm run test:unit', description: 'Run full unit suite' },
+        }],
+      },
+    },
+    {
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: 'toolu_bg_001',
+          content: 'Command did not complete within its 120s timeout and was moved to the background (ID: bcn1lpvpd). Output is being written to: /tmp/claude-1000/tasks/bcn1lpvpd.output. You will be notified when it completes. To check interim output, use Read on that file path.',
+          is_error: false,
+        }],
+      },
+    },
+    { type: 'result', subtype: 'success', result: resultText },
+  ];
+}
+
+test('abandoned_background_task: background marker + no sentinel + no commit → abandoned_background_task', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-encyclopedia-animations-section';
+    writeLog(tmp, slug, abandonedBackgroundTaskRunEvents('Waiting for the backgrounded test run to finish.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'abandoned_background_task', `expected abandoned_background_task, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('abandoned_background_task guard: no background marker, no sentinel, no commit → stays plain no_verdict_sentinel', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-no-background-marker';
+    writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'no_verdict_sentinel', `expected plain no_verdict_sentinel, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('abandoned_background_task guard: background marker present but run DID commit → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-background-marker-but-committed';
+    writeLog(tmp, slug, abandonedBackgroundTaskRunEvents('Backgrounded test run finished green; work committed.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: true,
+    });
+    assert.equal(verdict.verdict, 'clean', `background marker with a landed commit should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // ─── pass_no_commit: PASS sentinel with no commit is not "clean" ───────────
 
 test('pass_no_commit: SCHEDULER_VERDICT: PASS but no commit landed → needs_review', async () => {

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -12,6 +12,7 @@ const {
   selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate,
   healTargetForFix, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH,
   isEligibleForImmediateAutoFix, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor,
+  applyRcaClassification,
 } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
@@ -211,6 +212,12 @@ test('invariant: plan outcome WITH a queue row → not a target and NOT annotate
   assert.strictEqual(isAnnotatable, false);
 });
 
+test('excludes a job whose rcaRecoveryAction is archive (already-shipped stale re-run must never buy a fix-plan)', () => {
+  const jobs = [makeJob({ rcaRecoveryAction: 'archive', rcaFailureClass: 'already-shipped' })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
 test('excludes when fix sibling exists on disk', () => {
   const jobs = [makeJob()];
   // fixSlug = '05-fix-my-feature'
@@ -376,4 +383,40 @@ test('isEligibleForImmediateAutoFix: a job whose status is not needs_review (e.g
   assert.strictEqual(result, false);
 });
 
+// ---- applyRcaClassification (persists writeRcaReport's verdict onto the job row) ----
+
+test('applyRcaClassification: persists failureClass + recoveryAction onto a needs_review job', () => {
+  const job = makeJob({ status: 'needs_review' });
+  const applied = applyRcaClassification(job, { filed: true, failureClass: 'already-shipped', recoveryAction: 'archive' });
+  assert.strictEqual(applied, true);
+  assert.strictEqual(job.rcaFailureClass, 'already-shipped');
+  assert.strictEqual(job.rcaRecoveryAction, 'archive');
+});
+
+test('applyRcaClassification: no-op when the report was never filed', () => {
+  const job = makeJob({ status: 'needs_review' });
+  const applied = applyRcaClassification(job, { filed: false, reason: 'disabled' });
+  assert.strictEqual(applied, false);
+  assert.strictEqual(job.rcaFailureClass, undefined);
+});
+
+test('applyRcaClassification: no-op when the job has moved off needs_review', () => {
+  const job = makeJob({ status: 'completed' });
+  const applied = applyRcaClassification(job, { filed: true, failureClass: 'unknown', recoveryAction: 'investigate' });
+  assert.strictEqual(applied, false);
+  assert.strictEqual(job.rcaFailureClass, undefined);
+});
+
+test('applyRcaClassification: no-op when the job is missing (e.g. slug lookup miss)', () => {
+  const applied = applyRcaClassification(undefined, { filed: true, failureClass: 'unknown', recoveryAction: 'investigate' });
+  assert.strictEqual(applied, false);
+});
+
+test('applyRcaClassification result feeds selectAutoFixTargets: an archive-classified job is excluded', () => {
+  const job = makeJob({ status: 'needs_review' });
+  applyRcaClassification(job, { filed: true, failureClass: 'already-shipped', recoveryAction: 'archive' });
+  const result = selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
 console.log('scheduler-autofix-select tests: PASS');

package/src/main/__tests__/scheduler-bash-timeout-env.test.cjs

@@ -0,0 +1,103 @@
+/**
+ * scheduler-bash-timeout-env.test.cjs — PRD 1097.
+ *
+ * A headless `claude -p` job inherits the harness's 120s default foreground
+ * Bash timeout. Any legit gate command (a test suite, a build) that runs
+ * long gets auto-backgrounded, and the tool result promises a notification
+ * that a single-shot headless run can never receive — the run dead-ends
+ * with no commit and no verdict. The fix is to raise
+ * BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS on the spawned child's env.
+ *
+ * This proves:
+ *   1. executeJob's real spawned child actually receives both env vars, with
+ *      the exported constant values (not just that the constants exist).
+ *   2. BASH_MAX_TIMEOUT_MS stays strictly below IDLE_OUTPUT_KILL_MS — the
+ *      coupling that makes this more than a one-liner: a long foreground
+ *      Bash emits no stream-json events, so the log mtime stalls and the
+ *      idle-tail watchdog would SIGTERM the job mid-gate if the two ever
+ *      crossed.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-bash-timeout-env.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let executeJob;
+let BASH_DEFAULT_TIMEOUT_MS;
+let BASH_MAX_TIMEOUT_MS;
+let IDLE_OUTPUT_KILL_MS;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-bash-timeout-env-'));
+  process.env.HOME = tmpHome;
+  ({ executeJob, BASH_DEFAULT_TIMEOUT_MS, BASH_MAX_TIMEOUT_MS, IDLE_OUTPUT_KILL_MS } = require('../scheduler.cjs'));
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+});
+
+// Stub `claude` binary: dumps the two env vars it received into a marker
+// file, then emits a stream-json success result and exits 0.
+function writeClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-env-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const path = require('path');
+    fs.writeFileSync(path.join(process.cwd(), 'env.marker'), JSON.stringify({
+      BASH_DEFAULT_TIMEOUT_MS: process.env.BASH_DEFAULT_TIMEOUT_MS,
+      BASH_MAX_TIMEOUT_MS: process.env.BASH_MAX_TIMEOUT_MS,
+    }), 'utf8');
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
+    process.exit(0);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+test('BASH_MAX_TIMEOUT_MS stays strictly below IDLE_OUTPUT_KILL_MS with real margin', () => {
+  expect(typeof BASH_DEFAULT_TIMEOUT_MS).toBe('number');
+  expect(typeof BASH_MAX_TIMEOUT_MS).toBe('number');
+  expect(typeof IDLE_OUTPUT_KILL_MS).toBe('number');
+  expect(BASH_DEFAULT_TIMEOUT_MS).toBeLessThanOrEqual(BASH_MAX_TIMEOUT_MS);
+  expect(BASH_MAX_TIMEOUT_MS).toBeLessThan(IDLE_OUTPUT_KILL_MS);
+  // Real margin, not a razor's edge.
+  expect(IDLE_OUTPUT_KILL_MS - BASH_MAX_TIMEOUT_MS).toBeGreaterThanOrEqual(60_000);
+});
+
+test('executeJob spawns the executor child with BASH_DEFAULT_TIMEOUT_MS and BASH_MAX_TIMEOUT_MS set', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-bash-timeout-main-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-bash-timeout-run-'));
+  try {
+    const slug = `1097-test-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
+    fs.mkdirSync(prdsDir, { recursive: true });
+    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Verify the env vars are set.', 'utf8');
+    process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+    const job = { slug, cwd: mainCwd };
+    const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
+
+    expect(result.exitCode).toBe(0);
+    const marker = JSON.parse(fs.readFileSync(path.join(mainCwd, 'env.marker'), 'utf8'));
+    expect(marker.BASH_DEFAULT_TIMEOUT_MS).toBe(String(BASH_DEFAULT_TIMEOUT_MS));
+    expect(marker.BASH_MAX_TIMEOUT_MS).toBe(String(BASH_MAX_TIMEOUT_MS));
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/scheduler-effective-concurrency.test.cjs

@@ -69,3 +69,13 @@ test('free is net of held slots — a chat run shrinks it without changing cap',
   expect(payload.effectiveConcurrency).toEqual({ cap: 5, free: 4, source: 'env' });
   sessionSlots.release(token);
 });
+
+test('a row-level gateOutcome field survives the payload build unchanged (pass-through only, PRD 1109)', () => {
+  const state = fakeState();
+  state.jobs = [
+    { slug: 'a', status: 'failed', gateOutcome: 'never_ran' },
+    { slug: 'b', status: 'completed', gateOutcome: 'passed' },
+  ];
+  const payload = buildScheduleStatePayload(state);
+  expect(payload.jobs.map((j) => j.gateOutcome)).toEqual(['never_ran', 'passed']);
+});

package/src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs

@@ -0,0 +1,78 @@
+/**
+ * scheduler-foreign-wip-manifest.test.cjs — capDirtyPaths/buildForeignWipSection,
+ * the pure helpers behind the pre-run foreign-WIP manifest injected into the
+ * executor prompt (see the "starry-night-ships PRD 148" postmortem: a job
+ * running in a shared or WIP-carrying tree must be told explicitly which
+ * paths it does not own, rather than having to bisect by content).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const {
+  capDirtyPaths,
+  buildForeignWipSection,
+  PRE_RUN_DIRTY_PATHS_CAP,
+  FOREIGN_WIP_DELIMITER,
+  FOREIGN_WIP_END_DELIMITER,
+} = require('../scheduler.cjs');
+
+test('capDirtyPaths: [] for null/undefined/empty input', () => {
+  expect(capDirtyPaths(null)).toEqual([]);
+  expect(capDirtyPaths(undefined)).toEqual([]);
+  expect(capDirtyPaths([])).toEqual([]);
+});
+
+test('capDirtyPaths: returns the list unchanged when under the cap', () => {
+  expect(capDirtyPaths(['a.js', 'b.js'])).toEqual(['a.js', 'b.js']);
+});
+
+test('capDirtyPaths: truncates at the cap and appends a "+N more" marker', () => {
+  const many = Array.from({ length: PRE_RUN_DIRTY_PATHS_CAP + 7 }, (_, i) => `file-${i}.txt`);
+  const capped = capDirtyPaths(many);
+  expect(capped).toHaveLength(PRE_RUN_DIRTY_PATHS_CAP + 1);
+  expect(capped.slice(0, PRE_RUN_DIRTY_PATHS_CAP)).toEqual(many.slice(0, PRE_RUN_DIRTY_PATHS_CAP));
+  expect(capped[PRE_RUN_DIRTY_PATHS_CAP]).toBe('+7 more');
+});
+
+test('buildForeignWipSection: "" when both lists are empty/absent (clean spawn) — zero prompt tokens added', () => {
+  expect(buildForeignWipSection({})).toBe('');
+  expect(buildForeignWipSection({ preRunDirtyPaths: [], carriedPaths: [] })).toBe('');
+  expect(buildForeignWipSection()).toBe('');
+});
+
+test('buildForeignWipSection: shared dirty tree emits the manifest with the delimiter, paths verbatim, and do-not-touch wording', () => {
+  const section = buildForeignWipSection({ preRunDirtyPaths: ['src/foo.ts', 'src/bar.ts'] });
+  expect(section).toContain(FOREIGN_WIP_DELIMITER);
+  expect(section).toContain(FOREIGN_WIP_END_DELIMITER);
+  expect(section).toContain('src/foo.ts');
+  expect(section).toContain('src/bar.ts');
+  expect(section).toMatch(/SHARED working tree/);
+  expect(section).toMatch(/not this job's work/i);
+  expect(section).toMatch(/do not stage, commit, revert, or stash/i);
+  expect(section).toMatch(/not this job's regression/i);
+});
+
+test('buildForeignWipSection: carriedPaths (PRD 1094 base WIP) emits carry-over wording, not the shared-tree wording', () => {
+  const section = buildForeignWipSection({ carriedPaths: ['config/settings.json'] });
+  expect(section).toContain('config/settings.json');
+  expect(section).toMatch(/isolated git worktree/i);
+  expect(section).toMatch(/authoritative copy.*main tree/i);
+  expect(section).not.toMatch(/SHARED working tree/);
+});
+
+test('buildForeignWipSection: carriedPaths takes precedence over preRunDirtyPaths when both are somehow present', () => {
+  const section = buildForeignWipSection({
+    carriedPaths: ['carried.ts'],
+    preRunDirtyPaths: ['dirty.ts'],
+  });
+  expect(section).toContain('carried.ts');
+  expect(section).not.toContain('dirty.ts');
+  expect(section).toMatch(/isolated git worktree/i);
+});
+
+test('buildForeignWipSection: isolated-clean (worktree ok, no carried WIP) emits nothing', () => {
+  expect(buildForeignWipSection({ carriedPaths: [] })).toBe('');
+});

package/src/main/__tests__/scheduler-inplace-salvage.test.cjs

@@ -0,0 +1,242 @@
+/**
+ * scheduler-inplace-salvage.test.cjs — PRD 1098: an in-place run (no
+ * worktree — SM_JOB_WORKTREE_DISABLE=1 here, but the same finally-block path
+ * also covers a non-git cwd, the worktree cap, or a carry-over failure) must
+ * still salvage its uncommitted work, exactly like the worktree path already
+ * did (gitWorktreeSalvage.test.cjs), and regardless of exit code. Drives
+ * spawnJob end-to-end against a real git fixture repo with a stub `claude`
+ * binary (SM_CLAUDE_BIN, same pattern as scheduler-worktree-exec-cwd.test.cjs)
+ * that dirties the tree then exits 137 (SIGKILL), simulating a job killed
+ * mid-run before its finish-protocol commit.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-inplace-salvage.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+let tmpHome;
+let originalHome;
+let originalDisable;
+let spawnJob;
+let RUNS_DIR;
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' });
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(['init', '-q'], dir);
+  git(['config', 'user.email', 'test@example.com'], dir);
+  git(['config', 'user.name', 'Test'], dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+// readQueue()'s per-project discovery walks ~/.claude/projects/*/*.jsonl
+// transcripts for a `cwd` field to find known project queue.json shards — an
+// unregistered project's queue.json is invisible to mutate()/readQueue() and
+// silently never gets written back to. Same helper scheduler-reap-dead-
+// running-jobs.test.cjs uses.
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function writeProjectQueue(cwd, jobs) {
+  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
+  return path.join(stateDir, 'queue.json');
+}
+
+// Stub `claude` binary: dirties the repo it runs in (a tracked-file edit and
+// a brand-new untracked file — this job's own delta) then exits 137, with NO
+// result:success event — simulating a job SIGKILLed mid-run before its
+// finish-protocol commit. Deliberately emits no success result: scheduler.cjs
+// maps a killed process straight back to exitCode 0 when it already saw
+// result:success (the intentional "cleanup hung after real success" case),
+// which is not the scenario under test here — this must land as a genuine
+// non-zero exit.
+function writeKilledClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-killed-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const path = require('path');
+    fs.writeFileSync(path.join(process.cwd(), 'README.md'), 'hello\\nedited by job\\n', 'utf8');
+    fs.writeFileSync(path.join(process.cwd(), 'job-output.txt'), 'work the job produced before dying\\n', 'utf8');
+    process.exit(137);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-'));
+  process.env.HOME = tmpHome;
+  originalDisable = process.env.SM_JOB_WORKTREE_DISABLE;
+  // Force the in-place path deterministically — this test is about the
+  // salvage-on-every-exit-code behaviour, not about which condition
+  // triggered the fallback (not-a-repo / cap / carry-over failure all land
+  // in the same else branch).
+  process.env.SM_JOB_WORKTREE_DISABLE = '1';
+  ({ spawnJob, RUNS_DIR } = require('../scheduler.cjs'));
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  if (originalDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
+  else process.env.SM_JOB_WORKTREE_DISABLE = originalDisable;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+});
+
+test('an in-place job killed (exit 137) mid-run salvages a delta-scoped patch that applies cleanly, without disturbing pre-existing WIP', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-project-'));
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd);
+
+  // Pre-existing human WIP untouched by the job — must survive completely
+  // unmodified, and must never appear in the job's salvage patch.
+  fs.writeFileSync(path.join(projectCwd, 'human-wip.txt'), 'human work in progress\n', 'utf8');
+  git(['add', '-A'], projectCwd);
+  // Leave it staged-but-uncommitted (real dirty WIP), not committed.
+  fs.appendFileSync(path.join(projectCwd, 'human-wip.txt'), 'more human edits\n', 'utf8');
+
+  const slug = `1098-test-inplace-killed-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do a thing that gets killed mid-run.', 'utf8');
+
+  const queuePath = writeProjectQueue(projectCwd, [
+    { slug, status: 'pending', cwd: projectCwd },
+  ]);
+
+  const statusBefore = git(['status', '--porcelain'], projectCwd);
+  const stashBefore = git(['stash', 'list'], projectCwd);
+
+  process.env.SM_CLAUDE_BIN = writeKilledClaudeStub();
+
+  const runId = `run-${slug}`;
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+
+  try {
+    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
+
+    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+    const row = jobs.find((j) => j.slug === slug);
+    expect(row).toBeTruthy();
+    expect(row.exitCode).toBe(137);
+    expect(row.salvagePatch).toBeTruthy();
+    expect(fs.existsSync(row.salvagePatch)).toBe(true);
+
+    // Leftover-attribution fields: this job's own delta (README.md +
+    // job-output.txt), never the human's pre-existing baseline WIP.
+    expect(row.leftoverCount).toBe(2);
+    expect(new Set(row.leftoverPaths)).toEqual(new Set(['README.md', 'job-output.txt']));
+    // The pre-run baseline is cleared once the run has finalized — it was
+    // only ever needed to compute the delta above.
+    expect(row.guardBaseline).toBeUndefined();
+    expect(row.guardHeadBefore).toBeUndefined();
+
+    const patch = fs.readFileSync(row.salvagePatch, 'utf8');
+    expect(patch).toContain('README.md');
+    expect(patch).toContain('edited by job');
+    expect(patch).toContain('job-output.txt');
+    expect(patch).toContain('work the job produced before dying');
+    // The human's pre-existing WIP (baseline-dirty, not part of this job's
+    // delta) must never leak into the job's salvage patch.
+    expect(patch).not.toContain('more human edits');
+
+    // The patch must be self-sufficient and apply cleanly against a clean
+    // checkout of the same base commit.
+    const cleanCheckout = path.join(os.tmpdir(), `sm-inplace-salvage-clean-${process.pid}-${Math.floor(Math.random() * 1e6)}`);
+    git(['clone', '-q', projectCwd, cleanCheckout], os.tmpdir());
+    try {
+      expect(() => git(['apply', '--check', row.salvagePatch], cleanCheckout)).not.toThrow();
+    } finally {
+      fs.rmSync(cleanCheckout, { recursive: true, force: true });
+    }
+
+    // The shared tree itself was never mutated by the salvage pass — no
+    // add/stash/reset/checkout/clean. (The job's own dirtying of README.md
+    // and job-output.txt is real, expected, working-tree state left by the
+    // stub process itself, not something salvage did — so we only assert no
+    // stash was created and the human's pre-existing WIP file is untouched.)
+    const stashAfter = git(['stash', 'list'], projectCwd);
+    expect(stashAfter).toBe(stashBefore);
+    const humanWipContent = fs.readFileSync(path.join(projectCwd, 'human-wip.txt'), 'utf8');
+    expect(humanWipContent).toBe('human work in progress\nmore human edits\n');
+    void statusBefore; // baseline captured for readability of intent above
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+}, 30_000);
+
+// Stub `claude` binary: touches nothing, emits a success result, and exits 0
+// — a job whose only working-tree dirt is pre-existing human/sibling WIP
+// present before the run even started.
+function writeNoopClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-noop-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'nothing to do', is_error: false }) + '\\n');
+    process.exit(0);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+test('a job whose tree is dirty only from pre-existing baseline WIP (human/sibling), and which itself dirties/commits nothing, gets no leftover attribution', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-project-'));
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd);
+
+  // Pre-existing WIP present BEFORE the run — must never be attributed to
+  // this job, even though it's still dirty at exit.
+  fs.writeFileSync(path.join(projectCwd, 'human-wip.txt'), 'human work in progress\n', 'utf8');
+
+  const slug = `1098-test-inplace-noop-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do nothing.', 'utf8');
+
+  const queuePath = writeProjectQueue(projectCwd, [
+    { slug, status: 'pending', cwd: projectCwd },
+  ]);
+
+  process.env.SM_CLAUDE_BIN = writeNoopClaudeStub();
+
+  const runId = `run-${slug}`;
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+
+  try {
+    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
+
+    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+    const row = jobs.find((j) => j.slug === slug);
+    expect(row).toBeTruthy();
+    expect(row.exitCode).toBe(0);
+    // No leftover attribution: the only dirt is baseline WIP, not this job's.
+    expect(row.leftoverPaths).toBeUndefined();
+    expect(row.leftoverCount).toBeUndefined();
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+}, 30_000);

package/src/main/__tests__/scheduler-investigation-prompt.test.cjs

@@ -54,6 +54,37 @@ test('prompt includes the resolved job fields', () => {
   assert.match(prompt, /05-fix-my-feature\.md/);
 });
 
+// ─── abandoned_background_task: investigation prompt directs a commit-first check ─
+
+test('prompt for an abandoned_background_task job directs inspecting the working tree and committing before re-implementing', () => {
+  const prompt = buildInvestigationPrompt(makeArgs({
+    failedJob: { slug: '05-my-feature', title: 'My feature', exitCode: 0, verifierVerdict: 'abandoned_background_task' },
+  }));
+  assert.match(prompt, /abandoned_background_task/);
+  assert.match(prompt, /git status/);
+  assert.match(prompt, /COMMIT/);
+  assert.match(prompt, /not re-implement or re-plan the PRD from scratch/);
+});
+
+test('prompt for a job with no abandoned_background_task verdict omits the note', () => {
+  const prompt = buildInvestigationPrompt(makeArgs());
+  assert.doesNotMatch(prompt, /abandoned_background_task/);
+});
+
+test('prompt for an abandoned_background_task job with a salvage patch names its exact path', () => {
+  const prompt = buildInvestigationPrompt(makeArgs({
+    failedJob: {
+      slug: '05-my-feature',
+      title: 'My feature',
+      exitCode: 0,
+      verifierVerdict: 'abandoned_background_task',
+      salvagePatch: '/tmp/runs/2026-09-02/05-my-feature.uncommitted.patch',
+    },
+  }));
+  assert.match(prompt, /05-my-feature\.uncommitted\.patch/);
+  assert.match(prompt, /apply it to the working tree BEFORE inspecting/);
+});
+
 // ─── cwd-must-be-git-repo-root guidance (99-fix-e2e-needs-review-test) ────────
 
 test('prompt instructs that cwd must be the git repo root where the fix will land', () => {