claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-finalize-dispatch-guards.test.cjs

@@ -1,229 +0,0 @@
-/**
- * scheduler-finalize-dispatch-guards.test.cjs — regression cover for the
- * 2026-09-06 incident: PRD 1133 (reaper integration check) shipped correctly
- * in commit 5de4134, but its finalize mutate's silent early-return dropped
- * three subsequent no-op re-verifications of the same already-shipped slug
- * with no audit trail, leaving the row stuck 'pending' forever and causing
- * the dispatcher to re-fire it three more times.
- *
- * Covers the three pure decision helpers extracted for this fix:
- *  - evaluateFinalizeDrop: never silently discard a finalize (row missing,
- *    or row moved off 'running' by a concurrent cancel) — always says so,
- *    and still lets a genuinely-landed commit be stamped as a durable fact.
- *  - evaluateDispatchSidecarReconcile: refuse to re-dispatch a pending row
- *    whose newest run sidecar already shows a completed-equivalent outcome
- *    for THIS queueing episode.
- *  - isQueueRowRegression: detect (never repair) a running->pending change
- *    whose statusHistory got shorter — evidence of lost state, not a real
- *    transition.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, matching
- * scheduler-reap-dead-running-jobs.test.cjs's pattern — every path this
- * module touches is baked into a top-level const from os.homedir() at
- * require time.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-finalize-dispatch-guards.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 tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduler-finalize-dispatch-guards-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  evaluateFinalizeDrop,
-  evaluateDispatchSidecarReconcile,
-  isQueueRowRegression,
-} = require('../scheduler.cjs');
-
-describe('evaluateFinalizeDrop', () => {
-  it('drops loudly (row-missing) with nothing to stamp when the row vanished from s.jobs', () => {
-    const decision = evaluateFinalizeDrop({
-      rowExists: false,
-      rowStatus: null,
-      rowRunId: null,
-      rowLandedCommit: null,
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, true);
-    assert.equal(decision.reason, 'row-missing');
-    assert.equal(decision.stampLandedCommit, null);
-  });
-
-  it('drops the status change (row-not-running) but stamps landedCommit when this run owns the row', () => {
-    const decision = evaluateFinalizeDrop({
-      rowExists: true,
-      rowStatus: 'failed', // e.g. remote.cancelJob already finalized it (PRD 1024)
-      rowRunId: 'run-2',
-      rowLandedCommit: null,
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, true);
-    assert.equal(decision.reason, 'row-not-running');
-    assert.equal(decision.stampLandedCommit, 'deadbeef');
-  });
-
-  it('stamps landedCommit even when the row carries a different runId, as long as it has none of its own', () => {
-    const decision = evaluateFinalizeDrop({
-      rowExists: true,
-      rowStatus: 'pending',
-      rowRunId: 'some-other-run',
-      rowLandedCommit: null,
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, true);
-    assert.equal(decision.stampLandedCommit, 'deadbeef');
-  });
-
-  it('never overwrites a row that already carries its own newer landedCommit from a different run', () => {
-    const decision = evaluateFinalizeDrop({
-      rowExists: true,
-      rowStatus: 'failed',
-      rowRunId: 'some-other-run',
-      rowLandedCommit: 'already-there',
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, true);
-    assert.equal(decision.stampLandedCommit, null);
-  });
-
-  it('never re-legalizes a cancelled (failed) row back to completed — the PRD-1024 protection', () => {
-    // The finalize call site never even reaches transitionJob for a dropped
-    // finalize; this test documents the contract evaluateFinalizeDrop enforces:
-    // drop:true means the caller MUST NOT change job.status.
-    const decision = evaluateFinalizeDrop({
-      rowExists: true,
-      rowStatus: 'failed',
-      rowRunId: 'run-2',
-      rowLandedCommit: null,
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, true);
-  });
-
-  it('does not drop when the row is still running — the normal finalize path', () => {
-    const decision = evaluateFinalizeDrop({
-      rowExists: true,
-      rowStatus: 'running',
-      rowRunId: 'run-2',
-      rowLandedCommit: null,
-      runId: 'run-2',
-      landedCommit: 'deadbeef',
-    });
-    assert.equal(decision.drop, false);
-    assert.equal(decision.stampLandedCommit, null);
-  });
-});
-
-describe('evaluateDispatchSidecarReconcile', () => {
-  const baseRow = {
-    rowStatus: 'pending',
-    rowRunId: null,
-    statusHistory: [
-      { from: 'running', to: 'pending', at: '2026-09-06T19:30:00.000Z' },
-    ],
-    queuedAt: '2026-09-06T17:02:07.815Z',
-  };
-
-  it('skips dispatch when a prior run of this slug already completed after the last pending transition', () => {
-    const decision = evaluateDispatchSidecarReconcile({
-      ...baseRow,
-      outcome: { status: 'completed', runId: '2026-09-06T19-26-54-681Z', finishedAt: '2026-09-06T19:35:00.000Z' },
-    });
-    assert.equal(decision.skip, true);
-    assert.equal(decision.runId, '2026-09-06T19-26-54-681Z');
-  });
-
-  it('proceeds with dispatch when a deliberate human re-queue postdates the earlier completion', () => {
-    // The re-queue's own pending transition (19:30) is AFTER the completed
-    // sidecar's finishedAt (18:00) — an OLDER episode's completion, not this one.
-    const decision = evaluateDispatchSidecarReconcile({
-      ...baseRow,
-      outcome: { status: 'completed', runId: 'old-run', finishedAt: '2026-09-06T18:00:00.000Z' },
-    });
-    assert.equal(decision.skip, false);
-  });
-
-  it('proceeds with dispatch when there is no sidecar at all (guard is a no-op)', () => {
-    const decision = evaluateDispatchSidecarReconcile({ ...baseRow, outcome: null });
-    assert.equal(decision.skip, false);
-  });
-
-  it('proceeds with dispatch when the sidecar belongs to this row\'s own current runId', () => {
-    const decision = evaluateDispatchSidecarReconcile({
-      ...baseRow,
-      rowRunId: 'run-x',
-      outcome: { status: 'completed', runId: 'run-x', finishedAt: '2026-09-06T19:35:00.000Z' },
-    });
-    assert.equal(decision.skip, false);
-  });
-
-  it('proceeds with dispatch when the row is not pending (e.g. needs_review resume-recovery)', () => {
-    const decision = evaluateDispatchSidecarReconcile({
-      ...baseRow,
-      rowStatus: 'needs_review',
-      outcome: { status: 'completed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
-    });
-    assert.equal(decision.skip, false);
-  });
-
-  it('proceeds with dispatch when the newest sidecar reports a failed (not completed-equivalent) outcome', () => {
-    const decision = evaluateDispatchSidecarReconcile({
-      ...baseRow,
-      outcome: { status: 'failed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
-    });
-    assert.equal(decision.skip, false);
-  });
-
-  it('falls back to queuedAt when the row has never been reset (no pending statusHistory entry)', () => {
-    const decision = evaluateDispatchSidecarReconcile({
-      rowStatus: 'pending',
-      rowRunId: null,
-      statusHistory: [],
-      queuedAt: '2026-09-06T17:02:07.815Z',
-      outcome: { status: 'completed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
-    });
-    assert.equal(decision.skip, true);
-  });
-});
-
-describe('isQueueRowRegression', () => {
-  it('flags a running->pending change whose statusHistory got shorter', () => {
-    assert.equal(
-      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 5, historyLenAfter: 3 }),
-      true,
-    );
-  });
-
-  it('does not flag a running->pending change with a normal appended (equal or longer) history', () => {
-    assert.equal(
-      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 5, historyLenAfter: 6 }),
-      false,
-    );
-    assert.equal(
-      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 20, historyLenAfter: 20 }),
-      false,
-    );
-  });
-
-  it('does not flag a shortened history on transitions other than running->pending', () => {
-    assert.equal(
-      isQueueRowRegression({ statusBefore: 'pending', statusAfter: 'completed', historyLenBefore: 5, historyLenAfter: 3 }),
-      false,
-    );
-    assert.equal(
-      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'completed', historyLenBefore: 5, historyLenAfter: 3 }),
-      false,
-    );
-  });
-});

package/src/main/__tests__/scheduler-find-prd-dir.test.cjs

@@ -1,75 +0,0 @@
-/**
- * scheduler-find-prd-dir.test.cjs — unit test for findPrdDir's legacy-dir
- * fallback (PRD 812 split-brain fix): a PRD slug that exists only in the
- * legacy global `~/.claude/session-manager/scheduled-plans/prds/` dir (not
- * yet migrated into any project's own
- * `<cwd>/session-manager-operations/scheduler/prds/`) must still resolve,
- * since findPrdDir's candidatePrdsDirs() searches the legacy dir first.
- *
- * HOME-isolated (PRD 812 incident fix): scheduler.cjs derives PRDS_DIR from
- * os.homedir() at module load. This test used to write straight into the
- * REAL `~/.claude/session-manager/scheduled-plans/prds/` — the live
- * scheduler's `reconcile()` scans that dir every 60s and enqueued the
- * fixture as a phantom job (job 812-test-legacy-only-1975929-233060) before
- * this test's own cleanup ran. Now HOME is stubbed to a mkdtemp dir BEFORE
- * scheduler.cjs is first required, so PRDS_DIR resolves under the temp dir
- * and nothing here can reach the real scheduler root. The
- * `PRDS_DIR.startsWith(tmpHome)` guard is the regression test for that
- * incident: if module-load ordering ever changes so the real homedir gets
- * snapshotted first, this throws loudly instead of silently poisoning the
- * live queue again.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-find-prd-dir.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let findPrdDir;
-let PRDS_DIR;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-find-prd-dir-'));
-  process.env.HOME = tmpHome;
-
-  // Load AFTER HOME is stubbed — scheduler.cjs snapshots os.homedir() into
-  // PRDS_DIR at module load, not lazily.
-  ({ findPrdDir, PRDS_DIR } = require('../scheduler.cjs'));
-
-  // Hard guard: never let this test write into the real scheduler root.
-  if (!PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('findPrdDir resolves a slug that exists only in the legacy global PRDs dir', async () => {
-  const slug = `812-test-legacy-only-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const legacyPath = path.join(PRDS_DIR, `${slug}.md`);
-  fs.mkdirSync(PRDS_DIR, { recursive: true });
-  fs.writeFileSync(legacyPath, '---\ntitle: legacy fixture\n---\n\n# Goal\n\ntest\n', 'utf8');
-
-  try {
-    const dir = await findPrdDir(slug);
-    expect(dir).toBe(PRDS_DIR);
-  } finally {
-    fs.rmSync(legacyPath, { force: true });
-  }
-});
-
-test('findPrdDir returns null for a slug that exists nowhere', async () => {
-  const slug = `812-test-nonexistent-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const dir = await findPrdDir(slug);
-  expect(dir).toBe(null);
-});

package/src/main/__tests__/scheduler-fix-plan-path.test.cjs

@@ -1,119 +0,0 @@
-/**
- * scheduler-fix-plan-path.test.cjs — regression test for the self-heal
- * dead-letter bug: spawnInvestigation used to write every auto-fix plan into
- * the RETIRED flat `<cwd>/session-manager-operations/scheduler/prds/` dir
- * (prdDirForCwd), which reconcile()'s consolidateAllFlatPrds sweeps BEFORE
- * scanning for queue rows — so a freshly-authored fix plan (no queue row yet
- * by definition) was archived into `prds-archived/` on the very next pass
- * and never enqueued. Confirmed live in starry-night-ships: job
- * 105-arena-perf-fences produced a valid fix plan that landed in
- * prds-archived/ having never appeared in queue.json or history.jsonl.
- *
- * The fix: resolveFixPlanPath resolves the write dir from the ORIGINAL job's
- * live PRD location (findPrdDir, via resolveVerifyPrdPath) — normally the
- * originating Epic's own `epics/<epicId>/prds/`, which consolidateFlatPrds
- * never touches — falling back to the flat dir only when the original can't
- * be found live anywhere on disk.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-fix-plan-path.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let resolveFixPlanPath;
-let PRDS_DIR;
-let consolidateFlatPrds;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-fix-plan-path-'));
-  process.env.HOME = tmpHome;
-
-  // Load AFTER HOME is stubbed — scheduler.cjs snapshots os.homedir() into
-  // PRDS_DIR at module load, not lazily (see scheduler-find-prd-dir.test.cjs).
-  ({ resolveFixPlanPath, PRDS_DIR } = require('../scheduler.cjs'));
-  ({ consolidateFlatPrds } = require('../lib/prdMigration.cjs'));
-
-  if (!PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-
-  // allProjectCwds()/activeProjectCwds() (consumed by findPrdDir's candidate
-  // search) discover project cwds by scanning ~/.claude/projects/*/*.jsonl
-  // for a `cwd` field — fake one project transcript pointing at the real
-  // on-disk cwd used below (mirrors scheduler-verify-prd-path.test.cjs).
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const projDir = path.join(projectsDir, 'fake-fix-plan-project-slug');
-  fs.mkdirSync(projDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(projDir, 'session.jsonl'),
-    `${JSON.stringify({ cwd: projectCwd() })}\n`,
-    'utf8',
-  );
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function projectCwd() {
-  return path.join(tmpHome, 'fix-plan-project-cwd');
-}
-
-test('resolveFixPlanPath resolves the fix plan into the SAME Epic-scoped dir as the original PRD, and it survives consolidateFlatPrds', async () => {
-  const cwd = projectCwd();
-  const epicId = 'test-epic-arena-perf';
-  const slug = `105-arena-perf-fences-${process.pid}`;
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), '---\ntitle: arena perf fences\n---\n\n# Goal\n\ntest\n', 'utf8');
-
-  const failedJob = { slug, cwd, parallelGroup: 5 };
-  const resolved = await resolveFixPlanPath(failedJob);
-
-  const expectedFixSlug = '05-fix-arena-perf-fences-' + process.pid;
-  expect(resolved.fixSlug).toBe(expectedFixSlug);
-  expect(resolved.livePrdDir).toBe(prdsDir);
-  expect(resolved.fixPath).toBe(path.join(prdsDir, `${expectedFixSlug}.md`));
-
-  // A fix plan written at the resolved path must survive a consolidateFlatPrds
-  // pass over the SAME project cwd — the sweep only ever touches the flat dir.
-  fs.writeFileSync(resolved.fixPath, `---\ntitle: Fix: arena perf fences\ncwd: ${cwd}\nparallelGroup: 5\nestimateMinutes: 30\n---\n\nfix body\n`, 'utf8');
-  await consolidateFlatPrds(cwd);
-  expect(fs.existsSync(resolved.fixPath)).toBe(true);
-});
-
-test('resolveFixPlanPath falls back to the flat dir when the original PRD cannot be found live anywhere on disk', async () => {
-  const cwd = path.join(tmpHome, 'fix-plan-project-cwd-missing');
-  const slug = `999-nonexistent-${process.pid}`;
-  const failedJob = { slug, cwd, parallelGroup: 3 };
-
-  const resolved = await resolveFixPlanPath(failedJob);
-
-  expect(resolved.livePrdDir).toBe(null);
-  const flatDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
-  expect(resolved.fixPath).toBe(path.join(flatDir, `${resolved.fixSlug}.md`));
-});
-
-test('the OLD flat-dir path (regression guard) does NOT survive consolidateFlatPrds — proves the bug this fix addresses', async () => {
-  const cwd = path.join(tmpHome, 'fix-plan-project-cwd-old-behavior');
-  const flatDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(flatDir, { recursive: true });
-  const oldFixPath = path.join(flatDir, '07-fix-old-behavior.md');
-  fs.writeFileSync(oldFixPath, `---\ntitle: Fix: old behavior\ncwd: ${cwd}\nparallelGroup: 7\nestimateMinutes: 30\n---\n\nfix body\n`, 'utf8');
-
-  // No queue.json at all — the file has no live queue row, exactly the
-  // freshly-authored-fix-plan situation the bug hit.
-  await consolidateFlatPrds(cwd);
-
-  expect(fs.existsSync(oldFixPath)).toBe(false);
-  expect(fs.existsSync(path.join(cwd, 'session-manager-operations', 'scheduler', 'prds-archived', '07-fix-old-behavior.md'))).toBe(true);
-});

