@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/terminal-agent-lifecycle.test.ts

@@ -1,371 +0,0 @@
-import { afterEach, describe, expect, spyOn, test } from 'bun:test';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import {
-  acquireAgentStateLock, agentRecordPath, clearAgentRecord, isOurAgent, killAgentByRecord, readAgentRecord,
-  readAgentStartTime, spawnTerminalAgent, stopAgentByRecord, type AgentRecord,
-  writeAgentRecord,
-} from '../src/terminal-agent-control';
-
-const sourceDir = path.join(import.meta.dir, '..', 'src');
-const dirs: string[] = [];
-const pids: number[] = [];
-const dir = () => {
-  const value = fs.mkdtempSync(path.join(os.tmpdir(), 'g4-'));
-  dirs.push(value);
-  return value;
-};
-const waitFor = async (check: () => boolean, timeout = 3000) => {
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    if (check()) return true;
-    await Bun.sleep(25);
-  }
-  return check();
-};
-const spawn = (stateDir: string, ownerPid = process.pid) => {
-  const pid = spawnTerminalAgent({ stateFile: path.join(stateDir, 'browse.json'), serverPort: 0, ownerPid,
-    extraEnv: { GSTACK_TERMINAL_OWNER_WATCHDOG_MS: '25' } });
-  if (pid) pids.push(pid);
-  return pid;
-};
-
-afterEach(() => {
-  for (const pid of pids.splice(0)) {
-    const record = dirs.map(readAgentRecord).find(value => value?.pid === pid);
-    if (record) stopAgentByRecord(record, 200);
-  }
-  for (const stateDir of dirs.splice(0)) fs.rmSync(stateDir, { recursive: true, force: true });
-});
-
-describe('terminal-agent owned lifecycle regression', () => {
-  for (const field of ['dev', 'ino'] as const) {
-    test(`lock release preserves a replacement with an adjacent 64-bit ${field}`, () => {
-      const stateDir = dir();
-      const lockPath = path.join(stateDir, 'terminal-agent-pid.lock');
-      const identity = 1n << 63n;
-      expect(Number(identity)).toBe(Number(identity + 1n));
-      const originalFstat = fs.fstatSync;
-      const originalStat = fs.statSync;
-      const descriptor = spyOn(fs, 'fstatSync').mockImplementation(((fd: number, options?: any) => {
-        const stat = originalFstat(fd, options);
-        return Object.assign(stat, { [field]: options?.bigint ? identity : Number(identity) });
-      }) as typeof fs.fstatSync);
-      const pathname = spyOn(fs, 'statSync').mockImplementation(((file: fs.PathLike, options?: any) => {
-        const stat = originalStat(file, options);
-        return String(file) === lockPath
-          ? Object.assign(stat, { [field]: options?.bigint ? identity + 1n : Number(identity + 1n) })
-          : stat;
-      }) as typeof fs.statSync);
-      try {
-        acquireAgentStateLock(stateDir)();
-        expect(fs.existsSync(lockPath)).toBe(true);
-      } finally {
-        descriptor.mockRestore();
-        pathname.mockRestore();
-      }
-    });
-  }
-
-  test('connect and supervisor pass the persistent daemon as owner', () => {
-    const cli = fs.readFileSync(path.join(sourceDir, 'cli.ts'), 'utf8');
-    const connect = cli.slice(cli.indexOf('// Auto-start terminal agent'), cli.indexOf('// ─── Outer Supervisor'));
-    const supervisor = cli.slice(cli.indexOf('// ─── Outer Supervisor'), cli.indexOf('// ─── Headed Disconnect'));
-    expect(connect).toMatch(/spawnTerminalAgent\(\{[^}]*ownerPid:\s*newState\.pid/s);
-    expect(supervisor).toMatch(/spawnTerminalAgent\(\{[^}]*ownerPid:\s*respawned\.pid/s);
-  });
-
-  test('owned agent starts, is replaced only after exit, and leaves a live sibling alone', async () => {
-    const firstDir = dir();
-    const siblingDir = dir();
-    const first = spawn(firstDir);
-    const sibling = spawn(siblingDir);
-    expect(first).toBeGreaterThan(0);
-    expect(sibling).toBeGreaterThan(0);
-    expect(await waitFor(() => fs.existsSync(path.join(firstDir, 'terminal-port')))).toBe(true);
-    const firstRecord = readAgentRecord(firstDir)!;
-    const siblingRecord = readAgentRecord(siblingDir)!;
-    expect(isOurAgent(firstRecord, process.pid)).toBe(true);
-    const replacement = spawn(firstDir);
-    expect(replacement).toBeGreaterThan(0);
-    expect(replacement).not.toBe(first);
-    expect(isOurAgent(firstRecord)).toBe(false);
-    expect(isOurAgent(siblingRecord)).toBe(true);
-    expect(readAgentRecord(firstDir)?.pid).toBe(replacement);
-  });
-
-  test('child waits for its PID to replace the pre-spawn reservation', async () => {
-    const stateDir = dir();
-    const originalSpawn = Bun.spawn;
-    (Bun as any).spawn = (...args: Parameters<typeof Bun.spawn>) => {
-      const child = originalSpawn(...args);
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 800);
-      return child;
-    };
-    try {
-      const pid = spawn(stateDir);
-      expect(pid).toBeGreaterThan(0);
-      expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-port')))).toBe(true);
-      expect(readAgentRecord(stateDir)?.pid).toBe(pid);
-    } finally { (Bun as any).spawn = originalSpawn; }
-  });
-
-  test('failed signals retain the live record and prevent a duplicate spawn', () => {
-    const stateDir = dir();
-    const first = spawn(stateDir)!;
-    const record = readAgentRecord(stateDir)!;
-    const original = process.kill;
-    (process as any).kill = ((pid: number, signal: NodeJS.Signals | number) => {
-      if (pid === first && signal !== 0) throw Object.assign(new Error('denied'), { code: 'EPERM' });
-      return original(pid, signal);
-    }) as typeof process.kill;
-    try {
-      expect(spawn(stateDir)).toBeNull();
-      expect(readAgentRecord(stateDir)).toEqual(record);
-    } finally {
-      (process as any).kill = original;
-    }
-  });
-
-  test('a transient identity lookup failure after a signal is not confirmed exit', () => {
-    const stateDir = dir();
-    const first = spawn(stateDir)!;
-    const record = readAgentRecord(stateDir)!;
-    const originalKill = process.kill;
-    const originalSpawnSync = Bun.spawnSync;
-    let obscured = false;
-    (process as any).kill = ((pid: number, signal: NodeJS.Signals | number) => {
-      if (pid === first && signal !== 0) { obscured = true; return true; }
-      return originalKill(pid, signal);
-    }) as typeof process.kill;
-    (Bun as any).spawnSync = (...args: Parameters<typeof Bun.spawnSync>) => {
-      const command = args[0] as string[];
-      if (obscured && command[0] === 'ps' && command[2] === String(first)) {
-        return { exitCode: 1, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) };
-      }
-      return originalSpawnSync(...args);
-    };
-    try {
-      expect(spawn(stateDir)).toBeNull();
-      expect(readAgentRecord(stateDir)).toEqual(record);
-    } finally {
-      (process as any).kill = originalKill;
-      (Bun as any).spawnSync = originalSpawnSync;
-    }
-  });
-
-  test('PID reuse and foreign records are never signaled', () => {
-    const stateDir = dir();
-    const forged: AgentRecord = {
-      pid: process.pid, gen: 'synthetic-foreign-generation', startedAt: Date.now(),
-      startTime: readAgentStartTime(process.pid), ownerPid: process.pid, ownerStartTime: readAgentStartTime(process.pid),
-    };
-    fs.writeFileSync(agentRecordPath(stateDir), JSON.stringify(forged));
-    expect(isOurAgent(forged)).toBe(false);
-    expect(killAgentByRecord(forged, 'SIGTERM')).toBe(false);
-    expect(spawn(stateDir)).toBeNull();
-    expect(readAgentRecord(stateDir)).toEqual(forged);
-    clearAgentRecord(stateDir, { ...forged, gen: 'different' });
-    expect(readAgentRecord(stateDir)).toEqual(forged);
-  });
-
-  test('unwritable record path rejects before spawning any agent', () => {
-    const stateDir = dir();
-    const blocker = path.join(stateDir, 'blocker');
-    fs.writeFileSync(blocker, 'block');
-    const originalSpawn = Bun.spawn;
-    let child: ReturnType<typeof Bun.spawn> | undefined;
-    (Bun as any).spawn = (...args: Parameters<typeof Bun.spawn>) => {
-      child = originalSpawn(...args);
-      return child;
-    };
-    try {
-      expect(() => spawnTerminalAgent({ stateFile: path.join(blocker, 'browse.json'), serverPort: 0, ownerPid: process.pid }))
-        .toThrow();
-      expect(child).toBeUndefined();
-      expect(fs.readdirSync(stateDir)).toEqual(['blocker']);
-    } finally {
-      (Bun as any).spawn = originalSpawn;
-      try { child?.kill('SIGKILL'); } catch {}
-    }
-  });
-
-  test('a leftover exclusive lock refuses recovery without stealing ownership', () => {
-    const stateDir = dir();
-    const lock = path.join(stateDir, 'terminal-agent-pid.lock');
-    fs.writeFileSync(lock, '');
-    expect(() => acquireAgentStateLock(stateDir, 0)).toThrow('state lock unavailable');
-    expect(fs.existsSync(lock)).toBe(true);
-    expect(readAgentRecord(stateDir)).toBeNull();
-  });
-
-  test('record update failure after spawn confirms child exit before dropping its handle', async () => {
-    const stateDir = dir();
-    const originalSpawn = Bun.spawn;
-    const originalRename = fs.renameSync;
-    let child: ReturnType<typeof Bun.spawn> | undefined;
-    let writes = 0;
-    const rename = spyOn(fs, 'renameSync').mockImplementation(((from: fs.PathLike, to: fs.PathLike) => {
-      if (String(to) === agentRecordPath(stateDir) && ++writes === 2) {
-        throw Object.assign(new Error('synthetic state write failure'), { code: 'EIO' });
-      }
-      return originalRename(from, to);
-    }) as typeof fs.renameSync);
-    (Bun as any).spawn = (...args: Parameters<typeof Bun.spawn>) => {
-      child = originalSpawn(...args);
-      return child;
-    };
-    try {
-      expect(() => spawn(stateDir)).toThrow('synthetic state write failure');
-      expect(writes).toBe(2);
-      expect(child).toBeDefined();
-      expect(await Promise.race([child!.exited.then(() => true), Bun.sleep(3000).then(() => false)])).toBe(true);
-      expect(readAgentRecord(stateDir)).toBeNull();
-    } finally {
-      rename.mockRestore();
-      (Bun as any).spawn = originalSpawn;
-      try { child?.kill('SIGKILL'); } catch {}
-    }
-  });
-
-  (process.platform === 'win32' ? test.skip : test)('unconfirmed post-write child keeps its reservation until it exits', async () => {
-    const stateDir = dir();
-    const originalSpawn = Bun.spawn;
-    const originalRename = fs.renameSync;
-    const originalKill = process.kill;
-    let child: ReturnType<typeof Bun.spawn> | undefined;
-    let writes = 0;
-    let deniedSignals = 0;
-    const rename = spyOn(fs, 'renameSync').mockImplementation(((from: fs.PathLike, to: fs.PathLike) => {
-      if (String(to) === agentRecordPath(stateDir) && ++writes === 2) throw new Error('synthetic update refusal');
-      return originalRename(from, to);
-    }) as typeof fs.renameSync);
-    (Bun as any).spawn = (...args: Parameters<typeof Bun.spawn>) => {
-      child = originalSpawn(...args);
-      originalKill(child.pid, 'SIGSTOP');
-      return child;
-    };
-    (process as any).kill = ((pid: number, signal: NodeJS.Signals | number) => {
-      if (child && pid === child.pid && signal !== 0) {
-        deniedSignals++;
-        throw Object.assign(new Error('signal denied'), { code: 'EPERM' });
-      }
-      return originalKill(pid, signal);
-    }) as typeof process.kill;
-    try {
-      expect(() => spawn(stateDir)).toThrow('exit is unconfirmed');
-      expect(deniedSignals).toBeGreaterThan(0);
-      expect(readAgentRecord(stateDir)?.pid).toBe(0);
-      expect(spawn(stateDir)).toBeNull();
-      expect(readAgentRecord(stateDir)?.pid).toBe(0);
-      originalKill(child!.pid, 'SIGCONT');
-      expect(await Promise.race([child!.exited.then(() => true), Bun.sleep(4000).then(() => false)])).toBe(true);
-      expect(await waitFor(() => readAgentRecord(stateDir) === null)).toBe(true);
-    } finally {
-      (process as any).kill = originalKill;
-      (Bun as any).spawn = originalSpawn;
-      rename.mockRestore();
-      if (child) try { originalKill(child.pid, 'SIGCONT'); } catch {}
-      try { child?.kill('SIGKILL'); } catch {}
-    }
-  }, 6000);
-
-  test('owner death and record takeover shut down the old generation without deleting its successor', async () => {
-    const stateDir = dir();
-    const owner = Bun.spawn([process.execPath, '-e', 'process.stdin.resume()'], { stdio: ['pipe', 'ignore', 'ignore'] });
-    try {
-      const pid = spawn(stateDir, owner.pid)!;
-      expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-port')))).toBe(true);
-      const record = readAgentRecord(stateDir)!;
-      owner.kill('SIGTERM');
-      await owner.exited;
-      expect(await waitFor(() => !isOurAgent(record), 5000)).toBe(true);
-      expect(readAgentRecord(stateDir)).toBeNull();
-    } finally { try { owner.kill('SIGKILL'); } catch {} }
-
-    const first = spawn(stateDir)!;
-    expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-port')))).toBe(true);
-    const original = readAgentRecord(stateDir)!;
-    const successor = { ...original, pid: 2147483646, gen: 'synthetic-successor' };
-    fs.writeFileSync(agentRecordPath(stateDir), JSON.stringify(successor));
-    expect(await waitFor(() => !isOurAgent(original), 5000)).toBe(true);
-    expect(readAgentRecord(stateDir)).toEqual(successor);
-    expect(first).toBeGreaterThan(0);
-  }, 12000);
-
-  test('losing concurrent startup cannot publish over the winning generation', async () => {
-    const stateDir = dir();
-    const stateFile = path.join(stateDir, 'browse.json');
-    const barrier = path.join(stateDir, 'go');
-    const ownerStartTime = readAgentStartTime(process.pid);
-    const rawAgent = (gen: string, paused: boolean) => {
-      writeAgentRecord(stateDir, { pid: 0, gen, startedAt: Date.now(), ownerPid: process.pid, ownerStartTime });
-      const agent = Bun.spawn(['bun', 'run', path.join(sourceDir, 'terminal-agent.ts'), `--agent-gen=${gen}`], {
-        env: { ...process.env, BROWSE_STATE_FILE: stateFile, BROWSE_OWNER_PID: String(process.pid),
-          BROWSE_OWNER_START_TIME: ownerStartTime, BROWSE_AGENT_GEN: gen, NODE_ENV: 'test',
-          GSTACK_TERMINAL_OWNER_WATCHDOG_MS: '25',
-          ...(paused ? { GSTACK_TERMINAL_TEST_PUBLISH_BARRIER: barrier } : {}) },
-        stdio: ['ignore', 'ignore', 'ignore'],
-      });
-      writeAgentRecord(stateDir, { pid: agent.pid, gen, startedAt: Date.now(),
-        startTime: readAgentStartTime(agent.pid), ownerPid: process.pid, ownerStartTime });
-      return agent;
-    };
-    const old = rawAgent('synthetic-old-generation', true);
-    let winner: ReturnType<typeof Bun.spawn> | undefined;
-    try {
-      // Startup waits cover a cold `bun run` of the agent; under a fully
-      // loaded 16-shard run that alone can exceed 3s. They return as soon as
-      // the file appears, so the ordering contract below is unchanged.
-      expect(await waitFor(() => fs.existsSync(`${barrier}.ready`), 8000)).toBe(true);
-      winner = rawAgent('synthetic-new-generation', false);
-      expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-port')), 8000)).toBe(true);
-      const port = fs.readFileSync(path.join(stateDir, 'terminal-port'), 'utf8');
-      const token = fs.readFileSync(path.join(stateDir, 'terminal-internal-token'), 'utf8');
-      fs.writeFileSync(barrier, 'continue');
-      expect(await Promise.race([old.exited.then(() => true), Bun.sleep(8000).then(() => false)])).toBe(true);
-      expect(readAgentRecord(stateDir)?.gen).toBe('synthetic-new-generation');
-      expect(fs.readFileSync(path.join(stateDir, 'terminal-port'), 'utf8')).toBe(port);
-      expect(fs.readFileSync(path.join(stateDir, 'terminal-internal-token'), 'utf8')).toBe(token);
-    } finally {
-      fs.writeFileSync(barrier, 'continue');
-      try { old.kill('SIGKILL'); } catch {}
-      try { winner?.kill('SIGKILL'); } catch {}
-      await old.exited;
-      if (winner) await winner.exited;
-    }
-  }, 30000);
-
-  test('daemon respawns after agent crash, then exits without deleting a successor state', async () => {
-    const stateDir = dir();
-    const stateFile = path.join(stateDir, 'browse.json');
-    const daemon = Bun.spawn(['bun', 'run', path.join(sourceDir, 'server.ts')], {
-      env: { ...process.env, BROWSE_STATE_FILE: stateFile, BROWSE_HEADLESS_SKIP: '1', BROWSE_PARENT_PID: '0',
-        GSTACK_AGENT_WATCHDOG_TICK_MS: '50', GSTACK_STATE_WATCH_MS: '50', GSTACK_TERMINAL_OWNER_WATCHDOG_MS: '25' },
-      stdio: ['ignore', 'ignore', 'ignore'],
-    });
-    try {
-      expect(await waitFor(() => fs.existsSync(stateFile))).toBe(true);
-      expect(await waitFor(() => {
-        const record = readAgentRecord(stateDir);
-        return !!record && record.pid > 0 && isOurAgent(record, daemon.pid);
-      }, 5000)).toBe(true);
-      const old = readAgentRecord(stateDir)!;
-      expect(old.ownerPid).toBe(daemon.pid);
-      expect(isOurAgent(old, daemon.pid)).toBe(true);
-      expect(killAgentByRecord(old, 'SIGKILL')).toBe(true);
-      expect(await waitFor(() => {
-        const record = readAgentRecord(stateDir);
-        return !!record && record.gen !== old.gen;
-      }, 5000)).toBe(true);
-      const successor = { ...JSON.parse(fs.readFileSync(stateFile, 'utf8')), pid: process.pid, instanceId: 'synthetic-successor' };
-      fs.writeFileSync(stateFile, JSON.stringify(successor));
-      expect(await waitFor(() => daemon.exitCode !== null, 5000)).toBe(true);
-      expect(JSON.parse(fs.readFileSync(stateFile, 'utf8'))).toEqual(successor);
-    } finally {
-      try { daemon.kill('SIGKILL'); } catch {}
-      await daemon.exited;
-    }
-  }, 15000);
-});

