patchwork-os 0.2.0-alpha.9 → 0.2.0-beta.1

package/dist/bridge.js

@@ -5,33 +5,38 @@ import path from "node:path";
 import { WebSocket } from "ws";
 import { ActivityLog } from "./activityLog.js";
 import { buildSummary } from "./analyticsAggregator.js";
-import { getAnalyticsPref } from "./analyticsPrefs.js";
+import { getAnalyticsPref, getAnalyticsSalt } from "./analyticsPrefs.js";
 import { sendAnalytics } from "./analyticsSend.js";
 import { getApprovalQueue } from "./approvalQueue.js";
 import { AutomationHooks, loadPolicy } from "./automation.js";
 import { loadOrCreateBridgeToken } from "./bridgeToken.js";
 import { repairBridgeToolsRulesIfStale } from "./bridgeToolsRules.js";
-import { createDriver } from "./claudeDriver.js";
 import { ClaudeOrchestrator } from "./claudeOrchestrator.js";
 import { CommitIssueLinkLog } from "./commitIssueLinkLog.js";
 import { DecisionTraceLog } from "./decisionTraceLog.js";
+import { createDriver } from "./drivers/index.js";
 import { ExtensionClient } from "./extensionClient.js";
+import { lockKillSwitchEnv } from "./featureFlags.js";
 import { FileLock } from "./fileLock.js";
 import { buildEnforcementReminder } from "./instructionsUtils.js";
 import { LockFileManager } from "./lockfile.js";
 import { Logger } from "./logger.js";
 import { OAuthServerImpl } from "./oauth.js";
+import { defaultConfigPath, getApiKeysPresent, loadConfig as loadPatchworkConfig, } from "./patchworkConfig.js";
 import { loadPlugins, loadPluginsFull } from "./pluginLoader.js";
 import { PluginWatcher } from "./pluginWatcher.js";
+import { isPreToolUseHookRegistered } from "./preToolUseHook.js";
 import { probeAll } from "./probe.js";
-import { RecipeScheduler } from "./recipes/scheduler.js";
-import { findWebhookRecipe, listInstalledRecipes, loadRecipePrompt, renderWebhookPrompt, saveRecipe, } from "./recipesHttp.js";
+import { RecipeOrchestration } from "./recipeOrchestration.js";
+import { warnAboutLegacyPermissionsSidecars } from "./recipes/migrationWarnings.js";
+import { RecipeOrchestrator } from "./recipes/RecipeOrchestrator.js";
 import { classifyTool } from "./riskTier.js";
 import { RecipeRunLog } from "./runLog.js";
 import { Server } from "./server.js";
 import { SessionCheckpoint } from "./sessionCheckpoint.js";
 import { StreamableHttpHandler } from "./streamableHttp.js";
 import { initTelemetry, shutdownTelemetry } from "./telemetry.js";
+import { TokenUsageTracker } from "./tokenUsageTracker.js";
 import { createCtxQueryTracesTool } from "./tools/ctxQueryTraces.js";
 import { readNote, writeNote } from "./tools/handoffNote.js";
 import { registerAllTools } from "./tools/index.js";
