claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/scheduler-porcelain-rename.test.cjs

@@ -1,164 +0,0 @@
-/**
- * scheduler-porcelain-rename.test.cjs — PRD 1187/1186-follow-on: a staged
- * rename ("R  old -> new") was parsed by `parsePorcelainEntries` as ONE fused
- * path string `"old -> new"`. That string can never match a real path in
- * `dirtyAfter`, `pathsCommittedDuringRun`, or an `fs.existsSync` check, so
- * every staged rename in a shared-tree-guard baseline was structurally
- * guaranteed to be reported reverted — even when it was cleanly committed
- * during the run. On 2026-09-12 this flagged 45 paths and parked a clean,
- * committed run (job `1187-autoresolve-guard-verdict-parks`):
- *
- *   "job discarded pre-existing state in the shared tree: 45 path(s)
- *   reverted with no commit to explain it
- *   (scripts/__tests__/manual-chapter-links.test.cjs ->
- *   web/manual/__tests__/chapter-links.test.cjs, ...)" — exit 0, landedCommit
- *   recorded, nothing actually lost.
- *
- * Every test below is written to FAIL against the pre-fix implementation
- * (`path: l.slice(3)`, no rename/quote parsing at all).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-porcelain-rename.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const scheduler = require('../scheduler.cjs');
-const { parsePorcelainEntries, evaluateSharedTreeGuard } = scheduler;
-
-// --- parsePorcelainEntries: rename/copy lines split into real components ---
-
-test('parsePorcelainEntries: a plain staged rename splits into new path + oldPath, not one fused string', () => {
-  const entries = parsePorcelainEntries('R  old.txt -> new.txt\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a rename-with-worktree-modification (RM) line still splits correctly', () => {
-  const entries = parsePorcelainEntries('RM old.txt -> new.txt\n');
-  expect(entries).toEqual([{ code: 'RM', path: 'new.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a copy line (C) splits the same way as a rename', () => {
-  const entries = parsePorcelainEntries('C  old.txt -> copy.txt\n');
-  expect(entries).toEqual([{ code: 'C ', path: 'copy.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a NEW path containing a space is quoted by git and must be unquoted', () => {
-  // Real `git status --porcelain` output for `git mv new.txt "renamed with space.txt"`.
-  const entries = parsePorcelainEntries('R  new.txt -> "renamed with space.txt"\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'renamed with space.txt', oldPath: 'new.txt' }]);
-});
-
-test('parsePorcelainEntries: an OLD path containing a space is quoted independently of the new path', () => {
-  const entries = parsePorcelainEntries('R  "old with space.txt" -> new.txt\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old with space.txt' }]);
-});
-
-test('parsePorcelainEntries: a non-ASCII path is quoted with per-byte octal escapes and must decode back to UTF-8', () => {
-  // Real recorded `git status --porcelain` output for a rename onto
-  // "résumé file.txt" — git's default core.quotepath escapes each raw UTF-8
-  // byte >= 0x80 as \NNN octal: 'é' is UTF-8 bytes 0xC3 0xA9 -> \303\251.
-  const line = 'R  new.txt -> "r\\303\\251sum\\303\\251 file.txt"\n';
-  const entries = parsePorcelainEntries(line);
-  expect(entries).toEqual([{ code: 'R ', path: 'résumé file.txt', oldPath: 'new.txt' }]);
-});
-
-test('parsePorcelainEntries: non-rename entries are unaffected (no oldPath, path as before)', () => {
-  const entries = parsePorcelainEntries(' M src/foo.js\n?? untracked.txt\n');
-  expect(entries).toEqual([
-    { code: ' M', path: 'src/foo.js' },
-    { code: '??', path: 'untracked.txt' },
-  ]);
-});
-
-test('parsePorcelainEntries: a quoted plain (non-rename) path is also unquoted, not left with literal quotes', () => {
-  const entries = parsePorcelainEntries('?? "plain space.txt"\n');
-  expect(entries).toEqual([{ code: '??', path: 'plain space.txt' }]);
-});
-
-// --- The exact 1187 shape: committed rename must not be flagged reverted ---
-
-test('evaluateSharedTreeGuard: a staged rename that is committed during the run is NOT reported reverted (real 1187 case)', () => {
-  const oldPath = 'scripts/__tests__/manual-chapter-links.test.cjs';
-  const newPath = 'web/manual/__tests__/chapter-links.test.cjs';
-  const dirtyBefore = parsePorcelainEntries(`R  ${oldPath} -> ${newPath}\n`);
-  // git diff --name-only <headBefore>..<headAfter> reports only the NEW path
-  // for a committed rename (verified against real git 2.43 behavior).
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [], // fully committed, nothing left dirty
-    pathsCommittedDuringRun: [newPath],
-  });
-  expect(result.reverted).toEqual([]);
-});
-
-test('evaluateSharedTreeGuard: a batch of committed renames (the real 45-path shape) are all cleared, none reverted', () => {
-  const pairs = [
-    ['scripts/__tests__/manual-chapter-links.test.cjs', 'web/manual/__tests__/chapter-links.test.cjs'],
-    ['scripts/foo-old.js', 'src/foo-new.js'],
-    ['docs/old-name.md', 'docs/new-name.md'],
-  ];
-  const porcelain = pairs.map(([o, n]) => `R  ${o} -> ${n}`).join('\n') + '\n';
-  const dirtyBefore = parsePorcelainEntries(porcelain);
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [],
-    pathsCommittedDuringRun: pairs.map(([, n]) => n),
-  });
-  expect(result.reverted).toEqual([]);
-});
-
-// --- The guard's real purpose survives: an UNDONE rename still parks ---
-
-test('evaluateSharedTreeGuard: a staged rename that is UNDONE (old path restored, new path gone, nothing committed) IS still reported reverted', () => {
-  // This test must FAIL if the fix is implemented as "blanket skip rename
-  // entries" (dropping every rename-coded entry from consideration would
-  // make `reverted` come back empty here, exactly like the committed case
-  // above — but here nothing was committed to explain the disappearance).
-  const dirtyBefore = parsePorcelainEntries('R  old.txt -> new.txt\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [], // clean again — reverted to HEAD, old.txt restored, new.txt gone
-    pathsCommittedDuringRun: [], // nothing committed
-  });
-  expect(result.reverted).toEqual(['new.txt']);
-});
-
-// --- The two already-fixed false-positive classes stay fixed (pinned here
-// too, using parsePorcelainEntries as the real entry point rather than
-// hand-built fixtures, so a future change to the parser can't silently
-// regress them without failing a test right next to the rename fix). ---
-
-test('evaluateSharedTreeGuard: nowIgnored still works for a real parsePorcelainEntries untracked baseline entry', () => {
-  const dirtyBefore = parsePorcelainEntries('?? session-manager-operations/logs/errors-2026-09-12.jsonl\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [],
-    pathsCommittedDuringRun: ['.gitignore'],
-    existsAfter: ['session-manager-operations/logs/errors-2026-09-12.jsonl'],
-  });
-  expect(result.reverted).toEqual([]);
-  expect(result.nowIgnored).toEqual(['session-manager-operations/logs/errors-2026-09-12.jsonl']);
-});
-
-test('evaluateSharedTreeGuard: a genuine deletion of an untracked path (from a real parsePorcelainEntries entry) is still reverted', () => {
-  const dirtyBefore = parsePorcelainEntries('?? data/scratch.txt\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-    existsAfter: [],
-  });
-  expect(result.reverted).toEqual(['data/scratch.txt']);
-  expect(result.nowIgnored).toEqual([]);
-});

package/src/main/__tests__/scheduler-prd-missing-skip.test.cjs

@@ -1,161 +0,0 @@
-/**
- * scheduler-prd-missing-skip.test.cjs — regression test for PRD 812's
- * failure-classification fix: a queued job whose PRD source has disappeared
- * between enqueue and dispatch (e.g. a test fixture that leaked into the
- * live queue and was cleaned up before the job ran) must be retired as a
- * stale row (exitCode: 0, skipped: 'prd-missing'), not treated as a hard
- * job failure (exitCode: -1). A genuinely unreadable/unparseable PRD (a
- * real, non-ENOENT error) must still fail with exitCode: -1.
- *
- * HOME-isolated per the same incident: stub HOME to a mkdtemp dir before
- * requiring scheduler.cjs, and never write into the real scheduler root.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-missing-skip.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 executeJob;
-let spawnJob;
-let PRDS_DIR;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-skip-'));
-  process.env.HOME = tmpHome;
-
-  ({ executeJob, spawnJob, 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})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('a job whose PRD source is gone everywhere is retired, not failed', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-project-'));
-  // config.cjs's writeJsonSync (used for the job's meta.json) restricts
-  // writes to WRITE_PREFIXES, which includes `<home>/.claude` — so runDir
-  // must live under the stubbed tmpHome's .claude/, not the system tmpdir.
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-missing-run-'));
-  try {
-    const slug = `812-test-missing-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const job = { slug, cwd: projectCwd };
-
-    const result = await executeJob(job, runDir, projectCwd, () => {});
-
-    expect(result.exitCode).toBe(0);
-    expect(result.skipped).toBe('prd-missing');
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-test('a job whose PRD source exists but is unreadable for a non-ENOENT reason still fails', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-toobig-project-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-toobig-run-'));
-  try {
-    const slug = `812-test-toobig-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
-    fs.mkdirSync(prdsDir, { recursive: true });
-    // parsePrd rejects any PRD over 1MB with a plain Error (no .code) — this
-    // is the "found but unparseable" case, distinct from ENOENT, and must
-    // stay a real failure.
-    const oversized = '---\ntitle: too big\n---\n\n' + 'x'.repeat(1024 * 1024 + 1);
-    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), oversized, 'utf8');
-
-    const job = { slug, cwd: projectCwd };
-    const result = await executeJob(job, runDir, projectCwd, () => {});
-
-    expect(result.exitCode).toBe(-1);
-    expect(result.skipped).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-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');
-}
-
-// This test's whole premise is a PRD source missing EVERYWHERE — so the row
-// this produces is exactly what reconcile()'s auto-archive-drop path treats
-// as "archived on purpose": backfilled to history.jsonl and dropped from
-// queue.json in the very same reconcile pass that spawnJob's own
-// broadcast({flush:true}) triggers on completion (see
-// scheduler-reconcile-history-backfill.test.cjs). Look in both places.
-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);
-}
-
-// This is the actual regression case: PRD 812's fix only covered executeJob's
-// own return value. The bug lived one layer up, in spawnJob's post-run
-// handler, which only short-circuited on skipped === 'prd-archived' and let
-// 'prd-missing' fall through into the verify path meant for real runs —
-// downgrading a stale-queue-entry retire into a needs_review with a bogus RCA
-// feedback item. Drive spawnJob itself (not just executeJob) so this covers
-// the actual defect, not just the classification it depends on.
-test("spawnJob's post-run handler retires a prd-missing skip as a plain completion, without running verify", async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-spawnjob-project-'));
-  registerActiveProject(projectCwd);
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-missing-spawnjob-run-'));
-  try {
-    const slug = `812-test-spawnjob-missing-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const queuePath = writeProjectQueue(projectCwd, [
-      { slug, status: 'pending', cwd: projectCwd },
-    ]);
-
-    const job = { slug, cwd: projectCwd };
-    await spawnJob(job, 'run-spawnjob-missing', runDir, projectCwd);
-
-    const row = readTerminalRow(queuePath, projectCwd, slug);
-    expect(row).toBeDefined();
-    // A 'prd-missing' skip means no executor ever ran — it must land on the
-    // distinct 'skipped' status, never 'completed' (the status a genuine
-    // successful run produces), so unrun work can never masquerade as done.
-    expect(row.status).toBe('skipped');
-    expect(row.status).not.toBe('completed');
-    expect(row.exitCode).toBe(0);
-    expect(row.error).toBeNull();
-    // No verify pass ran and no RCA feedback fired: a verified run always
-    // stamps a verify-derived status ('needs_review') or a landedCommit/verify
-    // field onto the row. Neither is present here — the row was completed by
-    // the early-return skip branch, not the verification block further down.
-    expect(row.status).not.toBe('needs_review');
-    expect(row.landedCommit).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-prd-persona-spawn.test.cjs

@@ -1,178 +0,0 @@
-/**
- * scheduler-prd-persona-spawn.test.cjs — PRD 1115: a PRD's `agentType`
- * frontmatter must actually drive the headless spawn (--append-system-prompt
- * with the persona's frontmatter-stripped, capped body, and --model with the
- * persona's own model), not just sit in the prompt as prose the executor may
- * or may not obey. Covers buildClaudeSpawnArgs' pure argv shape plus a real
- * executeJob spawn (stub `claude` binary) proving the resolved persona
- * actually reaches the child process, and that a dangling agentType still
- * runs the job to completion (never parks or fails it).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-persona-spawn.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;
-let buildClaudeSpawnArgs;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-spawn-'));
-  process.env.HOME = tmpHome;
-  ({ executeJob, buildClaudeSpawnArgs } = require('../scheduler.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-// ---------- buildClaudeSpawnArgs: systemPrompt -> --append-system-prompt ----------
-
-test('buildClaudeSpawnArgs: a given systemPrompt is passed via --append-system-prompt', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'opus', sessionId: 'sid', resume: false, systemPrompt: 'You are dev-lead.' });
-  const idx = args.indexOf('--append-system-prompt');
-  expect(idx).toBeGreaterThanOrEqual(0);
-  expect(args[idx + 1]).toBe('You are dev-lead.');
-});
-
-test('buildClaudeSpawnArgs: omits --append-system-prompt entirely when systemPrompt is absent', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'sonnet', sessionId: 'sid', resume: false });
-  expect(args).not.toContain('--append-system-prompt');
-});
-
-test('buildClaudeSpawnArgs: model is never omitted even without a systemPrompt', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false });
-  const idx = args.indexOf('--model');
-  expect(idx).toBeGreaterThanOrEqual(0);
-  expect(args[idx + 1]).toBe('sonnet');
-});
-
-// ---------- real spawn: persona actually reaches the child process ----------
-
-// Stub `claude` binary: dumps its own argv into a marker file, then emits a
-// stream-json success result and exits 0 — same technique as
-// scheduler-bash-timeout-env.test.cjs's env-var proof, applied to argv.
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'argv.marker'), JSON.stringify(process.argv.slice(2)), 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-function writePersona(dir, name, frontmatterLines, bodyText) {
-  fs.mkdirSync(dir, { recursive: true });
-  const lines = ['---', `name: ${name}`, ...frontmatterLines, '---', bodyText];
-  fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
-}
-
-async function runJobWithAgentType({ agentType, overlay }) {
-  // Under tmpHome so config.validatePath's home-dir boundary admits the project overlay.
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-prd-persona-main-'));
-  if (overlay) writePersona(path.join(mainCwd, '.claude', 'agents'), overlay.name, overlay.frontmatter, overlay.body || '');
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-persona-run-'));
-  const slug = `1115-test-${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`), 'Do the thing.', 'utf8');
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  const job = { slug, cwd: mainCwd, agentType };
-  const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
-  const argv = JSON.parse(fs.readFileSync(path.join(mainCwd, 'argv.marker'), 'utf8'));
-  fs.rmSync(mainCwd, { recursive: true, force: true });
-  fs.rmSync(runDir, { recursive: true, force: true });
-  return { result, argv };
-}
-
-test('executeJob: a resolvable agentType reaches the spawned child as --append-system-prompt + --model', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'dev-lead', ['model: opus'], 'You are dev-lead. Ship it.');
-
-  const { result, argv } = await runJobWithAgentType({ agentType: 'dev-lead' });
-
-  expect(result.exitCode).toBe(0);
-  const spIdx = argv.indexOf('--append-system-prompt');
-  expect(spIdx).toBeGreaterThanOrEqual(0);
-  expect(argv[spIdx + 1]).toBe('You are dev-lead. Ship it.');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('opus');
-});
-
-test('executeJob: a dangling agentType (no resolvable persona file) still runs the job to completion, falling back to sonnet with no --append-system-prompt', async () => {
-  const { result, argv } = await runJobWithAgentType({ agentType: 'renamed-or-deleted-persona' });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv).not.toContain('--append-system-prompt');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('sonnet');
-});
-
-test('executeJob: a job with no agentType at all runs unaffected (no persona, sonnet fallback)', async () => {
-  const { result, argv } = await runJobWithAgentType({ agentType: null });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv).not.toContain('--append-system-prompt');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('sonnet');
-});
-
-// ---------- persona effort → --effort ----------
-
-test('buildClaudeSpawnArgs: effort appends --effort <level>; null/inherit/absent add no token', () => {
-  const base = { prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false };
-  const args = buildClaudeSpawnArgs({ ...base, effort: 'high' });
-  expect(args[args.indexOf('--effort') + 1]).toBe('high');
-  expect(args.indexOf('--model')).toBeGreaterThanOrEqual(0);
-  for (const effort of [null, 'inherit', undefined]) {
-    expect(buildClaudeSpawnArgs({ ...base, effort })).not.toContain('--effort');
-  }
-});
-
-test('executeJob: persona effort reaches the child as --effort; inherit yields no --effort token', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'effort-high', ['model: opus', 'effort: high'], 'body');
-  writePersona(globalAgentsDir, 'effort-inherit', ['model: opus', 'effort: inherit'], 'body');
-
-  const high = await runJobWithAgentType({ agentType: 'effort-high' });
-  expect(high.argv[high.argv.indexOf('--effort') + 1]).toBe('high');
-  expect(high.argv[high.argv.indexOf('--model') + 1]).toBe('opus');
-
-  const inherit = await runJobWithAgentType({ agentType: 'effort-inherit' });
-  expect(inherit.argv).not.toContain('--effort');
-  expect(inherit.argv).not.toContain('inherit');
-});
-
-// ---------- project overlay MERGE: frontmatter-only overlay patches the runtime fields ----------
-
-test('executeJob: a frontmatter-only project overlay changes --model/--effort while the global persona body still reaches --append-system-prompt', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'dev-lead', ['model: sonnet'], 'You are dev-lead. Global body.');
-
-  const { result, argv } = await runJobWithAgentType({
-    agentType: 'dev-lead',
-    overlay: { name: 'dev-lead', frontmatter: ['model: claude-opus-4-6', 'effort: high'], body: '' },
-  });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv[argv.indexOf('--model') + 1]).toBe('claude-opus-4-6');
-  expect(argv[argv.indexOf('--effort') + 1]).toBe('high');
-  expect(argv[argv.indexOf('--append-system-prompt') + 1]).toBe('You are dev-lead. Global body.');
-});

package/src/main/__tests__/scheduler-quarantine-autoresolve.test.cjs

@@ -1,165 +0,0 @@
-/**
- * scheduler-quarantine-autoresolve.test.cjs
- *
- * Covers the bounded automatic exit for a quarantined row that never
- * received a `createdVia` provenance stamp (this PRD): the pure selector
- * `selectQuarantineAutoResolveTargets`, the async applier
- * `autoResolveQuarantine` (which re-reads the PRD file's frontmatter fresh
- * from disk immediately before transitioning, so it can never race
- * reconcile()'s own adopt path), and the kill switch
- * `quarantineAutoResolveDisabled`.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
- * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
- * under $HOME/.claude/session-manager/audit-log.jsonl).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-quarantine-autoresolve.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(), 'quarantine-autoresolve-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  selectQuarantineAutoResolveTargets,
-  autoResolveQuarantine,
-  QUARANTINE_RESOLVE_CAP,
-  quarantineAutoResolveDisabled,
-} = require('../scheduler.cjs');
-
-const MIN_MS = 60_000;
-const THRESHOLD_MS = 60 * MIN_MS;
-
-function quarantinedJob(overrides = {}) {
-  return {
-    slug: 'quarantined-row',
-    cwd: '/home/user/project',
-    status: 'quarantined',
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 90 * MIN_MS).toISOString() }],
-    ...overrides,
-  };
-}
-
-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);
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-epic-1', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  return { cwd, prdsDir };
-}
-
-// --- selectQuarantineAutoResolveTargets ---
-
-test('a fresh quarantined row (under threshold) is not selected', () => {
-  const job = quarantinedJob({
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
-  });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a non-quarantined status is never selected', () => {
-  const job = quarantinedJob({ status: 'failed' });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a quarantined row with no statusHistory entry cannot have its age proven, and is skipped', () => {
-  const job = quarantinedJob({ statusHistory: [] });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a quarantined row past threshold, under the cap, is selected', () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: 0 });
-  const found = selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, 'quarantined-row');
-  assert.ok(found[0].ageMs >= 90 * MIN_MS - 1000);
-});
-
-test('a quarantined row that already spent its resolve cap is excluded', () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('quarantineAutoResolveDisabled reflects SM_QUARANTINE_AUTORESOLVE_DISABLE', () => {
-  const saved = process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-  try {
-    delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-    assert.equal(quarantineAutoResolveDisabled(), false);
-    process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = '1';
-    assert.equal(quarantineAutoResolveDisabled(), true);
-  } finally {
-    if (saved === undefined) delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-    else process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = saved;
-  }
-});
-
-// --- autoResolveQuarantine: the applier ---
-
-test('a quarantined row whose PRD file still has no createdVia is auto-resolved to skipped', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-noprovenance-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, 'quarantined-row.md'),
-      `---\ntitle: Unstamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
-    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-    assert.equal(outcome, 'skipped');
-    assert.equal(job.status, 'skipped');
-    assert.equal(job.quarantineResolveAttempts, 1);
-    assert.ok(typeof job.error === 'string' && /createdVia/.test(job.error));
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('a quarantined row whose PRD file HAS been stamped with createdVia is left alone — reconcile owns it now', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-stamped-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, 'quarantined-row.md'),
-      `---\ntitle: Stamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
-    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-    assert.equal(outcome, null);
-    assert.equal(job.status, 'quarantined'); // untouched — the adopt path owns the next pass
-    assert.equal(job.quarantineResolveAttempts, 0);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('autoResolveQuarantine race-guards against a row that moved off quarantined', async () => {
-  const job = quarantinedJob({ status: 'pending', quarantineResolveAttempts: 0 });
-  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
-  assert.equal(job.status, 'pending'); // untouched
-});
-
-test('autoResolveQuarantine race-guards against a row whose resolve cap is already spent', async () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
-  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
-  assert.equal(job.status, 'quarantined'); // untouched
-});
-
-test('a quarantined row whose PRD file is missing entirely is treated as still lacking provenance and auto-resolved', async () => {
-  const job = quarantinedJob({ cwd: '/nonexistent/project/path', quarantineResolveAttempts: 0 });
-  const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-  assert.equal(outcome, 'skipped');
-  assert.equal(job.status, 'skipped');
-});