claude-code-session-manager 0.93.0 → 0.95.0

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

@@ -139,3 +139,183 @@ describe('childWithLog onExit leakedDescendants reporting (PRD 1110)', () => {
     15000,
   );
 });
+
+// PRD 1353 — async enumeration must never block/alter the kill cascade, and a
+// throwing watchdog must not break the wall-clock kill path.
+describe('childWithLog async enumeration + guarded watchdog (PRD 1353)', () => {
+  const { _deps } = require('../childWithLog.cjs');
+  const realExecFile = _deps.execFile;
+  afterEach(() => { _deps.execFile = realExecFile; });
+
+  it.skipIf(process.platform !== 'linux')(
+    'enumeration failure omits the report, logs, and still kills the group',
+    async () => {
+      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-enumfail-'));
+      const logPath = path.join(dir, 'job.log');
+      const pidFile = path.join(dir, 'grandchild.pid');
+      const { fd, safeLog, closeFd } = openLog(logPath);
+      _deps.execFile = (_c, _a, _o, cb) => { setImmediate(() => cb(new Error('ps boom'))); };
+
+      const exitInfo = await new Promise((resolve) => {
+        withChildAndLog({
+          fd, logPath, safeLog, closeFd,
+          spawn: {
+            command: 'sh',
+            args: ['-c', `sleep 30 & echo $! > ${pidFile}; exec sleep 0.2`],
+            options: { detached: true },
+          },
+          onExit: (info) => { info.safeLog('onExit-ran\n'); resolve(info); },
+        });
+      });
+      expect(exitInfo.leakedDescendants).toEqual([]);
+      for (let i = 0; i < 20 && !fs.existsSync(pidFile); i++) await new Promise((r) => setTimeout(r, 50));
+      const gc = Number(fs.readFileSync(pidFile, 'utf8').trim());
+      await new Promise((r) => setTimeout(r, 500)); // SIGTERM lands immediately, no grace wait
+      expect(() => process.kill(gc, 0)).toThrow();
+      expect(fs.readFileSync(logPath, 'utf8')).toContain('enumeration failed');
+    },
+    15000,
+  );
+
+  function runWatchdog(wd) {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-wd-'));
+    const logPath = path.join(dir, 'job.log');
+    const { fd, safeLog, closeFd } = openLog(logPath);
+    let handle;
+    const done = new Promise((resolve) => {
+      handle = withChildAndLog({
+        fd, logPath, safeLog, closeFd,
+        spawn: { command: 'sleep', args: ['5'], options: {} },
+        watchdogs: [{ label: 'w', intervalMs: 20, ...wd }],
+        onExit: resolve,
+      });
+    });
+    return { logPath, handle, done };
+  }
+
+  it('a throwing shouldFire does not stop a later tick firing the action', async () => {
+    let calls = 0;
+    let fired = 0;
+    const { handle, logPath, done } = runWatchdog({
+      shouldFire: () => { calls++; if (calls < 3) throw new Error('sf boom'); return true; },
+      action: (ctx) => { fired++; ctx.killedByWatchdog = 'w'; ctx.killTree('SIGTERM'); },
+    });
+    const info = await done;
+    expect(fired).toBe(1);
+    expect(info.killedByWatchdog).toBe('w');
+    expect(fs.readFileSync(logPath, 'utf8')).toContain('watchdog "w" threw: sf boom');
+    handle.cancel();
+  }, 10000);
+
+  it('a throwing action clears its interval and is logged', async () => {
+    let should = 0;
+    let acts = 0;
+    const { handle, logPath, done } = runWatchdog({
+      shouldFire: () => { should++; return true; },
+      action: () => { acts++; throw new Error('act boom'); },
+    });
+    await new Promise((r) => setTimeout(r, 200));
+    expect(acts).toBe(1);
+    expect(should).toBe(1);
+    expect(fs.readFileSync(logPath, 'utf8')).toContain('watchdog "w" threw: act boom');
+    handle.cancel();
+    await done;
+  }, 10000);
+});
+
+// PRD 1370 — enumerate BEFORE SIGTERM; no-enumeration paths stay synchronous.
+describe('childWithLog sweep ordering + sync paths (PRD 1370)', () => {
+  const { _deps } = require('../childWithLog.cjs');
+  const realExecFile = _deps.execFile;
+  const realKill = process.kill;
+  afterEach(() => { _deps.execFile = realExecFile; process.kill = realKill; });
+
+  function setup(name) {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), name));
+    const logPath = path.join(dir, 'job.log');
+    return { logPath, ...openLog(logPath) };
+  }
+
+  it.skipIf(process.platform !== 'linux').each([
+    ['successful', (cb) => cb(null, 'PID PGRP %CPU ELAPSED COMMAND\n')],
+    ['failing', (cb) => cb(new Error('ps boom'))],
+  ])('SIGTERM waits for the %s enumeration', async (label, respond) => {
+    const { logPath, fd, safeLog, closeFd } = setup('sm-child-order-');
+    let psCb;
+    _deps.execFile = (_c, _a, _o, cb) => { psCb = cb; };
+    const groupKills = [];
+    process.kill = (pid, sig) => {
+      if (pid < -1 && sig === 'SIGTERM') { groupKills.push(pid); return true; }
+      return realKill.call(process, pid, sig);
+    };
+    let info;
+    const done = new Promise((resolve) => {
+      withChildAndLog({
+        fd, logPath, safeLog, closeFd,
+        spawn: { command: 'sh', args: ['-c', 'exit 0'], options: { detached: true } },
+        onExit: (i) => { info = i; resolve(); },
+      });
+    });
+    for (let i = 0; i < 100 && !psCb; i++) await new Promise((r) => setTimeout(r, 20));
+    expect(psCb).toBeTruthy();
+    await new Promise((r) => setTimeout(r, 100));
+    expect(groupKills).toEqual([]);
+    respond(psCb);
+    await done; // onExit runs only after the kill was issued
+    expect(groupKills.length).toBe(1);
+    expect(info.leakedDescendants).toEqual([]);
+    if (label === 'failing') expect(fs.readFileSync(logPath, 'utf8')).toContain('enumeration failed');
+  }, 15000);
+
+  it('runs onExit synchronously when the spawn throws', () => {
+    const { logPath, fd, safeLog, closeFd } = setup('sm-child-spawnfail-');
+    let ran = false;
+    const r = withChildAndLog({
+      fd, logPath, safeLog, closeFd,
+      spawn: { command: 'sh', args: [], options: { cwd: '/nonexistent\0bad', detached: true } },
+      onExit: (i) => { ran = i.spawnFailed === true; },
+    });
+    expect(r.child).toBeNull();
+    expect(ran).toBe(true);
+  });
+
+  it.skipIf(process.platform !== 'linux')('a throwing deferred onExit is logged and still closes the fd', async () => {
+    const { logPath, fd, safeLog, closeFd } = setup('sm-child-throw-');
+    _deps.execFile = (_c, _a, _o, cb) => { setImmediate(() => cb(null, 'h\n')); };
+    const unhandled = [];
+    const h = (e) => unhandled.push(e);
+    process.on('unhandledRejection', h);
+    let closed = false;
+    const wrapClose = () => { closed = true; closeFd(); };
+    await new Promise((resolve) => {
+      withChildAndLog({
+        fd, logPath, safeLog, closeFd: wrapClose,
+        spawn: { command: 'sh', args: ['-c', 'exit 0'], options: { detached: true } },
+        onExit: () => { setImmediate(resolve); throw new Error('exit boom'); },
+      });
+    });
+    await new Promise((r) => setTimeout(r, 50));
+    process.off('unhandledRejection', h);
+    expect(unhandled).toEqual([]);
+    expect(closed).toBe(true);
+    expect(fs.readFileSync(logPath, 'utf8')).toContain('onExit threw: exit boom');
+  }, 15000);
+
+  it('a throwing synchronous onExit is logged, closes the fd, and is re-thrown', async () => {
+    const { logPath, fd, safeLog, closeFd } = setup('sm-child-throw-sync-');
+    let closed = false;
+    const wrapClose = () => { closed = true; closeFd(); };
+    const thrown = await new Promise((resolve) => {
+      const onUncaught = (e) => { process.off('uncaughtException', onUncaught); resolve(e); };
+      process.on('uncaughtException', onUncaught);
+      withChildAndLog({
+        fd, logPath, safeLog, closeFd: wrapClose,
+        spawn: { command: 'sh', args: ['-c', 'exit 0'] },
+        onExit: () => { throw new Error('exit boom'); },
+      });
+    });
+    expect(thrown.message).toBe('exit boom');
+    expect(closed).toBe(true);
+    expect(fs.readFileSync(logPath, 'utf8')).toContain('onExit threw: exit boom');
+  }, 15000);
+});

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

