claude-code-session-manager 0.76.0 → 0.77.0

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

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

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

@@ -142,11 +142,13 @@ test('falls back with a reason for a non-git cwd', async () => {
   expect(result.reason).toMatch(/not a git repository/);
 });
 
-test('falls back with a reason for a dirty base tree with a modified TRACKED file (never silently drops uncommitted human WIP)', async () => {
+test('a dirty tracked base file is carried into the worktree instead of disabling isolation (never silently drops uncommitted human WIP)', async () => {
   fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
   const result = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
-  expect(result.ok).toBe(false);
-  expect(result.reason).toMatch(/uncommitted changes/);
+  expect(result.ok).toBe(true);
+  expect(result.carriedPaths).toEqual(['README.md']);
+  expect(fs.readFileSync(path.join(result.dir, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
+  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
 });
 
 test('falls back once the concurrency cap is reached, and recovers after cleanup', async () => {

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

@@ -0,0 +1,73 @@
+/**
+ * landedSinceRun.test.cjs — the widened, path-scoped commit evidence helper
+ * behind reverifyNeedsReview's looksDone annotation (PRD 1102).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/landedSinceRun.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+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 { landedSinceRun } = require('../landedSinceRun.cjs');
+
+function mkRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-since-run-'));
+  execFileSync('git', ['-C', dir, 'init', '-q']);
+  execFileSync('git', ['-C', dir, 'config', 'user.email', 'test@test.com']);
+  execFileSync('git', ['-C', dir, 'config', 'user.name', 'Test']);
+  return dir;
+}
+
+function commitFile(dir, relPath, content, message) {
+  const abs = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+  execFileSync('git', ['-C', dir, 'add', relPath]);
+  execFileSync('git', ['-C', dir, 'commit', '-q', '-m', message]);
+}
+
+test('finds a commit landed after sinceIso that touches a declared path', async () => {
+  const dir = mkRepo();
+  const since = new Date().toISOString();
+  await new Promise((r) => setTimeout(r, 1100)); // git --since has 1s resolution
+  commitFile(dir, 'src/foo.js', 'hello', 'touch foo');
+  const shas = await landedSinceRun(dir, since, ['src/foo.js']);
+  assert.strictEqual(shas.length, 1);
+});
+
+test('ignores a commit that does not touch any declared path', async () => {
+  const dir = mkRepo();
+  const since = new Date().toISOString();
+  await new Promise((r) => setTimeout(r, 1100));
+  commitFile(dir, 'src/unrelated.js', 'hello', 'touch unrelated');
+  const shas = await landedSinceRun(dir, since, ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('empty paths never fabricates evidence — resolves []', async () => {
+  const dir = mkRepo();
+  commitFile(dir, 'src/foo.js', 'hello', 'touch foo');
+  const shas = await landedSinceRun(dir, new Date(0).toISOString(), []);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('no cwd resolves [] without throwing', async () => {
+  const shas = await landedSinceRun(null, new Date().toISOString(), ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('git-unavailable (non-repo cwd) resolves [] without throwing', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-since-run-norepo-'));
+  const shas = await landedSinceRun(dir, new Date().toISOString(), ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('has a bounded default timeout', () => {
+  const { LANDED_SINCE_RUN_TIMEOUT_MS } = require('../landedSinceRun.cjs');
+  assert.ok(LANDED_SINCE_RUN_TIMEOUT_MS > 0 && LANDED_SINCE_RUN_TIMEOUT_MS <= 60_000);
+});

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

@@ -0,0 +1,220 @@
+/**
+ * launchFailure.test.cjs — the non-run classifier + launch circuit breaker
+ * behind GitHub issue #11 (macOS, 2026-09-02): an outdated Claude CLI sent
+ * `thinking.type.enabled`, the API answered HTTP 400 on the first request,
+ * and 12 of 41 runs in one project were recorded as `failed` with
+ * `error: null` and then investigated by a probe that died the same way.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/launchFailure.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const lf = require('../launchFailure.cjs');
+
+// Verbatim shape from the issue-#11 transcript (2c3cd24f-…ccf0eb290fff.jsonl):
+// a single assistant entry that IS the raw API error, then the result event.
+const THINKING_400_RESULT = {
+  type: 'result', subtype: 'error', is_error: true, api_error_status: 400, num_turns: 1,
+  duration_ms: 23811, total_cost_usd: 0,
+  usage: { input_tokens: 0, output_tokens: 0 },
+  result: '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.\\"}"}}',
+};
+
+const REAL_WORK_FAILURE = {
+  type: 'result', subtype: 'error', is_error: true, num_turns: 19,
+  usage: { input_tokens: 4000, output_tokens: 2200 },
+  result: 'Error: expected 2 but got 3\n  at test/foo.test.ts:12:5', terminal_reason: 'error_max_turns',
+};
+
+function tmpLog(lines) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-launch-'));
+  const p = path.join(dir, 'run.log');
+  fs.writeFileSync(p, lines.map((l) => (typeof l === 'string' ? l : JSON.stringify(l))).join('\n') + '\n');
+  return p;
+}
+
+test('parseResultEvent: flattens the last result event with turns/tokens/status', () => {
+  const r = lf.parseResultEvent([
+    '[scheduler] starting foo',
+    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'API Error: 400 …' }] } }),
+    JSON.stringify(THINKING_400_RESULT),
+  ].join('\n'));
+  expect(r).toMatchObject({ subtype: 'error', isError: true, numTurns: 1, outputTokens: 0, apiErrorStatus: 400 });
+  expect(r.resultText).toMatch(/thinking\.type\.enabled/);
+});
+
+test('parseResultEvent: null when no result event exists (process died first)', () => {
+  expect(lf.parseResultEvent('[scheduler] starting\n{"type":"system","subtype":"init"}\n')).toBeNull();
+  expect(lf.parseResultEvent('')).toBeNull();
+});
+
+test('classifyLaunchFailure: the issue-#11 thinking 400 → model_config_rejected with the API message', () => {
+  const c = lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(THINKING_400_RESULT)));
+  expect(c).not.toBeNull();
+  expect(c.kind).toBe('model_config_rejected');
+  expect(c.httpStatus).toBe(400);
+  expect(c.message).toMatch(/thinking\.type\.enabled.*not supported for this model/);
+  expect(c.message).not.toMatch(/^API Error/);
+});
+
+test('classifyLaunchFailure: a run that took real turns is NEVER a launch failure, even with API Error text', () => {
+  expect(lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(REAL_WORK_FAILURE)))).toBeNull();
+  const lateApiError = { ...THINKING_400_RESULT, num_turns: 7, usage: { output_tokens: 900 } };
+  expect(lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(lateApiError)))).toBeNull();
+});
+
+test('classifyLaunchFailure: zero-turn failure WITHOUT the API Error marker is not classified (someone else owns it)', () => {
+  const r = lf.parseResultEvent(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, num_turns: 1, usage: { output_tokens: 0 }, result: 'Invalid prompt' }));
+  expect(lf.classifyLaunchFailure(r)).toBeNull();
+});
+
+test('classifyLaunchFailure: 429 is left to the rate-limit path', () => {
+  const r = lf.parseResultEvent(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, api_error_status: 429, num_turns: 1, usage: { output_tokens: 0 }, result: 'API Error: 429 {"error":{"message":"rate limited"}}' }));
+  expect(lf.classifyLaunchFailure(r)).toBeNull();
+});
+
+test('classifyLaunchFailure: status → kind mapping', () => {
+  const mk = (status, text) => lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify({
+    type: 'result', subtype: 'error', is_error: true, num_turns: 1, usage: { output_tokens: 0 }, result: `API Error: ${status} ${text}`,
+  })));
+  expect(mk(401, '{"error":{"message":"invalid x-api-key"}}').kind).toBe('auth_failed');
+  expect(mk(403, '{"error":{"message":"forbidden"}}').kind).toBe('auth_failed');
+  expect(mk(404, '{"error":{"message":"model: claude-x not found"}}').kind).toBe('model_not_found');
+  expect(mk(400, '{"error":{"message":"max_tokens must be > 0"}}').kind).toBe('bad_request');
+  expect(mk(529, '{"error":{"type":"overloaded_error","message":"Overloaded"}}').kind).toBe('api_overloaded');
+  expect(mk(500, '{"error":{"message":"internal"}}').kind).toBe('api_overloaded');
+  expect(mk(418, 'teapot').kind).toBe('api_error');
+  expect(mk(401, '{"error":{"message":"invalid x-api-key"}}').message).toBe('invalid x-api-key');
+});
+
+test('readResultEvent + classify on a real log tail (scheduler log lines interleaved)', () => {
+  const p = tmpLog([
+    '[scheduler] starting 04-fix-cdp at 2026-09-02T17:54:14.770Z',
+    { type: 'system', subtype: 'init', session_id: 'x' },
+    { type: 'user', message: { content: [{ type: 'text', text: 'PRD body' }] } },
+    { type: 'assistant', message: { content: [{ type: 'text', text: 'API Error: 400 …' }] } },
+    THINKING_400_RESULT,
+    '[scheduler] exit code=1 (raw code=1 signal=null) duration=25s',
+  ]);
+  try {
+    const r = lf.readResultEvent(p);
+    expect(lf.classifyLaunchFailure(r)?.kind).toBe('model_config_rejected');
+    expect(lf.resultShowsRealTurn(r)).toBe(false);
+  } finally {
+    fs.rmSync(path.dirname(p), { recursive: true, force: true });
+  }
+});
+
+test('resultShowsRealTurn: true once a turn or any output token happened', () => {
+  expect(lf.resultShowsRealTurn({ numTurns: 1, outputTokens: 0 })).toBe(false);
+  expect(lf.resultShowsRealTurn({ numTurns: 2, outputTokens: 0 })).toBe(true);
+  expect(lf.resultShowsRealTurn({ numTurns: 1, outputTokens: 12 })).toBe(true);
+  expect(lf.resultShowsRealTurn(null)).toBe(false);
+});
+
+// ─── circuit breaker ────────────────────────────────────────────────────────
+
+const T0 = Date.parse('2026-09-02T18:00:00Z');
+
+test('armLaunchBlock: first failure opens with the kind backoff, a mitigation env, and an operator hint', () => {
+  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', httpStatus: 400, message: 'm', now: T0, claudeVersion: '1.0.90', slug: 'a', runId: 'r1' });
+  expect(b.attempts).toBe(1);
+  expect(b.exhausted).toBe(false);
+  expect(Date.parse(b.until) - T0).toBe(lf.backoffMsFor('model_config_rejected', 1));
+  expect(b.mitigationEnv).toEqual({ MAX_THINKING_TOKENS: '0' });
+  expect(b.hint).toMatch(/claude update/);
+  expect(b.claudeVersion).toBe('1.0.90');
+  expect(b.probing).toBeNull();
+});
+
+test('armLaunchBlock: repeated same-kind failures escalate, cap at 60 min, then exhaust (until=null)', () => {
+  let b = null;
+  const seen = [];
+  for (let i = 0; i < lf.LAUNCH_BLOCK_MAX_ATTEMPTS; i++) {
+    b = lf.armLaunchBlock(b, { kind: 'api_error', message: 'x', now: T0 + i * 1000 });
+    seen.push(b.until ? Date.parse(b.until) - (T0 + i * 1000) : null);
+  }
+  expect(b.attempts).toBe(lf.LAUNCH_BLOCK_MAX_ATTEMPTS);
+  expect(b.exhausted).toBe(true);
+  expect(b.until).toBeNull();
+  const finite = seen.filter((x) => x !== null);
+  for (let i = 1; i < finite.length; i++) expect(finite[i]).toBeGreaterThanOrEqual(finite[i - 1]);
+  expect(Math.max(...finite)).toBeLessThanOrEqual(60 * 60_000);
+  expect(b.since).toBe(new Date(T0).toISOString()); // first-failure time survives re-arming
+});
+
+test('armLaunchBlock: a different kind restarts the attempt count', () => {
+  const a = lf.armLaunchBlock(null, { kind: 'api_overloaded', message: 'x', now: T0 });
+  const b = lf.armLaunchBlock(a, { kind: 'api_overloaded', message: 'x', now: T0 + 1 });
+  const c = lf.armLaunchBlock(b, { kind: 'auth_failed', message: 'y', now: T0 + 2 });
+  expect(b.attempts).toBe(2);
+  expect(c.attempts).toBe(1);
+  expect(c.mitigationEnv).toBeNull();
+});
+
+test('evaluateLaunchGate: open → blocked during backoff → probe after → blocked while a probe is in flight', () => {
+  expect(lf.evaluateLaunchGate(null, { now: T0 }).state).toBe('open');
+  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: '1.0.90' });
+  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: '1.0.90' }).state).toBe('blocked');
+  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000 }).reason).toMatch(/re-probe in \d+ min/);
+  const afterBackoff = Date.parse(b.until) + 1;
+  expect(lf.evaluateLaunchGate(b, { now: afterBackoff, claudeVersion: '1.0.90' }).state).toBe('probe');
+  const probing = { ...b, probing: { slug: 'p', at: new Date(afterBackoff).toISOString() } };
+  const g = lf.evaluateLaunchGate(probing, { now: afterBackoff + 60_000, claudeVersion: '1.0.90' });
+  expect(g.state).toBe('blocked');
+  expect(g.reason).toMatch(/probe p in flight/);
+  // a probe that never reported back goes stale and the gate re-opens to a new probe
+  expect(lf.evaluateLaunchGate(probing, { now: afterBackoff + lf.LAUNCH_PROBE_STALE_MS + 1, claudeVersion: '1.0.90' }).state).toBe('probe');
+});
+
+test('evaluateLaunchGate: a CLI version change short-circuits the backoff (the real fix for issue #11)', () => {
+  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: '1.0.90' });
+  const g = lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: '1.0.128' });
+  expect(g.state).toBe('open');
+  expect(g.reason).toMatch(/cli-version-changed/);
+  // unknown current version (probe failed) → no shortcut, backoff still holds
+  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: null }).state).toBe('blocked');
+});
+
+test('evaluateLaunchGate: an exhausted block stays blocked until version change', () => {
+  let b = null;
+  for (let i = 0; i < lf.LAUNCH_BLOCK_MAX_ATTEMPTS; i++) b = lf.armLaunchBlock(b, { kind: 'auth_failed', message: 'x', now: T0, claudeVersion: 'v1' });
+  expect(lf.evaluateLaunchGate(b, { now: T0 + 365 * 24 * 3600_000, claudeVersion: 'v1' }).state).toBe('blocked');
+  expect(lf.evaluateLaunchGate(b, { now: T0 + 1, claudeVersion: 'v2' }).state).toBe('open');
+});
+
+test('launchBlockKeyFor: persona is the key, default when absent', () => {
+  expect(lf.launchBlockKeyFor({ agentType: 'dev-lead' })).toBe('dev-lead');
+  expect(lf.launchBlockKeyFor({})).toBe('default');
+  expect(lf.launchBlockKeyFor(null)).toBe('default');
+});
+
+test('deriveTerminalReason: closed-set taxonomy', () => {
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'completed', exitCode: 0 })).toBe('completed');
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'failed', exitCode: 1 })).toBe('impl_failed:exit_1');
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'failed', exitCode: 143 })).toBe('signal_kill');
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 143, sigtermOverride: { status: 'needs_review' } })).toBe('signal_kill_with_commit');
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 0, verifyResult: { verdict: 'silent_no_op' } })).toBe('verifier:silent_no_op');
+  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 0, worktreeIntegrationFailure: 'conflict' })).toBe('worktree_integration_failed');
+});
+
+test('writeOutcomeSidecar: writes <slug>.outcome.json atomically and never throws on a bad dir', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-outcome-'));
+  try {
+    const p = lf.writeOutcomeSidecar(dir, '12-foo', { numTurns: 1, outputTokens: 0, terminalReason: 'launch_failure:model_config_rejected' });
+    expect(p).toBe(path.join(dir, '12-foo.outcome.json'));
+    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+    expect(parsed).toMatchObject({ slug: '12-foo', numTurns: 1, outputTokens: 0, terminalReason: 'launch_failure:model_config_rejected' });
+    expect(parsed.writtenAt).toMatch(/^\d{4}-/);
+    expect(fs.existsSync(`${p}.tmp`)).toBe(false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  expect(lf.writeOutcomeSidecar('/nonexistent/dir/for/sure', 'x', {})).toBeNull();
+  expect(lf.writeOutcomeSidecar(null, 'x', {})).toBeNull();
+});

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

@@ -83,6 +83,7 @@ test('MCP_RECIPES covers queue-work, unstick-needs-review, and hand-off-to-anoth
   expect(ids).toContain('queue-work-via-develop');
   expect(ids).toContain('unstick-needs-review-job');
   expect(ids).toContain('hand-finding-to-another-project');
+  expect(ids).toContain('generate-project-home');
   for (const recipe of MCP_RECIPES) {
     expect(recipe.title).toBeTruthy();
     expect(Array.isArray(recipe.steps)).toBe(true);

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

@@ -27,6 +27,12 @@ test('the owner of a namespace may write it', () => {
   assert.equal(checkOpsWrite(`${P}/prompt-sessions/active-index.json`, 'epics').ok, true);
   assert.equal(checkOpsWrite(`${P}/scheduler/state/queue.json`, 'scheduler').ok, true);
   assert.equal(checkOpsWrite(`${P}/project-brief/brief.json`, 'project-home').ok, true);
+  // project-pages: declared owner is 'project-home', same as project-brief —
+  // this governs only the app's own /admin/project-home/render write path
+  // (config.cjs), NOT a project-home-builder Epic's own Write-tool authoring
+  // of summary.json/picks.json, which never goes through config.cjs at all
+  // and so is unaffected by this table either way (see project-pages/README.md).
+  assert.equal(checkOpsWrite(`${P}/project-pages/output/manifest.json`, 'project-home').ok, true);
 });
 
 test('a non-owner is refused, and the error names the owner', () => {
@@ -36,6 +42,7 @@ test('a non-owner is refused, and the error names the owner', () => {
   // The exact cross-write this law exists to prevent: another surface
   // rewriting the Epic store out from under Epics.
   assert.equal(checkOpsWrite(`${P}/prompt-sessions/psess-1.json`, 'scheduler').ok, false);
+  assert.equal(checkOpsWrite(`${P}/project-pages/output/manifest.json`, 'scheduler').ok, false);
 });
 
 test('an undeclared writer is refused (fail-closed)', () => {

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

@@ -0,0 +1,82 @@
+/**
+ * prdDeclaredPaths.test.cjs — extracting a PRD's declared file paths for the
+ * reverify self-heal pass's widened evidence window (PRD 1102).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/prdDeclaredPaths.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { extractDeclaredPaths, declaredPathsForPrd } = require('../prdDeclaredPaths.cjs');
+
+test('extracts backtick-quoted paths from Implementation notes', () => {
+  const body = [
+    '# Implementation notes',
+    '',
+    'Edit `src/main/scheduler.cjs` and `src/main/lib/gitWorktree.cjs`.',
+    '',
+    '# Out of scope',
+    'Do not touch `src/main/should-not-appear.cjs` here.',
+  ].join('\n');
+  const paths = extractDeclaredPaths(body);
+  assert.deepStrictEqual(paths, ['src/main/scheduler.cjs', 'src/main/lib/gitWorktree.cjs']);
+});
+
+test('extracts paths from Acceptance criteria and strips trailing :line', () => {
+  const body = [
+    '# Acceptance criteria',
+    '- [ ] Fix the bug in `src/main/scheduler.cjs:490`',
+  ].join('\n');
+  assert.deepStrictEqual(extractDeclaredPaths(body), ['src/main/scheduler.cjs']);
+});
+
+test('dedupes paths mentioned in both sections', () => {
+  const body = [
+    '# Acceptance criteria',
+    '- [ ] Fix `src/main/scheduler.cjs`',
+    '# Implementation notes',
+    'See `src/main/scheduler.cjs` again.',
+  ].join('\n');
+  assert.deepStrictEqual(extractDeclaredPaths(body), ['src/main/scheduler.cjs']);
+});
+
+test('never fabricates a path — no match anywhere returns []', () => {
+  const body = [
+    '# Implementation notes',
+    'Just prose, no backticked paths here.',
+    '# Acceptance criteria',
+    '- [ ] npm run typecheck passes',
+  ].join('\n');
+  assert.deepStrictEqual(extractDeclaredPaths(body), []);
+});
+
+test('empty/non-string body returns []', () => {
+  assert.deepStrictEqual(extractDeclaredPaths(''), []);
+  assert.deepStrictEqual(extractDeclaredPaths(null), []);
+});
+
+test('declaredPathsForPrd reads a real file and strips frontmatter', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'prd-declared-paths-'));
+  const prdPath = path.join(dir, '01-test.md');
+  fs.writeFileSync(prdPath, [
+    '---',
+    'title: Test',
+    '---',
+    '# Implementation notes',
+    'Touch `src/main/scheduler.cjs`.',
+  ].join('\n'));
+  assert.deepStrictEqual(declaredPathsForPrd(prdPath), ['src/main/scheduler.cjs']);
+});
+
+test('declaredPathsForPrd on a missing file returns [] without throwing', () => {
+  assert.deepStrictEqual(declaredPathsForPrd('/nonexistent/path/does-not-exist.md'), []);
+});
+
+test('declaredPathsForPrd with null path returns []', () => {
+  assert.deepStrictEqual(declaredPathsForPrd(null), []);
+});

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

@@ -0,0 +1,58 @@
+/**
+ * queueHealth.test.cjs — computeQueueHealth: the pure per-project rollup
+ * behind the periodic queue-health sweep (PRD 1109).
+ *
+ * Pure helper, no electron import — mirrors reaperHelpers.test.cjs's pattern
+ * so it never needs scheduler.cjs's mocked IPC surface.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/queueHealth.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const { computeQueueHealth } = require('../queueHealth.cjs');
+
+test('counts never_ran, looksDone, and stuck per project cwd', () => {
+  const jobs = [
+    { slug: 'a', cwd: '/proj-1', status: 'failed', gateOutcome: 'never_ran' },
+    { slug: 'b', cwd: '/proj-1', status: 'failed', looksDone: { commits: ['abc1234'] } },
+    { slug: 'c', cwd: '/proj-1', status: 'needs_review' },
+    { slug: 'd', cwd: '/proj-2', status: 'quarantined' },
+  ];
+  const rollup = computeQueueHealth(jobs);
+  const byProj = Object.fromEntries(rollup.map((r) => [r.cwd, r]));
+  assert.deepStrictEqual(byProj['/proj-1'], { cwd: '/proj-1', neverRan: 1, looksDone: 1, stuck: 1 });
+  assert.deepStrictEqual(byProj['/proj-2'], { cwd: '/proj-2', neverRan: 0, looksDone: 0, stuck: 1 });
+});
+
+test('a project with zero drift across all three counters is omitted entirely', () => {
+  const jobs = [
+    { slug: 'clean', cwd: '/proj-clean', status: 'completed' },
+    { slug: 'running', cwd: '/proj-clean', status: 'running' },
+    { slug: 'pending', cwd: '/proj-clean', status: 'pending' },
+  ];
+  assert.deepStrictEqual(computeQueueHealth(jobs), []);
+});
+
+test('gateOutcome values other than never_ran do not count', () => {
+  const jobs = [
+    { slug: 'a', cwd: '/proj', status: 'completed', gateOutcome: 'passed' },
+    { slug: 'b', cwd: '/proj', status: 'failed', gateOutcome: 'failed' },
+    { slug: 'c', cwd: '/proj', status: 'failed', gateOutcome: 'unknown' },
+  ];
+  assert.deepStrictEqual(computeQueueHealth(jobs), []);
+});
+
+test('empty/missing jobs array is handled without throwing', () => {
+  assert.deepStrictEqual(computeQueueHealth([]), []);
+  assert.deepStrictEqual(computeQueueHealth(undefined), []);
+});
+
+test('is a pure read: never mutates the input jobs array or its rows', () => {
+  const jobs = [{ slug: 'a', cwd: '/proj', status: 'needs_review', gateOutcome: 'never_ran' }];
+  const snapshot = JSON.parse(JSON.stringify(jobs));
+  computeQueueHealth(jobs);
+  assert.deepStrictEqual(jobs, snapshot);
+});