claude-code-session-manager 0.76.0 → 0.78.0

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();
+});

package/src/main/__tests__/scheduler-looks-done.test.cjs

@@ -0,0 +1,241 @@
+/**
+ * scheduler-looks-done.test.cjs — PRD 1102.
+ *
+ * reverifyNeedsReview() used to have two hard limits that left real, finished
+ * work parked red forever: (1) isRescanCandidate required status ===
+ * 'needs_review' — a `failed` row was never revisited at all; (2)
+ * committedInWindow only looked inside [startedAt, finishedAt+60s], missing a
+ * commit that landed later (a retry, a sibling run, a human). This tests the
+ * widened pass: a `failed` row whose failure is unverified-shaped (no result
+ * event at all — classifyRunOutcome === 'no_result') is now a rescan
+ * candidate, and any candidate with a POST-window commit touching its own
+ * declared paths gets annotated `looksDone` for a human — never auto-
+ * completed. A `failed` row with a genuine result event (a real red gate) must
+ * stay excluded, and the pre-existing needs_review heal path must be
+ * unaffected.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
+ * scheduler-reap-dead-running-jobs.test.cjs's comment for why (every path
+ * this code touches is baked into a top-level const from os.homedir() at
+ * require time).
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-looks-done.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'looks-done-test-'));
+process.env.HOME = tmpHome;
+
+const { reverifyNeedsReview, computeLooksDone } = require('../scheduler.cjs');
+const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
+const { bustCwdCache } = require('../lib/queueStore.cjs');
+
+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);
+}
+
+function commitFile(dir, relPath, content, message) {
+  const abs = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+  git(['add', relPath], dir);
+  git(['commit', '-q', '-m', message], dir);
+}
+
+function registerActiveProject(cwd, slug) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, slug);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+  bustCwdCache();
+}
+
+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');
+}
+
+function writeRunLog(runId, slug, lines) {
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+function writePrd(cwd, slug, body) {
+  const dir = resolvePrdWriteDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const text = `---\ntitle: Test PRD\ncwd: ${cwd}\nestimateMinutes: 30\n---\n${body}\n`;
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+}
+
+async function wait(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+test('failed + no result event (unverified-shaped) + later commit touching declared path → looksDone, transitions to needs_review', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-171');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-171-slug');
+  writePrd(projectCwd, '171-example', [
+    '# Implementation notes',
+    'Edit `src/foo.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '171-example',
+      status: 'failed',
+      cwd: projectCwd,
+      runId: 'run-171',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      error: 'reaped: process gone (outcome=no_result) (outcome=no_result)',
+    },
+  ]);
+  writeRunLog('run-171', '171-example', ['[scheduler] starting 171-example']); // no result event
+
+  await wait(1100); // git --since has 1s resolution
+  commitFile(projectCwd, 'src/foo.js', 'hello', 'fix 171');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'needs_review', 'looksDone never auto-completes — only surfaces for a human');
+  assert.ok(jobs[0].looksDone, 'expected a looksDone annotation');
+  assert.equal(jobs[0].looksDone.commits.length, 1);
+  assert.deepEqual(jobs[0].looksDone.paths, ['src/foo.js']);
+  assert.match(jobs[0].error, /looks done — 1 commit/);
+});
+
+test('failed + a real result event (genuine gate failure) → not a candidate, stays failed untouched', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-real-fail');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-real-fail-slug');
+  writePrd(projectCwd, '05-real-fail', [
+    '# Implementation notes',
+    'Edit `src/bar.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '05-real-fail',
+      status: 'failed',
+      cwd: projectCwd,
+      runId: 'run-real-fail',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      error: 'AC gate red: tests failed',
+    },
+  ]);
+  writeRunLog('run-real-fail', '05-real-fail', [
+    '[scheduler] starting 05-real-fail',
+    JSON.stringify({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'tests failed' }),
+  ]);
+
+  await wait(1100);
+  commitFile(projectCwd, 'src/bar.js', 'hello', 'unrelated later commit touching the declared path');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'failed', 'a genuine red gate must never become a heal candidate');
+  assert.equal(jobs[0].looksDone, undefined);
+  assert.equal(jobs[0].error, 'AC gate red: tests failed');
+});
+
+test('needs_review with an in-window commit heals exactly as today (regression — unchanged heal semantics)', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-heals-today');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-heals-today-slug');
+  writePrd(projectCwd, '20-clean-feature', [
+    '# Acceptance criteria',
+    '- [ ] `npm test` passes',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '20-clean-feature',
+      status: 'needs_review',
+      cwd: projectCwd,
+      runId: 'run-clean',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      verifierVerdict: 'transcript_errors',
+      error: 'transcript_errors: stale verdict',
+    },
+  ]);
+  writeRunLog('run-clean', '20-clean-feature', [
+    '[scheduler] starting 20-clean-feature',
+    JSON.stringify({
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'npm test' } }] },
+    }),
+    JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'all tests passed' }] },
+    }),
+    'SCHEDULER_VERDICT: PASS',
+    '[scheduler] exit code=0 (raw code=0 signal=null) duration=10s',
+  ]);
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed', 'a clean re-verify on a RESCANNABLE verdict must still heal');
+  assert.equal(jobs[0].verifierVerdict, undefined);
+  assert.equal(jobs[0].error, null);
+});
+
+test('computeLooksDone: no declared paths on the PRD → null, never fabricates evidence', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-no-paths');
+  initRepo(projectCwd);
+  writePrd(projectCwd, '09-no-paths', [
+    '# Implementation notes',
+    'Just prose here, no backticked file paths.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  await wait(1100);
+  commitFile(projectCwd, 'src/whatever.js', 'x', 'some later commit');
+
+  const job = { slug: '09-no-paths', cwd: projectCwd, startedAt };
+  const looksDone = await computeLooksDone(job);
+  assert.equal(looksDone, null);
+});
+
+test('computeLooksDone: non-git cwd → null without throwing (git-unavailable)', async () => {
+  const notARepo = fs.mkdtempSync(path.join(tmpHome, 'not-a-repo-'));
+  writePrd(notARepo, '11-no-repo', [
+    '# Implementation notes',
+    'Edit `src/thing.js`.',
+  ].join('\n'));
+
+  const job = { slug: '11-no-repo', cwd: notARepo, startedAt: new Date().toISOString() };
+  const looksDone = await computeLooksDone(job);
+  assert.equal(looksDone, null);
+});

package/src/main/__tests__/scheduler-prd-persona-spawn.test.cjs

@@ -0,0 +1,135 @@
+/**
+ * scheduler-prd-persona-spawn.test.cjs — PRD 1115: a PRD's `agentType`
+ * frontmatter must actually drive the headless spawn (--append-system-prompt
+ * with the persona's frontmatter-stripped, capped body, and --model with the
+ * persona's own model), not just sit in the prompt as prose the executor may
+ * or may not obey. Covers buildClaudeSpawnArgs' pure argv shape plus a real
+ * executeJob spawn (stub `claude` binary) proving the resolved persona
+ * actually reaches the child process, and that a dangling agentType still
+ * runs the job to completion (never parks or fails it).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-persona-spawn.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 buildClaudeSpawnArgs;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-spawn-'));
+  process.env.HOME = tmpHome;
+  ({ executeJob, buildClaudeSpawnArgs } = require('../scheduler.cjs'));
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+});
+
+// ---------- buildClaudeSpawnArgs: systemPrompt -> --append-system-prompt ----------
+
+test('buildClaudeSpawnArgs: a given systemPrompt is passed via --append-system-prompt', () => {
+  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'opus', sessionId: 'sid', resume: false, systemPrompt: 'You are dev-lead.' });
+  const idx = args.indexOf('--append-system-prompt');
+  expect(idx).toBeGreaterThanOrEqual(0);
+  expect(args[idx + 1]).toBe('You are dev-lead.');
+});
+
+test('buildClaudeSpawnArgs: omits --append-system-prompt entirely when systemPrompt is absent', () => {
+  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'sonnet', sessionId: 'sid', resume: false });
+  expect(args).not.toContain('--append-system-prompt');
+});
+
+test('buildClaudeSpawnArgs: model is never omitted even without a systemPrompt', () => {
+  const args = buildClaudeSpawnArgs({ prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false });
+  const idx = args.indexOf('--model');
+  expect(idx).toBeGreaterThanOrEqual(0);
+  expect(args[idx + 1]).toBe('sonnet');
+});
+
+// ---------- real spawn: persona actually reaches the child process ----------
+
+// Stub `claude` binary: dumps its own argv into a marker file, then emits a
+// stream-json success result and exits 0 — same technique as
+// scheduler-bash-timeout-env.test.cjs's env-var proof, applied to argv.
+function writeClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-argv-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const path = require('path');
+    fs.writeFileSync(path.join(process.cwd(), 'argv.marker'), JSON.stringify(process.argv.slice(2)), '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;
+}
+
+function writePersona(dir, name, frontmatterLines, bodyText) {
+  fs.mkdirSync(dir, { recursive: true });
+  const lines = ['---', `name: ${name}`, ...frontmatterLines, '---', bodyText];
+  fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
+}
+
+async function runJobWithAgentType({ agentType }) {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-main-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-persona-run-'));
+  const slug = `1115-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`), 'Do the thing.', 'utf8');
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+  const job = { slug, cwd: mainCwd, agentType };
+  const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
+  const argv = JSON.parse(fs.readFileSync(path.join(mainCwd, 'argv.marker'), 'utf8'));
+  fs.rmSync(mainCwd, { recursive: true, force: true });
+  fs.rmSync(runDir, { recursive: true, force: true });
+  return { result, argv };
+}
+
+test('executeJob: a resolvable agentType reaches the spawned child as --append-system-prompt + --model', async () => {
+  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
+  writePersona(globalAgentsDir, 'dev-lead', ['model: opus'], 'You are dev-lead. Ship it.');
+
+  const { result, argv } = await runJobWithAgentType({ agentType: 'dev-lead' });
+
+  expect(result.exitCode).toBe(0);
+  const spIdx = argv.indexOf('--append-system-prompt');
+  expect(spIdx).toBeGreaterThanOrEqual(0);
+  expect(argv[spIdx + 1]).toBe('You are dev-lead. Ship it.');
+  const modelIdx = argv.indexOf('--model');
+  expect(argv[modelIdx + 1]).toBe('opus');
+});
+
+test('executeJob: a dangling agentType (no resolvable persona file) still runs the job to completion, falling back to sonnet with no --append-system-prompt', async () => {
+  const { result, argv } = await runJobWithAgentType({ agentType: 'renamed-or-deleted-persona' });
+
+  expect(result.exitCode).toBe(0);
+  expect(argv).not.toContain('--append-system-prompt');
+  const modelIdx = argv.indexOf('--model');
+  expect(argv[modelIdx + 1]).toBe('sonnet');
+});
+
+test('executeJob: a job with no agentType at all runs unaffected (no persona, sonnet fallback)', async () => {
+  const { result, argv } = await runJobWithAgentType({ agentType: null });
+
+  expect(result.exitCode).toBe(0);
+  expect(argv).not.toContain('--append-system-prompt');
+  const modelIdx = argv.indexOf('--model');
+  expect(argv[modelIdx + 1]).toBe('sonnet');
+});