claude-code-session-manager 0.86.0 → 0.88.0

package/src/main/__tests__/queue-starvation-per-project.test.cjs

@@ -16,14 +16,21 @@
 
 'use strict';
 
-import { test } from 'vitest';
+import { test, afterAll } from 'vitest';
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
 // HOME before require: every state path is baked from os.homedir() at load.
-process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
+// beforeAll runs AFTER module evaluation, so this assignment must stay at
+// top level — see pollLoop-dispatch-on-failure.test.cjs:40-56 for the
+// beforeAll/afterAll pattern this restore mirrors.
+const originalHome = process.env.HOME;
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
+process.env.HOME = tmpHome;
+fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
 
 const {
   classifyQueueStarvation,
@@ -31,6 +38,11 @@ const {
   QUEUE_STARVATION_MS,
 } = require('../scheduler.cjs');
 
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
 const PROJECT_A = '/home/bilko/Projects/starry-night-ships';
 const PROJECT_B = '/home/bilko/Projects/session-manager';
 const NOW = Date.parse('2026-09-12T20:00:00.000Z');

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

@@ -53,11 +53,11 @@ beforeEach(() => {
   // Fresh require per test so HISTORY_PATH's target file starts clean.
   delete require.cache[require.resolve('../lib/queueHistory.cjs')];
   queueHistory = require('../lib/queueHistory.cjs');
-  try { fs.unlinkSync(queueHistory.HISTORY_PATH); } catch { /* ok if absent */ }
+  try { fs.unlinkSync(queueHistory.historyPath()); } catch { /* ok if absent */ }
 });
 
 afterEach(() => {
-  try { fs.unlinkSync(queueHistory.HISTORY_PATH); } catch { /* ok if absent */ }
+  try { fs.unlinkSync(queueHistory.historyPath()); } catch { /* ok if absent */ }
   if (prevOverride === undefined) delete process.env.SM_HISTORY_PATH_OVERRIDE;
   else process.env.SM_HISTORY_PATH_OVERRIDE = prevOverride;
 });
@@ -163,6 +163,25 @@ test('appendHistory dedupes by slug+runId against what is already on disk', asyn
   expect(read.length).toBe(1);
 });
 
