claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-reaper-helpers-basics.test.cjs

@@ -1,87 +0,0 @@
-'use strict';
-
-// Ported from the retired top-level test-root directory (a node:test suite,
-// never runnable by this repo's vitest-only setup — see CLAUDE.md's Commands
-// section). The existing src/main/lib/__tests__/reaperHelpers.test.cjs
-// exercises classifyRunOutcome extensively via selectReapableJobs and the
-// rate-limit paths, but never asserts claudePidAlive directly (only ever
-// injects a stand-in `pidAlive` function), and never pins the bare
-// no-result/empty-file/malformed-event edge cases below. These fill that
-// gap.
-//
-// Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reaper-helpers-basics.test.cjs
-
-const assert = require('node:assert/strict');
-const os = require('node:os');
-const path = require('node:path');
-const fs = require('node:fs');
-const { claudePidAlive, classifyRunOutcome } = require('../lib/reaperHelpers.cjs');
-
-// ─────────────────────────────────────────── claudePidAlive
-
-test('claudePidAlive: nonexistent pid (999999) returns false', () => {
-  assert.equal(claudePidAlive(999999), false);
-});
-
-test('claudePidAlive: pid 0 returns false', () => {
-  assert.equal(claudePidAlive(0), false);
-});
-
-test('claudePidAlive: pid 1 returns false', () => {
-  assert.equal(claudePidAlive(1), false);
-});
-
-test('claudePidAlive: null returns false', () => {
-  assert.equal(claudePidAlive(null), false);
-});
-
-test('claudePidAlive: undefined returns false', () => {
-  assert.equal(claudePidAlive(undefined), false);
-});
-
-// ─────────────────────────────────────────── classifyRunOutcome
-
-function writeTempLog(content) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'reaper-basics-test-'));
-  const filePath = path.join(dir, 'test.log');
-  fs.writeFileSync(filePath, content, 'utf8');
-  return filePath;
-}
-
-test('classifyRunOutcome: success without an is_error field → success', () => {
-  const p = writeTempLog('{"type":"result","subtype":"success","result":"ok"}\n');
-  assert.equal(classifyRunOutcome(p), 'success');
-});
-
-test('classifyRunOutcome: subtype success but is_error:true → failed (error wins)', () => {
-  const p = writeTempLog('{"type":"result","subtype":"success","is_error":true}\n');
-  assert.equal(classifyRunOutcome(p), 'failed');
-});
-
-test('classifyRunOutcome: no result event in the tail → no_result', () => {
-  const log = [
-    '{"type":"assistant","message":"working"}',
-    '{"type":"tool_use","name":"bash"}',
-    'some plain text log line',
-  ].join('\n');
-  const p = writeTempLog(log);
-  assert.equal(classifyRunOutcome(p), 'no_result');
-});
-
-test('classifyRunOutcome: empty file → no_result', () => {
-  const p = writeTempLog('');
-  assert.equal(classifyRunOutcome(p), 'no_result');
-});
-
-test('classifyRunOutcome: last result event wins when multiple exist', () => {
-  const log = [
-    '{"type":"result","subtype":"success"}',
-    '{"type":"result","subtype":"error","is_error":true}',
-  ].join('\n');
-  const p = writeTempLog(log);
-  assert.equal(classifyRunOutcome(p), 'failed');
-});
-
-test('classifyRunOutcome: nonexistent file → no_result (readTail swallows I/O errors)', () => {
-  assert.equal(classifyRunOutcome('/nonexistent/path/that/cannot/exist.log'), 'no_result');
-});

package/src/main/__tests__/scheduler-reconcile-cwd-preserve.test.cjs

