@indigoai-us/hq-cloud 6.18.24 → 6.18.26

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

@@ -12,7 +12,7 @@ import * as os from "os";
 import * as path from "path";
 import * as v8 from "node:v8";
 import * as vm from "node:vm";
-import { monitorEventLoopDelay } from "node:perf_hooks";
+import { monitorEventLoopDelay, PerformanceObserver } from "node:perf_hooks";
 import { runRunner, parseArgs, loopPassDeps, runRunnerWithLoop as runRunnerWithOwnerLease, resolveDeletePolicy, resolveSkipPersonal, resolveSkipCompanies, selectObjectIOFactory, routeChangeToTarget, buildTargetedPushArgv, resolvePullScope, readPinnedPrefixes, SESSIONS_SCOPE_PREFIX, defaultCollectTelemetry, AUTH_REQUIRED_PASS_EXIT, conventionalWatchSignalExitCode, DEFAULT_WATCH_RUNNER_SHUTDOWN_TIMEOUT_MS, resolveWatchRunnerShutdownTimeoutMs, WATCH_RUNNER_SHUTDOWN_TIMEOUT_ENV, } from "./sync-runner.js";
 import { SESSION_LOGS_PUSH_ONLY_PREFIX } from "../sync/pull-scope.js";
 import { WATCH_RUNNER_ALREADY_OWNED_EXIT, WATCH_OWNER_LEASE_LOST_EXIT, } from "../lib/exit-codes.js";
@@ -23,7 +23,7 @@ import { POST_SYNC_FLAG_KEYS, } from "./sync-runner-post-sync-flags.js";
 import { FakeClock, TreeWatcher, } from "../watcher.js";
 import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, resolveWatchPollMs, CHORE_STARVATION_CAP_MS, CooperativePassScheduler, REALTIME_ADMISSION_DEADLINE_MS, REALTIME_DRAIN_BURST_MS, REALTIME_WORKER_OCCUPANCY_CAP, RealtimeAdmissionTimeoutError, setRealtimeAdmissionDeadlineMsForTesting, setRealtimeDrainBurstMsForTesting, normalizeCoordinatorPaths, shouldQuarantineWatcherDeleteIntents, shouldUseAreaStorage, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS, } from "./sync-runner-watch-loop.js";
 import { FullPassCapController, resetFullPassCapLogForTest, } from "../sync/full-pass-caps.js";
-import { AreaLedgerMigration, JournalStore, openJournalStateStoreForMigration, PERSONAL_VAULT_JOURNAL_SLUG, readJournal, readJournalScoped, writeJournal, } from "../journal.js";
+import { AreaLedgerMigration, JournalStore, openJournalStateStoreForMigration, PERSONAL_VAULT_JOURNAL_SLUG, readJournal, readJournalForPass, readJournalScoped, readJournalScopedAsync, writeJournal, } from "../journal.js";
 import { AreaLedger } from "../sync/area-ledger.js";
 import { AreaResolver } from "../sync/area-resolver.js";
 import { AREA_LEGACY_MIRROR_LINGER_MS } from "../sync/area-ledger-migration.js";
@@ -285,6 +285,29 @@ describe("argv parsing", () => {
             exitWithParent: false,
         });
     });
