claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/pollLoop-dispatch-on-failure.test.cjs

@@ -1,176 +0,0 @@
-/**
- * pollLoop-dispatch-on-failure.test.cjs — PRD: 27 pending jobs across two
- * projects sat at 0 running for days while every surface reported healthy.
- * Root cause: under firePolicy 'when-available', maybeLaunchWhenAvailable()
- * (the only thing that ever calls tickQueue() on the poll timer) was reached
- * from exactly two of pollLoop()'s branches — 'ok' and 'meter_rate_limited'.
- * The auth branch, the transient/config branch, and the outer catch all
- * incremented consecutiveFailures and returned WITHOUT attempting a
- * dispatch, so a poller that started failing (for any reason) silently
- * stopped driving the queue even though slots/memory/utilization were fine.
- *
- * This suite drives the REAL pollLoop() (not a reimplementation) through a
- * transient billing failure and a thrown error, and asserts a dispatch was
- * actually attempted in both cases — observed via `lastDispatchAttemptAt`,
- * which tickQueue() stamps the moment it reaches the picker, independent of
- * whether that pass ends in an actual job launch (see classifyQueueStarvation's
- * header for why this must be distinct from `lastRunAt`).
- *
- * Usage-meter circuit PRD update: pollLoop no longer fires blind at a hard-
- * coded cachedUtilization=0 on failure — it falls back to
- * usageCircuit.degradedBudget(), which carries forward the last known-good
- * BINDING window's utilization (or conservatively assumes 100/no-headroom
- * when there's no known-good reading yet at all). So each test below first
- * drives ONE successful ('ok') poll — with the queue still empty, so it
- * can't itself cause a dispatch — to seed that known-good low-utilization
- * reading, THEN seeds the pending job and drives the failure. This proves
- * dispatch proceeds under the CARRIED-FORWARD degraded budget, not a blind 0.
- *
- * No existing test in this repo mocks a module import (see
- * pty-epic-worktree-spawn-cwd.test.cjs's header) — this monkey-patches
- * usage.cjs's cached module object directly instead, same pattern.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/pollLoop-dispatch-on-failure.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-let billing;
-let originalFetchUsage;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pollloop-dispatch-'));
-  process.env.HOME = tmpHome;
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-  billing = require('../usage.cjs');
-  originalFetchUsage = billing.fetchUsage;
-});
-
-afterAll(() => {
-  billing.fetchUsage = originalFetchUsage;
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  billing.fetchUsage = originalFetchUsage;
-  delete process.env.SM_E2E;
-  delete process.env.SM_MOCK_BILLING_KIND;
-});
-
-// allProjectCwds()/activeProjectCwds() (queueStore.cjs's stateCwds) discover
-// project cwds by scanning ~/.claude/projects/*/*.jsonl for a `cwd` field —
-// fake one project transcript pointing at the fixture cwd, same pattern as
-// prdAdminRoutes.test.cjs / scheduler-verify-prd-path.test.cjs.
-function mkProject() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pollloop-project-'));
-  const slug = `9001-pollloop-dispatch-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-pollloop-fake-'));
-  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
-  return { cwd, slug };
-}
-
-// dependsOn deliberately references a slug that can never resolve (no such
-// row, no history/archive entry) so pickNextBatch's dep gate holds this job
-// forever instead of ever handing it to spawnJob. tickQueue() still reaches
-// the picker and stamps lastDispatchAttemptAt (that stamp is unconditional —
-// see lastDispatchAttemptAt's own header comment), which is the only thing
-// these tests assert on. Without this, the picker actually dispatches the
-// job: spawnJob() is fire-and-forget (scheduler.cjs's own comment: "spawnJob
-// is fire-and-forget; it calls tickQueue() on completion") and its real
-// child-process exit handler later calls mutate() independently of the
-// tickTail chain flushPendingTick() drains — round-tripping whatever
-// lastDispatchAttemptAt was in memory at ITS read time. Reproduced outside
-// vitest: that stray write landed ~2s after this suite's own reset-to-null,
-// clobbering the NEXT test's "still null" assertion with the previous test's
-// stamp. A held (never-dispatched) job has no such background continuation.
-async function seedOnePendingJob() {
-  const { cwd, slug } = mkProject();
-  await scheduler.writeQueue({
-    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: ['unresolvable-dep-never-completes'] }],
-    config: {},
-    paused: null,
-  });
-  return { cwd, slug };
-}
-
-async function lastDispatchAttemptAt() {
-  return queueStore.readMergedSync().lastDispatchAttemptAt;
-}
-
-// After pollLoop() fires maybeLaunchWhenAvailable() fire-and-forget, the tick
-// it enqueues lands on the shared, serialized tickTail chain that tickQueue()
-// itself maintains. A follow-up tickQueue() call is appended to that SAME
-// chain, so awaiting it guarantees the earlier tick (if any was enqueued)
-// has already settled.
-async function flushPendingTick() {
-  await scheduler.tickQueue();
-}
-
-test('pollLoop still attempts a dispatch after a transient billing failure, using the degraded budget (not utilization 0)', async () => {
-  // Seed a known-good low-utilization reading via an 'ok' poll first.
-  process.env.SM_E2E = '1';
-  process.env.SM_MOCK_BILLING_KIND = 'ok';
-  await scheduler.pollLoop();
-  // A prior test's leftover project (a REAL, still-registered project cwd —
-  // readQueue() merges every such cwd) can still hold its own permanently-
-  // pending job, so this seed poll's own maybeLaunchWhenAvailable may itself
-  // spawn a fire-and-forget tick; drain it before resetting/reseeding so
-  // that stray tick's async mutate() can't land AFTER (and clobber) the
-  // reset below.
-  await flushPendingTick();
-  await scheduler.writeQueue({ jobs: [], config: {}, paused: null });
-
-  await seedOnePendingJob();
-  // Baseline, not `toBeNull()`: under full-suite load a straggler tick from an
-  // earlier poll/test (spawnJob's completion tick, a slot-release pump) can
-  // stamp between the reset above and here, so the stamp is not guaranteed
-  // null. What the test proves is that THIS poll+flush advances the stamp.
-  const before = await lastDispatchAttemptAt();
-
-  process.env.SM_MOCK_BILLING_KIND = 'transient';
-  await scheduler.pollLoop();
-  await flushPendingTick();
-
-  const after = await lastDispatchAttemptAt();
-  expect(after).not.toBeNull();
-  expect(after).not.toBe(before);
-});
-
-test('pollLoop still attempts a dispatch after the billing poll throws, using the degraded budget (not utilization 0)', async () => {
-  process.env.SM_E2E = '1';
-  process.env.SM_MOCK_BILLING_KIND = 'ok';
-  await scheduler.pollLoop(); // seed a known-good low-utilization reading
-  await flushPendingTick();
-  await scheduler.writeQueue({ jobs: [], config: {}, paused: null });
-
-  await seedOnePendingJob();
-  // Baseline, not `toBeNull()`: under full-suite load a straggler tick from an
-  // earlier poll/test (spawnJob's completion tick, a slot-release pump) can
-  // stamp between the reset above and here, so the stamp is not guaranteed
-  // null. What the test proves is that THIS poll+flush advances the stamp.
-  const before = await lastDispatchAttemptAt();
-
-  delete process.env.SM_E2E;
-  delete process.env.SM_MOCK_BILLING_KIND;
-  billing.fetchUsage = async () => { throw new Error('simulated IPC transport failure'); };
-  await scheduler.pollLoop();
-  await flushPendingTick();
-
-  const after = await lastDispatchAttemptAt();
-  expect(after).not.toBeNull();
-  expect(after).not.toBe(before);
-});

package/src/main/__tests__/prd-group-allocator.test.cjs

@@ -1,119 +0,0 @@
-/**
- * prd-group-allocator.test.cjs — regression test for gh-issue-4 / PRD
- * (allocateParallelGroup): two projects authoring PRDs concurrently under
- * the shared prds/ directory both computed the same max-NN and allocated
- * the same new parallel group (05-11 vs 06-09 on 2026-07-14, then 545 vs
- * 545 again on 2026-07-15 between session-manager and sigma). NN is both
- * the filename counter and the parallel-group key the scheduler parses,
- * so a collision silently merges two unrelated projects' PRDs into one
- * group.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/prd-group-allocator.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  allocateParallelGroup,
-  maxParallelGroupInUse,
-  parsePrdRaw,
-  _resetCache,
-} = require('../scheduler/prdParser.cjs');
-
-function mkTmpPrdsDir() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-alloc-'));
-}
-
-test('allocateParallelGroup returns max+1 on an empty directory', async () => {
-  const dir = await mkTmpPrdsDir();
-  const nn = await allocateParallelGroup(dir);
-  assert.strictEqual(nn, 1);
-});
-
-test('allocateParallelGroup scans the FULL directory, not a narrowed glob — reproduces the 577-PRD/max-544 live directory shape', async () => {
-  const dir = await mkTmpPrdsDir();
-  // Live directory (2026-07-18) holds an unpadded legacy name and a max of 544.
-  await fsp.writeFile(path.join(dir, '54-scheduler-memory-guard-cap3.md'), '# x\n');
-  await fsp.writeFile(path.join(dir, '110-some-slug.md'), '# x\n'); // would be missed by '^10[0-9]'
-  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
-  await fsp.writeFile(path.join(dir, '9-old-single-digit.md'), '# x\n');
-
-  const max = await maxParallelGroupInUse(dir);
-  assert.strictEqual(max, 544, 'must see 544 as the max even though 110 sorts before it lexically and 54/9 are unpadded');
-
-  const nn = await allocateParallelGroup(dir);
-  assert.strictEqual(nn, 545);
-});
-
-test('two concurrent allocateParallelGroup callers never receive the same new NN (the core race from the incident)', async () => {
-  const dir = await mkTmpPrdsDir();
-  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
-
-  const CONCURRENCY = 12;
-  const results = await Promise.all(
-    Array.from({ length: CONCURRENCY }, () => allocateParallelGroup(dir)),
-  );
-
-  const distinct = new Set(results);
-  assert.strictEqual(distinct.size, CONCURRENCY, `expected ${CONCURRENCY} distinct NNs, got collisions: ${results.join(',')}`);
-  for (const nn of results) {
-    assert.ok(nn > 544, `allocated NN ${nn} must not collide with existing on-disk NN 544`);
-  }
-});
-
-test('reservation markers are counted toward max-NN so a crash mid-allocation cannot be re-issued by a later caller', async () => {
-  const dir = await mkTmpPrdsDir();
-  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
-
-  const first = await allocateParallelGroup(dir); // 545, leaves .reserved-545 on disk
-  assert.strictEqual(first, 545);
-
-  // Simulate the caller never authoring 545-slug.md (crash between reserve
-  // and author). A later allocation must still move past 545, not reissue it.
-  const second = await allocateParallelGroup(dir);
-  assert.strictEqual(second, 546);
-});
-
-test('deliberate parallel siblings sharing one existing NN are unaffected by the allocator (main regression risk)', async () => {
-  const dir = await mkTmpPrdsDir();
-  // Three independent PRDs deliberately opting into the SAME group, exactly
-  // as /develop's SKILL.md contract allows — authored directly by filename,
-  // never through allocateParallelGroup.
-  await fsp.writeFile(path.join(dir, '545-scheduler-tick-stall-after-job-failure.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody A\n');
-  await fsp.writeFile(path.join(dir, '545-filetree-show-hidden-default-and-persist.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody B\n');
-  await fsp.writeFile(path.join(dir, '545-editor-tab-close-shortcut-and-close-right.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody C\n');
-
-  const files = await fsp.readdir(dir);
-  const parsed = await Promise.all(
-    files.filter((f) => f.endsWith('.md')).map((f) => parsePrdRaw(path.join(dir, f))),
-  );
-  assert.strictEqual(parsed.length, 3);
-  for (const p of parsed) {
-    assert.strictEqual(p.parallelGroup, 545, 'siblings must keep sharing group 545 — the allocator must not renumber existing files');
-  }
-
-  // A brand-new PRD (not a deliberate sibling) allocated afterward must NOT
-  // land in 545 — it gets the next free group instead.
-  const nn = await allocateParallelGroup(dir);
-  assert.strictEqual(nn, 546);
-});
-
-test('module-level PRD dir-mtime cache in prdParser is unaffected by reservation markers (hidden files stay invisible to listPrdFiles)', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-  await fsp.writeFile(path.join(dir, '1-a.md'), '# x\n');
-  const { listPrdFiles } = require('../scheduler/prdParser.cjs');
-  const before = await listPrdFiles(dir);
-  assert.strictEqual(before.length, 1);
-
-  await allocateParallelGroup(dir); // writes a .reserved-2 marker
-  _resetCache();
-  const after = await listPrdFiles(dir);
-  assert.strictEqual(after.length, 1, 'reservation markers must not appear as PRD files');
-});

package/src/main/__tests__/prdAdminRouteParity.test.cjs

@@ -1,70 +0,0 @@
-/**
- * prdAdminRouteParity.test.cjs — capability-parity gate for PRD 1024 ("lock
- * the PRD entity behind the scheduler service boundary, step 1").
- *
- * Enumerates every PRD/job mutation the codebase can perform (the full set
- * of `schedule:*` IPC channels that read/write a PRD file or a queue job,
- * plus create-prd and cancel-job which have no IPC twin) and asserts each
- * one has a corresponding admin HTTP route registered by scheduler.cjs's
- * registerAdminRoutes, prdCreate.cjs's registerAdminRoute, or
- * prdAdminRoutes.cjs's registerAdminRoute. A future PRD-lifecycle capability
- * added only as an IPC handler (filesystem-only from the admin API's point
- * of view) fails this test until an admin route is added for it too — that
- * is the whole point: the admin API must never fall behind what's actually
- * possible against a PRD/job.
- *
- * Route registration is captured via a fake `adminHttp` stub (just
- * `registerRoute`) — no real HTTP server or Electron boot needed, matching
- * how prdCreate.test.cjs already verifies wiring.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdAdminRouteParity.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const scheduler = require('../scheduler.cjs');
-const prdCreate = require('../lib/prdCreate.cjs');
-const prdAdminRoutes = require('../lib/prdAdminRoutes.cjs');
-
-// Every PRD-lifecycle capability the codebase can perform, mapped to the
-// admin HTTP route that must exist for it. `ipcChannel` is informational
-// (documents the renderer-facing twin, if any) — the assertion is only
-// against `adminRoute`.
-const REQUIRED_CAPABILITIES = [
-  { capability: 'create a PRD', ipcChannel: null, adminRoute: 'POST /admin/scheduler/create-prd' },
-  { capability: 'list PRDs (live + archived)', ipcChannel: 'schedule:list-prds', adminRoute: 'GET /admin/scheduler/prds' },
-  { capability: 'read one PRD (body + frontmatter)', ipcChannel: 'schedule:read-prd', adminRoute: 'GET /admin/scheduler/prd' },
-  { capability: 'edit a not-yet-running PRD', ipcChannel: 'schedule:write-prd', adminRoute: 'POST /admin/scheduler/update-prd' },
-  { capability: 'archive a PRD', ipcChannel: 'schedule:archive-prd', adminRoute: 'POST /admin/scheduler/archive-prd' },
-  { capability: 'retag a PRD (parallelGroup/estimateMinutes)', ipcChannel: 'schedule:retag-prd', adminRoute: 'POST /admin/scheduler/retag-prd' },
-  { capability: 'list scheduler jobs', ipcChannel: null, adminRoute: 'GET /admin/scheduler/jobs' },
-  { capability: 'reset a stuck job', ipcChannel: 'schedule:reset-job', adminRoute: 'POST /admin/scheduler/reset-job' },
-  { capability: 'pause new dispatch (user-initiated)', ipcChannel: 'schedule:pause', adminRoute: 'POST /admin/scheduler/pause' },
-  { capability: 'resume a paused scheduler', ipcChannel: 'schedule:resume', adminRoute: 'POST /admin/scheduler/resume' },
-  { capability: 'cancel a not-yet-terminal job', ipcChannel: null, adminRoute: 'POST /admin/scheduler/cancel-job' },
-];
-
-function captureRegisteredRoutes() {
-  const registered = new Set();
-  const fakeAdminHttp = {
-    registerRoute(method, url) {
-      registered.add(`${method} ${url}`);
-    },
-  };
-  scheduler.registerAdminRoutes(fakeAdminHttp, scheduler.remote);
-  prdCreate.registerAdminRoute(fakeAdminHttp, scheduler.remote);
-  prdAdminRoutes.registerAdminRoute(fakeAdminHttp, scheduler.remote);
-  return registered;
-}
-
-test('every enumerated PRD/job mutation capability has a registered admin route', () => {
-  const registered = captureRegisteredRoutes();
-  const missing = REQUIRED_CAPABILITIES.filter((c) => !registered.has(c.adminRoute));
-  expect(missing).toEqual([]);
-});
-
-test.each(REQUIRED_CAPABILITIES)('capability "$capability" → $adminRoute is registered', ({ adminRoute }) => {
-  const registered = captureRegisteredRoutes();
-  expect(registered.has(adminRoute)).toBe(true);
-});