v1.74.0.0 test/CI overhaul: green means green, suites restructured for speed (#2721)

* fix(ci): free-tests lane actually runs the make-pdf e2e gates The 9 make-pdf/test/e2e gate tests probe make-pdf/dist/pdf, browse/dist/browse, and the diagram-render bundle, then self-skip when absent. The required free-tests lane never built any of them, so the gates silently skipped on Linux for their entire life (verified: 9 of 14 skip, exit 0). make-pdf-gate.yml's justification for deleting its Linux leg claimed the free lane covered this — it didn't. - new build:gates script: exactly the three artifacts the gates probe (full bun run build compiles five binaries; ~60-90s tax on the only required check is not warranted) - free-tests.yml: build:gates step + poppler-utils + fonts-noto-color-emoji (fonts must precede the first browse daemon launch — Chromium snapshots fontconfig at startup; verified live: a warm daemon renders tofu, a fresh one embeds NotoColorEmoji) - make-pdf/test/e2e/ci-prereqs.test.ts: GSTACK_EXPECT_BINARIES=1 (set by the workflow) inverts the skip polarity in CI — dropping the build step or poppler fails the lane instead of re-opening the silent-skip hole Pre-flight: all 9 gates green on Linux locally. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): kill the three zero-test eval jobs (hollow green) - delete the vestigial e2e-codex / e2e-gemini matrix rows: both files are whole-file periodic-tier, so with no row tier: they ran ZERO tests and reported green on every PR (~2 min of runner each, pure false confidence; the periodic lane owns those suites) - e2e-pty-plan-smoke gains tier: gate — its two files are whole-file describeE2ETier('gate'), so the job burned ~7 min of container setup then skipped every describe - KNOWN_TIER_UNSET burned down to empty; the ratchet stays armed so a future row/file tier mismatch fails the suite instead of shipping hollow green Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): least-privilege permissions + fork-safe concurrency keys - evals.yml / evals-periodic.yml evals jobs: explicit contents:read + packages:read (container-image pull) and persist-credentials:false — the jobs that execute PR-authored code with three provider API keys ran on the repo-default token grant with the token written into .git/config - permissions blocks for the 4 workflows that had none (skill-docs, make-pdf-gate, windows-free-tests, windows-setup-e2e) - fork-safe concurrency keys: actionlint, skill-docs, make-pdf-gate, windows-setup-e2e switch from head_ref to PR-number keying — a bare branch name carries no fork prefix, so same-name branches from two forks shared one group and cancelled each other's runs Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): one bun version everywhere + drift tripwire Lanes disagreed four ways: 1.3.13 (free-tests, windows, Dockerfile.ci), latest (quality-gate, make-pdf-gate), unpinned (skill-docs, version-gate — setup-bun installs latest), 1.3.10 (.gitlab-ci.yml). Different Bun versions change the runner output shapes the strict classifiers regex-match, spawn semantics, and shell parsing — a lane on a different Bun tests a different product; Dockerfile.ci's own comment records this class biting once already (silent 1.3.13/1.3.14 drift). All surfaces pinned to 1.3.13; test/bun-version-drift.test.ts scans every workflow setup-bun stanza + Dockerfile.ci + .gitlab-ci.yml and fails on any mismatch or unpinned stanza. skill-docs also gains --frozen-lockfile (was bare bun install). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(ci): bind the three-way image-tag hashFiles() expressions evals.yml, evals-periodic.yml, and ci-image.yml each compute the CI image tag from hashFiles('.github/docker/Dockerfile.ci', 'bun.lock', 'patches/**') — synced by comment only (TODOS.md 'CI three-way image-tag drift'). If one input list drifts, that workflow computes a different tag for the same content: eval lanes silently rebuild the image every run, or ci-image prebuilds a tag nobody looks up. The test extracts each tag-computation site and fails on any mismatch. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): ci-image stops rebuilding the identical image every ship - package.json out of the trigger paths: the tag hash deliberately excludes it (version bumps every ship), so every merge rebuilt and re-pushed the IDENTICAL tag (~2m26s for zero content change); patches/** added (it IS a tag input) - manifest existence check (mirrors evals.yml): tag already exists → skip the build - concurrency group: two rapid main pushes raced pushing the same :latest/:buildcache tags - cron staggered 06:00→04:00 Monday: it shared the exact minute with evals-periodic, which could race a half-pushed tag or duplicate the build - timeout-minutes: 30 (was unbounded → 360-min default for a hung docker build) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): quality-gate drops the 74s full-history checkout fetch-depth:0 cost 74 of the job's 92 seconds; the three gates it feeds take ~12s combined. Shallow checkout + exact-SHA fetches for the diff's base/head (an exact-SHA fetch, not a guessed depth — long-lived branches and merge queues still resolve), with a --deepen fallback for push events whose 'before' is unusable. timeout right-sized 20→10 min. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): small-lane batch — timeouts, right-sizing, windows cache warm-start - timeout-minutes on the 6 remaining unbounded jobs (actionlint 5, skill-docs 10, version-gate 10, make-pdf-gate 15, pr-title-sync 5, evals build-image 15) — a hung step sat on GitHub's 360-min default - right-size measured-over-long timeouts: dependency-review 10→5, windows-setup-e2e 15→10 - dependency-review: 2-core runner (28s API call on an 8-core box) and drop .github/workflows/** from its trigger paths (workflow edits have no dependencies to review) - windows caches gain restore-keys: a lockfile bump paid the 26s/43s restore for a guaranteed cold miss Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): scope GSTACK_HOME to each file's execution window Five files assigned process.env.GSTACK_HOME at module scope. Shard processes evaluate sibling modules before running their tests, so the assignment leaked into every other file in the shard — the damage was already visible in defensive workarounds (relink.test.ts:28 'fresh install test saw a neighbor's skill_prefix'; cdp-e2e's own comment documents a sibling's temp dir baked into artifacts). Pattern: save original, assign in beforeAll, restore in afterAll (cdp-e2e already restored but still assigned at load — its window now matches the others). GSTACK_TELEMETRY_OFF and GSTACK_PROJECT_SLUG get the same treatment where they rode along. Victim files' defenses stay in place (cheap insurance). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test: tripwire against module-scope GSTACK_HOME assignments Column-0 assignment of GSTACK_HOME / GSTACK_STATE_ROOT in any tracked *.test.ts fails with the file:line and the fix (beforeAll + afterAll restore). Kills the cross-file env-leak class the previous commit swept. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): e2e-harness-audit derives its skill census from disk The hand-maintained 39-name SKILL_GLOBS list had drifted to 39 of 54 SKILL.md.tmpl on disk. No live gap today (none of the 15 unlisted skills is interactive), but the next interactive skill would have landed unguarded with zero signal. The audit now walks top-level dirs for SKILL.md.tmpl (statSync so symlinked dirs like connect-chrome count), so new skills are in scope the commit they appear. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(evals): judges honor the eval-model resolution chain + real 429 backoff callJudge inlined GSTACK_EVAL_MODEL_JUDGE || sonnet, silently ignoring the global GSTACK_EVAL_MODEL override every other eval call site honors via lib/eval-model.ts. New 'judge' kind in DEFAULTS (sonnet — the D1a pin-on-regressors calibration stands; model CHOICE unchanged) and callJudge resolves through it: explicit arg > GSTACK_EVAL_MODEL_JUDGE > GSTACK_EVAL_MODEL > default. 429 handling upgraded from one fixed 1s retry (reliably lost races at CI concurrency) to three jittered exponential retries (~1s/4s/16s), honoring the server's retry-after when present. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): the two expect(true) paid stubs become test.todo skill-e2e-spec-execute (600s budget) and skill-llm-eval-spec (300s) reported PASS on every periodic run while asserting nothing. Deleting them would remove the periodic-tier selector surface they exist to register (diff-based selection for spec/ changes), so they become test.todo — reported as todo/skip, never pass — with the v1.1 implementation specs kept in-file. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): reactivate 5 quarantined browse tests (2 security) extension-sender-auth's two privileged-message denial tests (content script + missing sender.url — the extension's security boundary) and snapshot's three skips were quarantined 'pre-existing' failures. Root cause: machine-local state on the quarantining dev machines — the test and gate code are byte-identical between the quarantining commit (410b4928) and HEAD, and all five pass deterministically on a clean checkout (68/68 across both files, multiple runs). No assertions weakened, no product changes. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(evals): activate the 4 paid test files that could never run anywhere carve-section-loading, codex-e2e-plan-format, codex-e2e-recommendation-substance, and llm-judge-recommendation gated on EVALS/tier (free suite loads them as describe.skip) but their names fell outside PAID_TEST_GLOBS, so no paid lane ever selected them — net execution zero, forever. The existing matrix tripwire filtered on isPaidTestFile() first, so it was blind to exactly this class (the same bug that hid the pre-split monolith's gate tests for ~8 releases). - PAID_TEST_GLOBS: codex-e2e* + skill-llm-eval* wildcards (replacing exact names) + llm-judge-recommendation + carve-section-loading; package.json's six test-script glob lists mirrored - codex-e2e-plan-format gains the explicit periodic tier gate its siblings carry (external-service rule) — without it the sharded runner's no-guard default would spawn Codex in the gate tier per PR - eval:bg:periodic --timeout 32400→37800: the census growth pushed the periodic worst case to 35910s; the old value had 270s of headroom BEFORE this change and would now kill healthy runs mid-flight - new test/paid-orphan-tripwire.test.ts: any EVALS/tier-gated test file outside the globs fails the free suite (reasoned SCANNER_EXEMPT for the gate helpers + meta-tests) — the class-killer - paid-shards pins updated: the four orphans now assert INSIDE the census Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(browse): restrictDirectoryPermissions warns and skips symlinked dirs Closes the Windows Free Tests red: recent lane failures showed a platform-unguarded POSIX mode-bit assertion ('Expected: 493' — a symlink-skip test) from PR-branch variants; the KNOWN_WINDOWS_SAFE force-include reason ('mode-bitmask hits are POSIX-branch only') did not hold for that shape, and main had neither the guard nor the behavior. - product: lstat first; a symlinked dir gets a warning and a skip on both platforms — chmod AND icacls dereference the link, so restricting through a symlink hardens an unvetted target (and /inheritance:r could lock out its real owner). All callers already treat hardening as best-effort (try/catch). - test: the symlink regression test, platform-aware — symlinkSync in the house try/catch skip pattern (Windows runners without Developer Mode can't create symlinks), mode-bit assertion guarded off win32, behavior assertions (no throw, warning text, target readable) everywhere; POSIX still proves the skip (0o755 unchanged, not 0o700) - KNOWN_WINDOWS_SAFE reason updated to the now-true premise 20/20 pass on Linux. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): unique tmp dirs for plan artifacts + audited live-repo cwd sites Six paid PTY tests wrote their expected plan artifact to a FIXED shared /tmp path ('/tmp/gstack-test-plan-<mode>.md') and rmSync'd it in finally — under --retry 1, EVALS_JOBS>1, or two concurrent worktrees, a sibling's cleanup deletes this run's artifact and the D19 'agent did not produce expected plan file' assertion fires spuriously. Each test now mkdtemps its own dir, interpolates the unique path into the agent prompt (fixture-sourced prompts get a replaceAll + drift guard that throws if the fixture's literal ever moves), and cleans up its own dir. The 18 cwd:-into-the-live-repo sites were audited: all deliberate (skill registry + hermetic pre-trusted dir, in-repo gen renders, git history reads, slug resolution) — each now carries a '// LIVE-REPO CWD: <reason>' comment so the next audit can tell deliberate from accidental. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): trim the seven over-wall 1700s timeouts to the 1500s physical ceiling 1,700,000ms (28.3 min) exceeded every wall these tests run inside: the 25-min CI job timeout and the 1800s sharded-runner wall (which also leaves --retry 1 zero room for a second attempt). Budget above the wall is fiction, not headroom — a test that actually used it produced a job-level kill (no bun summary, no artifact) instead of a clean per-test timeout. No recorded p95 exists for this family (they are being retiered to periodic in the re-platform wave); the trim stops at the physical ceiling rather than guessing lower. Final policy lands in the Wave-2 eval-budgets constants module. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(gen): main() guard — importing gen-skill-docs no longer regenerates the tree The generator's whole body executed at module load, so any import of it (test/gen-skill-docs.test.ts pulls assertSinglePreamble via require(); test/catalog-trim.test.ts imports helpers) regenerated all 71 SKILL.md in place — the root cause of half the TREE_MUTATING serial-shard entries (hazard class #2532). The body now lives in an exported main(): number behind if (import.meta.main). Semantics preserved exactly: failure exits are immediate (matching the old top-level process.exit), success leaves the event loop to drain so the llms.txt fire-and-forget IIFE finishes its write, and the module stays synchronous/require()-able. Proofs: byte-identical --host all output (git status clean), --dry-run stale-tree still exits 1 (the skill-docs freshness lane depends on it), and the new test/gen-skill-docs-import-purity.test.ts pins load-time purity via a subprocess probe (mtime-based, so a dirty worktree can't false-fail). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(gen): --out-dir renders every host, outputs-only --out-dir was Claude-host-only (gen-skill-docs.ts:842), which forced the codex/factory-regenerating tests (gen-skill-docs, skill-validation, host-config) to mutate the live tree — the reason they sit in the TREE_MUTATING serial shard. The flag now mirrors ALL outputs into the out-dir: external-host trees (.agents/.factory/... via processExternalHost), external section files, openclaw docs, and gstack/llms.txt (a catalog-mode render must never rewrite the tracked index). OUTPUTS ONLY — inputs (templates, sections/, host configs) are always read from ROOT, so an empty out-dir can never feed the render. rewriteSectionBase stays Claude-only (external hosts have their own path grammar). Proofs: in-place --host all is byte-identical (tree clean); --host all --out-dir <mkdtemp> renders the full multi-host tree with ROOT untouched; gen-skill-docs-out-dir tests + 415/415 gen-skill-docs.test.ts green (bin/dev-setup's claude rendering byte-compat). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(evals): every E2E key's dep list names its own declaring test file 129-of-177 keys omitted their own test file, so editing only a test's prompt or assertions selected NOTHING — the changed test never ran on the change that changed it. 135 keys self-registered (110 E2E + 25 LLM-judge), resolved by strict declaration evidence (testName:/ testIfSelected/judge call sites), with skill-name false positives excluded. e2e-tier-alignment's warn-only branch for unregistered files is now a hard failure with a 4-entry KNOWN_UNREGISTERED ratchet (template- literal testNames, fail-open-safe) + a burn-down test so the set only shrinks. Selection sanity: a one-file diff on skill-e2e-qa-workflow now selects its 4 tests (was 0); skill-llm-eval 0 → 25. Known follow-ups (filed): 15 E2E + 2 judge PHANTOM keys select tests that exist nowhere; codex-e2e-plan-format's testIfSelected names have no map keys (run-all only). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(evals): ratchet the 8 newly-visible gate-matrix gaps The self-registration sweep made these eight files' gate-tier keys visible to the census for the first time — their gate tests run in NO CI lane today (pre-existing hole, newly measurable). Ratcheted into KNOWN_MATRIX_GAPS with the burn-down note: the paid-lane re-platform runs every gate file by construction and retires this ratchet class. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(test): duration-aware LPT shard packing for the free suite Hash sharding balances file COUNTS (1.15x spread) but not cost — the Playwright-launching files landed 4/3/4/1/2/1 across 6 shards, giving a measured 28s–97s shard spread and ~40s of idle tail on every run. Full-suite mode now packs by recorded per-file durations (longest-processing-time-first) when the committed seed scripts/free-test-durations.json exists. - ONE store, no overlay: the seed is refreshed occasionally via the new --record-durations mode (each file timed in its own child — exact, and immune to bun's stream buffering, where silent passers print no header to timestamp); GSTACK_FREE_TEST_DURATIONS overrides the path for experiments; CI never records - seed is a hint: missing → silent hash-shard fallback; corrupt (bad merge) → one warning + fallback; unknown files → 75th-percentile pessimism so a surprise long-runner can't recreate the tail - packed shards get duration-aware walls (max(base, predicted x 3)) — LPT decouples count from cost BY DESIGN, so the 5s/file heuristic would undersize a shard holding few expensive files - one log line per shard (files + predicted seconds) so packing regressions are diagnosable from any run log - the --shard CI-matrix path is untouched: stable hash indices are its contract - successor note in-code: bun >=1.3.14 ships native --timings/--shard LPT — swap this packer when the repo unpins 1.3.13 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): decouple slop:diff from bun run test; quality-gate runs it per PR 'bun run test' silently appended up to two 120s npx slop-scan runs plus a git worktree add/remove after the suite (2>/dev/null || true) — invisible in the documented '~90-100s' timing and pure friction in the pre-commit loop. Decoupling is not coverage removal: quality-gate.yml now runs slop:diff on every PR (advisory, matching its in-repo 'never blocking' contract), and /review already invokes it explicitly. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(test): eval-budgets timeout tiers + fit/ceiling policy test Five named tiers (JUDGE 120s / CAPTURE 300s / CAPTURE_LONG 600s / PTY 900s / PTY_LONG 1200s) replace hand-ratcheted sprawl (46x300s, 46x120s, 44x360s, 44x180s, 27x240s, 19x150s, 13x420s, 12x600s...), much of it inflated to paper over the old 40-way in-shard concurrency that the sharded runner's 1-file-per-shard model kills. Policy test pins: every tier fits the shard wall minus 120s overhead (the structural fix for budgets-above-the-wall fiction), tiers stay ordered, and no paid literal exceeds PTY_LONG x1.25 — oversized tests get split, not budgeted past the wall. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(test): shared runBin helper for bin-script unit tests ~36 free test files each carry a near-identical local run() (spawnSync + utf-8 + {status, stdout, stderr}) differing only in env composition, cwd, and timeout. runBin absorbs the invariant core; options carry the variance (gstackHome sets BOTH GSTACK_HOME and GSTACK_STATE_DIR — the config-precedence trap several locals rediscovered independently; home for $HOME-anchored bins; input/trim/timeout/maxBuffer). Free-test-only by design so it never becomes a de facto global touchfile. Migration of the 36 call sites lands separately (mechanical batches). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): runBin trim assertion — trim shapes stream ends, not interior Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(test): mechanical sweep — 298 paid-test timeouts onto eval-budget tiers 69 files, both shapes (trailing bun-test budgets and runner timeout/timeoutMs options), ROUND-UP ONLY so nothing that passed can start failing: 75 → JUDGE_MS, 137 → CAPTURE_MS, 74 → CAPTURE_LONG_MS, 9 → PTY_MS, 3 → PTY_LONG_MS. Raw >=60s literal count in the paid scope: 395 → 97, of which 51 are non-timeout noise (fixture dates, run IDs) and 46 are enumerated justified holds (comment-carrying calibrated budgets, poll-loop constants, utility spawn waits, and the seven physical-ceiling 1_500_000 sites). The eval-budgets policy ratchet keeps the residue from regrowing. Known collapse: where an inner runner budget and its enclosing test budget now share a tier, the old stagger is gone — an overrun surfaces as a bun test timeout instead of a graceful runner timeout (diagnosability trade, not a correctness one). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test: coverage fill — 95 tests for six zero-coverage surfaces - eval CLI family (eval-list/compare/summary + eval-select smoke): the primary interface to eval results had no tests; isolation via a fake gstack-slug under a mkdtemp HOME (the scripts' real resolution path — they do NOT honor GSTACK_EVAL_DIR; only EvalCollector does). Pinned current behavior: eval-list does NOT exclude _partial runs (documented improvement candidate) - slop-diff (runs on every /review + quality-gate): fixture git repo + first-on-PATH npx stub (never downloads real slop-scan); no-diff early exit, missing-scanner fallback, fingerprint line-insensitivity, merge-base worktree scan - bin/gstack-code-intelligence CLI arg surface (lib was covered, the 284-line CLI wasn't): select/consent/suggest/index/search gating; pinned: --help routes to usage failure exit 1 (no handler) - browse media-extract: the page.evaluate callback exercised in-process against a mock DOM (no exports added) — lazy-src fallback chain, HLS/DASH detection, bg-image url() parsing, 500-element cap - browse session-cookie-store: factory contract (cookieName/ttlMs/ maxSessions eviction, cross-store isolation, mint→validate round-trip); store is in-memory — no fs cases exist - lib/version-source direct unit tests (gstack-version-bump.test.ts spawns the bin, never imports the lib): parse/format/cmp/bump coercion, npm 4→3 translation, #2501 mangled-JSON regression class All hermetic (mkdtemp homes, runBin child isolation); windows curation correctly partitions the six. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(test): first runBin migration batch (3 of ~36 run() duplicates) explain-level-config, benchmark-cli, evidence move onto the shared helper; each file's remaining special-case spawnSync sites (raw-buffer probes, env-scrub probes) stay put deliberately. 55/55 green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(evals): paid shards spool to disk + shared runShardChild lifecycle - runPaidShard no longer buffers whole 30-min stream-json streams in RAM (x concurrent jobs): every byte tees to a per-shard log file (slug-named, path printed at START for mid-run inspection and on the FAILED terminal line); failures print a 64KiB tail read back from disk; passing shards stay quiet (the file is the record) — the free runner's proven contract. Classification unchanged: the strict classifier still sees every byte first. - the ~35 duplicated spawn/group-kill/wall-timer/finally-reap lines move into runShardChild in test-strict-output.ts (detached-per- platform spawn, signal forwarding, SIGKILL group kill at the wall, drain-before-verdict); designed so the free runner can migrate later - expectedFiles drift fixed toward ENFORCEMENT: the injected-command exemption is gone — a fake command exiting 0 without bun's terminal summary now reads FAILED (pinned: silent-pass → failed) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(evals): parent-computed selection propagates to shard children The sharded runner computed diff selection once, then each of its 48-73 children recomputed it at module load — including, on touchfiles-diff branches, a per-child bun subprocess evaluating the old data file (20s timeout each). The parent now serializes {version, selected, reason} as EVALS_SELECTION_JSON into the shard env; e2e-helpers adopts it at load. Fail-open preserved: any parse/shape violation → ONE stderr warning + local recompute; absent env → silent local compute (non-sharded entrypoints unchanged). Drift test pins parent→child round-trip to identical selection decisions plus the malformed/absent cases. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): kill the four worst fixed sleeps (300s/30s/30s/20s) - watchdog.test: the 20s blind wait for one production parent-watchdog tick becomes BROWSE_PARENT_WATCHDOG_INTERVAL_MS=250 (new env knob in server.ts, NaN-safe, production default unchanged) + polls for the boot line and the tick's stay-alive log — strictly stronger (the old form never proved a tick observed the parent death). 24s → 3.6s. - stop-dead-daemon / terminal-agent-owner-watchdog: the 300s/30s stand-in child lifetimes become stdin-EOF-bound — the child can never self-exit mid-test on a slow runner (spurious-failure class) and self-reaps instantly if the test dies (no 300s orphans). Node-compat stdin APIs (owner-watchdog runs on the Windows lane). - browser-skill-commands: the sleeper fixture's 30s self-time becomes 8s (no stdin pipe exists in runToFiles) — far above the 1s product timeout it must outlive, below the test ceiling, so a timeout-kill regression fails on clean assertions instead of an opaque bun timeout; added: stdout must NOT contain 'done'. 45/45 green across the four files + server tripwires. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): gen-skill-docs + catalog-trim leave the serial mutator shard gen-skill-docs.test.ts's 15 in-place generator spawns now render into mkdtemp out-dirs (gitignored-artifact reads repointed; the handshake scan's silent console.warn degrade became a hard assertion); its tracked-tree reads (freshness dry-run, SKILL.md content pins) stay reads. catalog-trim needed no change beyond the earlier main() guard — its import is now side-effect-free (pinned by the import-purity test). Both TREE_MUTATING entries deleted in this commit, per the transition rule: an entry leaves in the same commit as the file's last in-place write. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): skill-validation renders codex host into an out-dir Its 3 in-place --host codex regeneration sites collapse into one module-level --out-dir render; assertions untouched. TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): host-config self-provisions goldens (ordering dependency severed) Its goldens were 'produced by gen-skill-docs.test.ts' with a when-missing beforeAll fallback that wrote the live tree — an inter-test ordering dependency the serial shard hid. It now renders codex+factory UNCONDITIONALLY into its own out-dir and reads goldens only from there (the Claude golden deliberately keeps reading tracked ship/SKILL.md — a read; out-dir claude renders repoint section-base paths by design). TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): gbrain-detection-override drops mutate-then-git-restore regenAndSnapshot renders --host claude --out-dir <mkdtemp> (+ --respect-detection) and snapshots probes from the out-dir. The git-restore machinery is deleted outright — it restored only PROBE_FILES of the 71 files each call wrote, so a stale tree kept the other 68 dirty (the partial-restore bug), and its 'no output-path arg' comment had been false since --out-dir landed. TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): catalog-mode-full renders to out-dir; restore machinery deleted The full-catalog smoke no longer rewrites all 71 SKILL.md then regenerates to restore (with its 'CRITICAL: failed to restore' prayer path) — it renders into a mkdtemp and additionally asserts tracked ship/SKILL.md is byte-unchanged. TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): idempotency proof strengthens to two-out-dir recursive diff Two renders into two separate out-dirs, EVERY file diffed byte-for-byte (claude-only and --host all; normalization only for each dir's own sanctioned section-base repoint; presence-sanity lists guard against a vacuous empty-dir pass) — strictly stronger than the old in-place double-regen that sampled 5 files. TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): spec-template-sync compares an out-dir render, not an in-place one TREE_MUTATING entry deleted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(test): the serial tree-mutating shard dissolves — TREE_MUTATING is empty Zero mutators remain (all eight render into out-dirs now), so the four ratchet READERS (parity caps, size budgets, carve parity/ordering) get a quiet tree by construction in any shard and rejoin the parallel phase. The ~35-40s serial tail on every full-suite run is gone. The mechanism stays: a future test that genuinely must write shared artifacts in place earns an entry with a reason and is serialized again; the census pin still fails on renamed keys. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(gen): out-dir byte-identity + tree-clean pins for external hosts codex render: porcelain unchanged AND out-dir gstack-ship/SKILL.md byte-identical to a fresh in-place render (+openai.yaml presence); --host all render: exit 0, porcelain unchanged, claude + .agents + .factory + llms.txt + openclaw docs all present in the out-dir. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(test): commit the initial free-test durations seed (496 files) Recorded via --record-durations on a quiescent tree: 479s serial total, p50 92ms / p90 1.8s / max 31.4s — the top-heavy cost shape LPT packing exists for. A hint, not a contract: refresh opportunistically with bun run test:free --record-durations. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(evals): planner/executor/report modes — the CI re-platform surface One PLANNER computes diff selection + the slice plan ONCE and writes a manifest (--emit-plan <path> --slices K); K executors consume it (--plan <path> --slice i), never self-selecting, and write slice-result artifacts; a REPORT reconciles results against the manifest (--report <dir>) fail-closed: a slice whose artifact never landed is a FAILURE, a planned shard nobody reported fails, wrong-slice/duplicate/cross-tier results fail. Kills per-slice selector divergence and hollow-lane aggregation at the root. - hollow-shard guard: under EVALS_ALL, exit 0 with ZERO executed tests (bun's 'Ran N tests' now captured by the classifier — additive) is 'passed-empty' and fails the run; selective runs keep it 'passed' with one warning (in-file diff/tier self-skips are legitimate there); unknown counts are never guessed hollow - retry parity: --retry 1 default + RETRY_OVERRIDES literals for the three files whose old matrix rows earned retries: 2 (stale entries pinned against disk) - live smoke: gate plan = 48 shards across 6 slices; report mode exits 1 on a fabricated missing slice, 0 when complete Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(ci): sliced paid lane (planner -> 6 executors -> fail-closed report) The parity-phase re-platform: evals.yml gains a second, sliced lane driven by scripts/test-paid-shards.ts — the SAME engine local eval:bg:gate uses, so CI and local share one selection engine. - plan-slices: ONE planner (fetch-depth 0 — the only job needing history) emits the manifest; selection fails open to run-all, never per-slice (the divergence class is structurally dead) - eval-slices: 6-way matrix consuming the manifest; PTY seed + skill-registration steps run unconditionally (idempotent — a sliced lane cannot key them on suite names); aggregate spawn budget 6 x EVALS_JOBS=2 x EVALS_CONCURRENCY=2 = 24 lane-wide (the matrix's 40-way per row queued session startup behind 39 siblings — the timeout-flake family root); slice results + spooled shard logs uploaded as artifacts - slices-report: reconciles slice artifacts against the manifest FAIL-CLOSED via --report — a slice whose artifact never landed, or a planned shard nobody reported, is a failure, not an absence - sequenced needs: evals so provider concurrency never doubles while both lanes coexist; the matrix + its ratchets are deleted after demonstrated parity (intersection + expected-additions comparison) - workflow_dispatch gains evals_all (default true) for parity runs and post-merge smokes — a dispatch can never silently select zero Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(ci): weekly periodic lane runs EVERY periodic test + gate census backstop evals-periodic.yml re-platforms onto the sharded runner: planner manifest → 6 executor slices → FAIL-CLOSED report. This IS the coverage contract: all ~70 periodic-tier files weekly (EVALS_ALL=1), killing the silent-rot class where a hard-coded 9-file matrix left ~57 files running NOWHERE (the autoplan E2E rotted invisibly for months). - test/helpers/periodic-exclude-data.ts: reasoned exclusions in their OWN literals file (deliberately not touchfiles-data — map-diff evaluates old versions of that file standalone). Every entry carries reason + tracking with a re-entry condition; the runner surfaces each exclusion per run; policy test pins real-file + non-empty fields. Initial: ship-idempotency + brain-privacy-gate (documented-red, never green) and skill-e2e-ios (manual hardware). The TODOS 'sidebar E2E trio' turned out already deleted — only tombstone tests remain. - gate-census job: weekly EVALS_ALL gate-tier run — PR lanes are diff-billed, so without this the full gate census might never execute anywhere; with the hollow-shard guard it is a census-health check (exit 0 + zero executed tests fails), not just a test run. - failure notification is a concrete gh issue UPSERT (one tracking issue, commented per red week — never issue-per-week spam), with issues:write scoped to the report job. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs: TESTING_INTERNALS covers the 2026-08 runner overhaul LPT-packed free suite + --record-durations, the emptied TREE_MUTATING mechanism, the sharded paid runner as the single selection engine, CI planner/executor/report with the fail-closed report and hollow-shard guard, the weekly coverage contract + exclusions policy, and the eval-budgets timeout tiers. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(CLAUDE.md): testing prose matches the overhauled runners - bun run test: duration-packed shards + --record-durations; the trailing serial tree-mutating shard no longer exists - two-tier system: the sliced CI lanes (one engine local+CI), the weekly all-periodic coverage contract + exclusions, the gate census - periodic detach timeout 32400 → 37800 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(TODOS): close the absorbed test-infra items, file the overhaul follow-ups Closed with receipts: the periodic coverage contract (implemented as full weekly coverage + exclusions), the eval-harness observability P1 (verified already landed: heartbeat, incremental _partial persistence, live stderr + eval-watch), and the sidebar trio (already deleted — tombstones remain). Filed: matrix deletion after parity, the required-check maintainer decision, browse /tmp-namespace hardening, PTY boot-readiness waits, the single typed test registry, bun-native LPT swap, runBin/free-runner migrations, eval-list partial exclusion, phantom key cleanup, duration-weighted slicing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * v1.73.0.0: test/CI overhaul — green means green, suites restructured for speed Version + release notes for the audit-and-overhaul branch: every silently-skipping or never-running test class fixed and tripwired, the free suite duration-packed with the serial mutator shard dissolved, the paid lane re-platformed onto the sharded runner (planner/slices/ fail-closed report, parity phase), the weekly all-periodic coverage contract, eval-budget timeout tiers, and 95 new coverage tests. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ci): first-live-run fixes — executor history + two environment-blind assertions The sliced lane's first run (PR #2721) did its job: the planner and report worked, the manifest governed, and every failure had a name. Three were fixable on the spot: - executor + gate-census checkouts get fetch-depth: 0 — files with SELF-derived selection (the LLM-judge map, routing) walk git at module load, and selection is deliberately fail-closed on git errors, so the shallow checkout crashed those shards ('ambiguous argument main...HEAD'). The manifest still governs WHICH shards run. - landscape --toc gate: the exact toBe(3) landscape-page count was font-metric-dependent (3 on Amazon Linux, 2 on ubuntu CI — the same disease the file's own page-index comment warns about). Now a comparative invariant: --toc must not CHANGE the landscape count vs a baseline render. - paid-run-manifest parse test builds its manifest under EVALS_ALL so it never walks git (proven with GIT_DIR=/nonexistent). Remaining first-run failures are newly-exposed rot in gate files that had never executed in CI (skillify D1 refusal, session-intelligence context-restore, one tpa-apple-ban retry flake) — being probed separately; they are the lane WORKING, not the lane failing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(TODOS): file the three first-execution findings from the sliced lane's live run Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * v1.74.0.0: queue-advance — #2722 claims the v1.73.0.0 slot The version gate caught a live queue collision (its whole job); same MINOR bump level, next free slot per bin/gstack-next-version. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): per-shard CHROMIUM_PROFILE — the collision class duration packing exposed Nine test files launch in-process persistent contexts or daemons that default to the SHARED ~/.gstack/chromium-profile. Two concurrent shard processes on one profile dir kill each other's browser — observed live on CI once duration packing recomposed shards: handoff's launchPersistentContext died 'Target page, context or browser has been closed' (--user-data-dir=~/.gstack/chromium-profile in the call log) while a sibling shard's daemon logged 'Chromium process crashed'. Hash sharding had masked the collision by chance placement; handoff passes standalone everywhere. Fix at the runner, not per file: each shard child gets CHROMIUM_PROFILE=<shard-state>/chromium-profile (the documented env knob, same isolation idea as the existing per-shard TMPDIR). Files within a shard run serially, so sharing the per-shard profile is safe; config.test's resolution-order tests save/restore the env around their assertions. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): landscape --toc gate asserts promotion PRESENCE, not counts Two rounds of CI receipts: the exact toBe(3) was font-metric-coupled (3 on Amazon Linux, 2 on ubuntu), and the baseline-comparison repair then failed 2-vs-3 across renders SECONDS apart in one CI job while the sibling no-toc test saw 3 — per-render image-promotion timing makes any count assertion here a coin flip. The sibling test owns exact promotion counts; this test's actual invariant is that --toc does not break the promotion machinery: >=1 landscape page + the TOC rendered. Also drops the second render (halves the test's runtime). Flaky per-render image promotion itself is worth its own look — noted in TODOS with these receipts. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(TODOS): file the per-render image-promotion nondeterminism (receipts from PR #2721) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): per-FILE Chromium profiles for the nine in-process launcher files Completes the profile-isolation work: the per-shard CHROMIUM_PROFILE stopped cross-shard kills; these nine files launch in-process persistent contexts and could still collide with a lingering daemon a sibling file spawned on the SAME shard profile. Each now scopes a mkdtemp profile via beforeAll/afterAll (the module-scope-tripwire-safe pattern), cleaned up per file. All nine green solo and in combined runs, except the pre-existing commands+snapshot pairing — proven identical WITH and WITHOUT these edits (baseline receipts) — which is the daemon-lifecycle follow-up now extended in TODOS with this session's receipts. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(browse): Chromium-crash exit is daemon-only — embedded launches never kill their host handleChromiumDisconnect unconditionally process.exit()ed. Correct for the standalone daemon (its supervisor/user must notice); suicidal when a TEST launches BrowserManager in-process: a mid-suite Chromium death exited the whole bun shard with no terminal summary — the exact truncation class the strict runner flags (observed live: CI shard 1 on eb233299 died at cache-concurrent-refresh right after a daemon-spawning gate test; with this fix the same pairing runs to completion and REPORTS instead of dying). The standalone entrypoint opts in via markDaemonProcess() under server.ts's import.meta.main gate — the same embedder contract its signal handlers already use (gbrowser phoenix keeps its own handlers). Embedded contexts now get the disconnect log line and continue. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): context-restore assertion is evidence-based, not prose-matching The test failed twice per run in TWO CI cycles while passing locally 4/4: the prompt said 'present the content' and the check grepped the FINAL message for exact phrases — local runs quoted the file, CI runs paraphrased ('the most recent context is from branch-b...') and the substring check lost the coin flip. - prompt now demands machine-checkable output: the newest file's '## Working on:' heading VERBATIM + a literal 'RESTORED: <filename>' marker (the mtime-scramble and cross-branch subject matter untouched) - assertion ordered strongest-first: RESTORED marker → legacy content phrases → tool-call corroboration (Read/Bash input naming the newer file, credited ONLY when the older file was never read — a both-files run must still present the right one) - the older-file negative got STRONGER: an explicit RESTORED marker naming the older file fails even if wintermute words appear elsewhere - sibling scan: context-recovery-artifacts got the additive prompt-side treatment only (quote the matched literals verbatim); its lenient 1-of-6 assertion deliberately unchanged 3/3 consecutive local green with all evidence classes firing (marker=true, content=true, toolNewer=true, toolOlder=false). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): skillify family — HOME==cwd broke project-skill registration Root cause (forensically pinned from stream-json init events + a kill-after-init probe): with HOME set EQUAL to the child's cwd, claude resolves <cwd>/.claude/skills as the PERSONAL skills directory and the seeded project-tier skills never register — the Skill tool returned 'Unknown skill'. The provenance-refusal test then improvised a refusal whose wording missed the regex (the deterministic CI+local red); the happy-path and approval-reject siblings passed only because their agents self-recovered by Reading SKILL.md manually — silently not exercising the Skill-tool path at all. All three tests now use HOME=<workDir>/home (a fresh subdir keeps the override's intent: child ~/.gstack writes land in the assertable sandbox, without the cwd collision). Refusal test additionally: a 'not registered/unknown skill' tripwire (a not-loaded skill can never pass as a refusal) and the refusal regex now matches assistant text only — the skill BODY echoed into the transcript contains the exact refusal message, so the old full-surface match could pass vacuously once the skill loaded. Sibling disk assertions sweep both $HOME/.gstack and cwd .gstack roots (positives and negatives). Verified paid: refusal 2x consecutive green with the skill's EXACT message rendered ('Launching skill: skillify' in-transcript), then the full file 5/5 green (~$1.35) with both siblings driving real Skill calls (25-27 turns each). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(TODOS): two of three first-execution findings fixed (skillify family, context-restore) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): context-restore gets a private home — the REAL root cause was fixture sharing The evidence-based assertion fix was treating a symptom. The slice artifact's embedded transcript showed the CI agent restoring 20260829-context-save-skill-test.md — the checkpoint the SIBLING context-save test wrote into the SHARED gstackHome checkpoints dir, which by filename-prefix ordering genuinely IS the newest. The agent behaved CORRECTLY; the test's fixture set was open to concurrent sibling writes, and bun --concurrent ordering differs between CI (save finished first) and local (restore listed first) — the entire local-green/CI-red split explained. The restore test now uses its own .gstack-restore-home (the whole home moves, not just the handed path — an agent deriving the dir from GSTACK_HOME/projects/<slug> must land in the closed set too). Full file 4/4 paid green with all evidence flags firing. Also: the on-failure shard-log artifact glob uploaded nothing — the Fix-bun-temp step points TMPDIR at /home/runner/.cache, so the spool lands there, not /tmp. Both eval workflows now glob both locations (this gap is why diagnosing THIS failure required digging transcripts out of the slice-results artifact). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(evidence): carry the real index mtime onto gstack-wtree's temp copy The stat-cache seed (cp of the real index) stamped the temp index "now", which defeats git's racy-git protection: an entry is only re-hashed when its cached mtime is not older than the index file itself, so a same-size rewrite landing in the same second as the last real index write looked non-racy, kept its stale stat-cache entry, and vanished from the fingerprint — evidence stayed FRESH after a source change. This is the CI flake in test/evidence.test.ts "allow-paths carve-out" (sub-second alignment on fast runners: expected STALE exit 1, got FRESH exit 0). touch -r restores the original index timestamp, reinstating the exact racy window git itself uses. Deterministic regression pin in test/review-log.test.ts reproduces the miss with pinned zero-nsec timestamps (fails on the old script, passes now); receipts: manual probe shows the fresh-stamped copy returning the clean tree for a same-size 'hello'→'howdy' rewrite while the mtime-carried copy detects it. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(test): landscape gate bounds the promotion count instead of pinning 3 The alt-hinted image promotion rides the per-render measurement race already filed in TODOS (2-vs-3 landscape pages on renders seconds apart — CI receipts from PR #2721, now reproduced locally). Pin the two deterministic promotions as the floor and the three promotable blocks as the ceiling (anything above 3 means the veto leaked); the veto/portrait assertions remain exact. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: Test <test@test.com>
2026-08-31 02:10:51 +02:00 · 2026-08-29 09:06:54 -07:00
parent b5a951e623
commit b1485d8897
171 changed files with 6786 additions and 1339 deletions
@@ -186,12 +186,32 @@ export async function resolveDisconnectCause(browser: Browser | null): Promise<'
 }

 /**
- * Headless `launch()` disconnect handler. Exits 0 on clean user-quit, 1 on
- * crash. Inlined into the launch() body via a one-line dispatch so
+ * Exit-on-disconnect is DAEMON-ONLY semantics. The standalone server
+ * entrypoint opts in via markDaemonProcess() (under its import.meta.main
+ * gate, same contract as its signal handlers); embedders — gbrowser
+ * phoenix, and every test that launches a BrowserManager in-process —
+ * must never have a Chromium crash process.exit() their HOST. Observed
+ * live before this flag: a test-launched browser died mid-suite and the
+ * exit(1) killed the whole bun shard with no terminal summary (the
+ * truncation class the strict runner exists to catch).
+ */
+let daemonProcess = false;
+export function markDaemonProcess(): void {
+  daemonProcess = true;
+}
+
+/**
+ * Headless `launch()` disconnect handler. In the standalone daemon: exits 0
+ * on clean user-quit, 1 on crash. Embedded contexts get the log line only.
+ * Inlined into the launch() body via a one-line dispatch so
 * browser-manager's flow stays grep-friendly.
 */
 export async function handleChromiumDisconnect(browser: Browser | null): Promise<void> {
  const cause = await resolveDisconnectCause(browser);
+  if (!daemonProcess) {
+    console.error(`[browse] Chromium disconnected (${cause}) in an embedded context — host process continues.`);
+    return;
+  }
  if (cause === 'clean') {
    console.error('[browse] Chromium closed cleanly (user-initiated quit). Server exiting (0).');
    process.exit(0);
@@ -155,8 +155,29 @@ export function restrictFilePermissions(filePath: string): void {
 * (CI = container inherit) inherit the single-user-full ACL — important
 * because child creations in `fs.writeFileSync(...)` without explicit
 * `restrictFilePermissions` still end up owner-only.
+ *
+ * Symlinked dirs are warned about and SKIPPED, never followed: both
+ * `chmod` and `icacls` dereference the link, so restricting through a
+ * symlink hardens whatever the link points at — a target the caller never
+ * vetted (and, with `/inheritance:r`, one we could lock its real owner out
+ * of). Skipping is best-effort-consistent with the rest of this module:
+ * the filesystem stays functional, we just don't hit the hardening target.
 */
 export function restrictDirectoryPermissions(dirPath: string): void {
+  try {
+    if (fs.lstatSync(dirPath).isSymbolicLink()) {
+      // biome-ignore lint/suspicious/noConsole: intentional user-facing warning
+      console.warn(
+        `[gstack] Refusing to restrict permissions through symlink ${dirPath} — skipping.\n` +
+        `  Restricting through a symlink would alter the link target instead. ` +
+        `Harden the real directory directly.`
+      );
+      return;
+    }
+  } catch {
+    // Path doesn't exist (or lstat failed) — fall through; both platform
+    // branches below already swallow failures on missing paths.
+  }
  if (process.platform === 'win32') {
    try {
      const user = currentUserPrincipal();
@@ -13,7 +13,7 @@
 *   Port:       random 10000-60000 (or BROWSE_PORT env for debug override)
 */

-import { BrowserManager } from './browser-manager';
+import { BrowserManager, markDaemonProcess } from './browser-manager';
 import { handleReadCommand, hasOutArg } from './read-commands';
 import { handleWriteCommand } from './write-commands';
 import { handleMetaCommand } from './meta-commands';
@@ -812,8 +812,17 @@ function parentWatchdogTick(parentPid: number = BROWSE_PARENT_PID): void {
    }
  }
 }
+// Poll cadence. Env-overridable as a test seam: watchdog.test.ts shrinks it
+// (250ms) so a free-tier test can observe a real tick deciding on a dead
+// parent instead of sleeping through the 15s production cadence. Production
+// launchers never set this; unparsable or non-positive values fall back to 15s.
+const rawWatchdogIntervalMs = parseInt(process.env.BROWSE_PARENT_WATCHDOG_INTERVAL_MS || '', 10);
+const PARENT_WATCHDOG_INTERVAL_MS =
+  Number.isFinite(rawWatchdogIntervalMs) && rawWatchdogIntervalMs > 0
+    ? rawWatchdogIntervalMs
+    : 15_000;
 if (BROWSE_PARENT_PID > 0 && !IS_HEADED_WATCHDOG) {
-  setInterval(parentWatchdogTick, 15_000);
+  setInterval(parentWatchdogTick, PARENT_WATCHDOG_INTERVAL_MS);
 } else if (IS_HEADED_WATCHDOG) {
  console.log('[browse] Parent-process watchdog disabled (headed mode)');
 } else if (BROWSE_PARENT_PID === 0) {
@@ -1385,6 +1394,10 @@ async function handleCommand(body: any, tokenInfo?: TokenInfo | null): Promise<R
 // server.ts as a submodule can register their own signal handlers without
 // fighting with gstack's. CLI path is unchanged.
 if (import.meta.main) {
+  // Standalone daemon: a Chromium crash must exit THIS process (its
+  // supervisor/user notices); embedders and in-process test launches must
+  // never be exited by browser-manager's disconnect handler.
+  markDaemonProcess();
  // SIGINT (Ctrl+C): user intentionally stopping → shutdown.
  process.on('SIGINT', () => activeShutdown?.());
  // SIGHUP (terminal hangup): with handleSIGHUP:false at the three launch
@@ -5,7 +5,10 @@
 * newtab/closetab handling, and batch validation.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';

@@ -62,6 +65,24 @@ import { handleMetaCommand } from '../src/meta-commands';
 import { handleSnapshot } from '../src/snapshot';
 import { READ_COMMANDS, WRITE_COMMANDS } from '../src/commands';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 const handleReadCommand = (cmd: string, args: string[], b: BrowserManager) =>
  _handleReadCommand(cmd, args, b.getActiveSession());
 const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
@@ -342,8 +342,15 @@ describe.skipIf(SKIP_SPAWN)('spawnSkill: lifecycle', () => {
  it('timeout fires, exit code 124, token revoked', async () => {
    const dir = makeSkillDir(tiers.bundled, 'sleeper',
      'name: sleeper\nhost: x.com\ntrusted: true',
-      // Sleep longer than the test timeout; the spawn should kill us.
-      `await new Promise(r => setTimeout(r, 30000)); console.log("done");`,
+      // The child's self-lifetime is a bound, not a wait — the test blocks
+      // only for the 1s spawn timeout that kills it. 8s is sized to be far
+      // above that 1s (the kill always lands first) but below this test's
+      // 10s ceiling: if the timeout-kill ever regresses, the child completes,
+      // prints "done", and the assertions below fail cleanly in-budget
+      // instead of the test opaquely timing out while the child lingers.
+      // (runToFiles gives skill children no stdin pipe, so a parent-death
+      // EOF lifetime isn't available here — self-timing is required.)
+      `await new Promise(r => setTimeout(r, 8000)); console.log("done");`,
    );
    const skill = readBrowserSkill('sleeper', tiers)!;
    const result = await spawnSkill({
@@ -351,6 +358,9 @@ describe.skipIf(SKIP_SPAWN)('spawnSkill: lifecycle', () => {
    });
    expect(result.timedOut).toBe(true);
    expect(result.exitCode).toBe(124);
+    // The kill must land before the script completes — "done" ever appearing
+    // means the child outlived its timeout.
+    expect(result.stdout).not.toContain('done');
    expect(listTokens().filter(t => t.clientId.startsWith('skill:sleeper:'))).toEqual([]);
  }, 10_000);

@@ -24,14 +24,15 @@ const TMP_HOME = path.join(os.tmpdir(), `gstack-cdp-e2e-${process.pid}-${Date.no
 // which then got baked into artifacts that outlived it (dangling symlinks
 // into a deleted render dir). Save + restore in afterAll.
 const ORIGINAL_GSTACK_HOME = process.env.GSTACK_HOME;
-process.env.GSTACK_HOME = TMP_HOME;
-process.env.GSTACK_TELEMETRY_OFF = '1'; // don't pollute analytics during tests
+const ORIGINAL_TELEMETRY_OFF = process.env.GSTACK_TELEMETRY_OFF;

 let testServer: ReturnType<typeof startTestServer>;
 let bm: BrowserManager;
 let baseUrl: string;

 beforeAll(async () => {
+  process.env.GSTACK_HOME = TMP_HOME;
+  process.env.GSTACK_TELEMETRY_OFF = '1'; // don't pollute analytics during tests
  await fs.rm(TMP_HOME, { recursive: true, force: true });
  await fs.mkdir(TMP_HOME, { recursive: true });
  testServer = startTestServer(0);
@@ -44,6 +45,8 @@ beforeAll(async () => {
 afterAll(async () => {
  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;
  try { await bm.cleanup?.(); } catch {}
  try { testServer.server.stop(); } catch {}
  await fs.rm(TMP_HOME, { recursive: true, force: true });
@@ -5,7 +5,8 @@
 * A real browse server is started and commands are sent via the CLI HTTP interface.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';
 import { resolveServerScript } from '../src/cli';
@@ -18,6 +19,24 @@ import * as fs from 'fs';
 import { spawn } from 'child_process';
 import * as path from 'path';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 // Thin wrappers that bridge old test calls (bm as 3rd arg) to new signatures (session + bm)
 const handleReadCommand = (cmd: string, args: string[], b: BrowserManager) =>
  _handleReadCommand(cmd, args, b.getActiveSession(), b);
@@ -10,7 +10,8 @@
 * No LLM involved — this is a deterministic functional test.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { BrowserManager } from '../src/browser-manager';
 import { handleReadCommand as _handleReadCommand } from '../src/read-commands';
 import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands';
@@ -23,6 +24,24 @@ import { generateCompareHtml } from '../../design/src/compare';
 import * as fs from 'fs';
 import * as path from 'path';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 // QUARANTINED (opt-in via GSTACK_COMPARE_BOARD_TESTS=1): all 16 tests fail
 // identically on origin/main v1.64.1.0, solo, on dev machines — verified per
 // the blame protocol during the 2026-08 test-infra pass. Main's own CI lane
@@ -11,7 +11,8 @@
 *   7. Chain security (domain + tab enforcement)
 */

-import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
+import * as os from 'os';
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import * as fs from 'fs';
 import * as path from 'path';
 import { startTestServer } from './test-server';
@@ -25,6 +26,24 @@ import {
 } from '../src/content-security';
 import { generateInstructionBlock } from '../src/cli';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 // Source-level tests
 const SERVER_SRC = fs.readFileSync(path.join(import.meta.dir, '../src/server.ts'), 'utf-8');
 const CLI_SRC = fs.readFileSync(path.join(import.meta.dir, '../src/cli.ts'), 'utf-8');
@@ -17,8 +17,12 @@ import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';

 const TMP_HOME = path.join(os.tmpdir(), `gstack-domain-e2e-${process.pid}-${Date.now()}`);
-process.env.GSTACK_HOME = TMP_HOME;
-process.env.GSTACK_PROJECT_SLUG = 'e2e-test-slug';
+
+// 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_PROJECT_SLUG = process.env.GSTACK_PROJECT_SLUG;

 let testServer: ReturnType<typeof startTestServer>;
 let bm: BrowserManager;
@@ -32,6 +36,8 @@ async function fakeBodyPipe(body: string): Promise<string> {
 }

 beforeAll(async () => {
+  process.env.GSTACK_HOME = TMP_HOME;
+  process.env.GSTACK_PROJECT_SLUG = 'e2e-test-slug';
  await fs.rm(TMP_HOME, { recursive: true, force: true });
  await fs.mkdir(path.join(TMP_HOME, 'projects', 'e2e-test-slug'), { recursive: true });
  testServer = startTestServer(0);
@@ -41,6 +47,10 @@ beforeAll(async () => {
 });

 afterAll(async () => {
+  if (ORIGINAL_GSTACK_HOME === undefined) delete process.env.GSTACK_HOME;
+  else process.env.GSTACK_HOME = ORIGINAL_GSTACK_HOME;
+  if (ORIGINAL_PROJECT_SLUG === undefined) delete process.env.GSTACK_PROJECT_SLUG;
+  else process.env.GSTACK_PROJECT_SLUG = ORIGINAL_PROJECT_SLUG;
  try { await bm.cleanup?.(); } catch {}
  try { testServer.server.stop(); } catch {}
  await fs.rm(TMP_HOME, { recursive: true, force: true });
@@ -1,10 +1,22 @@
-import { describe, it, expect, beforeEach } from 'bun:test';
+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-test-${process.pid}-${Date.now()}`);
-process.env.GSTACK_HOME = TMP_HOME;
+
+// 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). freshImport() below runs inside
+// tests, so the beforeAll value is what ../src/domain-skills reads.
+const ORIGINAL_GSTACK_HOME = process.env.GSTACK_HOME;
+beforeAll(() => {
+  process.env.GSTACK_HOME = TMP_HOME;
+});
+afterAll(() => {
+  if (ORIGINAL_GSTACK_HOME === undefined) delete process.env.GSTACK_HOME;
+  else process.env.GSTACK_HOME = ORIGINAL_GSTACK_HOME;
+});

 // Re-import after env var set so module reads updated GSTACK_HOME
 async function freshImport() {
@@ -190,11 +190,7 @@ describe('background.js onMessage listener (behavioral)', () => {
    expect(r.response!.error).toBeUndefined();
  });

-  // QUARANTINED (pre-existing): fails identically on origin/main v1.64.1.0,
-  // solo, on dev machines (blame protocol, 2026-08 test-infra pass). Main's
-  // CI lane skip-lists this whole FILE; we quarantine only this test so the
-  // rest keeps guarding. Un-skip when the underlying env dependency is fixed.
-  test.skip('own content script: every privileged type is denied with no token/port fields', () => {
+  test('own content script: every privileged type is denied with no token/port fields', () => {
    for (const type of PRIVILEGED) {
      const r = dispatch(listener, { type }, CONTENT_SCRIPT_SENDER);
      expect(r.responded).toBe(true); // the gate answers, it does not go silent
@@ -208,11 +204,7 @@ describe('background.js onMessage listener (behavioral)', () => {
    }
  });

-  // QUARANTINED (pre-existing): fails identically on origin/main v1.64.1.0,
-  // solo, on dev machines (blame protocol, 2026-08 test-infra pass). Main's
-  // CI lane skip-lists this whole FILE; we quarantine only this test so the
-  // rest keeps guarding. Un-skip when the underlying env dependency is fixed.
-  test.skip('missing sender.url: every privileged type is denied', () => {
+  test('missing sender.url: every privileged type is denied', () => {
    for (const type of PRIVILEGED) {
      const r = dispatch(listener, { type }, NO_URL_SENDER);
      expect(r.responded).toBe(true);
@@ -9,6 +9,11 @@
 *     we verify the helper doesn't throw and the file ends up accessible
 *     to the current user — the "doesn't crash, file still usable"
 *     contract the callers rely on.
+ *   - Every `mode & 0o777` bitmask assertion is platform-guarded: Windows
+ *     fakes POSIX mode bits (chmod is ~a no-op; dirs stat as 0o777), so a
+ *     bitmask expectation on win32 tests the runner, not our code. Symlink
+ *     fixtures are created in try/catch — Windows runners without Developer
+ *     Mode / admin can't create symlinks, and the test skips gracefully.
 */

 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
@@ -107,6 +112,47 @@ describe('restrictDirectoryPermissions', () => {
    expect(() => restrictDirectoryPermissions(d)).not.toThrow();
  });

+  test('warns and skips a symlinked dir without throwing', () => {
+    const real = path.join(tmpDir, 'real-target');
+    fs.mkdirSync(real);
+    if (process.platform !== 'win32') {
+      // chmod, not mkdir({ mode }), so a restrictive umask can't skew the
+      // starting bits we later assert were left untouched.
+      fs.chmodSync(real, 0o755);
+    }
+    const link = path.join(tmpDir, 'linked');
+    try {
+      fs.symlinkSync(real, link, 'dir');
+    } catch {
+      // Windows runners without Developer Mode / admin can't create
+      // symlinks (house pattern: security-audit-r2.test.ts skips the same
+      // way). Nothing to test without the link.
+      // biome-ignore lint/suspicious/noConsole: test-skip diagnostics
+      console.warn('Skipping: symlink creation failed (no symlink privilege)');
+      return;
+    }
+
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(args.map(String).join(' ')); };
+    try {
+      expect(() => restrictDirectoryPermissions(link)).not.toThrow();
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings.some((w) => w.includes('symlink'))).toBe(true);
+
+    // The skip must leave the link target untouched. Mode bits are only
+    // meaningful on POSIX — Windows fakes stat().mode (dirs report 0o777
+    // no matter what), so asserting 0o755 there fails on runner semantics,
+    // not on our behavior. The no-throw + warn + still-usable checks are
+    // the meaningful win32 contract.
+    if (process.platform !== 'win32') {
+      expect(fs.statSync(real).mode & 0o777).toBe(0o755);
+    }
+    expect(() => fs.readdirSync(real)).not.toThrow();
+  });
+
  test('on Windows, the directory stays usable by the calling process', () => {
    if (process.platform !== 'win32') return;
    const d = path.join(tmpDir, 'still-usable');
@@ -8,11 +8,32 @@
 * the framework's own validator still reports a mismatch.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';
 import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
  _handleWriteCommand(cmd, args, b.getActiveSession(), b);

@@ -5,12 +5,33 @@
 * Integration tests cover the full handoff flow with real Playwright browsers.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { startTestServer } from './test-server';
 import { BrowserManager, type BrowserState } from '../src/browser-manager';
 import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands';
 import { handleMetaCommand } from '../src/meta-commands';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
  _handleWriteCommand(cmd, args, b.getActiveSession(), b);

@@ -0,0 +1,294 @@
+/**
+ * Unit tests for browse/src/media-extract.ts — the media-discovery logic
+ * shared by the `media` and `scrape` commands.
+ *
+ * All of extractMedia's logic lives inside the page.evaluate() callback.
+ * Playwright serializes that callback to the browser, but the function itself
+ * is pure over the DOM globals it touches (`document`, `getComputedStyle`),
+ * so instead of exporting internals or launching a browser these tests pass a
+ * fake target whose evaluate() invokes the real callback in-process against a
+ * minimal mock DOM. No product code was modified.
+ *
+ * Globals are installed/restored inside each run (never at module scope) so
+ * nothing leaks to sibling test files sharing this shard process.
+ */
+import { describe, test, expect } from 'bun:test';
+import { extractMedia, type MediaResult } from '../src/media-extract';
+
+type Dom = Record<string, any[]>;
+
+/** querySelector/querySelectorAll over a selector → elements map. */
+function queryable(map: Dom) {
+  return {
+    querySelectorAll: (sel: string) => map[sel] ?? [],
+    querySelector: (sel: string) => (map[sel] ?? [])[0] ?? null,
+  };
+}
+
+const VISIBLE_RECT = { width: 100, height: 50, bottom: 400, right: 300 };
+const HIDDEN_RECT = { width: 0, height: 0, bottom: 0, right: 0 };
+
+function imgEl(overrides: Record<string, unknown> = {}, attrs: Record<string, string> = {}, rect = VISIBLE_RECT) {
+  return {
+    src: '', srcset: '', currentSrc: '', alt: '',
+    width: 0, height: 0, naturalWidth: 0, naturalHeight: 0, loading: '',
+    getAttribute: (name: string) => attrs[name] ?? null,
+    getBoundingClientRect: () => rect,
+    ...overrides,
+  };
+}
+
+function videoEl(overrides: Record<string, unknown> = {}, sources: Array<{ src?: string; type?: string }> = []) {
+  return {
+    src: '', currentSrc: '', poster: '',
+    videoWidth: 0, width: 0, videoHeight: 0, height: 0, duration: 0,
+    querySelectorAll: (sel: string) => (sel === 'source' ? sources : []),
+    ...overrides,
+  };
+}
+
+function audioEl(overrides: Record<string, unknown> = {}, source: { src?: string; type?: string } | null = null) {
+  return {
+    src: '', currentSrc: '', duration: 0,
+    querySelector: (sel: string) => (sel === 'source' ? source : null),
+    ...overrides,
+  };
+}
+
+/** An element visible only to the background-image pass (`*` + getComputedStyle). */
+function bgEl(backgroundImage: string, opts: { tagName?: string; id?: string; className?: unknown } = {}) {
+  return {
+    tagName: opts.tagName ?? 'DIV',
+    id: opts.id ?? '',
+    className: opts.className ?? '',
+    __backgroundImage: backgroundImage,
+  };
+}
+
+/**
+ * Run the REAL extractMedia against a mock document. The fake target's
+ * evaluate() calls the callback with its argument, exactly as Playwright does
+ * in the browser — resolving `document`/`getComputedStyle` to our shims.
+ */
+async function extract(
+  dom: Dom,
+  options?: Parameters<typeof extractMedia>[1],
+): Promise<MediaResult> {
+  const g = globalThis as any;
+  const savedDocument = g.document;
+  const savedGcs = g.getComputedStyle;
+  g.document = queryable(dom);
+  g.getComputedStyle = (el: any) => ({ backgroundImage: el.__backgroundImage ?? 'none' });
+  try {
+    const target = { evaluate: (fn: any, arg: any) => Promise.resolve(fn(arg)) } as any;
+    return await extractMedia(target, options);
+  } finally {
+    g.document = savedDocument;
+    g.getComputedStyle = savedGcs;
+  }
+}
+
+describe('extractMedia: images', () => {
+  test('collects attributes, dimensions, and the lazy-load data-src fallback chain', async () => {
+    const result = await extract({
+      img: [
+        imgEl({
+          src: 'https://cdn.example.com/hero.jpg',
+          srcset: 'hero-2x.jpg 2x',
+          currentSrc: 'https://cdn.example.com/hero-2x.jpg',
+          alt: 'Hero',
+          width: 640, height: 480, naturalWidth: 1280, naturalHeight: 960,
+          loading: 'lazy',
+        }, { 'data-lazy-src': 'lazy.jpg' }),
+      ],
+    });
+    expect(result.images).toHaveLength(1);
+    const img = result.images[0];
+    expect(img.index).toBe(0);
+    expect(img.src).toBe('https://cdn.example.com/hero.jpg');
+    expect(img.srcset).toBe('hero-2x.jpg 2x');
+    expect(img.currentSrc).toBe('https://cdn.example.com/hero-2x.jpg');
+    expect(img.alt).toBe('Hero');
+    expect(img.naturalWidth).toBe(1280);
+    expect(img.loading).toBe('lazy');
+    // No data-src → falls through to data-lazy-src.
+    expect(img.dataSrc).toBe('lazy.jpg');
+    expect(img.visible).toBe(true);
+    expect(result.total).toBe(1);
+  });
+
+  test('data-src wins over the later fallbacks, data-original is last', async () => {
+    const first = await extract({ img: [imgEl({}, { 'data-src': 'a.jpg', 'data-lazy-src': 'b.jpg', 'data-original': 'c.jpg' })] });
+    expect(first.images[0].dataSrc).toBe('a.jpg');
+    const last = await extract({ img: [imgEl({}, { 'data-original': 'c.jpg' })] });
+    expect(last.images[0].dataSrc).toBe('c.jpg');
+    const none = await extract({ img: [imgEl()] });
+    expect(none.images[0].dataSrc).toBe('');
+  });
+
+  test('a zero-size or fully offscreen rect marks the image not visible', async () => {
+    const result = await extract({
+      img: [
+        imgEl({}, {}, HIDDEN_RECT),
+        // Above/left of the viewport: bottom and right are negative.
+        imgEl({}, {}, { width: 10, height: 10, bottom: -5, right: -5 }),
+        imgEl({}, {}, VISIBLE_RECT),
+      ],
+    });
+    expect(result.images.map(index => index.visible)).toEqual([false, false, true]);
+  });
+});
+
+describe('extractMedia: videos', () => {
+  test('detects HLS from either the mime type or an .m3u8 source URL', async () => {
+    const result = await extract({
+      video: [
+        videoEl({}, [{ src: 'https://v.example.com/stream.m3u8', type: '' }]),
+        videoEl({}, [{ src: 'https://v.example.com/stream', type: 'application/x-mpegURL' }]),
+        videoEl({ src: 'plain.mp4' }, [{ src: 'plain.mp4', type: 'video/mp4' }]),
+      ],
+    });
+    expect(result.videos.map(v => v.isHLS)).toEqual([true, true, false]);
+    expect(result.videos[2].type).toBe('video/mp4');
+  });
+
+  test('detects DASH from either the mime type or an .mpd source URL', async () => {
+    const result = await extract({
+      video: [
+        videoEl({}, [{ src: 'https://v.example.com/manifest.mpd', type: '' }]),
+        videoEl({}, [{ src: 'https://v.example.com/manifest', type: 'application/dash+xml' }]),
+      ],
+    });
+    expect(result.videos.map(v => v.isDASH)).toEqual([true, true]);
+  });
+
+  test('an Infinity duration (live stream) is reported as 0; intrinsic size beats attributes', async () => {
+    const result = await extract({
+      video: [videoEl({ duration: Infinity, videoWidth: 1920, width: 640, videoHeight: 1080, height: 360 })],
+    });
+    expect(result.videos[0].duration).toBe(0);
+    expect(result.videos[0].width).toBe(1920);
+    expect(result.videos[0].height).toBe(1080);
+  });
+
+  test('collects every <source> child with src and type', async () => {
+    const sources = [
+      { src: 'a.webm', type: 'video/webm' },
+      { src: 'a.mp4', type: 'video/mp4' },
+    ];
+    const result = await extract({ video: [videoEl({ poster: 'poster.jpg' }, sources)] });
+    expect(result.videos[0].sources).toEqual(sources);
+    expect(result.videos[0].poster).toBe('poster.jpg');
+    expect(result.videos[0].type).toBe('video/webm'); // first source's type
+  });
+});
+
+describe('extractMedia: audio', () => {
+  test('falls back to the <source> child when the element has no src, NaN duration → 0', async () => {
+    const result = await extract({
+      audio: [audioEl({ duration: NaN }, { src: 'track.ogg', type: 'audio/ogg' })],
+    });
+    expect(result.audio[0].src).toBe('track.ogg');
+    expect(result.audio[0].type).toBe('audio/ogg');
+    expect(result.audio[0].duration).toBe(0);
+  });
+
+  test('element src wins over the source child', async () => {
+    const result = await extract({
+      audio: [audioEl({ src: 'direct.mp3', duration: 12.5 }, { src: 'child.ogg', type: 'audio/ogg' })],
+    });
+    expect(result.audio[0].src).toBe('direct.mp3');
+    expect(result.audio[0].duration).toBe(12.5);
+  });
+});
+
+describe('extractMedia: CSS background images', () => {
+  test('parses url(...) in quoted and unquoted forms, skipping none and data: URIs', async () => {
+    const result = await extract({
+      '*': [
+        bgEl('url("https://cdn.example.com/bg.png")'),
+        bgEl("url('https://cdn.example.com/bg2.png')"),
+        bgEl('url(https://cdn.example.com/bg3.png)'),
+        bgEl('none'),
+        bgEl('url(data:image/png;base64,AAAA)'),
+      ],
+    });
+    expect(result.backgroundImages.map(b => b.url)).toEqual([
+      'https://cdn.example.com/bg.png',
+      'https://cdn.example.com/bg2.png',
+      'https://cdn.example.com/bg3.png',
+    ]);
+    expect(result.backgroundImages.map(b => b.index)).toEqual([0, 1, 2]);
+  });
+
+  test('builds a tag#id.class selector; a non-string className (SVG) contributes no class part', async () => {
+    const result = await extract({
+      '*': [
+        bgEl('url(a.png)', { tagName: 'SECTION', id: 'hero', className: ' banner  large ' }),
+        bgEl('url(b.png)', { tagName: 'SVG', className: { baseVal: 'svg-class' } }),
+      ],
+    });
+    expect(result.backgroundImages[0].selector).toBe('section#hero.banner.large');
+    expect(result.backgroundImages[0].element).toBe('section');
+    expect(result.backgroundImages[1].selector).toBe('svg');
+  });
+
+  test('caps background-image extraction at 500 elements', async () => {
+    const many = Array.from({ length: 520 }, (_, i) => bgEl(`url(bg-${i}.png)`));
+    const result = await extract({ '*': many });
+    expect(result.backgroundImages).toHaveLength(500);
+    expect(result.backgroundImages[499].url).toBe('bg-499.png');
+    expect(result.total).toBe(500);
+  });
+});
+
+describe('extractMedia: filter and scope options', () => {
+  const FULL_DOM: Dom = {
+    img: [imgEl({ src: 'i.png' })],
+    video: [videoEl({ src: 'v.mp4' })],
+    audio: [audioEl({ src: 'a.mp3' })],
+    '*': [bgEl('url(bg.png)')],
+  };
+
+  test('no filter returns every category and total sums them', async () => {
+    const result = await extract(FULL_DOM);
+    expect(result.images).toHaveLength(1);
+    expect(result.videos).toHaveLength(1);
+    expect(result.audio).toHaveLength(1);
+    expect(result.backgroundImages).toHaveLength(1);
+    expect(result.total).toBe(4);
+  });
+
+  test("filter: 'videos' excludes images, audio, and background images", async () => {
+    const result = await extract(FULL_DOM, { filter: 'videos' });
+    expect(result.videos).toHaveLength(1);
+    expect(result.images).toEqual([]);
+    expect(result.audio).toEqual([]);
+    expect(result.backgroundImages).toEqual([]);
+    expect(result.total).toBe(1);
+  });
+
+  test("filter: 'images' includes background images (they are image media)", async () => {
+    const result = await extract(FULL_DOM, { filter: 'images' });
+    expect(result.images).toHaveLength(1);
+    expect(result.backgroundImages).toHaveLength(1);
+    expect(result.videos).toEqual([]);
+    expect(result.audio).toEqual([]);
+    expect(result.total).toBe(2);
+  });
+
+  test('a selector scopes extraction to the matching subtree', async () => {
+    const scoped = {
+      ...queryable({ img: [imgEl({ src: 'scoped.png' })] }),
+    };
+    const result = await extract({ img: [imgEl({ src: 'global.png' })], '#gallery': [scoped] }, { selector: '#gallery' });
+    expect(result.images).toHaveLength(1);
+    expect(result.images[0].src).toBe('scoped.png');
+  });
+
+  test('a selector matching nothing falls back to the whole document', async () => {
+    const result = await extract({ img: [imgEl({ src: 'global.png' })] }, { selector: '#missing' });
+    expect(result.images).toHaveLength(1);
+    expect(result.images[0].src).toBe('global.png');
+  });
+});
@@ -20,12 +20,30 @@
 * CI). To prime: `bun run browse/src/sidebar-agent.ts` for ~30s and kill it.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';
+
+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
 import {
  markHiddenElements,
  getCleanTextWithStripping,
@@ -0,0 +1,159 @@
+/**
+ * Unit tests for browse/src/session-cookie-store.ts — the factory behind
+ * pty-session-cookie.ts and sse-session-cookie.ts.
+ *
+ * sse-session-cookie.test.ts pins the SSE instantiation (flags, entropy,
+ * cross-endpoint isolation). This file tests the FACTORY's own contract with
+ * custom options the instantiations never vary: the cookieName knob in
+ * extract/buildSetCookie, the ttlMs knob in expiry and Max-Age, the
+ * maxSessions hard cap, and isolation between independently created stores.
+ *
+ * The store is purely in-memory (a Map keyed by token) — there is no on-disk
+ * state, so no temp dirs or permission cases apply.
+ */
+import { describe, test, expect } from 'bun:test';
+import { createSessionCookieStore } from '../src/session-cookie-store';
+
+const NAME = 'gstack_test_session';
+
+function makeStore(opts: Partial<Parameters<typeof createSessionCookieStore>[0]> = {}) {
+  return createSessionCookieStore({ cookieName: NAME, ttlMs: 60_000, ...opts });
+}
+
+function requestWithCookies(cookieHeader: string | null): Request {
+  return new Request('http://127.0.0.1/sse', {
+    headers: cookieHeader === null ? {} : { cookie: cookieHeader },
+  });
+}
+
+describe('session-cookie-store: mint + validate round-trip', () => {
+  test('a minted token validates until revoked', () => {
+    const store = makeStore();
+    const { token, expiresAt } = store.mint();
+    expect(token).toMatch(/^[A-Za-z0-9_-]{43}$/); // 32 bytes base64url, no padding
+    expect(expiresAt).toBeGreaterThan(Date.now());
+    expect(expiresAt).toBeLessThanOrEqual(Date.now() + 60_000);
+    expect(store.validate(token)).toBe(true);
+    store.revoke(token);
+    expect(store.validate(token)).toBe(false);
+  });
+
+  test('unknown, null, undefined, and empty tokens never validate', () => {
+    const store = makeStore();
+    store.mint();
+    expect(store.validate('forged-token')).toBe(false);
+    expect(store.validate(null)).toBe(false);
+    expect(store.validate(undefined)).toBe(false);
+    expect(store.validate('')).toBe(false);
+  });
+
+  test('revoke of an unknown/null token is a no-op, not an error', () => {
+    const store = makeStore();
+    const { token } = store.mint();
+    expect(() => store.revoke('never-minted')).not.toThrow();
+    expect(() => store.revoke(null)).not.toThrow();
+    expect(() => store.revoke(undefined)).not.toThrow();
+    expect(store.validate(token)).toBe(true); // untouched
+  });
+
+  test('a token expires after ttlMs and validate deletes it', async () => {
+    const store = makeStore({ ttlMs: 5 });
+    const { token, expiresAt } = store.mint();
+    expect(expiresAt - Date.now()).toBeLessThanOrEqual(5);
+    await new Promise(resolve => setTimeout(resolve, 25));
+    expect(store.validate(token)).toBe(false);
+    expect(store.validate(token)).toBe(false); // still gone after deletion
+  });
+
+  test('two stores are fully isolated — a token minted in one never validates in the other', () => {
+    const a = makeStore();
+    const b = makeStore();
+    const { token } = a.mint();
+    expect(b.validate(token)).toBe(false);
+    expect(a.validate(token)).toBe(true);
+  });
+
+  test('__reset clears every session', () => {
+    const store = makeStore();
+    const first = store.mint().token;
+    const second = store.mint().token;
+    store.__reset();
+    expect(store.validate(first)).toBe(false);
+    expect(store.validate(second)).toBe(false);
+  });
+});
+
+describe('session-cookie-store: maxSessions hard cap', () => {
+  test('minting past the cap evicts the oldest sessions', () => {
+    const store = makeStore({ maxSessions: 3 });
+    const tokens = Array.from({ length: 5 }, () => store.mint().token);
+    // Insertion order eviction: the two oldest are gone, the newest three live.
+    expect(store.validate(tokens[0])).toBe(false);
+    expect(store.validate(tokens[1])).toBe(false);
+    expect(store.validate(tokens[2])).toBe(true);
+    expect(store.validate(tokens[3])).toBe(true);
+    expect(store.validate(tokens[4])).toBe(true);
+  });
+});
+
+describe('session-cookie-store: extract (cookie header parsing)', () => {
+  test('finds the configured cookie among others, with surrounding whitespace', () => {
+    const store = makeStore();
+    const req = requestWithCookies(`other=1;  ${NAME}=tok-value ; trailing=2`);
+    // Each `name=value` part is trimmed as a whole before splitting.
+    expect(store.extract(req)).toBe('tok-value');
+  });
+
+  test('a cookie value containing = survives intact', () => {
+    const store = makeStore();
+    const req = requestWithCookies(`${NAME}=abc=def==`);
+    expect(store.extract(req)).toBe('abc=def==');
+  });
+
+  test('only the EXACT cookie name matches — no prefix/suffix confusion', () => {
+    const store = makeStore();
+    expect(store.extract(requestWithCookies(`x${NAME}=evil`))).toBeNull();
+    expect(store.extract(requestWithCookies(`${NAME}x=evil`))).toBeNull();
+  });
+
+  test('missing header and empty value both yield null', () => {
+    const store = makeStore();
+    expect(store.extract(requestWithCookies(null))).toBeNull();
+    expect(store.extract(requestWithCookies(`${NAME}=`))).toBeNull();
+    expect(store.extract(requestWithCookies('unrelated=1'))).toBeNull();
+  });
+
+  test('two stores with different cookie names read different cookies from one header', () => {
+    const ptyLike = createSessionCookieStore({ cookieName: 'pty_session', ttlMs: 1000 });
+    const sseLike = createSessionCookieStore({ cookieName: 'sse_session', ttlMs: 1000 });
+    const req = requestWithCookies('pty_session=pty-tok; sse_session=sse-tok');
+    expect(ptyLike.extract(req)).toBe('pty-tok');
+    expect(sseLike.extract(req)).toBe('sse-tok');
+  });
+});
+
+describe('session-cookie-store: buildSetCookie', () => {
+  test('emits the exact security flags with Max-Age derived from ttlMs', () => {
+    const store = makeStore({ ttlMs: 90_500 }); // floor(90.5s) = 90
+    expect(store.buildSetCookie('tok123')).toBe(
+      `${NAME}=tok123; HttpOnly; SameSite=Strict; Path=/; Max-Age=90`,
+    );
+  });
+
+  test('never emits Secure — the daemon serves plain HTTP on loopback', () => {
+    const store = makeStore();
+    expect(store.buildSetCookie('t')).not.toContain('Secure');
+  });
+
+  test('a minted token round-trips: Set-Cookie → request header → extract → validate', () => {
+    const store = makeStore();
+    const { token } = store.mint();
+    const setCookie = store.buildSetCookie(token);
+    // The browser echoes back only the name=value pair.
+    const pair = setCookie.split(';')[0];
+    const req = requestWithCookies(pair);
+    const extracted = store.extract(req);
+    expect(extracted).toBe(token);
+    expect(store.validate(extracted)).toBe(true);
+  });
+});
@@ -15,7 +15,7 @@
 *      shutdown, and the gate is BROWSE_PERSIST_STATE (default off).
 */

-import { describe, test, expect, afterAll } from 'bun:test';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { canRevokeWrites } from '../../test/helpers/fs-caps';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -26,6 +26,24 @@ import {
 } from '../src/session-persist';
 import type { BrowserState } from '../src/browser-manager';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-persist-'));
 afterAll(() => { fs.rmSync(tmpRoot, { recursive: true, force: true }); });

@@ -5,7 +5,9 @@
 * ref invalidation on navigation, and ref resolution in commands.
 */

-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import * as path from 'path';
+import * as os from 'os';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { startTestServer } from './test-server';
 import { BrowserManager } from '../src/browser-manager';
 import { handleReadCommand as _handleReadCommand } from '../src/read-commands';
@@ -13,6 +15,24 @@ import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands
 import { handleMetaCommand } from '../src/meta-commands';
 import * as fs from 'fs';

+// Per-FILE Chromium profile: this file launches an in-process persistent
+// context (BrowserManager.launch()), and sharing a profile dir with the
+// long-lived browse daemon a sibling file may have spawned kills one side's
+// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
+// module scope (see test/gstack-home-module-scope.test.ts's rationale).
+const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
+let CHROMIUM_PROFILE_DIR: string | undefined;
+beforeAll(() => {
+  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
+  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
+});
+afterAll(() => {
+  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
+  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
+  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
+});
+
+
 const handleReadCommand = (cmd: string, args: string[], b: BrowserManager) =>
  _handleReadCommand(cmd, args, b.getActiveSession(), b);
 const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
@@ -222,11 +242,7 @@ describe('Ref staleness detection', () => {
    expect(bm.getRefCount()).toBeGreaterThan(0);
  });

-  // QUARANTINED (pre-existing): fails identically on origin/main v1.64.1.0,
-  // solo, on dev machines (blame protocol, 2026-08 test-infra pass). Main's
-  // CI lane skip-lists this whole FILE; we quarantine only this test so the
-  // rest keeps guarding. Un-skip when the underlying env dependency is fixed.
-  test.skip('stale ref after DOM removal gives descriptive error', async () => {
+  test('stale ref after DOM removal gives descriptive error', async () => {
    await handleWriteCommand('goto', [baseUrl + '/snapshot.html'], bm);
    const snap = await handleMetaCommand('snapshot', ['-i'], bm, shutdown);
    // Find a button ref
@@ -276,11 +292,7 @@ describe('Snapshot diff', () => {
    expect(result).toContain('baseline');
  });

-  // QUARANTINED (pre-existing): fails identically on origin/main v1.64.1.0,
-  // solo, on dev machines (blame protocol, 2026-08 test-infra pass). Main's
-  // CI lane skip-lists this whole FILE; we quarantine only this test so the
-  // rest keeps guarding. Un-skip when the underlying env dependency is fixed.
-  test.skip('snapshot -D shows diff after change', async () => {
+  test('snapshot -D shows diff after change', async () => {
    await handleWriteCommand('goto', [baseUrl + '/snapshot.html'], bm);
    // Take first snapshot
    await handleMetaCommand('snapshot', [], bm, shutdown);
@@ -367,11 +379,7 @@ describe('Annotated screenshots', () => {
    if (fs.existsSync(screenshotPath)) fs.unlinkSync(screenshotPath);
  });

-  // QUARANTINED (pre-existing): fails identically on origin/main v1.64.1.0,
-  // solo, on dev machines (blame protocol, 2026-08 test-infra pass). Main's
-  // CI lane skip-lists this whole FILE; we quarantine only this test so the
-  // rest keeps guarding. Un-skip when the underlying env dependency is fixed.
-  test.skip('annotation overlays are cleaned up', async () => {
+  test('annotation overlays are cleaned up', async () => {
    await handleWriteCommand('goto', [baseUrl + '/snapshot.html'], bm);
    await handleMetaCommand('snapshot', ['-a'], bm, shutdown);
    // Check that overlays are removed
@@ -109,7 +109,16 @@ describe('stop --force-restart on a LIVE daemon', () => {
    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-stop-force-'));
    const stateFile = path.join(tmpDir, 'browse.json');
    // Portable long-lived child standing in for the wedged daemon process.
-    const wedged = spawn('bun', ['-e', 'await Bun.sleep(300000)'], { stdio: 'ignore' });
+    // Its lifetime is tied to this test process instead of a fixed sleep: it
+    // blocks until its stdin (a pipe we hold open) hits EOF. That means it
+    // can never self-exit mid-test — which would let the "pid is dead"
+    // assertion below pass without the CLI having killed anything — and it
+    // reaps itself the moment the test process dies, even on a hard kill
+    // where the finally block never runs.
+    const wedged = spawn('bun', ['-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'] });
    try {
      const port = await closedPort();
      fs.writeFileSync(stateFile, JSON.stringify({
@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterAll } from 'bun:test';
+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';
@@ -8,8 +8,21 @@ 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).
-process.env.GSTACK_HOME = TMP_HOME;
-process.env.GSTACK_TELEMETRY_OFF = '0';
+// 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 });
@@ -44,9 +44,16 @@ describe('terminal-agent owner lifecycle', () => {
    // 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', 'await Bun.sleep(30000)'],
-      { stdio: ['ignore', 'ignore', 'ignore'] },
+      [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], {
@@ -27,8 +27,10 @@ import { resolveConfig } from '../src/config';
 // seam as idleCheckTick) and tunnelActive is simulated via setTunnelActive.
 //
 // Each test spawns the real server.ts. Tests 1 and 2 verify behavior via
-// stdout log line (fast). Test 3 waits for the watchdog poll cycle to confirm
-// the server REMAINS alive after parent death (slow — ~20s observation window).
+// stdout log line (fast). Test 3 shrinks the poll cadence via
+// BROWSE_PARENT_WATCHDOG_INTERVAL_MS (test seam in server.ts), waits for the
+// tick's one-time "parent exited (server stays alive" log to prove a tick
+// observed the death, then confirms the server REMAINS alive.

 const ROOT = path.resolve(import.meta.dir, '..');
 const SERVER_SCRIPT = path.join(ROOT, 'src', 'server.ts');
@@ -139,21 +141,37 @@ describe('parent-process watchdog (v0.18.1.0)', () => {
    const parentPid = parentProc.pid!;

    // Default headless: no BROWSE_HEADED, real parent PID — watchdog active.
-    serverProc = spawnServer({ BROWSE_PARENT_PID: String(parentPid) }, 34903);
+    // The poll cadence is shrunk via the server's env seam (250ms instead of
+    // the production 15s) so observing a real tick doesn't cost a 20s sleep.
+    serverProc = spawnServer({
+      BROWSE_PARENT_PID: String(parentPid),
+      BROWSE_PARENT_WATCHDOG_INTERVAL_MS: '250',
+    }, 34903);
    const serverPid = serverProc.pid!;

-    // Give the server a moment to start and register the watchdog interval.
-    await Bun.sleep(2000);
+    // Startup barrier: poll stdout for the listen line instead of a fixed 2s
+    // sleep. The watchdog interval is registered at module load, before this
+    // line prints, so once we see it the ticks are running.
+    const bootOut = await readStdoutUntil(serverProc, 'Server running on', 15_000);
+    expect(bootOut).toContain('Server running on');
    expect(isProcessAlive(serverPid)).toBe(true);

-    // Kill the parent. The watchdog polls every 15s, so first tick after
-    // parent death lands within ~15s. Pre-#994 the server would shutdown
-    // here. Post-#994 the server logs the parent exit and stays alive.
+    // Kill the parent, then wait for a tick to OBSERVE the death: the
+    // stay-alive branch logs a one-time latched line. Seeing it proves a tick
+    // ran after parent death and chose NOT to shut down — pre-#994 the same
+    // tick called shutdown instead. (Await exited first so the PID is reaped
+    // and the tick's kill(pid, 0) probe sees ESRCH, not a zombie.)
    parentProc.kill('SIGKILL');
+    await parentProc.exited;
+    const marker = `Parent process ${parentPid} exited (server stays alive`;
+    const out = await readStdoutUntil(serverProc, marker, 15_000);
+    expect(out).toContain(marker);
+    expect(out).not.toContain('shutting down');

-    // Wait long enough for at least one watchdog tick (15s) plus margin.
-    // Server should still be alive — that's the whole point of #994.
-    await Bun.sleep(20_000);
+    // Let several more ticks land (4+ at 250ms — the old fixed 20s sleep
+    // covered ~1 production tick) and confirm the server is still alive —
+    // that's the whole point of #994.
+    await Bun.sleep(1_000);
    expect(isProcessAlive(serverPid)).toBe(true);
  }, 45_000);
 });