claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-inplace-salvage.test.cjs

@@ -1,323 +0,0 @@
-/**
- * scheduler-inplace-salvage.test.cjs — PRD 1098: an in-place run (no
- * worktree — SM_JOB_WORKTREE_DISABLE=1 here, but the same finally-block path
- * also covers a non-git cwd, the worktree cap, or a carry-over failure) must
- * still salvage its uncommitted work, exactly like the worktree path already
- * did (gitWorktreeSalvage.test.cjs), and regardless of exit code. Drives
- * spawnJob end-to-end against a real git fixture repo with a stub `claude`
- * binary (SM_CLAUDE_BIN, same pattern as scheduler-worktree-exec-cwd.test.cjs)
- * that dirties the tree then exits 137 (SIGKILL), simulating a job killed
- * mid-run before its finish-protocol commit.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-inplace-salvage.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-const { execFileSync } = require('node:child_process');
-
-let tmpHome;
-let originalHome;
-let originalDisable;
-let spawnJob;
-let RUNS_DIR;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-// readQueue()'s per-project discovery walks ~/.claude/projects/*/*.jsonl
-// transcripts for a `cwd` field to find known project queue.json shards — an
-// unregistered project's queue.json is invisible to mutate()/readQueue() and
-// silently never gets written back to. Same helper scheduler-reap-dead-
-// running-jobs.test.cjs uses.
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-// Every PRD fixture below lives Epic-scoped, not in the legacy flat prds/
-// dir: the flat dir is retired and swept into prds-archived/ by
-// consolidateFlatPrds the moment a job is no longer pending/running, which
-// would strand a just-completed/failed row the instant reconcile()'s
-// auto-archive-drop path (see scheduler-reconcile-history-backfill.test.cjs)
-// treats the now-missing PRD as "archived on purpose" and drops it.
-function writeProjectQueue(cwd, jobs) {
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
-  return path.join(stateDir, 'queue.json');
-}
-
-// Stub `claude` binary: dirties the repo it runs in (a tracked-file edit and
-// a brand-new untracked file — this job's own delta) then exits 137, with NO
-// result:success event — simulating a job SIGKILLed mid-run before its
-// finish-protocol commit. Deliberately emits no success result: scheduler.cjs
-// maps a killed process straight back to exitCode 0 when it already saw
-// result:success (the intentional "cleanup hung after real success" case),
-// which is not the scenario under test here — this must land as a genuine
-// non-zero exit.
-function writeKilledClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'README.md'), 'hello\\nedited by job\\n', 'utf8');
-    fs.writeFileSync(path.join(process.cwd(), 'job-output.txt'), 'work the job produced before dying\\n', 'utf8');
-    process.exit(137);
-  ` });
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-'));
-  process.env.HOME = tmpHome;
-  originalDisable = process.env.SM_JOB_WORKTREE_DISABLE;
-  // Force the in-place path deterministically — this test is about the
-  // salvage-on-every-exit-code behaviour, not about which condition
-  // triggered the fallback (not-a-repo / cap / carry-over failure all land
-  // in the same else branch).
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  ({ spawnJob, RUNS_DIR } = require('../scheduler.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
-  else process.env.SM_JOB_WORKTREE_DISABLE = originalDisable;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-test('an in-place job killed (exit 137) mid-run salvages a delta-scoped patch that applies cleanly, without disturbing pre-existing WIP', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  // Pre-existing human WIP untouched by the job — must survive completely
-  // unmodified, and must never appear in the job's salvage patch.
-  fs.writeFileSync(path.join(projectCwd, 'human-wip.txt'), 'human work in progress\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  // Leave it staged-but-uncommitted (real dirty WIP), not committed.
-  fs.appendFileSync(path.join(projectCwd, 'human-wip.txt'), 'more human edits\n', 'utf8');
-
-  const slug = `1098-test-inplace-killed-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do a thing that gets killed mid-run.', 'utf8');
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'pending', cwd: projectCwd },
-  ]);
-
-  const statusBefore = git(['status', '--porcelain'], projectCwd);
-  const stashBefore = git(['stash', 'list'], projectCwd);
-
-  process.env.SM_CLAUDE_BIN = writeKilledClaudeStub();
-
-  const runId = `run-${slug}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-
-  try {
-    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const row = jobs.find((j) => j.slug === slug);
-    expect(row).toBeTruthy();
-    expect(row.exitCode).toBe(137);
-    expect(row.salvagePatch).toBeTruthy();
-    expect(fs.existsSync(row.salvagePatch)).toBe(true);
-
-    // Leftover-attribution fields: this job's own delta (README.md +
-    // job-output.txt), never the human's pre-existing baseline WIP.
-    expect(row.leftoverCount).toBe(2);
-    expect(new Set(row.leftoverPaths)).toEqual(new Set(['README.md', 'job-output.txt']));
-    // The pre-run baseline is cleared once the run has finalized — it was
-    // only ever needed to compute the delta above.
-    expect(row.guardBaseline).toBeUndefined();
-    expect(row.guardHeadBefore).toBeUndefined();
-
-    const patch = fs.readFileSync(row.salvagePatch, 'utf8');
-    expect(patch).toContain('README.md');
-    expect(patch).toContain('edited by job');
-    expect(patch).toContain('job-output.txt');
-    expect(patch).toContain('work the job produced before dying');
-    // The human's pre-existing WIP (baseline-dirty, not part of this job's
-    // delta) must never leak into the job's salvage patch.
-    expect(patch).not.toContain('more human edits');
-
-    // The patch must be self-sufficient and apply cleanly against a clean
-    // checkout of the same base commit.
-    const cleanCheckout = path.join(os.tmpdir(), `sm-inplace-salvage-clean-${process.pid}-${Math.floor(Math.random() * 1e6)}`);
-    git(['clone', '-q', projectCwd, cleanCheckout], os.tmpdir());
-    try {
-      expect(() => git(['apply', '--check', row.salvagePatch], cleanCheckout)).not.toThrow();
-    } finally {
-      fs.rmSync(cleanCheckout, { recursive: true, force: true });
-    }
-
-    // The shared tree itself was never mutated by the salvage pass — no
-    // add/stash/reset/checkout/clean. (The job's own dirtying of README.md
-    // and job-output.txt is real, expected, working-tree state left by the
-    // stub process itself, not something salvage did — so we only assert no
-    // stash was created and the human's pre-existing WIP file is untouched.)
-    const stashAfter = git(['stash', 'list'], projectCwd);
-    expect(stashAfter).toBe(stashBefore);
-    const humanWipContent = fs.readFileSync(path.join(projectCwd, 'human-wip.txt'), 'utf8');
-    expect(humanWipContent).toBe('human work in progress\nmore human edits\n');
-    void statusBefore; // baseline captured for readability of intent above
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);
-
-// Stub `claude` binary: touches nothing, emits a success result, and exits 0
-// — a job whose only working-tree dirt is pre-existing human/sibling WIP
-// present before the run even started.
-function writeNoopClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'nothing to do', is_error: false }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-// Stub `claude` binary that blocks until a `go` marker file appears in its
-// cwd (polled), THEN emits a success result and exits 0 — gives the test a
-// window to read the queue row's intermediate dispatchPhase before the run
-// finalizes and deletes it.
-function writeGatedClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    const { execFileSync } = require('child_process');
-    // spawnJob's dispatch path probes 'claude --version' (claudeBin.cjs)
-    // BEFORE the real dispatch — a real claude binary answers that
-    // near-instantly regardless of any in-flight work, so the stub must
-    // too, or the probe's own 8s exec timeout eats almost this whole test's
-    // poll window before the row ever advances past 'running-stamped'.
-    if (process.argv.includes('--version')) {
-      process.stdout.write('1.0.0 (stub)\\n');
-      process.exit(0);
-    }
-    const goFile = path.join(process.cwd(), 'go.marker');
-    const deadline = Date.now() + 10_000;
-    while (!fs.existsSync(goFile) && Date.now() < deadline) {
-      try { execFileSync('sleep', ['0.02']); } catch {}
-    }
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok', is_error: false }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-test('dispatchPhase breadcrumb advances to "spawned" mid-run and is gone after finalize', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  const slug = `1163-test-dispatchphase-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do a thing, gated on a marker file.', 'utf8');
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'pending', cwd: projectCwd },
-  ]);
-
-  process.env.SM_CLAUDE_BIN = writeGatedClaudeStub();
-
-  const runId = `run-${slug}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-
-  const readRow = () => JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs.find((j) => j.slug === slug);
-
-  try {
-    const spawnPromise = spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
-
-    // Poll the row until dispatchPhase reaches 'spawned' (the onPid mutate),
-    // proving the breadcrumb advanced through the dispatch region while the
-    // stub is deliberately blocked mid-run.
-    const pollDeadline = Date.now() + 8_000;
-    let row = readRow();
-    while (row?.dispatchPhase !== 'spawned' && Date.now() < pollDeadline) {
-      await new Promise((r) => setTimeout(r, 25));
-      row = readRow();
-    }
-    expect(row?.dispatchPhase).toBe('spawned');
-    expect(typeof row.dispatchPhaseAt).toBe('string');
-    expect(Number.isNaN(Date.parse(row.dispatchPhaseAt))).toBe(false);
-
-    // Let the gated stub finish.
-    fs.writeFileSync(path.join(projectCwd, 'go.marker'), 'go\n', 'utf8');
-    await spawnPromise;
-
-    const finalRow = readRow();
-    expect(finalRow.exitCode).toBe(0);
-    expect(finalRow.dispatchPhase).toBeUndefined();
-    expect(finalRow.dispatchPhaseAt).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);
-
-test('a job whose tree is dirty only from pre-existing baseline WIP (human/sibling), and which itself dirties/commits nothing, gets no leftover attribution', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-inplace-salvage-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  // Pre-existing WIP present BEFORE the run — must never be attributed to
-  // this job, even though it's still dirty at exit.
-  fs.writeFileSync(path.join(projectCwd, 'human-wip.txt'), 'human work in progress\n', 'utf8');
-
-  const slug = `1098-test-inplace-noop-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do nothing.', 'utf8');
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'pending', cwd: projectCwd },
-  ]);
-
-  process.env.SM_CLAUDE_BIN = writeNoopClaudeStub();
-
-  const runId = `run-${slug}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-
-  try {
-    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const row = jobs.find((j) => j.slug === slug);
-    expect(row).toBeTruthy();
-    expect(row.exitCode).toBe(0);
-    // No leftover attribution: the only dirt is baseline WIP, not this job's.
-    expect(row.leftoverPaths).toBeUndefined();
-    expect(row.leftoverCount).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);

package/src/main/__tests__/scheduler-integration-failure-stamp.test.cjs

@@ -1,41 +0,0 @@
-/**
- * scheduler-integration-failure-stamp.test.cjs — a worktree_integration_failed
- * finalize stamps integrateBranch's failure subtype onto the job row, and the
- * RCA report names it.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-integration-failure-stamp.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { stampIntegrationFailure } = require('../scheduler.cjs');
-const { buildRcaMarkdown } = require('../lib/rcaReport.cjs');
-
-test('stamps content_conflict kind and conflicted paths', () => {
-  const row = { slug: 'x' };
-  stampIntegrationFailure(row, { ok: false, failureKind: 'content_conflict', conflictedPaths: ['a.md'] });
-  assert.equal(row.integrationFailureKind, 'content_conflict');
-  assert.deepEqual(row.integrationConflictPaths, ['a.md']);
-});
-
-test('blocking_paths stamps kind only; no failure clears stale fields', () => {
-  const row = { integrationConflictPaths: ['old'] };
-  stampIntegrationFailure(row, { ok: false, failureKind: 'blocking_paths', blockingPaths: { tracked: ['f'], untracked: [] } });
-  assert.equal(row.integrationFailureKind, 'blocking_paths');
-  assert.equal('integrationConflictPaths' in row, false);
-  stampIntegrationFailure(row, null);
-  assert.equal('integrationFailureKind' in row, false);
-});
-
-test('RCA markdown names the subtype and conflicted paths', () => {
-  const job = {
-    slug: 'x', runId: 'r', integrationFailureKind: 'content_conflict',
-    integrationConflictPaths: ['docs/asset-pipeline.md'],
-  };
-  const md = buildRcaMarkdown({
-    job, verdict: 'worktree_integration_failed', meta: null, logTail: '', acText: '', failureClass: 'unknown',
-  });
-  assert.ok(md.includes('Integration failure subtype: content_conflict (conflicted paths: docs/asset-pipeline.md)'));
-});

package/src/main/__tests__/scheduler-investigation-clean-skip.test.cjs

@@ -1,63 +0,0 @@
-/**
- * scheduler-investigation-clean-skip.test.cjs — a run that verified clean
- * (exit 0 + a completed-equivalent verdict) has nothing left to diagnose;
- * spawnInvestigation must decline rather than manufacturing a depth+1
- * fix-of-a-fix PRD for already-shipped work (PRD
- * 812-689-fix-fix-distribute-adminserver-routes).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-investigation-clean-skip.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { shouldSkipInvestigationForCleanRun } = require('../scheduler.cjs');
-
-test('declines for a clean, exit-0 run', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 0 },
-    verdicts: { verdict: 'clean' },
-  })).toBe(true);
-});
-
-test('declines for pass_no_commit_already_shipped, exit-0', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 0 },
-    verdicts: { verdict: 'pass_no_commit_already_shipped' },
-  })).toBe(true);
-});
-
-test('declines for pass_no_commit_target_verified, exit-0', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 0 },
-    verdicts: { verdict: 'pass_no_commit_target_verified' },
-  })).toBe(true);
-});
-
-test('proceeds (does not skip) for exitCode 1', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 1 },
-    verdicts: { verdict: 'clean' },
-  })).toBe(false);
-});
-
-test('proceeds for exit 0 with a non-completed-equivalent verdict', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 0 },
-    verdicts: { verdict: 'transcript_errors' },
-  })).toBe(false);
-});
-
-test('proceeds (fail-open) when verdicts.json is missing', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: { exitCode: 0 },
-    verdicts: null,
-  })).toBe(false);
-});
-
-test('proceeds (fail-open) when meta.json is missing', () => {
-  expect(shouldSkipInvestigationForCleanRun({
-    meta: null,
-    verdicts: { verdict: 'clean' },
-  })).toBe(false);
-});

package/src/main/__tests__/scheduler-investigation-prompt.test.cjs

@@ -1,123 +0,0 @@
-/**
- * scheduler-investigation-prompt.test.cjs — unit tests for buildInvestigationPrompt.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-investigation-prompt.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 { buildInvestigationPrompt, isGitRepoSync } = require('../scheduler.cjs');
-
-function makeArgs(overrides = {}) {
-  return {
-    failedJob: { slug: '05-my-feature', title: 'My feature', exitCode: 1 },
-    cwd: '/home/bilko/Projects/session-manager',
-    failedLogPath: '/tmp/05-my-feature.log',
-    originalBody: 'Original PRD body.',
-    logTail: 'some log tail output',
-    fixPath: '/tmp/05-fix-my-feature.md',
-    group: 5,
-    ...overrides,
-  };
-}
-
-test('prompt references the canonical standards.md file', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.match(prompt, /standards\.md/);
-  assert.match(prompt, /plugins\/session-manager-dev\/skills\/develop\/standards\.md/);
-});
-
-test('prompt instructs inlining the Execution discipline section under Engineering standards', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.match(prompt, /Engineering standards/);
-  assert.match(prompt, /Execution discipline \(headless runs\)/);
-});
-
-test('prompt contains the named "delegated instead of executed" detection check', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.match(prompt, /ScheduleWakeup/);
-  assert.match(prompt, /session-manager-dev:develop/);
-  assert.match(prompt, /never re-queue or self-schedule|delegated instead of executed/);
-});
-
-test('prompt includes the resolved job fields', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.match(prompt, /05-my-feature/);
-  assert.match(prompt, /Original PRD body\./);
-  assert.match(prompt, /some log tail output/);
-  assert.match(prompt, /05-fix-my-feature\.md/);
-});
-
-// ─── abandoned_background_task: investigation prompt directs a commit-first check ─
-
-test('prompt for an abandoned_background_task job directs inspecting the working tree and committing before re-implementing', () => {
-  const prompt = buildInvestigationPrompt(makeArgs({
-    failedJob: { slug: '05-my-feature', title: 'My feature', exitCode: 0, verifierVerdict: 'abandoned_background_task' },
-  }));
-  assert.match(prompt, /abandoned_background_task/);
-  assert.match(prompt, /git status/);
-  assert.match(prompt, /COMMIT/);
-  assert.match(prompt, /not re-implement or re-plan the PRD from scratch/);
-});
-
-test('prompt for a job with no abandoned_background_task verdict omits the note', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.doesNotMatch(prompt, /abandoned_background_task/);
-});
-
-test('prompt for an abandoned_background_task job with a salvage patch names its exact path', () => {
-  const prompt = buildInvestigationPrompt(makeArgs({
-    failedJob: {
-      slug: '05-my-feature',
-      title: 'My feature',
-      exitCode: 0,
-      verifierVerdict: 'abandoned_background_task',
-      salvagePatch: '/tmp/runs/2026-09-02/05-my-feature.uncommitted.patch',
-    },
-  }));
-  assert.match(prompt, /05-my-feature\.uncommitted\.patch/);
-  assert.match(prompt, /apply it to the working tree BEFORE inspecting/);
-});
-
-// ─── cwd-must-be-git-repo-root guidance (99-fix-e2e-needs-review-test) ────────
-
-test('prompt instructs that cwd must be the git repo root where the fix will land', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  assert.match(prompt, /cwd.*must be the git repo root/);
-  assert.match(prompt, /needs_review/);
-});
-
-test('prompt frontmatter block still declares exactly the five expected keys', () => {
-  const prompt = buildInvestigationPrompt(makeArgs());
-  const fenceMatch = prompt.match(/```\s*\n\s*---\n([\s\S]*?)\n\s*---\n\s*```/);
-  assert.ok(fenceMatch, 'expected a fenced frontmatter block in the prompt');
-  const keys = fenceMatch[1]
-    .split('\n')
-    .filter((line) => line.trim().length > 0)
-    .map((line) => line.split(':')[0].trim());
-  assert.deepEqual(keys, ['title', 'cwd', 'parallelGroup', 'estimateMinutes', 'isFixPlan']);
-});
-
-// ─── isGitRepoSync (scheduler.cjs) ─────────────────────────────────────────────
-
-test('isGitRepoSync: true for a real git repo, false for a non-repo dir, false for missing/undefined', () => {
-  const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduler-isgitrepo-repo-'));
-  const nonRepo = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduler-isgitrepo-plain-'));
-  try {
-    execFileSync('git', ['init', '-q'], { cwd: repo });
-    assert.equal(isGitRepoSync(repo), true);
-    assert.equal(isGitRepoSync(nonRepo), false);
-    assert.equal(isGitRepoSync(undefined), false);
-    assert.equal(isGitRepoSync(''), false);
-    assert.equal(isGitRepoSync('/definitely/does/not/exist'), false);
-  } finally {
-    fs.rmSync(repo, { recursive: true, force: true });
-    fs.rmSync(nonRepo, { recursive: true, force: true });
-  }
-});