claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/health-starve-escalation.test.cjs

@@ -1,94 +0,0 @@
-/**
- * health-starve-escalation.test.cjs — `npm run health` must report
- * non-GREEN when any project has been starved (findStarvedProjects) past
- * the LATER escalation threshold (STARVE_ESCALATION_MS), naming the project
- * and the hold reason scheduler.cjs's runStarveEscalationSweep already
- * recorded on the matching 'project_starve_escalated' audit event — health
- * runs as its own cold process with no access to the live scheduler's
- * in-memory `lastTick`, so the durable audit-log.jsonl trail is the only
- * place that reason survives to be read from here.
- *
- * Exercises evaluateStarveEscalationHealth() and
- * latestStarveEscalationReasons() directly — pure/fs-scoped, matching every
- * other evaluate* helper's test pattern in this file (see
- * health-queue-dispatch.test.cjs's header). `project_starve_escalation` is
- * wired into health.cjs's `criticalComponents` gate, so `ok: false` here is
- * exactly what flips `npm run health`'s exit code from 0 to 1.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-starve-escalation.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 {
-  evaluateStarveEscalationHealth,
-  latestStarveEscalationReasons,
-} = require('../health.cjs');
-const { STARVE_ESCALATION_MS } = require('../scheduler.cjs');
-
-const CWD = '/home/bilko/Projects/Bilko';
-const NOW = Date.parse('2026-09-12T20:00:00.000Z');
-const idleFor = (ms) => NOW - ms;
-
-test('a project starved past the escalation threshold is non-GREEN and names the project + hold reason', () => {
-  const jobs = [{ slug: 'a', cwd: CWD, status: 'pending', createdAt: new Date(idleFor(STARVE_ESCALATION_MS + 60_000)).toISOString() }];
-  // findStarvedProjects requires some OTHER project to be running — an idle
-  // machine is not starvation, only a passed-over project is.
-  const allJobs = [...jobs, { slug: 'other', cwd: '/home/bilko/Projects/other', status: 'running' }];
-  const result = evaluateStarveEscalationHealth(allJobs, NOW, STARVE_ESCALATION_MS, { [CWD]: 'slots-exhausted' });
-  expect(result.ok).toBe(false);
-  expect(result.projects).toEqual([
-    expect.objectContaining({ cwd: CWD, pendingCount: 1, holdReason: 'slots-exhausted' }),
-  ]);
-  expect(result.message).toMatch(new RegExp(CWD.replace(/\//g, '\\/')));
-  expect(result.message).toMatch(/slots-exhausted/);
-});
-
-test('a starved project with no recorded escalation reason yet reports "unknown", not a throw', () => {
-  const allJobs = [
-    { slug: 'a', cwd: CWD, status: 'pending', createdAt: new Date(idleFor(STARVE_ESCALATION_MS + 1)).toISOString() },
-    { slug: 'other', cwd: '/home/bilko/Projects/other', status: 'running' },
-  ];
-  const result = evaluateStarveEscalationHealth(allJobs, NOW, STARVE_ESCALATION_MS, {});
-  expect(result.ok).toBe(false);
-  expect(result.projects[0].holdReason).toBe('unknown');
-});
-
-test('a starve below the escalation threshold stays GREEN', () => {
-  const allJobs = [
-    { slug: 'a', cwd: CWD, status: 'pending', createdAt: new Date(idleFor(STARVE_ESCALATION_MS - 60_000)).toISOString() },
-    { slug: 'other', cwd: '/home/bilko/Projects/other', status: 'running' },
-  ];
-  const result = evaluateStarveEscalationHealth(allJobs, NOW, STARVE_ESCALATION_MS, {});
-  expect(result).toEqual({ ok: true });
-});
-
-test('nothing pending anywhere stays GREEN', () => {
-  const result = evaluateStarveEscalationHealth([], NOW, STARVE_ESCALATION_MS, {});
-  expect(result).toEqual({ ok: true });
-});
-
-test('latestStarveEscalationReasons reads the LAST recorded holdReason per cwd from the audit log', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-health-audit-'));
-  const auditPath = path.join(dir, 'audit-log.jsonl');
-  const lines = [
-    { kind: 'project_starved', cwd: CWD, ageMs: 1000 }, // different kind — must be ignored
-    { kind: 'project_starve_escalated', cwd: CWD, holdReason: 'memory-deferred' },
-    { kind: 'project_starve_escalated', cwd: CWD, holdReason: 'load-deferred' }, // latest wins
-    { kind: 'project_starve_escalated', cwd: '/home/bilko/Projects/other', holdReason: 'held' },
-  ];
-  fs.writeFileSync(auditPath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-
-  const reasons = latestStarveEscalationReasons(auditPath);
-  expect(reasons[CWD]).toBe('load-deferred');
-  expect(reasons['/home/bilko/Projects/other']).toBe('held');
-});
-
-test('latestStarveEscalationReasons returns {} for a missing audit log, never a throw', () => {
-  expect(latestStarveEscalationReasons('/nonexistent/path/audit-log.jsonl')).toEqual({});
-});

package/src/main/__tests__/health-tick-liveness.test.cjs

@@ -1,179 +0,0 @@
-/**
- * health-tick-liveness.test.cjs — tick-liveness assertion for the
- * scheduler_queue health check (PRD: health stayed GREEN through the
- * 2026-07-14 16.5h scheduler-tick stall while PRD 544 sat pending with free
- * capacity). Exercises evaluateTickLiveness()/readFreshHeartbeat() directly
- * since they're pure/fs-isolated — no need to mock os.homedir() through the
- * full check() to cover the liveness logic.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/health-tick-liveness.test.cjs
- */
-
-'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 {
-  evaluateTickLiveness,
-  readFreshHeartbeat,
-  TICK_STALL_THRESHOLD_MS,
-} = require('../health.cjs');
-
-// Real incident fixture, verified at triage (PRD notes): queue.json had one
-// job pending, running:0, concurrencyCap:3, paused:null, enabled:true, and
-// lastRunAt frozen at the moment the tick died.
-const STALL_LAST_RUN_AT = '2026-07-14T14:40:39.274Z';
-const NOW = Date.parse(STALL_LAST_RUN_AT) + 16.5 * 60 * 60_000; // 16.5h later
-
-function baseQueue(overrides = {}) {
-  return {
-    config: {
-      concurrencyCap: 3,
-      firePolicy: 'when-available',
-      utilizationThreshold: 90,
-      enabled: true,
-    },
-    jobs: [
-      { slug: '544-stuck-job', status: 'pending' },
-    ],
-    lastRunAt: STALL_LAST_RUN_AT,
-    paused: null,
-    ...overrides,
-  };
-}
-
-test('reports stalled: pending job, free capacity, not paused, enabled, tick silent for 16.5h (heartbeat confirms utilization is not the explanation)', () => {
-  const heartbeat = { ts: NOW - 30_000, utilization: 0 };
-  const result = evaluateTickLiveness(baseQueue(), heartbeat, NOW);
-  assert.strictEqual(result.stalled, true);
-  assert.strictEqual(result.oldestPendingSlug, '544-stuck-job');
-  assert.ok(result.tickAgeMs > TICK_STALL_THRESHOLD_MS);
-});
-
-test('no false positive: queue is paused (incl. rate-limit auto-pause)', () => {
-  const result = evaluateTickLiveness(
-    baseQueue({ paused: { reason: 'rate-limit', resumeAt: '2099-01-01T00:00:00.000Z' } }),
-    null,
-    NOW
-  );
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'paused');
-});
-
-test('no false positive: running is already at concurrencyCap', () => {
-  const q = baseQueue({
-    jobs: [
-      { slug: 'running-1', status: 'running' },
-      { slug: 'running-2', status: 'running' },
-      { slug: 'running-3', status: 'running' },
-      { slug: '544-stuck-job', status: 'pending' },
-    ],
-  });
-  q.slotCap = 3; // machine-wide sessionSlots pool is the only cap now
-  const result = evaluateTickLiveness(q, null, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'at-capacity');
-});
-
-test('no false positive: scheduler disabled', () => {
-  const q = baseQueue({ config: { ...baseQueue().config, enabled: false } });
-  const result = evaluateTickLiveness(q, null, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'disabled');
-});
-
-test('no false positive: billing utilization at/above utilizationThreshold (when-available is designed to hold)', () => {
-  const heartbeat = { ts: NOW - 30_000, utilization: 95 };
-  const result = evaluateTickLiveness(baseQueue(), heartbeat, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'utilization-at-threshold');
-});
-
-test('utilization hold with reset days out is flagged longHold; within 5h is benign', () => {
-  const far = evaluateTickLiveness(baseQueue(), { ts: NOW - 30_000, utilization: 95, utilizationWindow: 'weekly_all', nextReset: new Date(NOW + 3 * 86_400_000).toISOString() }, NOW);
-  assert.strictEqual(far.stalled, false);
-  assert.strictEqual(far.longHold, true);
-  assert.strictEqual(far.window, 'weekly_all');
-  const unknown = evaluateTickLiveness(baseQueue(), { ts: NOW - 30_000, utilization: 95, nextReset: null }, NOW);
-  assert.strictEqual(unknown.longHold, true);
-  const near = evaluateTickLiveness(baseQueue(), { ts: NOW - 30_000, utilization: 95, utilizationWindow: 'five_hour', nextReset: new Date(NOW + 2 * 3_600_000).toISOString() }, NOW);
-  assert.strictEqual(near.stalled, false);
-  assert.strictEqual(near.longHold, undefined);
-});
-
-test('no false positive: no pending jobs at all', () => {
-  const q = baseQueue({ jobs: [] });
-  const result = evaluateTickLiveness(q, null, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'no-pending-jobs');
-});
-
-test('degrades honestly: heartbeat missing/stale means utilization cannot be ruled out — caveat, not a confident stall', () => {
-  const result = evaluateTickLiveness(baseQueue(), null, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.caveat, true);
-  assert.strictEqual(result.reason, 'cannot-verify-utilization');
-});
-
-test('manual firePolicy: pending work with free capacity is configured behaviour, not a stall', () => {
-  const q = baseQueue({ config: { ...baseQueue().config, firePolicy: 'manual' } });
-  const result = evaluateTickLiveness(q, null, NOW);
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'manual-fire-policy');
-});
-
-test('does not caveat when firePolicy is neither when-available nor manual (no heartbeat needed)', () => {
-  const q = baseQueue({ config: { ...baseQueue().config, firePolicy: 'always' } });
-  const result = evaluateTickLiveness(q, null, NOW);
-  assert.strictEqual(result.stalled, true);
-});
-
-test('readFreshHeartbeat: returns null for missing file', () => {
-  const result = readFreshHeartbeat(path.join(os.tmpdir(), 'sm-health-test-nonexistent.log'));
-  assert.strictEqual(result, null);
-});
-
-test('readFreshHeartbeat: returns null for a stale (old) heartbeat line', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-health-heartbeat-'));
-  const p = path.join(dir, 'heartbeat.log');
-  try {
-    fs.writeFileSync(p, `${JSON.stringify({ ts: Date.now() - 60 * 60_000, utilization: 10 })}\n`);
-    assert.strictEqual(readFreshHeartbeat(p), null);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('readFreshHeartbeat: returns the parsed last line when fresh', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-health-heartbeat-'));
-  const p = path.join(dir, 'heartbeat.log');
-  try {
-    fs.writeFileSync(
-      p,
-      `${JSON.stringify({ ts: Date.now() - 5 * 60_000, utilization: 10 })}\n${JSON.stringify({ ts: Date.now(), utilization: 42 })}\n`
-    );
-    const entry = readFreshHeartbeat(p);
-    assert.strictEqual(entry.utilization, 42);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('no false positive: pending rows blocked on an unfinished dependsOn are waiting on a job, not a tick', () => {
-  const result = evaluateTickLiveness(
-    baseQueue({
-      jobs: [
-        { slug: '265-head', status: 'running' },
-        { slug: '266-next', status: 'pending', dependsOn: ['265-head'] },
-      ],
-    }),
-    { ts: NOW - 30_000, utilization: 0 },
-    NOW,
-    1,
-  );
-  assert.strictEqual(result.stalled, false);
-  assert.strictEqual(result.reason, 'no-pending-jobs');
-});

package/src/main/__tests__/health-usage-poller.test.cjs

@@ -1,144 +0,0 @@
-/**
- * health-usage-poller.test.cjs — `npm run health` must report GREEN / YELLOW
- * / RED for the usage/rate-limit poller (scheduler.cjs pollLoop), driven by
- * the shared usageCircuit's OWN open/closed state and how long it's been
- * open (usageCircuitState/usageCircuitOpenedAt, persisted to
- * ~/.claude/session-manager/scheduler-state.json by persistSchedulerState —
- * this is a separate `npm run health` process, so it reads the PERSISTED
- * circuit fields rather than holding the live in-memory breaker) — not the
- * old binary consecutiveFailures<5 check, which read flatly non-GREEN
- * forever after the fifth failure with no way to distinguish "just tripped"
- * from "down for hours." Exercises evaluateUsagePollerHealth() and
- * loadUsagePollerState() directly since both are pure/file-scoped, matching
- * every other evaluate* helper's test pattern in this file — deliberately NOT
- * driving the full (slow, machine-state-coupled) check() for this.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-usage-poller.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-const { evaluateUsagePollerHealth, loadUsagePollerState } = require('../health.cjs');
-const { FAILURE_STREAK_ESCALATION_MS } = require('../scheduler.cjs');
-
-test('missing state (fresh install / poller never ran) is ok, not applicable', () => {
-  expect(evaluateUsagePollerHealth(null)).toEqual({ ok: true, applicable: false });
-  expect(evaluateUsagePollerHealth(undefined)).toEqual({ ok: true, applicable: false });
-});
-
-test('circuit closed is GREEN, regardless of a nonzero consecutiveFailures count', () => {
-  const result = evaluateUsagePollerHealth({ usageCircuitState: 'closed', consecutiveFailures: 2, backoffMs: 60_000, lastPollAt: Date.now() });
-  expect(result.ok).toBe(true);
-  expect(result.applicable).toBe(true);
-  expect(result.color).toBe('GREEN');
-  expect(result.message).toBeUndefined();
-});
-
-test('no usageCircuitState field at all (pre-upgrade sidecar) defaults to closed -> GREEN', () => {
-  const result = evaluateUsagePollerHealth({ consecutiveFailures: 0, backoffMs: null, lastPollAt: Date.now() });
-  expect(result.ok).toBe(true);
-  expect(result.color).toBe('GREEN');
-});
-
-test('circuit open for under FAILURE_STREAK_ESCALATION_MS (30 min) is YELLOW, not GREEN — but still ok:true, not yet critical', () => {
-  const now = Date.now();
-  const result = evaluateUsagePollerHealth({
-    usageCircuitState: 'open',
-    usageCircuitOpenedAt: now - 5 * 60_000, // 5 minutes ago
-    consecutiveFailures: 6,
-    backoffMs: 480_000,
-    lastPollAt: now,
-  });
-  // ok:true is deliberate — the circuit's own open threshold (3 consecutive
-  // failures) is LOWER than the old 5-failure WARN, so an ok:false YELLOW
-  // would silently tighten the overall `npm run health` rollup's failure bar
-  // from 5 down to 3. Graceful degradation must not itself read as critical.
-  expect(result.ok).toBe(true);
-  expect(result.color).toBe('YELLOW');
-  expect(result.message).toMatch(/YELLOW/);
-});
-
-test('circuit open for AT LEAST FAILURE_STREAK_ESCALATION_MS (30 min) is RED — ok:false, this is the critical state', () => {
-  const now = Date.now();
-  const result = evaluateUsagePollerHealth({
-    usageCircuitState: 'open',
-    usageCircuitOpenedAt: now - FAILURE_STREAK_ESCALATION_MS,
-    consecutiveFailures: 57,
-    backoffMs: 480_000,
-    lastPollAt: now,
-  });
-  expect(result.ok).toBe(false);
-  expect(result.color).toBe('RED');
-  expect(result.consecutiveFailures).toBe(57);
-  expect(result.backoffMs).toBe(480_000);
-  expect(result.message).toMatch(/RED/);
-});
-
-test('half_open (mid-probe) is treated the same as open — not GREEN just because a probe is in flight', () => {
-  const now = Date.now();
-  const result = evaluateUsagePollerHealth({
-    usageCircuitState: 'half_open',
-    usageCircuitOpenedAt: now - 60_000,
-    consecutiveFailures: 5,
-    lastPollAt: now,
-  });
-  expect(result.ok).toBe(true); // still YELLOW-shaped (under the red threshold), so still ok:true
-  expect(result.color).toBe('YELLOW');
-});
-
-test('respects a custom redThresholdMs argument', () => {
-  const now = Date.now();
-  const openedAt = now - 10_000;
-  const red = evaluateUsagePollerHealth({ usageCircuitState: 'open', usageCircuitOpenedAt: openedAt, consecutiveFailures: 5 }, 5_000);
-  expect(red.color).toBe('RED');
-  expect(red.ok).toBe(false);
-  const yellow = evaluateUsagePollerHealth({ usageCircuitState: 'open', usageCircuitOpenedAt: openedAt, consecutiveFailures: 5 }, 60_000);
-  expect(yellow.color).toBe('YELLOW');
-  expect(yellow.ok).toBe(true);
-});
-
-test('tolerates a malformed/partial state object without throwing', () => {
-  const result = evaluateUsagePollerHealth({});
-  expect(result.ok).toBe(true);
-  expect(result.color).toBe('GREEN');
-  expect(result.consecutiveFailures).toBe(0);
-});
-
-// loadUsagePollerState: must distinguish "never ran" (ENOENT) from "corrupt"
-// (unparseable) — the exact silent-masking bug class as the sibling
-// scheduler-machine.json torn-write incident (f56bdc0), just for this sidecar.
-// Uses a real scratch temp dir/file, never the real ~/.claude/session-manager/.
-let scratchDir;
-function makeScratchPath() {
-  scratchDir = mkdtempSync(join(tmpdir(), 'sm-usage-poller-health-'));
-  return join(scratchDir, 'scheduler-state.json');
-}
-
-test('loadUsagePollerState: missing file -> { missing: true }', () => {
-  const p = join(makeScratchPath()); // never written
-  const result = loadUsagePollerState(p);
-  expect(result).toEqual({ missing: true });
-  rmSync(scratchDir, { recursive: true, force: true });
-});
-
-test('loadUsagePollerState: corrupt/unparseable JSON -> errorMessage, not missing', () => {
-  const p = makeScratchPath();
-  writeFileSync(p, '{ not: valid json', 'utf8');
-  const result = loadUsagePollerState(p);
-  expect(result.missing).toBeUndefined();
-  expect(result.state).toBeUndefined();
-  expect(result.errorMessage).toMatch(/corrupt/);
-  rmSync(scratchDir, { recursive: true, force: true });
-});
-
-test('loadUsagePollerState: valid JSON -> { state }', () => {
-  const p = makeScratchPath();
-  writeFileSync(p, JSON.stringify({ consecutiveFailures: 12, backoffMs: 480_000, lastPollAt: 123 }), 'utf8');
-  const result = loadUsagePollerState(p);
-  expect(result.state).toEqual({ consecutiveFailures: 12, backoffMs: 480_000, lastPollAt: 123 });
-  rmSync(scratchDir, { recursive: true, force: true });
-});

package/src/main/__tests__/health-worktree-cap-blocked.test.cjs

@@ -1,65 +0,0 @@
-/**
- * health-worktree-cap-blocked.test.cjs — `npm run health` must report
- * non-GREEN when the worktree cap (gitWorktree.cjs's reserveWorktreeSlot) is
- * blocking every dispatchable pending job with nothing running. Before this
- * check existed that state was invisible to health.cjs: rows in four
- * separate project queues carried heldReason 'worktree cap reached (5
- * concurrent)' for 16 hours with zero entries in
- * session-manager-operations/logs/ and nothing non-GREEN here — only a
- * console.log line and the heldReason field itself, which nothing surfaced.
- *
- * Exercises evaluateWorktreeCapBlocked() directly — pure, no fs — matching
- * every other evaluate* helper's test pattern in this file (see
- * health-usage-poller.test.cjs's header).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-worktree-cap-blocked.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluateWorktreeCapBlocked } = require('../health.cjs');
-
-test('a pending job held on "worktree cap reached" with 0 running is non-GREEN, blocked', () => {
-  const jobs = [
-    { slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
-    { slug: 'b', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
-  ];
-  const result = evaluateWorktreeCapBlocked(jobs, 0);
-  expect(result.ok).toBe(false);
-  expect(result.blocked).toBe(true);
-  expect(result.capBlockedSlugs).toEqual(['a', 'b']);
-});
-
-test('accepts a job map (queueStore.readMergedSync federated shape), not just an array', () => {
-  const jobs = {
-    a: { slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
-    b: { slug: 'b', status: 'completed' },
-  };
-  const result = evaluateWorktreeCapBlocked(jobs, 0);
-  expect(result.ok).toBe(false);
-  expect(result.capBlockedSlugs).toEqual(['a']);
-});
-
-test('the same cap-reached row stays GREEN while at least one job is running', () => {
-  const jobs = [{ slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' }];
-  const result = evaluateWorktreeCapBlocked(jobs, 1);
-  expect(result.ok).toBe(true);
-  expect(result.blocked).toBe(false);
-});
-
-test('a pending row with an unrelated heldReason (or none) stays GREEN', () => {
-  const jobs = [
-    { slug: 'a', status: 'pending', heldReason: 'launch blocked (rate_limit) — re-probe at 2026-09-11T00:00:00Z' },
-    { slug: 'b', status: 'pending' },
-  ];
-  const result = evaluateWorktreeCapBlocked(jobs, 0);
-  expect(result.ok).toBe(true);
-  expect(result.blocked).toBe(false);
-});
-
-test('no pending jobs at all stays GREEN', () => {
-  const result = evaluateWorktreeCapBlocked([], 0);
-  expect(result.ok).toBe(true);
-  expect(result.blocked).toBe(false);
-});

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

@@ -1,121 +0,0 @@
-/**
- * heapSnapshot.test.cjs — unit tests for heapSnapshot.cjs's default-off
- * gating, IPC/menu wiring, and the capture timeout bound.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/heapSnapshot.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const os = require('node:os');
-const path = require('node:path');
-const fsp = require('node:fs/promises');
-const heapSnapshot = require('../heapSnapshot.cjs');
-
-const ORIGINAL_FLAG = process.env.SM_HEAP_SNAPSHOT;
-
-beforeEach(() => {
-  delete process.env.SM_HEAP_SNAPSHOT;
-});
-
-afterEach(async () => {
-  if (ORIGINAL_FLAG === undefined) delete process.env.SM_HEAP_SNAPSHOT;
-  else process.env.SM_HEAP_SNAPSHOT = ORIGINAL_FLAG;
-});
-
-test('isEnabled is false by default (no env flag)', () => {
-  expect(heapSnapshot.isEnabled()).toBe(false);
-});
-
-test('isEnabled is true only when SM_HEAP_SNAPSHOT=1', () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  expect(heapSnapshot.isEnabled()).toBe(true);
-  process.env.SM_HEAP_SNAPSHOT = 'true';
-  expect(heapSnapshot.isEnabled()).toBe(false);
-});
-
-test('registerIpc registers nothing when disabled — default-off IPC surface', () => {
-  const calls = [];
-  const fakeIpcMain = { handle: (channel, listener) => calls.push({ channel, listener }) };
-  const registered = heapSnapshot.registerIpc({ ipcMain: fakeIpcMain, getWindow: () => null });
-  expect(registered).toBe(false);
-  expect(calls).toHaveLength(0);
-});
-
-test('registerIpc registers the channel when enabled', () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  const calls = [];
-  const fakeIpcMain = { handle: (channel, listener) => calls.push({ channel, listener }) };
-  const registered = heapSnapshot.registerIpc({ ipcMain: fakeIpcMain, getWindow: () => null });
-  expect(registered).toBe(true);
-  expect(calls).toHaveLength(1);
-  expect(calls[0].channel).toBe(heapSnapshot.CHANNEL);
-  expect(calls[0].channel).toBe('diagnostics:heap-snapshot');
-});
-
-test('buildMenuItem returns null when disabled — no menu entry added', () => {
-  expect(heapSnapshot.buildMenuItem(() => null)).toBeNull();
-});
-
-test('buildMenuItem returns a clickable item when enabled', () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  const item = heapSnapshot.buildMenuItem(() => null);
-  expect(item).not.toBeNull();
-  expect(typeof item.click).toBe('function');
-  expect(item.label).toMatch(/heap snapshot/i);
-});
-
-test('captureSnapshot rejects when disabled, without touching the window', async () => {
-  const win = { webContents: { takeHeapSnapshot: () => { throw new Error('should not be called'); } } };
-  await expect(heapSnapshot.captureSnapshot(win)).rejects.toThrow(/disabled/i);
-});
-
-test('captureSnapshot rejects when no window is available', async () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  await expect(heapSnapshot.captureSnapshot(null)).rejects.toThrow(/no renderer window/i);
-});
-
-test('captureSnapshot writes the file and reports size/duration on success', async () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-heap-test-'));
-  try {
-    const win = {
-      webContents: {
-        takeHeapSnapshot: async (filePath) => {
-          await fsp.writeFile(filePath, Buffer.alloc(1024, 1));
-        },
-      },
-    };
-    const result = await heapSnapshot.captureSnapshot(win, { dir, now: new Date('2026-08-07T12:00:00.000Z') });
-    expect(result.filePath).toBe(path.join(dir, 'heap-2026-08-07T12-00-00-000Z.heapsnapshot'));
-    expect(result.bytes).toBe(1024);
-    expect(typeof result.ms).toBe('number');
-    const stat = await fsp.stat(result.filePath);
-    expect(stat.size).toBe(1024);
-  } finally {
-    await fsp.rm(dir, { recursive: true, force: true });
-  }
-});
-
-test('captureSnapshot times out instead of hanging forever on a stuck write', async () => {
-  process.env.SM_HEAP_SNAPSHOT = '1';
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-heap-test-'));
-  try {
-    const win = {
-      webContents: {
-        // Never resolves — simulates a stuck/blocked renderer.
-        takeHeapSnapshot: () => new Promise(() => {}),
-      },
-    };
-    await expect(
-      heapSnapshot.captureSnapshot(win, { dir, timeoutMs: 20 })
-    ).rejects.toThrow(/timed out/i);
-  } finally {
-    await fsp.rm(dir, { recursive: true, force: true });
-  }
-});
-
-test('snapshotDir points under ~/.claude/session-manager', () => {
-  expect(heapSnapshot.snapshotDir()).toBe(path.join(os.homedir(), '.claude', 'session-manager'));
-});