+    it("validates --watch-parent-pid requirements and values", () => {
+        expect(parseArgs(["--companies", "--watch-parent-pid", "42"])).toEqual({
+            error: "--watch-parent-pid requires --watch",
+        });
+        expect(parseArgs(["--companies", "--watch", "--watch-parent-pid", "42"])).toEqual({
+            error: "--watch-parent-pid requires --exit-with-parent",
+        });
+        expect(parseArgs(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid"])).toEqual({
+            error: "--watch-parent-pid requires a positive integer",
+        });
+        for (const value of ["0", "-1", "1.5", "nope"]) {
+            expect(parseArgs(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", value])).toEqual({
+                error: "--watch-parent-pid requires a positive integer",
+            });
+        }
+        expect(parseArgs(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", "42"])).toMatchObject({ watch: true, exitWithParent: true, watchParentPid: 42 });
+        expect(parseArgs(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", "1"])).toEqual({
+            error: "--watch-parent-pid cannot be PID 1 or the runner process",
+        });
+        expect(parseArgs(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", String(process.pid)])).toEqual({
+            error: "--watch-parent-pid cannot be PID 1 or the runner process",
+        });
+    });
     it("rejects invalid --on-conflict value", async () => {
         const deps = makeDeps();
         const code = await runRunner(["--companies", "--on-conflict", "nuke"], deps);
@@ -5052,9 +5075,67 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         });
         expect(await loop).toBe(0);
         expect(startParentExitMonitor).toHaveBeenCalledOnce();
+        expect(startParentExitMonitor.mock.calls[0]?.slice(1)).toEqual([
+            process.ppid,
+            process.ppid,
+        ]);
         expect(release).toHaveBeenCalledOnce();
         expect(stopMonitor).toHaveBeenCalledOnce();
     });
