@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/bun-polyfill.test.ts

@@ -1,402 +0,0 @@
-import { describe, test, expect, afterAll, setDefaultTimeout } from 'bun:test';
-import * as path from 'path';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-
-// Every test here spawnSync's a `node` child; Windows CI cold-start (AV scan,
-// first-touch of node.exe) alone can blow bun's 5s default — observed 5,007ms
-// on a 50ms sleep test. 20s was still not enough: on 2026-08-26 (PR #2700,
-// run 32989821401) the 50ms sleep test blew 20s on BOTH bun retry attempts on
-// a degraded windows-latest runner, so cold-start alone doesn't explain it —
-// sustained AV/runner pressure does. Subprocess budget, not assertion
-// looseness: every assertion still checks exact output, only the slowness
-// allowance grows.
-setDefaultTimeout(60_000);
-
-// Load the polyfill into a fresh object (don't clobber globalThis.Bun)
-const polyfillPath = path.resolve(import.meta.dir, '../src/bun-polyfill.cjs');
-
-describe('bun-polyfill', () => {
-  // We test the polyfill by requiring it in a subprocess under Node.js
-  // since it's designed for Node, not Bun.
-
-  test('Bun.sleep resolves after delay', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const start = Date.now();
-        await Bun.sleep(50);
-        const elapsed = Date.now() - start;
-        console.log(elapsed >= 40 ? 'OK' : 'TOO_FAST');
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('OK');
-    expect(result.exitCode).toBe(0);
-  });
-
-  test('Bun.spawnSync runs a command and returns stdout', () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      const r = Bun.spawnSync(['echo', 'hello'], { stdout: 'pipe' });
-      console.log(r.stdout.toString().trim());
-      console.log('exit:' + r.exitCode);
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    const lines = result.stdout.toString().trim().split('\n');
-    expect(lines[0]).toBe('hello');
-    expect(lines[1]).toBe('exit:0');
-  });
-
-  test('Bun.spawn launches a process with pid', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      const p = Bun.spawn(['echo', 'test'], { stdio: ['pipe', 'pipe', 'pipe'] });
-      console.log(typeof p.pid === 'number' ? 'HAS_PID' : 'NO_PID');
-      console.log(typeof p.kill === 'function' ? 'HAS_KILL' : 'NO_KILL');
-      console.log(typeof p.unref === 'function' ? 'HAS_UNREF' : 'NO_UNREF');
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    const lines = result.stdout.toString().trim().split('\n');
-    expect(lines[0]).toBe('HAS_PID');
-    expect(lines[1]).toBe('HAS_KILL');
-    expect(lines[2]).toBe('HAS_UNREF');
-  });
-
-  // Bun.spawn parity: `proc.exited` is a Promise resolving to the exit code.
-  // The DPAPI helper and isBrowserRunning both `await proc.exited`; without
-  // it the awaits resolve immediately to `undefined` and the caller reads
-  // stdout before the child has produced it — surfacing as a silent failure.
-  test('Bun.spawn exposes proc.exited that resolves to the exit code', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const p = Bun.spawn(['node', '-e', 'process.exit(0)'], { stdio: ['ignore', 'ignore', 'ignore'] });
-        console.log(typeof p.exited === 'object' && typeof p.exited.then === 'function' ? 'IS_PROMISE' : 'NOT_PROMISE');
-        console.log('exit:' + await p.exited);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    const lines = result.stdout.toString().trim().split('\n');
-    expect(lines[0]).toBe('IS_PROMISE');
-    expect(lines[1]).toBe('exit:0');
-  });
-
-  test('Bun.spawn proc.exited reflects non-zero exit codes', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const p = Bun.spawn(['node', '-e', 'process.exit(3)'], { stdio: ['ignore', 'ignore', 'ignore'] });
-        console.log('exit:' + await p.exited);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('exit:3');
-  });
-
-  test('Bun.spawn proc.exited resolves before reading stdout (no race)', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        // Real-world pattern: write to stdout, then exit. Awaiting proc.exited
-        // before reading must guarantee the bytes are flushed.
-        const p = Bun.spawn(['node', '-e', 'process.stdout.write("ready"); process.exit(0)'], {
-          stdio: ['ignore', 'pipe', 'ignore']
-        });
-        const code = await p.exited;
-        const out = await new Response(p.stdout).text();
-        console.log(out + ':' + code);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('ready:0');
-  });
-
-  // Spawn-failure case: Node emits 'error' but not 'exit' when the binary
-  // is missing, so listening only for 'exit' hangs `await proc.exited`
-  // forever. The lifecycle promise must resolve on either event.
-  test('Bun.spawn proc.exited resolves on spawn failure (missing binary)', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const p = Bun.spawn(['this-binary-does-not-exist-zzz-' + Date.now()], {
-          stdio: ['ignore', 'pipe', 'pipe']
-        });
-        let deadline;
-        const code = await Promise.race([
-          p.exited,
-          new Promise((_, r) => { deadline = setTimeout(() => r(new Error('timeout')), 3000); })
-        ]).catch(() => 'TIMEOUT').finally(() => clearTimeout(deadline));
-        console.log('exit:' + code);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    // Anything other than 'TIMEOUT' (and ideally a non-zero number) means the
-    // lifecycle promise resolved on the spawn error.
-    const out = result.stdout.toString().trim();
-    expect(out).not.toBe('exit:TIMEOUT');
-    expect(out).toMatch(/^exit:\d+$/);
-  });
-
-  // Signal-exit branch: Bun reports 128 + signal number when a child is killed
-  // by a signal (code === null). Skipped on Windows, whose kill() semantics
-  // don't produce the POSIX 128+n mapping.
-  test.skipIf(process.platform === 'win32')('Bun.spawn proc.exited maps a killing signal to 128+signal', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const p = Bun.spawn(['node', '-e', 'setInterval(() => {}, 1000)'], { stdio: ['ignore', 'ignore', 'ignore'] });
-        setTimeout(() => p.kill('SIGTERM'), 150);
-        console.log('exit:' + await p.exited);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    // SIGTERM = 15 → 128 + 15 = 143.
-    expect(result.stdout.toString().trim()).toBe('exit:143');
-  });
-
-  // GSTACK_SPAWN_MAX_BUFFER caps the drain so a runaway child can't OOM the
-  // server. Past the cap, the pipe keeps flowing (child doesn't block) but
-  // further bytes are dropped. Set a small cap, write more than that, assert
-  // the captured stdout equals the cap and the child exits cleanly.
-  test('Bun.spawn caps buffered output at GSTACK_SPAWN_MAX_BUFFER', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      process.env.GSTACK_SPAWN_MAX_BUFFER = '${1024}';
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        // Child writes 10 KB; cap is 1 KB; drained output should be exactly 1 KB
-        // and exit should still resolve cleanly (child not back-pressured to death).
-        const p = Bun.spawn(
-          ['node', '-e', 'process.stdout.write("y".repeat(10 * 1024)); process.exit(0)'],
-          { stdio: ['ignore', 'pipe', 'ignore'] }
-        );
-        let deadline;
-        const code = await Promise.race([
-          p.exited,
-          new Promise((_, r) => { deadline = setTimeout(() => r(new Error('timeout')), 3000); })
-        ]).catch(() => 'TIMEOUT').finally(() => clearTimeout(deadline));
-        const out = await new Response(p.stdout).text();
-        console.log(out.length + ':' + code);
-      })();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('1024:0');
-  });
-
-  // Regression for the pipe-blocking case: if the child writes more than the
-  // OS pipe buffer (~16-64 KB) and the polyfill doesn't drain eagerly, the
-  // child blocks in write() and `exit` never fires. 1 MB is well past every
-  // OS pipe buffer size. Pre-fix this test hangs forever; post-fix it returns
-  // in <500ms. Bun's default per-test timeout is 5s — generous here.
-  test('Bun.spawn drains large stdout so proc.exited still resolves', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      (async () => {
-        const ONE_MB = 1024 * 1024;
-        // Exit in the write callback, not straight after write(): on modern
-        // Node a pipe write past the OS buffer is async, and process.exit()
-        // right after write() truncates at ~64 KB even with a live reader.
-        // The callback only fires once the full MB is flushed — which still
-        // requires the parent to drain, so the regression (no eager drain →
-        // child blocks → timeout) is still caught.
-        const p = Bun.spawn(
-          ['node', '-e', 'process.stdout.write("x".repeat(' + ONE_MB + '), () => process.exit(0))'],
-          { stdio: ['ignore', 'pipe', 'ignore'] }
-        );
-        let deadline;
-        const code = await Promise.race([
-          p.exited,
-          new Promise((_, r) => { deadline = setTimeout(() => r(new Error('timeout')), 10000); })
-        ]).catch(e => 'TIMEOUT').finally(() => clearTimeout(deadline));
-        const out = await new Response(p.stdout).text();
-        console.log(out.length + ':' + code);
-      })().catch((e) => { console.log('THREW:' + e.message); });
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('1048576:0');
-  }, 15000);
-
-  test('cancelled replay readers release inherited pipes after the direct child exits', () => {
-    const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'polyfill-cancel-')));
-    const marker = path.join(root, 'descendant.pid');
-    const pidPath = path.join(root, 'spawned.pid');
-    expect(fs.realpathSync(root)).toBe(root);
-    try {
-      const descendantScript = `
-        const fs = require('node:fs');
-        fs.writeSync(1, 'fixture-stdout');
-        fs.writeSync(2, 'fixture-stderr');
-        fs.writeFileSync(${JSON.stringify(marker + '.tmp')}, JSON.stringify({ pid: process.pid, stdout: true, stderr: true }));
-        fs.renameSync(${JSON.stringify(marker + '.tmp')}, ${JSON.stringify(marker)});
-        setInterval(() => {}, 1000);
-      `;
-      const childScript = `
-        const { spawn } = require('node:child_process');
-        const fs = require('node:fs');
-        const descendant = spawn(process.execPath, ['-e', ${JSON.stringify(descendantScript)}],
-          { stdio: ['ignore', 'inherit', 'inherit'], windowsHide: true, detached: process.platform === 'win32' });
-        fs.writeFileSync(${JSON.stringify(pidPath)}, String(descendant.pid));
-        const deadline = Date.now() + 5000;
-        const ready = () => {
-          if (fs.existsSync(${JSON.stringify(marker)})) process.exit(0);
-          if (descendant.exitCode !== null || Date.now() >= deadline) process.exit(1);
-          setTimeout(ready, 10);
-        };
-        ready();
-      `;
-      const script = `
-        const childProcess = require('node:child_process');
-        const originalSpawn = childProcess.spawn;
-        let direct;
-        childProcess.spawn = (...args) => { direct = originalSpawn(...args); return direct; };
-        require(${JSON.stringify(polyfillPath)});
-        let stage = 'spawn';
-        let directExitCode;
-        let markerValid = false;
-        let stdoutAck = false;
-        let stderrAck = false;
-        let descendantAlive = false;
-        let checkErrorCode = null;
-        (async () => {
-          const proc = Bun.spawn([process.execPath, '-e', ${JSON.stringify(childScript)}],
-            { stdio: ['ignore', 'pipe', 'pipe'] });
-          if (!direct) throw new Error('capture_missing');
-          const stdout = proc.stdout.getReader();
-          const stderr = proc.stderr.getReader();
-          const stdoutRead = stdout.read();
-          const stderrRead = stderr.read();
-          stage = 'direct_exit';
-          directExitCode = await new Promise((resolve, reject) => { direct.once('exit', resolve); direct.once('error', reject); });
-          let readyPid;
-          try {
-            const fs = require('node:fs');
-            const marker = JSON.parse(fs.readFileSync(${JSON.stringify(marker)}, 'utf8'));
-            readyPid = marker.pid;
-            markerValid = Number.isSafeInteger(readyPid) && readyPid > 0
-              && String(readyPid) === fs.readFileSync(${JSON.stringify(pidPath)}, 'utf8');
-            stdoutAck = marker.stdout === true;
-            stderrAck = marker.stderr === true;
-          } catch (error) { checkErrorCode = typeof error.code === 'string' ? error.code : 'invalid_marker'; }
-          if (markerValid) {
-            try { process.kill(readyPid, 0); descendantAlive = true; }
-            catch (error) { checkErrorCode = typeof error.code === 'string' ? error.code : 'liveness_error'; }
-          }
-          if (!markerValid || !stdoutAck || !stderrAck || !descendantAlive) throw new Error('descendant_not_ready');
-          stage = 'pending_check';
-          await new Promise(resolve => setImmediate(resolve));
-          let settled = false;
-          proc.exited.then(() => { settled = true; });
-          await new Promise(resolve => setImmediate(resolve));
-          if (settled) throw new Error('Inherited pipes unexpectedly closed before cancellation');
-          stage = 'cancel';
-          await Promise.all([stdout.cancel(), stderr.cancel()]);
-          const reads = await Promise.all([stdoutRead, stderrRead]);
-          stage = 'await_exited';
-          let timer;
-          const code = await Promise.race([proc.exited, new Promise((_, reject) =>
-            { timer = setTimeout(() => reject(new Error('cancel did not settle exited')), 5000); })])
-            .finally(() => clearTimeout(timer));
-          console.log(JSON.stringify({ code, directExitCode, reads: reads.map(read => read.done), descendantAlive: (() => {
-            try { process.kill(JSON.parse(require('node:fs').readFileSync(${JSON.stringify(marker)}, 'utf8')).pid, 0); return true; }
-            catch { return false; }
-          })() }));
-        })().catch(error => {
-          const reason = error.message === 'Inherited pipes unexpectedly closed before cancellation' ? 'early_pipes'
-            : error.message === 'cancel did not settle exited' ? 'cancel_stalled'
-            : error.message === 'capture_missing' ? 'capture_missing'
-            : error.message === 'descendant_not_ready' ? 'descendant_not_ready' : 'unexpected';
-          console.error(JSON.stringify({ stage, reason, directExitCode, markerValid, stdoutAck, stderrAck,
-            descendantAlive, checkErrorCode, errorCode: typeof error.code === 'string' ? error.code : null }));
-          process.exitCode = 1;
-        });
-      `;
-      const result = Bun.spawnSync(['node', '-e', script], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-      const errorOutput = result.stderr.toString().trim();
-      let diagnostic: object | null = null;
-      try { if (errorOutput) diagnostic = JSON.parse(errorOutput); }
-      catch { diagnostic = { stage: 'unframed', stderrBytes: Buffer.byteLength(errorOutput) }; }
-      expect({ exitCode: result.exitCode, diagnostic }).toEqual({ exitCode: 0, diagnostic: null });
-      expect(JSON.parse(result.stdout.toString())).toEqual({ code: 0, directExitCode: 0, reads: [true, true], descendantAlive: true });
-    } finally {
-      if (fs.existsSync(pidPath)) {
-        const pidText = fs.readFileSync(pidPath, 'utf8');
-        if (/^[1-9]\d*$/.test(pidText)) {
-          try { process.kill(Number(pidText)); } catch (error: any) { if (error.code !== 'ESRCH') throw error; }
-        }
-      }
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('Bun.serve creates an HTTP server that responds', async () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      require(${JSON.stringify(polyfillPath)});
-      const server = Bun.serve({
-        port: 0,  // Note: polyfill uses port directly, so we pick one
-        hostname: '127.0.0.1',
-        fetch(req) {
-          return new Response(JSON.stringify({ ok: true }), {
-            headers: { 'Content-Type': 'application/json' },
-          });
-        },
-      });
-      // The polyfill doesn't support port 0, so we test the object shape
-      console.log(typeof server.stop === 'function' ? 'HAS_STOP' : 'NO_STOP');
-      console.log(typeof server.port === 'number' ? 'HAS_PORT' : 'NO_PORT');
-      server.stop();
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    const lines = result.stdout.toString().trim().split('\n');
-    expect(lines[0]).toBe('HAS_STOP');
-    expect(lines[1]).toBe('HAS_PORT');
-  });
-
-  // windowsHide is the one option where Node's default is the opposite of
-  // Bun's: Node shows the child's console window, Bun hides it. Dropping it
-  // in translation makes every spawned child pop a window on Windows, which
-  // is the platform this whole file exists for. Both shims are covered, and
-  // an explicit windowsHide:false must survive forwarding (#2523 + #2539).
-  test('Bun.spawn defaults windowsHide to true', () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      const cp = require('child_process');
-      const orig = cp.spawn;
-      let seen;
-      cp.spawn = (c, a, o) => { seen = o; return orig(c, a, o); };
-      require(${JSON.stringify(polyfillPath)});
-      Bun.spawn(['node', '-e', ''], { stdio: ['ignore', 'ignore', 'ignore'] });
-      console.log('windowsHide:' + seen.windowsHide);
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('windowsHide:true');
-  });
-
-  test('Bun.spawnSync defaults windowsHide to true', () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      const cp = require('child_process');
-      const orig = cp.spawnSync;
-      let seen;
-      cp.spawnSync = (c, a, o) => { seen = o; return orig(c, a, o); };
-      require(${JSON.stringify(polyfillPath)});
-      Bun.spawnSync(['node', '-e', '']);
-      console.log('windowsHide:' + seen.windowsHide);
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('windowsHide:true');
-  });
-
-  // #2637: a non-detached Windows child is killed with its parent's job, so
-  // the shim must forward detached instead of dropping it.
-  test('Bun.spawn forwards detached and leaves it off by default', () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      const cp = require('child_process');
-      const orig = cp.spawn;
-      const seen = [];
-      cp.spawn = (c, a, o) => { seen.push(o.detached); return orig(c, a, o); };
-      require(${JSON.stringify(polyfillPath)});
-      Bun.spawn(['node', '-e', ''], { stdio: ['ignore', 'ignore', 'ignore'], detached: true });
-      Bun.spawn(['node', '-e', ''], { stdio: ['ignore', 'ignore', 'ignore'] });
-      console.log('detached:' + seen.join(','));
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('detached:true,false');
-  });
-
-  test('an explicit windowsHide:false is honored', () => {
-    const result = Bun.spawnSync(['node', '-e', `
-      const cp = require('child_process');
-      const orig = cp.spawn;
-      let seen;
-      cp.spawn = (c, a, o) => { seen = o; return orig(c, a, o); };
-      require(${JSON.stringify(polyfillPath)});
-      Bun.spawn(['node', '-e', ''], { stdio: ['ignore', 'ignore', 'ignore'], windowsHide: false });
-      console.log('windowsHide:' + seen.windowsHide);
-    `], { stdout: 'pipe', stderr: 'pipe', timeout: 30_000 });
-    expect(result.stdout.toString().trim()).toBe('windowsHide:false');
-  });
-});