+test('appendHistory: a needs_review ledger line and a terminal row sharing slug+runId do NOT dedupe against each other', async () => {
+  // An entry and its resolution line (needsReviewLedger.cjs) deliberately
+  // reference the SAME runId as each other — and a slug's terminal archive
+  // row can later reuse that same runId too (same run, different `kind`).
+  // jobKey must bucket by kind or the second/third write looks like a
+  // crash-replay of the first and silently never lands.
+  const entryLine = { kind: 'needs_review_entry', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
+  const resolutionLine = { kind: 'needs_review_resolution', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 1000 };
+  const terminalLine = old({ slug: 'ledger-dup', runId: 'shared-run' });
+  const r1 = await queueHistory.appendHistory([entryLine]);
+  const r2 = await queueHistory.appendHistory([resolutionLine]);
+  const r3 = await queueHistory.appendHistory([terminalLine]);
+  expect(r1.appended).toBe(1);
+  expect(r2.appended).toBe(1);
+  expect(r3.appended).toBe(1);
+  const read = await queueHistory.readHistory({ limit: 10 });
+  expect(read.filter((j) => j.slug === 'ledger-dup')).toHaveLength(3);
+});
+
 test('readHistory respects limit and returns [] when file is absent', async () => {
   const empty = await queueHistory.readHistory({ limit: 5 });
   expect(empty).toEqual([]);
@@ -220,6 +239,18 @@ test('selectHistoryJobs: default historyEntries=[] preserves old call shape', ()
   expect(merged.map((j) => j.slug)).toEqual(['01-fresh']);
 });
 
+test('selectHistoryJobs: needs_review ledger lines (kind !== "terminal") are excluded from the merged result', () => {
+  // The History view renders ScheduleJob-shaped rows (status, exitCode, ...)
+  // — a needs_review_entry/needs_review_resolution line (needsReviewLedger.cjs)
+  // has neither, and must not slip through as a statusless row in that table.
+  const { selectHistoryJobs } = require('../scheduler.cjs');
+  const terminalEntry = old({ slug: 'hist-1', runId: 'rhist1' });
+  const ledgerEntry = { kind: 'needs_review_entry', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
+  const ledgerResolution = { kind: 'needs_review_resolution', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 500 };
+  const merged = selectHistoryJobs([], 10, [terminalEntry, ledgerEntry, ledgerResolution]);
+  expect(merged.map((j) => j.slug)).toEqual(['hist-1']);
+});
+
 // ---------- historyTerminalBySlug ----------
 //
 // Guards against scheduler.cjs's reconcile() resurrecting an already-
@@ -258,6 +289,22 @@ test('historyTerminalBySlug: cache invalidates after a new appendHistory call (m
   expect(second.has('cache-2')).toBe(true);
 });
 
+test('historyTerminalBySlug: ignores needs_review ledger lines, even a LATER one for an already-terminal slug', async () => {
+  // Chronological order matters here: the terminal row lands first, and a
+  // needs_review_entry for the SAME slug (a later re-run parking again)
+  // lands after it. Without the kind guard, last-line-wins would replace
+  // the true 'completed' record with a status-less ledger row.
+  const terminal = old({ slug: 'mixed-1', status: 'completed', runId: 'rterm' });
+  await queueHistory.appendHistory([terminal]);
+  await queueHistory.appendHistory([{
+    kind: 'needs_review_entry', slug: 'mixed-1', runId: 'rlater', cwd: null,
+    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
+  }]);
+
+  const map = await queueHistory.historyTerminalBySlug();
+  expect(map.get('mixed-1')).toEqual({ status: 'completed', finishedAt: terminal.finishedAt, landedCommit: null });
+});
+
 // ---------- completedSlugsForCwd (PRD 1122) ----------
 //
 // Feeds scheduler.cjs's computeDepHistorySatisfaction: a dependsOn slug with
@@ -290,3 +337,19 @@ test('completedSlugsForCwd: returns an empty Set when the project has no history
   const slugs = await queueHistory.completedSlugsForCwd(freshCwd);
   expect(slugs.size).toBe(0);
 });
+
+test('completedSlugsForCwd: ignores needs_review ledger lines even when they are the newest line for a completed slug', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-ledger-'));
+  await queueHistory.appendHistory([
+    old({ slug: '900-base', status: 'completed', runId: 'ra', cwd: projectCwd }),
+  ]);
+  // A later needs_review park for a NEW run of the same slug must not blank
+  // out the earlier 'completed' record read by completedSlugsForCwd.
+  await queueHistory.appendHistory([{
+    kind: 'needs_review_entry', slug: '900-base', runId: 'rb', cwd: projectCwd,
+    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
+  }]);
+
+  const slugs = await queueHistory.completedSlugsForCwd(projectCwd);
+  expect(slugs.has('900-base')).toBe(true);
+});

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

@@ -4,9 +4,11 @@
  * pollLoop): the 'meter_rate_limited' branch used to never back off and
  * never call persistSchedulerState(), letting scheduler-state.json freeze
  * stale while the loop kept failing every POLL_INTERVAL_MS underneath it.
- * This suite covers the two pure pieces of the fix: the shared backoff
- * curve/cap (nextBackoffMs) and the once-per-streak WARN gate
- * (shouldWarnFailureStreak).
+ * This suite covers the pure pieces of the fix: the shared backoff
+ * curve/cap (nextBackoffMs), the once-per-streak WARN gate
+ * (shouldWarnFailureStreak), and the periodic escalation ladder that fires
+ * every FAILURE_STREAK_ESCALATION_MS while a streak PERSISTS past the
+ * initial WARN, re-arming once the streak clears (shouldEscalateFailureStreak).
  *
  * Run: timeout 120 npx vitest run src/main/__tests__/rateLimitPollerStreak.test.cjs
  */