@@ -1154,3 +1154,22 @@ test('ensureGuardsInstalled: records every auto-install attempt in the ops error
   expect(delegationLines.every((l) => l.level === 'info')).toBe(true);
   expect(delegationLines.every((l) => l.meta?.action === 'installed')).toBe(true);
 }, 15_000);
+
+test('ensureGuardsInstalled: an already-installed re-run writes no new ops error-log rows', async () => {
+  const cwd = await mkTmp('sm-ensure-guards-noop-');
+  const homeDir = await mkTmp('sm-ensure-guards-noop-home-');
+
+  await ensureGuardsInstalled(cwd, { homeDir });
+  const logFile = opsErrorLogTodayFile(cwd);
+  const before = fs.readFileSync(logFile, 'utf8');
+
+  clearGuardsInstalledCache();
+  const again = await ensureGuardsInstalled(cwd, { homeDir });
+  expect(Object.values(again.guards).every((g) => g.action === 'already-installed')).toBe(true);
+  expect(fs.readFileSync(logFile, 'utf8')).toBe(before);
+}, 15_000);
+
+test('delegationReadiness.cjs source contains no raw NUL byte', () => {
+  const src = fs.readFileSync(path.join(__dirname, '..', 'delegationReadiness.cjs'));
+  expect(src.includes(0)).toBe(false);
+});

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