package/.agent/skills/gstack-browse/test/busy-daemon-iron-rule.test.ts

@@ -1,270 +0,0 @@
-/**
- * #2219 IRON RULE regression tests (E5): an alive daemon pid is NEVER
- * auto-killed. Killing a live daemon loses the session's tabs, cookies, and
- * logins — strictly worse than a slow command. Only an explicit
- * --force-restart may replace a live daemon.
- *
- * Integration legs follow the busy-daemon-recovery.test.ts pattern: a fake
- * HTTP daemon + a live `sleep` child standing in for the daemon PID, wired
- * through BROWSE_STATE_FILE. Unit legs pin the pure decision function.
- */
-
-import { describe, test, expect, afterEach } from 'bun:test';
-import { spawn, type ChildProcess } from 'child_process';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import * as http from 'http';
-import { isProcessAlive } from '../src/error-handling';
-import { decideDaemonRestart, HEALTH_PROBE_TOTAL_BUDGET_MS } from '../src/cli';
-
-// ─── Unit: the pure restart decision (decision 9 / F10) ──────────────────
-
-describe('decideDaemonRestart (pure)', () => {
-  test('healthy after probe → retry against the SAME daemon', () => {
-    expect(decideDaemonRestart({ pidAlive: true, healthyAfterProbe: true, forceRestart: false }))
-      .toBe('retry-command');
-    // Even with --force-restart in hand, a healthy daemon is retried, not killed.
-    expect(decideDaemonRestart({ pidAlive: true, healthyAfterProbe: true, forceRestart: true }))
-      .toBe('retry-command');
-  });
-
-  test('IRON RULE: alive + unhealthy + no flag → report busy, never kill', () => {
-    expect(decideDaemonRestart({ pidAlive: true, healthyAfterProbe: false, forceRestart: false }))
-      .toBe('report-busy');
-  });
-
-  test('alive + unhealthy + explicit --force-restart → force-restart', () => {
-    expect(decideDaemonRestart({ pidAlive: true, healthyAfterProbe: false, forceRestart: true }))
-      .toBe('force-restart');
-  });
-
-  test('dead pid → restart, with or without the flag', () => {
-    expect(decideDaemonRestart({ pidAlive: false, healthyAfterProbe: false, forceRestart: false }))
-      .toBe('restart-dead');
-    expect(decideDaemonRestart({ pidAlive: false, healthyAfterProbe: false, forceRestart: true }))
-      .toBe('restart-dead');
-  });
-
-  test('probe budget is ~8s (F10) — long enough for heavy-page busy windows', () => {
-    expect(HEALTH_PROBE_TOTAL_BUDGET_MS).toBeGreaterThanOrEqual(7_000);
-    expect(HEALTH_PROBE_TOTAL_BUDGET_MS).toBeLessThanOrEqual(10_000);
-  });
-});
-
-// ─── Integration: real spawned CLI vs fake daemons ───────────────────────
-
-/** A daemon whose /health always answers healthy but never serves /command. */
-async function startHealthyDaemon(): Promise<{ port: number; close: () => Promise<void> }> {
-  const server = http.createServer((req, res) => {
-    if (req.url === '/health') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'healthy' }));
-      return;
-    }
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end('ok');
-  });
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(0, '127.0.0.1', () => resolve());
-  });
-  const addr = server.address();
-  if (!addr || typeof addr === 'string') throw new Error('fake daemon: bad address');
-  return { port: addr.port, close: () => new Promise((r) => server.close(() => r())) };
-}
-
-/** A WEDGED daemon: alive socket, but /health always answers unhealthy. */
-async function startWedgedDaemon(): Promise<{ port: number; close: () => Promise<void> }> {
-  const server = http.createServer((req, res) => {
-    res.writeHead(503, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ status: 'wedged' }));
-  });
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(0, '127.0.0.1', () => resolve());
-  });
-  const addr = server.address();
-  if (!addr || typeof addr === 'string') throw new Error('fake daemon: bad address');
-  return { port: addr.port, close: () => new Promise((r) => server.close(() => r())) };
-}
-
-function runCli(args: string[], env: Record<string, string>, timeoutMs = 30_000):
-  Promise<{ code: number; stdout: string; stderr: string }> {
-  const cliPath = path.resolve(import.meta.dir, '../src/cli.ts');
-  return new Promise((resolve) => {
-    const proc = spawn('bun', ['run', cliPath, ...args], { timeout: timeoutMs, env });
-    let stdout = ''; let stderr = '';
-    proc.stdout.on('data', (d) => stdout += d.toString());
-    proc.stderr.on('data', (d) => stderr += d.toString());
-    proc.on('close', (code) => resolve({ code: code ?? 1, stdout, stderr }));
-  });
-}
-
-function baseEnv(stateFile: string): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const [k, v] of Object.entries(process.env)) {
-    if (v !== undefined) env[k] = v;
-  }
-  env.BROWSE_STATE_FILE = stateFile;
-  return env;
-}
-
-let pidChild: ChildProcess | null = null;
-afterEach(() => { pidChild?.kill('SIGKILL'); pidChild = null; });
-
-describe('#2219 iron rule (CLI integration)', () => {
-  test('healthy daemon SURVIVES `browse connect` — refused with guidance, no kill', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-iron-'));
-    const stateFile = path.join(tmpDir, 'browse.json');
-    const daemon = await startHealthyDaemon();
-    try {
-      pidChild = spawn('sleep', ['60'], { stdio: 'ignore' });
-      const daemonPid = pidChild.pid!;
-      const stateContent = {
-        pid: daemonPid,
-        port: daemon.port,
-        token: 'iron-rule-token',
-        startedAt: new Date().toISOString(),
-        serverPath: '',
-        mode: 'launched' as const,
-      };
-      fs.writeFileSync(stateFile, JSON.stringify(stateContent, null, 2));
-
-      const result = await runCli(['connect'], baseEnv(stateFile));
-
-      expect(result.code).not.toBe(0);
-      expect(result.stderr).toContain('healthy daemon is already running');
-      expect(result.stderr).toContain('--force-restart');
-      // THE IRON RULE: the daemon process was not killed.
-      expect(isProcessAlive(daemonPid)).toBe(true);
-      // And the state file was not clobbered.
-      expect(JSON.parse(fs.readFileSync(stateFile, 'utf-8'))).toEqual(stateContent);
-    } finally {
-      await daemon.close();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  }, 30_000);
-
-  test('pair-agent over a live headless daemon WITHOUT --force-restart → daemon survives, notice printed, no headed relaunch', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-iron-'));
-    const stateFile = path.join(tmpDir, 'browse.json');
-    const daemon = await startHealthyDaemon();
-    try {
-      pidChild = spawn('sleep', ['60'], { stdio: 'ignore' });
-      const daemonPid = pidChild.pid!;
-      const stateContent = {
-        pid: daemonPid,
-        port: daemon.port,
-        token: 'iron-rule-token',
-        startedAt: new Date().toISOString(),
-        serverPath: '',
-        mode: 'launched' as const,
-      };
-      fs.writeFileSync(stateFile, JSON.stringify(stateContent, null, 2));
-
-      // Exit code is NOT asserted: the fake daemon answers /pair with
-      // non-JSON so handlePairAgent fails later — the iron rule under test
-      // is everything that happens BEFORE that: no kill, no headed relaunch.
-      const result = await runCli(['pair-agent'], baseEnv(stateFile));
-
-      // The consent notice: live session named, opt-in flag named.
-      expect(result.stderr).toContain('continuing against it');
-      expect(result.stderr).toContain('--force-restart');
-      // No headed relaunch was attempted.
-      const combined = result.stdout + result.stderr;
-      expect(combined).not.toContain('Opening GStack Browser');
-      // THE IRON RULE: the daemon process was not killed.
-      expect(isProcessAlive(daemonPid)).toBe(true);
-      // And the state file was not clobbered.
-      expect(JSON.parse(fs.readFileSync(stateFile, 'utf-8'))).toEqual(stateContent);
-    } finally {
-      await daemon.close();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  }, 30_000);
-
-  test('wedged-alive daemon + plain command → busy report + nonzero exit, NO kill', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-iron-'));
-    const stateFile = path.join(tmpDir, 'browse.json');
-    const daemon = await startWedgedDaemon();
-    try {
-      pidChild = spawn('sleep', ['120'], { stdio: 'ignore' });
-      const daemonPid = pidChild.pid!;
-      fs.writeFileSync(stateFile, JSON.stringify({
-        pid: daemonPid,
-        port: daemon.port,
-        token: 'iron-rule-token',
-        startedAt: new Date().toISOString(),
-        serverPath: '',
-        mode: 'launched' as const,
-      }, null, 2));
-
-      const result = await runCli(['status'], baseEnv(stateFile));
-
-      expect(result.code).not.toBe(0);
-      expect(result.stderr).toContain('Daemon busy');
-      expect(result.stderr).toContain('--force-restart');
-      // Never killed, never restarted.
-      expect(isProcessAlive(daemonPid)).toBe(true);
-      expect(result.stderr).not.toContain('Restarting');
-    } finally {
-      await daemon.close();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  }, 45_000);
-
-  test('wedged-alive daemon + --force-restart IS killed (explicit consent path)', async () => {
-    // Unix lanes only: the consent path must boot a REAL replacement daemon
-    // to answer the command, which the secretless/browserless Windows lane
-    // cannot do (no Chromium install), and the teardown relies on setsid
-    // process-group semantics Windows lacks. The Windows-relevant half of
-    // the iron rule — busy → refusal, never an implicit kill — runs above.
-    if (process.platform === 'win32') return;
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-iron-'));
-    const stateFile = path.join(tmpDir, 'browse.json');
-    const daemon = await startWedgedDaemon();
-    try {
-      pidChild = spawn('sleep', ['120'], { stdio: 'ignore' });
-      const daemonPid = pidChild.pid!;
-      fs.writeFileSync(stateFile, JSON.stringify({
-        pid: daemonPid,
-        port: daemon.port,
-        token: 'iron-rule-token',
-        startedAt: new Date().toISOString(),
-        serverPath: '',
-        mode: 'launched' as const,
-      }, null, 2));
-
-      // `status` with --force-restart: the wedged "daemon" must be killed and
-      // a REAL daemon started in its place.
-      const result = await runCli(['--force-restart', 'status'], baseEnv(stateFile), 60_000);
-
-      // The wedged pid was killed — the explicit consent path.
-      expect(isProcessAlive(daemonPid)).toBe(false);
-      expect(result.stderr).toContain('--force-restart');
-      // The replacement daemon answered the command.
-      expect(result.code).toBe(0);
-    } finally {
-      // Kill the REAL daemon's whole PROCESS GROUP, not just its pid.
-      // startServer spawns the daemon detached (setsid — its own group
-      // leader), so a bare SIGKILL on the pid orphans its Chromium child,
-      // which then squats memory for the REST of the suite (~100 files) —
-      // enough pressure on a loaded box for the OS to kill a LATER test's
-      // in-process Chromium, whose disconnect handler process.exit(1)s the
-      // whole bun run mid-suite with no summary.
-      try {
-        const newState = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
-        if (newState?.pid && isProcessAlive(newState.pid)) {
-          try {
-            process.kill(-newState.pid, 'SIGKILL'); // group: daemon + Chromium
-          } catch {
-            process.kill(newState.pid, 'SIGKILL'); // fallback: pid only
-          }
-        }
-      } catch { /* state file gone — nothing started */ }
-      await daemon.close();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  }, 90_000);
-});