claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-dispatch-loop.test.cjs

@@ -1,58 +0,0 @@
-/**
- * scheduler-dispatch-loop.test.cjs — dispatch cadence is the loop's, not the billing
- * poller's: with the meter failing (backoff at 480 s) a pending dispatchable row still
- * gets a tickQueue within 30 s.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-dispatch-loop.test.cjs
- */
-'use strict';
-
-import { test, expect, vi, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-dispatch-loop-'));
-  process.env.HOME = tmpHome;
-  process.env.SM_AUTOFIX_DISABLE = '1';
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  delete process.env.SM_AUTOFIX_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('with the billing poll backed off to 480 s, a pending row is still ticked within 30 s', async () => {
-  const { startDispatchLoop } = require('../lib/dispatchLoop.cjs');
-  await scheduler.writeQueue({
-    jobs: [{ slug: `9004-dispatch-loop-${process.pid}`, title: 'x', cwd: tmpHome, status: 'pending', dependsOn: [] }],
-    config: {},
-    paused: null,
-  });
-  vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] });
-  const seen = [];
-  const h = startDispatchLoop({
-    // Same wiring init() uses (tick: () => tickQueue()), observed.
-    tick: async () => { seen.push(await scheduler.tickQueue()); },
-  });
-  try {
-    // Billing poll is at 480 s backoff: nothing else fires. The loop's own 30 s cadence does.
-    await vi.advanceTimersByTimeAsync(30_000);
-    // tickQueue does real file I/O; wait for the (real-time) pass to settle.
-    await vi.waitFor(() => expect(seen.length).toBe(1), { timeout: 10_000 });
-    expect(seen[0]).toBeTruthy(); // tickQueue ran and recorded an outcome for the pending row
-  } finally {
-    h.stop();
-    vi.useRealTimers();
-  }
-});

package/src/main/__tests__/scheduler-effective-concurrency.test.cjs