package/src/main/__tests__/scheduler-force-tick-outcome.test.cjs

@@ -1,46 +0,0 @@
-/**
- * scheduler-force-tick-outcome.test.cjs — unit tests for forceTickOutcome().
- *
- * Covers the "No pending jobs" vs "Already running" ambiguity: when
- * pickNextBatch() returns an empty batch with no hold reason, that's only
- * genuinely "no pending jobs" if nothing is running either — if a job
- * already transitioned to running (e.g. the when-available poll won a race
- * against a manual force-tick click), the message must say so instead of
- * flatly claiming nothing is pending.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-force-tick-outcome.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { forceTickOutcome } = require('../scheduler.cjs');
-
-test('forceTickOutcome: null result → No pending jobs', () => {
-  const outcome = forceTickOutcome(null);
-  assert.strictEqual(outcome.message, 'No pending jobs');
-});
-
-test('forceTickOutcome: fired → Fired N job(s)', () => {
-  const outcome = forceTickOutcome({ fired: true, count: 2, group: 0 });
-  assert.strictEqual(outcome.message, 'Fired 2 job(s) (group g0)');
-});
-
-test('forceTickOutcome: reason=drained (genuinely nothing pending or running) → No pending jobs', () => {
-  const outcome = forceTickOutcome({ fired: false, reason: 'drained' });
-  assert.strictEqual(outcome.message, 'No pending jobs');
-});
-
-test('forceTickOutcome: reason=already-running (race: poll fired it first) → Already running message, not "No pending jobs"', () => {
-  const outcome = forceTickOutcome({ fired: false, reason: 'already-running', runningCount: 1 });
-  assert.strictEqual(outcome.message, 'Already running — 1 job(s) in flight');
-  assert.notStrictEqual(outcome.message, 'No pending jobs');
-});
-
-test('forceTickOutcome: reason=held → detail message surfaces', () => {
-  const outcome = forceTickOutcome({ fired: false, reason: 'held', detail: '[scheduler] concurrency [/a]: cap reached, no slots' });
-  assert.strictEqual(outcome.message, 'cap reached, no slots');
-});
-
-console.log('scheduler-force-tick-outcome tests: PASS');

package/src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs

@@ -1,78 +0,0 @@
-/**
- * scheduler-foreign-wip-manifest.test.cjs — capDirtyPaths/buildForeignWipSection,
- * the pure helpers behind the pre-run foreign-WIP manifest injected into the
- * executor prompt (see the "starry-night-ships PRD 148" postmortem: a job
- * running in a shared or WIP-carrying tree must be told explicitly which
- * paths it does not own, rather than having to bisect by content).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  capDirtyPaths,
-  buildForeignWipSection,
-  PRE_RUN_DIRTY_PATHS_CAP,
-  FOREIGN_WIP_DELIMITER,
-  FOREIGN_WIP_END_DELIMITER,
-} = require('../scheduler.cjs');
-
-test('capDirtyPaths: [] for null/undefined/empty input', () => {
-  expect(capDirtyPaths(null)).toEqual([]);
-  expect(capDirtyPaths(undefined)).toEqual([]);
-  expect(capDirtyPaths([])).toEqual([]);
-});
-
-test('capDirtyPaths: returns the list unchanged when under the cap', () => {
-  expect(capDirtyPaths(['a.js', 'b.js'])).toEqual(['a.js', 'b.js']);
-});
-
-test('capDirtyPaths: truncates at the cap and appends a "+N more" marker', () => {
-  const many = Array.from({ length: PRE_RUN_DIRTY_PATHS_CAP + 7 }, (_, i) => `file-${i}.txt`);
-  const capped = capDirtyPaths(many);
-  expect(capped).toHaveLength(PRE_RUN_DIRTY_PATHS_CAP + 1);
-  expect(capped.slice(0, PRE_RUN_DIRTY_PATHS_CAP)).toEqual(many.slice(0, PRE_RUN_DIRTY_PATHS_CAP));
-  expect(capped[PRE_RUN_DIRTY_PATHS_CAP]).toBe('+7 more');
-});
-
-test('buildForeignWipSection: "" when both lists are empty/absent (clean spawn) — zero prompt tokens added', () => {
-  expect(buildForeignWipSection({})).toBe('');
-  expect(buildForeignWipSection({ preRunDirtyPaths: [], carriedPaths: [] })).toBe('');
-  expect(buildForeignWipSection()).toBe('');
-});
-
-test('buildForeignWipSection: shared dirty tree emits the manifest with the delimiter, paths verbatim, and do-not-touch wording', () => {
-  const section = buildForeignWipSection({ preRunDirtyPaths: ['src/foo.ts', 'src/bar.ts'] });
-  expect(section).toContain(FOREIGN_WIP_DELIMITER);
-  expect(section).toContain(FOREIGN_WIP_END_DELIMITER);
-  expect(section).toContain('src/foo.ts');
-  expect(section).toContain('src/bar.ts');
-  expect(section).toMatch(/SHARED working tree/);
-  expect(section).toMatch(/not this job's work/i);
-  expect(section).toMatch(/do not stage, commit, revert, or stash/i);
-  expect(section).toMatch(/not this job's regression/i);
-});
-
-test('buildForeignWipSection: carriedPaths (PRD 1094 base WIP) emits carry-over wording, not the shared-tree wording', () => {
-  const section = buildForeignWipSection({ carriedPaths: ['config/settings.json'] });
-  expect(section).toContain('config/settings.json');
-  expect(section).toMatch(/isolated git worktree/i);
-  expect(section).toMatch(/authoritative copy.*main tree/i);
-  expect(section).not.toMatch(/SHARED working tree/);
-});
-
-test('buildForeignWipSection: carriedPaths takes precedence over preRunDirtyPaths when both are somehow present', () => {
-  const section = buildForeignWipSection({
-    carriedPaths: ['carried.ts'],
-    preRunDirtyPaths: ['dirty.ts'],
-  });
-  expect(section).toContain('carried.ts');
-  expect(section).not.toContain('dirty.ts');
-  expect(section).toMatch(/isolated git worktree/i);
-});
-
-test('buildForeignWipSection: isolated-clean (worktree ok, no carried WIP) emits nothing', () => {
-  expect(buildForeignWipSection({ carriedPaths: [] })).toBe('');
-});

package/src/main/__tests__/scheduler-gate-shadow.test.cjs

@@ -1,119 +0,0 @@
-/**
- * scheduler-gate-shadow.test.cjs — the shadow gate records `gateShadow` on the
- * verdicts sidecar and the row, and NEVER changes a status.
- *
- * HOME is overridden BEFORE requiring scheduler.cjs (top-level consts bake in
- * os.homedir() — see scheduler-looks-done.test.cjs).
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-gate-shadow.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(), 'gate-shadow-test-'));
-process.env.HOME = tmpHome;
-
-const { runGateShadow } = require('../scheduler.cjs');
-const { runGateSequence } = require('../lib/definitionOfDone.cjs');
-const { resolveEpicPrdWriteDir } = require('../lib/prdLocations.cjs');
-const { bustCwdCache } = require('../lib/queueStore.cjs');
-
-function git(args, cwd) { return execFileSync('git', args, { cwd, encoding: 'utf8' }); }
-
-function setup(name, gateBody) {
-  const cwd = path.join(tmpHome, name);
-  fs.mkdirSync(cwd, { recursive: true });
-  git(['init', '-q'], cwd);
-  git(['config', 'user.email', 't@example.com'], cwd);
-  git(['config', 'user.name', 'T'], cwd);
-  fs.writeFileSync(path.join(cwd, 'README.md'), 'x\n');
-  git(['add', '-A'], cwd);
-  git(['commit', '-q', '-m', 'init'], cwd);
-  const slugDir = path.join(tmpHome, '.claude', 'projects', `${name}-slug`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 't.jsonl'), JSON.stringify({ cwd }) + '\n');
-  bustCwdCache();
-  const prdDir = resolveEpicPrdWriteDir(cwd, 'gate-epic');
-  fs.mkdirSync(prdDir, { recursive: true });
-  const slug = `01-${name}`;
-  fs.writeFileSync(path.join(prdDir, `${slug}.md`), `---\ntitle: T\ncwd: ${cwd}\nestimateMinutes: 5\n---\n${gateBody}\n`);
-  const runId = `run-${name}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-  const verdictsPath = path.join(runDir, `${slug}.verdicts.json`);
-  fs.writeFileSync(verdictsPath, JSON.stringify({ verdict: 'transcript_errors', reason: 'r' }));
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  const queuePath = path.join(stateDir, 'queue.json');
-  const job = { slug, status: 'needs_review', cwd, runId, verifierVerdict: 'transcript_errors', startedAt: new Date().toISOString(), finishedAt: new Date().toISOString() };
-  fs.writeFileSync(queuePath, JSON.stringify({ jobs: [job] }, null, 2));
-  return { cwd, slug, job, verdictsPath, queuePath };
-}
-
-const ac = (cmd) => `# Acceptance criteria\n\n- [ ] Gate: \`${cmd}\`\n`;
-
-test('green gate: recorded on sidecar + row, status untouched, verdict keys preserved', async () => {
-  const t = setup('green', ac('timeout 30 node -e "process.exit(0)" && timeout 30 node -e "process.exit(0)"'));
-  const rec = await runGateShadow(t.job);
-  assert.equal(rec.status, 'green');
-  assert.equal(rec.results.length, 2);
-  const sidecar = JSON.parse(fs.readFileSync(t.verdictsPath, 'utf8'));
-  assert.equal(sidecar.verdict, 'transcript_errors', 'read-merge keeps runVerify keys');
-  assert.equal(sidecar.gateShadow.status, 'green');
-  const row = JSON.parse(fs.readFileSync(t.queuePath, 'utf8')).jobs.find((j) => j.slug === t.slug);
-  assert.equal(row.status, 'needs_review', 'shadow never transitions');
-  assert.equal(row.gateShadow.status, 'green');
-});
-
-test('red gate stops at the first failure and records red; status still untouched', async () => {
-  const t = setup('red', ac('timeout 30 node -e "process.exit(3)" && timeout 30 node -e "process.exit(0)"'));
-  const rec = await runGateShadow(t.job);
-  assert.equal(rec.status, 'red');
-  assert.equal(rec.results.length, 1);
-  assert.equal(rec.results[0].code, 3);
-  const row = JSON.parse(fs.readFileSync(t.queuePath, 'utf8')).jobs.find((j) => j.slug === t.slug);
-  assert.equal(row.status, 'needs_review');
-});
-
-test('the gate runs with CI=1 and an isolated TMPDIR', async () => {
-  const t = setup('env', ac('timeout 30 node -e "process.exit(process.env.CI===\'1\'&&process.env.TMPDIR.includes(\'sm-gate-shadow-\')?0:9)"'));
-  assert.equal((await runGateShadow(t.job)).status, 'green');
-});
-
-test('gate: none is recorded as an explicit opt-out (unavailable), nothing spawned', async () => {
-  const t = setup('optout', '# Acceptance criteria\n\n- [ ] `timeout 30 node -e "process.exit(9)"`\n');
-  t.job.slug = t.slug;
-  fs.writeFileSync(path.join(resolveEpicPrdWriteDir(t.cwd, 'gate-epic'), `${t.slug}.md`), `---\ntitle: T\ncwd: ${t.cwd}\ngate: none\n---\nbody\n`);
-  const rec = await runGateShadow(t.job);
-  assert.equal(rec.status, 'unavailable');
-  assert.equal(rec.reason, 'gate-opt-out');
-  assert.deepEqual(rec.results, []);
-});
-
-test('no parseable gate → unavailable', async () => {
-  const t = setup('nogate', '# Acceptance criteria\n\n- [ ] just prose\n');
-  const rec = await runGateShadow(t.job);
-  assert.equal(rec.status, 'unavailable');
-  assert.equal(rec.reason, 'no-parseable-gate');
-});
-
-test('at most one shadow gate in flight: a concurrent run reports busy and runs nothing', async () => {
-  const slow = [{ argv: ['node', '-e', 'setTimeout(()=>{},400)'], timeoutMs: 10_000, env: {} }];
-  const first = runGateSequence(slow, { cwd: tmpHome });
-  const second = await runGateSequence(slow, { cwd: tmpHome });
-  assert.equal(second.status, 'busy');
-  assert.deepEqual(second.results, []);
-  assert.equal((await first).status, 'green');
-});
-
-test('a hung command is killed at its timeout and the gate is red', async () => {
-  const hang = [{ argv: ['node', '-e', 'setTimeout(()=>{},60000)'], timeoutMs: 300, env: {} }];
-  const r = await runGateSequence(hang, { cwd: tmpHome });
-  assert.equal(r.status, 'red');
-  assert.equal(r.results[0].timedOut, true);
-});