claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-job-budget.test.cjs

@@ -1,172 +0,0 @@
-/**
- * scheduler-job-budget.test.cjs — per-job wall-clock budget derived from the
- * PRD's own `estimateMinutes`, and the classifier that parks an over-budget
- * job `needs_review` (never 'failed', never silently 'completed').
- *
- * Closes the gap `findOverrunningJobs` deliberately leaves open (escalation
- * only, never kills — see its own header): p50/p90/max across 606 run-meta
- * records since 2026-08-25 was 13m/60m/240m against a concurrencyCap of 4,
- * so a chatty-but-runaway executor that keeps emitting output (never
- * tripping IDLE_OUTPUT_KILL_MS) could hold a dispatch slot for hours with
- * nothing to notice or act on it.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-job-budget.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const {
-  computeJobBudgetMs,
-  classifyBudgetKill,
-  isJobBudgetExempt,
-  shouldKillForBudget,
-  resolveBudgetKillOutcome,
-  selectAutoFixTargets,
-  JOB_BUDGET_FACTOR,
-  JOB_BUDGET_FLOOR_MS,
-  JOB_BUDGET_CEILING_MS,
-} = require('../scheduler.cjs');
-
-// ---------- computeJobBudgetMs: both clamps ----------
-
-test('computeJobBudgetMs: a mid-size estimate is factor*estimate, no clamp hit', () => {
-  // 30m * 3 = 90m — comfortably between the 45m floor and the 180m ceiling.
-  const budgetMs = computeJobBudgetMs(30);
-  assert.strictEqual(budgetMs, 90 * 60_000);
-});
-
-test('computeJobBudgetMs: the floor clamp — a tiny/missing/zero estimate never goes below 45m', () => {
-  // 5m * 3 = 15m, well under the 45m floor.
-  assert.strictEqual(computeJobBudgetMs(5), JOB_BUDGET_FLOOR_MS);
-  // Missing/zero estimate is treated as 0 — the floor dominates, no special-casing.
-  assert.strictEqual(computeJobBudgetMs(0), JOB_BUDGET_FLOOR_MS);
-  assert.strictEqual(computeJobBudgetMs(null), JOB_BUDGET_FLOOR_MS);
-  assert.strictEqual(computeJobBudgetMs(undefined), JOB_BUDGET_FLOOR_MS);
-});
-
-test('computeJobBudgetMs: the ceiling clamp — a huge estimate never exceeds 180m', () => {
-  // 200m * 3 = 600m, way past the 180m ceiling.
-  assert.strictEqual(computeJobBudgetMs(200), JOB_BUDGET_CEILING_MS);
-});
-
-test('computeJobBudgetMs: honors caller overrides when neither clamp is hit', () => {
-  const budgetMs = computeJobBudgetMs(5, { factor: 2, floorMs: 1000, ceilingMs: 3_600_000 });
-  assert.strictEqual(budgetMs, 10 * 60_000);
-});
-
-test('JOB_BUDGET_FACTOR/FLOOR/CEILING are the named constants the AC requires (3x, 45m, 180m)', () => {
-  assert.strictEqual(JOB_BUDGET_FACTOR, 3);
-  assert.strictEqual(JOB_BUDGET_FLOOR_MS, 45 * 60_000);
-  assert.strictEqual(JOB_BUDGET_CEILING_MS, 180 * 60_000);
-});
-
-// ---------- shouldKillForBudget: under vs over budget ----------
-
-test('shouldKillForBudget: a job under budget is untouched', () => {
-  assert.strictEqual(shouldKillForBudget(44 * 60_000, 45 * 60_000), false);
-});
-
-test('shouldKillForBudget: a job at or past its budget fires', () => {
-  assert.strictEqual(shouldKillForBudget(45 * 60_000, 45 * 60_000), true);
-  assert.strictEqual(shouldKillForBudget(241 * 60_000, 90 * 60_000), true);
-});
-
-// ---------- classifyBudgetKill: the needs_review park + evidence threading ----------
-
-test('classifyBudgetKill: a job not killed by the budget watchdog is untouched (returns null)', () => {
-  assert.strictEqual(classifyBudgetKill({ killedByWatchdog: 'idle-tail', exitCode: 143 }, null), null);
-  assert.strictEqual(classifyBudgetKill({ killedByWatchdog: null, exitCode: 0 }, null), null);
-  assert.strictEqual(classifyBudgetKill(null, null), null);
-});
-
-test('classifyBudgetKill: an over-budget job parks needs_review with the exact reason string, no evidence', () => {
-  const res = {
-    killedByWatchdog: 'budget',
-    exitCode: 143,
-    budgetKillReason: 'wall-clock budget exceeded: ran 241m against a 90m budget (estimateMinutes=30)',
-  };
-  const decision = classifyBudgetKill(res, null);
-  assert.strictEqual(decision.status, 'needs_review');
-  assert.strictEqual(decision.reason, 'wall-clock budget exceeded: ran 241m against a 90m budget (estimateMinutes=30)');
-  assert.strictEqual(decision.landedCommit, null);
-});
-
-test('classifyBudgetKill: an over-budget job with a verified landed commit is still adjudicated on git evidence, not discarded', () => {
-  const res = {
-    killedByWatchdog: 'budget',
-    exitCode: 143,
-    budgetKillReason: 'wall-clock budget exceeded: ran 91m against a 90m budget (estimateMinutes=30)',
-  };
-  const decision = classifyBudgetKill(res, 'deadbeef1234567890');
-  // Never 'failed' or 'completed' just because a commit landed — still parked
-  // for review, but the evidence is threaded onto the row rather than dropped.
-  assert.strictEqual(decision.status, 'needs_review');
-  assert.strictEqual(decision.landedCommit, 'deadbeef1234567890');
-});
-
-// ---------- isJobBudgetExempt: quietMachine + explicit opt-out ----------
-
-test('isJobBudgetExempt: a quietMachine job is exempt', () => {
-  assert.strictEqual(isJobBudgetExempt({ quietMachine: true }), true);
-});
-
-test('isJobBudgetExempt: a PRD with an explicit budgetExempt opt-out is exempt', () => {
-  assert.strictEqual(isJobBudgetExempt({ budgetExempt: true }), true);
-});
-
-test('isJobBudgetExempt: an ordinary job is not exempt', () => {
-  assert.strictEqual(isJobBudgetExempt({}), false);
-  assert.strictEqual(isJobBudgetExempt({ quietMachine: false, budgetExempt: false }), false);
-});
-
-// ---------- resolveBudgetKillOutcome: the watchdog-tick vs natural-exit race ----------
-
-test('resolveBudgetKillOutcome: a genuine signal kill (exit 143) is trusted', () => {
-  const outcome = resolveBudgetKillOutcome({
-    killedByWatchdog: 'budget', killedBySignal: true, durationMs: 91 * 60_000, jobBudgetMs: 90 * 60_000, estimateMinutes: 30,
-  });
-  assert.strictEqual(outcome.killedByWatchdog, 'budget');
-  assert.strictEqual(outcome.budgetKillReason, 'wall-clock budget exceeded: ran 91m against a 90m budget (estimateMinutes=30)');
-});
-
-test('resolveBudgetKillOutcome: a race where the child exits cleanly (exit 0) in the same tick is NOT trusted as a budget kill', () => {
-  // The watchdog's action() fired (stamping ctx.killedByWatchdog='budget')
-  // but the agent had already exited on its own with exit 0 — killTree()
-  // was a no-op against an already-dead pid. Must never misclassify a
-  // genuinely successful run as needs_review.
-  const outcome = resolveBudgetKillOutcome({
-    killedByWatchdog: 'budget', killedBySignal: false, durationMs: 90 * 60_000, jobBudgetMs: 90 * 60_000, estimateMinutes: 30,
-  });
-  assert.strictEqual(outcome.killedByWatchdog, null);
-  assert.strictEqual(outcome.budgetKillReason, null);
-});
-
-test('resolveBudgetKillOutcome: a race where the child fails on its own (exit 1, unrelated) is NOT trusted as a budget kill', () => {
-  const outcome = resolveBudgetKillOutcome({
-    killedByWatchdog: 'budget', killedBySignal: false, durationMs: 90 * 60_000, jobBudgetMs: 90 * 60_000, estimateMinutes: 30,
-  });
-  assert.strictEqual(outcome.killedByWatchdog, null);
-});
-
-test('resolveBudgetKillOutcome: no watchdog fired at all — untouched', () => {
-  const outcome = resolveBudgetKillOutcome({
-    killedByWatchdog: 'idle-tail', killedBySignal: true, durationMs: 25 * 60_000, jobBudgetMs: 90 * 60_000, estimateMinutes: 30,
-  });
-  assert.strictEqual(outcome.killedByWatchdog, 'idle-tail');
-  assert.strictEqual(outcome.budgetKillReason, null);
-});
-
-// ---------- selectAutoFixTargets: a budget-killed job never gets auto-retried ----------
-
-test('selectAutoFixTargets: a budget_exceeded needs_review job is excluded — it parks for a human/ladder decision, never a fix-plan', () => {
-  const jobs = [
-    { slug: '10-budget-victim', status: 'needs_review', verifierVerdict: 'budget_exceeded', runId: 'r1' },
-    { slug: '11-ordinary', status: 'needs_review', verifierVerdict: 'transcript_errors', runId: 'r2' },
-  ];
-  const targets = selectAutoFixTargets(jobs, { fixSlugExists: () => false });
-  assert.ok(!targets.some((t) => t.slug === '10-budget-victim'));
-  assert.ok(targets.some((t) => t.slug === '11-ordinary'));
-});

package/src/main/__tests__/scheduler-job-overrun.test.cjs

@@ -1,175 +0,0 @@
-/**
- * scheduler-job-overrun.test.cjs — findOverrunningJobs: escalate a RUNNING
- * job that has blown past its own PRD's `estimateMinutes`.
- *
- * Covers the blind spot between the two existing kill paths, which is how a
- * PRD ran 3h+ on 2026-08-08 with nothing noticing:
- *   - MAX_JOB_DURATION_MS (4h) deadman — 3h is still an hour short of it
- *   - IDLE_OUTPUT_KILL_MS (20m) — only fires on a STALLED log; a job looping
- *     while still writing output never trips it
- * `estimateMinutes` was stored and displayed but never compared to runtime.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-job-overrun.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md). A
-// node:test file loads here as "No test suite found" and contributes zero
-// tests, so the guard silently wouldn't exist.
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const {
-  findOverrunningJobs,
-  JOB_OVERRUN_FACTOR,
-  JOB_OVERRUN_FLOOR_MS,
-  resetJobFields,
-} = require('../scheduler.cjs');
-
-const NOW = Date.parse('2026-08-08T12:00:00.000Z');
-const agoMin = (m) => new Date(NOW - m * 60_000).toISOString();
-
-test('the real incident: a 20-minute PRD still running at 3h escalates', () => {
-  const jobs = [
-    { slug: '1029-long', cwd: '/p1', status: 'running', estimateMinutes: 20, startedAt: agoMin(180) },
-  ];
-  const over = findOverrunningJobs(jobs, NOW);
-  assert.strictEqual(over.length, 1);
-  assert.strictEqual(over[0].slug, '1029-long');
-  assert.strictEqual(over[0].estimateMinutes, 20);
-  assert.ok(over[0].ratio >= 8.9 && over[0].ratio <= 9.1, `expected ~9x, got ${over[0].ratio}`);
-});
-
-test('a job comfortably inside its estimate does not escalate', () => {
-  const jobs = [
-    { slug: 'ok', cwd: '/p1', status: 'running', estimateMinutes: 60, startedAt: agoMin(30) },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-});
-
-test('the floor stops a tiny estimate escalating on noise', () => {
-  // 5m estimate x3 = 15m, but the floor is 45m — at 20m elapsed this is
-  // over the factor yet under the floor, so it must stay silent.
-  const jobs = [
-    { slug: 'tiny', cwd: '/p1', status: 'running', estimateMinutes: 5, startedAt: agoMin(20) },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-  // Past the floor it does escalate.
-  const past = findOverrunningJobs(
-    [{ slug: 'tiny', cwd: '/p1', status: 'running', estimateMinutes: 5, startedAt: agoMin(50) }],
-    NOW,
-  );
-  assert.strictEqual(past.length, 1);
-});
-
-test('only RUNNING jobs are considered — pending/completed/quarantined are not', () => {
-  const base = { cwd: '/p1', estimateMinutes: 10, startedAt: agoMin(300) };
-  const jobs = [
-    { ...base, slug: 'a', status: 'pending' },
-    { ...base, slug: 'b', status: 'completed' },
-    { ...base, slug: 'c', status: 'failed' },
-    { ...base, slug: 'd', status: 'quarantined' },
-    { ...base, slug: 'e', status: 'needs_review' },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-});
-
-test('a job with no usable estimate or start time is skipped, never guessed at', () => {
-  const jobs = [
-    { slug: 'no-est', cwd: '/p1', status: 'running', startedAt: agoMin(300) },
-    { slug: 'zero-est', cwd: '/p1', status: 'running', estimateMinutes: 0, startedAt: agoMin(300) },
-    { slug: 'nan-est', cwd: '/p1', status: 'running', estimateMinutes: 'soon', startedAt: agoMin(300) },
-    { slug: 'no-start', cwd: '/p1', status: 'running', estimateMinutes: 10 },
-    { slug: 'bad-start', cwd: '/p1', status: 'running', estimateMinutes: 10, startedAt: 'not-a-date' },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-});
-
-test('a clock skew making elapsed negative does not escalate', () => {
-  const jobs = [
-    { slug: 'future', cwd: '/p1', status: 'running', estimateMinutes: 10, startedAt: agoMin(-60) },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-});
-
-test('escalation is per-project and reports every overrunning job', () => {
-  const jobs = [
-    { slug: 'p1-a', cwd: '/p1', status: 'running', estimateMinutes: 20, startedAt: agoMin(180) },
-    { slug: 'p2-a', cwd: '/p2', status: 'running', estimateMinutes: 30, startedAt: agoMin(200) },
-    { slug: 'p2-b', cwd: '/p2', status: 'running', estimateMinutes: 60, startedAt: agoMin(30) },
-  ];
-  const slugs = findOverrunningJobs(jobs, NOW).map((o) => o.slug).sort();
-  assert.deepStrictEqual(slugs, ['p1-a', 'p2-a']);
-});
-
-test('factor and floor are overridable per call', () => {
-  const jobs = [
-    { slug: 'x', cwd: '/p1', status: 'running', estimateMinutes: 60, startedAt: agoMin(90) },
-  ];
-  // Default: 60m x3 = 180m threshold, 90m elapsed → silent.
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-  // Tighter factor → escalates.
-  assert.strictEqual(findOverrunningJobs(jobs, NOW, { factor: 1.5, floorMs: 0 }).length, 1);
-});
-
-test('the shipped defaults are the documented ones', () => {
-  assert.strictEqual(JOB_OVERRUN_FACTOR, 3);
-  assert.strictEqual(JOB_OVERRUN_FLOOR_MS, 45 * 60_000);
-});
-
-// The escalation loop in scheduler.cjs (~8700) stamps job.overrun straight
-// from findOverrunningJobs' own return shape — these tests exercise that
-// exact shape against the live starry-night-ships incident fixture
-// (estimateMinutes: 22, ranMs: 6379556, ratio: 4.83) rather than duplicating
-// the threshold math the escalation loop itself must not recompute.
-
-test('the live incident fixture (4.9x over a 22m estimate) is stamped', () => {
-  const startedAt = new Date(NOW - 6379556).toISOString();
-  const jobs = [
-    { slug: '231-saturn-record-and-docs', cwd: '/starry', status: 'running', estimateMinutes: 22, startedAt },
-  ];
-  const over = findOverrunningJobs(jobs, NOW);
-  assert.strictEqual(over.length, 1);
-  const [hit] = over;
-  assert.ok(hit.ratio >= 4.8 && hit.ratio <= 4.9, `expected ~4.83x, got ${hit.ratio}`);
-
-  // Mirror the escalation loop's own stamp assignment (job.overrun = {...}) —
-  // same fields the ScheduleJobLite renderer type now carries.
-  const job = jobs[0];
-  job.overrun = { ratio: hit.ratio, ranMs: hit.ranMs, estimateMinutes: hit.estimateMinutes, at: new Date(NOW).toISOString() };
-  assert.strictEqual(job.overrun.estimateMinutes, 22);
-  assert.strictEqual(job.overrun.ranMs, 6379556);
-  assert.ok(job.overrun.ratio >= 4.8 && job.overrun.ratio <= 4.9);
-
-  // Idempotent re-escalation: a later sweep overwrites in place, never appends.
-  const laterNow = NOW + 10 * 60_000;
-  const laterOver = findOverrunningJobs(jobs, laterNow)[0];
-  job.overrun = {
-    ratio: laterOver.ratio, ranMs: laterOver.ranMs, estimateMinutes: laterOver.estimateMinutes, at: new Date(laterNow).toISOString(),
-  };
-  assert.strictEqual(typeof job.overrun, 'object');
-  assert.ok(job.overrun.ranMs > hit.ranMs, 'ranMs should have advanced on re-escalation, not duplicated');
-});
-
-test('a job with no usable estimate is never in the escalation list, so it is never stamped', () => {
-  const jobs = [
-    { slug: 'no-est', cwd: '/p1', status: 'running', startedAt: agoMin(300) },
-  ];
-  assert.deepStrictEqual(findOverrunningJobs(jobs, NOW), []);
-  assert.strictEqual(jobs[0].overrun, undefined);
-});
-
-test('resetJobFields clears a stamped overrun badge — this run\'s outcome, not durable across a reset', () => {
-  const job = {
-    slug: '231-saturn-record-and-docs',
-    status: 'running',
-    statusHistory: [],
-    runId: 'r1',
-    startedAt: agoMin(180),
-    overrun: { ratio: 4.83, ranMs: 6379556, estimateMinutes: 22, at: new Date(NOW).toISOString() },
-  };
-  const ok = resetJobFields(job, 'reset for test');
-  assert.strictEqual(ok, true);
-  assert.strictEqual(job.status, 'pending');
-  assert.strictEqual('overrun' in job, false);
-});

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

@@ -1,199 +0,0 @@
-/**
- * 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');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-
-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 }) {
-  return claudeStub.writeClaudeStub({ 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);
-  ` });
-}
-
-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

@@ -1,52 +0,0 @@
-/**
- * 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();
-});