claude-code-session-manager 0.75.3 → 0.77.0

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', () => {

package/src/main/__tests__/scheduler-launch-failure.test.cjs

@@ -0,0 +1,201 @@
+/**
+ * scheduler-launch-failure.test.cjs — issue #11 end to end at the executeJob
+ * + handleLaunchFailure level with a stub `claude` that reproduces the
+ * macOS incident verbatim: HTTP 400 `thinking.type.enabled` on the first
+ * request, one turn, zero output tokens, exit 1 in seconds.
+ *
+ * Proves: the run is classified as a launch failure (not a PRD failure), the
+ * API message lands on the row, the row goes back to `pending` (never
+ * `failed`), the persona's launch breaker is armed in the machine state, the
+ * outcome sidecar is written, the child env carries the headless-job marker
+ * and the mitigation env, and a stub that then takes a real turn is NOT a
+ * launch failure.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-launch-failure.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 handleLaunchFailure;
+let applyLaunchFailure;
+let writeQueue;
+let queueStore;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-launch-failure-'));
+  process.env.HOME = tmpHome;
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  ({ executeJob, handleLaunchFailure, applyLaunchFailure, writeQueue } = require('../scheduler.cjs'));
+  queueStore = require('../lib/queueStore.cjs');
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+});
+
+const THINKING_400 = 'API Error: 400 {"detail":{"error":"{\\"message\\":\\"\\\\\\"thinking.type.enabled\\\\\\" is not supported for this model. Use \\\\\\"thinking.type.adaptive\\\\\\" and \\\\\\"output_config.effort\\\\\\" to control thinking behavior.\\"}"}}';
+
+function writeStub({ mode }) {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-launch-${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({
+      SM_SCHEDULER_JOB_SLUG: process.env.SM_SCHEDULER_JOB_SLUG || null,
+      SM_SCHEDULER_JOB_MAY_QUEUE: process.env.SM_SCHEDULER_JOB_MAY_QUEUE || null,
+      MAX_THINKING_TOKENS: process.env.MAX_THINKING_TOKENS || null,
+    }), 'utf8');
+    const mode = ${JSON.stringify(mode)};
+    if (mode === 'thinking-400') {
+      process.stdout.write(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: ${JSON.stringify(THINKING_400)} }] } }) + '\\n');
+      process.stdout.write(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, api_error_status: 400, num_turns: 1, duration_ms: 2000, total_cost_usd: 0, usage: { input_tokens: 0, output_tokens: 0 }, result: ${JSON.stringify(THINKING_400)} }) + '\\n');
+      process.exit(1);
+    }
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, num_turns: 9, usage: { input_tokens: 100, output_tokens: 250 }, result: 'Error: tests failed' }) + '\\n');
+    process.exit(1);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+function mkProject() {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-launch-main-'));
+  const slug = `1201-launch-${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`), 'Do the thing.', 'utf8');
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-launch-run-'));
+  return { mainCwd, slug, runDir };
+}
+
+test('executeJob: the issue-#11 400 is a launch failure with the API message, and meta.json records it', async () => {
+  const { mainCwd, slug, runDir } = mkProject();
+  process.env.SM_CLAUDE_BIN = writeStub({ mode: 'thinking-400' });
+  const job = { slug, cwd: mainCwd, agentType: 'dev-lead' };
+
+  const res = await executeJob(job, runDir, mainCwd, () => Promise.resolve(), undefined, null, null, { MAX_THINKING_TOKENS: '0' });
+
+  expect(res.exitCode).toBe(1);
+  expect(res.launchFailure).toMatchObject({ kind: 'model_config_rejected', httpStatus: 400 });
+  expect(res.launchFailure.message).toMatch(/thinking\.type\.enabled.*not supported/);
+  expect(res.resultStats).toMatchObject({ numTurns: 1, outputTokens: 0 });
+
+  const meta = JSON.parse(fs.readFileSync(path.join(runDir, `${slug}.meta.json`), 'utf8'));
+  expect(meta.launchFailure.kind).toBe('model_config_rejected');
+  expect(meta.numTurns).toBe(1);
+  expect(meta.outputTokens).toBe(0);
+  expect(meta.launchEnvApplied).toEqual(['MAX_THINKING_TOKENS']);
+
+  const env = JSON.parse(fs.readFileSync(path.join(mainCwd, 'env.marker'), 'utf8'));
+  expect(env.SM_SCHEDULER_JOB_SLUG).toBe(slug);
+  expect(env.SM_SCHEDULER_JOB_MAY_QUEUE).toBe('0');
+  expect(env.MAX_THINKING_TOKENS).toBe('0');
+
+  const log = fs.readFileSync(path.join(runDir, `${slug}.log`), 'utf8');
+  expect(log).toMatch(/LAUNCH FAILURE \(model_config_rejected HTTP 400\)/);
+  expect(log).toMatch(/launch mitigation env applied: MAX_THINKING_TOKENS=0/);
+
+  fs.rmSync(mainCwd, { recursive: true, force: true });
+});
+
+test('executeJob: a run that took real turns and failed is NOT a launch failure; architect persona may queue', async () => {
+  const { mainCwd, slug, runDir } = mkProject();
+  process.env.SM_CLAUDE_BIN = writeStub({ mode: 'real-failure' });
+  const job = { slug, cwd: mainCwd, agentType: 'architect' };
+
+  const res = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
+
+  expect(res.exitCode).toBe(1);
+  expect(res.launchFailure).toBeNull();
+  expect(res.resultStats).toMatchObject({ numTurns: 9, outputTokens: 250 });
+  const env = JSON.parse(fs.readFileSync(path.join(mainCwd, 'env.marker'), 'utf8'));
+  expect(env.SM_SCHEDULER_JOB_MAY_QUEUE).toBe('1');
+  expect(env.MAX_THINKING_TOKENS).toBeNull();
+
+  fs.rmSync(mainCwd, { recursive: true, force: true });
+});
+
+test('applyLaunchFailure: row → pending with the API message, breaker armed, never failed; a repeat escalates the same block', () => {
+  const runId = '2026-09-02T17-54-14-770Z';
+  const job = { slug: '1201-a', cwd: '/tmp/p', agentType: 'dev-lead', status: 'running', runId, startedAt: '2026-09-02T17:54:14.770Z', statusHistory: [] };
+  const s = { jobs: [job], launchBlocks: {}, launchMitigations: { 'dev-lead': { env: { MAX_THINKING_TOKENS: '0' } } } };
+  const lf = { kind: 'model_config_rejected', httpStatus: 400, message: '"thinking.type.enabled" is not supported for this model.' };
+  const T0 = Date.parse('2026-09-02T18:00:00Z');
+
+  const armed = applyLaunchFailure(s, { job, lf, runId, launchKey: 'dev-lead', mitigationApplied: false, claudeVersion: '1.0.90', now: T0 });
+
+  expect(armed.kind).toBe('model_config_rejected');
+  expect(armed.attempts).toBe(1);
+  expect(s.launchBlocks['dev-lead']).toBe(armed);
+  expect(s.launchMitigations['dev-lead']).toBeTruthy(); // not dropped: no mitigation was applied to THIS run
+
+  const row = s.jobs[0];
+  expect(row.status).toBe('pending');
+  expect(row.error).toMatch(/launch failure \(model_config_rejected HTTP 400\): "thinking\.type\.enabled"/);
+  expect(row.launchFailure).toMatchObject({ kind: 'model_config_rejected', httpStatus: 400, count: 1, runId, mitigationApplied: false });
+  expect(row.terminalReason).toBe('launch_failure:model_config_rejected');
+  expect(row.heldReason).toMatch(/^launch blocked \(model_config_rejected\)/);
+  expect(row.transientRetries ?? 0).toBe(0);
+  expect(row.autoFixOutcome).toBeUndefined();
+  expect(row.runId).toBeNull();
+
+  // Second identical failure, this time WITH the mitigation applied → same
+  // block escalates, the unproven mitigation is dropped, the hint is honest.
+  row.status = 'running';
+  const armed2 = applyLaunchFailure(s, { job: row, lf, runId, launchKey: 'dev-lead', mitigationApplied: true, claudeVersion: '1.0.90', now: T0 + 1000 });
+  expect(armed2.attempts).toBe(2);
+  expect(armed2.mitigationApplied).toBe(true);
+  expect(armed2.hint).toMatch(/did not get past it/);
+  expect(Date.parse(armed2.until)).toBeGreaterThan(Date.parse(armed.until));
+  expect(s.launchMitigations['dev-lead']).toBeUndefined();
+  expect(row.launchFailure.count).toBe(2);
+  expect(row.status).toBe('pending');
+});
+
+test('applyLaunchFailure: a row already finalized by someone else (cancel) is left alone, breaker still arms', () => {
+  const job = { slug: '1201-b', agentType: 'dev-lead', status: 'failed', error: 'cancelled via admin API' };
+  const s = { jobs: [job], launchBlocks: {}, launchMitigations: {} };
+  applyLaunchFailure(s, { job, lf: { kind: 'auth_failed', httpStatus: 401, message: 'bad key' }, runId: 'r', launchKey: 'dev-lead', mitigationApplied: false, claudeVersion: null, now: Date.now() });
+  expect(s.jobs[0].status).toBe('failed');
+  expect(s.jobs[0].error).toBe('cancelled via admin API');
+  expect(s.launchBlocks['dev-lead'].kind).toBe('auth_failed');
+});
+
+test('handleLaunchFailure: persists the breaker into the machine state file and writes the outcome sidecar', async () => {
+  const { mainCwd, slug, runDir } = mkProject();
+  const runId = path.basename(runDir);
+  const job = { slug, cwd: mainCwd, agentType: 'dev-lead', status: 'running', runId };
+  await writeQueue({ config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null, launchBlocks: {}, launchMitigations: {} });
+
+  const res = {
+    exitCode: 1, durationMs: 2000,
+    launchFailure: { kind: 'model_config_rejected', httpStatus: 400, message: '"thinking.type.enabled" is not supported for this model.' },
+    resultStats: { numTurns: 1, outputTokens: 0, totalCostUsd: 0 },
+  };
+  await handleLaunchFailure({ job, res, runId, runDir, launchKey: 'dev-lead', launchEnv: null, claudeVersion: '1.0.90' });
+
+  const machine = JSON.parse(fs.readFileSync(queueStore.MACHINE_STATE_PATH, 'utf8'));
+  const block = machine.launchBlocks['dev-lead'];
+  expect(block).toMatchObject({ kind: 'model_config_rejected', attempts: 1, claudeVersion: '1.0.90', lastSlug: slug, mitigationEnv: { MAX_THINKING_TOKENS: '0' } });
+  expect(block.hint).toMatch(/claude update/);
+
+  const outcome = JSON.parse(fs.readFileSync(path.join(runDir, `${slug}.outcome.json`), 'utf8'));
+  expect(outcome).toMatchObject({ slug, runId, numTurns: 1, outputTokens: 0, status: 'pending', terminalReason: 'launch_failure:model_config_rejected' });
+  expect(outcome.launchFailure.kind).toBe('model_config_rejected');
+
+  fs.rmSync(mainCwd, { recursive: true, force: true });
+});

package/src/main/__tests__/scheduler-leftover-fields.test.cjs

@@ -0,0 +1,52 @@
+/**
+ * scheduler-leftover-fields.test.cjs — leftoverFieldsFrom/applyLeftoverFields,
+ * the pure helpers that turn a newly-dirty path list into the
+ * `leftoverPaths`/`leftoverCount`/`leftoverPathsTruncated` triple stamped on
+ * a terminal job row (see the leftover-attribution PRD: a `failed` row that
+ * left uncommitted work must be visually distinct from one that left
+ * nothing).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-leftover-fields.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { leftoverFieldsFrom, applyLeftoverFields, LEFTOVER_PATHS_CAP } = require('../scheduler.cjs');
+
+test('leftoverFieldsFrom: null when the path list is null (git status unavailable) — never treated as "left nothing"', () => {
+  expect(leftoverFieldsFrom(null)).toBeNull();
+});
+
+test('leftoverFieldsFrom: null for an empty array (left nothing)', () => {
+  expect(leftoverFieldsFrom([])).toBeNull();
+});
+
+test('leftoverFieldsFrom: a real list returns leftoverPaths + leftoverCount, no truncation flag under the cap', () => {
+  const fields = leftoverFieldsFrom(['a.js', 'b.js', 'c.js']);
+  expect(fields).toEqual({ leftoverPaths: ['a.js', 'b.js', 'c.js'], leftoverCount: 3 });
+});
+
+test('leftoverFieldsFrom: caps the displayed path list at LEFTOVER_PATHS_CAP but keeps the true total count', () => {
+  const many = Array.from({ length: LEFTOVER_PATHS_CAP + 12 }, (_, i) => `file-${i}.txt`);
+  const fields = leftoverFieldsFrom(many);
+  expect(fields.leftoverPaths).toHaveLength(LEFTOVER_PATHS_CAP);
+  expect(fields.leftoverCount).toBe(LEFTOVER_PATHS_CAP + 12);
+  expect(fields.leftoverPathsTruncated).toBe(true);
+});
+
+test('applyLeftoverFields: stamps the fields on the row when paths are present', () => {
+  const row = { slug: 'x' };
+  applyLeftoverFields(row, ['a.js']);
+  expect(row.leftoverPaths).toEqual(['a.js']);
+  expect(row.leftoverCount).toBe(1);
+  expect(row.leftoverPathsTruncated).toBeUndefined();
+});
+
+test('applyLeftoverFields: clears any stale fields from a prior call when the new list is empty/null', () => {
+  const row = { slug: 'x', leftoverPaths: ['stale.js'], leftoverCount: 1, leftoverPathsTruncated: true };
+  applyLeftoverFields(row, []);
+  expect(row.leftoverPaths).toBeUndefined();
+  expect(row.leftoverCount).toBeUndefined();
+  expect(row.leftoverPathsTruncated).toBeUndefined();
+});