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

package/dist/bin/sync-runner-watch-loop.test.js

@@ -1,734 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { createHash } from "node:crypto";
-import { buildHeapCensus, coordinatorPathOutcome, publishedContentHashFromJournalEntry, realtimeTelemetryReason, stripTransientWatchScopeArgs, RUNNER_HEAP_RECYCLE_EXIT, takeEnumeratedBatchChunk, } from "./sync-runner-watch-loop.js";
-import { TRANSIENT_NETWORK_EXIT } from "../lib/net-errors.js";
-import { parseArgs } from "./sync-runner.js";
-import { PARTIAL_SYNC_EXIT, UNRESOLVED_COMPANY_EXIT, } from "../lib/exit-codes.js";
-import { AUTH_REQUIRED_PASS_EXIT, runRunnerWithLoop, } from "./sync-runner.js";
-import { reindexAfterSync } from "../qmd-reindex.js";
-import { HEAP_FOOTPRINT_RECYCLE_ENABLED_ENV, HEAP_FOOTPRINT_RECYCLE_MB_ENV, HEAP_FOOTPRINT_HARD_EXIT_MB_ENV, resolveHeapFootprintRecycleEnabled, resolveHeapFootprintRecycleBytes, resolveHeapFootprintHardExitBytes, DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES, DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES, } from "./sync-runner-heap-telemetry.js";
-import { PushEventEmitter } from "../watcher.js";
-import { updateEntry } from "../journal.js";
-function snapshotOf(census) {
-    return Object.fromEntries(census.snapshot().map((site) => [site.site, site.count]));
-}
-describe("stripTransientWatchScopeArgs", () => {
-    it("removes all transient scopes before a scheduled reconcile", () => {
-        expect(stripTransientWatchScopeArgs([
-            "--companies",
-            "--watch",
-            "--exit-with-parent",
-            "--poll-remote-ms",
-            "60000",
-            "--event-push",
-            "--owner",
-            "hq-daemon",
-            "--scope-path",
-            "docs/legacy.md",
-            "--scope-upsert-path",
-            "docs/new.md",
-            "--delete-scope-path",
-            "docs/removed.md",
-            "--direction",
-            "pull",
-        ])).toEqual(["--companies", "--direction", "pull"]);
-    });
-    // Regression (2026-10-02, Mac app-hosted runner 6.18.32): a launcher that
-    // passes --watch-parent-pid got "--watch-parent-pid requires --watch" from
-    // every scheduled full reconcile, because the chore argv kept the flag.
-    it("removes --watch-parent-pid and its value", () => {
-        expect(stripTransientWatchScopeArgs([
-            "--companies",
-            "--watch",
-            "--exit-with-parent",
-            "--watch-parent-pid",
-            "4242",
-            "--direction",
-            "both",
-        ])).toEqual(["--companies", "--direction", "both"]);
-    });
-    it("produces a reconcile argv the runner parser accepts for a desktop launcher argv", () => {
-        const launcherArgv = [
-            "--companies",
-            "--direction",
-            "both",
-            "--on-conflict",
-            "keep",
-            "--hq-root",
-            "/tmp/hq-root",
-            "--watch",
-            "--lock-timeout",
-            "600",
-            "--event-push",
-            "--owner",
-            "hq-desktop",
-            "--exit-with-parent",
-            "--watch-parent-pid",
-            "4242",
-        ];
-        expect(parseArgs(launcherArgv)).not.toHaveProperty("error");
-        expect(parseArgs(stripTransientWatchScopeArgs(launcherArgv))).not.toHaveProperty("error");
-    });
-    it("strips every flag the parser declares watch-only", () => {
-        const source = fs.readFileSync(path.join(path.dirname(new URL(import.meta.url).pathname), "sync-runner.ts"), "utf8");
-        const watchOnly = [...source.matchAll(/"(--[a-z-]+) requires --watch"/g)].map((m) => m[1]);
-        expect(watchOnly).toContain("--watch-parent-pid");
-        for (const flag of watchOnly) {
-            const stripped = stripTransientWatchScopeArgs(["--companies", "--watch", flag, "4242", "--direction", "pull"]);
-            expect(stripped, flag).not.toContain(flag);
-        }
-    });
-});
-describe("buildHeapCensus", () => {
-    // The emitter/watcher SIZE lookups still key off the producers' own field
-    // names (`...ContentHashes`, etc.), but the census emits a DECOUPLED deny-safe
-    // TOKEN (`...Digests`), so the flattened property survives hq-pro ingest — the
-    // pre-fix `content`-bearing keys were silently dropped, losing the attribution.
-    it("registers watch-loop, emitter, and watcher sites under fixed deny-safe tokens", () => {
-        const census = buildHeapCensus({
-            ownMaps: {
-                pendingAppliedUpserts: () => 3,
-                pendingWatcherEntries: () => 4,
-                pendingSlowPasses: () => 2,
-            },
-            eventSyncSizes: () => ({
-                lastPublishedContentHashes: 10,
-                publishedContentHashGenerations: 20,
-                deferredPublishes: 1,
-                durablePublishedHashRetries: 2,
-                initialPublishedContentHashes: 0,
-            }),
-            watcherSizes: () => ({ knownKinds: 100, deleteSnapshotEpochs: 5, ignoreFilterMemo: 50 }),
-        });
-        const snap = snapshotOf(census);
-        expect(snap.pendingAppliedUpserts).toBe(3);
-        expect(snap.pendingWatcherEntries).toBe(4);
-        expect(snap.pendingSlowPasses).toBe(2);
-        // Emitter fields land under their decoupled deny-safe tokens.
-        expect(snap.lastPublishedDigests).toBe(10);
-        expect(snap.publishedDigestGenerations).toBe(20);
-        expect(snap.deferredPublishes).toBe(1);
-        expect(snap.durablePublishedHashRetries).toBe(2);
-        expect(snap.initialPublishedDigests).toBe(0);
-        expect(snap.knownKinds).toBe(100);
-        expect(snap.deleteSnapshotEpochs).toBe(5);
-        expect(snap.ignoreFilterMemo).toBe(50);
-        // The pre-fix `content`-bearing tokens are never registered.
-        expect(snap.publishedContentHashGenerations).toBeUndefined();
-        expect(snap.lastPublishedContentHashes).toBeUndefined();
-    });
-    it("every registered census token is deny-safe for hq-pro ingest", () => {
-        // Any token containing a denied ingest substring would make its flattened
-        // `census_<token>_count` key dropped at ingest — the exact defect being fixed.
-        const DENY_PARTS = [
-            "authorization", "body", "content", "cookie", "email", "file", "message",
-            "password", "path", "prompt", "query", "secret", "text", "token", "transcript",
-        ];
-        const census = buildHeapCensus({
-            ownMaps: {
-                pendingAppliedUpserts: () => 0,
-                pendingWatcherEntries: () => 0,
-                pendingWatcherChanges: () => 0,
-                pendingWatcherDroppedRouteHints: () => 0,
-            },
-            eventSyncSizes: () => ({
-                lastPublishedContentHashes: 0,
-                publishedContentHashGenerations: 0,
-                deferredPublishes: 0,
-                durablePublishedHashRetries: 0,
-                initialPublishedContentHashes: 0,
-            }),
-            watcherSizes: () => ({ knownKinds: 0, deleteSnapshotEpochs: 0, ignoreFilterMemo: 0 }),
-        });
-        for (const { site } of census.snapshot()) {
-            const lower = site.toLowerCase();
-            for (const part of DENY_PARTS) {
-                expect(lower.includes(part), `deny part "${part}" in census token ${site}`).toBe(false);
-            }
-        }
-    });
-    it("reports 0 for emitter/watcher sites when no handle is live yet", () => {
-        const census = buildHeapCensus({
-            ownMaps: { pendingAppliedUpserts: () => 7 },
-            eventSyncSizes: () => undefined, // no live emitter
-            watcherSizes: () => undefined, // no attached watcher
-        });
-        const snap = snapshotOf(census);
-        expect(snap.pendingAppliedUpserts).toBe(7);
-        expect(snap.publishedDigestGenerations).toBe(0);
-        expect(snap.knownKinds).toBe(0);
-        expect(snap.deleteSnapshotEpochs).toBe(0);
-        expect(snap.ignoreFilterMemo).toBe(0);
-    });
-    it("reflects the CURRENT handle on each snapshot, so a late/replaced handle is picked up", () => {
-        const handle = { sizes: undefined };
-        const census = buildHeapCensus({
-            ownMaps: {},
-            eventSyncSizes: () => handle.sizes,
-            watcherSizes: () => undefined,
-        });
-        expect(snapshotOf(census).publishedDigestGenerations).toBe(0);
-        handle.sizes = {
-            lastPublishedContentHashes: 0,
-            publishedContentHashGenerations: 42,
-            deferredPublishes: 0,
-            durablePublishedHashRetries: 0,
-        };
-        expect(snapshotOf(census).publishedDigestGenerations).toBe(42);
-    });
-});
-describe("publishedContentHashFromJournalEntryBeforeSession", () => {
-    function makeEmitter(published, lookup) {
-        return new PushEventEmitter({
-            originTenantId: "tenant-indigo",
-            originDeviceId: "device-a",
-            transport: {
-                start: async () => { },
-                dispose: async () => { },
-                connected: true,
-                publish: async (event) => { published.push(event); },
-            },
-            flagProvider: { isEnabled: () => true },
-            now: () => new Date("2026-08-31T12:00:00.000Z"),
-            publishMinIntervalMs: 0,
-            publishedContentHashLookup: lookup,
-        });
-    }
-    function journalEntry(hash, syncedAt) {
-        return { hash, size: 23, syncedAt, direction: "up" };
-    }
-    it("does not re-announce an unchanged file after a runner restart and no-op upload reconciliation", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/reuploaded-unchanged.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "already published content\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const hash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.now();
-            const journal = {
-                version: "1",
-                lastSync: "",
-                files: {
-                    [relativePath]: journalEntry(hash, new Date(sessionStartedAt - 1_000).toISOString()),
-                },
-            };
-            // The upload reconciler sees the remote digest already matches local
-            // content, so it updates the journal without sending another PUT.
-            updateEntry(journal, relativePath, hash, Buffer.byteLength(content), "up", filePath, {
-                preserveSyncedAt: true,
-            });
-            const published = [];
-            const emitter = makeEmitter(published, (candidate) => candidate === relativePath
-                ? publishedContentHashFromJournalEntry(journal.files[relativePath], sessionStartedAt)
-                : undefined);
-            // A restarted runner starts with a cold emitter. The journal fallback
-            // must still identify these bytes as already published.
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toEqual([]);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("still publishes changed content first uploaded in the current runner session", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/changed-after-restart.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "new content\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const oldHash = createHash("sha256").update("old content\n").digest("hex");
-            const hash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.now();
-            const journal = {
-                version: "1",
-                lastSync: "",
-                files: {
-                    [relativePath]: journalEntry(oldHash, new Date(sessionStartedAt - 1_000).toISOString()),
-                },
-            };
-            updateEntry(journal, relativePath, hash, Buffer.byteLength(content), "up", filePath);
-            const published = [];
-            const emitter = makeEmitter(published, (candidate) => candidate === relativePath
-                ? publishedContentHashFromJournalEntry(journal.files[relativePath], sessionStartedAt)
-                : undefined);
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toHaveLength(1);
-            expect(published[0]).toMatchObject({
-                kind: "upsert",
-                relativePath,
-                contentHash: `sha256:${hash}`,
-            });
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("publishes a local upsert when this runner session has just persisted its hash", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/newly-pushed.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "newly pushed by this runner\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const hash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.parse("2026-08-31T12:00:00.000Z");
-            const persistedByThisSession = journalEntry(hash, "2026-08-31T12:00:00.001Z");
-            expect(publishedContentHashFromJournalEntry(persistedByThisSession, sessionStartedAt)).toBeUndefined();
-            const published = [];
-            const emitter = makeEmitter(published, (path) => path === relativePath
-                ? publishedContentHashFromJournalEntry(persistedByThisSession, sessionStartedAt)
-                : undefined);
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toHaveLength(1);
-            expect(published[0]).toMatchObject({
-                kind: "upsert",
-                relativePath,
-                contentHash: `sha256:${hash}`,
-            });
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("suppresses a hash that was genuinely published before the runner session", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/published-before-start.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "already published before this runner\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const hash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.parse("2026-08-31T12:00:00.000Z");
-            const publishedBeforeSession = journalEntry(hash, "2026-08-31T11:59:59.999Z");
-            expect(publishedContentHashFromJournalEntry(publishedBeforeSession, sessionStartedAt)).toBe(`sha256:${hash}`);
-            const published = [];
-            const emitter = makeEmitter(published, (path) => path === relativePath
-                ? publishedContentHashFromJournalEntry(publishedBeforeSession, sessionStartedAt)
-                : undefined);
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toEqual([]);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("suppresses a hash this session downloaded", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/downloaded-this-session.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "downloaded from the cloud this session\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const hash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.parse("2026-08-31T12:00:00.000Z");
-            const downloadedThisSession = {
-                ...journalEntry(hash, "2026-08-31T12:00:00.001Z"),
-                direction: "down",
-            };
-            expect(publishedContentHashFromJournalEntry(downloadedThisSession, sessionStartedAt)).toBe(`sha256:${hash}`);
-            const published = [];
-            const emitter = makeEmitter(published, (path) => path === relativePath
-                ? publishedContentHashFromJournalEntry(downloadedThisSession, sessionStartedAt)
-                : undefined);
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toEqual([]);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("publishes a local edit made after this session downloaded the file", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-published-hash-"));
-        try {
-            const relativePath = "companies/indigo/edited-after-download.md";
-            const filePath = path.join(dir, relativePath);
-            const content = "edited locally after the download\n";
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content);
-            const downloadedHash = createHash("sha256").update("downloaded cloud content\n").digest("hex");
-            const localHash = createHash("sha256").update(content).digest("hex");
-            const sessionStartedAt = Date.parse("2026-08-31T12:00:00.000Z");
-            const downloadedThisSession = {
-                ...journalEntry(downloadedHash, "2026-08-31T12:00:00.001Z"),
-                direction: "down",
-            };
-            expect(publishedContentHashFromJournalEntry(downloadedThisSession, sessionStartedAt)).toBe(`sha256:${downloadedHash}`);
-            const published = [];
-            const emitter = makeEmitter(published, (path) => path === relativePath
-                ? publishedContentHashFromJournalEntry(downloadedThisSession, sessionStartedAt)
-                : undefined);
-            await emitter.emitForBatch({ paths: new Map([[filePath, relativePath]]) });
-            expect(published).toHaveLength(1);
-            expect(published[0]).toMatchObject({
-                kind: "upsert",
-                relativePath,
-                contentHash: `sha256:${localHash}`,
-            });
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});
-describe("runner deliberate-exit code (cooperative recycle / hard exit)", () => {
-    it("RUNNER_HEAP_RECYCLE_EXIT is 1, distinct from success (0) and the auth-required exit (18)", () => {
-        // Every deliberate governor exit — cooperative, latch_timeout, hard_fraction —
-        // uses this one code, which the desktop classifies LocalLogOnly. It must never
-        // collide with success (0) or the auth-required pass exit (18).
-        expect(RUNNER_HEAP_RECYCLE_EXIT).toBe(1);
-        expect(RUNNER_HEAP_RECYCLE_EXIT).not.toBe(0);
-        expect(RUNNER_HEAP_RECYCLE_EXIT).not.toBe(AUTH_REQUIRED_PASS_EXIT);
-        expect(AUTH_REQUIRED_PASS_EXIT).toBe(18);
-    });
-});
-describe("coordinatorWorker unresolved-company exit", () => {
-    it("maps UNRESOLVED_COMPANY_EXIT (19) to durable and keeps 75 and 2 retryable", () => {
-        expect(coordinatorPathOutcome(0)).toEqual({ status: "durable" });
-        expect(coordinatorPathOutcome(UNRESOLVED_COMPANY_EXIT)).toEqual({
-            status: "durable",
-            reason: "unresolved company",
-        });
-        expect(coordinatorPathOutcome(PARTIAL_SYNC_EXIT)).toEqual({
-            status: "retryable",
-            reason: `sync pass exited ${PARTIAL_SYNC_EXIT}`,
-        });
-        expect(coordinatorPathOutcome(TRANSIENT_NETWORK_EXIT)).toEqual({
-            status: "retryable",
-            reason: `sync pass exited ${TRANSIENT_NETWORK_EXIT}`,
-        });
-        expect(coordinatorPathOutcome(1)).toEqual({
-            status: "retryable",
-            reason: "sync pass exited 1",
-        });
-    });
-    it("maps unresolved company to telemetry reason unresolved-company, not pass-exit", () => {
-        expect(realtimeTelemetryReason([
-            {
-                path: "companies/acme/note.md",
-                epoch: 1,
-                status: "durable",
-                reason: "unresolved company",
-            },
-        ])).toBe("unresolved-company");
-        expect(realtimeTelemetryReason([
-            {
-                path: "companies/acme/note.md",
-                epoch: 1,
-                status: "retryable",
-                reason: `sync pass exited ${UNRESOLVED_COMPANY_EXIT}`,
-            },
-        ])).toBe("unresolved-company");
-        expect(realtimeTelemetryReason([
-            {
-                path: "companies/indigo/note.md",
-                epoch: 1,
-                status: "retryable",
-                reason: `sync pass exited ${PARTIAL_SYNC_EXIT}`,
-            },
-        ])).toBe("pass-exit");
-        expect(realtimeTelemetryReason([
-            {
-                path: "companies/indigo/note.md",
-                epoch: 1,
-                status: "retryable",
-                reason: `sync pass exited ${TRANSIENT_NETWORK_EXIT}`,
-            },
-        ])).toBe("pass-exit");
-    });
-});
-describe("takeEnumeratedBatchChunk", () => {
-    it("returns the original batch when it already fits the limit", () => {
-        const batch = {
-            paths: new Map([
-                ["/a", "a"],
-                ["/b", "b"],
-            ]),
-        };
-        const split = takeEnumeratedBatchChunk(batch, 2);
-        expect(split.chunk).toBe(batch);
-        expect(split.remainder).toBeNull();
-    });
-    it("keeps insertion order, change records, and the remainder queued", () => {
-        const addA = { kind: "add" };
-        const addB = { kind: "add" };
-        const addC = { kind: "add" };
-        const batch = {
-            paths: new Map([
-                ["/a", "a"],
-                ["/b", "b"],
-                ["/c", "c"],
-            ]),
-            changes: new Map([
-                ["/a", addA],
-                ["/b", addB],
-                ["/c", addC],
-            ]),
-        };
-        const split = takeEnumeratedBatchChunk(batch, 2);
-        expect([...split.chunk.paths.values()]).toEqual(["a", "b"]);
-        expect(split.chunk.changes?.get("/a")).toBe(addA);
-        expect(split.chunk.changes?.get("/b")).toBe(addB);
-        expect(split.remainder).not.toBeNull();
-        expect([...(split.remainder?.paths.values() ?? [])]).toEqual(["c"]);
-        expect(split.remainder?.changes?.get("/c")).toBe(addC);
-        expect(split.chunk).not.toHaveProperty("overflowed");
-        expect(split.remainder).not.toHaveProperty("overflowed");
-    });
-});
-describe("resident-footprint env knobs (startRunnerHeapSampling seam)", () => {
-    // The watch loop maps these env knobs onto the footprint options it passes to
-    // startRunnerHeapSampling. Pin the exact knob names so a rename that would make
-    // the desktop's env override silently ineffective fails here, and pin the
-    // fail-soft parsing so a malformed value can never disable the tier or the
-    // heap tiers beside it.
-    it("uses the exact HQ_SYNC_RUNNER_FOOTPRINT_* knob names the desktop can set", () => {
-        expect(HEAP_FOOTPRINT_RECYCLE_ENABLED_ENV).toBe("HQ_SYNC_RUNNER_FOOTPRINT_RECYCLE_ENABLED");
-        expect(HEAP_FOOTPRINT_RECYCLE_MB_ENV).toBe("HQ_SYNC_RUNNER_FOOTPRINT_RECYCLE_MB");
-        expect(HEAP_FOOTPRINT_HARD_EXIT_MB_ENV).toBe("HQ_SYNC_RUNNER_FOOTPRINT_HARD_EXIT_MB");
-    });
-    it("resolves malformed footprint values to fail-soft defaults and never silently disables the tier", () => {
-        expect(resolveHeapFootprintRecycleBytes("garbage")).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(resolveHeapFootprintRecycleBytes(undefined)).toBe(DEFAULT_HEAP_FOOTPRINT_RECYCLE_BYTES);
-        expect(resolveHeapFootprintHardExitBytes("4gb")).toBe(DEFAULT_HEAP_FOOTPRINT_HARD_EXIT_BYTES);
-        // A typo in the enable knob keeps the tier ARMED; only an explicit off disables it.
-        expect(resolveHeapFootprintRecycleEnabled("nope")).toBe(true);
-        expect(resolveHeapFootprintRecycleEnabled("0")).toBe(false);
-    });
-});
-describe("watch-loop qmd heartbeat and shutdown", () => {
-    const acquireLease = () => ({
-        status: "acquired",
-        lease: {
-            statusPath: "test://qmd-watch-owner",
-            lost: new Promise(() => { }),
-            release: async () => { },
-        },
-    });
-    it("emits stopping and final shutdown protocol statuses", async () => {
-        const stdout = [];
-        let triggerShutdown = (_signal) => { };
-        const loop = runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
-            acquireWatchOwnerLease: acquireLease,
-            idleHeartbeatIntervalMs: 10,
-            stdout: { write: (chunk) => { stdout.push(chunk); return true; } },
-            sleep: () => new Promise(() => { }),
-            onShutdownSignal: (handler) => {
-                triggerShutdown = handler;
-                return () => { };
-            },
-            runPass: async () => {
-                triggerShutdown("SIGTERM");
-                return 0;
-            },
-        });
-        await expect(loop).resolves.toBe(0);
-        const statuses = stdout
-            .flatMap((chunk) => chunk.split("\n"))
-            .filter(Boolean)
-            .map((line) => JSON.parse(line))
-            .filter((line) => line.type === "status");
-        expect(statuses).toContainEqual(expect.objectContaining({ state: "stopping", signal: "SIGTERM" }));
-        expect(statuses.at(-1)).toEqual(expect.objectContaining({
-            state: "stopped",
-            exitReason: "clean",
-            eventLoopDelay: expect.objectContaining({ maxMs: expect.any(Number), p99Ms: expect.any(Number) }),
-        }));
-    });
-    it("writes protocol heartbeats while the post-sync qmd command is pending", async () => {
-        vi.useFakeTimers();
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-heartbeat-"));
-        const stdout = [];
-        let triggerShutdown = (_signal) => { };
-        let shutdownTriggered = false;
-        const shutdown = () => {
-            if (shutdownTriggered)
-                return;
-            shutdownTriggered = true;
-            triggerShutdown("SIGTERM");
-        };
-        let heartbeatDuringQmd = false;
-        let qmdUpdated = false;
-        const countHeartbeats = () => stdout
-            .flatMap((chunk) => chunk.split("\n"))
-            .filter(Boolean)
-            .map((line) => JSON.parse(line))
-            .filter((event) => event.type === "maintenance-progress").length;
-        try {
-            const code = await runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
-                acquireWatchOwnerLease: acquireLease,
-                idleHeartbeatIntervalMs: 10,
-                stdout: { write: (chunk) => { stdout.push(chunk); return true; } },
-                sleep: () => new Promise(() => { }),
-                onShutdownSignal: (handler) => {
-                    triggerShutdown = handler;
-                    return () => { };
-                },
-                runPassSupportsQmdLifecycle: true,
-                runPass: async (_argv, _checkpoint, _onJournals, _onUpserts, _priority, qmdSignal, qmdHeartbeat, qmdHeartbeatIntervalMs) => {
-                    const result = await reindexAfterSync("/tmp/hq", {
-                        signal: qmdSignal,
-                        onHeartbeat: qmdHeartbeat,
-                        heartbeatIntervalMs: qmdHeartbeatIntervalMs,
-                        statePath: path.join(dir, "qmd-state.json"),
-                        changedPaths: ["companies/acme/knowledge/note.md"],
-                        debounceMs: 0,
-                        existsSync: (candidate) => candidate === path.join("/tmp/hq", "core", "core.yaml"),
-                        readCompanies: () => [],
-                        acquireReindexLock: () => ({ release() { } }),
-                        exec: async (args) => {
-                            if (args[0] === "update") {
-                                const before = countHeartbeats();
-                                await vi.advanceTimersByTimeAsync(35);
-                                heartbeatDuringQmd = countHeartbeats() > before;
-                            }
-                            return { status: 0, stdout: "" };
-                        },
-                    });
-                    qmdUpdated = result.updated;
-                    shutdown();
-                    return 0;
-                },
-            });
-            expect(code).toBe(0);
-            expect(qmdUpdated).toBe(true);
-            expect(heartbeatDuringQmd).toBe(true);
-        }
-        finally {
-            shutdown();
-            vi.clearAllTimers();
-            vi.useRealTimers();
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("does not heartbeat during a pass that remains pending without qmd", async () => {
-        vi.useFakeTimers();
-        const stdout = [];
-        let triggerShutdown = (_signal) => { };
-        let shutdownTriggered = false;
-        const shutdown = () => {
-            if (shutdownTriggered)
-                return;
-            shutdownTriggered = true;
-            triggerShutdown("SIGTERM");
-        };
-        let releasePass = () => { };
-        let loop = null;
-        let runPassStarted = () => { };
-        const passStarted = new Promise((resolve) => {
-            runPassStarted = resolve;
-        });
-        const countHeartbeats = () => stdout
-            .flatMap((chunk) => chunk.split("\n"))
-            .filter(Boolean)
-            .map((line) => JSON.parse(line))
-            .filter((event) => event.type === "maintenance-progress").length;
-        try {
-            loop = runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
-                acquireWatchOwnerLease: acquireLease,
-                idleHeartbeatIntervalMs: 10,
-                stdout: { write: (chunk) => { stdout.push(chunk); return true; } },
-                sleep: () => new Promise(() => { }),
-                onShutdownSignal: (handler) => {
-                    triggerShutdown = handler;
-                    return () => { };
-                },
-                runPass: async () => {
-                    runPassStarted();
-                    await new Promise((resolve) => { releasePass = resolve; });
-                    return 0;
-                },
-            });
-            await passStarted;
-            await vi.advanceTimersByTimeAsync(50);
-            expect(countHeartbeats()).toBe(0);
-            shutdown();
-            releasePass();
-            await expect(loop).resolves.toBe(0);
-        }
-        finally {
-            shutdown();
-            releasePass();
-            if (loop)
-                await loop.catch(() => undefined);
-            vi.clearAllTimers();
-            vi.useRealTimers();
-        }
-    });
-    it("aborts an in-flight qmd command on SIGTERM and preserves pending-dirty state", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-qmd-shutdown-"));
-        const stdout = [];
-        let triggerShutdown = (_signal) => { };
-        let shutdownTriggered = false;
-        const shutdown = () => {
-            if (shutdownTriggered)
-                return;
-            shutdownTriggered = true;
-            triggerShutdown("SIGTERM");
-        };
-        let signalDelivered = false;
-        let observedAbort = () => { };
-        const updateStarted = new Promise((resolve) => {
-            observedAbort = resolve;
-        });
-        const statePath = path.join(dir, "qmd-state.json");
-        try {
-            const loop = runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
-                acquireWatchOwnerLease: acquireLease,
-                idleHeartbeatIntervalMs: 10,
-                stdout: { write: (chunk) => { stdout.push(chunk); return true; } },
-                sleep: () => new Promise(() => { }),
-                onShutdownSignal: (handler) => {
-                    triggerShutdown = handler;
-                    return () => { };
-                },
-                runPassSupportsQmdLifecycle: true,
-                runPass: async (_argv, _checkpoint, _onJournals, _onUpserts, _priority, qmdSignal) => {
-                    await reindexAfterSync("/tmp/hq", {
-                        signal: qmdSignal,
-                        statePath,
-                        changedPaths: ["companies/acme/knowledge/note.md"],
-                        debounceMs: 0,
-                        existsSync: (candidate) => candidate === path.join("/tmp/hq", "core", "core.yaml"),
-                        readCompanies: () => [],
-                        acquireReindexLock: () => ({ release() { } }),
-                        exec: async (args, options) => {
-                            if (args[0] === "update") {
-                                observedAbort();
-                                await new Promise((resolve) => {
-                                    options?.signal?.addEventListener("abort", () => {
-                                        signalDelivered = true;
-                                        resolve({ status: null, stdout: "", stderr: "" });
-                                    }, { once: true });
-                                });
-                            }
-                            return { status: 0, stdout: "" };
-                        },
-                    });
-                    return 0;
-                },
-            });
-            await updateStarted;
-            shutdown();
-            await expect(loop).resolves.toBe(0);
-            expect(signalDelivered).toBe(true);
-            expect(JSON.parse(fs.readFileSync(statePath, "utf8"))).toMatchObject({
-                pendingDirty: true,
-            });
-        }
-        finally {
-            shutdown();
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});
-//# sourceMappingURL=sync-runner-watch-loop.test.js.map