@@ -17,8 +19,10 @@ import { test, expect } from 'vitest';
 const {
   nextBackoffMs,
   shouldWarnFailureStreak,
+  shouldEscalateFailureStreak,
   BACKOFF_MAX_MS,
   FAILURE_STREAK_WARN_THRESHOLD,
+  FAILURE_STREAK_ESCALATION_MS,
 } = require('../scheduler.cjs');
 
 test('nextBackoffMs starts at 30s from a zero/falsy backoff', () => {
@@ -77,3 +81,34 @@ test('shouldWarnFailureStreak respects a custom threshold', () => {
   expect(shouldWarnFailureStreak(3, false, 3)).toBe(true);
   expect(shouldWarnFailureStreak(2, false, 3)).toBe(false);
 });
+
+test('shouldEscalateFailureStreak: false below the WARN threshold, regardless of elapsed time', () => {
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD - 1, null, Date.now())).toBe(false);
+});
+
+test('shouldEscalateFailureStreak: fires immediately the first time (lastEscalatedAtMs null) once past the WARN threshold', () => {
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, Date.now())).toBe(true);
+});
+
+test('shouldEscalateFailureStreak: does not re-fire before FAILURE_STREAK_ESCALATION_MS has elapsed since the last one', () => {
+  const lastEscalatedAtMs = 1_000_000;
+  const tooSoon = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS - 1;
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, tooSoon)).toBe(false);
+});
+
+test('shouldEscalateFailureStreak: fires again once FAILURE_STREAK_ESCALATION_MS has elapsed — the persisting-streak ladder', () => {
+  const lastEscalatedAtMs = 1_000_000;
+  const dueNow = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS;
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, dueNow)).toBe(true);
+});
+
+test('shouldEscalateFailureStreak: re-arms after a streak clears (lastEscalatedAtMs reset to null) — a later independent streak escalates again', () => {
+  const firstStreakNow = 1_000_000;
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, firstStreakNow)).toBe(true);
+  // Streak clears (a success resets both failureStreakWarned and the
+  // escalation timestamp) — a LATER, independent streak crossing the WARN
+  // threshold again must escalate again immediately, not wait out a stale
+  // 30-minute window from the previous incident.
+  const laterStreakNow = firstStreakNow + 5 * 60_000; // well under 30 min later
+  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, laterStreakNow)).toBe(true);
+});

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