@@ -0,0 +1,69 @@
+/**
+ * gitCacheBound.test.cjs — git status caches are LRU-bounded and drop expired entries.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/gitCacheBound.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeEach, afterEach, vi } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { addAllowedRoot } = require('../../config.cjs');
+const git = require('../../git.cjs');
+
+const { statusCache, fileStatusCache, CACHE_MAX_CWDS } = git._caches;
+let root;
+beforeEach(() => {
+  git.clearCache();
+  root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'git-cache-bound-')));
+  addAllowedRoot(root);
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+function mkdirs(n) {
+  return Array.from({ length: n }, (_, i) => {
+    const d = path.join(root, `d${i}`);
+    fs.mkdirSync(d);
+    return fs.realpathSync(d);
+  });
+}
+
+test('50 distinct cwds never exceed the cap', async () => {
+  for (const d of mkdirs(50)) {
+    await git.getStatus(d);
+    await git.getFileStatus(d);
+  }
+  expect(statusCache.size).toBeLessThanOrEqual(CACHE_MAX_CWDS);
+  expect(fileStatusCache.size).toBeLessThanOrEqual(CACHE_MAX_CWDS);
+  expect(statusCache.size).toBe(CACHE_MAX_CWDS);
+});
+
+test('an expired entry is deleted when encountered', async () => {
+  const [d] = mkdirs(1);
+  const t0 = 1_000_000;
+  const now = vi.spyOn(Date, 'now').mockReturnValue(t0);
+  await git.getStatus(d);
+  await git.getFileStatus(d);
+  expect(statusCache.get(d).expiresAt).toBe(t0 + 5_000);
+
+  // Live entry: served from cache, untouched.
+  now.mockReturnValue(t0 + 4_999);
+  await git.getStatus(d);
+  expect(statusCache.get(d).expiresAt).toBe(t0 + 5_000);
+
+  // Expired: the stale entry is deleted and replaced by a fresh one.
+  now.mockReturnValue(t0 + 60_000);
+  const del = vi.spyOn(statusCache, 'delete');
+  await git.getStatus(d);
+  expect(del).toHaveBeenCalledWith(d);
+  expect(statusCache.get(d).expiresAt).toBe(t0 + 65_000);
+
+  const delFile = vi.spyOn(fileStatusCache, 'delete');
+  await git.getFileStatus(d);
+  expect(delFile).toHaveBeenCalledWith(d);
+  expect(fileStatusCache.get(d).expiresAt).toBe(t0 + 65_000);
+});

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

@@ -0,0 +1,68 @@
+/**
+ * loopDelay.test.cjs — event-loop delay probe used by crashDiagnostics's heartbeat.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/loopDelay.test.cjs
+ */
+'use strict';
+
+import { test, expect } from 'vitest';
+
+const { createLoopDelayMonitor, stallVerdict, LOOP_STALL_WARN_MS } = require('../loopDelay.cjs');
+
+// Histogram stub: values in ns, like perf_hooks.
+function stubHistogram(state) {
+  return () => ({
+    enabled: false,
+    enable() { this.enabled = true; },
+    disable() { this.enabled = false; },
+    percentile(p) { return p === 50 ? state.p50 : state.p99; },
+    get max() { return state.max; },
+    reset() { state.resets += 1; state.p50 = 0; state.p99 = 0; state.max = 0; },
+  });
+}
+
+test('normal beat: converts ns to ms (1 decimal) and does not flag a stall', () => {
+  const state = { p50: 21_040_000, p99: 34_960_000, max: 40_000_000, resets: 0 };
+  const m = createLoopDelayMonitor(stubHistogram(state));
+  m.enable();
+  const snap = m.snapshot();
+  expect(snap).toEqual({ loopDelayP50Ms: 21, loopDelayP99Ms: 35, loopDelayMaxMs: 40 });
+  expect(stallVerdict(snap)).toBeNull();
+});
+
+test('stall beat: max above threshold yields warn "main loop stall"', () => {
+  const state = { p50: 20_000_000, p99: 300_000_000, max: 412_300_000, resets: 0 };
+  const snap = createLoopDelayMonitor(stubHistogram(state)).snapshot();
+  expect(snap.loopDelayMaxMs).toBe(412.3);
+  expect(stallVerdict(snap)).toEqual({ level: 'warn', message: 'main loop stall' });
+  expect(stallVerdict({ loopDelayMaxMs: LOOP_STALL_WARN_MS })).toBeNull(); // strictly greater
+});
+
+test('reset between beats: a stall does not bleed into the next interval', () => {
+  const state = { p50: 20_000_000, p99: 300_000_000, max: 500_000_000, resets: 0 };
+  const m = createLoopDelayMonitor(stubHistogram(state));
+  expect(stallVerdict(m.snapshot())).not.toBeNull();
+  expect(state.resets).toBe(1);
+  const second = m.snapshot();
+  expect(second.loopDelayMaxMs).toBe(0);
+  expect(stallVerdict(second)).toBeNull();
+  expect(state.resets).toBe(2);
+});
+
+test('passes a 20 ms resolution to the histogram factory and disable() stops it', () => {
+  let opts; let h;
+  const m = createLoopDelayMonitor((o) => { opts = o; h = stubHistogram({ resets: 0 })(); return h; });
+  m.enable();
+  expect(opts).toEqual({ resolution: 20 });
+  expect(h.enabled).toBe(true);
+  m.disable();
+  expect(h.enabled).toBe(false);
+});
+
+test('real perf_hooks histogram produces finite numbers', () => {
+  const m = createLoopDelayMonitor();
+  m.enable();
+  const snap = m.snapshot();
+  m.disable();
+  for (const v of Object.values(snap)) expect(Number.isFinite(v)).toBe(true);
+});

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

