claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,152 +0,0 @@
-/**
- * machineProfile.test.cjs — unit tests for buildMachineProfile().
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/machineProfile.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const os = require('node:os');
-const { buildMachineProfile, computeMachineDigest, resolveInstallChannel, resolveEnv } = require('../lib/machineProfile.cjs');
-
-function fakeOs(overrides = {}) {
-  return {
-    platform: () => overrides.platform ?? 'linux',
-    release: () => overrides.release ?? '6.1.0',
-    arch: () => overrides.arch ?? 'x64',
-    cpus: () => overrides.cpus ?? [{ model: '  Fancy CPU  ', speed: 3200 }],
-    totalmem: () => overrides.totalmem ?? 16 * 1024 * 1024 * 1024,
-  };
-}
-
-const stubProbeNull = async () => null;
-
-test('buildMachineProfile returns only the specified fields', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  const expectedKeys = [
-    'appVersion', 'installChannel', 'machineDigest', 'platform', 'osRelease', 'arch',
-    'cpuModel', 'cpuCount', 'cpuSpeedMhz', 'totalMemMb', 'nodeVersion', 'electronVersion',
-    'chromeVersion', 'v8Version', 'claudeCliVersion', 'locale', 'timezoneOffsetMinutes', 'firstSeenAt',
-  ].sort();
-  expect(Object.keys(profile).sort()).toEqual(expectedKeys);
-});
-
-test('specs come from the injected os module; cpuModel is trimmed', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(profile.platform).toBe('linux');
-  expect(profile.osRelease).toBe('6.1.0');
-  expect(profile.arch).toBe('x64');
-  expect(profile.cpuModel).toBe('Fancy CPU');
-  expect(profile.cpuSpeedMhz).toBe(3200);
-  expect(profile.cpuCount).toBe(1);
-  expect(profile.totalMemMb).toBe(16384);
-});
-
-test('cpuModel/cpuSpeedMhz are null-safe when os.cpus() is empty (containers)', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs({ cpus: [] }), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(profile.cpuModel).toBeNull();
-  expect(profile.cpuSpeedMhz).toBeNull();
-  expect(profile.cpuCount).toBe(0);
-});
-
-test('machineDigest: identical specs produce an identical digest', async () => {
-  const p1 = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  const p2 = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(p1.machineDigest).toBe(p2.machineDigest);
-  expect(p1.machineDigest).toMatch(/^[0-9a-f]{12}$/);
-});
-
-test('machineDigest: a changed cpuCount produces a different digest', async () => {
-  const base = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  const changed = await buildMachineProfile({
-    osModule: fakeOs({ cpus: [{ model: 'Fancy CPU', speed: 3200 }, { model: 'Fancy CPU', speed: 3200 }] }),
-    probeClaudeVersion: stubProbeNull,
-    electronApp: null,
-  });
-  expect(changed.machineDigest).not.toBe(base.machineDigest);
-});
-
-test('computeMachineDigest is derived from specs only, never installId/hostname/etc', () => {
-  const specs = { platform: 'linux', osRelease: '6.1.0', arch: 'x64', cpuModel: 'Fancy CPU', cpuCount: 1, totalMemMb: 16384 };
-  const digest = computeMachineDigest(specs);
-  expect(digest).toMatch(/^[0-9a-f]{12}$/);
-});
-
-test('timezoneOffsetMinutes is a number, and no field matches an IANA zone pattern', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(typeof profile.timezoneOffsetMinutes).toBe('number');
-  for (const value of Object.values(profile)) {
-    if (typeof value === 'string') {
-      expect(value).not.toMatch(/^[A-Z][a-zA-Z_]+\/[A-Z][a-zA-Z_]+$/);
-    }
-  }
-});
-
-test('no PII: no field contains hostname, homedir, or OS username', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  const hostname = os.hostname();
-  const homedir = os.homedir();
-  const username = os.userInfo().username;
-  for (const value of Object.values(profile)) {
-    if (typeof value === 'string' && value.length > 0) {
-      expect(value).not.toContain(hostname);
-      expect(value).not.toContain(homedir);
-      expect(value).not.toContain(username);
-    }
-  }
-});
-
-test('loads and returns a profile under plain vitest with no Electron runtime (electronApp resolves null, falls back to package.json)', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(typeof profile.appVersion).toBe('string');
-  expect(profile.appVersion.length).toBeGreaterThan(0);
-});
-
-test('appVersion resolves from electronApp.getVersion() when available', async () => {
-  const fakeApp = { getVersion: () => '9.9.9-electron', getAppPath: () => '/opt/app' };
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: fakeApp });
-  expect(profile.appVersion).toBe('9.9.9-electron');
-});
-
-test('appVersion falls back to package.json version when electron is unavailable', async () => {
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  const pkg = require('../../../package.json');
-  expect(profile.appVersion).toBe(pkg.version);
-});
-
-test('claudeCliVersion is null and buildMachineProfile still returns promptly when the CLI is unavailable', async () => {
-  const start = Date.now();
-  const profile = await buildMachineProfile({ osModule: fakeOs(), probeClaudeVersion: stubProbeNull, electronApp: null });
-  expect(profile.claudeCliVersion).toBeNull();
-  expect(Date.now() - start).toBeLessThan(2000);
-});
-
-test('resolveInstallChannel: npx when app path is inside an npm/npx cache dir', () => {
-  expect(resolveInstallChannel({ appPath: '/home/u/.npm/_npx/abc123/node_modules/foo', devFlag: false })).toBe('npx');
-});
-
-test('resolveInstallChannel: dev when SM_DEV flag is set, regardless of app path', () => {
-  expect(resolveInstallChannel({ appPath: '/opt/some/app', devFlag: true })).toBe('dev');
-});
-
-test('resolveInstallChannel: unknown otherwise', () => {
-  expect(resolveInstallChannel({ appPath: '/opt/some/app', devFlag: false })).toBe('unknown');
-});
-
-// ─── resolveEnv (wire-level env discriminator) ──────────────────────────
-
-test('resolveEnv: test when running under a test runner, regardless of installChannel', () => {
-  expect(resolveEnv({ isTestRunner: true, installChannel: 'dev' })).toBe('test');
-  expect(resolveEnv({ isTestRunner: true, installChannel: 'npx' })).toBe('test');
-  expect(resolveEnv({ isTestRunner: true, installChannel: 'unknown' })).toBe('test');
-});
-
-test('resolveEnv: dev when installChannel is dev and not under a test runner', () => {
-  expect(resolveEnv({ isTestRunner: false, installChannel: 'dev' })).toBe('dev');
-});
-
-test('resolveEnv: prod for every other installChannel (npx, unknown) when not under a test runner', () => {
-  expect(resolveEnv({ isTestRunner: false, installChannel: 'npx' })).toBe('prod');
-  expect(resolveEnv({ isTestRunner: false, installChannel: 'unknown' })).toBe('prod');
-  expect(resolveEnv({ isTestRunner: false, installChannel: undefined })).toBe('prod');
-});

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

@@ -1,61 +0,0 @@
-/**
- * mcpStatus.test.cjs — unit tests for the `claude mcp list` output parser.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/mcpStatus.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { parseMcpList } = require('../mcpStatus.cjs');
-
-const SAMPLE = `Checking MCP server health…
-
-claude.ai Gmail: https://gmailmcp.googleapis.com/mcp/v1 - ✔ Connected
-fetch: uvx mcp-server-fetch - ✔ Connected
-n8n: bash /home/bilko/.config/n8n-mcp/run.sh - ✘ Failed to connect
-session-manager-scheduler: node scripts/scheduler-mcp-server.cjs - ⏸ Pending approval (run \`claude\` to approve)
-claude_design: https://api.anthropic.com/v1/design/mcp (HTTP) - ✔ Connected
-claude.ai Google Drive: https://drivemcp.googleapis.com/mcp/v1 - ! Needs authentication
-`;
-
-test('parses the captured claude mcp list sample', () => {
-  const servers = parseMcpList(SAMPLE);
-  assert.ok(servers.length >= 6, `expected >=6 servers, got ${servers.length}`);
-
-  const byName = Object.fromEntries(servers.map((s) => [s.name, s]));
-
-  assert.equal(byName['claude.ai Gmail'].status, 'connected');
-  assert.equal(byName['fetch'].status, 'connected');
-  assert.equal(byName['n8n'].status, 'failed');
-  assert.equal(byName['session-manager-scheduler'].status, 'pending');
-  assert.equal(byName['claude_design'].status, 'connected');
-  assert.equal(byName['claude_design'].transport, 'http');
-  assert.equal(byName['claude.ai Google Drive'].status, 'needs-auth');
-});
-
-test('ignores the header and blank lines', () => {
-  const servers = parseMcpList(SAMPLE);
-  assert.ok(!servers.some((s) => /Checking MCP server health/i.test(s.name)));
-});
-
-test('defaults transport to stdio for non-HTTP targets', () => {
-  const servers = parseMcpList(SAMPLE);
-  const byName = Object.fromEntries(servers.map((s) => [s.name, s]));
-  assert.equal(byName['n8n'].transport, 'stdio');
-  assert.equal(byName['fetch'].transport, 'stdio');
-});
-
-test('returns [] (not a throw) on empty input', () => {
-  assert.deepEqual(parseMcpList(''), []);
-});
-
-test('returns [] (not a throw) on garbage input', () => {
-  assert.deepEqual(parseMcpList('this is not\na valid mcp list output\n12345'), []);
-});
-
-test('returns [] on non-string input without throwing', () => {
-  assert.deepEqual(parseMcpList(null), []);
-  assert.deepEqual(parseMcpList(undefined), []);
-});

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

@@ -1,109 +0,0 @@
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { parseClusters, aggregate, clustersCachePath } = require('../memoryAggregate.cjs');
-const { opsPath } = require('../lib/opsOwnership.cjs');
-
-test('parseClusters maps well-formed JSON to the result shape and routes unlisted slugs to orphans', () => {
-  const slugs = ['scheduler_concurrency_memory', 'no_schedule_self_e2e', 'unrelated_note'];
-  const raw = JSON.stringify({
-    clusters: [
-      {
-        name: 'Scheduler ops',
-        summary: 'Scheduler concurrency + e2e isolation rules.',
-        memberSlugs: ['scheduler_concurrency_memory', 'no_schedule_self_e2e'],
-        links: [{ from: 'scheduler_concurrency_memory', to: 'no_schedule_self_e2e', label: 'related' }],
-      },
-    ],
-    orphans: ['unrelated_note'],
-  });
-
-  const result = parseClusters(raw, slugs);
-
-  assert.equal(result.clusters.length, 1);
-  assert.equal(result.clusters[0].name, 'Scheduler ops');
-  assert.deepEqual(result.clusters[0].memberSlugs, ['scheduler_concurrency_memory', 'no_schedule_self_e2e']);
-  assert.deepEqual(result.clusters[0].links, [{ from: 'scheduler_concurrency_memory', to: 'no_schedule_self_e2e', label: 'related' }]);
-  assert.deepEqual(result.orphans, ['unrelated_note']);
-});
-
-test('parseClusters routes a slug omitted from the response to orphans even without explicit listing', () => {
-  const slugs = ['a', 'b', 'c'];
-  const raw = JSON.stringify({
-    clusters: [{ name: 'Cluster A', summary: 's', memberSlugs: ['a'], links: [] }],
-  });
-
-  const result = parseClusters(raw, slugs);
-
-  assert.deepEqual(result.orphans.sort(), ['b', 'c']);
-});
-
-test('parseClusters returns empty clusters and all slugs as orphans on garbage LLM output', () => {
-  const slugs = ['one', 'two', 'three'];
-  const result = parseClusters('not json at all, just prose garbage', slugs);
-
-  assert.deepEqual(result.clusters, []);
-  assert.deepEqual(result.orphans, slugs);
-});
-
-test('parseClusters is robust to empty/null input', () => {
-  const slugs = ['x'];
-  assert.deepEqual(parseClusters('', slugs), { clusters: [], orphans: ['x'] });
-  assert.deepEqual(parseClusters(null, slugs), { clusters: [], orphans: ['x'] });
-});
-
-test('parseClusters drops link endpoints and members that reference nonexistent slugs', () => {
-  const slugs = ['known'];
-  const raw = JSON.stringify({
-    clusters: [{
-      name: 'C',
-      summary: 's',
-      memberSlugs: ['known', 'ghost'],
-      links: [{ from: 'known', to: 'ghost' }],
-    }],
-  });
-
-  const result = parseClusters(raw, slugs);
-  assert.deepEqual(result.clusters[0].memberSlugs, ['known']);
-  assert.deepEqual(result.clusters[0].links, []);
-  assert.deepEqual(result.orphans, []);
-});
-
-test('clustersCachePath resolves under <cwd>/session-manager-operations/memory-clusters/clusters.json, one file per project', () => {
-  const cwd = '/home/u/Projects/demo';
-  assert.equal(clustersCachePath(cwd), opsPath(cwd, 'memory-clusters', 'clusters.json'));
-  assert.match(clustersCachePath(cwd), /\/session-manager-operations\/memory-clusters\/clusters\.json$/);
-});
-
-test('aggregate persists and reads back the per-project cache file at the new ops-owned location', async () => {
-  const cwd = fs.mkdtempSync(path.join(os.homedir(), '.sm-test-memory-clusters-'));
-  try {
-    const workspace = `test-ws-${Date.now()}`;
-
-    const written = await aggregate({ workspace, refresh: true, cwd });
-    assert.equal(written.cached, false);
-    assert.deepEqual(written.clusters, []);
-    assert.deepEqual(written.orphans, []);
-
-    const expectedPath = opsPath(cwd, 'memory-clusters', 'clusters.json');
-    assert.ok(fs.existsSync(expectedPath), `expected cache file at ${expectedPath}`);
-    assert.deepEqual(JSON.parse(fs.readFileSync(expectedPath, 'utf8')).workspace, workspace);
-
-    const read = await aggregate({ workspace, refresh: false, cwd });
-    assert.equal(read.cached, true);
-    assert.equal(read.workspace, workspace);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('aggregate without a cwd skips the cache instead of throwing', async () => {
-  const workspace = `test-ws-nocwd-${Date.now()}`;
-  const result = await aggregate({ workspace, refresh: false });
-  assert.equal(result.cached, false);
-  assert.deepEqual(result.clusters, []);
-});

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

@@ -1,88 +0,0 @@
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { scoreMemories } = require('../lib/memoryStale.cjs');
-
-const DAY_MS = 86_400_000;
-const NOW = 1_800_000_000_000; // fixed epoch ms for deterministic tests
-
-test('a fresh linked memory is not stale', () => {
-  const entries = [
-    { name: 'a.md', mtimeMs: NOW - 5 * DAY_MS, body: 'links to [[b]]' },
-    { name: 'b.md', mtimeMs: NOW - 5 * DAY_MS, body: 'nothing here' },
-  ];
-  const result = scoreMemories({ entries, now: NOW, existsPath: () => true });
-  const b = result.find((r) => r.name === 'b.md');
-  assert.equal(b.stale, false);
-  assert.equal(b.inboundLinks, 1);
-  assert.deepEqual(b.reasons, []);
-});
-
-test('a 200-day-old memory with zero inbound links is stale', () => {
-  const entries = [
-    { name: 'old.md', mtimeMs: NOW - 200 * DAY_MS, body: 'no links to me' },
-  ];
-  const result = scoreMemories({ entries, now: NOW, existsPath: () => true });
-  const old = result[0];
-  assert.equal(old.ageDays, 200);
-  assert.equal(old.inboundLinks, 0);
-  assert.equal(old.stale, true);
-  assert.ok(old.reasons.some((r) => /90\+ days old/.test(r)));
-});
-
-test('a 200-day-old memory WITH an inbound link is not stale', () => {
-  const entries = [
-    { name: 'old.md', mtimeMs: NOW - 200 * DAY_MS, body: 'old content' },
-    { name: 'linker.md', mtimeMs: NOW - 1 * DAY_MS, body: 'see [[old]] for context' },
-  ];
-  const result = scoreMemories({ entries, now: NOW, existsPath: () => true });
-  const old = result.find((r) => r.name === 'old.md');
-  assert.equal(old.inboundLinks, 1);
-  assert.equal(old.stale, false);
-});
-
-test('a recent memory naming a dead path IS stale', () => {
-  const entries = [
-    { name: 'recent.md', mtimeMs: NOW - 1 * DAY_MS, body: 'see `src/main/gone.cjs` for details' },
-  ];
-  const existsPath = (p) => p !== 'src/main/gone.cjs';
-  const result = scoreMemories({ entries, now: NOW, existsPath });
-  const r = result[0];
-  assert.equal(r.ageDays, 1);
-  assert.deepEqual(r.deadRefs, ['src/main/gone.cjs']);
-  assert.equal(r.stale, true);
-  assert.ok(r.reasons.some((s) => /no longer exist/.test(s)));
-});
-
-test('a :42 line suffix is stripped before the existence check', () => {
-  const entries = [
-    { name: 'recent.md', mtimeMs: NOW - 1 * DAY_MS, body: 'see `src/main/config.cjs:42` for the helper' },
-  ];
-  let checked = null;
-  const existsPath = (p) => { checked = p; return true; };
-  const result = scoreMemories({ entries, now: NOW, existsPath });
-  assert.equal(checked, 'src/main/config.cjs');
-  assert.deepEqual(result[0].deadRefs, []);
-  assert.equal(result[0].stale, false);
-});
-
-test('the candidate cap holds at 20', () => {
-  const paths = Array.from({ length: 30 }, (_, i) => `src/main/file${i}.cjs`);
-  const body = paths.map((p) => `\`${p}\``).join(' ');
-  const entries = [{ name: 'many.md', mtimeMs: NOW - 1 * DAY_MS, body }];
-  let callCount = 0;
-  const existsPath = () => { callCount += 1; return false; };
-  const result = scoreMemories({ entries, now: NOW, existsPath });
-  assert.equal(result[0].deadRefs.length, 20);
-  assert.equal(callCount, 20);
-});
-
-test('[[self]] in a memory own body does not count as an inbound link', () => {
-  const entries = [
-    { name: 'self.md', mtimeMs: NOW - 200 * DAY_MS, body: 'refers to itself: [[self]]' },
-  ];
-  const result = scoreMemories({ entries, now: NOW, existsPath: () => true });
-  assert.equal(result[0].inboundLinks, 0);
-  assert.equal(result[0].stale, true);
-});

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

@@ -1,162 +0,0 @@
-/**
- * needsReviewLedger.test.cjs — unit tests for src/main/lib/needsReviewLedger.cjs's
- * pure ladder-rung classification, line builders, and rollup reduction.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/needsReviewLedger.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  LADDER_RUNGS,
-  classifyLadderRung,
-  buildNeedsReviewEntryLine,
-  buildNeedsReviewResolutionLine,
-  reduceNeedsReviewLedger,
-} = require('../lib/needsReviewLedger.cjs');
-
-// ---------- classifyLadderRung ----------
-
-test('classifyLadderRung maps every known automated source to its named rung', () => {
-  expect(classifyLadderRung({ source: 'scheduler:mechanicalRecovery' })).toBe('mechanical-recovery');
-  expect(classifyLadderRung({ source: 'spawnJob:dispatch', reason: 'dispatched for resume-recovery' })).toBe('resume-recovery');
-  expect(classifyLadderRung({ source: 'spawnInvestigation:start' })).toBe('auto-fix');
-  expect(classifyLadderRung({ source: 'spawnJob:auto-promote' })).toBe('auto-fix');
-  expect(classifyLadderRung({ source: 'reverifyNeedsReview:auto-promote' })).toBe('auto-fix');
-  expect(classifyLadderRung({ source: 'reverifyNeedsReview:heal' })).toBe('reverify');
-  expect(classifyLadderRung({ source: 'needsReviewAutoResolve' })).toBe('reverify');
-});
-
-test('classifyLadderRung: ordinary spawnJob:dispatch (no resume-recovery reason) is NOT resume-recovery', () => {
-  // 'spawnJob:dispatch' is shared with the everyday pending->running dispatch
-  // — only the resume-recovery REASON text distinguishes the two.
-  expect(classifyLadderRung({ source: 'spawnJob:dispatch', reason: 'dispatched for execution' })).toBe('manual-reset');
-});
-
-test('classifyLadderRung: unrecognized/explicit-reset sources default to manual-reset', () => {
-  expect(classifyLadderRung({ source: 'ipc:schedule:reset-job' })).toBe('manual-reset');
-  expect(classifyLadderRung({ source: 'remote:resetJob' })).toBe('manual-reset');
-  expect(classifyLadderRung({ source: 'clear-queue' })).toBe('manual-reset');
-  expect(classifyLadderRung({})).toBe('manual-reset');
-});
-
-test('LADDER_RUNGS names exactly the 6 documented rungs', () => {
-  expect(LADDER_RUNGS).toEqual(['mechanical-recovery', 'resume-recovery', 'quarantine', 'auto-fix', 'reverify', 'manual-reset']);
-});
-
-// ---------- buildNeedsReviewEntryLine / buildNeedsReviewResolutionLine ----------
-
-test('buildNeedsReviewEntryLine: park reason prefers verifierVerdict, then heldReason, then error', () => {
-  const entry = { to: 'needs_review', source: 'spawnJob:finalize', at: '2026-09-13T00:00:00.000Z' };
-  expect(buildNeedsReviewEntryLine({ slug: 's1', verifierVerdict: 'uncommitted_changes', heldReason: 'held', error: 'err' }, entry).reason).toBe('uncommitted_changes');
-  expect(buildNeedsReviewEntryLine({ slug: 's1', heldReason: 'held', error: 'err' }, entry).reason).toBe('held');
-  expect(buildNeedsReviewEntryLine({ slug: 's1', error: 'err' }, entry).reason).toBe('err');
-  expect(buildNeedsReviewEntryLine({ slug: 's1' }, entry).reason).toBeNull();
-});
-
-test('buildNeedsReviewEntryLine: carries slug/cwd/epicId/runId/at/source verbatim', () => {
-  const job = { slug: '42-x', cwd: '/proj', epicId: 'epic-1', runId: 'run-9' };
-  const entry = { to: 'needs_review', source: 'spawnJob:finalize', at: '2026-09-13T00:00:00.000Z' };
-  const line = buildNeedsReviewEntryLine(job, entry);
-  expect(line).toEqual({
-    kind: 'needs_review_entry',
-    slug: '42-x',
-    cwd: '/proj',
-    epicId: 'epic-1',
-    runId: 'run-9',
-    at: '2026-09-13T00:00:00.000Z',
-    reason: null,
-    source: 'spawnJob:finalize',
-  });
-});
-
-test('buildNeedsReviewResolutionLine: references the EPISODE runId, not job.runId, and computes dwellMs', () => {
-  const job = { slug: '42-x', cwd: '/proj', epicId: 'epic-1', runId: 'run-LATER' };
-  const entry = { to: 'completed', source: 'reverifyNeedsReview:heal', at: '2026-09-13T00:10:00.000Z' };
-  const episode = { runId: 'run-ORIGINAL', enteredAt: '2026-09-13T00:00:00.000Z' };
-  const line = buildNeedsReviewResolutionLine(job, entry, episode);
-  expect(line.runId).toBe('run-ORIGINAL');
-  expect(line.resolvedTo).toBe('completed');
-  expect(line.ladderRung).toBe('reverify');
-  expect(line.dwellMs).toBe(10 * 60_000);
-});
-
-test('buildNeedsReviewResolutionLine: dwellMs is null when the episode has no enteredAt (defensive — should not happen in practice)', () => {
-  const job = { slug: '42-x', runId: 'run-1' };
-  const entry = { to: 'failed', source: 'ipc:schedule:reset-job', at: '2026-09-13T00:00:00.000Z' };
-  const line = buildNeedsReviewResolutionLine(job, entry, { runId: 'run-1', enteredAt: null });
-  expect(line.dwellMs).toBeNull();
-});
-
-// ---------- reduceNeedsReviewLedger ----------
-
-function entryLine({ slug, runId, at, reason = 'uncommitted_changes', source = 'spawnJob:finalize' }) {
-  return { kind: 'needs_review_entry', slug, cwd: null, epicId: null, runId, at, reason, source };
-}
-function resolutionLine({ slug, runId, at, resolvedTo = 'completed', ladderRung = 'reverify', source = 'reverifyNeedsReview:heal', dwellMs = 1000 }) {
-  return { kind: 'needs_review_resolution', slug, cwd: null, epicId: null, runId, at, resolvedTo, ladderRung, source, dwellMs };
-}
-
-test('reduceNeedsReviewLedger: entry-only (unresolved) episode counts toward byReason and unresolvedCount, not byLadderRung', () => {
-  const lines = [entryLine({ slug: 'a', runId: 'r1', at: '2026-09-13T00:00:00.000Z', reason: 'silent_no_op' })];
-  const rollup = reduceNeedsReviewLedger(lines);
-  expect(rollup.byReason).toEqual({ silent_no_op: 1 });
-  expect(rollup.byLadderRung).toEqual({});
-  expect(rollup.unresolvedCount).toBe(1);
-  expect(rollup.dwellMsP50).toBeNull();
-  expect(rollup.dwellMsP90).toBeNull();
-});
-
-test('reduceNeedsReviewLedger: entry+resolution pair resolves and contributes dwell', () => {
-  const lines = [
-    entryLine({ slug: 'a', runId: 'r1', at: '2026-09-13T00:00:00.000Z' }),
-    resolutionLine({ slug: 'a', runId: 'r1', at: '2026-09-13T00:00:05.000Z', dwellMs: 5000, ladderRung: 'mechanical-recovery' }),
-  ];
-  const rollup = reduceNeedsReviewLedger(lines);
-  expect(rollup.unresolvedCount).toBe(0);
-  expect(rollup.byLadderRung).toEqual({ 'mechanical-recovery': 1 });
-  expect(rollup.dwellMsP50).toBe(5000);
-  expect(rollup.dwellMsP90).toBe(5000);
-});
-
-test('reduceNeedsReviewLedger: repeated entries for the same slug (different runIds) count as independent episodes', () => {
-  const lines = [
-    entryLine({ slug: 'a', runId: 'r1', at: '2026-09-13T00:00:00.000Z', reason: 'uncommitted_changes' }),
-    resolutionLine({ slug: 'a', runId: 'r1', at: '2026-09-13T00:00:10.000Z', dwellMs: 10_000, ladderRung: 'manual-reset' }),
-    entryLine({ slug: 'a', runId: 'r2', at: '2026-09-13T01:00:00.000Z', reason: 'uncommitted_changes' }),
-    // r2 never resolves.
-  ];
-  const rollup = reduceNeedsReviewLedger(lines);
-  expect(rollup.byReason).toEqual({ uncommitted_changes: 2 });
-  expect(rollup.unresolvedCount).toBe(1);
-  expect(rollup.byLadderRung).toEqual({ 'manual-reset': 1 });
-  expect(rollup.dwellMsP50).toBe(10_000);
-});
-
-test('reduceNeedsReviewLedger: p50/p90 over several resolved episodes', () => {
-  const dwells = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10_000];
-  const lines = dwells.flatMap((d, i) => [
-    entryLine({ slug: `s${i}`, runId: `r${i}`, at: '2026-09-13T00:00:00.000Z' }),
-    resolutionLine({ slug: `s${i}`, runId: `r${i}`, at: '2026-09-13T00:00:00.000Z', dwellMs: d }),
-  ]);
-  const rollup = reduceNeedsReviewLedger(lines);
-  expect(rollup.dwellMsP50).toBe(5000);
-  expect(rollup.dwellMsP90).toBe(9000);
-});
-
-test('reduceNeedsReviewLedger: ignores unrelated (terminal) rows mixed into the same lines array', () => {
-  const lines = [
-    { kind: 'terminal', slug: 'a', status: 'completed', runId: 'r1' },
-    { slug: 'b', status: 'failed', runId: 'r2' }, // legacy row, no kind at all
-    entryLine({ slug: 'c', runId: 'r3', at: '2026-09-13T00:00:00.000Z' }),
-  ];
-  const rollup = reduceNeedsReviewLedger(lines);
-  expect(rollup.unresolvedCount).toBe(1);
-  expect(Object.keys(rollup.byReason)).toEqual(['uncommitted_changes']);
-});
-
-test('reduceNeedsReviewLedger: empty/non-array input returns a zeroed rollup, never throws', () => {
-  expect(reduceNeedsReviewLedger([])).toEqual({ byReason: {}, byLadderRung: {}, unresolvedCount: 0, dwellMsP50: null, dwellMsP90: null });
-  expect(reduceNeedsReviewLedger(null)).toEqual({ byReason: {}, byLadderRung: {}, unresolvedCount: 0, dwellMsP50: null, dwellMsP90: null });
-  expect(reduceNeedsReviewLedger(undefined)).toEqual({ byReason: {}, byLadderRung: {}, unresolvedCount: 0, dwellMsP50: null, dwellMsP90: null });
-});

package/src/main/__tests__/openExternalApp-spawn-error.test.cjs

@@ -1,25 +0,0 @@
-import { test, expect, vi } from 'vitest';
-const Module = require('node:module');
-const origLoad = Module._load;
-Module._load = function (req, ...rest) {
-  if (req === 'electron') return { shell: { openPath: async () => '' } };
-  return origLoad.call(this, req, ...rest);
-};
-const { spawnDetached } = require('../lib/openExternalApp.cjs');
-Module._load = origLoad;
-
-test('non-existent command resolves ok:false with no uncaught exception', async () => {
-  const onUncaught = vi.fn();
-  process.on('uncaughtException', onUncaught);
-  const r = await spawnDetached('sm-definitely-not-a-real-binary-xyz', ['/tmp']);
-  await new Promise((res) => setTimeout(res, 20));
-  process.off('uncaughtException', onUncaught);
-  expect(r.ok).toBe(false);
-  expect(r.error).toMatch(/failed to launch/);
-  expect(onUncaught).not.toHaveBeenCalled();
-});
-
-test('real command resolves ok:true with opener name', async () => {
-  const r = await spawnDetached('true', []);
-  expect(r).toEqual({ ok: true, opener: 'true' });
-});