claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-utilization-hold.test.cjs

@@ -1,89 +0,0 @@
-/**
- * scheduler-utilization-hold.test.cjs — the when-available gate holds on the
- * BINDING window and records a machine-readable hold (window/percent/
- * threshold/reset) on the snapshot; under threshold it dispatches.
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-utilization-hold.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let billing;
-let originalFetchUsage;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-utilhold-'));
-  process.env.HOME = tmpHome;
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-  billing = require('../usage.cjs');
-  originalFetchUsage = billing.fetchUsage;
-});
-
-afterAll(() => {
-  billing.fetchUsage = originalFetchUsage;
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => { billing.fetchUsage = originalFetchUsage; });
-
-const RESET = '2026-09-24T17:00:00Z';
-function usageWith(weeklyPct) {
-  return {
-    kind: 'ok',
-    data: {
-      usage: {
-        five_hour: { utilization: 10, resets_at: '2026-09-21T20:00:00Z' },
-        limits: [
-          { kind: 'session', percent: 10, scope: null, resets_at: '2026-09-21T20:00:00Z' },
-          { kind: 'weekly_all', percent: weeklyPct, scope: null, resets_at: RESET },
-        ],
-      },
-    },
-  };
-}
-
-// dependsOn never resolves so a tick reaches the picker (stamping
-// lastDispatchAttemptAt) without ever spawning a real job.
-function state() {
-  return {
-    config: { firePolicy: 'when-available', utilizationThreshold: 90 },
-    paused: null,
-    jobs: [{ slug: '9002-hold', title: 'x', cwd: tmpHome, status: 'pending', dependsOn: ['never'] }],
-  };
-}
-
-test('holds (no tick) and records the hold when the binding weekly window is over threshold', async () => {
-  billing.fetchUsage = async () => usageWith(91);
-  await scheduler.refreshNextReset();
-  const logs = [];
-  const orig = console.log;
-  console.log = (...a) => { logs.push(a.join(' ')); };
-  try { await scheduler.maybeLaunchWhenAvailable(state()); } finally { console.log = orig; }
-  const payload = scheduler.buildScheduleStatePayload(state());
-  expect(payload.utilizationHold).toEqual({ window: 'weekly_all', percent: 91, threshold: 90, resetsAt: RESET });
-  expect(payload.utilizationWindow).toBe('weekly_all');
-  expect(logs.some((l) => l.includes('utilization-held') && l.includes('weekly_all'))).toBe(true);
-  expect(logs.some((l) => l.includes('— ticking'))).toBe(false);
-});
-
-test('ticks and clears the hold when the binding window is under threshold (weekly_all 64)', async () => {
-  billing.fetchUsage = async () => usageWith(64);
-  await scheduler.refreshNextReset();
-  const logs = [];
-  const orig = console.log;
-  console.log = (...a) => { logs.push(a.join(' ')); };
-  try { await scheduler.maybeLaunchWhenAvailable(state()); } finally { console.log = orig; }
-  await scheduler.tickQueue();
-  expect(scheduler.buildScheduleStatePayload(state()).utilizationHold).toBeNull();
-  expect(logs.some((l) => l.includes('— ticking'))).toBe(true);
-});

package/src/main/__tests__/scheduler-verify-prd-path.test.cjs

@@ -1,109 +0,0 @@
-/**
- * scheduler-verify-prd-path.test.cjs — regression test for PRD 991: the
- * verifier's `prdPath` must resolve to a REAL, existing file for an
- * Epic-scoped PRD, both live and archived.
- *
- * Before this PRD, `verifyRun`'s two call sites (the post-run verify in
- * spawnJob and reverifyNeedsReview) built `prdPath` via `prdPathForJob`,
- * which resolves to the RETIRED flat
- * `<cwd>/session-manager-operations/scheduler/prds/` dir — a dir that holds
- * only zero-byte `.reserved-NNN` stubs for every project that has migrated
- * to Epic-scoped PRDs (i.e. every project today). The verifier therefore
- * silently lost access to the PRD body (dependsOn checks, soak-floor dates,
- * deliverable-path checks, the merge-main PR-number exemption) on every
- * single run.
- *
- * This test exercises actual path resolution against a temp tree — no
- * resolver-stubbing — the same class of gap that let this bug (and PRD
- * 985's sibling notify-path bug) ship green twice.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-verify-prd-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 resolveVerifyPrdPath;
-let archivedPrdPathForJob;
-let PRDS_DIR;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-verify-prd-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).
-  ({ resolveVerifyPrdPath, archivedPrdPathForJob, PRDS_DIR } = require('../scheduler.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() discover project cwds by scanning
-  // ~/.claude/projects/*/*.jsonl for a `cwd` field — fake one project with a
-  // transcript pointing at a real on-disk cwd.
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const projDir = path.join(projectsDir, 'fake-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, 'fake-project-cwd');
-}
-
-test('resolveVerifyPrdPath resolves a LIVE Epic-scoped PRD to a real existing path', async () => {
-  const cwd = projectCwd();
-  const epicId = 'test-epic-live';
-  const slug = `991-test-live-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  const prdPath = path.join(prdsDir, `${slug}.md`);
-  fs.writeFileSync(prdPath, '---\ntitle: live fixture\n---\n\n# Goal\n\ntest\n', 'utf8');
-
-  const resolved = await resolveVerifyPrdPath({ slug, cwd });
-  expect(resolved).toBe(prdPath);
-  expect(fs.existsSync(resolved)).toBe(true);
-});
-
-test('resolveVerifyPrdPath returns null for an ARCHIVED-only PRD; archivedPrdPathForJob fills the gap', async () => {
-  const cwd = projectCwd();
-  const epicId = 'test-epic-archived';
-  const slug = `991-test-archived-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const epicDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId);
-  const archiveDir = path.join(epicDir, 'prds-archived');
-  fs.mkdirSync(archiveDir, { recursive: true });
-  const archivedPath = path.join(archiveDir, `${slug}.md`);
-  fs.writeFileSync(archivedPath, '---\ntitle: archived fixture\n---\n\n# Goal\n\ntest\n', 'utf8');
-
-  const job = { slug, cwd };
-  const live = await resolveVerifyPrdPath(job);
-  expect(live).toBe(null);
-
-  const fallback = live ?? archivedPrdPathForJob(job);
-  expect(fallback).toBe(archivedPath);
-  expect(fs.existsSync(fallback)).toBe(true);
-});
-
-test('resolveVerifyPrdPath returns null for a slug that exists nowhere (never falls back to the retired flat dir)', async () => {
-  const cwd = projectCwd();
-  const slug = `991-test-nonexistent-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const resolved = await resolveVerifyPrdPath({ slug, cwd });
-  expect(resolved).toBe(null);
-});

package/src/main/__tests__/scheduler-worktree-cap-defer.test.cjs

@@ -1,234 +0,0 @@
-/**
- * scheduler-worktree-cap-defer.test.cjs — PRD 1112: a job that cannot get
- * worktree isolation because the concurrency cap is currently exhausted must
- * be DEFERRED (left 'pending', retried on the next dispatch pass), never
- * spawned in a shared working tree the way every OTHER worktree.ok===false
- * reason (e.g. "not a git repository") still falls back to running in place.
- *
- * Drives spawnJob end-to-end against a real git fixture repo, forcing the
- * cap via SM_JOB_WORKTREE_MAX=1 plus a real occupying worktree (so the cap
- * check itself, not a mock, is what defers the job).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-worktree-cap-defer.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 originalMax;
-let spawnJob;
-let gitWorktree;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-// A completed job's PRD is archived immediately (archiveCompletedPrd, called
-// for EVERY job that reaches effectiveStatus:'completed' — not just a
-// retention-aged one), and the very next reconcile() pass (spawnJob's own
-// broadcast({flush:true}) right after finishing) then finds the row's PRD
-// gone and backfills+drops it from queue.json into history.jsonl in that
-// SAME pass — see scheduler-reconcile-history-backfill.test.cjs. So a job
-// that actually completed is found in EITHER queue.json OR history.jsonl,
-// never guaranteed to still be the former.
-function readTerminalRow(queuePath, projectCwd, slug) {
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  const row = jobs.find((j) => j.slug === slug);
-  if (row) return row;
-  const historyPath = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'state', 'history.jsonl');
-  if (!fs.existsSync(historyPath)) return undefined;
-  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
-  return lines.map((l) => JSON.parse(l)).reverse().find((j) => j.slug === slug);
-}
-
-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);
-}
-
-// See scheduler-quiet-machine-lease.test.cjs's identical helper: readQueue()'s
-// per-project discovery walks ~/.claude/projects/*/*.jsonl transcripts for a
-// `cwd` field to find known project queue.json shards.
-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 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: writes a marker file into its OWN process.cwd() so a
-// test can prove whether — and where — it was actually spawned, then emits a
-// clean stream-json success result.
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({
-    allowCommitUnder: os.tmpdir(),
-    body: `
-    const fs = require('fs');
-    const path = require('path');
-    const { execFileSync } = require('child_process');
-    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
-    // Land a real commit + finish-protocol sentinel when possible, so a run
-    // that actually reaches the finish protocol lands 'completed' — a
-    // best-effort no-op when the cwd isn't a git repo (e.g. the non-git
-    // fallback case), where the run parks in needs_review instead, which is
-    // fine — this test only cares whether it ran in place, not its verdict.
-    try {
-      runGit(['add', '-A']);
-      runGit(['commit', '-q', '-m', 'stub commit']);
-    } catch { /* not a git repo — best-effort only */ }
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
-    process.exit(0);
-  `,
-  });
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-'));
-  process.env.HOME = tmpHome;
-  originalMax = process.env.SM_JOB_WORKTREE_MAX;
-  ({ spawnJob } = require('../scheduler.cjs'));
-  gitWorktree = require('../lib/gitWorktree.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalMax === undefined) delete process.env.SM_JOB_WORKTREE_MAX;
-  else process.env.SM_JOB_WORKTREE_MAX = originalMax;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  delete process.env.SM_JOB_WORKTREE_MAX;
-  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
-});
-
-test('a job held behind the worktree cap stays pending with a heldReason, is never spawned in place, and dispatches once the cap frees up', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  const slug = `1112-test-held-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  // Epic-scoped, not the legacy flat prds/ dir: the flat dir is retired and
-  // swept into prds-archived/ by consolidateFlatPrds on every reconcile()
-  // pass once a row is no longer 'pending'/'running' — which would strand
-  // this test's row the moment it completes (reconcile()'s terminal-job
-  // "PRD gone -> archived on purpose" drop, see
-  // scheduler-reconcile-history-backfill.test.cjs).
-  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`), 'Held behind the worktree cap.', 'utf8');
-  const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);
-
-  process.env.SM_JOB_WORKTREE_MAX = '1';
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  // Occupy the single worktree slot with a REAL checkout, so the cap check
-  // spawnJob relies on is exercising the actual gitWorktree plumbing, not a
-  // mock.
-  const occupier = await gitWorktree.createJobWorktree({ cwd: projectCwd, slug: 'occupier' });
-  expect(occupier.ok).toBe(true);
-
-  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);
-
-    // Held: still pending, never spawned, heldReason visible on the row.
-    let jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    let row = jobs.find((j) => j.slug === slug);
-    expect(row.status).toBe('pending');
-    expect(row.heldReason).toMatch(/worktree cap reached/);
-    expect(fs.existsSync(path.join(projectCwd, 'ran-here.marker'))).toBe(false);
-    expect(fs.existsSync(path.join(occupier.dir, 'ran-here.marker'))).toBe(false);
-
-    // Free the cap (mirrors cleanupJobWorktree releasing the counter), then
-    // retry — the held job dispatches on this next pass, exactly like a
-    // sessionSlots-blocked job retries once a slot frees up.
-    await gitWorktree.cleanupJobWorktree({ cwd: projectCwd, dir: occupier.dir, branch: occupier.branch });
-
-    await spawnJob({ slug, cwd: projectCwd }, `${runId}-2`, runDir, projectCwd);
-
-    row = readTerminalRow(queuePath, projectCwd, slug);
-    expect(row).toBeTruthy();
-    expect(row.status).toBe('completed');
-    expect(row.heldReason).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);
-
-test('a non-git cwd still falls back to running in place (unchanged behaviour — only cap-reached is a deferral)', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-nongit-'));
-  fs.mkdirSync(projectCwd, { recursive: true }); // deliberately NOT a git repo
-  registerActiveProject(projectCwd);
-
-  const slug = `1112-test-nongit-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  // Epic-scoped — see the sibling test above for why not the flat prds/ dir.
-  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`), 'Non-git cwd, must run in place.', 'utf8');
-  const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);
-
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  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);
-    // Not held/deferred — it actually ran (a non-git cwd can't commit, so it
-    // parks in needs_review rather than completed; this test only cares that
-    // it was dispatched in place, not its exact verdict).
-    expect(row.status).not.toBe('pending');
-    expect(row.heldReason).toBeUndefined();
-    expect(row.worktreeFallbackReason).toMatch(/not a git repository/);
-    // Ran IN PLACE — the marker landed directly in projectCwd, not a worktree.
-    expect(fs.existsSync(path.join(projectCwd, 'ran-here.marker'))).toBe(true);
-
-    // A job losing worktree isolation must never be a silent downgrade
-    // discoverable only by reading queue.json afterwards — it must also land
-    // as a warn line in the durable ops error log, naming the slug, cwd, and
-    // reason.
-    const { todayFile } = require('../lib/opsErrorLog.cjs');
-    const errorLogPath = todayFile(projectCwd);
-    expect(fs.existsSync(errorLogPath)).toBe(true);
-    const logLines = fs.readFileSync(errorLogPath, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
-    const fallbackLine = logLines.find((l) => l.scope === 'scheduler' && l.level === 'warn' && l.message.includes(slug));
-    expect(fallbackLine).toBeTruthy();
-    expect(fallbackLine.message).toMatch(/SHARED working tree/);
-    expect(fallbackLine.message).toMatch(/not a git repository/);
-    expect(fallbackLine.meta).toMatchObject({ slug, cwd: projectCwd, reason: expect.stringMatching(/not a git repository/) });
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);

package/src/main/__tests__/scheduler-worktree-exec-cwd.test.cjs

@@ -1,120 +0,0 @@
-/**
- * scheduler-worktree-exec-cwd.test.cjs — PRD 994, LOAD-BEARING acceptance
- * criterion: when a job is isolated into a worktree, its PRD file, queue
- * state, and run logs must still resolve to the MAIN tree, never the
- * worktree — `session-manager-operations/` is resolved from a `cwd` param
- * (lib/prdLocations.cjs), so a naive cwd swap would give the job a
- * different, empty ops root and orphan its own PRD.
- *
- * Drives executeJob's real `execCwd` parameter (the 5th arg scheduler.cjs
- * passes when a worktree was created) with a stub `claude` binary, proving:
- *   1. the child process's OWN cwd is the worktree dir (execCwd) — verified
- *      by having the stub write a marker file to `process.cwd()`;
- *   2. the PRD source is still found via job.cwd (the main tree) even though
- *      the worktree dir has no PRD file in it at all;
- *   3. the run's meta.json still records job.cwd, not the worktree dir.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-worktree-exec-cwd.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');
-
-let tmpHome;
-let originalHome;
-let executeJob;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-execcwd-'));
-  process.env.HOME = tmpHome;
-  ({ executeJob } = require('../scheduler.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-// Stub `claude` binary: writes a marker file into its OWN process.cwd() (proving
-// where it actually ran), captures the '-p' prompt, then emits a stream-json
-// success result and exits 0.
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-test('executeJob spawns the child in execCwd (worktree) while resolving the PRD from job.cwd (main tree)', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-main-'));
-  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-exec-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-worktree-run-'));
-
-  try {
-    const slug = `994-test-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
-    fs.mkdirSync(prdsDir, { recursive: true });
-    const bodyText = 'Do the isolated-worktree thing.';
-    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), bodyText, 'utf8');
-
-    process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-    const job = { slug, cwd: mainCwd };
-    const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve(), worktreeCwd);
-
-    expect(result.exitCode).toBe(0);
-
-    // 1. The child process really ran with cwd = worktreeCwd, not mainCwd.
-    expect(fs.existsSync(path.join(worktreeCwd, 'ran-here.marker'))).toBe(true);
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(false);
-
-    // 2. The PRD source itself is untouched — resolved via job.cwd, not execCwd.
-    const onDiskPrd = fs.readFileSync(path.join(prdsDir, `${slug}.md`), 'utf8');
-    expect(onDiskPrd).toBe(bodyText);
-
-    // 3. The run's meta.json records job.cwd (the main tree), not the worktree.
-    const metaPath = path.join(runDir, `${slug}.meta.json`);
-    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    expect(meta.cwd).toBe(mainCwd);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-    fs.rmSync(worktreeCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-test('executeJob falls back to job.cwd for the spawn cwd when no execCwd is supplied (unchanged behaviour)', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-fallback-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-worktree-run2-'));
-  try {
-    const slug = `994-test-fallback-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
-    fs.mkdirSync(prdsDir, { recursive: true });
-    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'no worktree here', 'utf8');
-    process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-    const job = { slug, cwd: mainCwd };
-    const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
-
-    expect(result.exitCode).toBe(0);
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(true);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-writeprd-epic-rollback.test.cjs

@@ -1,105 +0,0 @@
-/**
- * scheduler-writeprd-epic-rollback.test.cjs — remote.writePrd may only JOIN
- * an existing, already-human-approved Epic (via `sourcePromptId`); it must
- * never mint a new one (no mintAuthority, see epicMint.cjs's ensureEpic).
- * A write with no resolvable Epic fails outright with zero residual
- * active-index.json entries — no orphaned Epic can ever be left behind by
- * this path because none is ever created by it.
- *
- * A PRD write that joins a pre-existing Epic and then fails (e.g. an invalid
- * slug) must leave that Epic's history untouched.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-writeprd-epic-rollback.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { remote } = require('../scheduler.cjs');
-const { ensureEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-const config = require('../config.cjs');
-
-const tmpDirs = [];
-
-function makeFixtureCwd() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-writeprd-epic-rollback-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-afterEach(() => {
-  while (tmpDirs.length) {
-    const dir = tmpDirs.pop();
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// A slug that escapes safeSlugPathIn's containment check, tripping the
-// "invalid slug" branch of writePrd (scheduler.cjs's writePrd). Only the
-// second test below (joining a pre-existing Epic) actually reaches this
-// check — the first test fails earlier, at Epic resolution, before the slug
-// is ever considered.
-const ESCAPING_SLUG = '../escape-attempt';
-
-test('writePrd: no sourcePromptId refuses to write (no Epic to join) and mints nothing', async () => {
-  const cwd = makeFixtureCwd();
-  const body = '---\ntitle: No epic given\n---\n\nbody text\n';
-
-  const result = await remote.writePrd(ESCAPING_SLUG, body, cwd);
-
-  expect(result.ok).toBe(false);
-  expect(result.error).toMatch(/no existing Epic to join/);
-
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(0);
-  expect(Object.keys(index.events)).toHaveLength(0);
-});
-
-test('writePrd: invalid-slug failure when joining a pre-existing Epic leaves that Epic untouched', async () => {
-  const cwd = makeFixtureCwd();
-
-  const preexisting = await ensureEpic(cwd, { goalText: 'pre-existing epic goal', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-  expect(preexisting.created).toBe(true);
-
-  const beforeIndex = readActiveIndex(cwd);
-  expect(Object.keys(beforeIndex.sessions)).toEqual([preexisting.epicId]);
-
-  const body = `---\ntitle: Joins the existing epic\nsourcePromptId: ${preexisting.epicId}\n---\n\nbody text\n`;
-  const result = await remote.writePrd(ESCAPING_SLUG, body, cwd);
-
-  expect(result.ok).toBe(false);
-  expect(result.error).toBe('invalid slug');
-
-  const afterIndex = readActiveIndex(cwd);
-  expect(Object.keys(afterIndex.sessions)).toEqual([preexisting.epicId]);
-  expect(afterIndex.sessions[preexisting.epicId]).toEqual(beforeIndex.sessions[preexisting.epicId]);
-  expect(afterIndex.events[preexisting.epicId]).toEqual(beforeIndex.events[preexisting.epicId]);
-});
-
-// Provenance (PRD 905): writePrd's ensureEpic call passes
-// source: { producer: 'scheduler-dispatch', prdSlug }, but this call is
-// join-only (no mintAuthority, explicit epicId) — ensureEpic's
-// explicitEpicId branch returns before ever reading `source`, so a
-// successful join must NOT write/alter the joined Epic's `source` field.
-test('writePrd: successful join does not write a source field onto the pre-existing Epic (join-only no-op)', async () => {
-  // Must live under the home dir — config.cjs's writeTextAtomic validates
-  // paths against allowedRoots=home dir, unlike the failure-path tests above
-  // (which never reach the write) os.tmpdir() is not sufficient here.
-  const cwd = fs.mkdtempSync(path.join(os.homedir(), '.sm-writeprd-epic-source-'));
-  tmpDirs.push(cwd);
-  config.addAllowedRoot(cwd);
-
-  const preexisting = await ensureEpic(cwd, { goalText: 'pre-existing epic goal for join', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-  expect(preexisting.created).toBe(true);
-
-  const body = `---\ntitle: Joins the existing epic\nsourcePromptId: ${preexisting.epicId}\n---\n\nbody text\n`;
-  const result = await remote.writePrd('valid-slug', body, cwd);
-
-  expect(result.ok).toBe(true);
-
-  const index = readActiveIndex(cwd);
-  expect('source' in index.sessions[preexisting.epicId]).toBe(false);
-});