package/.agent/skills/gstack-browse/test/terminal-agent-native-observation.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, spyOn, test } from 'bun:test';
-import * as childProcess from 'node:child_process';
-import { isAgentRecordGone, isOurAgent, stopAgentByRecord } from '../src/terminal-agent-control';
-
-describe('terminal-agent native exit observations', () => {
-  const pid = 2147483645;
-  const startTime = 'Tue Sep 22 23:39:21 2026';
-  const gen = 'test-observed-generation';
-  const ownedCommand = `bun run terminal-agent.ts --agent-gen=${gen}`;
-  const cases = [
-    { name: 'Darwin zombie retains nonempty command text', command: '(bun)', state: 'Z', gone: true },
-    { name: 'zombie retains its generation argument', command: ownedCommand, state: 'Z', gone: true },
-    { name: 'process exits during start-time lookup', command: '', state: '', missingStart: true, reap: true, gone: true },
-    { name: 'process exits during command lookup', command: '', state: '', reap: true, gone: true },
-    { name: 'live process has a failed start-time lookup', command: '', state: 'S', missingStart: true, gone: false },
-    { name: 'live process has a failed command lookup', command: '', state: 'S', gone: false },
-    { name: 'live foreign generation is not ours', command: 'bun unrelated.ts', state: 'S', gone: false },
-    { name: 'live owned generation remains ours', command: ownedCommand, state: 'S', gone: false, owned: true },
-    { name: 'failed state probe cannot certify a zombie', command: '', state: 'Z', stateStatus: 1, gone: false },
-    { name: 'process exits before the owned signal', command: ownedCommand, state: 'S', gone: false, owned: true, reapOnSignal: true },
-  ];
-
-  for (const scenario of cases) {
-    test(scenario.name, () => {
-      const platform = Object.getOwnPropertyDescriptor(process, 'platform')!;
-      let live = true;
-      const signals: unknown[] = [];
-      const kill = spyOn(process, 'kill').mockImplementation(((target: number, signal: unknown) => {
-        expect(target).toBe(pid);
-        if (signal !== 0) {
-          signals.push(signal);
-          if (scenario.reapOnSignal) { live = false; throw Object.assign(new Error('gone'), { code: 'ESRCH' }); }
-          throw new Error('unexpected signal');
-        }
-        if (!live) throw Object.assign(new Error('gone'), { code: 'ESRCH' });
-        return true;
-      }) as typeof process.kill);
-      const probe = spyOn(Bun, 'spawnSync').mockImplementation(((command: string[]) => {
-        expect(command.slice(0, 3)).toEqual(['ps', '-p', String(pid)]);
-        const start = command[4] === 'lstart=';
-        if (scenario.reap && (!start || scenario.missingStart)) live = false;
-        return {
-          exitCode: start && scenario.missingStart ? 1 : 0,
-          stdout: Buffer.from(start ? scenario.missingStart ? '' : startTime : scenario.command),
-          stderr: Buffer.alloc(0),
-        };
-      }) as typeof Bun.spawnSync);
-      const state = spyOn(childProcess, 'spawnSync').mockReturnValue({
-        status: scenario.stateStatus ?? 0, stdout: scenario.state, stderr: '',
-      } as any);
-      Object.defineProperty(process, 'platform', { ...platform, value: 'darwin' });
-      try {
-        const record = { pid, gen, startTime, startedAt: 0, ownerPid: pid, ownerStartTime: startTime };
-        expect(isAgentRecordGone(record)).toBe(scenario.gone);
-        expect(isOurAgent(record)).toBe(scenario.owned ?? false);
-        if (scenario.gone || scenario.reapOnSignal) expect(stopAgentByRecord(record, 0)).toBe(true);
-        expect(signals).toEqual(scenario.reapOnSignal ? ['SIGTERM'] : []);
-      } finally {
-        Object.defineProperty(process, 'platform', platform);
-        state.mockRestore();
-        probe.mockRestore();
-        kill.mockRestore();
-      }
-    });
-  }
-});

