claude-code-session-manager 0.36.0 → 0.37.1

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

@@ -0,0 +1,104 @@
+/**
+ * broadcastCoalescer.test.cjs — unit tests for src/main/lib/broadcastCoalescer.cjs,
+ * the trailing-edge debounce used by scheduler.cjs's broadcast().
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/broadcastCoalescer.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { createBroadcastCoalescer } = require('../lib/broadcastCoalescer.cjs');
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+function makeCoalescer(delayMs = 200) {
+  const sent = [];
+  let counter = 0;
+  const getPayload = vi.fn(() => `state-${counter}`);
+  const send = vi.fn((payload) => sent.push(payload));
+  const coalescer = createBroadcastCoalescer({ delayMs, send, getPayload });
+  return {
+    coalescer,
+    sent,
+    send,
+    getPayload,
+    bump: () => { counter += 1; },
+  };
+}
+
+test('5 rapid schedule() calls within the window produce exactly 1 send', async () => {
+  const { coalescer, sent, bump } = makeCoalescer(200);
+
+  bump(); coalescer.schedule();
+  bump(); coalescer.schedule();
+  bump(); coalescer.schedule();
+  bump(); coalescer.schedule();
+  bump(); coalescer.schedule();
+
+  await vi.advanceTimersByTimeAsync(200);
+
+  expect(sent.length).toBe(1);
+});
+
+test('the trailing send reflects the LATEST state, not the state at the first schedule() call', async () => {
+  const { coalescer, sent, bump } = makeCoalescer(200);
+
+  bump(); // state-1
+  coalescer.schedule();
+  bump(); // state-2
+  coalescer.schedule(); // no-op — timer already armed
+  bump(); // state-3
+  coalescer.schedule(); // no-op
+
+  await vi.advanceTimersByTimeAsync(200);
+
+  expect(sent).toEqual(['state-3']);
+});
+
+test('flush() cancels the pending timer and sends immediately with the current payload', async () => {
+  const { coalescer, sent, bump } = makeCoalescer(200);
+
+  bump();
+  coalescer.schedule();
+
+  // Flush before the 200ms window elapses.
+  await vi.advanceTimersByTimeAsync(50);
+  await coalescer.flush();
+
+  expect(sent).toEqual(['state-1']);
+
+  // The window's original timer must not fire a second, stale send.
+  await vi.advanceTimersByTimeAsync(200);
+  expect(sent).toEqual(['state-1']);
+});
+
+test('a schedule() call after a quiet period still arrives (not dropped)', async () => {
+  const { coalescer, sent, bump } = makeCoalescer(200);
+
+  bump();
+  coalescer.schedule();
+  await vi.advanceTimersByTimeAsync(200);
+  expect(sent).toEqual(['state-1']);
+
+  bump();
+  coalescer.schedule();
+  await vi.advanceTimersByTimeAsync(200);
+  expect(sent).toEqual(['state-1', 'state-2']);
+});
+
+test('flush() with no pending timer still sends (no-arm case)', async () => {
+  const { coalescer, sent, bump } = makeCoalescer(200);
+  bump();
+  await coalescer.flush();
+  expect(sent).toEqual(['state-1']);
+});
+
+console.log('broadcastCoalescer tests: PASS');

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

@@ -0,0 +1,163 @@
+/**
+ * historyDashboard.test.cjs — unit tests for src/main/historyDashboard.cjs
+ * (the `history:dashboard` IPC's pure rollup-only computation).
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/historyDashboard.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach, vi } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let realHome;
+let historyRollup;
+let historyDashboard;
+
+const MODULES_TO_RELOAD = [
+  '../lib/historyRollup.cjs',
+  '../historyAggregator.cjs',
+  '../historyDashboard.cjs',
+  '../config.cjs',
+];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'history-dashboard-test-'));
+  process.env.HOME = tmpHome;
+  purgeRequireCache();
+  historyRollup = require('../lib/historyRollup.cjs');
+  historyDashboard = require('../historyDashboard.cjs');
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  purgeRequireCache();
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+function today() {
+  return new Date().toLocaleDateString('en-CA');
+}
+
+function daysAgo(n) {
+  const d = new Date();
+  d.setDate(d.getDate() - n);
+  return d.toLocaleDateString('en-CA');
+}
+
+async function seedThreeDayFixture() {
+  const d2 = daysAgo(2);
+  const d1 = daysAgo(1);
+  const d0 = today();
+
+  await historyRollup.appendRollupDays([
+    // day -2: project A, finalized, sonnet
+    { date: d2, projectDir: 'proj-a', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 4, toolCallCount: 2, toolBreakdown: { Read: 2 }, errorCount: 0, sessionCount: 1, activeMinutes: 12, v: 2 },
+    { date: d2, projectDir: 'proj-a', modelId: 'claude-sonnet-5', promptCount: 0, inputTokens: 1000, outputTokens: 200, cacheReadTokens: 0, cacheCreationTokens: 0, v: 2 },
+    { date: d2, projectDir: historyRollup.FINALIZED_PROJECT_ID, modelId: historyRollup.FINALIZED_MODEL_ID, finalizedAt: 111, v: 2 },
+
+    // day -1: project A and B, finalized
+    { date: d1, projectDir: 'proj-a', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 3, toolCallCount: 1, toolBreakdown: { Edit: 1 }, errorCount: 1, sessionCount: 1, activeMinutes: 8, v: 2 },
+    { date: d1, projectDir: 'proj-a', modelId: 'claude-sonnet-5', promptCount: 0, inputTokens: 500, outputTokens: 100, cacheReadTokens: 0, cacheCreationTokens: 0, v: 2 },
+    { date: d1, projectDir: 'proj-b', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 2, toolCallCount: 0, toolBreakdown: {}, errorCount: 0, sessionCount: 1, activeMinutes: 5, v: 2 },
+    { date: d1, projectDir: 'proj-b', modelId: 'claude-opus-5', promptCount: 0, inputTokens: 300, outputTokens: 50, cacheReadTokens: 0, cacheCreationTokens: 0, v: 2 },
+    { date: d1, projectDir: historyRollup.FINALIZED_PROJECT_ID, modelId: historyRollup.FINALIZED_MODEL_ID, finalizedAt: 222, v: 2 },
+
+    // today: provisional, project A only, no finalized marker
+    { date: d0, projectDir: 'proj-a', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 1, toolCallCount: 1, toolBreakdown: { Bash: 1 }, errorCount: 0, sessionCount: 1, activeMinutes: 3, v: 2 },
+    { date: d0, projectDir: 'proj-a', modelId: 'claude-sonnet-5', promptCount: 0, inputTokens: 100, outputTokens: 20, cacheReadTokens: 0, cacheCreationTokens: 0, v: 2 },
+  ]);
+
+  return { d2, d1, d0 };
+}
+
+test('dashboard response shape: 3-day fixture with rangeDays=30 includes all seeded days, correct totals, provisional today', async () => {
+  const { d2, d1, d0 } = await seedThreeDayFixture();
+
+  const result = await historyDashboard.computeDashboard({ rangeDays: 30 });
+
+  expect(result.from).toBeTruthy();
+  expect(result.to).toBe(d0);
+  expect(Array.isArray(result.days)).toBe(true);
+
+  const dates = result.days.map((d) => d.date);
+  expect(dates).toContain(d2);
+  expect(dates).toContain(d1);
+  expect(dates).toContain(d0);
+
+  // provisionalDates: only today (no finalized marker was written for it).
+  expect(result.provisionalDates).toEqual([d0]);
+
+  // Totals across all 3 days: promptCount 4+3+2+1 = 10
+  expect(result.totals.promptCount).toBe(10);
+  expect(result.totals.activeMinutes).toBe(12 + 8 + 5 + 3);
+
+  // byProjectTotals: proj-a spans all 3 days, proj-b only day -1
+  expect(result.byProjectTotals['proj-a'].promptCount).toBe(4 + 3 + 1);
+  expect(result.byProjectTotals['proj-b'].promptCount).toBe(2);
+
+  // byModelTotals: sonnet appears on all 3 days for proj-a + day -1 for... only proj-a uses sonnet
+  expect(result.byModelTotals['claude-sonnet-5'].inputTokens).toBe(1000 + 500 + 100);
+  expect(result.byModelTotals['claude-sonnet-5'].costUsd).toBeGreaterThan(0);
+  expect(result.byModelTotals['claude-opus-5'].inputTokens).toBe(300);
+
+  // toolsByProject
+  expect(result.toolsByProject['proj-a']).toEqual({ Read: 2, Edit: 1, Bash: 1 });
+  expect(result.toolsByProject['proj-b']).toEqual({});
+
+  // Per-day, per-project bucket shape.
+  const dayMinus2 = result.days.find((d) => d.date === d2);
+  expect(dayMinus2.byProject['proj-a'].promptCount).toBe(4);
+  expect(dayMinus2.byProject['proj-a'].byModel['claude-sonnet-5'].costUsd).toBeGreaterThan(0);
+
+  expect(typeof result.generatedAt).toBe('number');
+});
+
+test('dashboard: rangeDays=0 (all time) includes every day with no prior-window bound, prevTotals stays zero', async () => {
+  await seedThreeDayFixture();
+
+  const result = await historyDashboard.computeDashboard({ rangeDays: 0 });
+  expect(result.days.length).toBe(3);
+  expect(result.prevTotals.promptCount).toBe(0);
+  expect(result.prevTotals.estimatedCostUsd).toBe(0);
+});
+
+test('dashboard: prevTotals aggregates the prior window distinct from the current window', async () => {
+  const d0 = today();
+  // Two 1-day windows: rangeDays=1 → current = [today, today], prior = [yesterday, yesterday].
+  const yesterday = daysAgo(1);
+  await historyRollup.appendRollupDays([
+    { date: yesterday, projectDir: 'proj-a', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 9, sessionCount: 1, activeMinutes: 20, v: 2 },
+    { date: yesterday, projectDir: historyRollup.FINALIZED_PROJECT_ID, modelId: historyRollup.FINALIZED_MODEL_ID, finalizedAt: 1, v: 2 },
+    { date: d0, projectDir: 'proj-a', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 2, sessionCount: 1, activeMinutes: 4, v: 2 },
+  ]);
+
+  const result = await historyDashboard.computeDashboard({ rangeDays: 1 });
+  expect(result.totals.promptCount).toBe(2);
+  expect(result.prevTotals.promptCount).toBe(9);
+});
+
+test('zero-scan guarantee: computeDashboard never reads PROJECTS_DIR / transcript files', async () => {
+  await seedThreeDayFixture();
+
+  const fsp = require('node:fs/promises');
+  const PROJECTS_DIR = path.join(tmpHome, '.claude', 'projects');
+  const readdirSpy = vi.spyOn(fsp, 'readdir');
+
+  await historyDashboard.computeDashboard({ rangeDays: 30 });
+
+  const scannedProjectsDir = readdirSpy.mock.calls.some((call) => String(call[0]).startsWith(PROJECTS_DIR));
+  expect(scannedProjectsDir).toBe(false);
+
+  readdirSpy.mockRestore();
+});

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

@@ -0,0 +1,333 @@
+/**
+ * historyRollup.test.cjs — unit tests for src/main/lib/historyRollup.cjs
+ * (durable daily rollup) and its integration into historyAggregator.cjs
+ * (rollup-first closed-day aggregation, finalize pass, backfill, deleted-file
+ * immunity).
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/historyRollup.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let realHome;
+let historyRollup;
+let historyAggregator;
+
+function encodeCwd(cwd) {
+  return cwd.replace(/\//g, '-');
+}
+
+function writeTranscript(projectCwd, sessionId, lines, mtime) {
+  const encoded = encodeCwd(projectCwd);
+  const dir = path.join(tmpHome, '.claude', 'projects', encoded);
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, `${sessionId}.jsonl`);
+  fs.writeFileSync(file, lines.map((l) => JSON.stringify(l)).join('\n') + '\n', 'utf8');
+  if (mtime) fs.utimesSync(file, mtime, mtime);
+  return file;
+}
+
+function userLine(ts) {
+  return { role: 'user', ts };
+}
+
+function assistantLine(ts, model, tokens = {}) {
+  return {
+    ts,
+    message: {
+      role: 'assistant',
+      model,
+      usage: {
+        input_tokens: tokens.in ?? 10,
+        output_tokens: tokens.out ?? 5,
+        cache_read_input_tokens: tokens.cacheR ?? 0,
+        cache_creation_input_tokens: tokens.cacheC ?? 0,
+      },
+    },
+  };
+}
+
+// These modules are required via Node's own require() (this is a .cjs file,
+// not transformed ESM), so vi.resetModules() — which only resets vitest's
+// ESM module graph — does NOT clear them. Each module also bakes os.homedir()
+// into a top-level const (ROLLUP_PATH, config.cjs's allowedRoots/
+// WRITE_PREFIXES) at first require. Without purging Node's require.cache here,
+// every test after the first would keep writing to the FIRST test's tmpHome.
+const MODULES_TO_RELOAD = [
+  '../lib/historyRollup.cjs',
+  '../historyAggregator.cjs',
+  '../config.cjs',
+];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'history-rollup-test-'));
+  process.env.HOME = tmpHome;
+  purgeRequireCache();
+  historyRollup = require('../lib/historyRollup.cjs');
+  historyAggregator = require('../historyAggregator.cjs');
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  purgeRequireCache();
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test('rollupKey is stable and distinguishes date/project/model', () => {
+  const a = historyRollup.rollupKey('2026-07-01', 'proj-a', 'sonnet');
+  const b = historyRollup.rollupKey('2026-07-01', 'proj-a', 'opus');
+  const c = historyRollup.rollupKey('2026-07-02', 'proj-a', 'sonnet');
+  expect(a).not.toBe(b);
+  expect(a).not.toBe(c);
+  expect(historyRollup.rollupKey('2026-07-01', 'proj-a', 'sonnet')).toBe(a);
+});
+
+test('mergeRollupLines: last-write-wins per key', () => {
+  const lines = [
+    JSON.stringify({ date: '2026-07-01', projectDir: 'p', modelId: 'sonnet', inputTokens: 10 }),
+    JSON.stringify({ date: '2026-07-01', projectDir: 'p', modelId: 'sonnet', inputTokens: 99 }),
+    JSON.stringify({ date: '2026-07-01', projectDir: 'p', modelId: 'opus', inputTokens: 5 }),
+  ];
+  const merged = historyRollup.mergeRollupLines(lines);
+  expect(merged.size).toBe(2);
+  const key = historyRollup.rollupKey('2026-07-01', 'p', 'sonnet');
+  expect(merged.get(key).inputTokens).toBe(99);
+});
+
+test('mergeRollupLines: skips malformed lines without throwing', () => {
+  const lines = ['not json', '', JSON.stringify({ date: '2026-07-01', projectDir: 'p', modelId: '' })];
+  expect(() => historyRollup.mergeRollupLines(lines)).not.toThrow();
+  expect(historyRollup.mergeRollupLines(lines).size).toBe(1);
+});
+
+test('appendRollupDays + readRollup: date-range read only returns in-range buckets', async () => {
+  await historyRollup.appendRollupDays([
+    { date: '2026-07-01', projectDir: 'p', modelId: 'sonnet', inputTokens: 1 },
+    { date: '2026-07-05', projectDir: 'p', modelId: 'sonnet', inputTokens: 2 },
+    { date: '2026-07-10', projectDir: 'p', modelId: 'sonnet', inputTokens: 3 },
+  ]);
+  const map = await historyRollup.readRollup('2026-07-02', '2026-07-09');
+  expect(map.size).toBe(1);
+  const only = Array.from(map.values())[0];
+  expect(only.date).toBe('2026-07-05');
+});
+
+test('appendRollupDays: compacts (dedupes) once file exceeds threshold', async () => {
+  // Force a tiny threshold isn't exposed, so just verify repeated appends of
+  // the SAME key collapse to one line on disk after a compact() call.
+  await historyRollup.appendRollupDays([
+    { date: '2026-07-01', projectDir: 'p', modelId: 'sonnet', inputTokens: 1 },
+  ]);
+  await historyRollup.appendRollupDays([
+    { date: '2026-07-01', projectDir: 'p', modelId: 'sonnet', inputTokens: 2 },
+  ]);
+  await historyRollup.compact();
+  const raw = fs.readFileSync(historyRollup.ROLLUP_PATH, 'utf8');
+  const nonEmptyLines = raw.split('\n').filter((l) => l.trim());
+  expect(nonEmptyLines.length).toBe(1);
+  expect(JSON.parse(nonEmptyLines[0]).inputTokens).toBe(2);
+});
+
+test('finalizeClosedDays: skips today, only finalizes days strictly before today', async () => {
+  const today = new Date().toLocaleDateString('en-CA');
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toLocaleDateString('en-CA');
+  const cwd = '/tmp/projfinalize';
+
+  writeTranscript(cwd, 'sess-today', [
+    userLine(new Date().toISOString()),
+    assistantLine(new Date().toISOString(), 'claude-sonnet-5'),
+  ]);
+  writeTranscript(cwd, 'sess-yesterday', [
+    userLine(new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()),
+    assistantLine(new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), 'claude-sonnet-5'),
+  ]);
+
+  await historyAggregator.finalizeClosedDays();
+
+  const map = await historyRollup.readRollup('2000-01-01', today);
+  const todayFinalized = historyRollup.isDateFinalized(map, today);
+  const yesterdayFinalized = historyRollup.isDateFinalized(map, yesterday);
+  expect(todayFinalized).toBe(false);
+  expect(yesterdayFinalized).toBe(true);
+});
+
+test('deleted-transcript immunity: aggregate returns a finalized day even after its .jsonl is deleted', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const cwd = '/tmp/projdeleted';
+  const file = writeTranscript(cwd, 'sess-del', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 100, out: 50 }),
+  ]);
+
+  await historyAggregator.finalizeClosedDays();
+  fs.rmSync(file);
+
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const result = await historyAggregator.remote.aggregate({ fromDate: yStr, toDate: yStr });
+  const row = result.rows.find((r) => r.encodedCwd === encodeCwd(cwd));
+  expect(row).toBeTruthy();
+  expect(row.inputTokens).toBeGreaterThanOrEqual(100);
+  expect(result.rollupDays).toBeGreaterThanOrEqual(1);
+});
+
+test('backfill fold-in: aggregate() folds a rollup-missing past day into the rollup', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projbackfill';
+  writeTranscript(cwd, 'sess-backfill', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 7, out: 3 }),
+  ]);
+
+  // No finalize pass has run — the rollup has nothing for this day yet.
+  const before = await historyRollup.readRollup(yStr, yStr);
+  expect(before.size).toBe(0);
+
+  const result = await historyAggregator.remote.aggregate({ fromDate: yStr, toDate: yStr });
+  const row = result.rows.find((r) => r.encodedCwd === encodeCwd(cwd));
+  expect(row).toBeTruthy();
+  expect(row.inputTokens).toBeGreaterThanOrEqual(7);
+
+  const after = await historyRollup.readRollup(yStr, yStr);
+  expect(after.size).toBeGreaterThan(0);
+});
+
+test('finalizeClosedDays: budgetMs exceeded before any dir is walked → no dates finalized, partial=true', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projbudgetcap';
+  writeTranscript(cwd, 'sess-budgetcap', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 11, out: 4 }),
+  ]);
+
+  const result = await historyAggregator.finalizeClosedDays({ budgetMs: -1 });
+  expect(result.partial).toBe(true);
+  expect(result.finalizedDates).toEqual([]);
+
+  const map = await historyRollup.readRollup('2000-01-01', yStr);
+  expect(historyRollup.isDateFinalized(map, yStr)).toBe(false);
+});
+
+test('finalizeClosedDays: unbounded budgetMs finalizes normally (partial=false)', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projbudgetok';
+  writeTranscript(cwd, 'sess-budgetok', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 9, out: 2 }),
+  ]);
+
+  const result = await historyAggregator.finalizeClosedDays({ budgetMs: 60_000 });
+  expect(result.partial).toBe(false);
+  expect(result.finalizedDates).toContain(yStr);
+
+  const map = await historyRollup.readRollup('2000-01-01', yStr);
+  expect(historyRollup.isDateFinalized(map, yStr)).toBe(true);
+});
+
+test('finalizeClosedDays: dryRun computes finalizedDates but writes nothing', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projdryrun';
+  writeTranscript(cwd, 'sess-dryrun', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 5, out: 1 }),
+  ]);
+
+  const result = await historyAggregator.finalizeClosedDays({ dryRun: true });
+  expect(result.partial).toBe(false);
+  expect(result.finalizedDates).toContain(yStr);
+
+  const map = await historyRollup.readRollup('2000-01-01', yStr);
+  expect(map.size).toBe(0);
+});
+
+test('computeActiveMinutes: clamps to [0, 24h] and handles missing/invalid timestamps', () => {
+  const { computeActiveMinutes } = historyAggregator;
+  expect(computeActiveMinutes(null, '2026-07-01T00:10:00Z')).toBe(0);
+  expect(computeActiveMinutes('2026-07-01T00:00:00Z', null)).toBe(0);
+  expect(computeActiveMinutes('not-a-date', '2026-07-01T00:10:00Z')).toBe(0);
+  expect(computeActiveMinutes('2026-07-01T00:00:00Z', '2026-07-01T00:10:00Z')).toBeCloseTo(10, 5);
+  // Out-of-order (last before first) clamps to 0, not negative.
+  expect(computeActiveMinutes('2026-07-01T00:10:00Z', '2026-07-01T00:00:00Z')).toBe(0);
+  // A 30h span clamps to the 24h ceiling.
+  expect(computeActiveMinutes('2026-07-01T00:00:00Z', '2026-07-02T06:00:00Z')).toBe(24 * 60);
+});
+
+test('rollup v1 lines default activeMinutes to 0 and v to 1 at read time', async () => {
+  await historyRollup.appendRollupDays([
+    // v1-shaped line: no activeMinutes, no v field.
+    { date: '2026-07-01', projectDir: 'p', modelId: historyRollup.TOTALS_MODEL_ID, promptCount: 5 },
+  ]);
+  const map = await historyRollup.readRollup('2026-07-01', '2026-07-01');
+  const bucket = map.get(historyRollup.rollupKey('2026-07-01', 'p', historyRollup.TOTALS_MODEL_ID));
+  expect(bucket.activeMinutes).toBe(0);
+});
+
+test('refreshIntradayToday: upserts a provisional (non-finalized) line for today; a second run replaces it after compact', async () => {
+  const now = new Date();
+  const today = now.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projintraday';
+
+  writeTranscript(cwd, 'sess-intraday', [
+    userLine(new Date(now.getTime() - 5 * 60_000).toISOString()),
+    assistantLine(new Date(now.getTime() - 5 * 60_000).toISOString(), 'claude-sonnet-5', { in: 10, out: 5 }),
+    assistantLine(now.toISOString(), 'claude-sonnet-5', { in: 3, out: 1 }),
+  ]);
+
+  const first = await historyAggregator.refreshIntradayToday();
+  expect(first.date).toBe(today);
+  expect(first.projectsUpdated).toBeGreaterThanOrEqual(1);
+
+  let map = await historyRollup.readRollup(today, today);
+  expect(historyRollup.isDateFinalized(map, today)).toBe(false);
+  const totalsKey = historyRollup.rollupKey(today, encodeCwd(cwd), historyRollup.TOTALS_MODEL_ID);
+  const firstBucket = map.get(totalsKey);
+  expect(firstBucket).toBeTruthy();
+  expect(firstBucket.promptCount).toBeGreaterThanOrEqual(1);
+  expect(firstBucket.activeMinutes).toBeGreaterThan(0);
+
+  // A second refresh (e.g. 5 min later, more activity) replaces — not
+  // duplicates — today's line for the same key once the file is compacted.
+  await historyAggregator.refreshIntradayToday();
+  await historyRollup.compact();
+  const raw = fs.readFileSync(historyRollup.ROLLUP_PATH, 'utf8');
+  const matchingLines = raw.split('\n').filter((l) => {
+    if (!l.trim()) return false;
+    const obj = JSON.parse(l);
+    return obj.date === today && obj.projectDir === encodeCwd(cwd) && obj.modelId === historyRollup.TOTALS_MODEL_ID;
+  });
+  expect(matchingLines.length).toBe(1);
+});
+
+test('history:aggregate PARSE_BUDGET_MS truncation only affects today; finalized closed days come back complete', async () => {
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+  const yStr = yesterday.toLocaleDateString('en-CA');
+  const cwd = '/tmp/projbudget';
+  writeTranscript(cwd, 'sess-budget', [
+    userLine(yesterday.toISOString()),
+    assistantLine(yesterday.toISOString(), 'claude-sonnet-5', { in: 42, out: 21 }),
+  ]);
+
+  await historyAggregator.finalizeClosedDays();
+
+  const result = await historyAggregator.remote.aggregate({ fromDate: yStr, toDate: yStr });
+  expect(result.truncated).toBe(false);
+  const row = result.rows.find((r) => r.encodedCwd === encodeCwd(cwd));
+  expect(row).toBeTruthy();
+  expect(row.inputTokens).toBeGreaterThanOrEqual(42);
+});

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

@@ -0,0 +1,74 @@
+/**
+ * prdParserHighWater.test.cjs — regression test for allocateParallelGroup's
+ * high-water mark: once queueOps.cjs's autoArchiveCompleted starts moving
+ * old NN-*.md files out of prds/ into prds-archived/, a bare directory scan
+ * (maxParallelGroupInUse) can regress once the highest-NN files age out —
+ * letting a later allocation reissue an already-used NN and collide with an
+ * archived group. The high-water-mark sidecar (.max-allocated-group) must
+ * keep the allocator monotonic even after every file is archived away.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/prdParserHighWater.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const { allocateParallelGroup, maxParallelGroupInUse, _resetCache } = require('../scheduler/prdParser.cjs');
+
+function mkTmpPrdsDir() {
+  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-highwater-'));
+}
+
+test('allocator stays monotonic after every NN-*.md file (and its reservation marker) is archived away', async () => {
+  const dir = await mkTmpPrdsDir();
+  _resetCache();
+
+  // Directly-authored legacy files (never allocated via allocateParallelGroup
+  // — e.g. /develop's deliberate-sibling path — so no .reserved-NN marker
+  // exists for them). This is the real gap: reservation markers alone would
+  // already protect any NN the allocator itself minted, so the regression
+  // this PRD guards against is specifically legacy/directly-authored NNs.
+  await fsp.writeFile(path.join(dir, '10-a.md'), '# a\n');
+  await fsp.writeFile(path.join(dir, '544-b.md'), '# b\n');
+
+  // A scan (via allocateParallelGroup) observes 544 and persists it as the
+  // high-water mark before returning the next free NN.
+  const first = await allocateParallelGroup(dir);
+  expect(first).toBe(545);
+
+  // Simulate autoArchiveCompleted moving every .md out of the live dir, and
+  // also strip the reservation marker the allocation above created — so
+  // nothing on disk still evidences 544/545 except the high-water sidecar.
+  await fsp.unlink(path.join(dir, '10-a.md'));
+  await fsp.unlink(path.join(dir, '544-b.md'));
+  await fsp.unlink(path.join(dir, '.reserved-545'));
+
+  const bareScanMax = await maxParallelGroupInUse(dir);
+  expect(bareScanMax).toBe(0);
+
+  _resetCache();
+  const second = await allocateParallelGroup(dir);
+  expect(second).toBeGreaterThan(545);
+  expect(second).toBe(546);
+});
+
+test('high-water mark also protects against a fresh scan that is lower than a prior allocation, without any archiving involved', async () => {
+  const dir = await mkTmpPrdsDir();
+  _resetCache();
+
+  await fsp.writeFile(path.join(dir, '5-only.md'), '# x\n');
+  const nn = await allocateParallelGroup(dir);
+  expect(nn).toBe(6);
+
+  // A slow/partial directory listing (or a caller passing a differently
+  // scoped dir) must not be able to walk the allocator backwards.
+  const rescanMax = await maxParallelGroupInUse(dir);
+  expect(rescanMax).toBe(6); // the .reserved-6 marker from the allocation above still counts
+
+  const next = await allocateParallelGroup(dir);
+  expect(next).toBe(7);
+});