@@ -1,100 +0,0 @@
-/**
- * scheduler-reconcile-cwd-preserve.test.cjs — regression test for the
- * data-loss bug found while chasing PRD 1218's test:unit gate: reconcile()
- * rebuilt a queue row's `cwd` unconditionally from its PRD's own
- * frontmatter (`cwd: p.cwd`) at all three of its row-construction sites. A
- * PRD file with no `cwd:` frontmatter key — every hand-written or legacy PRD,
- * and every fixture in this test suite before this fix — parses to
- * `p.cwd === undefined`, which nulled the row's real, already-correct `cwd`.
- * queueStore.writeSplit's `job.cwd || defaultCwd` bucketing then relocated
- * the row into schedulerBatch.cjs's DEFAULT_PROJECT_CWD shard
- * (`~/Projects/session-manager`) — the WRONG project — while the row's own
- * project's shard was rewritten without it. A PRD's frontmatter `cwd` must
- * REFINE a row's existing `cwd`, never erase one.
- *
- * Covers the normal refresh path (an existing row matched to its PRD) and
- * the fresh-discovery path (a PRD with no prior row, falling back to the
- * project root it was actually found under via
- * prdLocations.deriveProjectCwdFromPrdPath rather than nulling to
- * DEFAULT_PROJECT_CWD).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reconcile-cwd-preserve.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 reconcile;
-let DEFAULT_PROJECT_CWD;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-cwd-preserve-'));
-  process.env.HOME = tmpHome;
-  ({ reconcile } = require('../scheduler.cjs'));
-  ({ DEFAULT_PROJECT_CWD } = require('../lib/schedulerBatch.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-// allProjectCwds()/activeProjectCwds() (queueStore.cjs's stateCwds) discover
-// project cwds by scanning ~/.claude/projects/*/*.jsonl for a `cwd` field —
-// same pattern as scheduler-reap-dead-running-jobs.test.cjs and friends.
-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');
-}
-
-test('reconcile() never nulls an existing row\'s cwd because its PRD has no cwd: frontmatter', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-cwd-preserve-project-'));
-  registerActiveProject(projectCwd);
-
-  const slug = `1218-cwd-preserve-${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 });
-  // Deliberately NO `cwd:` frontmatter key — the exact shape of every
-  // hand-written or legacy PRD that triggered the bug.
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), '# Goal\n\nNo cwd frontmatter here.\n', 'utf8');
-
-  const job = { slug, title: 'x', cwd: projectCwd, status: 'pending' };
-  const state = { jobs: [job] };
-
-  await reconcile(state);
-
-  const row = state.jobs.find((j) => j.slug === slug);
-  expect(row).toBeDefined();
-  expect(row.cwd).toBe(projectCwd);
-  expect(row.cwd).not.toBe(DEFAULT_PROJECT_CWD);
-});
-
-test('reconcile() gives a freshly-discovered, frontmatter-less PRD the project root it was actually found under, never DEFAULT_PROJECT_CWD', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-cwd-preserve-fresh-'));
-  registerActiveProject(projectCwd);
-
-  const slug = `1218-cwd-preserve-fresh-${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`), '# Goal\n\nNo cwd frontmatter here either.\n', 'utf8');
-
-  // No prior row at all — this PRD is discovered fresh by reconcile()'s own
-  // onDisk scan, not handed in via `state.jobs`.
-  const state = { jobs: [] };
-
-  await reconcile(state);
-
-  const row = state.jobs.find((j) => j.slug === slug);
-  expect(row).toBeDefined();
-  expect(row.cwd).toBe(projectCwd);
-  expect(row.cwd).not.toBe(DEFAULT_PROJECT_CWD);
-});

package/src/main/__tests__/scheduler-reconcile-history-backfill.test.cjs

@@ -1,105 +0,0 @@
-/**
- * scheduler-reconcile-history-backfill.test.cjs — regression test for the
- * bug found 2026-08-02 while investigating why session-manager's own
- * Scheduler tab showed an empty Queue AND an empty History: a completed
- * job's PRD `.md` is archived immediately (archiveCompletedPrd, called right
- * when the job finishes) — long before HISTORY_RETENTION_MS (7 days) would
- * ever cause queueHistory.partitionJobs to append it to history.jsonl. The
- * very next reconcile() pass then found the .md gone and silently dropped
- * the job's row from jobs[] via the "terminal job whose .md is gone was
- * archived on purpose" branch, without ever writing it to history.jsonl —
- * total loss of the completed job's record.
- *
- * reconcile() must now backfill history.jsonl for exactly this case before
- * dropping the row.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reconcile-history-backfill.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpDirs = [];
-
-function makeFixtureCwd() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-history-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-afterEach(() => {
-  vi.resetModules();
-  while (tmpDirs.length) {
-    const dir = tmpDirs.pop();
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() backfills history.jsonl for a completed job whose PRD file is already gone', async () => {
-  const cwd = makeFixtureCwd();
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  fs.mkdirSync(path.join(opsRoot, 'scheduler', 'prds'), { recursive: true });
-  fs.mkdirSync(path.join(opsRoot, 'scheduler', 'state'), { recursive: true });
-
-  const { reconcile } = require('../scheduler.cjs');
-
-  const job = {
-    slug: '999-vanished-prd',
-    title: 'Vanished PRD',
-    cwd,
-    status: 'completed',
-    finishedAt: new Date().toISOString(),
-    exitCode: 0,
-    error: null,
-    runId: 'run-1',
-  };
-  // No matching .md anywhere under prds/ or prds-archived/ for this slug —
-  // simulates the file having already been archived by archiveCompletedPrd
-  // in the same tick the job finished, well before this reconcile() call.
-  const state = { jobs: [job] };
-
-  await reconcile(state);
-
-  expect(state.jobs.find((j) => j.slug === job.slug)).toBeUndefined();
-
-  const historyPath = path.join(opsRoot, 'scheduler', 'state', 'history.jsonl');
-  expect(fs.existsSync(historyPath)).toBe(true);
-  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
-  const recorded = lines.map((l) => JSON.parse(l)).find((e) => e.slug === job.slug);
-  expect(recorded).toBeDefined();
-  expect(recorded.status).toBe('completed');
-  expect(recorded.runId).toBe('run-1');
-});
-
-test('reconcile() does not double-write history for a job already recorded there', async () => {
-  const cwd = makeFixtureCwd();
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  fs.mkdirSync(path.join(opsRoot, 'scheduler', 'prds'), { recursive: true });
-  const stateDir = path.join(opsRoot, 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-
-  const job = {
-    slug: '998-already-recorded',
-    title: 'Already recorded',
-    cwd,
-    status: 'completed',
-    finishedAt: new Date().toISOString(),
-    exitCode: 0,
-    error: null,
-    runId: 'run-2',
-  };
-  const historyPath = path.join(stateDir, 'history.jsonl');
-  fs.writeFileSync(historyPath, JSON.stringify(job) + '\n', 'utf8');
-
-  const { reconcile } = require('../scheduler.cjs');
-  const state = { jobs: [job] };
-  await reconcile(state);
-
-  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
-  const matches = lines.map((l) => JSON.parse(l)).filter((e) => e.slug === job.slug);
-  expect(matches.length).toBe(1);
-});

package/src/main/__tests__/scheduler-reconcile-invalid-repair.test.cjs

@@ -1,203 +0,0 @@
-/**
- * scheduler-reconcile-invalid-repair.test.cjs — end-to-end reproduction of
- * the 2026-08-07 1021/1022 incident: a queue.json row with `"status":
- * "queued"` (a value outside ScheduleJobStatus) sat unpicked for 4+ hours.
- *
- * queueStore.shapeJobs (scheduleJobSchema.cjs, landed by a prior PRD)
- * already quarantines such a row into `invalidJobs` on read rather than
- * passing it through — but reconcile() itself was still add-only (`if
- * (seen.has(slug)) continue`), so a quarantined row was never repaired, only
- * silently absent from state.jobs with no log of what its bad status had
- * been.
- *
- * This test exercises the real quarantine path (queueStore.shapeJobs on the
- * raw incident JSON) against a real on-disk PRD, runs the real reconcile(),
- * and asserts: computeStallSummary flags the PRE-repair state as stalled,
- * reconcile() repairs the row to 'pending', logs the repair at warn level,
- * and audits it.
- *
- * HOME-isolated (mirrors scheduler-prd-missing-skip.test.cjs): stub HOME to
- * a mkdtemp dir before requiring scheduler.cjs/queueStore.cjs, and register
- * the fixture project as "active" via a fake ~/.claude/projects transcript —
- * reconcile's PRD/history discovery (prdLocations.cjs, queueHistory.cjs)
- * only scans cwds it can find that way.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reconcile-invalid-repair.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-repair-home-'));
-  process.env.HOME = tmpHome;
-
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-
-  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-function makeFixtureProject(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  registerActiveProject(cwd);
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  const prdsDir = path.join(opsRoot, 'scheduler', 'prds');
-  const stateDir = path.join(opsRoot, 'scheduler', 'state');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.mkdirSync(stateDir, { recursive: true });
-  return { cwd, prdsDir, stateDir };
-}
-
-test('reconcile() repairs a queue row with an invalid status back to pending, logs, and audits it', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-reconcile-repair-proj-');
-  try {
-    // Real on-disk PRD (its file location is the reconcile source of truth).
-    fs.writeFileSync(
-      path.join(prdsDir, '1021-fix-the-thing.md'),
-      '---\ntitle: Fix the thing\ncwd: ' + cwd + '\nestimateMinutes: 15\n---\n\n# Goal\nFix it.\n',
-      'utf8',
-    );
-
-    // The exact incident shape: a row whose status is 'queued', outside
-    // ScheduleJobStatus entirely.
-    const badRow = {
-      slug: '1021-fix-the-thing',
-      title: 'Fix the thing',
-      cwd,
-      status: 'queued',
-      runId: null,
-      startedAt: null,
-      finishedAt: null,
-      exitCode: null,
-      error: null,
-    };
-    const queuePath = path.join(stateDir, 'queue.json');
-    fs.writeFileSync(queuePath, JSON.stringify({ jobs: [badRow] }, null, 2), 'utf8');
-
-    // Exercise the REAL quarantine gate (same one queueStore.readMerged runs
-    // at boot/every IPC read) rather than hand-building invalidJobs.
-    const { jobs, invalid } = queueStore.shapeJobs(fs.readFileSync(queuePath, 'utf8'), queuePath);
-    expect(jobs.length).toBe(0); // the bad row never reaches state.jobs
-    expect(invalid.length).toBe(1);
-    expect(invalid[0].slug).toBe(badRow.slug);
-    expect(invalid[0].row.status).toBe('queued');
-
-    const state = { jobs, invalidJobs: invalid, paused: null };
-
-    // Stall detector must flag the PRE-repair state: the queue holds a
-    // (quarantined) job but nothing is running or pending and it isn't
-    // paused — this is exactly the condition that was silent for 4+ hours.
-    const preRepairStall = scheduler.computeStallSummary(state);
-    expect(preRepairStall.stalled).toBe(true);
-    expect(preRepairStall.total).toBe(1);
-    expect(preRepairStall.running).toBe(0);
-    expect(preRepairStall.pending).toBe(0);
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    // scheduler.cjs destructures `appendAuditEvent` out of auditLog.cjs at
-    // require time, so spying on the module's export property after the
-    // fact wouldn't intercept scheduler.cjs's already-bound reference —
-    // assert against the real (tmpHome-isolated) audit log file instead.
-    const { auditLogPath } = require('../lib/auditLog.cjs');
-    expect(auditLogPath().startsWith(tmpHome)).toBe(true);
-
-    queueStore.bustCwdCache();
-    await scheduler.reconcile(state);
-
-    const repaired = state.jobs.find((j) => j.slug === badRow.slug);
-    expect(repaired).toBeDefined();
-    expect(repaired.status).toBe('pending');
-
-    const warnedRepair = warnSpy.mock.calls.some((args) =>
-      String(args[0]).includes('repaired invalid queue row') && String(args[0]).includes(badRow.slug),
-    );
-    expect(warnedRepair).toBe(true);
-
-    const auditLines = fs.readFileSync(auditLogPath(), 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-    const auditedRepair = auditLines.some(
-      (rec) => rec.kind === 'scheduler_row_repaired' && rec.slug === badRow.slug && rec.oldStatus === 'queued',
-    );
-    expect(auditedRepair).toBe(true);
-
-    // Post-repair, the same condition must no longer read as stalled.
-    const postRepairStall = scheduler.computeStallSummary(state);
-    expect(postRepairStall.stalled).toBe(false);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() does not resurrect an invalid row whose slug already has a terminal history record', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-reconcile-repair-done-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, '1022-already-done.md'),
-      '---\ntitle: Already done\ncwd: ' + cwd + '\nestimateMinutes: 15\n---\n\n# Goal\nDone.\n',
-      'utf8',
-    );
-
-    const badRow = {
-      slug: '1022-already-done',
-      title: 'Already done',
-      cwd,
-      status: 'queued',
-      runId: 'run-xyz',
-      startedAt: new Date().toISOString(),
-      finishedAt: null,
-      exitCode: null,
-      error: null,
-    };
-    const queuePath = path.join(stateDir, 'queue.json');
-    fs.writeFileSync(queuePath, JSON.stringify({ jobs: [badRow] }, null, 2), 'utf8');
-
-    const { jobs, invalid } = queueStore.shapeJobs(fs.readFileSync(queuePath, 'utf8'), queuePath);
-    expect(invalid.length).toBe(1);
-
-    const state = { jobs, invalidJobs: invalid, paused: null };
-
-    // A terminal record already exists for this slug — reconcile must never
-    // repair the corrupted row back into a runnable 'pending' state on top
-    // of already-shipped work.
-    fs.writeFileSync(
-      path.join(stateDir, 'history.jsonl'),
-      JSON.stringify({ slug: badRow.slug, status: 'completed', finishedAt: new Date().toISOString(), runId: 'run-xyz' }) + '\n',
-      'utf8',
-    );
-
-    queueStore.bustCwdCache();
-    await scheduler.reconcile(state);
-
-    expect(state.jobs.find((j) => j.slug === badRow.slug)).toBeUndefined();
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});