claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,220 +0,0 @@
-/**
- * launchFailure.test.cjs — the non-run classifier + launch circuit breaker
- * behind GitHub issue #11 (macOS, 2026-09-02): an outdated Claude CLI sent
- * `thinking.type.enabled`, the API answered HTTP 400 on the first request,
- * and 12 of 41 runs in one project were recorded as `failed` with
- * `error: null` and then investigated by a probe that died the same way.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/launchFailure.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 lf = require('../launchFailure.cjs');
-
-// Verbatim shape from the issue-#11 transcript (2c3cd24f-…ccf0eb290fff.jsonl):
-// a single assistant entry that IS the raw API error, then the result event.
-const THINKING_400_RESULT = {
-  type: 'result', subtype: 'error', is_error: true, api_error_status: 400, num_turns: 1,
-  duration_ms: 23811, total_cost_usd: 0,
-  usage: { input_tokens: 0, output_tokens: 0 },
-  result: 'API Error: 400 {"detail":{"error":"{\\"message\\":\\"\\\\\\"thinking.type.enabled\\\\\\" is not supported for this model. Use \\\\\\"thinking.type.adaptive\\\\\\" and \\\\\\"output_config.effort\\\\\\" to control thinking behavior.\\"}"}}',
-};
-
-const REAL_WORK_FAILURE = {
-  type: 'result', subtype: 'error', is_error: true, num_turns: 19,
-  usage: { input_tokens: 4000, output_tokens: 2200 },
-  result: 'Error: expected 2 but got 3\n  at test/foo.test.ts:12:5', terminal_reason: 'error_max_turns',
-};
-
-function tmpLog(lines) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-launch-'));
-  const p = path.join(dir, 'run.log');
-  fs.writeFileSync(p, lines.map((l) => (typeof l === 'string' ? l : JSON.stringify(l))).join('\n') + '\n');
-  return p;
-}
-
-test('parseResultEvent: flattens the last result event with turns/tokens/status', () => {
-  const r = lf.parseResultEvent([
-    '[scheduler] starting foo',
-    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'API Error: 400 …' }] } }),
-    JSON.stringify(THINKING_400_RESULT),
-  ].join('\n'));
-  expect(r).toMatchObject({ subtype: 'error', isError: true, numTurns: 1, outputTokens: 0, apiErrorStatus: 400 });
-  expect(r.resultText).toMatch(/thinking\.type\.enabled/);
-});
-
-test('parseResultEvent: null when no result event exists (process died first)', () => {
-  expect(lf.parseResultEvent('[scheduler] starting\n{"type":"system","subtype":"init"}\n')).toBeNull();
-  expect(lf.parseResultEvent('')).toBeNull();
-});
-
-test('classifyLaunchFailure: the issue-#11 thinking 400 → model_config_rejected with the API message', () => {
-  const c = lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(THINKING_400_RESULT)));
-  expect(c).not.toBeNull();
-  expect(c.kind).toBe('model_config_rejected');
-  expect(c.httpStatus).toBe(400);
-  expect(c.message).toMatch(/thinking\.type\.enabled.*not supported for this model/);
-  expect(c.message).not.toMatch(/^API Error/);
-});
-
-test('classifyLaunchFailure: a run that took real turns is NEVER a launch failure, even with API Error text', () => {
-  expect(lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(REAL_WORK_FAILURE)))).toBeNull();
-  const lateApiError = { ...THINKING_400_RESULT, num_turns: 7, usage: { output_tokens: 900 } };
-  expect(lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify(lateApiError)))).toBeNull();
-});
-
-test('classifyLaunchFailure: zero-turn failure WITHOUT the API Error marker is not classified (someone else owns it)', () => {
-  const r = lf.parseResultEvent(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, num_turns: 1, usage: { output_tokens: 0 }, result: 'Invalid prompt' }));
-  expect(lf.classifyLaunchFailure(r)).toBeNull();
-});
-
-test('classifyLaunchFailure: 429 is left to the rate-limit path', () => {
-  const r = lf.parseResultEvent(JSON.stringify({ type: 'result', subtype: 'error', is_error: true, api_error_status: 429, num_turns: 1, usage: { output_tokens: 0 }, result: 'API Error: 429 {"error":{"message":"rate limited"}}' }));
-  expect(lf.classifyLaunchFailure(r)).toBeNull();
-});
-
-test('classifyLaunchFailure: status → kind mapping', () => {
-  const mk = (status, text) => lf.classifyLaunchFailure(lf.parseResultEvent(JSON.stringify({
-    type: 'result', subtype: 'error', is_error: true, num_turns: 1, usage: { output_tokens: 0 }, result: `API Error: ${status} ${text}`,
-  })));
-  expect(mk(401, '{"error":{"message":"invalid x-api-key"}}').kind).toBe('auth_failed');
-  expect(mk(403, '{"error":{"message":"forbidden"}}').kind).toBe('auth_failed');
-  expect(mk(404, '{"error":{"message":"model: claude-x not found"}}').kind).toBe('model_not_found');
-  expect(mk(400, '{"error":{"message":"max_tokens must be > 0"}}').kind).toBe('bad_request');
-  expect(mk(529, '{"error":{"type":"overloaded_error","message":"Overloaded"}}').kind).toBe('api_overloaded');
-  expect(mk(500, '{"error":{"message":"internal"}}').kind).toBe('api_overloaded');
-  expect(mk(418, 'teapot').kind).toBe('api_error');
-  expect(mk(401, '{"error":{"message":"invalid x-api-key"}}').message).toBe('invalid x-api-key');
-});
-
-test('readResultEvent + classify on a real log tail (scheduler log lines interleaved)', () => {
-  const p = tmpLog([
-    '[scheduler] starting 04-fix-cdp at 2026-09-02T17:54:14.770Z',
-    { type: 'system', subtype: 'init', session_id: 'x' },
-    { type: 'user', message: { content: [{ type: 'text', text: 'PRD body' }] } },
-    { type: 'assistant', message: { content: [{ type: 'text', text: 'API Error: 400 …' }] } },
-    THINKING_400_RESULT,
-    '[scheduler] exit code=1 (raw code=1 signal=null) duration=25s',
-  ]);
-  try {
-    const r = lf.readResultEvent(p);
-    expect(lf.classifyLaunchFailure(r)?.kind).toBe('model_config_rejected');
-    expect(lf.resultShowsRealTurn(r)).toBe(false);
-  } finally {
-    fs.rmSync(path.dirname(p), { recursive: true, force: true });
-  }
-});
-
-test('resultShowsRealTurn: true once a turn or any output token happened', () => {
-  expect(lf.resultShowsRealTurn({ numTurns: 1, outputTokens: 0 })).toBe(false);
-  expect(lf.resultShowsRealTurn({ numTurns: 2, outputTokens: 0 })).toBe(true);
-  expect(lf.resultShowsRealTurn({ numTurns: 1, outputTokens: 12 })).toBe(true);
-  expect(lf.resultShowsRealTurn(null)).toBe(false);
-});
-
-// ─── circuit breaker ────────────────────────────────────────────────────────
-
-const T0 = Date.parse('2026-09-02T18:00:00Z');
-
-test('armLaunchBlock: first failure opens with the kind backoff, a mitigation env, and an operator hint', () => {
-  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', httpStatus: 400, message: 'm', now: T0, claudeVersion: '1.0.90', slug: 'a', runId: 'r1' });
-  expect(b.attempts).toBe(1);
-  expect(b.exhausted).toBe(false);
-  expect(Date.parse(b.until) - T0).toBe(lf.backoffMsFor('model_config_rejected', 1));
-  expect(b.mitigationEnv).toEqual({ MAX_THINKING_TOKENS: '0' });
-  expect(b.hint).toMatch(/claude update/);
-  expect(b.claudeVersion).toBe('1.0.90');
-  expect(b.probing).toBeNull();
-});
-
-test('armLaunchBlock: repeated same-kind failures escalate, cap at 60 min, then exhaust (until=null)', () => {
-  let b = null;
-  const seen = [];
-  for (let i = 0; i < lf.LAUNCH_BLOCK_MAX_ATTEMPTS; i++) {
-    b = lf.armLaunchBlock(b, { kind: 'api_error', message: 'x', now: T0 + i * 1000 });
-    seen.push(b.until ? Date.parse(b.until) - (T0 + i * 1000) : null);
-  }
-  expect(b.attempts).toBe(lf.LAUNCH_BLOCK_MAX_ATTEMPTS);
-  expect(b.exhausted).toBe(true);
-  expect(b.until).toBeNull();
-  const finite = seen.filter((x) => x !== null);
-  for (let i = 1; i < finite.length; i++) expect(finite[i]).toBeGreaterThanOrEqual(finite[i - 1]);
-  expect(Math.max(...finite)).toBeLessThanOrEqual(60 * 60_000);
-  expect(b.since).toBe(new Date(T0).toISOString()); // first-failure time survives re-arming
-});
-
-test('armLaunchBlock: a different kind restarts the attempt count', () => {
-  const a = lf.armLaunchBlock(null, { kind: 'api_overloaded', message: 'x', now: T0 });
-  const b = lf.armLaunchBlock(a, { kind: 'api_overloaded', message: 'x', now: T0 + 1 });
-  const c = lf.armLaunchBlock(b, { kind: 'auth_failed', message: 'y', now: T0 + 2 });
-  expect(b.attempts).toBe(2);
-  expect(c.attempts).toBe(1);
-  expect(c.mitigationEnv).toBeNull();
-});
-
-test('evaluateLaunchGate: open → blocked during backoff → probe after → blocked while a probe is in flight', () => {
-  expect(lf.evaluateLaunchGate(null, { now: T0 }).state).toBe('open');
-  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: '1.0.90' });
-  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: '1.0.90' }).state).toBe('blocked');
-  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000 }).reason).toMatch(/re-probe in \d+ min/);
-  const afterBackoff = Date.parse(b.until) + 1;
-  expect(lf.evaluateLaunchGate(b, { now: afterBackoff, claudeVersion: '1.0.90' }).state).toBe('probe');
-  const probing = { ...b, probing: { slug: 'p', at: new Date(afterBackoff).toISOString() } };
-  const g = lf.evaluateLaunchGate(probing, { now: afterBackoff + 60_000, claudeVersion: '1.0.90' });
-  expect(g.state).toBe('blocked');
-  expect(g.reason).toMatch(/probe p in flight/);
-  // a probe that never reported back goes stale and the gate re-opens to a new probe
-  expect(lf.evaluateLaunchGate(probing, { now: afterBackoff + lf.LAUNCH_PROBE_STALE_MS + 1, claudeVersion: '1.0.90' }).state).toBe('probe');
-});
-
-test('evaluateLaunchGate: a CLI version change short-circuits the backoff (the real fix for issue #11)', () => {
-  const b = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: '1.0.90' });
-  const g = lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: '1.0.128' });
-  expect(g.state).toBe('open');
-  expect(g.reason).toMatch(/cli-version-changed/);
-  // unknown current version (probe failed) → no shortcut, backoff still holds
-  expect(lf.evaluateLaunchGate(b, { now: T0 + 1000, claudeVersion: null }).state).toBe('blocked');
-});
-
-test('evaluateLaunchGate: an exhausted block stays blocked until version change', () => {
-  let b = null;
-  for (let i = 0; i < lf.LAUNCH_BLOCK_MAX_ATTEMPTS; i++) b = lf.armLaunchBlock(b, { kind: 'auth_failed', message: 'x', now: T0, claudeVersion: 'v1' });
-  expect(lf.evaluateLaunchGate(b, { now: T0 + 365 * 24 * 3600_000, claudeVersion: 'v1' }).state).toBe('blocked');
-  expect(lf.evaluateLaunchGate(b, { now: T0 + 1, claudeVersion: 'v2' }).state).toBe('open');
-});
-
-test('launchBlockKeyFor: persona is the key, default when absent', () => {
-  expect(lf.launchBlockKeyFor({ agentType: 'dev-lead' })).toBe('dev-lead');
-  expect(lf.launchBlockKeyFor({})).toBe('default');
-  expect(lf.launchBlockKeyFor(null)).toBe('default');
-});
-
-test('deriveTerminalReason: closed-set taxonomy', () => {
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'completed', exitCode: 0 })).toBe('completed');
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'failed', exitCode: 1 })).toBe('impl_failed:exit_1');
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'failed', exitCode: 143 })).toBe('signal_kill');
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 143, sigtermOverride: { status: 'needs_review' } })).toBe('signal_kill_with_commit');
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 0, verifyResult: { verdict: 'silent_no_op' } })).toBe('verifier:silent_no_op');
-  expect(lf.deriveTerminalReason({ effectiveStatus: 'needs_review', exitCode: 0, worktreeIntegrationFailure: 'conflict' })).toBe('worktree_integration_failed');
-});
-
-test('writeOutcomeSidecar: writes <slug>.outcome.json atomically and never throws on a bad dir', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-outcome-'));
-  try {
-    const p = lf.writeOutcomeSidecar(dir, '12-foo', { numTurns: 1, outputTokens: 0, terminalReason: 'launch_failure:model_config_rejected' });
-    expect(p).toBe(path.join(dir, '12-foo.outcome.json'));
-    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
-    expect(parsed).toMatchObject({ slug: '12-foo', numTurns: 1, outputTokens: 0, terminalReason: 'launch_failure:model_config_rejected' });
-    expect(parsed.writtenAt).toMatch(/^\d{4}-/);
-    expect(fs.existsSync(`${p}.tmp`)).toBe(false);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-  expect(lf.writeOutcomeSidecar('/nonexistent/dir/for/sure', 'x', {})).toBeNull();
-  expect(lf.writeOutcomeSidecar(null, 'x', {})).toBeNull();
-});

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

@@ -1,303 +0,0 @@
-'use strict';
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/loadGate.test.cjs
-//
-// PRD 1085 — CPU-load launch gate. The static per-project cap
-// (schedulerBatchProjectCap.test.cjs) cannot see the feedback loop observed
-// 2026-09-01 on starry-night-ships: 4 Godot test batteries under Xvfb,
-// loadavg 12.95 / 14 cores = 0.93, every battery stretching past its
-// executor's timeout and spawning fix-chain reruns that launch more
-// batteries. These tests pin the pure decision, the audit rate-limit and the
-// escalation, with loadavg/cores/clock all injected.
-const assert = require('node:assert/strict');
-const { isLoadGated, createLoadGate, topCpuConsumers, AUDIT_INTERVAL_MS } = require('../loadGate.cjs');
-const { loadGateThreshold, LOAD_GATE_PER_CORE } = require('../schedulerConfig.cjs');
-
-const ORIGINAL_ENV = process.env.SM_LOAD_GATE_PER_CORE;
-afterEach(() => {
-  if (ORIGINAL_ENV === undefined) delete process.env.SM_LOAD_GATE_PER_CORE;
-  else process.env.SM_LOAD_GATE_PER_CORE = ORIGINAL_ENV;
-});
-
-// ─── isLoadGated ────────────────────────────────────────────────────────────
-
-test('the live incident shape gates: 12.95 / 14 cores = 0.93 > 0.85', () => {
-  assert.equal(isLoadGated(12.95, 14, 0.85), true);
-});
-
-test('below threshold does not gate', () => {
-  assert.equal(isLoadGated(5, 14, 0.85), false);
-});
-
-test('exactly AT threshold does not gate (strictly greater)', () => {
-  assert.equal(isLoadGated(0.85 * 14, 14, 0.85), false);
-});
-
-test('zero cores never gates (unknown topology must not wedge the queue)', () => {
-  assert.equal(isLoadGated(100, 0, 0.85), false);
-});
-
-test('loadavg [0,0,0] (Windows / unsupported) never gates', () => {
-  assert.equal(isLoadGated(0, 14, 0.85), false);
-});
-
-test('a disabled threshold (0) never gates regardless of load', () => {
-  assert.equal(isLoadGated(1000, 1, 0), false);
-});
-
-// ─── loadGateThreshold (env) ────────────────────────────────────────────────
-
-test('default threshold is the documented 0.85', () => {
-  delete process.env.SM_LOAD_GATE_PER_CORE;
-  assert.equal(LOAD_GATE_PER_CORE, 0.85);
-  assert.equal(loadGateThreshold(), 0.85);
-});
-
-test('SM_LOAD_GATE_PER_CORE is honored and clamped to [0.25, 4]; 0 disables; garbage falls back', () => {
-  process.env.SM_LOAD_GATE_PER_CORE = '1.5';
-  assert.equal(loadGateThreshold(), 1.5);
-  process.env.SM_LOAD_GATE_PER_CORE = '0.01';
-  assert.equal(loadGateThreshold(), 0.25);
-  process.env.SM_LOAD_GATE_PER_CORE = '99';
-  assert.equal(loadGateThreshold(), 4);
-  process.env.SM_LOAD_GATE_PER_CORE = '0';
-  assert.equal(loadGateThreshold(), 0);
-  process.env.SM_LOAD_GATE_PER_CORE = 'banana';
-  assert.equal(loadGateThreshold(), 0.85);
-});
-
-// ─── topCpuConsumers: platform-correct ps invocation ───────────────────────
-//
-// The audit line the scheduler warn-logs when the load gate escalates. Purely
-// diagnostic (nothing branches on it) but it was blank on macOS: the code only
-// ran the GNU `ps --sort` form, which BSD ps rejects with "illegal option",
-// so every Mac logged `top CPU: n/a` exactly when the operator needed to know
-// what was saturating the box.
-
-test('Linux uses the GNU ps form (-eo … --sort=-pcpu) and skips the header row', () => {
-  const calls = [];
-  const fakeExec = (bin, args) => {
-    calls.push({ bin, args });
-    return 'PID %CPU COMMAND\n  1 90.0 node\n  2 10.0 tsc\n';
-  };
-  const rows = topCpuConsumers(2, { execImpl: fakeExec, platform: 'linux' });
-  assert.deepEqual(calls[0], { bin: 'ps', args: ['-eo', 'pid,pcpu,comm', '--sort=-pcpu'] });
-  assert.deepEqual(rows, ['1 90.0 node', '2 10.0 tsc']);
-});
-
-test('macOS uses the BSD ps form (-Aco … -r), NOT the GNU --sort that BSD ps rejects', () => {
-  const calls = [];
-  const fakeExec = (bin, args) => {
-    calls.push({ bin, args });
-    return '  PID %CPU COMM\n  847 94.4 suggestd\n  443 15.1 WindowServer\n';
-  };
-  const rows = topCpuConsumers(3, { execImpl: fakeExec, platform: 'darwin' });
-  assert.deepEqual(calls[0].args, ['-Aco', 'pid,pcpu,comm', '-r']);
-  assert.ok(!calls[0].args.some((a) => String(a).includes('--sort')), 'must not pass the GNU --sort to BSD ps');
-  assert.deepEqual(rows, ['847 94.4 suggestd', '443 15.1 WindowServer']);
-});
-
-test('an unsupported platform returns [] without ever spawning ps', () => {
-  let spawned = false;
-  const rows = topCpuConsumers(3, { execImpl: () => { spawned = true; return ''; }, platform: 'win32' });
-  assert.deepEqual(rows, []);
-  assert.equal(spawned, false);
-});
-
-test('a ps failure (throw) degrades to [] rather than propagating — the audit line is best-effort', () => {
-  const rows = topCpuConsumers(3, { execImpl: () => { throw new Error('boom'); }, platform: 'darwin' });
-  assert.deepEqual(rows, []);
-});
-
-// ─── createLoadGate: decision, 1-minute-only, bypass ───────────────────────
-
-function gateWith({ l1 = 12.95, l5 = 0, l15 = 0, cores = 14, threshold = 0.85, clock }) {
-  let t = clock ?? 0;
-  const g = createLoadGate({
-    loadavg: () => [l1, l5, l15],
-    cores: () => cores,
-    now: () => t,
-    threshold,
-  });
-  return { g, tick: (ms) => { t += ms; } };
-}
-
-test('evaluate() gates on the incident shape and reports ratio/threshold', () => {
-  const { g } = gateWith({});
-  const r = g.evaluate();
-  assert.equal(r.gated, true);
-  assert.equal(r.bypassed, false);
-  assert.equal(r.ratio, 0.925);
-  assert.equal(r.threshold, 0.85);
-  assert.equal(r.loadavg1, 12.95);
-  assert.equal(r.cores, 14);
-});
-
-test('only the 1-minute average is consulted — a saturated 5/15-minute history with a quiet last minute launches', () => {
-  const { g } = gateWith({ l1: 2, l5: 13, l15: 13 });
-  assert.equal(g.evaluate().gated, false);
-});
-
-test('an explicit Run now bypasses the gate but records that it did', () => {
-  const { g } = gateWith({});
-  const r = g.evaluate({ bypass: true });
-  assert.equal(r.gated, false);
-  assert.equal(r.bypassed, true);
-});
-
-test('bypass on an UNgated tick is not reported as a bypass', () => {
-  const { g } = gateWith({ l1: 1 });
-  const r = g.evaluate({ bypass: true });
-  assert.deepEqual([r.gated, r.bypassed], [false, false]);
-});
-
-// ─── audit rate limit + escalation (fake clock) ─────────────────────────────
-
-test('audits once, then not again until AUDIT_INTERVAL_MS has elapsed', () => {
-  const { g, tick } = gateWith({});
-  assert.equal(g.evaluate().shouldAudit, true, 'first gated tick audits');
-  tick(60_000);
-  assert.equal(g.evaluate().shouldAudit, false, '1 min later: silent');
-  tick(AUDIT_INTERVAL_MS - 60_000 - 1);
-  assert.equal(g.evaluate().shouldAudit, false, 'just under the interval: silent');
-  tick(1);
-  assert.equal(g.evaluate().shouldAudit, true, 'at the interval: audits again');
-});
-
-test('an ungated tick never audits', () => {
-  const { g } = gateWith({ l1: 1 });
-  assert.equal(g.evaluate().shouldAudit, false);
-});
-
-test('escalates once the gated stretch exceeds the escalation window, and the stretch only resets once load has stayed sub-threshold past the release window', () => {
-  let l1 = 12.95;
-  let t = 0;
-  const g = createLoadGate({
-    loadavg: () => [l1, 0, 0],
-    cores: () => 14,
-    now: () => t,
-    threshold: 0.85,
-    escalateAfterMs: 45 * 60_000,
-    releaseWindowMs: 2 * 60_000,
-  });
-  assert.equal(g.evaluate().escalate, false);
-  t += 44 * 60_000;
-  assert.equal(g.evaluate().escalate, false, 'under 45m: no escalation');
-  t += 60_000;
-  const r = g.evaluate();
-  assert.equal(r.escalate, true, 'at 45m: escalates');
-  assert.equal(r.gatedSinceMs, 45 * 60_000);
-  // A single sub-threshold sample must NOT reset the stretch (the boundary-
-  // hovering bug this PRD fixes) — gatedSinceMs keeps growing.
-  l1 = 1; t += 60_000;
-  const oneMinBelow = g.evaluate();
-  assert.equal(oneMinBelow.gated, false, 'gate decision is immediate');
-  assert.equal(oneMinBelow.gatedSinceMs, 46 * 60_000, 'stretch not yet released');
-  // Load climbs back above threshold before the release window elapses: the
-  // stretch was never actually cleared, so it just keeps accumulating.
-  l1 = 12.95; t += 30_000;
-  assert.equal(g.evaluate().gatedSinceMs, 46 * 60_000 + 30_000, 'stretch survived the brief dip');
-  // Now hold sub-threshold continuously past the release window (the window
-  // is measured from the first sub-threshold sample of this sustained drop,
-  // so it takes a tick to mark that start, then another once the window has
-  // actually elapsed).
-  l1 = 1; t += 1;
-  g.evaluate();
-  t += 2 * 60_000;
-  assert.equal(g.evaluate().gatedSinceMs, 0, 'sustained sub-threshold load past the release window clears the stretch');
-  l1 = 12.95; t += 60_000;
-  assert.equal(g.evaluate().gatedSinceMs, 0, 'a fresh stretch starts from zero');
-});
-
-test('the gate decision itself is unaffected by hysteresis: a sub-threshold tick is never gated, even mid-stretch', () => {
-  let l1 = 12.95;
-  let t = 0;
-  const g = createLoadGate({
-    loadavg: () => [l1, 0, 0],
-    cores: () => 14,
-    now: () => t,
-    threshold: 0.85,
-    releaseWindowMs: 5 * 60_000,
-  });
-  assert.equal(g.evaluate().gated, true);
-  l1 = 1; t += 60_000;
-  assert.equal(g.evaluate().gated, false, 'below threshold: gated:false immediately, hysteresis notwithstanding');
-});
-
-test('snapshot() reflects the last evaluation and is null before any', () => {
-  const { g } = gateWith({});
-  assert.equal(g.snapshot(), null);
-  g.evaluate();
-  const s = g.snapshot();
-  assert.equal(s.gated, true);
-  assert.equal(typeof s.at, 'string');
-  assert.equal('shouldAudit' in s, false, 'per-tick flags are not part of the persisted snapshot');
-});
-
-test('snapshot() exposes gated, ratio, threshold, loadavg1, cores and gatedSinceMs (what buildScheduleStatePayload surfaces as loadGate)', () => {
-  const { g } = gateWith({});
-  g.evaluate();
-  const s = g.snapshot();
-  assert.equal(typeof s.gated, 'boolean');
-  assert.equal(typeof s.ratio, 'number');
-  assert.equal(typeof s.threshold, 'number');
-  assert.equal(typeof s.loadavg1, 'number');
-  assert.equal(typeof s.cores, 'number');
-  assert.equal(typeof s.gatedSinceMs, 'number');
-});
-
-// ─── hysteresis: the real observed boundary-hovering sequence ──────────────
-
-test('a boundary-hovering box (real observed sequence, alternating above/below threshold) grows gatedSinceMs monotonically across 50 simulated minutes and eventually escalates', () => {
-  // 14 cores, 0.85/core = 11.9 threshold; loadavg1 observed 2026-09-12
-  // oscillating 11.07 - 13.31, straddling the threshold every tick. Before
-  // this PRD, the immediate reset on ANY sub-threshold sample meant every
-  // one of these ticks reset gatedSince to null and escalate never fired.
-  const CORES = 14;
-  const THRESHOLD = 0.85;
-  const SEQUENCE = [11.07, 13.31, 11.51, 12.8];
-  let l1 = SEQUENCE[0];
-  let t = 0;
-  const g = createLoadGate({
-    loadavg: () => [l1, 0, 0],
-    cores: () => CORES,
-    now: () => t,
-    threshold: THRESHOLD,
-    escalateAfterMs: 20 * 60_000, // shorter than the 45m default so 50 sim-minutes crosses it
-  });
-
-  const TICK_MS = 60_000;
-  const TOTAL_MS = 50 * 60_000;
-  let prevGatedSinceMs = -1;
-  let sawEscalate = false;
-  let i = 0;
-  for (let elapsed = 0; elapsed < TOTAL_MS; elapsed += TICK_MS) {
-    l1 = SEQUENCE[i % SEQUENCE.length];
-    i += 1;
-    const r = g.evaluate();
-    assert.ok(r.gatedSinceMs >= prevGatedSinceMs, `gatedSinceMs must not shrink (was ${prevGatedSinceMs}, now ${r.gatedSinceMs})`);
-    prevGatedSinceMs = r.gatedSinceMs;
-    if (r.escalate) sawEscalate = true;
-    t += TICK_MS;
-  }
-  assert.equal(sawEscalate, true, 'escalate must fire once the (never-reset) stretch exceeds escalateAfterMs');
-});
-
-test('the release window actually releases: sustained sub-threshold load past the window reports gated:false and gatedSinceMs:0 on the next tick', () => {
-  let l1 = 13.31;
-  let t = 0;
-  const g = createLoadGate({
-    loadavg: () => [l1, 0, 0],
-    cores: () => 14,
-    now: () => t,
-    threshold: 0.85,
-    releaseWindowMs: 2 * 60_000,
-  });
-  assert.equal(g.evaluate().gated, true);
-  l1 = 5;
-  t += 1;
-  g.evaluate(); // marks the start of the sustained sub-threshold run
-  t += 2 * 60_000;
-  const r = g.evaluate();
-  assert.equal(r.gated, false);
-  assert.equal(r.gatedSinceMs, 0);
-});