package/.agent/skills/gstack-browse/test/terminal-agent-owner-watchdog.test.ts

@@ -1,81 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-const AGENT_SCRIPT = path.join(import.meta.dir, '../src/terminal-agent.ts');
-const spawned: any[] = [];
-const tempDirs: string[] = [];
-
-function isAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function waitFor(predicate: () => boolean, timeoutMs = 5_000): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (predicate()) return true;
-    await Bun.sleep(25);
-  }
-  return predicate();
-}
-
-afterEach(() => {
-  for (const proc of spawned.splice(0)) {
-    try { proc.kill?.('SIGKILL'); } catch {}
-  }
-  for (const dir of tempDirs.splice(0)) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
-  }
-});
-
-describe('terminal-agent owner lifecycle', () => {
-  test('exits after its owning browse server process exits', async () => {
-    const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-term-owner-'));
-    tempDirs.push(stateDir);
-    const stateFile = path.join(stateDir, 'browse.json');
-    fs.writeFileSync(stateFile, JSON.stringify({ token: 'test-token' }));
-
-    // process.execPath (the running bun) instead of `sleep`: coreutils are
-    // not guaranteed on a bare windows-latest runner, and this test is on the
-    // Windows CI curated list — the owner-orphan leak it pins is a Windows bug.
-    // The owner's lifetime is tied to this test process instead of a fixed
-    // 30s sleep: it blocks until its stdin (a pipe we hold open) hits EOF, so
-    // it is guaranteed alive until the SIGTERM below no matter how slow the
-    // runner is, and it reaps itself if the test process dies without running
-    // afterEach. Node-compatible stdin APIs, not Bun.stdin — Windows-portable.
-    const owner = Bun.spawn(
-      [process.execPath, '-e',
-        "process.stdin.resume(); const bye = () => process.exit(0); "
-        + "process.stdin.on('end', bye); process.stdin.on('error', bye); process.stdin.on('close', bye);"],
-      { stdio: ['pipe', 'ignore', 'ignore'] },
-    );
-    spawned.push(owner);
-    const agent = Bun.spawn(['bun', 'run', AGENT_SCRIPT], {
-      env: {
-        ...process.env,
-        BROWSE_STATE_FILE: stateFile,
-        BROWSE_SERVER_PORT: '0',
-        BROWSE_OWNER_PID: String(owner.pid),
-        GSTACK_TERMINAL_OWNER_WATCHDOG_MS: '25',
-      },
-      stdio: ['ignore', 'ignore', 'ignore'],
-    });
-    spawned.push(agent);
-
-    expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-agent-pid')))).toBe(true);
-    expect(isAlive(agent.pid)).toBe(true);
-
-    owner.kill('SIGTERM');
-    await owner.exited;
-
-    expect(await waitFor(() => !isAlive(agent.pid))).toBe(true);
-    expect(fs.existsSync(path.join(stateDir, 'terminal-agent-pid'))).toBe(false);
-    expect(fs.existsSync(path.join(stateDir, 'terminal-port'))).toBe(false);
-  });
-});

