claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-never-stop.test.cjs

@@ -1,157 +0,0 @@
-/**
- * scheduler-never-stop.test.cjs — the invariant: if a queue holds ready PRDs,
- * something must drive them.
- *
- * Every stall observed in this codebase was a different CAUSE with the same
- * SHAPE — ready rows, nothing running, nobody ticking:
- *   - a rate-limited exit stamped terminal 'failed' (2026-09-05: 42 rows)
- *   - a spin loop past the manual-clear cooldown
- *   - a worktree merge-back leaving the project on a job branch
- *   - a job parked needs_review with no fix plan
- *   - app churn under session-manager-operations/ counted as unfinished work
- *   - the billing meter itself 429ing so utilization never reported
- * Guarding each cause individually always lags the next one, so the watchdog
- * guards the shape.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-never-stop.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// HOME before require: every state path is baked from os.homedir() at load.
-process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'never-stop-test-'));
-
-const {
-  classifyQueueStarvation,
-  QUEUE_STARVATION_MS,
-  stripAppOwnedChurn,
-} = require('../scheduler.cjs');
-
-const CWD = '/home/bilko/Projects/starry-night-ships';
-const NOW = Date.parse('2026-09-05T23:00:00.000Z');
-const idleFor = (ms) => NOW - ms;
-const LONG = QUEUE_STARVATION_MS + 60_000;
-
-const base = (over = {}) => ({
-  jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-  paused: null,
-  runningCount: 0,
-  lastRunAtMs: idleFor(LONG),
-  now: NOW,
-  ...over,
-});
-
-// ── the invariant ────────────────────────────────────────────────────────────
-
-test('ready work + nothing running + long idle => starved, and a tick would help', () => {
-  const v = classifyQueueStarvation(base());
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 1);
-});
-
-test('the real incident shape: 40 ready rows, 0 running, idle for hours', () => {
-  const jobs = Array.from({ length: 40 }, (_, i) => ({
-    slug: `${207 + i}-step`, cwd: CWD, status: 'pending', dependsOn: [],
-  }));
-  const v = classifyQueueStarvation(base({ jobs, lastRunAtMs: idleFor(3 * 60 * 60_000) }));
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.dispatchable, 40);
-});
-
-// ── it must NOT fire when the queue is legitimately quiet ────────────────────
-
-test('a running job means the queue is flowing — never starved', () => {
-  assert.equal(classifyQueueStarvation(base({ runningCount: 1 })), null);
-});
-
-test('no pending rows is not a stall', () => {
-  assert.equal(classifyQueueStarvation(base({ jobs: [{ slug: 'a', cwd: CWD, status: 'completed' }] })), null);
-});
-
-test('paused is a DECISION, not a stall — the watchdog must never override it', () => {
-  assert.equal(classifyQueueStarvation(base({ paused: { reason: 'rate_limit', resumeAt: null } })), null);
-});
-
-test('inside the idle threshold the normal path gets its chance first', () => {
-  assert.equal(classifyQueueStarvation(base({ lastRunAtMs: idleFor(QUEUE_STARVATION_MS - 1000) })), null);
-});
-
-test('a never-recorded lastRunAt counts as infinitely idle, not as healthy', () => {
-  const v = classifyQueueStarvation(base({ lastRunAtMs: NaN }));
-  assert.equal(v.kind, 'starved');
-});
-
-// ── blocked is a DIFFERENT verdict from starved ──────────────────────────────
-
-test('every pending row behind a terminal dep => blocked, not starved (a tick cannot help)', () => {
-  const jobs = [
-    { slug: '206-lava-ape', cwd: CWD, status: 'failed', dependsOn: [] },
-    { slug: '207-body', cwd: CWD, status: 'pending', dependsOn: ['206-lava-ape'] },
-    { slug: '208-docs', cwd: CWD, status: 'pending', dependsOn: ['207-body'] },
-  ];
-  const v = classifyQueueStarvation(base({ jobs }));
-  assert.equal(v.kind, 'blocked');
-  assert.equal(v.pending, 2);
-  assert.equal(v.dispatchable, 0);
-  assert.deepEqual(v.blockedChains[0].blockedBy, ['206-lava-ape']);
-});
-
-test('one dispatchable row among blocked ones still counts as starved — the queue can make progress', () => {
-  const jobs = [
-    { slug: 'x-dead', cwd: CWD, status: 'failed', dependsOn: [] },
-    { slug: 'y-blocked', cwd: CWD, status: 'pending', dependsOn: ['x-dead'] },
-    { slug: 'z-ready', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueStarvation(base({ jobs }));
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.dispatchable, 1);
-});
-
-test('a project blocked while ANOTHER project has ready work is still starved overall', () => {
-  const jobs = [
-    { slug: 'a-dead', cwd: '/p/one', status: 'failed', dependsOn: [] },
-    { slug: 'b-blocked', cwd: '/p/one', status: 'pending', dependsOn: ['a-dead'] },
-    { slug: 'c-ready', cwd: '/p/two', status: 'pending', dependsOn: [] },
-  ];
-  assert.equal(classifyQueueStarvation(base({ jobs })).kind, 'starved');
-});
-
-// ── app-owned churn must never be blamed on a job ────────────────────────────
-
-test('stripAppOwnedChurn drops session-manager-operations churn, keeps real source', () => {
-  const out = stripAppOwnedChurn([
-    'src/main/scheduler.cjs',
-    'session-manager-operations/scheduler/state/queue.json',
-    'session-manager-operations/scheduler/state/history.jsonl',
-    'session-manager-operations/prompt-sessions/active-index.json',
-    'dashboard/panels/outcome-stats.jsx',
-  ]);
-  assert.deepEqual(out, ['src/main/scheduler.cjs', 'dashboard/panels/outcome-stats.jsx']);
-});
-
-test('stripAppOwnedChurn preserves the null contract (git status unavailable != left nothing)', () => {
-  assert.equal(stripAppOwnedChurn(null), null);
-  assert.equal(stripAppOwnedChurn(undefined), undefined);
-});
-
-test('stripAppOwnedChurn only matches a whole path segment, never a substring', () => {
-  assert.deepEqual(
-    stripAppOwnedChurn(['docs/session-manager-operations-guide.md', 'a/session-manager-operations/x.json']),
-    ['docs/session-manager-operations-guide.md'],
-  );
-});
-
-test('a job that leaves REAL source dirty still parks — the filter must not excuse that', () => {
-  assert.deepEqual(
-    stripAppOwnedChurn(['session-manager-operations/scheduler/state/queue.json', 'scripts/arena/titan.gd']),
-    ['scripts/arena/titan.gd'],
-  );
-});

package/src/main/__tests__/scheduler-no-dead-end-status.test.cjs

@@ -1,152 +0,0 @@
-/**
- * scheduler-no-dead-end-status.test.cjs
- *
- * Structural guard for the no-human-intervention guarantee (this PRD): every
- * value in `JOB_STATUSES` (imported from scheduleJobSchema.cjs — the real
- * array, never a hand-written copy) must either be genuinely final
- * (completed/skipped) or have at least one AUTOMATED selector that can move
- * a row parked in it, with no human action required.
- *
- * Each non-final status is asserted by CONSTRUCTING a representative parked
- * row (a stale timestamp + a counter positioned so the row is still
- * selectable) and showing the named selector actually returns it — not by
- * asserting a hand-maintained status -> selector-name string map, which
- * would pass even if the real wiring silently broke. If a future change adds
- * a new status to JOB_STATUSES with no automated exit wired up here, this
- * test fails loudly instead of the row becoming a new, silent dead end.
- *
- * 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-no-dead-end-status.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(), 'no-dead-end-status-test-'));
-process.env.HOME = tmpHome;
-
-const { JOB_STATUSES } = require('../lib/scheduleJobSchema.cjs');
-const {
-  selectFailedAutoResetTargets,
-  FAILED_AUTORESET_CAP,
-  selectExhaustedNeedsReviewTargets,
-  NEEDS_REVIEW_RESOLVE_CAP,
-  selectQuarantineAutoResolveTargets,
-  QUARANTINE_RESOLVE_CAP,
-  findStrandedInvestigations,
-  INVESTIGATION_MAX_MS,
-} = require('../scheduler.cjs');
-const { selectReapableJobs } = require('../lib/reaperHelpers.cjs');
-const { pickForProject } = require('../lib/schedulerBatch.cjs');
-
-const MIN_MS = 60_000;
-
-// Every terminal status (no automated exit needed — nothing should ever
-// move a row out of these) and every non-terminal status's proof that a
-// row parked there is reachable by an automated selector, keyed only for
-// this test's own assertions (never treated as authoritative wiring below).
-const FINAL_STATUSES = new Set(['completed', 'skipped']);
-
-test('JOB_STATUSES contains exactly the statuses this test accounts for (fails loudly on drift)', () => {
-  // Not a hand-maintained selector map — just a manifest of what this file
-  // below actually exercises, so an entirely new, unhandled status trips
-  // this assertion instead of silently passing the loop below with zero
-  // coverage.
-  const accountedFor = new Set([
-    'pending', 'running', 'investigating', 'completed', 'skipped', 'failed', 'needs_review', 'quarantined',
-  ]);
-  const unaccounted = JOB_STATUSES.filter((s) => !accountedFor.has(s));
-  if (unaccounted.length > 0) {
-    throw new Error(
-      `HALT: JOB_STATUSES has status(es) with no automated-exit test coverage: ${unaccounted.join(', ')} — `
-      + 'add a case to scheduler-no-dead-end-status.test.cjs before shipping this status.',
-    );
-  }
-});
-
-test('every terminal status in JOB_STATUSES is genuinely final (completed/skipped only)', () => {
-  for (const status of JOB_STATUSES) {
-    if (status === 'completed' || status === 'skipped') continue;
-    assert.ok(!FINAL_STATUSES.has(status), `${status} must not be treated as final`);
-  }
-});
-
-test('pending: a fresh pending row with no blockers is picked for dispatch by pickForProject', () => {
-  assert.ok(JOB_STATUSES.includes('pending'));
-  const job = { slug: 'pending-row', cwd: '/home/user/project', status: 'pending' };
-  const { batch } = pickForProject([job], new Set(), 5);
-  assert.ok(batch.some((j) => j.slug === 'pending-row'), 'pending row must be dispatch-eligible with no blockers');
-});
-
-test('running: a running row whose pid is provably dead is reaped by selectReapableJobs', () => {
-  assert.ok(JOB_STATUSES.includes('running'));
-  const job = {
-    slug: 'dead-running-row',
-    cwd: '/home/user/project',
-    status: 'running',
-    runtime: { pid: 12345 },
-  };
-  const { reapable } = selectReapableJobs([job], Date.now(), { pidAlive: () => false, grace: 5 * MIN_MS });
-  assert.ok(reapable.some((r) => r.slug === 'dead-running-row'), 'a running row with a dead pid must be reapable');
-});
-
-test('investigating: a stranded investigation (stale, no live pid) is found by findStrandedInvestigations', () => {
-  assert.ok(JOB_STATUSES.includes('investigating'));
-  const job = {
-    slug: 'stranded-investigation',
-    cwd: '/home/user/project',
-    status: 'investigating',
-    statusHistory: [{ to: 'investigating', from: 'failed', at: new Date(Date.now() - (INVESTIGATION_MAX_MS + 5 * MIN_MS)).toISOString() }],
-  };
-  const found = findStrandedInvestigations([job], Date.now(), INVESTIGATION_MAX_MS, () => false);
-  assert.ok(found.some((f) => f.slug === 'stranded-investigation'), 'a stale investigating row with no live pid must be found');
-});
-
-test('failed: a stale failed row under its auto-reset cap is selected by selectFailedAutoResetTargets', () => {
-  assert.ok(JOB_STATUSES.includes('failed'));
-  const job = {
-    slug: 'stale-failed-row',
-    cwd: '/home/user/project',
-    status: 'failed',
-    failedAutoResetAttempts: FAILED_AUTORESET_CAP - 1,
-    statusHistory: [{ to: 'failed', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectFailedAutoResetTargets([job], Date.now(), 10 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'stale-failed-row'), 'a stale failed row under the cap must be auto-reset-selectable');
-});
-
-test('needs_review: an exhausted, stale needs_review row is selected by selectExhaustedNeedsReviewTargets', () => {
-  assert.ok(JOB_STATUSES.includes('needs_review'));
-  const job = {
-    slug: 'exhausted-needs-review-row',
-    cwd: '/home/user/project',
-    status: 'needs_review',
-    autoFixAttempted: true,
-    autoFixOutcome: 'no-plan',
-    autoFixRetries: 1,
-    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), 30 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'exhausted-needs-review-row'), 'an exhausted, stale needs_review row must be auto-resolve-selectable');
-});
-
-test('quarantined: a stale quarantined row under its resolve cap is selected by selectQuarantineAutoResolveTargets', () => {
-  assert.ok(JOB_STATUSES.includes('quarantined'));
-  const job = {
-    slug: 'stale-quarantined-row',
-    cwd: '/home/user/project',
-    status: 'quarantined',
-    quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP - 1,
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectQuarantineAutoResolveTargets([job], Date.now(), 30 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'stale-quarantined-row'), 'a stale quarantined row under the cap must be auto-resolve-selectable');
-});

package/src/main/__tests__/scheduler-no-orphan-run-dir.test.cjs

@@ -1,81 +0,0 @@
-/**
- * scheduler-no-orphan-run-dir.test.cjs — PRD 1120: pickRunDir() must not
- * mkdir a run directory until a dispatch actually commits (executeJob's
- * first write). A dispatch that aborts inside spawnJob before that point —
- * e.g. sessionSlots.acquire() returning null, the earliest exit in spawnJob
- * — must leave RUNS_DIR untouched.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-no-orphan-run-dir.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 originalSlots;
-let scheduler;
-let sessionSlots;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-no-orphan-rundir-'));
-  process.env.HOME = tmpHome;
-  originalSlots = process.env.SM_SESSION_SLOTS;
-  scheduler = require('../scheduler.cjs');
-  sessionSlots = require('../lib/sessionSlots.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalSlots === undefined) delete process.env.SM_SESSION_SLOTS;
-  else process.env.SM_SESSION_SLOTS = originalSlots;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  sessionSlots.__resetForTests();
-});
-
-function runsDirEntryCount() {
-  const runsDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs');
-  try {
-    return fs.readdirSync(runsDir).length;
-  } catch {
-    return 0;
-  }
-}
-
-test('pickRunDir() allocates a runId/dir pair without creating the directory', () => {
-  const before = runsDirEntryCount();
-  const { runId, dir } = scheduler.pickRunDir();
-  expect(runId).toBeTruthy();
-  expect(fs.existsSync(dir)).toBe(false);
-  expect(runsDirEntryCount()).toBe(before);
-});
-
-test('a dispatch that bails at slot-acquisition (earliest spawnJob exit) leaves no directory under RUNS_DIR', async () => {
-  // Force sessionSlots.acquire() to return null immediately — no slots at all.
-  process.env.SM_SESSION_SLOTS = '0';
-  const before = runsDirEntryCount();
-
-  const slug = `1120-slot-miss-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-no-orphan-rundir-project-'));
-  try {
-    await scheduler.spawnJob({ slug, cwd: projectCwd }, `run-${slug}`, path.join(
-      tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`
-    ), projectCwd);
-
-    expect(runsDirEntryCount()).toBe(before);
-    expect(fs.existsSync(path.join(
-      tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`
-    ))).toBe(false);
-  } finally {
-    delete process.env.SM_SESSION_SLOTS;
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs

@@ -1,87 +0,0 @@
-/**
- * scheduler-notify-originating-tab-transcript.test.cjs — unit tests for the
- * PRD 863 addition to notifyOriginatingTab: persisting the job's real
- * result text (read from the run's log) to the durable per-Epic transcript
- * store, independent of the existing short-status-chip notification.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { notifyOriginatingTab, extractResultTextFromLog } = require('../scheduler.cjs');
-
-test('extractResultTextFromLog returns null for a missing log path', () => {
-  expect(extractResultTextFromLog(null)).toBeNull();
-  expect(extractResultTextFromLog('/does/not/exist.log')).toBeNull();
-});
-
-test('appends the job result text to the transcript store when sourcePromptId is known', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => 'the real agent result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-transcript', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).toHaveBeenCalledTimes(1);
-  expect(appendTranscriptTurn).toHaveBeenCalledWith('/some/cwd', 'psess-abc', {
-    role: 'assistant',
-    text: 'the real agent result text',
-    eventId: 'prd-result:863-transcript:run-1',
-  });
-});
-
-test('falls back to the short status message when the run log has no result text', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => null);
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-fallback', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(
-    '/some/cwd',
-    'psess-abc',
-    expect.objectContaining({ text: expect.stringContaining('863-fallback') }),
-  );
-});
-
-test('a throwing transcript append never breaks the existing notification path', async () => {
-  const appendTranscriptTurn = vi.fn(async () => {
-    throw new Error('disk full');
-  });
-  const readResultFromLog = vi.fn(() => 'result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '863-safe', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-      { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-    ),
-  ).resolves.toBeUndefined();
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-});
-
-test('no cwd on the job skips the transcript append but does not throw', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => 'result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-nocwd', status: 'completed', cwd: null, runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).not.toHaveBeenCalled();
-});