@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/tab-session-frame-detach.test.ts

@@ -1,154 +0,0 @@
-/**
- * Regression: refMap must be cleared when an iframe detaches.
- *
- * `TabSession.getActiveFrameOrPage()` (tab-session.ts:151) auto-recovers
- * from detached iframes by setting `activeFrame = null` and silently
- * falling back to the main page. The asymmetric bug: the matching
- * `clearRefs()` call is missing.
- *
- * Compare to `onMainFrameNavigated()` (tab-session.ts:167) — the
- * staleness condition is equivalent (refs were captured against a frame
- * that no longer exists), and the main-frame path correctly clears both
- * the activeFrame AND the refMap:
- *
- *     onMainFrameNavigated(): void {
- *       this.clearRefs();           //  ← clears refs
- *       this.activeFrame = null;
- *       this.loadedHtml = null;
- *       this.loadedHtmlWaitUntil = undefined;
- *     }
- *
- *     getActiveFrameOrPage(): Page | Frame {
- *       if (this.activeFrame?.isDetached()) {
- *         this.activeFrame = null;  //  ← but no clearRefs() here
- *       }
- *       return this.activeFrame ?? this.page;
- *     }
- *
- * The lazy click-time staleness check at `resolveRef` (tab-session.ts:97)
- * partially saves us — `entry.locator.count()` on a detached-frame
- * locator throws or returns 0, so a click against a stale ref errors out
- * with "Ref X is stale". But the user has no signal that frame context
- * silently changed underfoot: the next `snapshot` runs against
- * `this.page` (main) while old iframe refs still litter `refMap` with
- * the same role+name keys. New refs collide with stale ones, the
- * resolver picks one at random, the user clicks the wrong element.
- *
- * Behavior the test locks: when an iframe detaches and
- * `getActiveFrameOrPage()` auto-recovers, the refMap is cleared in the
- * same step (matching the `onMainFrameNavigated` symmetry). TODOS.md
- * line 816-820 documents "Detached frame auto-recovery" as a feature;
- * this restores the documented intent.
- */
-
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { TabSession, type RefEntry } from '../src/tab-session';
-import type { Page, Frame, Locator } from 'playwright';
-
-// Minimal type-cast mocks. Same pattern as tab-isolation.test.ts —
-// pure-logic tests don't launch a browser.
-function mockPage(): Page {
-  return {} as Page;
-}
-
-function mockDetachedFrame(): Frame {
-  return { isDetached: () => true } as unknown as Frame;
-}
-
-function mockAttachedFrame(): Frame {
-  return { isDetached: () => false } as unknown as Frame;
-}
-
-function mockRefEntry(role: string, name: string): RefEntry {
-  return {
-    locator: {} as Locator,
-    role,
-    name,
-  };
-}
-
-// Fresh refs Map per call — avoid by-reference mutation poisoning across
-// halves of the symmetry test (clearRefs() clears the same Map instance
-// the test holds a reference to).
-function makeRefs(): Map<string, RefEntry> {
-  const r = new Map<string, RefEntry>();
-  r.set('e1', mockRefEntry('button', 'Submit'));
-  r.set('e2', mockRefEntry('textbox', 'Email'));
-  r.set('e3', mockRefEntry('link', 'Forgot password'));
-  return r;
-}
-
-describe('TabSession — frame detach + ref staleness', () => {
-  let session: TabSession;
-
-  beforeEach(() => {
-    session = new TabSession(mockPage());
-    session.setRefMap(makeRefs());
-  });
-
-  test('refs cleared when getActiveFrameOrPage detects detached iframe', () => {
-    // Pre-condition: refs captured inside an iframe context
-    session.setFrame(mockDetachedFrame());
-    expect(session.getRefCount()).toBe(3);
-
-    // Act: caller invokes getActiveFrameOrPage (e.g. via the next /command
-    // dispatch). The detach gets noticed inside.
-    const result = session.getActiveFrameOrPage();
-
-    // Auto-recovery: activeFrame nulled (already worked pre-fix)
-    expect(session.getFrame()).toBeNull();
-
-    // The fix: refs ALSO cleared so the next snapshot runs against a
-    // clean ref namespace. Pre-fix this was 3 — refs lingered against a
-    // dead frame, colliding with refs the next snapshot would emit.
-    expect(session.getRefCount()).toBe(0);
-  });
-
-  test('refs preserved when active frame is still attached', () => {
-    // No regression on the happy path — attached frame should NOT
-    // trigger the cleanup.
-    session.setFrame(mockAttachedFrame());
-    expect(session.getRefCount()).toBe(3);
-
-    session.getActiveFrameOrPage();
-
-    // Frame still set, refs still present.
-    expect(session.getFrame()).not.toBeNull();
-    expect(session.getRefCount()).toBe(3);
-  });
-
-  test('refs preserved when no frame is set (page-level snapshot)', () => {
-    // No frame ever set → the if-branch never enters → refs untouched.
-    expect(session.getFrame()).toBeNull();
-    expect(session.getRefCount()).toBe(3);
-
-    session.getActiveFrameOrPage();
-
-    expect(session.getRefCount()).toBe(3);
-  });
-
-  test('matches onMainFrameNavigated symmetry (refs+frame both cleared)', () => {
-    // Pin the design symmetry: both staleness paths (main-frame nav AND
-    // iframe detach) must clear both pieces of state together. If a
-    // future refactor splits these, the test fails before merge.
-    session.setFrame(mockDetachedFrame());
-    expect(session.getRefCount()).toBe(3);
-
-    session.onMainFrameNavigated();
-
-    expect(session.getFrame()).toBeNull();
-    expect(session.getRefCount()).toBe(0);
-
-    // Reset with a FRESH Map (the previous one was emptied by clearRefs
-    // by-reference) and exercise the iframe-detach path. End state must
-    // match.
-    session.setRefMap(makeRefs());
-    session.setFrame(mockDetachedFrame());
-    expect(session.getRefCount()).toBe(3);
-
-    session.getActiveFrameOrPage();
-
-    expect(session.getFrame()).toBeNull();
-    expect(session.getRefCount()).toBe(0);
-  });
-});