@@ -1,81 +0,0 @@
-/**
- * scheduler-effective-concurrency.test.cjs — unit tests for the
- * effectiveConcurrency field on buildScheduleStatePayload.
- *
- * The scheduler's private `concurrencyCap` is retired: the machine-wide
- * sessionSlots pool is the ONLY concurrency limit, so effectiveConcurrency
- * now reports the pool (and its SM_SESSION_SLOTS override), not a config
- * field. See lib/sessionSlots.cjs's charter — caps belong to Session-Manager,
- * not to each consumer.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-effective-concurrency.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const { buildScheduleStatePayload } = require('../scheduler.cjs');
-const sessionSlots = require('../lib/sessionSlots.cjs');
-
-const ENV_KEY = 'SM_SESSION_SLOTS';
-let savedEnv;
-
-beforeEach(() => {
-  savedEnv = process.env[ENV_KEY];
-  delete process.env[ENV_KEY];
-  sessionSlots.__resetForTests();
-});
-
-afterEach(() => {
-  if (savedEnv === undefined) delete process.env[ENV_KEY];
-  else process.env[ENV_KEY] = savedEnv;
-  sessionSlots.__resetForTests();
-});
-
-function fakeState() {
-  return {
-    config: {},
-    jobs: [],
-    scheduledFor: null,
-    lastRunAt: null,
-    paused: null,
-  };
-}
-
-test('effectiveConcurrency reports the pool when no env override is set', () => {
-  const payload = buildScheduleStatePayload(fakeState());
-  expect(payload.effectiveConcurrency.source).toBe('pool');
-  expect(payload.effectiveConcurrency.cap).toBe(sessionSlots.totalSlots());
-  expect(payload.effectiveConcurrency.free).toBe(sessionSlots.available());
-});
-
-test('effectiveConcurrency is env-sourced when SM_SESSION_SLOTS is set', () => {
-  process.env[ENV_KEY] = '7';
-  const payload = buildScheduleStatePayload(fakeState());
-  expect(payload.effectiveConcurrency).toEqual({ cap: 7, free: 7, source: 'env' });
-});
-
-test('effectiveConcurrency clamps the env var into the pool range [0, 10]', () => {
-  process.env[ENV_KEY] = '999';
-  const payload = buildScheduleStatePayload(fakeState());
-  expect(payload.effectiveConcurrency).toEqual({ cap: 10, free: 10, source: 'env' });
-});
-
-test('free is net of held slots — a chat run shrinks it without changing cap', () => {
-  process.env[ENV_KEY] = '5';
-  const token = sessionSlots.acquire('chat:test-tab');
-  expect(token).toBeTruthy();
-  const payload = buildScheduleStatePayload(fakeState());
-  expect(payload.effectiveConcurrency).toEqual({ cap: 5, free: 4, source: 'env' });
-  sessionSlots.release(token);
-});
-
-test('a row-level gateOutcome field survives the payload build unchanged (pass-through only, PRD 1109)', () => {
-  const state = fakeState();
-  state.jobs = [
-    { slug: 'a', status: 'failed', gateOutcome: 'never_ran' },
-    { slug: 'b', status: 'completed', gateOutcome: 'passed' },
-  ];
-  const payload = buildScheduleStatePayload(state);
-  expect(payload.jobs.map((j) => j.gateOutcome)).toEqual(['never_ran', 'passed']);
-});

package/src/main/__tests__/scheduler-epic-digest.test.cjs

@@ -1,227 +0,0 @@
-/**
- * scheduler-epic-digest.test.cjs — PRD 958: prepend the Epic context digest
- * (PRD 950's epicContextDigest.cjs) to a job's prompt when job.epicId
- * resolves to a known Epic (same resolution resolveOriginSessionId already
- * performs). Additive only: the PRD's own body + FINISH_PROTOCOL must remain
- * byte-for-byte unchanged, and a digest build failure must never block
- * dispatch.
- *
- * Drives the REAL spawn path via SM_CLAUDE_BIN pointing at a stub process
- * that captures the '-p' prompt argv to a file, so the assertions inspect
- * exactly what would have been sent to `claude -p`.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-epic-digest.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 originalClaudeBin;
-let executeJob;
-let FINISH_PROTOCOL;
-let buildContextDigest;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  originalClaudeBin = process.env.SM_CLAUDE_BIN;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-epic-digest-'));
-  process.env.HOME = tmpHome;
-
-  ({ executeJob, FINISH_PROTOCOL } = require('../scheduler.cjs'));
-  ({ buildContextDigest } = require('../lib/epicContextDigest.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalClaudeBin === undefined) delete process.env.SM_CLAUDE_BIN;
-  else process.env.SM_CLAUDE_BIN = originalClaudeBin;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-// Stub `claude` binary: captures the '-p' prompt argv to `capturePath`, then
-// emits one stream-json result line and exits 0.
-function writeClaudeStub(capturePath) {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const idx = process.argv.indexOf('-p');
-    const prompt = idx >= 0 ? process.argv[idx + 1] : '';
-    fs.writeFileSync(${JSON.stringify(capturePath)}, prompt, 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-function setupProject(prefix) {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-project-`));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', `${prefix}-run-`));
-  return { projectCwd, runDir };
-}
-
-function writeLegacyPrd(projectCwd, slug, bodyText) {
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), bodyText, 'utf8');
-  return path.join(prdsDir, `${slug}.md`);
-}
-
-function writeActiveIndex(projectCwd, sessions) {
-  const idxPath = path.join(projectCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  fs.mkdirSync(path.dirname(idxPath), { recursive: true });
-  fs.writeFileSync(idxPath, JSON.stringify({ sessions, events: {} }, null, 2), 'utf8');
-}
-
-test('prepends the Epic context digest when job.epicId resolves to a known Epic', async () => {
-  const { projectCwd, runDir } = setupProject('sm-epic-digest-hit');
-  try {
-    const epicId = 'epic-hit-1';
-    writeActiveIndex(projectCwd, {
-      [epicId]: { claudeSessionId: 'sess-abc-123', goalText: 'Ship the digest feature.' },
-    });
-
-    const slug = `958-test-hit-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const bodyText = 'Do the thing described in this PRD body.';
-    writeLegacyPrd(projectCwd, slug, bodyText);
-
-    const capturePath = path.join(runDir, 'captured-prompt.txt');
-    process.env.SM_CLAUDE_BIN = writeClaudeStub(capturePath);
-
-    const job = { slug, cwd: projectCwd, epicId };
-    const result = await executeJob(job, runDir, projectCwd, () => Promise.resolve());
-
-    expect(result.exitCode).toBe(0);
-    const capturedPrompt = fs.readFileSync(capturePath, 'utf8');
-
-    const digestText = await buildContextDigest({ cwd: projectCwd, epicId });
-    expect(digestText.length).toBeGreaterThan(0);
-    // Section order: PRD body -> fenced Epic-context digest -> finish
-    // protocol -> task restatement (PRD 992). The finish protocol must NOT
-    // be buried ahead of the digest — that was the defect this PRD fixes.
-    expect(capturedPrompt.startsWith(bodyText)).toBe(true);
-    const bodyIndex = capturedPrompt.indexOf(bodyText);
-    const digestIndex = capturedPrompt.indexOf(digestText);
-    const fenceEndIndex = capturedPrompt.indexOf('--- END EPIC CONTEXT ---');
-    const finishProtocolIndex = capturedPrompt.indexOf('SCHEDULER FINISH PROTOCOL');
-    const restatementIndex = capturedPrompt.indexOf('Your task is the PRD at the top of this prompt. Implement it now.');
-    expect(digestIndex).toBeGreaterThan(bodyIndex);
-    expect(capturedPrompt).toContain('BEGIN EPIC CONTEXT (background only');
-    expect(fenceEndIndex).toBeGreaterThan(digestIndex);
-    expect(finishProtocolIndex).toBeGreaterThan(fenceEndIndex);
-    expect(restatementIndex).toBeGreaterThan(finishProtocolIndex);
-    expect(capturedPrompt.trim().endsWith('Your task is the PRD at the top of this prompt. Implement it now.')).toBe(true);
-
-    // The PRD source on disk must never be rewritten with the digest merged in.
-    const onDiskPrd = fs.readFileSync(path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds', `${slug}.md`), 'utf8');
-    expect(onDiskPrd).toBe(bodyText);
-
-    const metaPath = path.join(runDir, `${slug}.meta.json`);
-    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    expect(meta.contextDigestApplied).toBe(true);
-    expect(meta.originSessionId).toBe('sess-abc-123');
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-test('is a silent no-op when job.epicId does not resolve to a known Epic', async () => {
-  const { projectCwd, runDir } = setupProject('sm-epic-digest-miss');
-  try {
-    const slug = `958-test-miss-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const bodyText = 'Do the thing described in this PRD body, unaccompanied.';
-    writeLegacyPrd(projectCwd, slug, bodyText);
-
-    const capturePath = path.join(runDir, 'captured-prompt.txt');
-    process.env.SM_CLAUDE_BIN = writeClaudeStub(capturePath);
-
-    // epicId is absent entirely — no active-index.json even exists for this project.
-    const job = { slug, cwd: projectCwd };
-    const result = await executeJob(job, runDir, projectCwd, () => Promise.resolve());
-
-    expect(result.exitCode).toBe(0);
-    const capturedPrompt = fs.readFileSync(capturePath, 'utf8');
-    expect(capturedPrompt).toBe(bodyText + FINISH_PROTOCOL);
-
-    const metaPath = path.join(runDir, `${slug}.meta.json`);
-    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    expect(meta.contextDigestApplied).toBe(false);
-    expect(meta.originSessionId).toBe(null);
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-test('a digest build failure is caught and never blocks dispatch', async () => {
-  const { projectCwd, runDir } = setupProject('sm-epic-digest-fail');
-  try {
-    const epicId = 'epic-fail-1';
-    writeActiveIndex(projectCwd, {
-      [epicId]: { claudeSessionId: 'sess-def-456', goalText: 'This Epic exists and resolves fine.' },
-    });
-
-    const slug = `958-test-fail-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const bodyText = 'Do the thing even if the digest build blows up.';
-    writeLegacyPrd(projectCwd, slug, bodyText);
-
-    const capturePath = path.join(runDir, 'captured-prompt.txt');
-    process.env.SM_CLAUDE_BIN = writeClaudeStub(capturePath);
-
-    // Stub epicContextDigest.cjs's export to reject, then force scheduler.cjs
-    // to re-require it so it picks up the stub (mirrors exchanges.test.cjs's
-    // summarize.cjs stubbing pattern) — only scheduler.cjs's own cache entry
-    // is cleared, not its whole dependency tree.
-    const digestPath = require.resolve('../lib/epicContextDigest.cjs');
-    const realDigestModule = require.cache[digestPath];
-    const { composeExecutorPrompt: realComposeExecutorPrompt } = require('../lib/epicContextDigest.cjs');
-    require.cache[digestPath] = {
-      id: digestPath,
-      filename: digestPath,
-      loaded: true,
-      exports: {
-        buildContextDigest: async () => {
-          throw new Error('boom: digest build exploded');
-        },
-        composeExecutorPrompt: realComposeExecutorPrompt,
-      },
-    };
-    const schedulerPath = require.resolve('../scheduler.cjs');
-    delete require.cache[schedulerPath];
-    const freshScheduler = require('../scheduler.cjs');
-
-    try {
-      const job = { slug, cwd: projectCwd, epicId };
-      const result = await freshScheduler.executeJob(job, runDir, projectCwd, () => Promise.resolve());
-
-      expect(result.exitCode).toBe(0);
-      const capturedPrompt = fs.readFileSync(capturePath, 'utf8');
-      // Digest failed to build — prompt falls back to the un-prefixed PRD body.
-      expect(capturedPrompt).toBe(bodyText + FINISH_PROTOCOL);
-
-      const metaPath = path.join(runDir, `${slug}.meta.json`);
-      const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-      expect(meta.contextDigestApplied).toBe(false);
-      expect(meta.originSessionId).toBe('sess-def-456');
-    } finally {
-      // Restore real modules for any later test in this file/process.
-      if (realDigestModule) require.cache[digestPath] = realDigestModule;
-      else delete require.cache[digestPath];
-      delete require.cache[schedulerPath];
-      ({ executeJob, FINISH_PROTOCOL } = require('../scheduler.cjs'));
-    }
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-failed-autoreset.test.cjs

@@ -1,121 +0,0 @@
-/**
- * scheduler-failed-autoreset.test.cjs
- *
- * Covers selectFailedAutoResetTargets (the bounded failed -> pending
- * auto-reset selector, PRD 1151) and failedAutoResetDisabled (its kill
- * switch) in isolation. selectFailedAutoResetTargets is pure — no IO, no
- * `require` inside the function — so unlike findStuckFailedJobs' own test
- * file, there is no run-log fixture to set up here.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
- * scheduler-reap-dead-running-jobs.test.cjs's comment for why.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-failed-autoreset.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(), 'failed-autoreset-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  selectFailedAutoResetTargets,
-  FAILED_AUTORESET_CAP,
-  failedAutoResetDisabled,
-} = require('../scheduler.cjs');
-
-const MIN_MS = 60_000;
-const THRESHOLD_MS = 10 * MIN_MS;
-
-test('a fresh failed row (under threshold) is not selected', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'fresh-failure',
-    status: 'failed',
-    statusHistory: [{ to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() }],
-  };
-  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
-});
-
-test('a row past threshold is selected, with its current attempt count', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'ripe-for-reset',
-    cwd: '/home/user/project',
-    status: 'failed',
-    failedAutoResetAttempts: 1,
-    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
-  };
-  const found = selectFailedAutoResetTargets([job], now, THRESHOLD_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, 'ripe-for-reset');
-  assert.equal(found[0].cwd, '/home/user/project');
-  assert.equal(found[0].attempts, 1);
-  assert.ok(found[0].ageMs >= 15 * MIN_MS - 1000);
-});
-
-test('a row at the cap (failedAutoResetAttempts: 3) is not selected', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'cap-exhausted',
-    status: 'failed',
-    failedAutoResetAttempts: FAILED_AUTORESET_CAP,
-    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
-  };
-  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
-});
-
-test('a non-failed status is never selected', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'needs-review-row',
-    status: 'needs_review',
-    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
-  };
-  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
-});
-
-test('the newest failed entry gates the threshold, not the first one', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'refailed-recently',
-    status: 'failed',
-    failedAutoResetAttempts: 1,
-    statusHistory: [
-      { to: 'failed', at: new Date(now - 2 * 24 * 60 * MIN_MS).toISOString() },
-      { to: 'pending', at: new Date(now - 23 * 60 * MIN_MS).toISOString() },
-      { to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() },
-    ],
-  };
-  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0, 'the old failed entry must not be used to gate this row');
-});
-
-test('a row whose newest failed entry came from spawnJob:fail-dirty is never selected — that source is a deliberate do-not-auto-requeue decision', () => {
-  const now = Date.now();
-  const job = {
-    slug: 'dirty-worktree',
-    status: 'failed',
-    statusHistory: [
-      { to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString(), source: 'spawnJob:fail-dirty' },
-    ],
-  };
-  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
-});
-
-test('failedAutoResetDisabled reflects SM_FAILED_AUTORESET_DISABLE', () => {
-  const saved = process.env.SM_FAILED_AUTORESET_DISABLE;
-  try {
-    delete process.env.SM_FAILED_AUTORESET_DISABLE;
-    assert.equal(failedAutoResetDisabled(), false);
-    process.env.SM_FAILED_AUTORESET_DISABLE = '1';
-    assert.equal(failedAutoResetDisabled(), true);
-  } finally {
-    if (saved === undefined) delete process.env.SM_FAILED_AUTORESET_DISABLE;
-    else process.env.SM_FAILED_AUTORESET_DISABLE = saved;
-  }
-});