+    it("passes the explicit launcher PID to the exit monitor", async () => {
+        const release = vi.fn(async () => { });
+        const startParentExitMonitor = vi.fn((onParentExit) => {
+            queueMicrotask(onParentExit);
+            return { stop: vi.fn() };
+        });
+        const code = await runRunnerWithLoop(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", "9001"], {
+            parentExists: () => true,
+            startParentExitMonitor,
+            runPass: async () => 0,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: () => () => { },
+            acquireWatchOwnerLease: () => ({
+                status: "acquired",
+                lease: {
+                    statusPath: "test://watch-owner",
+                    lost: new Promise(() => { }),
+                    release,
+                },
+            }),
+        });
+        expect(code).toBe(0);
+        expect(startParentExitMonitor.mock.calls[0]?.slice(1)).toEqual([9001, process.ppid]);
+        expect(release).toHaveBeenCalledOnce();
+    });
+    it("shuts down before the first pass when the explicit launcher is already gone", async () => {
+        const release = vi.fn(async () => { });
+        const runPass = vi.fn(async () => 0);
+        const stderr = makeWriter();
+        const parentExists = vi.fn(() => false);
+        const startParentExitMonitor = vi.fn(() => ({ stop: vi.fn() }));
+        const code = await runRunnerWithLoop(["--companies", "--watch", "--exit-with-parent", "--watch-parent-pid", "9001"], {
+            stderr,
+            parentExists,
+            startParentExitMonitor,
+            runPass,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: () => () => { },
+            acquireWatchOwnerLease: () => ({
+                status: "acquired",
+                lease: {
+                    statusPath: "test://watch-owner",
+                    lost: new Promise(() => { }),
+                    release,
+                },
+            }),
+        });
+        expect(code).toBe(0);
+        expect(parentExists).toHaveBeenCalledWith(9001);
+        expect(stderr.raw()).toContain("--watch-parent-pid 9001 is not running");
+        expect(runPass).not.toHaveBeenCalled();
+        expect(startParentExitMonitor).not.toHaveBeenCalled();
+        expect(release).toHaveBeenCalledOnce();
+    });
     it("bounds parent-exit shutdown when an active pass ignores cancellation", async () => {
         const previousTimeout = process.env[WATCH_RUNNER_SHUTDOWN_TIMEOUT_ENV];
         process.env[WATCH_RUNNER_SHUTDOWN_TIMEOUT_ENV] = "50";
@@ -7656,22 +7737,43 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         const watcher = makeBatchWatcherStub();
         let shutdown = () => { };
         let committedAt;
+        let activeCommitSample;
+        let scopedCommitSequence = 0;
+        const commitPhases = [];
         const runPass = vi.fn(async (argv) => {
             if (!argv.includes("--scope-path")) {
                 // Production opens the packed journal during the initial full pass,
                 // before the watcher accepts realtime work. That recovered projection
                 // is the one a scoped commit must reuse.
-                readJournal(PERSONAL_VAULT_JOURNAL_SLUG);
+                readJournalForPass(PERSONAL_VAULT_JOURNAL_SLUG);
             }
             if (argv.includes("--scope-path") && argv.includes("push")) {
-                const scoped = readJournalScoped(PERSONAL_VAULT_JOURNAL_SLUG, targetPaths);
+                const passStartedAt = performance.now();
+                const scopedReadStartedAt = performance.now();
+                const scoped = await readJournalScopedAsync(PERSONAL_VAULT_JOURNAL_SLUG, targetPaths);
+                const scopedReadMs = performance.now() - scopedReadStartedAt;
+                const mutationStartedAt = performance.now();
                 const target = targetPaths[0];
                 scoped.files[target] = {
                     ...scoped.files[target],
-                    syncedAt: "2026-09-16T21:38:18.000Z",
+                    syncedAt: new Date(Date.parse("2026-09-16T21:38:18.000Z") + scopedCommitSequence++).toISOString(),
                 };
+                const entryMutationMs = performance.now() - mutationStartedAt;
+                const journalWriteStartedAt = performance.now();
                 writeJournal(PERSONAL_VAULT_JOURNAL_SLUG, scoped);
+                const journalWriteMs = performance.now() - journalWriteStartedAt;
                 committedAt = performance.now();
+                if (activeCommitSample) {
+                    commitPhases.push({
+                        sample: activeCommitSample.sample,
+                        dispatchToPassMs: passStartedAt - activeCommitSample.submittedAt,
+                        scopedReadMs,
+                        entryMutationMs,
+                        journalWriteMs,
+                        passRemainderMs: committedAt - passStartedAt - scopedReadMs - entryMutationMs - journalWriteMs,
+                        submitToCommitMs: committedAt - activeCommitSample.submittedAt,
+                    });
+                }
             }
             return completedPassOutcome();
         });
@@ -7684,21 +7786,19 @@ describe("runRunnerWithLoop — event-push wiring", () => {
                 return () => { };
             },
         });
+        const gcActivity = [];
+        const gcObserver = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                const detail = entry;
+                gcActivity.push({ kind: detail.detail?.kind ?? null, duration: entry.duration, startTime: entry.startTime });
+            }
+        });
+        gcObserver.observe({ entryTypes: ["gc"] });
         try {
             await flushLoopMicrotasks(30);
             runPass.mockClear();
             resetStateStoreSnapshotRecoveryCountForTest();
-            const eventLoopDelay = monitorEventLoopDelay({ resolution: 10 });
-            eventLoopDelay.enable();
             await new Promise((resolve) => setTimeout(resolve, 0));
-            const submittedAt = performance.now();
-            let timerDelayMs;
-            const eventLoopTurn = new Promise((resolve) => {
-                setTimeout(() => {
-                    timerDelayMs = performance.now() - submittedAt;
-                    resolve();
-                }, 0);
-            });
             const batch = {
                 paths: new Map(targetPaths.map((relativePath) => [path.join(hqRoot, relativePath), relativePath])),
                 changes: new Map(targetPaths.map((relativePath) => [
@@ -7706,17 +7806,73 @@ describe("runRunnerWithLoop — event-push wiring", () => {
                     { kind: "change" },
                 ])),
             };
-            watcher.emit(targetPaths[0], batch);
-            await vi.waitFor(() => expect(committedAt).toBeDefined(), { timeout: 30_000, interval: 10 });
-            await eventLoopTurn;
-            eventLoopDelay.disable();
-            expect(committedAt - submittedAt).toBeLessThan(1_000);
-            expect(Number(eventLoopDelay.max) / 1_000_000).toBeLessThan(100);
-            expect(timerDelayMs).toBeLessThan(100);
+            // Measure each commit independently so one long event-loop block cannot
+            // disappear inside an aggregate statistic.
+            const loopDelayMaxMs = [];
+            const commitDurations = [];
+            for (let sample = 0; sample < 5; sample += 1) {
+                const loopDelay = monitorEventLoopDelay({ resolution: 10 });
+                loopDelay.enable();
+                try {
+                    // Preserve the old pre-commit window as a separately reported idle
+                    // baseline. The guarded histogram starts only after this window.
+                    const warmupStart = performance.now();
+                    await new Promise((resolve) => setTimeout(resolve, 30));
+                    const warmupEnd = performance.now();
+                    for (const entry of gcObserver.takeRecords()) {
+                        const detail = entry;
+                        gcActivity.push({ kind: detail.detail?.kind ?? null, duration: entry.duration, startTime: entry.startTime });
+                    }
+                    const warmupMaxDelayMs = loopDelay.max / 1e6;
+                    const warmupGc = gcActivity
+                        .filter((entry) => entry.startTime >= warmupStart && entry.startTime <= warmupEnd)
+                        .map((entry) => ({ kind: entry.kind, duration: Number(entry.duration.toFixed(2)), startTime: Number(entry.startTime.toFixed(2)) }));
+                    loopDelay.reset();
+                    committedAt = undefined;
+                    const windowStart = performance.now();
+                    activeCommitSample = { sample: sample + 1, submittedAt: windowStart };
+                    const watcherCallbackStartedAt = performance.now();
+                    watcher.emit(targetPaths[0], batch);
+                    const watcherCallbackSyncMs = performance.now() - watcherCallbackStartedAt;
+                    await vi.waitFor(() => expect(committedAt).toBeDefined(), { timeout: 30_000, interval: 10 });
+                    commitDurations.push(committedAt - windowStart);
+                    // Give the histogram's next 10 ms sample time to observe a stall that
+                    // ended in the commit callback before reading this window's maximum.
+                    await new Promise((resolve) => setTimeout(resolve, 20));
+                    const windowEnd = performance.now();
+                    for (const entry of gcObserver.takeRecords()) {
+                        const detail = entry;
+                        gcActivity.push({ kind: detail.detail?.kind ?? null, duration: entry.duration, startTime: entry.startTime });
+                    }
+                    const maxDelayMs = loopDelay.max / 1e6;
+                    loopDelayMaxMs.push(maxDelayMs);
+                    const phases = commitPhases.find((phase) => phase.sample === sample + 1);
+                    const sampleGc = gcActivity
+                        .filter((entry) => entry.startTime >= windowStart && entry.startTime <= windowEnd)
+                        .map((entry) => ({ kind: entry.kind, duration: Number(entry.duration.toFixed(2)), startTime: Number(entry.startTime.toFixed(2)) }));
+                    process.stdout.write(`realtime-commit-sample ${JSON.stringify({
+                        sample: sample + 1,
+                        warmupMaxDelayMs: Number(warmupMaxDelayMs.toFixed(1)),
+                        warmupGc,
+                        maxDelayMs: Number(maxDelayMs.toFixed(1)),
+                        windowStart: Number(windowStart.toFixed(2)),
+                        windowEnd: Number(windowEnd.toFixed(2)),
+                        phases: phases ? { ...phases, watcherCallbackSyncMs } : null,
+                        gc: sampleGc,
+                    })}\n`);
+                    activeCommitSample = undefined;
+                }
+                finally {
+                    loopDelay.disable();
+                }
+            }
+            expect(Math.max(...commitDurations)).toBeLessThan(1_000);
+            expect(Math.max(...loopDelayMaxMs)).toBeLessThan(100);
             expect(getStateStoreSnapshotRecoveryCountForTest()).toBe(0);
-            expect(runPass.mock.calls.filter(([argv]) => argv.includes("--scope-path"))).toHaveLength(1);
+            expect(runPass.mock.calls.filter(([argv]) => argv.includes("--scope-path"))).toHaveLength(5);
         }
         finally {
+            gcObserver.disconnect();
             shutdown();
             await loop;
             if (previousCoordinator === undefined)