@@ -112,8 +117,10 @@ export class Bridge {
     pluginTools = [];
     pluginWatcher = null;
     automationHooks = undefined;
+    recipeOrchestration = null;
     recipeScheduler = null;
     recipeRunLog = null;
+    recipeOrchestrator = null;
     commitIssueLinkLog = null;
     decisionTraceLog = null;
     /** Pre-computed digest of recent decisions, refreshed on each session connect. */
@@ -129,6 +136,7 @@ export class Bridge {
     /** ISO timestamp of last getProjectContext cache write — drives status-bar "context X min ago". */
     _lastContextCachedAt = null;
     wsHeartbeatInterval = null;
+    tokenUsageTracker;
     constructor(config) {
         this.config = config;
         this.logger = new Logger(config.verbose, config.jsonl);
@@ -136,6 +144,7 @@ export class Bridge {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
         this.authToken = config.fixedToken ?? loadOrCreateBridgeToken(configDir);
         this.server = new Server(this.authToken, this.logger, config.corsOrigins);
+        this.server.bridgeConfigPath = config.configFilePath ?? undefined;
         if (config.issuerUrl) {
             this.oauthServer = new OAuthServerImpl(this.authToken, config.issuerUrl, {
                 configDir,
@@ -150,6 +159,10 @@ export class Bridge {
             this.logger.info(`Audit log: ${config.auditLogPath}`);
         }
         this.extensionClient = new ExtensionClient(this.logger);
+        this.tokenUsageTracker = new TokenUsageTracker({
+            workspace: config.workspace,
+            logger: { warn: (m) => this.logger.warn(m) },
+        });
         // Handle new Claude Code connections
         this.server.on("connection", async (ws) => {
             // Reject connections before probes are ready
@@ -181,6 +194,15 @@ export class Bridge {
                     existing.graceTimer = null;
                     existing.ws = ws;
                     existing.wsAlive = true;
+                    // Clean up old WS listener + reject stale pending elicitations
+                    // before attaching the new socket. Without this, the previous
+                    // listener accumulates and pending elicitations from the old
+                    // client can resolve against the new connection's `activeWs`,
+                    // surfacing prompts to a client that didn't request them.
+                    // Intentionally NOT calling `detach()` — that would abort
+                    // in-flight tool calls, but grace-period semantics preserve
+                    // those across the reconnect.
+                    existing.transport.detachSoft();
                     existing.transport.attach(ws);
                     ws.on("pong", () => {
                         existing.wsAlive = true;
@@ -239,8 +261,26 @@ export class Bridge {
             transport.sessionId = sessionId;
             transport.setActivityLog(this.activityLog);
             transport.setToolRateLimit(this.config.toolRateLimit);
+            if (this.config.lazyTools)
+                transport.setLazyTools(true);
             if (this.server.approvalGate !== "off") {
                 this.logger.info(`[patchwork] approval gate active: ${this.server.approvalGate} tier(s) require dashboard approval`);
+                // The approval gate only sees traffic if Claude Code's PreToolUse
+                // hook is registered to POST into /approvals. If it isn't, every
+                // CC tool call bypasses the bridge entirely — the queue stays
+                // empty, no `approval_decision` rows accumulate, and the entire
+                // personalSignals catalog has no input data. Silent foot-gun
+                // that wasted hours of investigation; surface it loudly.
+                try {
+                    const ccSettingsPath = path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude"), "settings.json");
+                    if (!isPreToolUseHookRegistered(ccSettingsPath)) {
+                        this.logger.warn?.(`[patchwork] WARNING: approval gate is on but no PreToolUse hook found in ${ccSettingsPath}. ` +
+                            `Claude Code will bypass the approval queue. Run 'patchwork-init' to register the hook.`);
+                    }
+                }
+                catch {
+                    // Best-effort warning — never block startup on a hook check failure.
+                }
                 transport.setApprovalGate(async ({ toolName, params, sessionId }) => {
                     const tier = classifyTool(toolName);
                     if (this.server.approvalGate === "off")
@@ -677,7 +717,11 @@ export class Bridge {
     async start() {
         // 0. Initialize OpenTelemetry (no-op when OTEL_EXPORTER_OTLP_ENDPOINT is unset)
         initTelemetry();
-        // 0a. Auto-repair .claude/rules/bridge-tools.md if stale (present but missing the
+        // 0a. Snapshot env-derived kill-switch flags. After this, plugins or
+        // recipe steps mutating `process.env.PATCHWORK_FLAG_*` cannot disable an
+        // active emergency stop. Closes MED-2 from the 2026-04-28 audit.
+        lockKillSwitchEnv();
+        // 0b. Auto-repair .claude/rules/bridge-tools.md if stale (present but missing the
         // current version sentinel). Older package versions write stale files that may
         // lack new tool substitution rules. Repair is silent on success; falls back to
         // warn-only if the template is missing or the write fails.
@@ -685,6 +729,7 @@ export class Bridge {
         // 1. Probe available CLI tools (pass workspace so local node_modules/.bin is checked)
         this.probes = await probeAll(this.config.workspace);
         this.ready = true;
+        this.tokenUsageTracker.start();
         // 2. Load plugins (after probes, before accepting sessions)
         this.pluginTools = await loadPlugins(this.config.plugins, this.config, this.logger);
         if (this.config.pluginWatch && this.config.plugins.length > 0) {
@@ -703,8 +748,21 @@ export class Bridge {
         this.logger.info(`Available linters: ${probeList(["tsc", "eslint", "pyright", "ruff", "cargo", "go", "biome"])}`);
         this.logger.info(`Available test runners: ${probeList(["vitest", "jest", "pytest", "cargo", "go"])}`);
         // 2. Initialize Claude driver and orchestrator (if configured)
-        if (this.config.claudeDriver !== "none") {
-            const driver = createDriver(this.config.claudeDriver, this.config.claudeBinary, this.config.antBinary, (msg) => this.logger.info(msg));
+        if (this.config.driver !== "none") {
+            const driver = createDriver(this.config.driver, {
+                binary: this.config.claudeBinary,
+                antBinary: this.config.antBinary,
+                // Provided to all subprocess-style drivers (claude, gemini). The
+                // claude SubprocessDriver only injects --mcp-config when the spawned
+                // task sets providerOptions.mcpAccess=true (per-recipe-step opt-in).
+                // Gemini wires it unconditionally into ~/.gemini/settings.json.
+                bridgeMcp: () => this.port > 0
+                    ? {
+                        url: `http://127.0.0.1:${this.port}/mcp`,
+                        authToken: this.authToken,
+                    }
+                    : undefined,
+            }, (msg) => this.logger.info(msg));
             // Patchwork: enrichment link log is useful regardless of orchestrator.
             const patchworkDir = path.join(os.homedir(), ".patchwork");
             this.commitIssueLinkLog = new CommitIssueLinkLog({
@@ -764,17 +822,33 @@ export class Bridge {
                     },
                 });
                 this.logger.info(`[bridge] Claude driver: ${driver.name}`);
-                // Patchwork: start cron-trigger scheduler once the orchestrator exists.
+                // Recipe orchestrator — owns in-flight dedup across all entry paths.
+                this.recipeOrchestrator = new RecipeOrchestrator({
+                    workdir: this.config.workspace,
+                });
+                // Patchwork: wire recipe server fns + build cron scheduler.
                 const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
-                this.recipeScheduler = new RecipeScheduler({
+                // One-shot scan for legacy `<name>.permissions.json` sidecars (alpha.36+
+                // no longer generates them). Skipped under NODE_ENV=test.
+                warnAboutLegacyPermissionsSidecars(recipesDir);
+                this.recipeOrchestration = new RecipeOrchestration({
+                    server: this.server,
+                    getOrchestrator: () => this.orchestrator,
+                    recipeOrchestrator: this.recipeOrchestrator,
+                    recipeRunLog: this.recipeRunLog,
+                    activityLog: this.activityLog,
+                    workdir: this.config.workspace,
+                    logger: this.logger,
+                });
+                this.recipeOrchestration.wireServerFns();
+                this.recipeScheduler = RecipeOrchestration.buildScheduler({
                     recipesDir,
-                    enqueue: (opts) => this.orchestrator.enqueue(opts),
+                    runRecipeFn: async (name) => this.server.runRecipeFn?.(name),
+                    enqueue: (opts) => this.orchestrator?.enqueue(opts) ?? "",
                     logger: this.logger,
                 });
-                const scheduled = this.recipeScheduler.start();
-                if (scheduled.length > 0) {
-                    this.logger.info(`[patchwork] scheduled ${scheduled.length} cron recipe${scheduled.length === 1 ? "" : "s"}`);
-                }
+                // scheduler.start() deferred to after this.port is set (see below)
+                // so bridgeMcp callback has a valid port when first cron fires.
             }
         }
         if (this.config.automationEnabled) {
@@ -808,6 +882,7 @@ export class Bridge {
                 extensionCircuitBreaker: this.extensionClient.getCircuitBreakerState(),
                 extensionDisconnectCount: this.extensionDisconnectCount,
                 recentActivity: this.activityLog.query({ last: 10 }),
+                tokens: this.tokenUsageTracker.getTotals(),
             };
         };
         this.server.metricsFn = () => this.activityLog.toPrometheus({
@@ -974,6 +1049,37 @@ export class Bridge {
             };
         };
         this.server.streamFn = (listener) => this.activityLog.subscribe(listener);
+        this.server.cancelTaskFn = (id) => this.orchestrator?.cancel(id, "user") ?? false;
+        // Wire `/sessions` for the dashboard's Sessions page. The same Map is
+        // already iterated by `statusFn` for the bridge-status payload — exposing
+        // it as a list-only endpoint lets the dashboard render per-session cards
+        // without coupling to the rest of the status payload. Without this the
+        // page returns 404 forever (sessionsFn was declared but never assigned),
+        // even when sessions are connected.
+        this.server.sessionsFn = () => {
+            const approvals = getApprovalQueue().list();
+            const pendingBySession = new Map();
+            for (const a of approvals) {
+                if (!a.sessionId)
+                    continue;
+                // Match by 8-char prefix because the dashboard's session id is
+                // the same prefix shape (statusFn emits `s.id.slice(0, 8)`).
+                const prefix = a.sessionId.slice(0, 8);
+                pendingBySession.set(prefix, (pendingBySession.get(prefix) ?? 0) + 1);
+            }
+            const out = [];
+            for (const s of this.sessions.values()) {
+                const id = s.id.slice(0, 8);
+                out.push({
+                    id,
+                    connectedAt: new Date(s.connectedAt).toISOString(),
+                    openedFileCount: s.openedFiles.size,
+                    pendingApprovals: pendingBySession.get(id) ?? 0,
+                    ...(s.remoteAddr ? { remoteAddr: s.remoteAddr } : {}),
+                });
+            }
+            return out;
+        };
         this.server.tasksFn = () => ({
             tasks: (this.orchestrator?.list() ?? []).map((t) => ({
                 taskId: t.id,
@@ -1000,134 +1106,21 @@ export class Bridge {
         this.server.approvalWebhookUrl =
             this.config.approvalWebhookUrl ?? undefined;
         this.server.onApprovalDecision = (event, meta) => this.activityLog.recordEvent(event, meta);
-        this.server.recipesFn = () => {
-            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
-            return listInstalledRecipes(recipesDir);
-        };
-        this.server.saveRecipeFn = (draft) => {
-            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
-            return saveRecipe(recipesDir, draft);
-        };
-        this.server.runsFn = (q) => {
-            if (!this.recipeRunLog)
-                return [];
-            return this.recipeRunLog.query({
-                ...(q.limit !== undefined && { limit: q.limit }),
-                ...(q.trigger !== undefined && {
-                    trigger: q.trigger,
-                }),
-                ...(q.status !== undefined && {
-                    status: q.status,
-                }),
-                ...(q.recipe !== undefined && { recipe: q.recipe }),
-                ...(q.after !== undefined && { after: q.after }),
-            });
-        };
-        this.server.sessionsFn = () => [...this.sessions.values()].map((s) => {
-            const tools = this.activityLog.querySessionTools(s.id, 1);
-            return {
-                id: s.id,
-                connectedAt: new Date(s.connectedAt).toISOString(),
-                openedFileCount: s.openedFiles.size,
-                pendingApprovals: getApprovalQueue()
-                    .list()
-                    .filter((a) => a.sessionId === s.id).length,
-                firstTool: tools[0]?.tool,
-                remoteAddr: s.remoteAddr,
-            };
-        });
-        this.server.sessionDetailFn = (id) => {
-            const s = this.sessions.get(id);
-            const summary = s
-                ? {
-                    id: s.id,
-                    connectedAt: new Date(s.connectedAt).toISOString(),
-                    openedFileCount: s.openedFiles.size,
-                    pendingApprovals: getApprovalQueue()
-                        .list()
-                        .filter((a) => a.sessionId === s.id).length,
-                }
-                : null;
-            const lifecycle = this.activityLog.querySessionLifecycle(id, 100);
-            const tools = this.activityLog.querySessionTools(id, 100);
-            const decisions = this.decisionTraceLog?.query({ sessionId: id, limit: 50 }) ?? [];
-            const approvals = getApprovalQueue()
-                .list()
-                .filter((a) => a.sessionId === id);
-            return {
-                summary,
-                lifecycle: lifecycle,
-                tools: tools,
-                decisions: decisions,
-                approvals: approvals,
-            };
-        };
-        this.server.webhookFn = async (hookPath, payload) => {
-            if (!this.orchestrator) {
-                return {
-                    ok: false,
-                    error: "orchestrator_unavailable",
-                };
-            }
-            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
-            const match = findWebhookRecipe(recipesDir, hookPath);
-            if (!match) {
-                return { ok: false, error: "not_found" };
-            }
-            const loaded = loadRecipePrompt(recipesDir, match.name);
-            if (!loaded) {
-                return { ok: false, error: "recipe_file_missing" };
-            }
-            try {
-                const taskId = this.orchestrator.enqueue({
-                    prompt: renderWebhookPrompt(loaded.prompt, payload),
-                    triggerSource: `webhook:${match.name}`,
-                });
-                return { ok: true, taskId, name: match.name };
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    error: err instanceof Error ? err.message : String(err),
-                };
-            }
-        };
-        this.server.runRecipeFn = async (name, vars) => {
-            if (!this.orchestrator) {
-                return {
-                    ok: false,
-                    error: "Orchestrator unavailable — start bridge with --claude-driver subprocess",
-                };
-            }
-            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
-            const loaded = loadRecipePrompt(recipesDir, name);
-            if (!loaded) {
-                return {
-                    ok: false,
-                    error: `Recipe "${name}" not found in ${recipesDir}`,
-                };
-            }
-            try {
-                let prompt = loaded.prompt;
-                if (vars && Object.keys(vars).length > 0) {
-                    const varLines = Object.entries(vars)
-                        .map(([k, v]) => `${k}=${v}`)
-                        .join("\n");
-                    prompt = `Variables:\n${varLines}\n\n${prompt}`;
-                }
-                const taskId = this.orchestrator.enqueue({
-                    prompt,
-                    triggerSource: `recipe:${name}`,
-                });
-                return { ok: true, taskId };
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    error: err instanceof Error ? err.message : String(err),
-                };
-            }
-        };
+        // Wire activityLog into approvalHttp so passive risk personalization
+        // signals (src/approvalSignals.ts) actually compute against the
+        // user's history. Without this, the personalSignals catalog is
+        // defined but inert — every approval queue entry has
+        // personalSignals: undefined.
+        this.server.activityLog = this.activityLog;
+        // Same wire pattern for h6 (recipe-step trust). recipeRunLog may be
+        // undefined when no orchestrator is configured; that's fine — h6
+        // silently skips and the other 11 heuristics still compute.
+        this.server.recipeRunLog = this.recipeRunLog ?? undefined;
+        // Opt-in switch for personalSignals h10 (time-of-day anomaly).
+        // Default false; user enables via --enable-time-of-day-anomaly or
+        // ~/.patchwork/config.json's enableTimeOfDayAnomaly field.
+        this.server.enableTimeOfDayAnomaly =
+            this.config.enableTimeOfDayAnomaly ?? false;
         this.server.readyFn = () => {
             // Count tools from the first active session (all sessions share the same tool set)
             const anySession = [...this.sessions.values()][0];
@@ -1165,15 +1158,29 @@ export class Bridge {
                 extension: this.extensionClient.isConnected(),
                 extensionCircuitBreaker: this.extensionClient.getCircuitBreakerState(),
                 timeline: this.activityLog.queryTimeline({ last: 50 }),
-                patchwork: {
-                    workspace: this.config.workspace,
-                    approvalGate: this.server.approvalGate,
-                    fullMode: this.config.fullMode,
-                    claudeDriver: this.config.claudeDriver,
-                    automationEnabled: this.config.automationEnabled,
-                    port: this.port,
-                    webhookUrl: this.server.approvalWebhookUrl ?? null,
-                },
+                patchwork: (() => {
+                    const cfg = loadPatchworkConfig();
+                    return {
+                        workspace: this.config.workspace,
+                        approvalGate: this.server.approvalGate,
+                        enableTimeOfDayAnomaly: this.server.enableTimeOfDayAnomaly,
+                        fullMode: this.config.fullMode,
+                        driver: this.config.driver,
+                        model: cfg.model,
+                        localEndpoint: cfg.localEndpoint,
+                        localModel: cfg.localModel,
+                        automationEnabled: this.config.automationEnabled,
+                        port: this.port,
+                        httpPort: this.port,
+                        inboxDir: path.join(os.homedir(), ".patchwork", "inbox"),
+                        configPath: defaultConfigPath(),
+                        apiKeysPresent: getApiKeysPresent(),
+                        webhookUrl: this.server.approvalWebhookUrl ?? null,
+                        pushServiceUrl: this.server.pushServiceUrl ?? null,
+                        pushServiceToken: this.server.pushServiceToken ? "***" : null,
+                        pushServiceBaseUrl: this.server.pushServiceBaseUrl ?? null,
+                    };
+                })(),
             };
         };
         // 3b-notify. Wire CC hook notify endpoint
@@ -1259,6 +1266,31 @@ export class Bridge {
             : null, async () => {
             await this.refreshRecentTracesDigest();
             return this.buildInstructions();
+        }, 
+        // Tail-end deps so `registerAllTools` registers the same tool set
+        // on Streamable-HTTP sessions as on WebSocket. Without this object,
+        // `ctxSaveTrace`, `ctxQueryTraces`, and any tool gated on the
+        // remaining deps silently failed to register over Streamable HTTP
+        // (caught dogfooding `ctx-loop-test` from a remote MCP client).
+        {
+            automationHooks: this.automationHooks,
+            getDisconnectInfo: () => ({
+                at: this.lastDisconnectAt,
+                code: this.lastDisconnectCode,
+                reason: this.lastDisconnectReason,
+            }),
+            onContextCacheUpdated: (generatedAt) => {
+                this._lastContextCachedAt = generatedAt;
+                this._emitLiveState();
+            },
+            getExtensionDisconnectCount: () => this.extensionDisconnectCount,
+            ...(this.commitIssueLinkLog && {
+                commitIssueLinkLog: this.commitIssueLinkLog,
+            }),
+            ...(this.recipeRunLog && { recipeRunLog: this.recipeRunLog }),
+            ...(this.decisionTraceLog && {
+                decisionTraceLog: this.decisionTraceLog,
+            }),
         });
         this.server.httpMcpHandler = (req, res) => this.httpMcpHandler?.handle(req, res) ?? Promise.resolve();
         // 3. Check for stale lock files
@@ -1275,6 +1307,13 @@ export class Bridge {
             throw err;
         }
         this.port = port;
+        // 4a-deferred. Start recipe scheduler now that port is known (bridgeMcp needs a valid port).
+        if (this.recipeScheduler) {
+            const scheduled = this.recipeScheduler.start();
+            if (scheduled.length > 0) {
+                this.logger.info(`[patchwork] scheduled ${scheduled.length} cron recipe${scheduled.length === 1 ? "" : "s"}`);
+            }
+        }
         // 4b. Start WebSocket keepalive heartbeat (keeps MCP session alive during long idle periods)
         this._startWsHeartbeat();
         // 4c. Load persisted tasks from previous sessions (best-effort)
@@ -1438,6 +1477,7 @@ export class Bridge {
         this.stopped = true;
         this.logger.info("Shutting down...");
         this._stopPeriodicSnapshots();
+        this.tokenUsageTracker.stop();
         this.automationHooks?.destroy();
         this.recipeScheduler?.stop();
         this.recipeScheduler = null;
@@ -1471,7 +1511,7 @@ export class Bridge {
         if (this.checkpoint && this.port > 0) {
             try {
                 await Promise.race([
-                    Promise.resolve().then(() => this.checkpoint.write(this._buildCheckpoint(this.port))),
+                    Promise.resolve().then(() => this.checkpoint?.write(this._buildCheckpoint(this.port))),
                     new Promise((resolve) => setTimeout(resolve, 3000)),
                 ]);
             }
@@ -1495,7 +1535,8 @@ export class Bridge {
         if (analyticsOn === true && totalSessions > 0) {
             try {
                 const entries = this.activityLog.query({ last: 500 });
-                const summary = buildSummary(entries, maxDurationMs, PACKAGE_VERSION);
+                const salt = getAnalyticsSalt();
+                const summary = buildSummary(entries, maxDurationMs, PACKAGE_VERSION, salt);
                 await Promise.race([
                     sendAnalytics(summary),
                     new Promise((resolve) => setTimeout(resolve, 2000)),