@indigoai-us/hq-cloud 6.18.44-alpha.9 → 6.18.44

package/dist/bin/sync-runner-heap-telemetry.test.js

@@ -1,1966 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { HeapCensus, RunnerHeapTelemetry, sampleRunnerHeap, heapSampleCloudProperties, heapPressureCloudProperties, heapRecycleCloudProperties, heapPressureStderrLine, heapRecycleStderrLine, performHeapHardExit, startRunnerHeapSampling, nodeMajorGcObserver, isFreshGcReading, MAX_FRESH_GC_READING_MS, resolveHeapPressureFraction, resolveHeapSampleIntervalMs, resolveHeapRecycleEnabled, resolveHeapRecycleLiveFraction, resolveHeapRecycleEmergencyFraction, resolveHeapRecycleSustainWindowMs, resolveHeapRecycleMinUptimeMs, resolveHeapCheckpointMs, resolveHeapPinnedFraction, resolveHeapPinnedSustainMs, resolveHeapHardExitFraction, resolveHeapRecycleLatchHardExitMs, resolveHeapFootprintRecycleEnabled, resolveHeapFootprintRecycleBytes, resolveHeapFootprintHardExitBytes, resolveDeclaredHeapCeilingBytes, DEFAULT_HEAP_RECYCLE_LIVE_FRACTION, DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION, DEFAULT_HEAP_RECYCLE_SUSTAIN_WINDOW_MS, DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS, DEFAULT_HEAP_CHECKPOINT_MS, DEFAULT_HEAP_PINNED_FRACTION, DEFAULT_HEAP_PINNED_SUSTAIN_MS, DEFAULT_HEAP_HARD_EXIT_FRACTION, DEFAULT_HEAP_RECYCLE_LATCH_HARD_EXIT_MS, DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES, DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES, } from "./sync-runner-heap-telemetry.js";
-import { emitCloudTelemetry } from "../telemetry-events.js";
-function mutableReaders() {
-    const state = {
-        used: 0,
-        total: 0,
-        limit: 1000,
-        externalV8: 0,
-        rss: 0,
-        external: 0,
-        arrayBuffers: 0,
-        now: 0,
-    };
-    const readers = {
-        getHeapStatistics: () => ({
-            used_heap_size: state.used,
-            total_heap_size: state.total,
-            heap_size_limit: state.limit,
-            external_memory: state.externalV8,
-        }),
-        memoryUsage: () => ({
-            rss: state.rss,
-            heapTotal: state.total,
-            heapUsed: state.used,
-            external: state.external,
-            arrayBuffers: state.arrayBuffers,
-        }),
-        monotonicNowMs: () => state.now,
-    };
-    return { state, readers };
-}
-function fakeScheduler() {
-    let handler = null;
-    let cleared = false;
-    let unrefCalls = 0;
-    const scheduler = {
-        setInterval: (fn) => {
-            handler = fn;
-            return {
-                unref: () => {
-                    unrefCalls += 1;
-                },
-            };
-        },
-        clearInterval: () => {
-            cleared = true;
-            handler = null;
-        },
-    };
-    return {
-        scheduler,
-        tick: () => handler?.(),
-        isCleared: () => cleared,
-        unrefCalls: () => unrefCalls,
-    };
-}
-/** A manual GC observer whose registered callback the test fires by hand. */
-function fakeGcObserver() {
-    let cb = null;
-    let started = false;
-    let stopped = false;
-    const observer = {
-        start: (onMajorGc) => {
-            cb = onMajorGc;
-            started = true;
-        },
-        stop: () => {
-            stopped = true;
-            cb = null;
-        },
-    };
-    return {
-        observer,
-        fire: () => cb?.(),
-        started: () => started,
-        stopped: () => stopped,
-    };
-}
-describe("sampleRunnerHeap", () => {
-    it("maps injected v8/process readings to a flat numeric record", () => {
-        const census = new HeapCensus();
-        census.register("mapA", () => 3);
-        census.register("setB", () => 5);
-        const { state, readers } = mutableReaders();
-        Object.assign(state, {
-            used: 111,
-            total: 222,
-            limit: 2048,
-            externalV8: 33,
-            rss: 444,
-            external: 55,
-            arrayBuffers: 66,
-            now: 5000,
-        });
-        const sample = sampleRunnerHeap({ readers, census, sessionStartedAtMs: 1000 });
-        expect(sample).toMatchObject({
-            usedHeapBytes: 111,
-            totalHeapBytes: 222,
-            heapLimitBytes: 2048,
-            externalV8Bytes: 33,
-            rssBytes: 444,
-            externalBytes: 55,
-            arrayBuffersBytes: 66,
-            uptimeMs: 4000,
-            censusTotal: 8,
-        });
-        expect(sample.census).toEqual([
-            { site: "mapA", count: 3 },
-            { site: "setB", count: 5 },
-        ]);
-    });
-    it("emits only numeric properties that survive the LOCAL telemetry sanitizer", async () => {
-        // NOTE: this exercises hq-cloud's own emit-side sanitizer, which keys on the
-        // VALUE type — a numeric value survives regardless of key. It is a DIFFERENT
-        // and more permissive layer than hq-pro's ingest contract (the vault's
-        // redactProperties, which drops any key not ending in _count/_bytes/_ms or
-        // containing a denied substring). The regression this module fixes is that
-        // the old `census_<token>` spelling passed HERE but was silently dropped at
-        // ingest; the deny-safe `_count` spelling — pinned by the ingest-key-contract
-        // test below — is what makes the attribution actually reach the store.
-        const census = new HeapCensus();
-        census.register("publishedDigestGenerations", () => 12345);
-        census.register("knownKinds", () => 10);
-        const { state, readers } = mutableReaders();
-        Object.assign(state, {
-            used: 1,
-            total: 2,
-            limit: 3,
-            externalV8: 4,
-            rss: 5,
-            external: 6,
-            arrayBuffers: 7,
-            now: 10,
-        });
-        const props = heapSampleCloudProperties(sampleRunnerHeap({ readers, census, sessionStartedAtMs: 0 }));
-        for (const value of Object.values(props)) {
-            expect(typeof value).toBe("number");
-        }
-        const captured = [];
-        const client = {
-            postTelemetryEvents: async (batch) => {
-                for (const event of batch.events)
-                    captured.push(event);
-                return { accepted: batch.events.length };
-            },
-        };
-        await emitCloudTelemetry(client, {
-            eventName: "sync_runner_heap_sample",
-            source: "sync-runner-heap",
-            properties: props,
-        });
-        const survived = captured[0]?.properties ?? {};
-        expect(survived.census_publishedDigestGenerations_count).toBe(12345);
-        expect(survived.heap_used_bytes).toBe(1);
-        // No property was dropped by the sanitizer.
-        expect(Object.keys(survived).length).toBe(Object.keys(props).length);
-    });
-});
-describe("HeapCensus", () => {
-    it("rejects non-fixed census tokens and overwrites duplicates so the registry stays bounded", () => {
-        const census = new HeapCensus();
-        expect(() => census.register("has space", () => 1)).toThrow();
-        expect(() => census.register("../path", () => 1)).toThrow();
-        census.register("dupe", () => 1);
-        census.register("dupe", () => 2);
-        expect(census.siteCount).toBe(1);
-        expect(census.snapshot()).toEqual([{ site: "dupe", count: 2 }]);
-    });
-    it("reports 0 for a faulty reader rather than throwing", () => {
-        const census = new HeapCensus();
-        census.register("ok", () => 4);
-        census.register("boom", () => {
-            throw new Error("reader exploded");
-        });
-        expect(census.snapshot()).toEqual([
-            { site: "ok", count: 4 },
-            { site: "boom", count: 0 },
-        ]);
-    });
-});
-describe("RunnerHeapTelemetry", () => {
-    it("computes census growth against the session's first sample", () => {
-        let a = 1;
-        const b = 100;
-        const census = new HeapCensus();
-        census.register("aMap", () => a);
-        census.register("bMap", () => b);
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 10;
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-        });
-        controller.sample(); // baseline a=1, b=100
-        a = 5000;
-        state.used = 800; // 0.8 of limit -> crosses 0.75
-        const { pressure } = controller.sample();
-        expect(pressure?.topSites[0]).toMatchObject({ site: "aMap", growth: 4999 });
-    });
-    it("keeps only baseline and latest across many samples (no unbounded history)", () => {
-        let n = 0;
-        const census = new HeapCensus();
-        census.register("n", () => n);
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 1;
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-        });
-        for (n = 0; n < 100; n += 1) {
-            state.now = n;
-            controller.sample();
-        }
-        expect(controller.baselineSample?.census).toEqual([{ site: "n", count: 0 }]);
-        expect(controller.latestSample?.census).toEqual([{ site: "n", count: 99 }]);
-    });
-    it("emits the pressure record exactly once per rising crossing, calibrated to the injected heap limit", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * 1024 * 1024; // desktop-injected 2048 MB ceiling
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-        });
-        state.used = state.limit * 0.5;
-        expect(controller.sample().pressure).toBeNull(); // below threshold
-        state.used = Math.round(state.limit * 0.76);
-        const crossing = controller.sample().pressure; // rising crossing -> one record
-        expect(crossing).not.toBeNull();
-        expect(crossing?.thresholdFraction).toBe(0.75);
-        expect(crossing?.usedFraction).toBeCloseTo(0.76, 2);
-        state.used = Math.round(state.limit * 0.8);
-        expect(controller.sample().pressure).toBeNull(); // still above -> no repeat
-        state.used = Math.round(state.limit * 0.5);
-        expect(controller.sample().pressure).toBeNull(); // dropped below -> re-arm
-        state.used = Math.round(state.limit * 0.9);
-        expect(controller.sample().pressure).not.toBeNull(); // second crossing -> record
-    });
-});
-describe("startRunnerHeapSampling", () => {
-    it("unrefs the timer, clears it on stop, and never lets a fault reach the caller", () => {
-        const census = new HeapCensus();
-        // A faulty reader must be swallowed to 0, never thrown out of the sampler.
-        census.register("x", () => {
-            throw new Error("reader boom");
-        });
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 900; // 0.9 -> above the 0.75 threshold -> pressure fires
-        const fake = fakeScheduler();
-        const onSample = vi.fn(() => {
-            throw new Error("sample emit boom");
-        });
-        const onPressure = vi.fn(() => {
-            throw new Error("pressure emit boom");
-        });
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            intervalMs: 60_000,
-            scheduler: fake.scheduler,
-            onSample,
-            onPressure,
-            log: () => { },
-        });
-        expect(fake.unrefCalls()).toBe(1);
-        // A tick with a throwing reader AND throwing emit callbacks must not throw.
-        expect(() => fake.tick()).not.toThrow();
-        expect(onSample).toHaveBeenCalledTimes(1);
-        expect(onPressure).toHaveBeenCalledTimes(1);
-        handle.stop();
-        expect(fake.isCleared()).toBe(true);
-        // Ticks after stop are inert.
-        fake.tick();
-        expect(onSample).toHaveBeenCalledTimes(1);
-    });
-    it("drives repeated samples so at least two heap records reach the sink", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 1; // never crosses -> only heap samples, no pressure
-        const fake = fakeScheduler();
-        const samples = [];
-        startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            intervalMs: 1,
-            scheduler: fake.scheduler,
-            onSample: (sample) => samples.push(sample.usedHeapBytes),
-            onPressure: () => {
-                throw new Error("no crossing expected");
-            },
-        });
-        fake.tick();
-        fake.tick();
-        expect(samples).toHaveLength(2);
-    });
-    it("primes the growth baseline at start, so a first crossing already above the threshold still reports real growth", () => {
-        let count = 100;
-        const census = new HeapCensus();
-        census.register("x", () => count);
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 900; // already above the 0.75 threshold at the very first tick
-        const fake = fakeScheduler();
-        const pressures = [];
-        startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            intervalMs: 1000,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: (record) => pressures.push(record),
-        });
-        // Baseline was primed at count=100 before the first interval. Grow, then the
-        // first scheduled sample crosses the threshold.
-        count = 5000;
-        fake.tick();
-        expect(pressures).toHaveLength(1);
-        // Without priming the baseline would equal the crossing sample and growth
-        // would be reported as 0, losing the attribution.
-        expect(pressures[0].topSites[0]).toMatchObject({ site: "x", growth: 4900 });
-    });
-});
-describe("resolveHeapPressureFraction", () => {
-    it("parses a valid fraction and falls back to the default on garbage or out-of-range input", () => {
-        expect(resolveHeapPressureFraction("0.6")).toBe(0.6);
-        expect(resolveHeapPressureFraction("1")).toBe(1);
-        expect(resolveHeapPressureFraction("")).toBe(0.75);
-        expect(resolveHeapPressureFraction("2")).toBe(0.75);
-        expect(resolveHeapPressureFraction("-1")).toBe(0.75);
-        expect(resolveHeapPressureFraction("0.5x")).toBe(0.75); // trailing junk rejected
-        expect(resolveHeapPressureFraction(undefined)).toBe(0.75);
-    });
-});
-describe("resolveHeapSampleIntervalMs", () => {
-    it("parses whole milliseconds and rejects a malformed value like '60s' rather than accepting its prefix", () => {
-        expect(resolveHeapSampleIntervalMs("60000")).toBe(60_000);
-        expect(resolveHeapSampleIntervalMs("500")).toBe(500);
-        // The natural-but-invalid "60s" must NOT become a 60 ms interval.
-        expect(resolveHeapSampleIntervalMs("60s")).toBe(60_000);
-        expect(resolveHeapSampleIntervalMs("1_000")).toBe(60_000);
-        expect(resolveHeapSampleIntervalMs("")).toBe(60_000);
-        expect(resolveHeapSampleIntervalMs("0")).toBe(60_000);
-        expect(resolveHeapSampleIntervalMs(undefined)).toBe(60_000);
-    });
-});
-describe("heapPressureStderrLine", () => {
-    it("renders a compact numeric-only pressure line with fixed-token sites", () => {
-        const line = heapPressureStderrLine({
-            usedHeapBytes: 100,
-            heapLimitBytes: 200,
-            effectiveLimitBytes: 200,
-            declaredCeilingBytes: 0,
-            usedFraction: 0.5,
-            thresholdFraction: 0.75,
-            rssBytes: 300,
-            externalBytes: 40,
-            uptimeMs: 1000,
-            topSites: [{ site: "knownKinds", count: 5, growth: 3 }],
-        });
-        expect(line).toContain("used=100");
-        expect(line).toContain("limit=200");
-        expect(line).toContain("uptime_ms=1000");
-        expect(line).toContain("top=knownKinds:3");
-    });
-});
-// --- Self-recycling governor (GC-anchored post-GC live floor) -----------------
-const MB = 1024 * 1024;
-// Comfortably past the 35-minute uptime floor, so the floor never gates a test
-// that is exercising a different property.
-const PAST_FLOOR_MS = DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS + 5 * 60_000;
-function governor(overrides = {}) {
-    const census = overrides.census ?? new HeapCensus();
-    if (!overrides.census)
-        census.register("knownKinds", () => 1);
-    const { state, readers } = mutableReaders();
-    state.limit = overrides.limitBytes ?? 2048 * MB;
-    const controller = new RunnerHeapTelemetry({
-        readers,
-        census,
-        sessionStartedAtMs: 0,
-        pressureThresholdFraction: 0.75,
-        recycleLiveFraction: overrides.liveFraction ?? 0.6,
-        recycleSustainWindowMs: overrides.windowMs ?? 120_000,
-        recycleEmergencyFraction: overrides.emergencyFraction ?? 0.9,
-        recycleMinUptimeMs: overrides.minUptimeMs ?? DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS,
-        recycleEnabled: overrides.recycleEnabled ?? true,
-        ...(overrides.declaredCeilingBytes !== undefined
-            ? { declaredCeilingBytes: overrides.declaredCeilingBytes }
-            : {}),
-        ...(overrides.pinnedFraction !== undefined
-            ? { recyclePinnedFraction: overrides.pinnedFraction }
-            : {}),
-        ...(overrides.pinnedSustainWindowMs !== undefined
-            ? { recyclePinnedSustainWindowMs: overrides.pinnedSustainWindowMs }
-            : {}),
-        ...(overrides.hardExitFraction !== undefined
-            ? { hardExitFraction: overrides.hardExitFraction }
-            : {}),
-        ...(overrides.latchHardExitMs !== undefined
-            ? { latchHardExitMs: overrides.latchHardExitMs }
-            : {}),
-        ...(overrides.latchHardExitObservations !== undefined
-            ? { latchHardExitObservations: overrides.latchHardExitObservations }
-            : {}),
-        ...(overrides.footprintRecycleEnabled !== undefined
-            ? { footprintRecycleEnabled: overrides.footprintRecycleEnabled }
-            : {}),
-        ...(overrides.footprintRecycleBytes !== undefined
-            ? { footprintRecycleBytes: overrides.footprintRecycleBytes }
-            : {}),
-        ...(overrides.footprintHardExitBytes !== undefined
-            ? { footprintHardExitBytes: overrides.footprintHardExitBytes }
-            : {}),
-    });
-    const setAt = (fraction, nowMs) => {
-        state.used = Math.round(state.limit * fraction);
-        state.now = nowMs;
-    };
-    // Footprint driver: a HIGH resident rss (absolute bytes) with a QUIET heap
-    // (usedFraction default 0.30, below every heap floor), so only the footprint
-    // tier can produce a verdict.
-    const setFootprint = (rssBytes, nowMs, usedFraction = 0.3) => {
-        state.rss = rssBytes;
-        state.used = Math.round(state.limit * usedFraction);
-        state.now = nowMs;
-    };
-    // The cooperative recycle channel (backward-compatible with the shipped tests).
-    const observeAt = (fraction, nowMs) => {
-        setAt(fraction, nowMs);
-        return controller.observeMajorGc().recycle;
-    };
-    const sampleAt = (fraction, nowMs) => {
-        setAt(fraction, nowMs);
-        return controller.sample();
-    };
-    const evaluateAt = (fraction, nowMs) => {
-        setAt(fraction, nowMs);
-        return controller.evaluate().recycle;
-    };
-    // The full verdict channel (both cooperative recycle AND hard exit).
-    const observeFullAt = (fraction, nowMs) => {
-        setAt(fraction, nowMs);
-        return controller.observeMajorGc();
-    };
-    const evaluateFullAt = (fraction, nowMs) => {
-        setAt(fraction, nowMs);
-        return controller.evaluate();
-    };
-    return {
-        state,
-        readers,
-        census,
-        controller,
-        setAt,
-        setFootprint,
-        observeAt,
-        sampleAt,
-        evaluateAt,
-        observeFullAt,
-        evaluateFullAt,
-    };
-}
-describe("RunnerHeapTelemetry — recycle governor (primary post-GC live path)", () => {
-    it("recycles on a sustained post-GC live floor across the window, past the uptime floor", () => {
-        const g = governor();
-        // First qualifying post-GC observation at/above the live floor: anchors only.
-        expect(g.observeAt(0.62, PAST_FLOOR_MS)).toBeNull();
-        // Too soon (less than the 120 s window since the anchor): still no verdict.
-        expect(g.observeAt(0.65, PAST_FLOOR_MS + 119_000)).toBeNull();
-        // A window later, still at/above the floor: recycle, trigger "live".
-        const recycle = g.observeAt(0.66, PAST_FLOOR_MS + 121_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("live");
-        expect(recycle?.liveFraction).toBeCloseTo(0.66, 2);
-        expect(recycle?.observedSustainMs).toBe(121_000);
-        expect(recycle?.recycleLiveFraction).toBe(0.6);
-    });
-    it("is immune to an instantaneous sawtooth: neither the sample path nor a below-floor live reading ever recycles", () => {
-        // The exact defect: instantaneous used_heap_size oscillates high (0.60..0.89,
-        // never at the 0.90 emergency line) while the POST-GC live floor stays low
-        // (0.30). The old rule watched the instantaneous series and would have tripped;
-        // the GC-anchored rule watches only the post-GC floor and never does.
-        const g = governor();
-        const inst = [0.62, 0.30, 0.88, 0.35, 0.89, 0.28, 0.87, 0.40];
-        let t = PAST_FLOOR_MS;
-        for (const f of inst) {
-            // The interval sampler sees the instantaneous sawtooth — emergency only,
-            // and 0.89 < 0.90, so it never fires.
-            expect(g.sampleAt(f, t).recycle).toBeNull();
-            // The post-GC live floor is flat at 0.30, well below the 0.60 floor.
-            expect(g.observeAt(0.3, t)).toBeNull();
-            t += 60_000;
-        }
-    });
-    it("requires the window between the TWO qualifying observations, and resets the anchor on a dip", () => {
-        const g = governor();
-        // Two qualifying observations less than a window apart never recycle.
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull();
-        expect(g.observeAt(0.7, PAST_FLOOR_MS + 60_000)).toBeNull(); // 60 s < 120 s
-        // A dip below the floor resets the anchor: the clock since the FIRST
-        // observation no longer counts.
-        expect(g.observeAt(0.4, PAST_FLOOR_MS + 90_000)).toBeNull(); // dip -> anchor cleared
-        expect(g.observeAt(0.7, PAST_FLOOR_MS + 100_000)).toBeNull(); // re-anchor here
-        expect(g.observeAt(0.7, PAST_FLOOR_MS + 180_000)).toBeNull(); // only 80 s since re-anchor
-        const recycle = g.observeAt(0.7, PAST_FLOOR_MS + 221_000); // 121 s since re-anchor
-        expect(recycle).not.toBeNull();
-        // The sustain span is measured from the RE-ANCHOR, not the first observation.
-        expect(recycle?.observedSustainMs).toBe(121_000);
-    });
-    it("never recycles (live path) before the uptime floor, however high the live floor climbs", () => {
-        const g = governor();
-        // Live floor pinned at 0.80 for many observations, but every one is below the
-        // 35-minute floor: no verdict, so the desktop's crash streak is never touched.
-        let t = 60_000;
-        for (let i = 0; i < 40; i += 1) {
-            expect(g.observeAt(0.8, t)).toBeNull();
-            t += 30_000; // stays under DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS (35 min)
-        }
-        // Cross the floor with the window already satisfied -> recycle.
-        const recycle = g.observeAt(0.8, DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS + 1);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("live");
-    });
-    it("keeps the uptime floor strictly above hq-desktop-app's 30-minute HEALTHY_RUN_WINDOW", () => {
-        // A recycle must OUTLIVE the desktop's 30-minute window so should_reset_after_recovery
-        // clears the crash streak instead of pacing respawn backoff. The literal is
-        // quoted so a future change that would drop the floor to/under it fails here.
-        const DESKTOP_HEALTHY_RUN_WINDOW_MS = 1_800_000;
-        expect(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS).toBe(2_100_000); // 35 min
-        expect(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS).toBeGreaterThan(DESKTOP_HEALTHY_RUN_WINDOW_MS);
-    });
-    it("scales the live floor with the reported heap limit, so a larger ceiling never recycles prematurely", () => {
-        // 1700 MB is 0.83 of a 2048 MB ceiling (recycles) but only 0.415 of a 4096 MB
-        // ceiling (below the 0.60 live floor -> never), because the floor is a
-        // fraction of the injected heap_size_limit, not an absolute figure.
-        const small = governor({ limitBytes: 2048 * MB });
-        small.state.used = 1700 * MB;
-        small.state.now = PAST_FLOOR_MS;
-        expect(small.controller.observeMajorGc().recycle).toBeNull(); // anchor
-        small.state.now = PAST_FLOOR_MS + 121_000;
-        expect(small.controller.observeMajorGc().recycle).not.toBeNull();
-        const large = governor({ limitBytes: 4096 * MB });
-        let t = PAST_FLOOR_MS;
-        for (let i = 0; i < 10; i += 1) {
-            large.state.used = 1700 * MB; // 0.415 of 4096 MB
-            large.state.now = t;
-            expect(large.controller.observeMajorGc().recycle).toBeNull();
-            t += 121_000;
-        }
-    });
-    it("maintains the anchor on every major GC, so a close below-floor recovery resets the sustain run", () => {
-        // The anchor is updated on EVERY observed major GC — there is no throttle
-        // that could skip a below-floor recovery and leave a stale anchor faking a
-        // continuous run (the reviewed defect).
-        const g = governor();
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull(); // anchor
-        expect(g.observeAt(0.4, PAST_FLOOR_MS + 1_000)).toBeNull(); // 1 s later, below floor -> reset
-        expect(g.observeAt(0.7, PAST_FLOOR_MS + 2_000)).toBeNull(); // re-anchor here
-        // 121 s past the FIRST anchor but only 119 s past the RE-anchor: no recycle.
-        expect(g.observeAt(0.7, PAST_FLOOR_MS + 121_000)).toBeNull();
-        // A window past the re-anchor -> recycle, sustain measured from the re-anchor.
-        const recycle = g.observeAt(0.7, PAST_FLOOR_MS + 123_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.observedSustainMs).toBe(121_000);
-    });
-    it("attaches census growth and rss/external/arrayBuffers deltas to the recycle record", () => {
-        let entries = 100;
-        const census = new HeapCensus();
-        census.register("watcherJournalStores", () => entries);
-        const g = governor({ census });
-        // Prime the growth baseline at session start (entries=100, rss=0), exactly as
-        // startRunnerHeapSampling does before the first interval.
-        g.controller.primeBaseline();
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull(); // anchor
-        entries = 900;
-        g.state.rss = 1_500 * MB;
-        g.state.external = 40 * MB;
-        g.state.arrayBuffers = 12 * MB;
-        const recycle = g.observeAt(0.7, PAST_FLOOR_MS + 121_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.topSites[0]).toMatchObject({ site: "watcherJournalStores", growth: 800 });
-        expect(recycle?.rssGrowthBytes).toBe(1_500 * MB);
-        expect(recycle?.externalGrowthBytes).toBe(40 * MB);
-        expect(recycle?.arrayBuffersGrowthBytes).toBe(12 * MB);
-        expect(recycle?.censusTotal).toBe(900);
-    });
-});
-describe("RunnerHeapTelemetry — emergency backstop", () => {
-    it("recycles on a single instantaneous sample at/above the emergency fraction, even below the uptime floor", () => {
-        const g = governor();
-        // Well below the uptime floor, but a single instantaneous sample above the
-        // 0.90 emergency line: at that reading V8 is minutes from aborting, recycle now.
-        const { recycle } = g.sampleAt(0.92, 30_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("emergency");
-        expect(recycle?.observedSustainMs).toBe(0);
-    });
-    it("does not fire the emergency backstop below the emergency fraction", () => {
-        const g = governor();
-        // 0.89 instantaneous, sustained across many samples below the floor: the
-        // emergency arm never fires (and the live path is off — no GC observations).
-        let t = 30_000;
-        for (let i = 0; i < 20; i += 1) {
-            expect(g.sampleAt(0.89, t).recycle).toBeNull();
-            t += 60_000;
-        }
-    });
-    it("fires the emergency path even when a post-GC observation is already abort-adjacent (bypassing the window)", () => {
-        const g = governor();
-        // A post-GC live reading already at 0.95 recycles immediately, without the
-        // sustain window and without a prior anchor.
-        const recycle = g.observeAt(0.95, 20_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("emergency");
-    });
-    it("evaluate() is a loop-top backstop that runs the emergency check off the timer path", () => {
-        const g = governor();
-        // The interval sampler never ticked, but a loop-top evaluate() catches an
-        // abort-adjacent instantaneous reading — the starved-timer safety net.
-        expect(g.evaluateAt(0.6, 30_000)).toBeNull(); // below emergency, no window seen
-        const recycle = g.evaluateAt(0.92, 60_000);
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("emergency");
-    });
-});
-describe("RunnerHeapTelemetry — recycle governor invariants", () => {
-    it("emits at most one recycle verdict per session, across every path", () => {
-        const g = governor();
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull();
-        const first = g.observeAt(0.7, PAST_FLOOR_MS + 121_000);
-        expect(first).not.toBeNull();
-        // No second verdict from any path.
-        expect(g.observeAt(0.95, PAST_FLOOR_MS + 200_000)).toBeNull();
-        expect(g.sampleAt(0.99, PAST_FLOOR_MS + 260_000).recycle).toBeNull();
-        expect(g.evaluateAt(0.99, PAST_FLOOR_MS + 320_000)).toBeNull();
-    });
-    it("the kill switch disables every recycle path; pressure still behaves as base", () => {
-        const g = governor({ recycleEnabled: false });
-        let pressures = 0;
-        let recycles = 0;
-        let t = PAST_FLOOR_MS;
-        for (let i = 0; i < 20; i += 1) {
-            const { pressure, recycle } = g.sampleAt(0.99, t); // far above any fraction
-            if (pressure)
-                pressures += 1;
-            if (recycle)
-                recycles += 1;
-            if (g.observeAt(0.99, t))
-                recycles += 1;
-            if (g.evaluateAt(0.99, t))
-                recycles += 1;
-            t += 60_000;
-        }
-        expect(recycles).toBe(0); // governor off — never recycles on ANY path
-        expect(pressures).toBe(1); // pressure record still fires once per crossing
-    });
-    it("a recycle record and stderr line carry only fixed tokens and integers — never a runner byte", () => {
-        const SECRET_PATH = "/Users/hassaan/hq/companies/acme-corp/vault/report.md";
-        const SLUG = "acme-corp";
-        const FILENAME = "report.md";
-        const backing = new Map();
-        backing.set(SECRET_PATH, 1);
-        backing.set(`companies/${SLUG}/notes`, 2);
-        backing.set(FILENAME, 3);
-        const census = new HeapCensus();
-        census.register("watcherJournalStores", () => backing.size);
-        census.register("publishedDigestGenerations", () => backing.size);
-        const g = governor({ census });
-        const recycle = g.sampleAt(0.95, PAST_FLOOR_MS).recycle; // emergency path
-        expect(recycle).not.toBeNull();
-        const line = heapRecycleStderrLine(recycle);
-        const json = JSON.stringify(recycle);
-        for (const secret of [SECRET_PATH, SLUG, FILENAME, "/Users/", "companies/"]) {
-            expect(line).not.toContain(secret);
-            expect(json).not.toContain(secret);
-        }
-        expect(json).toContain("watcherJournalStores");
-    });
-    it("the recycle stderr line matches NONE of hq-desktop-app's fatal stderr markers", () => {
-        const DESKTOP_FATAL_MARKERS = [
-            "javascript heap out of memory",
-            "ineffective mark-compacts",
-            "fatal error",
-            "uncaught exception",
-            "unhandledrejection",
-            "panicked at",
-            "assertion failed",
-            "npm error ",
-            "npm err! ",
-            "enospc",
-            "permission denied",
-            "no such file or directory",
-            "command not found",
-        ];
-        const census = new HeapCensus();
-        for (const token of [
-            "pendingAppliedUpserts",
-            "watcherJournalStores",
-            "publishedDigestGenerations",
-            "knownKinds",
-            "deleteSnapshotEpochs",
-        ]) {
-            census.register(token, () => 7);
-        }
-        const g = governor({ census });
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull();
-        const recycle = g.observeAt(0.7, PAST_FLOOR_MS + 121_000);
-        const line = heapRecycleStderrLine(recycle);
-        const lowered = line.toLowerCase();
-        for (const marker of DESKTOP_FATAL_MARKERS) {
-            expect(lowered).not.toContain(marker);
-        }
-        expect(line.trimStart().startsWith("#")).toBe(false);
-        expect(line).toContain("hq-sync-runner: heap-recycle");
-        expect(line).toContain("trigger=live");
-        expect(line).toContain("sustain_ms=");
-    });
-});
-describe("RunnerHeapTelemetry — recorded production series replay (regression reopen)", () => {
-    // The aborting generation's own recorded telemetry (person#prs_01KQ2TZQMA...,
-    // 2026-09-01 18:57..19:48Z). heap_size_limit was 2348810240 B; the SIGABRT
-    // landed at uptime 55m16s = 3_316_000 ms.
-    const RECORDED_LIMIT_BYTES = 2_348_810_240;
-    const ABORT_UPTIME_MS = 3_316_000;
-    // The recorded per-sample INSTANTANEOUS used/limit fractions. Max is 0.741 —
-    // it never reaches the old 0.78 rule and never two-in-a-row, and never the
-    // 0.90 emergency line, so the instantaneous path is inert (the base failure).
-    const INSTANTANEOUS = [
-        0.072, 0.106, 0.109, 0.458, 0.546, 0.251, 0.592, 0.564, 0.559, 0.427, 0.457,
-        0.564, 0.397, 0.584, 0.438, 0.523, 0.64, 0.548, 0.66, 0.664, 0.512, 0.513,
-        0.69, 0.703, 0.741,
-    ];
-    it("base instantaneous logic is inert: no sample-path recycle across the entire recorded series", () => {
-        const g = governor({ limitBytes: RECORDED_LIMIT_BYTES });
-        let recycles = 0;
-        let t = 4.24 * 60_000;
-        for (const f of INSTANTANEOUS) {
-            if (g.sampleAt(f, t).recycle)
-                recycles += 1;
-            t += 2 * 60_000;
-        }
-        expect(recycles).toBe(0); // the exact inertness the regression exhibited
-    });
-    it("GC-anchored logic produces exactly one live recycle before the recorded 55m16s abort", () => {
-        // The implied POST-GC live floor: monotonic, crossing 0.60 between ~36.7 and
-        // ~39 min (the lower envelope of the instantaneous series). One major-GC
-        // observation per minute.
-        const LIVE_FLOOR = [
-            { uptimeMin: 4, fraction: 0.07 },
-            { uptimeMin: 12, fraction: 0.11 },
-            { uptimeMin: 20, fraction: 0.25 },
-            { uptimeMin: 28, fraction: 0.42 },
-            { uptimeMin: 34, fraction: 0.51 },
-            { uptimeMin: 37, fraction: 0.6 }, // crosses the floor here -> anchor
-            { uptimeMin: 39, fraction: 0.63 }, // >= 120 s later -> recycle
-            { uptimeMin: 46, fraction: 0.69 },
-            { uptimeMin: 52, fraction: 0.74 },
-        ];
-        const g = governor({ limitBytes: RECORDED_LIMIT_BYTES });
-        const verdicts = [];
-        for (const point of LIVE_FLOOR) {
-            const recycle = g.observeAt(point.fraction, point.uptimeMin * 60_000);
-            if (recycle)
-                verdicts.push(recycle);
-        }
-        expect(verdicts).toHaveLength(1);
-        expect(verdicts[0].trigger).toBe("live");
-        expect(verdicts[0].uptimeMs).toBeLessThan(ABORT_UPTIME_MS); // wins the race to V8
-        expect(verdicts[0].uptimeMs).toBeGreaterThanOrEqual(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS);
-        // ~16 minutes of headroom before the recorded abort.
-        expect(ABORT_UPTIME_MS - verdicts[0].uptimeMs).toBeGreaterThan(10 * 60_000);
-    });
-});
-describe("ingest key contract — every emitted property key survives hq-pro redactProperties", () => {
-    // hq-pro's raw-telemetry-envelope ingest keeps a numeric property ONLY when its
-    // key matches this shape, ends in _count/_bytes/_ms, and contains none of these
-    // denied substrings. Quoted here as literals: a future key that violates the
-    // contract (the exact defect that dropped every census field to date) fails.
-    const KEY_SHAPE = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
-    const DENY_PARTS = [
-        "authorization",
-        "body",
-        "content",
-        "cookie",
-        "email",
-        "file",
-        "message",
-        "password",
-        "path",
-        "prompt",
-        "query",
-        "secret",
-        "text",
-        "token",
-        "transcript",
-    ];
-    // Every FIXED census token the production runner registers (watch-loop ownMaps
-    // + the decoupled emitter/watcher tokens). If a new token is added, add it here.
-    const PRODUCTION_CENSUS_TOKENS = [
-        "pendingAppliedUpserts",
-        "pendingWatcherEntries",
-        "pendingWatcherChanges",
-        "pendingWatcherDroppedRouteHints",
-        "quarantinedDeleteRoots",
-        "watcherJournalStores",
-        "watcherJournalRows",
-        "targetedJournalSessions",
-        "targetedJournalRows",
-        "cachedAreaJournalMigrations",
-        "pendingSlowPasses",
-        "pendingFastPasses",
-        "lastPublishedDigests",
-        "publishedDigestGenerations",
-        "deferredPublishes",
-        "durablePublishedHashRetries",
-        "initialPublishedDigests",
-        "knownKinds",
-        "deleteSnapshotEpochs",
-        "ignoreFilterMemo",
-    ];
-    function assertIngestSafe(props) {
-        for (const key of Object.keys(props)) {
-            const lower = key.toLowerCase();
-            expect(KEY_SHAPE.test(key), `key shape: ${key}`).toBe(true);
-            expect(lower.endsWith("count") || lower.endsWith("bytes") || lower.endsWith("ms"), `key suffix: ${key}`).toBe(true);
-            for (const part of DENY_PARTS) {
-                expect(lower.includes(part), `deny part "${part}" in ${key}`).toBe(false);
-            }
-        }
-    }
-    function fullCensus() {
-        const census = new HeapCensus();
-        for (const token of PRODUCTION_CENSUS_TOKENS)
-            census.register(token, () => 7);
-        return census;
-    }
-    it("heapSampleCloudProperties keys are all ingest-safe", () => {
-        const { readers } = mutableReaders();
-        const sample = sampleRunnerHeap({ readers, census: fullCensus(), sessionStartedAtMs: 0 });
-        assertIngestSafe(heapSampleCloudProperties(sample));
-    });
-    it("heapPressureCloudProperties keys are all ingest-safe", () => {
-        const census = fullCensus();
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(2048 * MB * 0.8);
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-        });
-        const { pressure } = controller.sample();
-        expect(pressure).not.toBeNull();
-        assertIngestSafe(heapPressureCloudProperties(pressure));
-    });
-    it("heapRecycleCloudProperties keys are all ingest-safe (every trigger)", () => {
-        const emergency = governor({ census: fullCensus() }).sampleAt(0.95, PAST_FLOOR_MS).recycle;
-        expect(emergency).not.toBeNull();
-        assertIngestSafe(heapRecycleCloudProperties(emergency));
-        const g = governor({ census: fullCensus() });
-        expect(g.observeAt(0.7, PAST_FLOOR_MS)).toBeNull();
-        const live = g.observeAt(0.7, PAST_FLOOR_MS + 121_000);
-        expect(live).not.toBeNull();
-        assertIngestSafe(heapRecycleCloudProperties(live));
-        // A footprint recycle carries the three NEW keys (trigger flag + two byte
-        // floors); they must satisfy the same contract or ingest would drop them.
-        const gFoot = governor({ census: fullCensus(), minUptimeMs: 0 });
-        gFoot.setFootprint(4600 * MB, 30_000); // > 4096 recycle floor, < 4864 hard floor
-        const footprint = gFoot.controller.evaluate().recycle;
-        expect(footprint?.trigger).toBe("footprint");
-        const footProps = heapRecycleCloudProperties(footprint);
-        assertIngestSafe(footProps);
-        expect(footProps.recycle_footprint_trigger_count).toBe(1);
-        expect(footProps.recycle_footprint_recycle_floor_bytes).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(footProps.recycle_footprint_hard_exit_floor_bytes).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-        // A heap trigger reports 0 for the footprint trigger flag.
-        expect(heapRecycleCloudProperties(live).recycle_footprint_trigger_count).toBe(0);
-    });
-});
-describe("startRunnerHeapSampling — GC observer + recycle callback", () => {
-    it("drives the governor to a LIVE recycle via the injected GC observer and swallows a throwing onRecycle", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        const fake = fakeScheduler();
-        const gc = fakeGcObserver();
-        const recycles = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            recycleLiveFraction: 0.6,
-            recycleSustainWindowMs: 120_000,
-            recycleEmergencyFraction: 0.9,
-            recycleMinUptimeMs: DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS,
-            intervalMs: 1,
-            scheduler: fake.scheduler,
-            gcObserver: gc.observer,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => {
-                recycles.push(record);
-                throw new Error("recycle emit boom"); // must be swallowed
-            },
-            log: () => { },
-        });
-        expect(gc.started()).toBe(true);
-        // First major GC at/above the live floor: anchors, no verdict.
-        state.used = Math.round(state.limit * 0.7);
-        state.now = PAST_FLOOR_MS;
-        expect(() => gc.fire()).not.toThrow();
-        expect(recycles).toHaveLength(0);
-        // A window later: the second major GC produces the live recycle (throw swallowed).
-        state.now = PAST_FLOOR_MS + 121_000;
-        expect(() => gc.fire()).not.toThrow();
-        expect(recycles).toHaveLength(1);
-        expect(recycles[0].trigger).toBe("live");
-        // At most once per session, even as GCs continue.
-        state.now = PAST_FLOOR_MS + 300_000;
-        expect(() => gc.fire()).not.toThrow();
-        expect(recycles).toHaveLength(1);
-        handle.stop();
-        expect(gc.stopped()).toBe(true);
-    });
-    it("the loop-top evaluate() fires the emergency backstop when the interval timer never ticks", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        const fake = fakeScheduler();
-        const recycles = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            recycleEmergencyFraction: 0.9,
-            intervalMs: 60_000,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => recycles.push(record),
-            log: () => { },
-        });
-        // The timer never ticked. An abort-adjacent instantaneous heap: the loop-top
-        // evaluate() catches it anyway.
-        state.used = Math.round(state.limit * 0.93);
-        state.now = 30_000;
-        handle.evaluate();
-        expect(recycles).toHaveLength(1);
-        expect(recycles[0].trigger).toBe("emergency");
-    });
-    it("produces no recycle when the governor is disabled by option", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 1000;
-        state.used = 999;
-        state.now = PAST_FLOOR_MS;
-        const fake = fakeScheduler();
-        const gc = fakeGcObserver();
-        const recycles = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            recycleEnabled: false,
-            recycleMinUptimeMs: 0,
-            intervalMs: 1,
-            scheduler: fake.scheduler,
-            gcObserver: gc.observer,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => recycles.push(record),
-            log: () => { },
-        });
-        for (let i = 0; i < 10; i += 1) {
-            fake.tick();
-            gc.fire();
-            handle.evaluate();
-        }
-        expect(recycles).toHaveLength(0);
-    });
-});
-describe("isFreshGcReading", () => {
-    it("accepts a promptly-captured reading and rejects a stale (blocked-loop) one", () => {
-        expect(isFreshGcReading(1000, 1000)).toBe(true); // captured at the GC end
-        expect(isFreshGcReading(1000, 1000 + MAX_FRESH_GC_READING_MS)).toBe(true); // exactly at the bound
-        expect(isFreshGcReading(1000, 1000 + MAX_FRESH_GC_READING_MS + 1)).toBe(false); // just over
-        expect(isFreshGcReading(1000, 5000)).toBe(false); // blocked loop: 4 s stale reading
-        expect(isFreshGcReading(1000, 900)).toBe(true); // reading at/just before the GC end
-        // Missing entry timing degrades to "not fresh" (skip), never a false accept.
-        expect(isFreshGcReading(Number.NaN, 1000)).toBe(false);
-        expect(isFreshGcReading(1000, Number.NaN)).toBe(false);
-        expect(isFreshGcReading(1000, 1400, 500)).toBe(true); // custom threshold honored
-    });
-});
-describe("nodeMajorGcObserver", () => {
-    it("constructs, observes major GCs, and disconnects without throwing", () => {
-        const observer = nodeMajorGcObserver();
-        let fires = 0;
-        expect(() => observer.start(() => (fires += 1))).not.toThrow();
-        // Force a real major GC if the runtime exposes it; otherwise this is a no-op
-        // and the observer simply never fires — both are acceptable (degrade to
-        // silence). The contract under test is that neither start nor stop throws.
-        const globalGc = globalThis.gc;
-        if (typeof globalGc === "function") {
-            try {
-                globalGc({ type: "major" });
-            }
-            catch {
-                globalGc();
-            }
-        }
-        expect(() => observer.stop()).not.toThrow();
-        expect(fires).toBeGreaterThanOrEqual(0);
-    });
-    it("start() twice and stop() before start() never throw (degrade to silence)", () => {
-        const observer = nodeMajorGcObserver();
-        expect(() => observer.stop()).not.toThrow(); // stop before start
-        expect(() => observer.start(() => { })).not.toThrow();
-        expect(() => observer.start(() => { })).not.toThrow(); // re-start
-        expect(() => observer.stop()).not.toThrow();
-        expect(() => observer.stop()).not.toThrow(); // double stop
-    });
-});
-describe("resolveHeapRecycleEnabled", () => {
-    it("is ON by default and disabled only by an explicit whole-string off value", () => {
-        expect(resolveHeapRecycleEnabled(undefined)).toBe(true);
-        expect(resolveHeapRecycleEnabled("")).toBe(true);
-        expect(resolveHeapRecycleEnabled("1")).toBe(true);
-        expect(resolveHeapRecycleEnabled("true")).toBe(true);
-        expect(resolveHeapRecycleEnabled("0")).toBe(false);
-        expect(resolveHeapRecycleEnabled("false")).toBe(false);
-        expect(resolveHeapRecycleEnabled("NO")).toBe(false);
-        expect(resolveHeapRecycleEnabled(" off ")).toBe(false);
-        // A typo keeps the governor armed rather than silently disabling it.
-        expect(resolveHeapRecycleEnabled("disabled")).toBe(true);
-    });
-});
-describe("resolveHeapRecycleLiveFraction", () => {
-    it("parses a valid fraction and falls back to 0.60 on garbage or out-of-range input", () => {
-        expect(resolveHeapRecycleLiveFraction("0.5")).toBe(0.5);
-        expect(resolveHeapRecycleLiveFraction("1")).toBe(1);
-        expect(resolveHeapRecycleLiveFraction(undefined)).toBe(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION);
-        expect(resolveHeapRecycleLiveFraction("")).toBe(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION);
-        expect(resolveHeapRecycleLiveFraction("2")).toBe(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION);
-        expect(resolveHeapRecycleLiveFraction("-1")).toBe(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION);
-        expect(resolveHeapRecycleLiveFraction("0.6x")).toBe(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION);
-    });
-});
-describe("resolveHeapRecycleEmergencyFraction", () => {
-    it("parses a valid fraction and falls back to 0.90 on garbage or out-of-range input", () => {
-        expect(resolveHeapRecycleEmergencyFraction("0.95")).toBe(0.95);
-        expect(resolveHeapRecycleEmergencyFraction("1")).toBe(1);
-        expect(resolveHeapRecycleEmergencyFraction(undefined)).toBe(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION);
-        expect(resolveHeapRecycleEmergencyFraction("")).toBe(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION);
-        expect(resolveHeapRecycleEmergencyFraction("2")).toBe(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION);
-        expect(resolveHeapRecycleEmergencyFraction("0.9x")).toBe(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION);
-    });
-});
-describe("resolveHeapRecycleSustainWindowMs", () => {
-    it("parses whole ms >= 0 (0 removes the window) and rejects '2m' rather than its prefix", () => {
-        expect(resolveHeapRecycleSustainWindowMs("120000")).toBe(120_000);
-        expect(resolveHeapRecycleSustainWindowMs("0")).toBe(0); // 0 is a valid window
-        expect(resolveHeapRecycleSustainWindowMs(undefined)).toBe(DEFAULT_HEAP_RECYCLE_SUSTAIN_WINDOW_MS);
-        expect(resolveHeapRecycleSustainWindowMs("2m")).toBe(DEFAULT_HEAP_RECYCLE_SUSTAIN_WINDOW_MS);
-        expect(resolveHeapRecycleSustainWindowMs("-1")).toBe(DEFAULT_HEAP_RECYCLE_SUSTAIN_WINDOW_MS);
-        expect(resolveHeapRecycleSustainWindowMs("")).toBe(DEFAULT_HEAP_RECYCLE_SUSTAIN_WINDOW_MS);
-    });
-});
-describe("resolveHeapRecycleMinUptimeMs", () => {
-    it("parses whole ms >= 0 (0 disables the floor) and rejects '35m' rather than its prefix", () => {
-        expect(resolveHeapRecycleMinUptimeMs("60000")).toBe(60_000);
-        expect(resolveHeapRecycleMinUptimeMs("0")).toBe(0); // 0 is a valid floor
-        expect(resolveHeapRecycleMinUptimeMs(undefined)).toBe(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS);
-        expect(resolveHeapRecycleMinUptimeMs("35m")).toBe(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS);
-        expect(resolveHeapRecycleMinUptimeMs("-1")).toBe(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS);
-        expect(resolveHeapRecycleMinUptimeMs("")).toBe(DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS);
-    });
-});
-// --- v2-layered governor: effective limit, pinned + hard-exit tiers ----------
-describe("RunnerHeapTelemetry — effective-limit re-denomination", () => {
-    it("divides every fraction by min(declared, reported) so a declared ceiling makes the trigger real", () => {
-        const declared = 2048 * MB;
-        const reported = 2233 * MB; // Node-25 reported limit sits above the declared ceiling
-        const withDeclared = governor({
-            declaredCeilingBytes: declared,
-            limitBytes: reported,
-            minUptimeMs: 0,
-        });
-        // 0.91 of the DECLARED ceiling: 1863 MB. Over effective (declared) that is
-        // 0.91 >= the 0.90 emergency line, so a single post-GC reading recycles.
-        withDeclared.state.used = Math.round(declared * 0.91);
-        withDeclared.state.now = 30_000;
-        const armed = withDeclared.controller.observeMajorGc().recycle;
-        expect(armed).not.toBeNull();
-        expect(armed?.trigger).toBe("emergency");
-        expect(armed?.effectiveLimitBytes).toBe(declared);
-        expect(armed?.declaredCeilingBytes).toBe(declared);
-        expect(armed?.heapLimitBytes).toBe(reported); // reported kept for provenance
-        expect(armed?.usedFraction).toBeCloseTo(0.91, 2);
-    });
-    it("the SAME bytes never reach emergency when the reported limit is the denominator (no declared)", () => {
-        const declared = 2048 * MB;
-        const reported = 2233 * MB;
-        const noDeclared = governor({ declaredCeilingBytes: null, limitBytes: reported, minUptimeMs: 0 });
-        // 1863 MB is 0.834 of the reported limit — below the 0.90 emergency line, so
-        // the post-GC path only anchors the live floor (no immediate recycle).
-        noDeclared.state.used = Math.round(declared * 0.91);
-        noDeclared.state.now = 30_000;
-        expect(noDeclared.controller.observeMajorGc().recycle).toBeNull();
-    });
-    it("falls back to the reported limit (bit-identical shipped semantics) when no ceiling is declared", () => {
-        const g = governor({ declaredCeilingBytes: null });
-        expect(g.observeAt(0.62, PAST_FLOOR_MS)).toBeNull();
-        const recycle = g.observeAt(0.66, PAST_FLOOR_MS + 121_000);
-        expect(recycle?.trigger).toBe("live");
-        expect(recycle?.effectiveLimitBytes).toBe(recycle?.heapLimitBytes);
-        expect(recycle?.declaredCeilingBytes).toBe(0);
-    });
-});
-describe("RunnerHeapTelemetry — pinned tier (T2, instantaneous sustained)", () => {
-    it("arms on an instantaneous fraction held at/above the floor across the window, past the uptime floor", () => {
-        const g = governor({ pinnedFraction: 0.84, pinnedSustainWindowMs: 20_000, minUptimeMs: 0 });
-        expect(g.sampleAt(0.85, 0).recycle).toBeNull(); // anchor (count 1)
-        expect(g.sampleAt(0.85, 10_000).recycle).toBeNull(); // 10 s < 20 s window
-        const { recycle } = g.sampleAt(0.85, 21_000); // 21 s >= window, count >= 2
-        expect(recycle).not.toBeNull();
-        expect(recycle?.trigger).toBe("pinned");
-        expect(recycle?.reason).toBe("cooperative");
-        expect(recycle?.pinnedFraction).toBe(0.84);
-    });
-    it("resets its anchor on any single below-floor observation (a healthy sawtooth never sustains)", () => {
-        const g = governor({ pinnedFraction: 0.84, pinnedSustainWindowMs: 20_000, minUptimeMs: 0 });
-        expect(g.sampleAt(0.85, 0).recycle).toBeNull(); // anchor
-        expect(g.sampleAt(0.80, 5_000).recycle).toBeNull(); // dip -> anchor reset
-        expect(g.sampleAt(0.85, 25_000).recycle).toBeNull(); // re-anchor here (count 1)
-        const { recycle } = g.sampleAt(0.85, 46_000); // 21 s past the re-anchor
-        expect(recycle?.trigger).toBe("pinned");
-    });
-    it("honours the 35-minute uptime floor (unlike the emergency tier)", () => {
-        const g = governor({ pinnedFraction: 0.84, pinnedSustainWindowMs: 0, minUptimeMs: 100_000 });
-        expect(g.sampleAt(0.85, 0).recycle).toBeNull(); // anchor
-        expect(g.sampleAt(0.85, 50_000).recycle).toBeNull(); // window satisfied but 50 s < 100 s floor
-        const { recycle } = g.sampleAt(0.85, 120_000); // past the floor
-        expect(recycle?.trigger).toBe("pinned");
-    });
-    it("never fires off the post-GC live path, and the live path never fires 'pinned'", () => {
-        // Instantaneous readings drive pinned; post-GC readings drive live. They keep
-        // separate anchors, so neither impersonates the other.
-        const gPinned = governor({ pinnedFraction: 0.84, pinnedSustainWindowMs: 0, minUptimeMs: 0 });
-        gPinned.sampleAt(0.85, 0); // instantaneous only
-        expect(gPinned.sampleAt(0.85, 1_000).recycle?.trigger).toBe("pinned");
-        const gLive = governor({ minUptimeMs: 0 });
-        gLive.observeAt(0.65, 0);
-        expect(gLive.observeAt(0.65, 121_000)?.trigger).toBe("live");
-    });
-});
-describe("RunnerHeapTelemetry — hard-exit tiers (T4)", () => {
-    it("hard_fraction: a single instantaneous observation at/above the hard line hard-exits with no prior latch", () => {
-        const g = governor({ minUptimeMs: DEFAULT_HEAP_RECYCLE_MIN_UPTIME_MS });
-        // 0.96 >= 0.955, well BELOW the uptime floor: the hard tier bypasses the floor
-        // exactly like a SIGABRT would, and preempts the cooperative recycle.
-        const { recycle, hardExit } = g.evaluateFullAt(0.96, 10_000);
-        expect(recycle).toBeNull();
-        expect(hardExit).not.toBeNull();
-        expect(hardExit?.reason).toBe("hard_fraction");
-        expect(hardExit?.trigger).toBe("emergency"); // no prior latch -> instantaneous family
-        expect(hardExit?.hardExitFraction).toBe(DEFAULT_HEAP_HARD_EXIT_FRACTION);
-    });
-    it("latch_timeout: an unhonoured cooperative latch ages out by TIME into a hard exit", () => {
-        const g = governor({ minUptimeMs: 0, latchHardExitMs: 60_000, latchHardExitObservations: 1_000_000 });
-        const armed = g.evaluateFullAt(0.92, 0); // cooperative emergency latch
-        expect(armed.recycle?.reason).toBe("cooperative");
-        expect(armed.recycle?.trigger).toBe("emergency");
-        expect(g.evaluateFullAt(0.92, 30_000).hardExit).toBeNull(); // 30 s < 60 s deadline
-        const late = g.evaluateFullAt(0.92, 61_000); // 61 s >= deadline
-        expect(late.recycle).toBeNull();
-        expect(late.hardExit?.reason).toBe("latch_timeout");
-        expect(late.hardExit?.trigger).toBe("emergency"); // inherits the latched tier
-        expect(late.hardExit?.postLatchObservations).toBeGreaterThanOrEqual(1);
-    });
-    it("latch_timeout: ages out by observation COUNT before the time deadline", () => {
-        const g = governor({ minUptimeMs: 0, latchHardExitMs: 10 * 60_000, latchHardExitObservations: 3 });
-        g.evaluateFullAt(0.92, 0); // cooperative emergency latch
-        expect(g.evaluateFullAt(0.7, 1_000).hardExit).toBeNull(); // post-latch obs 1 < 3
-        expect(g.evaluateFullAt(0.7, 2_000).hardExit).toBeNull(); // post-latch obs 2 < 3
-        const third = g.evaluateFullAt(0.7, 3_000); // post-latch obs 3 >= 3
-        expect(third.hardExit?.reason).toBe("latch_timeout");
-    });
-    it("the latch-age arm fires from EVERY observation path (interval sample, loop-top, post-GC)", () => {
-        const g = governor({ minUptimeMs: 0, latchHardExitMs: 0, latchHardExitObservations: 1_000_000 });
-        // latchHardExitMs=0: the first post-latch observation from any path hard-exits.
-        g.observeFullAt(0.92, 0); // post-GC emergency cooperative latch
-        const viaSample = g.sampleAt(0.7, 1);
-        expect(viaSample.hardExit?.reason).toBe("latch_timeout");
-    });
-    it("fires at most one hard exit per session and never a cooperative verdict afterwards", () => {
-        const g = governor({ minUptimeMs: 0, latchHardExitMs: 0, latchHardExitObservations: 1_000_000 });
-        g.evaluateFullAt(0.92, 0); // cooperative latch
-        expect(g.evaluateFullAt(0.7, 1).hardExit?.reason).toBe("latch_timeout"); // first hard exit
-        expect(g.evaluateFullAt(0.99, 2).hardExit).toBeNull(); // already hard-signalled
-        expect(g.evaluateFullAt(0.99, 3).recycle).toBeNull();
-    });
-});
-describe("RunnerHeapTelemetry — tier ordering and derivation pin (guard-constant policy)", () => {
-    it("pins 0.60 < 0.84 < 0.90 < 0.955 and each against the observed abort band", () => {
-        expect(DEFAULT_HEAP_RECYCLE_LIVE_FRACTION).toBe(0.6);
-        expect(DEFAULT_HEAP_PINNED_FRACTION).toBe(0.84);
-        expect(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION).toBe(0.9);
-        expect(DEFAULT_HEAP_HARD_EXIT_FRACTION).toBe(0.955);
-        const order = [
-            DEFAULT_HEAP_RECYCLE_LIVE_FRACTION,
-            DEFAULT_HEAP_PINNED_FRACTION,
-            DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION,
-            DEFAULT_HEAP_HARD_EXIT_FRACTION,
-        ];
-        for (let i = 1; i < order.length; i += 1)
-            expect(order[i]).toBeGreaterThan(order[i - 1]);
-        // Pinned sits above the max healthy instantaneous evidence (~0.816 of declared)
-        // and below the legacy abort floor (1788/2048 = 0.873).
-        expect(DEFAULT_HEAP_PINNED_FRACTION).toBeGreaterThan(0.816);
-        expect(DEFAULT_HEAP_PINNED_FRACTION).toBeLessThan(1788 / 2048);
-        // Emergency and hard-exit both sit strictly below the minimum post-#471
-        // observed abort ratio (1995/2048 = 0.974), so both preempt the SIGABRT.
-        expect(DEFAULT_HEAP_RECYCLE_EMERGENCY_FRACTION).toBeLessThan(1995 / 2048);
-        expect(DEFAULT_HEAP_HARD_EXIT_FRACTION).toBeLessThan(1995 / 2048);
-    });
-});
-describe("RunnerHeapTelemetry — kill switch disables every tier (incl. hard)", () => {
-    it("disables live, pinned, emergency, hard_fraction, AND latch_timeout at once", () => {
-        const g = governor({ recycleEnabled: false, minUptimeMs: 0 });
-        let t = 0;
-        for (let i = 0; i < 20; i += 1) {
-            // 0.99 would fire hard_fraction; 0.85 sustained would fire pinned — none do.
-            const viaSample = g.sampleAt(0.99, t);
-            expect(viaSample.recycle).toBeNull();
-            expect(viaSample.hardExit).toBeNull();
-            const viaEval = g.evaluateFullAt(0.99, t + 1);
-            expect(viaEval.recycle).toBeNull();
-            expect(viaEval.hardExit).toBeNull();
-            const viaGc = g.observeFullAt(0.99, t + 2);
-            expect(viaGc.recycle).toBeNull();
-            expect(viaGc.hardExit).toBeNull();
-            t += 60_000;
-        }
-    });
-});
-// --- Resident-footprint tier (T5): the regression-reopen fix ------------------
-//
-// The four heap tiers denominate every fraction in min(declaredCeiling,
-// heap_size_limit) — the V8 old-space cap. A non-heap (external/ArrayBuffer)
-// burst outruns that cap while used_heap_size stays quiet, so NONE of them can
-// see a 5,598 MB resident process with a calm heap; the desktop's whole-tree
-// footprint backstop is left to pre-empt it, which IS this Sentry issue. The
-// footprint tier adds an absolute rss BUDGET the heap tiers never had.
-describe("RunnerHeapTelemetry — resident-footprint tier (T5)", () => {
-    // hq-desktop-app crates/hq-desktop-core: WATCHER_FOOTPRINT_HARD_CEILING_MB.
-    const DESKTOP_FOOTPRINT_HARD_CEILING_MB = 5120;
-    // Max npx launcher sibling across the 8 decomposed events (8-84 MB observed).
-    const LAUNCHER_HEADROOM_MB = 84;
-    // Highest healthy cold-ramp tree peak that must NOT recycle.
-    const HIGHEST_COLD_RAMP_MB = 3623;
-    // Drive ONE footprint reading (rss in bytes, quiet heap) through a chosen path
-    // on a fresh session, so the one-verdict-per-session latch never carries over.
-    function footprintVerdict(rssBytes, path) {
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(rssBytes, 30_000);
-        if (path === "sample") {
-            const r = g.controller.sample();
-            return { recycle: r.recycle, hardExit: r.hardExit };
-        }
-        if (path === "evaluate")
-            return g.controller.evaluate();
-        return g.controller.observeMajorGc();
-    }
-    it("pins the budgets from the production traces and hq-desktop-app's published constants", () => {
-        expect(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES).toBe(4096 * MB);
-        expect(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES).toBe(4864 * MB);
-        // Both budgets recycle the runner's OWN rss STRICTLY below the desktop's
-        // whole-tree pre-empt line (5120 MB) minus the launcher-sibling headroom.
-        const preemptLineBytes = (DESKTOP_FOOTPRINT_HARD_CEILING_MB - LAUNCHER_HEADROOM_MB) * MB;
-        expect(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES).toBeLessThan(preemptLineBytes);
-        expect(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES).toBeLessThan(preemptLineBytes);
-        // Cooperative < hard: a moderate climb recycles cooperatively; only an
-        // abort-adjacent reading hard-exits.
-        expect(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES).toBeLessThan(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-        // The cooperative floor sits above the highest healthy cold ramp, so a large
-        // sync never trades this issue for respawn churn (the r1 failure mode).
-        expect(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES).toBeGreaterThan(HIGHEST_COLD_RAMP_MB * MB);
-    });
-    it("replays the evented production traces: runaways recycle/hard-exit, cold ramps never do", () => {
-        // The four cold ramps (healthy large syncs) must NEVER produce a verdict, on
-        // ANY path. On BASE the tier does not exist and these produce no verdict
-        // either — but neither do the runaways below, which is the base defect.
-        for (const treeMb of [2776, 3080, 3337, 3623]) {
-            for (const path of ["sample", "evaluate", "gc"]) {
-                const v = footprintVerdict(treeMb * MB, path);
-                expect(v.recycle, `cold ramp ${treeMb} via ${path}`).toBeNull();
-                expect(v.hardExit, `cold ramp ${treeMb} via ${path}`).toBeNull();
-            }
-        }
-        // 4493 MB (below the hard floor): a COOPERATIVE footprint recycle.
-        for (const path of ["sample", "evaluate", "gc"]) {
-            const v = footprintVerdict(4493 * MB, path);
-            expect(v.recycle?.trigger, `4493 via ${path}`).toBe("footprint");
-            expect(v.recycle?.reason).toBe("cooperative");
-            expect(v.recycle?.observedSustainMs).toBe(0); // single observation, no window
-            expect(v.hardExit).toBeNull();
-        }
-        // 5598 and 7949 MB (at/above the hard floor, already past the desktop line on
-        // the runner's own rss): a footprint HARD EXIT, no waiting for a pass boundary.
-        for (const rssMb of [5598, 7949]) {
-            for (const path of ["sample", "evaluate", "gc"]) {
-                const v = footprintVerdict(rssMb * MB, path);
-                expect(v.hardExit?.trigger, `${rssMb} via ${path}`).toBe("footprint");
-                expect(v.hardExit?.reason).toBe("hard_fraction");
-                expect(v.recycle).toBeNull();
-            }
-        }
-    });
-    it("arms on a SINGLE observation with no sustain window and below the uptime floor", () => {
-        // Default 35-minute uptime floor; a burst at 5 s uptime still recycles, so an
-        // 83-1142 MB/s climb can never outrun the tier the way a sustain window would.
-        const g = governor(); // default minUptimeMs = 35 min
-        g.setFootprint(4200 * MB, 5_000);
-        const { recycle } = g.controller.evaluate();
-        expect(recycle?.trigger).toBe("footprint");
-        expect(recycle?.reason).toBe("cooperative");
-        expect(recycle?.observedSustainMs).toBe(0);
-        expect(recycle?.uptimeMs).toBe(5_000);
-    });
-    it("carries rss/external/arrayBuffers, their growth deltas, and census attribution", () => {
-        let entries = 100;
-        const census = new HeapCensus();
-        census.register("watcherJournalStores", () => entries);
-        const g = governor({ census, minUptimeMs: 0 });
-        g.controller.primeBaseline(); // baseline at entries=100, rss=0
-        entries = 900;
-        g.state.external = 40 * MB;
-        g.state.arrayBuffers = 2000 * MB; // the non-heap growth that the heap cap misses
-        g.setFootprint(4600 * MB, 30_000);
-        const { recycle } = g.controller.evaluate();
-        expect(recycle?.trigger).toBe("footprint");
-        expect(recycle?.rssBytes).toBe(4600 * MB);
-        expect(recycle?.rssGrowthBytes).toBe(4600 * MB);
-        expect(recycle?.arrayBuffersGrowthBytes).toBe(2000 * MB);
-        expect(recycle?.externalGrowthBytes).toBe(40 * MB);
-        expect(recycle?.topSites[0]).toMatchObject({ site: "watcherJournalStores", growth: 800 });
-    });
-    it("adds a verdict only where the heap tiers are silent — a heap verdict always wins", () => {
-        // Quiet heap + high rss -> footprint fires (heap silent).
-        expect(footprintVerdict(4200 * MB, "evaluate").recycle?.trigger).toBe("footprint");
-        // A heap emergency with rss ALSO over the footprint budget keeps trigger
-        // "emergency": the heap tiers are evaluated first and their verdict is returned
-        // unchanged, so the footprint tier never suppresses or re-denominates it.
-        const g = governor({ minUptimeMs: 0 });
-        g.state.rss = 9000 * MB;
-        g.state.used = Math.round(g.state.limit * 0.95); // heap emergency line
-        g.state.now = 30_000;
-        expect(g.controller.evaluate().recycle?.trigger).toBe("emergency");
-        // A heap HARD-fraction with rss over the footprint budget stays a heap hard
-        // exit (trigger from the instantaneous family, not "footprint").
-        const gh = governor({ minUptimeMs: 0 });
-        gh.state.rss = 9000 * MB;
-        gh.state.used = Math.round(gh.state.limit * 0.96); // hard-exit fraction
-        gh.state.now = 30_000;
-        const hv = gh.controller.evaluate();
-        expect(hv.hardExit?.reason).toBe("hard_fraction");
-        expect(hv.hardExit?.trigger).toBe("emergency"); // NOT footprint
-    });
-    it("fires from evaluate() (loop-top) when the interval timer never ticks and no GC is observed", () => {
-        // The starved-sampler backstop: the module's own 11-minute-hole safety net now
-        // covers footprint too. Only evaluate() is ever called here.
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(4200 * MB, 30_000);
-        expect(g.controller.evaluate().recycle?.trigger).toBe("footprint");
-    });
-    it("hard-exits on a single reading at/above the footprint hard budget", () => {
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES, 30_000); // exactly the floor
-        const { recycle, hardExit } = g.controller.evaluate();
-        expect(recycle).toBeNull();
-        expect(hardExit?.trigger).toBe("footprint");
-        expect(hardExit?.reason).toBe("hard_fraction");
-        expect(hardExit?.rssBytes).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-    });
-    it("ages an unhonoured footprint cooperative latch into a footprint latch_timeout hard exit", () => {
-        const g = governor({ minUptimeMs: 0, latchHardExitMs: 0, latchHardExitObservations: 1_000_000 });
-        g.setFootprint(4200 * MB, 0); // cooperative footprint latch (below the hard floor)
-        expect(g.controller.evaluate().recycle?.trigger).toBe("footprint");
-        // latchHardExitMs=0: the next observation ages the latch out. The hard exit
-        // inherits the footprint trigger from the latched tier.
-        g.setFootprint(4200 * MB, 1);
-        const late = g.controller.evaluate();
-        expect(late.recycle).toBeNull();
-        expect(late.hardExit?.reason).toBe("latch_timeout");
-        expect(late.hardExit?.trigger).toBe("footprint");
-    });
-    it("recycles at most once per session across every path, then never again", () => {
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(4200 * MB, 0);
-        expect(g.controller.evaluate().recycle?.trigger).toBe("footprint"); // the one recycle
-        g.setFootprint(4600 * MB, 60_000);
-        expect(g.controller.sample().recycle).toBeNull();
-        g.setFootprint(4600 * MB, 120_000);
-        expect(g.controller.observeMajorGc().recycle).toBeNull();
-    });
-    it("the footprint-specific disable silences ONLY the footprint tier; heap tiers still fire", () => {
-        const g = governor({ footprintRecycleEnabled: false, minUptimeMs: 0 });
-        g.setFootprint(9000 * MB, 30_000); // way over both budgets, quiet heap
-        const off = g.controller.evaluate();
-        expect(off.recycle).toBeNull();
-        expect(off.hardExit).toBeNull();
-        // A heap emergency on the same governor still fires — base behaviour intact.
-        g.state.used = Math.round(g.state.limit * 0.95);
-        g.state.now = 60_000;
-        expect(g.controller.evaluate().recycle?.trigger).toBe("emergency");
-    });
-    it("the global kill switch also disables the footprint tier", () => {
-        const g = governor({ recycleEnabled: false, minUptimeMs: 0 });
-        g.setFootprint(9000 * MB, 30_000);
-        const v = g.controller.evaluate();
-        expect(v.recycle).toBeNull();
-        expect(v.hardExit).toBeNull();
-    });
-    it("a disabled footprint tier reports 0 for both budget floors in the verdict record", () => {
-        // A reader must be able to tell an OFF tier (0) from a live one (the budget).
-        const g = governor({ footprintRecycleEnabled: false, minUptimeMs: 0 });
-        const emg = g.sampleAt(0.95, PAST_FLOOR_MS).recycle; // heap emergency still fires
-        expect(emg?.footprintRecycleBytes).toBe(0);
-        expect(emg?.footprintHardExitBytes).toBe(0);
-        // With the tier ON, a heap verdict still carries the configured budgets.
-        const g2 = governor({ minUptimeMs: 0 });
-        const emg2 = g2.sampleAt(0.95, PAST_FLOOR_MS).recycle;
-        expect(emg2?.footprintRecycleBytes).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(emg2?.footprintHardExitBytes).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-    });
-    it("honours a custom footprint budget and never fires just below it", () => {
-        const g = governor({ footprintRecycleBytes: 3000 * MB, footprintHardExitBytes: 4000 * MB, minUptimeMs: 0 });
-        g.setFootprint(2999 * MB, 10_000);
-        expect(g.controller.evaluate().recycle).toBeNull(); // 1 MB under the floor
-        g.setFootprint(3000 * MB, 20_000);
-        expect(g.controller.evaluate().recycle?.trigger).toBe("footprint"); // exactly the floor
-    });
-    it("a disabled footprint tier adds NO rss read, so a throwing memoryUsage never breaks a quiet-heap observation", () => {
-        // Regression: the kill switch must restore the exact prior observation path.
-        // With the tier off and a quiet heap (no verdict), evaluate()/observeMajorGc()
-        // must not touch memoryUsage() at all — so a throwing reader cannot swallow the
-        // observation before the heap tiers run.
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        let memReads = 0;
-        const readers = {
-            getHeapStatistics: () => ({
-                used_heap_size: Math.round(2048 * MB * 0.3), // quiet heap: no heap verdict
-                total_heap_size: 0,
-                heap_size_limit: 2048 * MB,
-                external_memory: 0,
-            }),
-            memoryUsage: () => {
-                memReads += 1;
-                throw new Error("memoryUsage boom");
-            },
-            monotonicNowMs: () => 30_000,
-        };
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            recycleMinUptimeMs: 0,
-            footprintRecycleEnabled: false,
-        });
-        expect(() => controller.evaluate()).not.toThrow();
-        expect(() => controller.observeMajorGc()).not.toThrow();
-        expect(controller.evaluate().recycle).toBeNull();
-        expect(controller.observeMajorGc().recycle).toBeNull();
-        expect(memReads).toBe(0); // the disabled tier read rss zero times
-    });
-    it("records the rss value that CROSSED the budget, not a later drifted re-read", () => {
-        // The decision reads rss once; the verdict sample re-reads memoryUsage a hair
-        // later. A reader whose rss drops between the two reads must not make the
-        // durable record claim an rss below the floor that triggered the hard exit.
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const rssSequence = [5000 * MB, 100 * MB]; // decision sees 5000 (>= hard floor); re-read drifts to 100
-        let i = 0;
-        const readers = {
-            getHeapStatistics: () => ({
-                used_heap_size: Math.round(2048 * MB * 0.3), // quiet heap
-                total_heap_size: 0,
-                heap_size_limit: 2048 * MB,
-                external_memory: 0,
-            }),
-            memoryUsage: () => ({
-                rss: rssSequence[Math.min(i++, rssSequence.length - 1)],
-                heapTotal: 0,
-                heapUsed: 0,
-                external: 0,
-                arrayBuffers: 0,
-            }),
-            monotonicNowMs: () => 30_000,
-        };
-        const controller = new RunnerHeapTelemetry({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.75,
-            recycleMinUptimeMs: 0,
-        });
-        const { hardExit } = controller.evaluate();
-        expect(hardExit?.trigger).toBe("footprint");
-        expect(hardExit?.reason).toBe("hard_fraction");
-        // Stamped with the checked 5000 MB, never the drifted 100 MB re-read.
-        expect(hardExit?.rssBytes).toBe(5000 * MB);
-        expect(hardExit?.rssBytes).toBeGreaterThanOrEqual(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-    });
-    it("the footprint recycle stderr line matches NONE of hq-desktop-app's fatal markers", () => {
-        const DESKTOP_FATAL_MARKERS = [
-            "javascript heap out of memory",
-            "ineffective mark-compacts",
-            "fatal error",
-            "uncaught exception",
-            "unhandledrejection",
-            "panicked at",
-            "assertion failed",
-            "npm error ",
-            "npm err! ",
-            "enospc",
-            "permission denied",
-            "no such file or directory",
-            "command not found",
-        ];
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(4200 * MB, 30_000);
-        const line = heapRecycleStderrLine(g.controller.evaluate().recycle);
-        const lowered = line.toLowerCase();
-        for (const marker of DESKTOP_FATAL_MARKERS)
-            expect(lowered).not.toContain(marker);
-        expect(line.trimStart().startsWith("#")).toBe(false);
-        expect(line).toContain("trigger=footprint");
-    });
-});
-describe("startRunnerHeapSampling — footprint tier", () => {
-    it("drives a footprint cooperative recycle through the interval tick and swallows a throwing onRecycle", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(state.limit * 0.3); // quiet heap
-        state.rss = 4300 * MB; // over the 4096 MB recycle floor, under the hard floor
-        const fake = fakeScheduler();
-        const recycles = [];
-        startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => {
-                recycles.push(record);
-                throw new Error("recycle emit boom"); // must be swallowed
-            },
-            log: () => { },
-        });
-        state.now = 30_000;
-        expect(() => fake.tick()).not.toThrow();
-        expect(recycles).toHaveLength(1);
-        expect(recycles[0].trigger).toBe("footprint");
-    });
-    it("delivers a footprint hard exit to onHardExit (never onRecycle)", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(state.limit * 0.3); // quiet heap
-        state.rss = 5000 * MB; // over the 4864 MB hard floor
-        const fake = fakeScheduler();
-        const recycles = [];
-        const hardExits = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            checkpointMs: 10,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => recycles.push(record),
-            onHardExit: (record) => hardExits.push(record),
-            log: () => { },
-        });
-        state.now = 0;
-        handle.maybeObserve();
-        expect(hardExits).toHaveLength(1);
-        expect(hardExits[0].trigger).toBe("footprint");
-        expect(hardExits[0].reason).toBe("hard_fraction");
-        expect(recycles).toHaveLength(0);
-        handle.stop();
-    });
-    it("the loop-top evaluate() fires the footprint tier when the interval timer never ticks", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(state.limit * 0.3);
-        state.rss = 4300 * MB;
-        const fake = fakeScheduler();
-        const recycles = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => recycles.push(record),
-            log: () => { },
-        });
-        state.now = 30_000;
-        handle.evaluate(); // timer never ticked
-        expect(recycles).toHaveLength(1);
-        expect(recycles[0].trigger).toBe("footprint");
-        handle.stop();
-    });
-    it("a throwing memoryUsage reader degrades to silence on every path (never throws into a watch pass)", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const readers = {
-            getHeapStatistics: () => ({
-                used_heap_size: 10,
-                total_heap_size: 20,
-                heap_size_limit: 2048 * MB,
-                external_memory: 0,
-            }),
-            memoryUsage: () => {
-                throw new Error("memoryUsage boom");
-            },
-            monotonicNowMs: () => 30_000,
-        };
-        const fake = fakeScheduler();
-        const gc = fakeGcObserver();
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            scheduler: fake.scheduler,
-            gcObserver: gc.observer,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: () => { },
-            onHardExit: () => { },
-            log: () => { },
-        });
-        expect(() => fake.tick()).not.toThrow();
-        expect(() => handle.evaluate()).not.toThrow();
-        expect(() => gc.fire()).not.toThrow();
-        handle.stop();
-    });
-    it("a footprint value in the record survives the LOCAL telemetry sanitizer as numbers only", async () => {
-        const g = governor({ minUptimeMs: 0 });
-        g.setFootprint(4300 * MB, 30_000);
-        const record = g.controller.evaluate().recycle;
-        const props = heapRecycleCloudProperties(record);
-        for (const value of Object.values(props))
-            expect(typeof value).toBe("number");
-        const captured = [];
-        const client = {
-            postTelemetryEvents: async (batch) => {
-                for (const event of batch.events)
-                    captured.push(event);
-                return { accepted: batch.events.length };
-            },
-        };
-        await emitCloudTelemetry(client, {
-            eventName: "sync_runner_heap_recycle",
-            source: "sync-runner-heap",
-            properties: props,
-        });
-        const survived = captured[0]?.properties ?? {};
-        expect(survived.recycle_footprint_trigger_count).toBe(1);
-        expect(Object.keys(survived).length).toBe(Object.keys(props).length);
-    });
-});
-describe("resolve* parsers for the footprint knobs", () => {
-    it("resolveHeapFootprintRecycleEnabled: ON by default, disabled only by an explicit off value", () => {
-        expect(resolveHeapFootprintRecycleEnabled(undefined)).toBe(true);
-        expect(resolveHeapFootprintRecycleEnabled("")).toBe(true);
-        expect(resolveHeapFootprintRecycleEnabled("1")).toBe(true);
-        expect(resolveHeapFootprintRecycleEnabled("0")).toBe(false);
-        expect(resolveHeapFootprintRecycleEnabled("false")).toBe(false);
-        expect(resolveHeapFootprintRecycleEnabled(" OFF ")).toBe(false);
-        // A typo keeps the tier armed rather than silently disabling protection.
-        expect(resolveHeapFootprintRecycleEnabled("disabled")).toBe(true);
-    });
-    it("resolveHeapFootprintRecycleBytes: whole MB -> bytes, 4096 MB default, rejects a numeric prefix", () => {
-        expect(resolveHeapFootprintRecycleBytes("4096")).toBe(4096 * MB);
-        expect(resolveHeapFootprintRecycleBytes("1000")).toBe(1000 * MB);
-        expect(resolveHeapFootprintRecycleBytes(undefined)).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(resolveHeapFootprintRecycleBytes("")).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(resolveHeapFootprintRecycleBytes("0")).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        // A malformed value can NEVER silently lower the budget or disable the tier.
-        expect(resolveHeapFootprintRecycleBytes("4096x")).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(resolveHeapFootprintRecycleBytes("4gb")).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-    });
-    it("resolveHeapFootprintHardExitBytes: whole MB -> bytes, 4864 MB default, rejects garbage", () => {
-        expect(resolveHeapFootprintHardExitBytes("4864")).toBe(4864 * MB);
-        expect(resolveHeapFootprintHardExitBytes(undefined)).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-        expect(resolveHeapFootprintHardExitBytes("0")).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-        expect(resolveHeapFootprintHardExitBytes("4864x")).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-    });
-});
-describe("startRunnerHeapSampling — work-driven checkpoint gate", () => {
-    function pinnedHandle(overrides) {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(state.limit * 0.85); // pinned range
-        const fake = fakeScheduler();
-        const recs = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recyclePinnedFraction: 0.84,
-            recyclePinnedSustainWindowMs: 0, // any two gated observations suffice
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            checkpointMs: overrides.checkpointMs,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record, counters) => recs.push({ record, counters }),
-            log: () => { },
-        });
-        return { state, handle, recs };
-    }
-    it("observes only when the gate is open (>= checkpointMs since the last observation)", () => {
-        const { state, handle, recs } = pinnedHandle({ checkpointMs: 100 });
-        state.now = 0;
-        handle.maybeObserve(); // first checkpoint: no prior observation -> observes (pinned count 1)
-        state.now = 50;
-        handle.maybeObserve(); // 50 < 100 -> below the gate, no observation
-        state.now = 150;
-        handle.maybeObserve(); // 150 >= 100 -> observes (pinned count 2 -> recycle)
-        expect(recs).toHaveLength(1);
-        expect(recs[0].record.trigger).toBe("pinned");
-        // Exactly two checkpoint observations (the 50 ms one was gated out); the 60 s
-        // interval timer never ticked, proving the feed was work-driven, not the timer.
-        expect(recs[0].counters.heapCheckpointObservationsCount).toBe(2);
-        expect(recs[0].counters.heapIntervalObservationsCount).toBe(0);
-        expect(recs[0].counters.msSincePreviousObservationMs).toBe(150);
-    });
-    it("checkpointMs=0 disables the work-driven checkpoint but keeps the loop-top evaluate()", () => {
-        const { state, handle, recs } = pinnedHandle({ checkpointMs: 0 });
-        state.now = 0;
-        handle.maybeObserve();
-        state.now = 100_000;
-        handle.maybeObserve(); // both disabled -> never observes
-        expect(recs).toHaveLength(0);
-        // The loop-top evaluate() is ungated and still works with checkpoints off.
-        state.used = Math.round(2048 * MB * 0.96); // hard-fraction range
-        // ... but this handle has no onHardExit, so route through a recycle instead:
-        state.used = Math.round(2048 * MB * 0.92); // emergency cooperative
-        state.now = 200_000;
-        handle.evaluate();
-        expect(recs).toHaveLength(1);
-        expect(recs[0].record.trigger).toBe("emergency");
-    });
-    it("delivers a hard exit to onHardExit (never onRecycle) and preempts the cooperative verdict", () => {
-        const census = new HeapCensus();
-        census.register("x", () => 1);
-        const { state, readers } = mutableReaders();
-        state.limit = 2048 * MB;
-        state.used = Math.round(state.limit * 0.96); // hard-fraction range
-        const fake = fakeScheduler();
-        const recycles = [];
-        const hardExits = [];
-        const handle = startRunnerHeapSampling({
-            readers,
-            census,
-            sessionStartedAtMs: 0,
-            pressureThresholdFraction: 0.99,
-            recycleMinUptimeMs: 0,
-            intervalMs: 60_000,
-            checkpointMs: 10,
-            scheduler: fake.scheduler,
-            onSample: () => { },
-            onPressure: () => { },
-            onRecycle: (record) => recycles.push(record),
-            onHardExit: (record) => hardExits.push(record),
-            log: () => { },
-        });
-        state.now = 0;
-        handle.maybeObserve();
-        expect(hardExits).toHaveLength(1);
-        expect(hardExits[0].reason).toBe("hard_fraction");
-        expect(recycles).toHaveLength(0);
-        handle.stop();
-    });
-});
-describe("performHeapHardExit", () => {
-    function hardFractionRecord() {
-        const record = governor({ minUptimeMs: 0 }).sampleAt(0.96, 10_000).hardExit;
-        expect(record).not.toBeNull();
-        return record;
-    }
-    it("writes the NDJSON record to stdout, then the marker to stderr, then exits — in that order", () => {
-        const calls = [];
-        performHeapHardExit(hardFractionRecord(), {
-            writeStdout: (line) => calls.push(`out:${line}`),
-            writeStderr: (line) => calls.push(`err:${line}`),
-            exit: (code) => calls.push(`exit:${code}`),
-        }, 1);
-        expect(calls).toHaveLength(3);
-        expect(calls[0]).toContain("out:");
-        expect(calls[0]).toContain('"type":"heap-recycle"');
-        expect(calls[0]).toContain('"reason":"hard_fraction"');
-        expect(calls[1]).toContain("err:");
-        expect(calls[1]).toContain("hq-sync-runner: heap-recycle");
-        expect(calls[2]).toBe("exit:1");
-    });
-    it("still exits even if BOTH stream writes throw (a closed/blocked pipe)", () => {
-        let exited = -1;
-        performHeapHardExit(hardFractionRecord(), {
-            writeStdout: () => {
-                throw new Error("EPIPE");
-            },
-            writeStderr: () => {
-                throw new Error("EPIPE");
-            },
-            exit: (code) => {
-                exited = code;
-            },
-        }, 1);
-        expect(exited).toBe(1);
-    });
-    it("the hard-exit stderr marker matches NONE of hq-desktop-app's fatal classifiers (both hard reasons)", () => {
-        const DESKTOP_FATAL_MARKERS = [
-            "javascript heap out of memory",
-            "ineffective mark-compacts",
-            "fatal error",
-            "uncaught exception",
-            "unhandledrejection",
-            "panicked at",
-            "assertion failed",
-            "npm error ",
-            "npm err! ",
-            "enospc",
-            "permission denied",
-            "no such file or directory",
-            "command not found",
-        ];
-        const hardFraction = hardFractionRecord();
-        const latch = (() => {
-            const g = governor({ minUptimeMs: 0, latchHardExitMs: 0, latchHardExitObservations: 1_000_000 });
-            g.evaluateFullAt(0.92, 0);
-            return g.evaluateFullAt(0.7, 1).hardExit;
-        })();
-        for (const record of [hardFraction, latch]) {
-            const line = heapRecycleStderrLine(record).toLowerCase();
-            for (const marker of DESKTOP_FATAL_MARKERS) {
-                expect(line, `reason ${record.reason} must not contain "${marker}"`).not.toContain(marker);
-            }
-            expect(line.trimStart().startsWith("#")).toBe(false);
-            expect(line).toContain("hq-sync-runner: heap-recycle");
-        }
-        expect(heapRecycleStderrLine(hardFraction)).toContain("reason=hard_fraction");
-        expect(heapRecycleStderrLine(latch)).toContain("reason=latch_timeout");
-    });
-});
-describe("resolveDeclaredHeapCeilingBytes", () => {
-    const MBb = 1024 * 1024;
-    it("parses --max-old-space-size from execArgv in both forms, last occurrence wins", () => {
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size=2048"], undefined)).toBe(2048 * MBb);
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size", "2048"], undefined)).toBe(2048 * MBb);
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size=1024", "--max-old-space-size=2048"], undefined)).toBe(2048 * MBb);
-        expect(resolveDeclaredHeapCeilingBytes(["--max_old_space_size=2048"], undefined)).toBe(2048 * MBb);
-    });
-    it("falls back to NODE_OPTIONS only when execArgv has none, honours one pair of quotes, execArgv wins", () => {
-        expect(resolveDeclaredHeapCeilingBytes([], "--max-old-space-size=2048")).toBe(2048 * MBb);
-        expect(resolveDeclaredHeapCeilingBytes([], '--max-old-space-size="2048"')).toBe(2048 * MBb);
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size=4096"], "--max-old-space-size=2048")).toBe(4096 * MBb);
-    });
-    it("returns null on absent/garbage/zero so the governor falls back to the reported limit", () => {
-        expect(resolveDeclaredHeapCeilingBytes([], undefined)).toBeNull();
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size=abc"], undefined)).toBeNull();
-        expect(resolveDeclaredHeapCeilingBytes(["--max-old-space-size=0"], undefined)).toBeNull();
-        expect(resolveDeclaredHeapCeilingBytes(["--other=5"], "   ")).toBeNull();
-    });
-});
-describe("resolve* parsers for the new governor knobs", () => {
-    it("resolveHeapCheckpointMs: 250 default, 0 valid (disables), rejects '250x'", () => {
-        expect(resolveHeapCheckpointMs("250")).toBe(250);
-        expect(resolveHeapCheckpointMs("0")).toBe(0);
-        expect(resolveHeapCheckpointMs(undefined)).toBe(DEFAULT_HEAP_CHECKPOINT_MS);
-        expect(resolveHeapCheckpointMs("250x")).toBe(DEFAULT_HEAP_CHECKPOINT_MS);
-        expect(resolveHeapCheckpointMs("-1")).toBe(DEFAULT_HEAP_CHECKPOINT_MS);
-    });
-    it("resolveHeapPinnedFraction: 0.84 default, out-of-range/garbage falls back", () => {
-        expect(resolveHeapPinnedFraction("0.84")).toBe(0.84);
-        expect(resolveHeapPinnedFraction("1")).toBe(1);
-        expect(resolveHeapPinnedFraction(undefined)).toBe(DEFAULT_HEAP_PINNED_FRACTION);
-        expect(resolveHeapPinnedFraction("2")).toBe(DEFAULT_HEAP_PINNED_FRACTION);
-        expect(resolveHeapPinnedFraction("0.84x")).toBe(DEFAULT_HEAP_PINNED_FRACTION);
-    });
-    it("resolveHeapPinnedSustainMs: 20000 default, 0 valid, rejects '20s'", () => {
-        expect(resolveHeapPinnedSustainMs("20000")).toBe(20_000);
-        expect(resolveHeapPinnedSustainMs("0")).toBe(0);
-        expect(resolveHeapPinnedSustainMs(undefined)).toBe(DEFAULT_HEAP_PINNED_SUSTAIN_MS);
-        expect(resolveHeapPinnedSustainMs("20s")).toBe(DEFAULT_HEAP_PINNED_SUSTAIN_MS);
-    });
-    it("resolveHeapHardExitFraction: 0.955 default, out-of-range/garbage falls back", () => {
-        expect(resolveHeapHardExitFraction("0.955")).toBe(0.955);
-        expect(resolveHeapHardExitFraction(undefined)).toBe(DEFAULT_HEAP_HARD_EXIT_FRACTION);
-        expect(resolveHeapHardExitFraction("2")).toBe(DEFAULT_HEAP_HARD_EXIT_FRACTION);
-        expect(resolveHeapHardExitFraction("0.955x")).toBe(DEFAULT_HEAP_HARD_EXIT_FRACTION);
-    });
-    it("resolveHeapRecycleLatchHardExitMs: 60000 default, 0 valid, rejects '60s'", () => {
-        expect(resolveHeapRecycleLatchHardExitMs("60000")).toBe(60_000);
-        expect(resolveHeapRecycleLatchHardExitMs("0")).toBe(0);
-        expect(resolveHeapRecycleLatchHardExitMs(undefined)).toBe(DEFAULT_HEAP_RECYCLE_LATCH_HARD_EXIT_MS);
-        expect(resolveHeapRecycleLatchHardExitMs("60s")).toBe(DEFAULT_HEAP_RECYCLE_LATCH_HARD_EXIT_MS);
-    });
-});
-//# sourceMappingURL=sync-runner-heap-telemetry.test.js.map