@@ -0,0 +1,135 @@
+/**
+ * reconcileTiming.test.cjs — proves reconcile() (src/main/scheduler.cjs)
+ * records a per-phase timing breakdown and emits exactly one warn-level
+ * `logs.writeLine` when a pass exceeds RECONCILE_SLOW_PASS_MS
+ * (src/main/lib/schedulerConfig.cjs), and stays silent on a normal-speed
+ * pass. Before this, diagnosing a slow reconcile pass (the
+ * "schedule.state timed out after 5000ms" toast) required hand-timing the
+ * filesystem scans from a throwaway script.
+ *
+ * HOME-isolated (mirrors reconcileFlatPrdSweep.test.cjs): stub HOME to a
+ * mkdtemp dir before requiring scheduler.cjs, and register the fixture
+ * project as "active" via a fake ~/.claude/projects transcript — reconcile's
+ * PRD discovery (prdLocations.cjs) only scans cwds it can find that way.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/reconcileTiming.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let scheduler;
+let queueHistory;
+let logs;
+let RECONCILE_SLOW_PASS_MS;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-timing-home-'));
+  process.env.HOME = tmpHome;
+
+  scheduler = require('../scheduler.cjs');
+  queueHistory = require('../lib/queueHistory.cjs');
+  logs = require('../logs.cjs');
+  ({ RECONCILE_SLOW_PASS_MS } = require('../lib/schedulerConfig.cjs'));
+
+  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+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 makeFixtureProject(prefix) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  registerActiveProject(cwd);
+  return cwd;
+}
+
+function writeCanonicalPrd(cwd, epicId, slug) {
+  const epicPrdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(epicPrdsDir, `${slug}.md`),
+    `---\ntitle: Timing fixture\ncwd: ${cwd}\nestimateMinutes: 10\nsourcePromptId: ${epicId}\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\n\nSomething.\n`,
+    'utf8',
+  );
+}
+
+function warnCallsMatching(spy) {
+  return spy.mock.calls
+    .map(([payload]) => payload)
+    .filter((payload) => payload?.level === 'warn' && payload?.scope === 'scheduler' && /reconcile\(\) pass took/.test(payload?.message ?? ''));
+}
+
+test('a normal-speed reconcile() pass logs nothing', async () => {
+  const cwd = makeFixtureProject('sm-reconcile-timing-fast-proj-');
+  writeCanonicalPrd(cwd, 'epic-fast', '1600-fast');
+
+  const writeLineSpy = vi.spyOn(logs, 'writeLine');
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await scheduler.reconcile(state);
+
+  expect(warnCallsMatching(writeLineSpy)).toHaveLength(0);
+});
+
+test('a slow reconcile() pass emits exactly one warn with the per-phase breakdown', async () => {
+  const cwd = makeFixtureProject('sm-reconcile-timing-slow-proj-');
+  writeCanonicalPrd(cwd, 'epic-slow', '1601-slow');
+
+  const realHistoryTerminalBySlug = queueHistory.historyTerminalBySlug.bind(queueHistory);
+  vi.spyOn(queueHistory, 'historyTerminalBySlug').mockImplementation(async (...args) => {
+    await new Promise((resolve) => { setTimeout(resolve, RECONCILE_SLOW_PASS_MS + 200); });
+    return realHistoryTerminalBySlug(...args);
+  });
+  const writeLineSpy = vi.spyOn(logs, 'writeLine');
+
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await scheduler.reconcile(state);
+
+  const warnCalls = warnCallsMatching(writeLineSpy);
+  expect(warnCalls).toHaveLength(1);
+  const { meta } = warnCalls[0];
+  expect(meta.totalMs).toBeGreaterThan(RECONCILE_SLOW_PASS_MS);
+  expect(meta.phaseMs).toHaveProperty('flatPrdSweep');
+  expect(meta.phaseMs).toHaveProperty('prdDirResolve');
+  expect(meta.phaseMs).toHaveProperty('parseLoop');
+  expect(meta.phaseMs).toHaveProperty('historyLookup');
+  expect(meta.phaseMs).toHaveProperty('queueWrite');
+  expect(meta.phaseMs.historyLookup).toBeGreaterThanOrEqual(RECONCILE_SLOW_PASS_MS);
+  expect(typeof meta.prdFileCount).toBe('number');
+  expect(typeof meta.resolvedDirCount).toBe('number');
+  expect(meta.prdFileCount).toBeGreaterThanOrEqual(1);
+}, 15_000);
+
+test('reconcile() surfaces its own error and does not swallow it while timing', async () => {
+  vi.spyOn(queueHistory, 'partitionJobs').mockImplementation(() => {
+    throw new Error('boom: injected failure for timing-swallow test');
+  });
+
+  const cwd = makeFixtureProject('sm-reconcile-timing-throw-proj-');
+  writeCanonicalPrd(cwd, 'epic-throw', '1602-throw');
+
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await expect(scheduler.reconcile(state)).rejects.toThrow('boom: injected failure for timing-swallow test');
+});

package/src/main/__tests__/runVerify-landed-commit-outranks.test.cjs

@@ -0,0 +1,181 @@
+/**
+ * runVerify-landed-commit-outranks.test.cjs — ground truth (exit 0 + a commit
+ * landed THIS run + no explicit FAIL sentinel) outranks the transcript-
+ * pattern heuristics (final-20% is_error, FAIL/Traceback,
+ * ModuleNotFoundError), so a self-recovered tool error no longer parks a
+ * green, committed run.
+ *
+ * Fixture: the REAL run log for 1218-fo-01-move-scripts-lib-into-src-main-lib
+ * (session-manager-operations/reviews/2026-09-13-scheduler-stability-
+ * investigation.md), copied verbatim from
+ * ~/.claude/session-manager/scheduled-plans/runs/2026-09-13T21-52-51-192Z/ —
+ * a `git apply` "patch does not apply" tool error at event 179/209 (inside
+ * the final 20% of the transcript) that the agent retried and resolved 3
+ * events later, in a run that landed commit d1edf15 and was STILL parked
+ * needs_review (verdicts.json: verdict transcript_errors, reason
+ * "is_error=true in final 20% of transcript (event 179/209)"), spawning a
+ * $3.74 fix-plan investigation into work that needed no fix.
+ *
+ * The real run's own SCHEDULER_VERDICT sentinel is an explicit FAIL — an
+ * honest, UNRELATED report that test:unit was red for proven pre-existing/
+ * environmental reasons (shared /tmp contention), not a regression from this
+ * PRD's move. Per this PRD's own AC, an explicit FAIL sentinel must keep
+ * today's behavior byte-for-byte, so scenarios (a)/(b)/(d) below use a
+ * variant of the fixture with that trailing SCHEDULER_VERDICT line stripped
+ * (sentinel === null) — the majority real-world park shape this rule targets
+ * (the findings report measured 77 of 212 parks as transcript_errors with NO
+ * sentinel at all, vs. this one specific row's own additional, unrelated
+ * FAIL claim). Scenario (c) reuses the pristine, byte-for-byte-unmodified
+ * fixture to prove the real, still-present FAIL sentinel is honored exactly
+ * as before this change.
+ *
+ * Run standalone: timeout 120 npx vitest run src/main/__tests__/runVerify-landed-commit-outranks.test.cjs
+ */
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { verifyRun } = require('../runVerify.cjs');
+
+const SLUG = '1218-fo-01-move-scripts-lib-into-src-main-lib';
+const FIXTURE_PATH = path.join(__dirname, 'fixtures', `${SLUG}.log`);
+const LANDED_COMMIT = 'd1edf15be50a783f08a55e6de328780f0feb3cb0';
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-landed-commit-outranks-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function makeTmpGitRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-landed-commit-outranks-repo-'));
+  execFileSync('git', ['init', '-q'], { cwd: dir });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: dir });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: dir });
+  fs.writeFileSync(path.join(dir, 'README.md'), 'init\n');
+  execFileSync('git', ['add', 'README.md'], { cwd: dir });
+  execFileSync('git', ['commit', '-q', '-m', 'init'], { cwd: dir });
+  return dir;
+}
+
+function writePrd(dir, slug) {
+  const text = '---\ntitle: Test PRD\ncwd: /tmp\nestimateMinutes: 30\n---\n# Move scripts/lib into src/main/lib\n';
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+  return path.join(dir, `${slug}.md`);
+}
+
+/**
+ * Load the real fixture log, optionally stripping the trailing
+ * `SCHEDULER_VERDICT: FAIL ...` line from the final `{"type":"result",...}`
+ * event's `result` field so the sentinel scan sees no sentinel at all.
+ */
+function loadFixture({ stripFailSentinel }) {
+  const raw = fs.readFileSync(FIXTURE_PATH, 'utf8');
+  if (!stripFailSentinel) return raw;
+  const lines = raw.split('\n');
+  const idx = lines.findIndex((l) => l.includes('"type":"result"'));
+  assert.ok(idx !== -1, 'fixture must contain a type:result line');
+  const obj = JSON.parse(lines[idx]);
+  assert.ok(/SCHEDULER_VERDICT:\s*FAIL/.test(obj.result), 'fixture result must carry the real FAIL sentinel before stripping');
+  obj.result = obj.result.replace(/\n?SCHEDULER_VERDICT:\s*FAIL[^\n]*$/, '');
+  assert.ok(!/SCHEDULER_VERDICT/.test(obj.result), 'sentinel must be fully removed from the stripped variant');
+  lines[idx] = JSON.stringify(obj);
+  return lines.join('\n');
+}
+
+function writeLog(dir, slug, text) {
+  fs.writeFileSync(path.join(dir, `${slug}.log`), text);
+}
+
+// (a) exit 0 + commit landed THIS run + no sentinel at all → clean, demoted to annotation.
+test('exit 0 + landed commit this run + no FAIL sentinel → clean with annotation (1218-fo-01)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'clean', `expected clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+    const sidecar = JSON.parse(fs.readFileSync(path.join(tmp, `${SLUG}.verdicts.json`), 'utf8'));
+    assert.ok(Array.isArray(sidecar.annotations) && sidecar.annotations.length > 0, 'the demoted is_error hit must be recorded as an annotation');
+    assert.ok(sidecar.annotations.some((a) => a.verdict === 'transcript_errors'), 'annotation must carry the original transcript_errors verdict');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (b) the same (stripped-sentinel) log, but exitCode !== 0 → keeps today's behavior.
+test('non-zero exit → transcript_errors (evidence never applies to a failing run)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 1,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (c) the pristine, byte-for-byte-unmodified fixture — its own real FAIL sentinel — keeps today's behavior.
+test('explicit FAIL sentinel (the real, unmodified fixture) → transcript_errors byte-for-byte', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: false }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+    assert.equal(verdict.sentinel, 'fail');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (d) no landed-commit evidence at all → transcript_errors (evidence gate requires attribution).
+test('no landed commit evidence → transcript_errors (evidence gate requires attribution)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: null,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally { rmdir(tmp); rmdir(repo); }
+});

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

@@ -1140,7 +1140,7 @@ function noOpRunEvents(resultText) {
 test('no_verdict_sentinel: no tool_result issues, no sentinel, no commit → needs_review', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui';
+    const slug = '406-capture-panel-ui';
     writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1160,7 +1160,7 @@ test('no_verdict_sentinel: no tool_result issues, no sentinel, no commit → nee
 test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays clean', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui-committed';
+    const slug = '406-capture-panel-ui-committed';
     writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1180,7 +1180,7 @@ test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays
 test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS sentinel + a commit → stays clean', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui-sentinel';
+    const slug = '406-capture-panel-ui-sentinel';
     writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1634,7 +1634,7 @@ test('isMergeMainSlug matches the NN-prXXX-merge-main and NN-fix-prXXX-merge-mai
   assert.equal(isMergeMainSlug('565-pr188-merge-main'), true);
   assert.equal(isMergeMainSlug('571-fix-pr141-merge-main'), true);
   assert.equal(isMergeMainSlug('523-fix-bounded-fix-plan-retry'), false);
-  assert.equal(isMergeMainSlug('406-browser-capture-panel-ui'), false);
+  assert.equal(isMergeMainSlug('406-capture-panel-ui'), false);
   assert.equal(isMergeMainSlug(''), false);
   assert.equal(isMergeMainSlug(undefined), false);
 });
@@ -1727,7 +1727,7 @@ test('merge-main exemption: gh call throws → falls through to pass_no_commit,
 test('merge-main exemption: non-merge-main slug never attempts a gh call', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui';
+    const slug = '406-capture-panel-ui';
     writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     let ghCalls = 0;

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

@@ -6,7 +6,7 @@
  * is types-only (erased at build time, nothing to import at test runtime), so
  * each consumer keeps its own hand-written mirror of the status enum:
  *   - src/preload/api.d.ts's `ScheduleJobStatus` union
- *   - src/renderer/components/ui/StatusBadge.tsx's `JobStatus` union
+ *   - src/renderer/lib/jobStatus.ts's `JobStatus` union
  *   - src/renderer/components/SchedulePanel.tsx's `FilterStatus` union
  *     (which also carries the UI-only 'all' meta-value)
  *
@@ -52,8 +52,8 @@ test('src/preload/api.d.ts ScheduleJobStatus matches JOB_STATUSES', () => {
   expect(sorted(values)).toEqual(sorted(JOB_STATUSES));
 });
 
-test('src/renderer/components/ui/StatusBadge.tsx JobStatus matches JOB_STATUSES', () => {
-  const source = readSource('src/renderer/components/ui/StatusBadge.tsx');
+test('src/renderer/lib/jobStatus.ts JobStatus matches JOB_STATUSES', () => {
+  const source = readSource('src/renderer/lib/jobStatus.ts');
   const values = extractQuotedList(source, /export type JobStatus = ([^\n]+)/);
   expect(sorted(values)).toEqual(sorted(JOB_STATUSES));
 });