package/.agent/skills/gstack-browse/test/terminal-agent-pid-identity.test.ts

@@ -1,161 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  readAgentRecord,
-  writeAgentRecord,
-  clearAgentRecord,
-  killAgentByRecord,
-  agentRecordPath,
-  type AgentRecord,
-} from '../src/terminal-agent-control';
-
-// REGRESSION TEST for the v1.44 PID-identity migration.
-//
-// Pre-v1.44, both `cli.ts` and `server.ts` killed the terminal-agent with
-// `spawnSync('pkill', ['-f', 'terminal-agent\\.ts'])`. That command matches
-// by argv regex — any process whose command line contains the string
-// `terminal-agent.ts` got SIGTERM'd. In practice this killed:
-//
-//   * sibling gstack sessions on the same host
-//   * editor processes (vim, code, less) that had the file open
-//   * any second gstack run on the host
-//
-// The v1.44 migration replaces both kill sites with identity-based PID kill
-// against the record written at `<stateDir>/terminal-agent-pid` by the
-// agent's own boot path. This test is the static-grep tripwire that prevents
-// reintroducing the regex teardown anywhere in the source tree.
-//
-// Pattern mirrors browse/test/server-embedder-terminal-port.test.ts (Test 4)
-// and browse/test/server-sanitize-surrogates.test.ts: read source files
-// directly, assert an invariant on their contents.
-
-const SRC_DIR = path.resolve(import.meta.path, '..', '..', 'src');
-
-function readAllSourceFiles(): Array<{ file: string; content: string }> {
-  const out: Array<{ file: string; content: string }> = [];
-  for (const entry of fs.readdirSync(SRC_DIR)) {
-    if (!entry.endsWith('.ts')) continue;
-    const full = path.join(SRC_DIR, entry);
-    out.push({ file: entry, content: fs.readFileSync(full, 'utf-8') });
-  }
-  return out;
-}
-
-describe('terminal-agent PID identity (v1.44+)', () => {
-  test('1. no source file calls `pkill -f terminal-agent`', () => {
-    // The regex matches both `pkill -f terminal-agent\.ts` (escaped form
-    // used in spawnSync args) and `pkill -f terminal-agent.ts` (literal),
-    // since the dot is the only difference and both are footguns.
-    const offenders: string[] = [];
-    for (const { file, content } of readAllSourceFiles()) {
-      // Walk line by line so we can skip comments that mention the historical
-      // pattern (acceptable as documentation, not as code).
-      const lines = content.split('\n');
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (!/pkill/.test(line)) continue;
-        if (!/terminal-agent/.test(line)) continue;
-        // Skip comment lines — historical mentions in JSDoc are fine.
-        const trimmed = line.trim();
-        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) continue;
-        offenders.push(`${file}:${i + 1}: ${trimmed}`);
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-
-  test('2. neither cli.ts nor server.ts calls spawnSync with pkill', () => {
-    // Tighter check — even if someone routes through a different code path,
-    // any spawnSync('pkill', ...) anywhere in src/ is the smell.
-    const offenders: string[] = [];
-    for (const { file, content } of readAllSourceFiles()) {
-      if (/spawnSync\s*\(\s*['"]pkill['"]/.test(content)) {
-        offenders.push(file);
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-
-  test('3. readAgentRecord round-trips writeAgentRecord', () => {
-    const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'gstack-pid-id-'));
-    try {
-      const record: AgentRecord = {
-        pid: 12345,
-        gen: 'test-gen-abcdef',
-        startedAt: Date.now(),
-      };
-      writeAgentRecord(tmpDir, record);
-      const read = readAgentRecord(tmpDir);
-      expect(read).toEqual(record);
-      expect(fs.existsSync(agentRecordPath(tmpDir))).toBe(true);
-
-      clearAgentRecord(tmpDir);
-      expect(readAgentRecord(tmpDir)).toBeNull();
-      expect(fs.existsSync(agentRecordPath(tmpDir))).toBe(false);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test('4. readAgentRecord returns null on missing or malformed file', () => {
-    const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'gstack-pid-id-'));
-    try {
-      // Missing.
-      expect(readAgentRecord(tmpDir)).toBeNull();
-
-      // Malformed: wrong type for pid.
-      fs.writeFileSync(agentRecordPath(tmpDir), JSON.stringify({ pid: 'not-a-number', gen: 'x', startedAt: 0 }));
-      expect(readAgentRecord(tmpDir)).toBeNull();
-
-      // Malformed: not JSON.
-      fs.writeFileSync(agentRecordPath(tmpDir), 'definitely not json');
-      expect(readAgentRecord(tmpDir)).toBeNull();
-
-      // Missing field.
-      fs.writeFileSync(agentRecordPath(tmpDir), JSON.stringify({ pid: 1, gen: 'x' }));
-      expect(readAgentRecord(tmpDir)).toBeNull();
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test('5. killAgentByRecord returns false for a dead PID and never throws', () => {
-    // PID 2147483646 is below Linux PID_MAX_LIMIT but way above macOS's
-    // typical max — no real process will ever hold it. isProcessAlive
-    // returns false; killAgentByRecord no-ops.
-    const record: AgentRecord = {
-      pid: 2147483646,
-      gen: 'sentinel',
-      startedAt: Date.now(),
-    };
-    const result = killAgentByRecord(record, 'SIGTERM');
-    expect(result).toBe(false);
-  });
-
-  test('6. killAgentByRecord skips the kill when isProcessAlive is false', () => {
-    // Guard via process.kill stub: confirm killAgentByRecord does NOT call
-    // process.kill with a non-zero signal when the PID is dead. This is the
-    // belt-and-suspenders defense against PID-reuse: even if isProcessAlive
-    // changes implementation, killAgentByRecord must validate liveness first.
-    const origKill = process.kill;
-    const kills: Array<[number, NodeJS.Signals | number]> = [];
-    (process as any).kill = ((pid: number, sig: NodeJS.Signals | number) => {
-      kills.push([pid, sig ?? 'SIGTERM']);
-      if (sig === 0) {
-        const err: any = new Error('ESRCH');
-        err.code = 'ESRCH';
-        throw err;
-      }
-      return true;
-    }) as any;
-    try {
-      const record: AgentRecord = { pid: 9999999, gen: 'x', startedAt: Date.now() };
-      killAgentByRecord(record, 'SIGTERM');
-      const terminations = kills.filter(([, s]) => s !== 0);
-      expect(terminations).toEqual([]);
-    } finally {
-      (process as any).kill = origKill;
-    }
-  });
-});