package/.agent/skills/gstack-browse/test/telemetry-optout.test.ts

@@ -1,171 +0,0 @@
-/**
- * Telemetry consent tiers — the user-consent enforcement point.
- *
- * Telemetry is OPT-IN: it emits only when the user granted a tier through
- * the consent prompt (`telemetry: community` or `telemetry: anonymous` in
- * ~/.gstack/config.yaml). An absent key, an absent config file, an explicit
- * `off`, or any unrecognized value all mean DISABLED — the same default
- * bin/gstack-config's DEFAULTS table reports for an unset key, so a daemon
- * spawned outside a skill preamble (direct $B use, embedders) can never
- * emit while `gstack-config get telemetry` tells the user 'off'.
- *
- * The persistent tier reads through the shared flat-YAML helper in
- * config.ts (readGstackConfigYamlKey), same parser as the pair-agent gate.
- * Env tier: GSTACK_TELEMETRY_OFF=1 always disables; =0 is a harness-side
- * consent assertion that covers the no-config default only — it never
- * overrides an explicit `telemetry: off`.
- *
- * Harness mirrors pair-agent-optin-gate.test.ts: GSTACK_HOME → temp dir,
- * env saved/restored per test, cache reset via _resetTelemetryCache.
- */
-
-import { describe, test, expect, afterEach } from 'bun:test';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { isTelemetryDisabled, logTelemetry, _resetTelemetryCache } from '../src/telemetry';
-
-const savedEnv = {
-  GSTACK_HOME: process.env.GSTACK_HOME,
-  GSTACK_TELEMETRY_OFF: process.env.GSTACK_TELEMETRY_OFF,
-};
-const tmpHomes: string[] = [];
-
-/** Fresh GSTACK_HOME with the given config.yaml body (null = no file). */
-function tmpHomeWith(configYaml: string | null): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-telemetry-optout-'));
-  tmpHomes.push(dir);
-  if (configYaml !== null) {
-    fs.writeFileSync(path.join(dir, 'config.yaml'), configYaml);
-  }
-  process.env.GSTACK_HOME = dir;
-  delete process.env.GSTACK_TELEMETRY_OFF;
-  _resetTelemetryCache();
-  return dir;
-}
-
-afterEach(() => {
-  for (const k of ['GSTACK_HOME', 'GSTACK_TELEMETRY_OFF'] as const) {
-    if (savedEnv[k] === undefined) delete process.env[k];
-    else process.env[k] = savedEnv[k]!;
-  }
-  _resetTelemetryCache();
-  while (tmpHomes.length) fs.rmSync(tmpHomes.pop()!, { recursive: true, force: true });
-});
-
-describe('telemetry persistent opt-out tier (config.yaml)', () => {
-  test('DISABLED when config.yaml has plain `telemetry: off`', () => {
-    tmpHomeWith('telemetry: off\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test("DISABLED when the value is single-quoted: telemetry: 'off'", () => {
-    tmpHomeWith("telemetry: 'off'\n");
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('DISABLED when the value is double-quoted: telemetry: "off"', () => {
-    tmpHomeWith('telemetry: "off"\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('DISABLED with a trailing comment: telemetry: off # user opted out', () => {
-    tmpHomeWith('telemetry: off # user opted out\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('DISABLED when the key sits among other keys', () => {
-    tmpHomeWith('pair_agent: off\ntelemetry: off\nskill_prefix: none\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('ENABLED when the user granted the `anonymous` tier', () => {
-    tmpHomeWith('telemetry: anonymous\n');
-    expect(isTelemetryDisabled()).toBe(false);
-  });
-
-  test('ENABLED when the user granted the `community` tier', () => {
-    tmpHomeWith('telemetry: community\n');
-    expect(isTelemetryDisabled()).toBe(false);
-  });
-
-  test('DISABLED when the key is absent — consent was never granted', () => {
-    // bin/gstack-config's DEFAULTS table reports 'off' for an unset telemetry
-    // key; the daemon must agree or direct-$B spawns emit while the user is
-    // told telemetry is off (default-polarity split-brain).
-    tmpHomeWith('pair_agent: on\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('DISABLED when config.yaml does not exist — fresh installs emit nothing', () => {
-    tmpHomeWith(null);
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('DISABLED on an unrecognized tier value (fail-closed)', () => {
-    tmpHomeWith('telemetry: banana\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('a commented-out consent line does not enable: `# telemetry: community`', () => {
-    tmpHomeWith('# telemetry: community\n');
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-});
-
-describe('telemetry env tier + cache semantics', () => {
-  test('GSTACK_TELEMETRY_OFF=1 disables even when config says anonymous', () => {
-    tmpHomeWith('telemetry: anonymous\n');
-    process.env.GSTACK_TELEMETRY_OFF = '1';
-    _resetTelemetryCache();
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('GSTACK_TELEMETRY_OFF=0 never overrides an explicit `telemetry: off`', () => {
-    // The =0 hint is a harness-side consent assertion for scratch homes with
-    // no config store; a user's written opt-out always wins over it.
-    tmpHomeWith('telemetry: off\n');
-    process.env.GSTACK_TELEMETRY_OFF = '0';
-    _resetTelemetryCache();
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-
-  test('GSTACK_TELEMETRY_OFF=0 enables when no config store exists (harness seam)', () => {
-    tmpHomeWith(null);
-    process.env.GSTACK_TELEMETRY_OFF = '0';
-    _resetTelemetryCache();
-    expect(isTelemetryDisabled()).toBe(false);
-  });
-
-  test('verdict is cached per process; _resetTelemetryCache re-reads config', () => {
-    const dir = tmpHomeWith('telemetry: anonymous\n');
-    expect(isTelemetryDisabled()).toBe(false);
-    // Opt out on disk mid-process: the cached verdict holds until reset.
-    fs.writeFileSync(path.join(dir, 'config.yaml'), 'telemetry: off\n');
-    expect(isTelemetryDisabled()).toBe(false);
-    _resetTelemetryCache();
-    expect(isTelemetryDisabled()).toBe(true);
-  });
-});
-
-describe('enforcement: logTelemetry writes only with granted consent', () => {
-  test('config-tier opt-out suppresses the JSONL append', async () => {
-    const dir = tmpHomeWith('telemetry: off\n');
-    await logTelemetry({ event: 'domain_skill_fired', host: 'example.com' });
-    expect(fs.existsSync(path.join(dir, 'analytics', 'browse-telemetry.jsonl'))).toBe(false);
-  });
-
-  test('no consent ever recorded (absent key) suppresses the JSONL append', async () => {
-    const dir = tmpHomeWith('pair_agent: on\n');
-    await logTelemetry({ event: 'domain_skill_fired', host: 'example.com' });
-    expect(fs.existsSync(path.join(dir, 'analytics', 'browse-telemetry.jsonl'))).toBe(false);
-  });
-
-  test('granted `community` tier appends the event', async () => {
-    const dir = tmpHomeWith('telemetry: community\n');
-    await logTelemetry({ event: 'domain_skill_fired', host: 'example.com' });
-    const file = path.join(dir, 'analytics', 'browse-telemetry.jsonl');
-    expect(fs.existsSync(file)).toBe(true);
-    expect(fs.readFileSync(file, 'utf-8')).toContain('domain_skill_fired');
-  });
-});

package/.agent/skills/gstack-browse/test/telemetry.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'bun:test';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-const TMP_HOME = path.join(os.tmpdir(), `gstack-telemetry-test-${process.pid}-${Date.now()}`);
-const TELEMETRY_FILE = path.join(TMP_HOME, 'analytics', 'browse-telemetry.jsonl');
-
-// Use GSTACK_HOME env to redirect telemetry writes (read each call,
-// not cached at module-load).
-// Scoped to this file's execution window — module-scope env assignment
-// leaks into sibling files in the shard process (see
-// test/gstack-home-module-scope.test.ts).
-const ORIGINAL_GSTACK_HOME = process.env.GSTACK_HOME;
-const ORIGINAL_TELEMETRY_OFF = process.env.GSTACK_TELEMETRY_OFF;
-beforeAll(() => {
-  process.env.GSTACK_HOME = TMP_HOME;
-  process.env.GSTACK_TELEMETRY_OFF = '0';
-});
-afterAll(() => {
-  if (ORIGINAL_GSTACK_HOME === undefined) delete process.env.GSTACK_HOME;
-  else process.env.GSTACK_HOME = ORIGINAL_GSTACK_HOME;
-  if (ORIGINAL_TELEMETRY_OFF === undefined) delete process.env.GSTACK_TELEMETRY_OFF;
-  else process.env.GSTACK_TELEMETRY_OFF = ORIGINAL_TELEMETRY_OFF;
-});
-
-beforeEach(async () => {
-  await fs.rm(TMP_HOME, { recursive: true, force: true });
-});
-
-afterAll(async () => {
-  await fs.rm(TMP_HOME, { recursive: true, force: true });
-});
-
-async function readEvents(): Promise<any[]> {
-  try {
-    const raw = await fs.readFile(TELEMETRY_FILE, 'utf8');
-    return raw.trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  } catch {
-    return [];
-  }
-}
-
-describe('telemetry: signals fire to ~/.gstack/analytics/browse-telemetry.jsonl', () => {
-  it('logTelemetry writes a JSONL line with ts injected', async () => {
-    const { logTelemetry, _resetTelemetryCache } = await import('../src/telemetry');
-    _resetTelemetryCache();
-    await logTelemetry({ event: 'domain_skill_saved', host: 'test.com', scope: 'project', state: 'quarantined', bytes: 42 });
-    const events = await readEvents();
-    expect(events).toHaveLength(1);
-    expect(events[0].event).toBe('domain_skill_saved');
-    expect(events[0].host).toBe('test.com');
-    expect(events[0].bytes).toBe(42);
-    expect(events[0].ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-  });
-
-  it('GSTACK_TELEMETRY_OFF=1 silences all events', async () => {
-    process.env.GSTACK_TELEMETRY_OFF = '1';
-    const { logTelemetry, _resetTelemetryCache } = await import('../src/telemetry');
-    _resetTelemetryCache();
-    await logTelemetry({ event: 'cdp_method_called', domain: 'X', method: 'y' });
-    const events = await readEvents();
-    expect(events).toHaveLength(0);
-    process.env.GSTACK_TELEMETRY_OFF = '0';
-  });
-
-  it('telemetry never throws even if disk fails', async () => {
-    // Point HOME to a path that doesn't exist + can't be created (root-owned)
-    // — but that's hard to set up cross-platform. Just check that calling
-    // logTelemetry on a missing directory doesn't throw.
-    const { logTelemetry, _resetTelemetryCache } = await import('../src/telemetry');
-    _resetTelemetryCache();
-    let completed: Promise<void> | undefined;
-    expect(() => { completed = logTelemetry({ event: 'noop_test' }); }).not.toThrow();
-    await completed;
-  });
-});

package/.agent/skills/gstack-browse/test/temp-dirs.test.ts

@@ -1,129 +0,0 @@
-/**
- * TEMP_DIRS portability allowlist (platform.ts) and its path-security wiring.
- *
- * TEMP_DIRS widens LOCAL path validation to include os.tmpdir() — on macOS
- * that is the per-user /var/folders dir, and TMPDIR-honoring CI/sandbox
- * environments point it elsewhere entirely. The load-bearing SECURITY
- * invariant is asymmetry: SAFE_DIRECTORIES (local read/write) gains
- * os.tmpdir(), while validateTempPath (REMOTE file serving, GET /file) stays
- * pinned to classic TEMP_DIR alone — widening that one would let a tunnel
- * client fetch files from an arbitrary TMPDIR (e.g. $HOME/tmp).
- */
-import { describe, it, expect } from 'bun:test';
-import { TEMP_DIR, TEMP_DIRS, IS_WINDOWS, isPathWithin } from '../src/platform';
-import { SAFE_DIRECTORIES, validateOutputPath, validateReadPath, validateTempPath } from '../src/path-security';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-const real = (p: string) => { try { return fs.realpathSync(p); } catch { return p; } };
-const tmpdirIsDistinct = real(os.tmpdir()) !== real(TEMP_DIR);
-
-describe('TEMP_DIRS allowlist shape', () => {
-  it('contains exactly TEMP_DIR + os.tmpdir() deduped, and SAFE_DIRECTORIES wires them realpathed alongside cwd', () => {
-    expect(TEMP_DIRS).toContain(TEMP_DIR);
-    expect(TEMP_DIRS).toContain(os.tmpdir());
-    expect(new Set(TEMP_DIRS).size).toBe(TEMP_DIRS.length);
-    // Nothing else sneaks into the allowlist.
-    for (const d of TEMP_DIRS) {
-      expect([TEMP_DIR, os.tmpdir()]).toContain(d);
-    }
-    expect(SAFE_DIRECTORIES).toContain(real(os.tmpdir()));
-    expect(SAFE_DIRECTORIES).toContain(real(process.cwd()));
-  });
-});
-
-describe('local commands accept os.tmpdir() paths (TMPDIR-honoring environments)', () => {
-  it('validateReadPath allows an existing file under os.tmpdir()', () => {
-    const f = path.join(os.tmpdir(), `browse-tempdirs-read-${Date.now()}.js`);
-    fs.writeFileSync(f, 'document.title');
-    try {
-      expect(() => validateReadPath(f)).not.toThrow();
-    } finally {
-      fs.unlinkSync(f);
-    }
-  });
-
-  it('validateOutputPath allows a new (not-yet-existing) file under os.tmpdir()', () => {
-    const f = path.join(os.tmpdir(), `browse-tempdirs-out-${Date.now()}.png`);
-    expect(() => validateOutputPath(f)).not.toThrow();
-    expect(fs.existsSync(f)).toBe(false); // validation never creates the file
-  });
-});
-
-describe('remote file serving stays pinned to TEMP_DIR alone (no exfil widening)', () => {
-  it('validateTempPath REJECTS a project file the local allowlist accepts — the actual exfil boundary, on every topology', () => {
-    // cwd is in SAFE_DIRECTORIES (local commands read project files) but must
-    // NEVER be servable to a remote agent. Unlike the os.tmpdir() case below,
-    // this holds regardless of where the environment points TMPDIR.
-    const f = path.join(process.cwd(), 'package.json');
-    expect(() => validateReadPath(f)).not.toThrow();
-    expect(() => validateTempPath(f)).toThrow(/temp directory/i);
-  });
-
-  it('validateTempPath and a distinct os.tmpdir(): rejected outside TEMP_DIR, allowed when nested inside it', () => {
-    if (!tmpdirIsDistinct) {
-      // On hosts where os.tmpdir() IS /tmp the widening is a no-op — the
-      // allowlist must have collapsed to the single dir.
-      expect(TEMP_DIRS).toEqual([TEMP_DIR]);
-      return;
-    }
-    const f = path.join(os.tmpdir(), `browse-tempdirs-remote-${Date.now()}.txt`);
-    fs.writeFileSync(f, 'served?');
-    try {
-      // Local commands accept it on every topology.
-      expect(() => validateReadPath(f)).not.toThrow();
-      if (isPathWithin(real(os.tmpdir()), real(TEMP_DIR))) {
-        // CI shard topology: the runner nests each child's TMPDIR INSIDE
-        // /tmp (e.g. /tmp/gstack-free-shard-*/tmp). The file is under
-        // TEMP_DIR, so serving it remotely is legitimate — the boundary
-        // under test is TEMP_DIR, not os.tmpdir() identity.
-        expect(() => validateTempPath(f)).not.toThrow();
-      } else {
-        // os.tmpdir() genuinely outside TEMP_DIR (macOS /var/folders,
-        // TMPDIR=$HOME/tmp sandboxes): the local-only allowlist must never
-        // reach the remote surface.
-        expect(() => validateTempPath(f)).toThrow(/temp directory/i);
-      }
-    } finally {
-      fs.unlinkSync(f);
-    }
-  });
-});
-
-describe('untrustable TMPDIR values never widen the allowlist', () => {
-  // TEMP_DIRS is computed at module load from os.tmpdir(), which honors
-  // TMPDIR — so a daemon launched with TMPDIR=/ or TMPDIR=$HOME must not
-  // trust that subtree for its whole lifetime. Probed via a subprocess so
-  // each case gets a fresh module load.
-  //
-  // POSIX-only: on Windows TEMP_DIR is DEFINED as os.tmpdir() (which reads
-  // TEMP/TMP, not TMPDIR), so the fixed-dir + movable-dir topology the guard
-  // filters does not exist — overriding the temp env vars there moves
-  // TEMP_DIR itself, and there is never a second entry to distrust.
-  const itPosix = IS_WINDOWS ? it.skip : it;
-
-  const probe = (tmpdir: string): string[] => {
-    const r = Bun.spawnSync([
-      process.execPath, '-e',
-      "import { TEMP_DIRS } from './browse/src/platform'; console.log(JSON.stringify(TEMP_DIRS));",
-    ], { env: { ...process.env, TMPDIR: tmpdir }, cwd: path.resolve(import.meta.dir, '..', '..'), timeout: 30_000 });
-    return JSON.parse(r.stdout.toString().trim().split('\n').pop()!);
-  };
-
-  itPosix('TMPDIR=/ and TMPDIR=$HOME collapse to TEMP_DIR alone; a cwd ancestor is rejected too', () => {
-    expect(probe('/')).toEqual([TEMP_DIR]);
-    expect(probe(os.homedir())).toEqual([TEMP_DIR]);
-    // Parent of the daemon cwd (the repo checkout's parent) — rejected.
-    expect(probe(path.resolve(import.meta.dir, '..', '..', '..'))).toEqual([TEMP_DIR]);
-  });
-
-  itPosix('a benign distinct TMPDIR (e.g. $HOME/tmp) is still honored for local paths', () => {
-    const benign = fs.mkdtempSync(path.join(os.homedir(), 'browse-tmp-probe-'));
-    try {
-      expect(probe(benign).map(real)).toContain(real(benign));
-    } finally {
-      fs.rmdirSync(benign);
-    }
-  });
-});

package/.agent/skills/gstack-browse/test/terminal-agent-detach-reattach.test.ts

@@ -1,84 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// v1.44 Commit 3 — detach state machine + ring buffer + re-attach replay.
-//
-// The state machine is what turns a single network blip from "fall through
-// to ENDED state, click Restart" into "silent re-attach with scrollback
-// intact, keep typing." Live WS cycles + buffer-overflow exercises belong
-// in the e2e tier; these static-grep tripwires defend the load-bearing
-// protocol + correctness properties.
-
-const AGENT_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent.ts');
-
-describe('terminal-agent detach + re-attach (v1.44+ Commit 3)', () => {
-  test('2. RING_BUFFER_MAX_BYTES default is 1 MB, env-overridable', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    expect(src).toContain('GSTACK_PTY_RING_BUFFER_BYTES');
-    expect(src).toContain('1024 * 1024');
-  });
-
-  test('3. DETACH_WINDOW_MS default is 60s, env-overridable', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    expect(src).toContain('GSTACK_PTY_DETACH_WINDOW_MS');
-    expect(src).toContain("'60000'");
-  });
-
-  test('7. WS open() re-attaches when sessionId already lives in sessionsById', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    const block = sliceBetween(src, 'open(ws) {', 'message(ws, raw) {');
-    expect(block).toContain('sessionsById.get(sessionId)');
-    expect(block).toContain('existing.liveWs = ws');
-    expect(block).toContain('clearTimeout(existing.detachTimer)');
-    // Tells the client to write RIS before treating the next binary
-    // frame as replay.
-    expect(block).toContain("type: 'reattach-begin'");
-    expect(block).toContain('sendBinary(buildReplayPayload(existing))');
-  });
-
-  test('8. WS close starts detach timer for non-intentional close codes', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    const i = src.indexOf('close(ws');
-    const j = src.indexOf('function handleTabState', i);
-    const block = src.slice(i, j);
-    // 4001 = intentional restart (Commit 2), 4404 = no-claude, 1000 = clean
-    // exit. Any other code (1006 abnormal, 1001 going-away, etc.) gets the
-    // 60s detach grace.
-    expect(block).toContain('code === 4001');
-    expect(block).toContain('code === 4404');
-    expect(block).toContain('code === 1000');
-    expect(block).toContain('session.detached = true');
-    expect(block).toContain('session.detachTimer = setTimeout');
-    expect(block).toContain('DETACH_WINDOW_MS');
-    // Detach timer must unref so the bun process can exit cleanly.
-    expect(block).toContain('detachTimer as any)?.unref?.()');
-  });
-
-  test('9. /internal/restart cancels detach timer before disposal', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    const block = sliceBetween(src, "url.pathname === '/internal/restart'", "// /claude-available");
-    // Without the cancellation, a later detach-timer fire would dispose a
-    // session that's already been disposed by the explicit restart path.
-    expect(block).toContain('clearTimeout(session.detachTimer)');
-  });
-
-  test('10. PTY on-data writes through session.liveWs (not the original ws closure)', () => {
-    const src = fs.readFileSync(AGENT_TS, 'utf-8');
-    // Critical for re-attach correctness: the PTY's on-data callback
-    // closes over `session`, not the original `ws`, so after re-attach
-    // it routes to the new liveWs automatically.
-    expect(src).toContain('session.liveWs.sendBinary');
-    // Always append to the ring buffer regardless of attach state — so
-    // a detached session still captures output for the next re-attach.
-    expect(src).toContain('appendToRingBuffer(session, flush)');
-  });
-});
-
-function sliceBetween(source: string, start: string, end: string): string {
-  const i = source.indexOf(start);
-  if (i === -1) throw new Error(`marker not found: ${start}`);
-  const j = source.indexOf(end, i + start.length);
-  if (j === -1) throw new Error(`end marker not found: ${end}`);
-  return source.slice(i, j);
-}

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

@@ -1,42 +0,0 @@
-import { afterEach, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const roots: string[] = [];
-const agent = new URL('../src/terminal-agent.ts', import.meta.url).href;
-
-afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-test('importing terminal-agent helpers does not boot the CLI or install process handlers', () => {
-  const root = mkdtempSync(join(tmpdir(), 'terminal-agent-import-'));
-  roots.push(root);
-  const result = Bun.spawnSync([process.execPath, '-e', `
-    const errors = process.listenerCount('uncaughtException');
-    const rejections = process.listenerCount('unhandledRejection');
-    await import(${JSON.stringify(agent)});
-    await Bun.sleep(2300);
-    if (process.listenerCount('uncaughtException') !== errors || process.listenerCount('unhandledRejection') !== rejections) process.exit(2);
-    console.log('imported without boot');
-  `], {
-    env: { ...process.env, HOME: root, BROWSE_STATE_FILE: join(root, 'browse.json'), BROWSE_AGENT_GEN: 'missing-record' },
-    timeout: 6000,
-  });
-  expect(result.exitCode).toBe(0);
-  expect(new TextDecoder().decode(result.stdout)).toContain('imported without boot');
-  expect(new TextDecoder().decode(result.stderr)).not.toContain('[terminal-agent]');
-}, 8000);
-
-test('direct terminal-agent execution still refuses an unconfirmed startup record', () => {
-  const root = mkdtempSync(join(tmpdir(), 'terminal-agent-direct-'));
-  roots.push(root);
-  const result = Bun.spawnSync([process.execPath, fileURLToPath(new URL('../src/terminal-agent.ts', import.meta.url))], {
-    env: { ...process.env, HOME: root, BROWSE_STATE_FILE: join(root, 'browse.json'), BROWSE_AGENT_GEN: 'missing-record' },
-    timeout: 6000,
-  });
-  expect(result.exitCode).toBe(1);
-  expect(new TextDecoder().decode(result.stderr)).toContain('terminal-agent startup record was not confirmed');
-}, 8000);