@@ -101,18 +101,74 @@ test('isResetFresh: past -> false, future -> true, null -> false', () => {
   assert.strictEqual(isResetFresh('not-a-date', now), false);
 });
 
-test('bindingWindow: limits[] with weekly_all is_active wins over five_hour', () => {
+const REAL_LIMITS = [
+  { kind: 'session', group: 'session', percent: 6, severity: 'normal', resets_at: '2026-09-22T00:40:00.280514+00:00', scope: null, is_active: false },
+  { kind: 'weekly_all', group: 'weekly', percent: 64, severity: 'normal', resets_at: '2026-09-24T17:00:00.280532+00:00', scope: null, is_active: true },
+  { kind: 'weekly_scoped', group: 'weekly', percent: 18, severity: 'normal', resets_at: '2026-09-24T17:00:00.280763+00:00', scope: { model: { id: null, display_name: 'Fable' }, surface: null }, is_active: false },
+];
+
+test('bindingWindow: verbatim real payload selects weekly_all 64', () => {
   const payload = {
-    five_hour: { utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
+    five_hour: { utilization: 6, resets_at: '2026-09-22T00:40:00.280514+00:00' },
+    seven_day: { utilization: 64, resets_at: '2026-09-24T17:00:00.280532+00:00' },
+    limits: REAL_LIMITS,
+  };
+  assert.deepStrictEqual(bindingWindow(payload), {
+    name: 'weekly_all',
+    utilization: 64,
+    resets_at: '2026-09-24T17:00:00.280532+00:00',
+  });
+});
+
+test('bindingWindow: max percent wins over is_active (session 95 beats weekly_all 64)', () => {
+  const win = bindingWindow({
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
-      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+      { kind: 'session', percent: 95, resets_at: '2026-09-22T00:40:00Z', scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
     ],
-  };
-  const win = bindingWindow(payload);
+  });
+  assert.strictEqual(win.name, 'session');
+  assert.strictEqual(win.utilization, 95);
+});
+
+test('bindingWindow: is_active breaks a percent tie', () => {
+  const win = bindingWindow({
+    limits: [
+      { kind: 'session', percent: 50, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 50, resets_at: null, scope: null, is_active: true },
+    ],
+  });
   assert.strictEqual(win.name, 'weekly_all');
-  assert.strictEqual(win.utilization, 81);
-  assert.strictEqual(win.resets_at, '2026-09-19T00:00:00Z');
+});
+
+test('bindingWindow: a high weekly_scoped entry is never selected', () => {
+  const win = bindingWindow({
+    limits: [
+      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 10, resets_at: null, scope: null, is_active: true },
+      { kind: 'weekly_scoped', percent: 99, resets_at: null, scope: { model: { display_name: 'Fable' } }, is_active: false },
+    ],
+  });
+  assert.strictEqual(win.name, 'weekly_all');
+  assert.strictEqual(win.utilization, 10);
+});
+
+test('bindingWindow: percent over 100 is returned raw, not clamped', () => {
+  const win = bindingWindow({ limits: [{ kind: 'session', percent: 112, resets_at: null, scope: null }] });
+  assert.strictEqual(win.utilization, 112);
+});
+
+test('bindingWindow: null resets_at backfills from the matching flat window', () => {
+  const win = bindingWindow({
+    five_hour: { utilization: 40, resets_at: '2026-09-22T00:40:00Z' },
+    seven_day: { utilization: 5, resets_at: '2026-09-24T17:00:00Z' },
+    limits: [
+      { kind: 'session', percent: 40, resets_at: null, scope: null },
+      { kind: 'weekly_all', percent: 5, resets_at: null, scope: null },
+    ],
+  });
+  assert.strictEqual(win.name, 'session');
+  assert.strictEqual(win.resets_at, '2026-09-22T00:40:00Z');
 });
 
 test('bindingWindow: limits[] absent falls back to five_hour', () => {
@@ -122,12 +178,12 @@ test('bindingWindow: limits[] absent falls back to five_hour', () => {
   assert.strictEqual(win.utilization, 42);
 });
 
-test('bindingWindow: limits[] present but nothing is_active also falls back to five_hour', () => {
+test('bindingWindow: limits[] with only scoped / non-finite entries falls back to five_hour', () => {
   const payload = {
     five_hour: { utilization: 12, resets_at: null },
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 12, resets_at: null },
-      { type: 'weekly_all', is_active: false, utilization: 81, resets_at: null },
+      { kind: 'weekly_scoped', percent: 81, resets_at: null, scope: { model: { display_name: 'Fable' } } },
+      { kind: 'session', resets_at: null, scope: null },
     ],
   };
   const win = bindingWindow(payload);
@@ -135,19 +191,32 @@ test('bindingWindow: limits[] present but nothing is_active also falls back to f
   assert.strictEqual(win.utilization, 12);
 });
 
-test('degradedBudget: never yields 0 utilization, even when the last good binding window read 0', () => {
+test('degradedBudget: a last-good binding window that genuinely read 0% carries forward as 0, not 100', () => {
   const payload = { five_hour: { utilization: 0, resets_at: null } };
-  const { utilization } = degradedBudget(payload, {});
-  assert.notStrictEqual(utilization, 0);
-  assert.strictEqual(utilization, 100); // no real signal -> conservative default
+  assert.strictEqual(degradedBudget(payload, {}).utilization, 0);
+});
+
+test('degradedBudget: no payload ever received (null/absent) still yields 100, never a blind 0', () => {
+  assert.strictEqual(degradedBudget(null, {}).utilization, 100);
+  assert.strictEqual(degradedBudget(undefined, {}).utilization, 100);
+});
+
+test('degradedBudget: a degraded cycle after a real-shape poll carries forward the real percent (64), not 100', () => {
+  const payload = {
+    limits: [
+      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
+    ],
+  };
+  assert.strictEqual(degradedBudget(payload, {}).utilization, 64);
 });
 
 test('degradedBudget: carries forward the real last-good BINDING (weekly_all) utilization, e.g. 81%, never 0', () => {
   const payload = {
     five_hour: { utilization: 0, resets_at: null },
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 0, resets_at: null },
-      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+      { kind: 'session', is_active: false, percent: 0, resets_at: null, scope: null },
+      { kind: 'weekly_all', is_active: true, percent: 81, resets_at: '2026-09-19T00:00:00Z', scope: null },
     ],
   };
   const { utilization } = degradedBudget(payload, {});

package/src/main/lib/agentPersonaSchema.cjs

@@ -1,3 +1,4 @@
+// @ts-check
 /**
  * Canonical runtime schema for an Agent persona WRITE payload, mirroring the
  * TS `AgentPersonaSaveInput` interface in src/preload/api.d.ts
@@ -67,6 +68,7 @@ const AgentPersonaSaveSchema = z.object({
  * Throws a clear, descriptive error (not a raw ZodError dump) when `persona`
  * doesn't match AgentPersonaSaveSchema. Mirrors assertValidPromptSession /
  * assertValidScheduleJob's shape and message format exactly.
+ * @param {unknown} persona
  */
 function assertValidAgentPersonaSave(persona) {
   const result = AgentPersonaSaveSchema.safeParse(persona);