claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/lib/__tests__/telemetryBoot.test.cjs

@@ -1,134 +0,0 @@
-/**
- * telemetryBoot.test.cjs — unit tests for the boot-time telemetry send rules:
- * the machine-profile heartbeat (version-change OR 30-day liveness) and the
- * boot/version-change flush triggers.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/telemetryBoot.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const { bootSequence } = require('../telemetryBoot.cjs');
-const telemetrySettings = require('../telemetrySettings.cjs');
-
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-function fakeDeps({ settings } = {}) {
-  let saved = { ...telemetrySettings.DEFAULTS, ...settings };
-  const flushCalls = [];
-  return {
-    state: () => saved,
-    flushCalls,
-    deps: {
-      telemetrySettings: {
-        load: async () => saved,
-        save: async (next) => { saved = { ...saved, ...next }; return saved; },
-        isMachineReportDue: telemetrySettings.isMachineReportDue,
-      },
-      telemetryClient: {
-        flush: async (reason) => { flushCalls.push(reason); return { sent: [], failed: [], reason }; },
-        reportInstall: async (profile) => ({ accepted: true, profile }),
-      },
-      buildMachineProfile: async () => ({ appVersion: '1.0.0', platform: 'linux', arch: 'x64', machineDigest: 'abc123' }),
-      telemetryCounters: { trackAppLaunch: () => {} },
-    },
-  };
-}
-
-test('a second boot at the same version within 30 days sends nothing', async () => {
-  const now = Date.now();
-  const priorReportAt = new Date(now - DAY_MS).toISOString();
-  const { deps, state } = fakeDeps({
-    settings: { lastMachineReportAt: priorReportAt, lastMachineReportVersion: '1.0.0' },
-  });
-  const seen = [];
-  deps.telemetryClient.reportInstall = async (profile) => { seen.push(profile); return { accepted: true }; };
-
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-
-  expect(seen).toHaveLength(0);
-  expect(state().lastMachineReportAt).toBe(priorReportAt);
-});
-
-test('a version bump sends the machine profile exactly once', async () => {
-  const now = Date.now();
-  const { deps, state } = fakeDeps({
-    settings: { lastMachineReportAt: new Date(now - DAY_MS).toISOString(), lastMachineReportVersion: '1.0.0' },
-  });
-  const seen = [];
-  deps.telemetryClient.reportInstall = async (profile) => { seen.push(profile); return { accepted: true }; };
-
-  await bootSequence({ now, appVersion: '2.0.0', deps });
-
-  expect(seen.length).toBe(1);
-  expect(state().lastMachineReportVersion).toBe('2.0.0');
-});
-
-test('31 days on an unchanged version sends the machine profile exactly once (liveness heartbeat)', async () => {
-  const now = Date.now();
-  const { deps, state } = fakeDeps({
-    settings: { lastMachineReportAt: new Date(now - 31 * DAY_MS).toISOString(), lastMachineReportVersion: '1.0.0' },
-  });
-  const seen = [];
-  deps.telemetryClient.reportInstall = async (profile) => { seen.push(profile); return { accepted: true }; };
-
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-
-  expect(seen.length).toBe(1);
-  expect(state().lastMachineReportAt).toBe(new Date(now).toISOString());
-});
-
-test('the install report appVersion equals the appVersion stamped on a sibling error record', async () => {
-  const now = Date.now();
-  const { deps } = fakeDeps({ settings: { lastMachineReportVersion: '', lastMachineReportAt: null } });
-  const seen = [];
-  deps.telemetryClient.reportInstall = async (profile) => { seen.push(profile); return { accepted: true }; };
-  // Sibling error record stamped by the SAME process's telemetryClient with the same appVersion.
-  const siblingErrorStampAppVersion = '1.0.0';
-
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-
-  const [install] = seen;
-  expect(install.appVersion).toBe(siblingErrorStampAppVersion);
-});
-
-test('on app ready, flush("boot") always runs', async () => {
-  const now = Date.now();
-  const { deps, flushCalls } = fakeDeps({ settings: { lastMachineReportVersion: '1.0.0', lastMachineReportAt: new Date(now).toISOString() } });
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-  expect(flushCalls).toContain('boot');
-});
-
-test('on a detected app-version change, flush("version-change") also runs', async () => {
-  const now = Date.now();
-  const { deps, flushCalls } = fakeDeps({ settings: { lastMachineReportVersion: '1.0.0', lastMachineReportAt: new Date(now).toISOString() } });
-  await bootSequence({ now, appVersion: '2.0.0', deps });
-  expect(flushCalls).toEqual(['boot', 'version-change']);
-});
-
-test('with no version change, flush("version-change") does NOT run', async () => {
-  const now = Date.now();
-  const { deps, flushCalls } = fakeDeps({ settings: { lastMachineReportVersion: '1.0.0', lastMachineReportAt: new Date(now).toISOString() } });
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-  expect(flushCalls).toEqual(['boot']);
-});
-
-test('a rejected reportInstall leaves lastMachineReportAt unset so the next boot retries', async () => {
-  const now = Date.now();
-  const { deps, state } = fakeDeps({ settings: { lastMachineReportVersion: '', lastMachineReportAt: null } });
-  deps.telemetryClient.reportInstall = async () => ({ accepted: false, reason: 'error' });
-
-  await bootSequence({ now, appVersion: '1.0.0', deps });
-
-  expect(state().lastMachineReportAt).toBe(null);
-  expect(state().lastMachineReportVersion).toBe('');
-});
-
-test('fires app.launch via telemetryCounters with installChannel + appVersion', async () => {
-  const now = Date.now();
-  const { deps } = fakeDeps({ settings: { lastMachineReportVersion: '1.0.0', lastMachineReportAt: new Date(now).toISOString() } });
-  const calls = [];
-  deps.telemetryCounters = { trackAppLaunch: (props) => calls.push(props) };
-  await bootSequence({ now, appVersion: '1.0.0', installChannel: 'npx', deps });
-  expect(calls).toEqual([{ installChannel: 'npx', appVersion: '1.0.0' }]);
-});

package/src/main/lib/__tests__/telemetryConsent.test.cjs

@@ -1,136 +0,0 @@
-/**
- * telemetryConsent.test.cjs — unit tests for the telemetry:set-config
- * handler's write path (PRD 1142).
- *
- * Run: timeout 300 npx vitest run src/main/lib/__tests__/telemetryConsent.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeEach, afterEach, vi } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpDirs = [];
-let originalHome;
-let originalSmTelemetrySpool;
-
-beforeEach(() => {
-  originalHome = process.env.HOME;
-  originalSmTelemetrySpool = process.env.SM_TELEMETRY_SPOOL;
-});
-
-afterEach(async () => {
-  if (originalHome !== undefined) process.env.HOME = originalHome; else delete process.env.HOME;
-  if (originalSmTelemetrySpool === undefined) delete process.env.SM_TELEMETRY_SPOOL; else process.env.SM_TELEMETRY_SPOOL = originalSmTelemetrySpool;
-  vi.unstubAllGlobals();
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkHome() {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-telemetry-consent-home-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function freshModules(home) {
-  process.env.HOME = home;
-  // Explicit opt-in: overrides the test-environment no-op guard so this
-  // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
-  for (const p of ['../telemetryConsent.cjs', '../telemetryClient.cjs', '../telemetrySettings.cjs', '../machineProfile.cjs', '../../config.cjs']) {
-    const resolved = require.resolve(p);
-    delete require.cache[resolved];
-  }
-  const telemetryConsent = require('../telemetryConsent.cjs');
-  const telemetrySettings = require('../telemetrySettings.cjs');
-  const telemetryClient = require('../telemetryClient.cjs');
-  telemetryClient._setMachineProfileBuilder(async () => ({
-    appVersion: '0.83.0', platform: 'linux', arch: 'x64', machineDigest: 'abc123', installChannel: 'dev',
-  }));
-  return { telemetryConsent, telemetrySettings, telemetryClient };
-}
-
-test('turning telemetry off persists enabled:false and telemetrySettings.isEnabled() reflects it', async () => {
-  const home = await mkHome();
-  const { telemetryConsent, telemetrySettings } = freshModules(home);
-  const cfg = await telemetrySettings.load();
-  expect(cfg.enabled).toBe(true);
-
-  const saved = await telemetryConsent.applyConsentUpdate({ ...cfg, enabled: false });
-  expect(saved.enabled).toBe(false);
-  expect(telemetrySettings.isEnabled(saved)).toBe(false);
-});
-
-test('after turning off, telemetryClient drops subsequent records at ingress', async () => {
-  const home = await mkHome();
-  const { telemetryConsent, telemetrySettings, telemetryClient } = freshModules(home);
-  const cfg = await telemetrySettings.load();
-  await telemetryConsent.applyConsentUpdate({ ...cfg, enabled: false });
-
-  const res = await telemetryClient.track('some.event', { a: 1 });
-  expect(res).toEqual({ accepted: false, reason: 'disabled' });
-  telemetryClient.shutdown();
-});
-
-test('turning off clears the pending queue file so a re-enable never resends it', async () => {
-  const home = await mkHome();
-  const { telemetryConsent, telemetrySettings, telemetryClient } = freshModules(home);
-
-  // Accumulate a record while still enabled.
-  const accepted = await telemetryClient.reportError({ name: 'BoomError', msg: 'kaboom', stack: 'at x' });
-  expect(accepted.accepted).toBe(true);
-  const beforeQueue = await fsp.readFile(telemetryClient.queuePath(), 'utf8');
-  expect(beforeQueue.trim().length).toBeGreaterThan(0);
-
-  const cfg = await telemetrySettings.load();
-  await telemetryConsent.applyConsentUpdate({ ...cfg, enabled: false });
-
-  const afterQueue = await fsp.readFile(telemetryClient.queuePath(), 'utf8');
-  expect(afterQueue.trim()).toBe('');
-  telemetryClient.shutdown();
-});
-
-test('turning off does NOT clear telemetry-sent.json or the watermarks — re-enabling later does not resend delivered history', async () => {
-  const home = await mkHome();
-  const { telemetryConsent, telemetrySettings, telemetryClient } = freshModules(home);
-
-  telemetryClient._setFetchImpl(async () => ({ ok: true, status: 200 }));
-  await telemetryClient.reportError({ name: 'SentError', msg: 'already delivered', stack: 'at y' });
-  await telemetryClient.flush('manual');
-  const sentPathContent = await fsp.readFile(telemetryClient.sentPath(), 'utf8');
-  expect(JSON.parse(sentPathContent).ids.length).toBeGreaterThan(0);
-
-  // Also seed a watermarks file to prove opt-out leaves it untouched.
-  const watermarksDir = path.join(home, '.claude', 'session-manager');
-  await fsp.mkdir(watermarksDir, { recursive: true });
-  const watermarksPath = path.join(watermarksDir, 'telemetry-watermarks.json');
-  const watermarksBefore = { 'abc123/errors-2026-01-01.jsonl': { bytesEnqueued: 100, bytesConfirmed: 100 } };
-  await fsp.writeFile(watermarksPath, JSON.stringify(watermarksBefore));
-
-  const cfg = await telemetrySettings.load();
-  await telemetryConsent.applyConsentUpdate({ ...cfg, enabled: false });
-
-  const sentAfter = await fsp.readFile(telemetryClient.sentPath(), 'utf8');
-  expect(sentAfter).toBe(sentPathContent);
-  const watermarksAfter = await fsp.readFile(watermarksPath, 'utf8');
-  expect(JSON.parse(watermarksAfter)).toEqual(watermarksBefore);
-  telemetryClient.shutdown();
-});
-
-test('turning telemetry on (already enabled) is a no-op on the queue', async () => {
-  const home = await mkHome();
-  const { telemetryConsent, telemetrySettings, telemetryClient } = freshModules(home);
-  await telemetryClient.reportError({ name: 'KeptError', msg: 'still queued', stack: 'at z' });
-  const before = await fsp.readFile(telemetryClient.queuePath(), 'utf8');
-
-  const cfg = await telemetrySettings.load();
-  await telemetryConsent.applyConsentUpdate({ ...cfg, enabled: true });
-
-  const after = await fsp.readFile(telemetryClient.queuePath(), 'utf8');
-  expect(after).toBe(before);
-  telemetryClient.shutdown();
-});

package/src/main/lib/__tests__/telemetryCounters.test.cjs

@@ -1,57 +0,0 @@
-/**
- * telemetryCounters.test.cjs — unit tests for the single shared emission
- * point behind 'app.launch' / 'session.open' / 'epic.create' /
- * 'scheduler.job.finish'. Each real call site (pty.cjs, epicMint.cjs,
- * scheduleJobTransitions.cjs, telemetryBoot.cjs) delegates here, so this is
- * where the event name + prop-key shape is verified once.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/telemetryCounters.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const counters = require('../telemetryCounters.cjs');
-
-function fakeClient() {
-  const calls = [];
-  return { calls, deps: { telemetryClient: { track: (name, props) => { calls.push({ name, props }); } } } };
-}
-
-test('trackAppLaunch fires app.launch once with installChannel + appVersion', () => {
-  const { calls, deps } = fakeClient();
-  counters.trackAppLaunch({ installChannel: 'npx', appVersion: '0.83.0' }, deps);
-  expect(calls).toHaveLength(1);
-  expect(calls[0].name).toBe('app.launch');
-  expect(Object.keys(calls[0].props).sort()).toEqual(['appVersion', 'installChannel'].sort());
-});
-
-test('trackSessionOpen fires session.open once', () => {
-  const { calls, deps } = fakeClient();
-  counters.trackSessionOpen(deps);
-  expect(calls).toHaveLength(1);
-  expect(calls[0].name).toBe('session.open');
-});
-
-test('trackEpicCreate fires epic.create once', () => {
-  const { calls, deps } = fakeClient();
-  counters.trackEpicCreate(deps);
-  expect(calls).toHaveLength(1);
-  expect(calls[0].name).toBe('epic.create');
-});
-
-test('trackSchedulerJobFinish fires scheduler.job.finish once with a status-only prop', () => {
-  const { calls, deps } = fakeClient();
-  counters.trackSchedulerJobFinish({ status: 'completed' }, deps);
-  expect(calls).toHaveLength(1);
-  expect(calls[0].name).toBe('scheduler.job.finish');
-  expect(Object.keys(calls[0].props)).toEqual(['status']);
-  expect(calls[0].props.status).toBe('completed');
-});
-
-test('a throwing telemetryClient.track never escapes any counter function', () => {
-  const deps = { telemetryClient: { track: () => { throw new Error('boom'); } } };
-  expect(() => counters.trackAppLaunch({ installChannel: 'dev', appVersion: '1.0.0' }, deps)).not.toThrow();
-  expect(() => counters.trackSessionOpen(deps)).not.toThrow();
-  expect(() => counters.trackEpicCreate(deps)).not.toThrow();
-  expect(() => counters.trackSchedulerJobFinish({ status: 'failed' }, deps)).not.toThrow();
-});

package/src/main/lib/__tests__/telemetryCountersMetadataColumn.test.cjs

@@ -1,98 +0,0 @@
-/**
- * telemetryCountersMetadataColumn.test.cjs — the event channel has no version
- * column (telemetryClient.test.cjs's "funnel_events has no version column"
- * test covers the generic case); this asserts the same survives specifically
- * for each of the four counter events this PRD adds, once serialized the way
- * the /api/telemetry/event route persists it into `metadata`.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/telemetryCountersMetadataColumn.test.cjs
- */
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const counters = require('../telemetryCounters.cjs');
-
-const tmpDirs = [];
-let originalHome;
-let originalSmTelemetrySpool;
-
-afterEach(async () => {
-  if (originalHome !== undefined) process.env.HOME = originalHome;
-  if (originalSmTelemetrySpool === undefined) delete process.env.SM_TELEMETRY_SPOOL; else process.env.SM_TELEMETRY_SPOOL = originalSmTelemetrySpool;
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkHome() {
-  originalHome = process.env.HOME;
-  originalSmTelemetrySpool = process.env.SM_TELEMETRY_SPOOL;
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-telemetry-counters-home-'));
-  tmpDirs.push(dir);
-  process.env.HOME = dir;
-  // Explicit opt-in: overrides the test-environment no-op guard so this
-  // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(dir, '.claude', 'session-manager');
-  return dir;
-}
-
-function freshClient() {
-  for (const p of ['../telemetryClient.cjs', '../../config.cjs', '../telemetrySettings.cjs', '../machineProfile.cjs']) {
-    const resolved = require.resolve(p);
-    delete require.cache[resolved];
-  }
-  const client = require('../telemetryClient.cjs');
-  client._setMachineProfileBuilder(async () => ({
-    appVersion: '0.83.0', platform: 'linux', arch: 'x64', machineDigest: 'deadbeefcafe',
-  }));
-  return client;
-}
-
-async function readQueueLines(client) {
-  const fs = require('node:fs/promises');
-  try {
-    const raw = await fs.readFile(client.queuePath(), 'utf8');
-    return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  } catch (e) {
-    if (e.code === 'ENOENT') return [];
-    throw e;
-  }
-}
-
-function asPersistedMetadata(rec) {
-  // Mirrors exactly what the deployed /api/telemetry/event INSERT persists
-  // into the `metadata` column (see telemetryClient.test.cjs).
-  return JSON.parse(JSON.stringify(rec.wire.props));
-}
-
-test('every counter event still yields appVersion + machineDigest once persisted into metadata', async () => {
-  await mkHome();
-  const client = freshClient();
-  const deps = { telemetryClient: client };
-
-  counters.trackAppLaunch({ installChannel: 'npx', appVersion: '0.83.0' }, deps);
-  counters.trackSessionOpen(deps);
-  counters.trackEpicCreate(deps);
-  counters.trackSchedulerJobFinish({ status: 'completed' }, deps);
-
-  // track() ingress does real fs I/O and the counter functions fire it without
-  // awaiting the promise, so poll (bounded) for all 4 records rather than a fixed
-  // sleep — a fixed 50ms lost the race under CPU contention.
-  let recs = [];
-  for (let i = 0; i < 200 && recs.length < 4; i++) {
-    await new Promise((r) => setTimeout(r, 25));
-    recs = await readQueueLines(client);
-  }
-  expect(recs.length).toBe(4);
-  for (const rec of recs) {
-    const meta = asPersistedMetadata(rec);
-    expect(meta.appVersion).toBe('0.83.0');
-    expect(meta.machineDigest).toBe('deadbeefcafe');
-  }
-  client.shutdown();
-});

package/src/main/lib/__tests__/terminalRunOutcome.test.cjs

@@ -1,200 +0,0 @@
-/**
- * terminalRunOutcome.test.cjs — unit tests for the history-independent
- * terminal-run-outcome probe (PRD 812-689-fix-fix-distribute-adminserver-routes).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/terminalRunOutcome.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  latestTerminalOutcomeForSlug,
-  MAX_DIRS_SCANNED,
-} = require('../terminalRunOutcome.cjs');
-
-function mkTmpRunsDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'terminal-run-outcome-'));
-}
-
-function writeRun(runsDir, runId, slug, meta, verdicts) {
-  const dir = path.join(runsDir, runId);
-  fs.mkdirSync(dir, { recursive: true });
-  if (meta !== undefined) {
-    fs.writeFileSync(path.join(dir, `${slug}.meta.json`), typeof meta === 'string' ? meta : JSON.stringify(meta));
-  }
-  if (verdicts !== undefined) {
-    fs.writeFileSync(path.join(dir, `${slug}.verdicts.json`), typeof verdicts === 'string' ? verdicts : JSON.stringify(verdicts));
-  }
-}
-
-test('returns completed for newest run with exitCode 0 + clean verdict', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574748 }, { verdict: 'clean' });
-  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
-  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574748).toISOString() });
-});
-
-test('returns completed for pass_no_commit_already_shipped verdict', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574749 }, { verdict: 'pass_no_commit_already_shipped' });
-  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
-  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574749).toISOString() });
-});
-
-test('returns failed for non-zero exitCode', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 1, finishedAt: 1785483574750 });
-  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
-  expect(result).toEqual({ status: 'failed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574750).toISOString() });
-});
-
-test('returns failed for exitCode 0 with a non-completed-equivalent verdict', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574751 }, { verdict: 'transcript_errors' });
-  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
-  expect(result).toEqual({ status: 'failed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574751).toISOString() });
-});
-
-test('returns null when there is no run dir for the slug', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'other-slug', { exitCode: 0 }, { verdict: 'clean' });
-  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
-});
-
-test('returns null on malformed meta.json', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', '{not json', { verdict: 'clean' });
-  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
-});
-
-test('returns null on malformed verdicts.json', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0 }, '{not json');
-  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
-});
-
-test('returns null when runsDir does not exist', () => {
-  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir: '/nonexistent/path/xyz' })).toBeNull();
-});
-
-test('picks the newest of several run dirs for the same slug', () => {
-  const runsDir = mkTmpRunsDir();
-  writeRun(runsDir, '2026-07-01T00-00-00-000Z', 'my-slug', { exitCode: 1, finishedAt: 10 });
-  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574752 }, { verdict: 'clean' });
-  writeRun(runsDir, '2026-06-01T00-00-00-000Z', 'my-slug', { exitCode: 1, finishedAt: 5 });
-  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
-  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574752).toISOString() });
-});
-
-test('stats at most the newest few run dirs (bound enforced)', () => {
-  const runsDir = mkTmpRunsDir();
-  // Create many more matching run dirs than MAX_DIRS_SCANNED, all with a
-  // non-terminal-equivalent verdict so the loop never early-returns before
-  // exhausting the candidate slice — proves the bound is actually applied.
-  const total = MAX_DIRS_SCANNED + 10;
-  for (let i = 0; i < total; i++) {
-    const ts = `2026-07-${String(i + 1).padStart(2, '0')}T00-00-00-000Z`;
-    writeRun(runsDir, ts, 'my-slug', { exitCode: 0, finishedAt: i }, { verdict: 'transcript_errors' });
-  }
-
-  let readFileCalls = 0;
-  const fsImpl = {
-    readdirSync: (...a) => fs.readdirSync(...a),
-    existsSync: (...a) => fs.existsSync(...a),
-    readFileSync: (...a) => {
-      readFileCalls++;
-      return fs.readFileSync(...a);
-    },
-  };
-
-  latestTerminalOutcomeForSlug('my-slug', { runsDir, fsImpl });
-  // Each scanned dir reads meta.json, then (since exitCode===0) verdicts.json
-  // too, so at most MAX_DIRS_SCANNED * 2 readFileSync calls.
-  expect(readFileCalls).toBeLessThanOrEqual(MAX_DIRS_SCANNED * 2);
-});
-
-// ─── sidecar-resilience (2026-08-13) ────────────────────────────────────────
-//
-// Every branch used to `return` on the FIRST candidate dir, so an unreadable
-// or half-written sidecar in the newest run erased an older, complete terminal
-// record — the anti-resurrection guard switching itself off on exactly the
-// input it exists to survive, which lets reconcile re-derive a fresh queue row
-// and re-run an already-completed PRD. It also made MAX_DIRS_SCANNED a no-op.
-
-function memFs(files) {
-  return {
-    readdirSync: (d) => Object.keys(files[d] ?? {}),
-    existsSync: (p) => {
-      const dir = path.dirname(p);
-      const base = path.basename(p);
-      return Boolean(files[path.dirname(dir)]?.[path.basename(dir)]?.[base]);
-    },
-    readFileSync: (p) => {
-      const dir = path.dirname(p);
-      const base = path.basename(p);
-      const content = files[path.dirname(dir)]?.[path.basename(dir)]?.[base];
-      if (content === undefined) throw new Error(`ENOENT: ${p}`);
-      return content;
-    },
-  };
-}
-
-const RUNS = '/runs';
-const SLUG = '900-thing';
-
-function tree(dirs) {
-  return { [RUNS]: dirs };
-}
-
-test('an unreadable meta sidecar in the newest dir falls through to an older complete run', () => {
-  const fsImpl = memFs(tree({
-    '2026-08-14T02-00-00-000Z': { [`${SLUG}.meta.json`]: '{ not json' },
-    '2026-08-14T01-00-00-000Z': {
-      [`${SLUG}.meta.json`]: JSON.stringify({ exitCode: 0, finishedAt: 1786669013583 }),
-      [`${SLUG}.verdicts.json`]: JSON.stringify({ verdict: 'clean' }),
-    },
-  }));
-  const out = latestTerminalOutcomeForSlug(SLUG, { runsDir: RUNS, fsImpl });
-  expect(out).toBeTruthy();
-  expect(out.status).toBe('completed');
-  expect(out.runId).toBe('2026-08-14T01-00-00-000Z');
-});
-
-test('a newest run missing its verdicts sidecar falls through instead of erasing the older record', () => {
-  const fsImpl = memFs(tree({
-    '2026-08-14T02-00-00-000Z': { [`${SLUG}.meta.json`]: JSON.stringify({ exitCode: 0, finishedAt: 1 }) },
-    '2026-08-14T01-00-00-000Z': {
-      [`${SLUG}.meta.json`]: JSON.stringify({ exitCode: 0, finishedAt: 1786669013583 }),
-      [`${SLUG}.verdicts.json`]: JSON.stringify({ verdict: 'pass_no_commit_prior_run_verified' }),
-    },
-  }));
-  const out = latestTerminalOutcomeForSlug(SLUG, { runsDir: RUNS, fsImpl });
-  expect(out).toBeTruthy();
-  expect(out.status).toBe('completed');
-  expect(out.runId).toBe('2026-08-14T01-00-00-000Z');
-});
-
-test('a non-zero exit in the newest dir is still authoritative — fall-through only covers UNREADABLE sidecars', () => {
-  const fsImpl = memFs(tree({
-    '2026-08-14T02-00-00-000Z': { [`${SLUG}.meta.json`]: JSON.stringify({ exitCode: 1, finishedAt: 2 }) },
-    '2026-08-14T01-00-00-000Z': {
-      [`${SLUG}.meta.json`]: JSON.stringify({ exitCode: 0, finishedAt: 1 }),
-      [`${SLUG}.verdicts.json`]: JSON.stringify({ verdict: 'clean' }),
-    },
-  }));
-  const out = latestTerminalOutcomeForSlug(SLUG, { runsDir: RUNS, fsImpl });
-  expect(out.status).toBe('failed');
-  expect(out.runId).toBe('2026-08-14T02-00-00-000Z');
-});
-
-test('every candidate being unreadable still yields null (no invented outcome)', () => {
-  const fsImpl = memFs(tree({
-    '2026-08-14T02-00-00-000Z': { [`${SLUG}.meta.json`]: '{ nope' },
-    '2026-08-14T01-00-00-000Z': { [`${SLUG}.meta.json`]: '{ also nope' },
-  }));
-  expect(latestTerminalOutcomeForSlug(SLUG, { runsDir: RUNS, fsImpl })).toBeNull();
-});

package/src/main/lib/__tests__/toolUseClassify.test.cjs

@@ -1,53 +0,0 @@
-/**
- * toolUseClassify.test.cjs — unit tests for src/main/lib/toolUseClassify.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/toolUseClassify.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const { classifyToolUse, MAX_DIFF_STR } = require('../toolUseClassify.cjs');
-
-test('Edit tool_use produces a diff payload with filePath/oldText/newText', () => {
-  const block = {
-    name: 'Edit',
-    input: { file_path: '/tmp/foo.js', old_string: 'a', new_string: 'b' },
-  };
-  const result = classifyToolUse(block);
-  expect(result.kind).toBe('tool');
-  expect(result.diff).toEqual({ filePath: '/tmp/foo.js', oldText: 'a', newText: 'b' });
-});
-
-test('Write tool_use produces a diff payload with filePath/newText only', () => {
-  const block = { name: 'Write', input: { file_path: '/tmp/bar.js', content: 'hello' } };
-  const result = classifyToolUse(block);
-  expect(result.diff).toEqual({ filePath: '/tmp/bar.js', newText: 'hello' });
-});
-
-test('non-Edit/Write tool_use has no diff field', () => {
-  const block = { name: 'Bash', input: { command: 'ls' } };
-  const result = classifyToolUse(block);
-  expect(result.diff).toBeUndefined();
-  expect('diff' in result).toBe(false);
-});
-
-test('Skill/mcp tool_use never get a diff field', () => {
-  expect(classifyToolUse({ name: 'Skill', input: { skill: 'x' } }).diff).toBeUndefined();
-  expect(classifyToolUse({ name: 'mcp__foo__bar', input: {} }).diff).toBeUndefined();
-});
-
-test('oversized Edit strings are capped at MAX_DIFF_STR', () => {
-  const big = 'x'.repeat(MAX_DIFF_STR + 100);
-  const block = { name: 'Edit', input: { file_path: '/tmp/foo.js', old_string: big, new_string: big } };
-  const result = classifyToolUse(block);
-  expect(result.diff.oldText.length).toBe(MAX_DIFF_STR + 1); // + ellipsis char
-  expect(result.diff.oldText.endsWith('…')).toBe(true);
-});
-
-test('Edit block missing file_path yields no diff', () => {
-  const block = { name: 'Edit', input: { old_string: 'a', new_string: 'b' } };
-  const result = classifyToolUse(block);
-  expect(result.diff).toBeUndefined();
-});