claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,333 +0,0 @@
-/**
- * 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.historyRollupPath(), '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.historyRollupPath(), '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__/intradayRefresh.test.cjs

@@ -1,39 +0,0 @@
-import { test, expect, vi } from 'vitest';
-const { createIntradayRefresh } = require('../lib/intradayRefresh.cjs');
-
-const mk = (over = {}) => {
-  const logs = { writeLine: vi.fn() };
-  const releaseLock = vi.fn();
-  const deps = { tryAcquireLock: vi.fn(() => true), releaseLock, lockPath: '/x.lock', refresh: vi.fn(async () => {}), logs, ...over };
-  return { deps, run: createIntradayRefresh(deps), logs, releaseLock };
-};
-const flush = () => new Promise((r) => setTimeout(r, 0));
-
-test('sync throw from refresh releases the lock and logs', async () => {
-  const { run, logs, releaseLock } = mk({ refresh: () => { throw new Error('boom'); } });
-  expect(() => run()).not.toThrow();
-  await flush();
-  expect(releaseLock).toHaveBeenCalledWith('/x.lock');
-  expect(logs.writeLine).toHaveBeenCalled();
-});
-
-test('async rejection releases the lock', async () => {
-  const { run, releaseLock } = mk({ refresh: async () => { throw new Error('x'); } });
-  run(); await flush();
-  expect(releaseLock).toHaveBeenCalledTimes(1);
-});
-
-test('lock-acquire throw is logged, not escaped, and no release', async () => {
-  const { run, logs, releaseLock, deps } = mk({ tryAcquireLock: () => { throw Object.assign(new Error('EACCES'), { code: 'EACCES' }); } });
-  expect(() => run()).not.toThrow();
-  expect(logs.writeLine).toHaveBeenCalledTimes(1);
-  expect(releaseLock).not.toHaveBeenCalled();
-  expect(deps.refresh).not.toHaveBeenCalled();
-});
-
-test('contended lock skips refresh', () => {
-  const { run, deps, releaseLock } = mk({ tryAcquireLock: () => false });
-  run();
-  expect(deps.refresh).not.toHaveBeenCalled();
-  expect(releaseLock).not.toHaveBeenCalled();
-});

package/src/main/__tests__/ipcSchemas-dependsOn.test.cjs

@@ -1,39 +0,0 @@
-/**
- * ipcSchemas-dependsOn.test.cjs — dependsOn array cap for schedulerCreatePrd
- * (PRD: raise-dependson-cap-to-100). A /develop plan's validate PRD depends
- * on every other slug in the plan, so the cap must clear a 36-PRD plan while
- * still bounding an unbounded payload.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/ipcSchemas-dependsOn.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { schemas } = require('../ipcSchemas.cjs');
-
-const basePrd = {
-  title: 'validate the plan',
-  estimateMinutes: 5,
-  goal: 'Validate the plan',
-  acceptanceCriteria: ['it validates'],
-  implementationNotes: 'n/a',
-};
-
-test('schedulerCreatePrd accepts 36 dependsOn entries', () => {
-  const dependsOn = Array.from({ length: 36 }, (_, i) => `prd-${i}`);
-  const result = schemas.schedulerCreatePrd.safeParse({ ...basePrd, dependsOn });
-  expect(result.success).toBe(true);
-});
-
-test('schedulerCreatePrd rejects 101 dependsOn entries', () => {
-  const dependsOn = Array.from({ length: 101 }, (_, i) => `prd-${i}`);
-  const result = schemas.schedulerCreatePrd.safeParse({ ...basePrd, dependsOn });
-  expect(result.success).toBe(false);
-});
-
-test('schedulerCreatePrd accepts exactly 100 dependsOn entries', () => {
-  const dependsOn = Array.from({ length: 100 }, (_, i) => `prd-${i}`);
-  const result = schemas.schedulerCreatePrd.safeParse({ ...basePrd, dependsOn });
-  expect(result.success).toBe(true);
-});

package/src/main/__tests__/kg-augment.test.cjs

@@ -1,195 +0,0 @@
-'use strict';
-
-/**
- * Unit test for kg exchange-pairing logic (kgExchangePairing.cjs).
- *
- * Verifies:
- *   1. When a prompt has a matching exchange record, the enriched entry includes
- *      result and summary from the exchange.
- *   2. When no exchange file exists for the cwd, entries fall back to prompt-only
- *      (no crash, no empty-graph wipe).
- *   3. When an exchange exists but the prompt text doesn't match, the entry is
- *      returned unchanged (no false enrichment).
- *   4. normalizePromptKey trims, lowercases, and collapses whitespace so minor
- *      differences between log sources don't break the match.
- *
- * Does NOT spawn claude -p. Run:
- *   timeout 300 npx vitest run src/main/__tests__/kg-augment.test.cjs
- */
-
-import { test, describe, beforeAll as before, afterAll as after } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const os = require('node:os');
-
-// ─── Tmp directory ───────────────────────────────────────────────────────────
-
-let tmpDir;
-
-before(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kg-augment-test-'));
-});
-
-after(async () => {
-  await fsp.rm(tmpDir, { recursive: true, force: true });
-});
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function freshRequire(mod) {
-  delete require.cache[require.resolve(mod)];
-  return require(mod);
-}
-
-const PAIRING_MOD = '../lib/kgExchangePairing.cjs';
-
-/** Write NDJSON exchange records to a file under a fresh exchanges dir. */
-async function writeExchangeFile(exchangesDir, cwd, records) {
-  // Derive the encoded cwd the same way the module does
-  const { encodeCwd } = require('../lib/encodeCwd.cjs');
-  const encoded = encodeCwd(cwd);
-  const filePath = path.join(exchangesDir, `${encoded}.jsonl`);
-  await fsp.mkdir(exchangesDir, { recursive: true });
-  const content = records.map((r) => JSON.stringify(r)).join('\n') + '\n';
-  await fsp.writeFile(filePath, content, 'utf8');
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe('normalizePromptKey', () => {
-  test('lowercases, collapses whitespace, trims', () => {
-    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
-    assert.equal(normalizePromptKey('  Hello   World  '), 'hello world');
-    assert.equal(normalizePromptKey('Fix\nthe\t\tbug'), 'fix the bug');
-  });
-
-  test('truncates at 500 chars', () => {
-    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
-    const long = 'a'.repeat(800);
-    assert.equal(normalizePromptKey(long).length, 500);
-  });
-
-  test('handles empty / null / undefined gracefully', () => {
-    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
-    assert.equal(normalizePromptKey(''), '');
-    assert.equal(normalizePromptKey(null), '');
-    assert.equal(normalizePromptKey(undefined), '');
-  });
-});
-
-describe('loadExchangeIndex', () => {
-  test('returns empty Map when exchanges file does not exist', async () => {
-    const { loadExchangeIndex } = freshRequire(PAIRING_MOD);
-    const exchangesDir = path.join(tmpDir, 'missing-dir');
-    const idx = await loadExchangeIndex(exchangesDir, '/some/project');
-    assert.ok(idx instanceof Map);
-    assert.equal(idx.size, 0, 'should return empty Map on missing file');
-  });
-
-  test('indexes exchange records by normalized prompt key', async () => {
-    const { loadExchangeIndex } = freshRequire(PAIRING_MOD);
-    const exchangesDir = path.join(tmpDir, 'idx-test-exchanges');
-    const cwd = '/home/user/testproject';
-
-    await writeExchangeFile(exchangesDir, cwd, [
-      { ts: '2026-06-25T01:00:00Z', sessionId: 's1', cwd, prompt: 'Fix the bug', result: 'I fixed it.', summary: 'Bug fixed.' },
-      { ts: '2026-06-25T01:01:00Z', sessionId: 's1', cwd, prompt: 'Add a feature', result: 'Feature added.', summary: 'Feature added.' },
-    ]);
-
-    const idx = await loadExchangeIndex(exchangesDir, cwd);
-    assert.equal(idx.size, 2);
-    assert.ok(idx.has('fix the bug'), 'should have normalized key');
-    assert.equal(idx.get('fix the bug').result, 'I fixed it.');
-    assert.equal(idx.get('fix the bug').summary, 'Bug fixed.');
-  });
-
-  test('skips malformed NDJSON lines without throwing', async () => {
-    const { loadExchangeIndex, normalizePromptKey } = freshRequire(PAIRING_MOD);
-    const { encodeCwd } = require('../lib/encodeCwd.cjs');
-    const exchangesDir = path.join(tmpDir, 'malformed-test');
-    const cwd = '/home/user/malformed';
-
-    await fsp.mkdir(exchangesDir, { recursive: true });
-    const encoded = encodeCwd(cwd);
-    const filePath = path.join(exchangesDir, `${encoded}.jsonl`);
-    await fsp.writeFile(filePath, [
-      'not-json-at-all',
-      JSON.stringify({ ts: '2026-06-25T00:00:00Z', sessionId: 's1', cwd, prompt: 'valid prompt', result: 'ok', summary: 'ok' }),
-      '{ broken json',
-    ].join('\n') + '\n', 'utf8');
-
-    const idx = await loadExchangeIndex(exchangesDir, cwd);
-    assert.equal(idx.size, 1, 'should index only the valid line');
-    assert.ok(idx.has(normalizePromptKey('valid prompt')));
-  });
-});
-
-describe('enrichEntries', () => {
-  test('adds result and summary when exchange matches by prompt text', async () => {
-    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
-    const exchangesDir = path.join(tmpDir, 'enrich-match');
-    const cwd = '/home/user/myapp';
-
-    await writeExchangeFile(exchangesDir, cwd, [
-      { ts: '2026-06-25T10:00:00Z', sessionId: 's1', cwd, prompt: 'Refactor the scheduler', result: 'I refactored it.', summary: 'Scheduler refactored.' },
-    ]);
-
-    const idx = await loadExchangeIndex(exchangesDir, cwd);
-
-    const entries = [
-      { ts: '2026-06-25T09:59:00Z', session_id: 's1', cwd, prompt: 'Refactor the scheduler' },
-      { ts: '2026-06-25T09:58:00Z', session_id: 's1', cwd, prompt: 'Unrelated prompt' },
-    ];
-
-    const enriched = enrichEntries(entries, idx);
-
-    // First entry has a match — should have result + summary
-    assert.equal(enriched[0].result, 'I refactored it.', 'matched entry should get result');
-    assert.equal(enriched[0].summary, 'Scheduler refactored.', 'matched entry should get summary');
-    // Original fields preserved
-    assert.equal(enriched[0].prompt, 'Refactor the scheduler');
-    assert.equal(enriched[0].cwd, cwd);
-
-    // Second entry has no match — returned unchanged (no result/summary)
-    assert.equal(enriched[1].result, undefined, 'unmatched entry should not get result');
-    assert.equal(enriched[1].summary, undefined, 'unmatched entry should not get summary');
-    assert.equal(enriched[1].prompt, 'Unrelated prompt');
-  });
-
-  test('falls back to prompt-only when exchange index is empty (missing file)', async () => {
-    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
-    // Point at a directory that doesn't exist
-    const idx = await loadExchangeIndex(path.join(tmpDir, 'nonexistent'), '/some/cwd');
-    assert.equal(idx.size, 0);
-
-    const entries = [
-      { ts: '2026-06-25T00:00:00Z', session_id: 'sx', cwd: '/some/cwd', prompt: 'Do something' },
-    ];
-    const enriched = enrichEntries(entries, idx);
-    // Entry returned unchanged — no crash
-    assert.equal(enriched.length, 1);
-    assert.equal(enriched[0].prompt, 'Do something');
-    assert.equal(enriched[0].result, undefined);
-    assert.equal(enriched[0].summary, undefined);
-  });
-
-  test('whitespace-tolerant matching (trailing newline in one source)', async () => {
-    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
-    const exchangesDir = path.join(tmpDir, 'ws-tolerant');
-    const cwd = '/home/user/wstol';
-
-    // Exchange record has trailing whitespace/newline in prompt
-    await writeExchangeFile(exchangesDir, cwd, [
-      { ts: '2026-06-25T00:00:00Z', sessionId: 's1', cwd, prompt: '  Build the widget  \n', result: 'Widget built.', summary: 'Widget.' },
-    ]);
-
-    const idx = await loadExchangeIndex(exchangesDir, cwd);
-
-    // Prompt log entry has clean text — should still match after normalization
-    const entries = [{ ts: '2026-06-25T00:00:01Z', session_id: 's1', cwd, prompt: 'Build the widget' }];
-    const enriched = enrichEntries(entries, idx);
-    assert.equal(enriched[0].result, 'Widget built.', 'should match despite whitespace differences');
-  });
-});

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

@@ -1,31 +0,0 @@
-/**
- * loadGateDetailTick.test.cjs — unit test for the human-readable detail
- * string a `reason: 'load-deferred'` tick surfaces to the renderer via
- * lastTick.detail (buildScheduleStatePayload). Extracted as a pure function
- * (formatLoadGateDetail) so this is testable without driving tickQueue's
- * full fs/worktree machinery or launching the app.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/loadGateDetailTick.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { formatLoadGateDetail } = require('../scheduler.cjs');
-
-test('names the load gate, the measured ratio, the threshold and how long it has been held', () => {
-  const detail = formatLoadGateDetail({
-    loadavg1: 13.31,
-    cores: 14,
-    ratio: 0.951,
-    threshold: 0.85,
-    gatedSinceMs: 83 * 60_000,
-  });
-
-  expect(detail).toMatch(/load gate/i);
-  expect(detail).toContain('13.31');
-  expect(detail).toContain('14');
-  expect(detail).toContain('0.951');
-  expect(detail).toContain('0.85');
-  expect(detail).toMatch(/83m/);
-});