@openrig/cli 0.6.11 → 0.6.12

package/daemon/dist/adapters/pi-runner.js

@@ -26,7 +26,10 @@ import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { stripVTControlCharacters } from "node:util";
 import { formatDaemonHostForUrl } from "./daemon-url.js";
-import { piCredentialNotice } from "./pi-readiness.js";
+import { credentialTaint, judgeChargeProvenance, piCredentialEvidence, piCredentialNotice } from "./pi-readiness.js";
+import { extractPiUsageFacts, parsePiSessionHeader, tiesPiForkHeader } from "../domain/pi-usage-facts.js";
+import { OpenRouterChargeLookup, openRouterGenerationFetcher } from "./pi-openrouter-charge.js";
+import { OMP_MAX_FRAME_BYTES, OmpFrameDecoder, ompProtocolV2Limit } from "./omp-rpc-frame.js";
 import { piSeatPaths, buildPiChildArgs, buildPiChildEnv, buildPendingRunnerState, parsePiRunnerState, PI_RUNNER_READY_MARKER, PI_RUNNER_ERROR_MARKER, PI_PROVIDER_ENV_VARS, } from "./pi-runner-protocol.js";
 // ── Submitted input boundaries ─────────────────────────────────────────────
 // Canonical TTY buffers can overflow before Node sees even the paste terminator.
@@ -157,10 +160,11 @@ function piCredentialHint(message) {
         ? ` For managed Pi, set ${key} in the daemon environment and add ${key} to recovery.provider_auth_env_allowlist. Use model ${provider}/<id>, then restart the daemon and relaunch the seat. Default Pi logins are not automatically shared.`
         : " For managed Pi, configure this provider in the seat's PI_CODING_AGENT_DIR (auth.json or models.json). Its key is not in OpenRig's Pi environment passthrough map; default Pi logins are not automatically shared.";
 }
-function errorNotice(detail, runtime) {
-    const text = typeof detail === "string"
+function errorNotice(details, runtime) {
+    // Empty or control-only fields must not hide a later usable diagnostic.
+    const text = details.map(detail => typeof detail === "string"
         ? stripVTControlCharacters(detail).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").replace(/\s+/g, " ").trim()
-        : "";
+        : "").find(Boolean) ?? "";
     const marker = runtime === "omp" ? "[omp-runner] ERROR" : PI_RUNNER_ERROR_MARKER;
     return `${marker} ${text.slice(0, 400) || "request failed"}${runtime === "pi" ? piCredentialHint(text) : ""}`;
 }
@@ -171,12 +175,11 @@ function errorNotice(detail, runtime) {
  *  repeats into one notice per failure. */
 function modelErrorNotice(event, runtime) {
     if (event.type === "auto_retry_end") {
-        return event.success === false ? { errorNotice: errorNotice(event.finalError ?? event.error, runtime) } : {};
+        return event.success === false ? { errorNotice: errorNotice([event.finalError, event.error], runtime) } : {};
     }
     const message = event.message;
     if (message?.role === "assistant" && message.stopReason === "error") {
-        const detail = message.errorMessage ?? message.error ?? event.error;
-        return { errorNotice: errorNotice(detail, runtime) };
+        return { errorNotice: errorNotice([message.errorMessage, message.error, event.error], runtime) };
     }
     return {};
 }
@@ -253,9 +256,76 @@ export function mapPiEvent(event, runtime = "pi") {
 const GET_STATE_ID = "pi-runner-get-state";
 const CATCH_UP_ID = "pi-runner-catch-up";
 const CURSOR_REFRESH_ID = "pi-runner-cursor-refresh";
+const NEGOTIATE_ID = "omp-runner-negotiate";
 /** RPC commands that carry operator input. Their failure means the seat
  *  cannot do the requested work; other command failures are not attention. */
 const INPUT_COMMANDS = { prompt: true, steer: true, follow_up: true };
+/** OPR.0.7.0.2: the largest fork parent read to decide a header tie; a larger parent leaves the tie unknown. */
+const PARENT_SESSION_READ_LIMIT_BYTES = 64 * 1024 * 1024;
+/**
+ * OPR.0.7.0.2: the entry ids of a fork's parent session file, read only to decide a tie with the fork header.
+ * Absence from the result is a claim that the parent doesn't have the entry, so only a complete, valid file
+ * answers: a regular file (checked on the opened handle, opened non-blocking so a FIFO or device can't stall the
+ * runner), at most `limitBytes` actually read from that handle, a session header first, every line a whole
+ * entry with an id, and no torn last line. Anything else is null (the tie stays unknown and is retried). Ids only.
+ */
+export async function readPiSessionEntryIds(path, limitBytes = PARENT_SESSION_READ_LIMIT_BYTES, 
+/** Test seam only: called after the stat and after the read, to change the file at those points. */
+testHooks) {
+    let handle;
+    try {
+        handle = await fs.promises.open(path, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > limitBytes)
+            return null;
+        await testHooks?.afterStat?.();
+        // Complete only with evidence: the read reaches end of file (a read returns 0 bytes) before filling a buffer
+        // one byte larger than the stat, it got exactly the stat's size, and the size is unchanged afterwards. A parent
+        // that grew, shrank or is still being written answers nothing (the tie stays unknown and is read again later).
+        const buffer = Buffer.alloc(stat.size + 1);
+        let length = 0;
+        let reachedEnd = false;
+        while (length < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
+            if (bytesRead === 0) {
+                reachedEnd = true;
+                break;
+            }
+            length += bytesRead;
+        }
+        if (!reachedEnd || length !== stat.size || length === 0)
+            return null;
+        await testHooks?.afterRead?.();
+        if ((await handle.stat()).size !== length)
+            return null;
+        const text = buffer.subarray(0, length).toString("utf8");
+        if (!text.endsWith("\n"))
+            return null; // Pi ends every entry with a newline: a torn or partial write
+        const lines = text.slice(0, -1).split("\n");
+        const ids = new Set();
+        for (const [index, line] of lines.entries()) {
+            const entry = JSON.parse(line); // a malformed line throws: incomplete, so null
+            if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+                return null;
+            const { type, id } = entry;
+            if (index === 0) {
+                if (type !== "session")
+                    return null;
+                continue;
+            }
+            if (typeof id !== "string" || !id)
+                return null;
+            ids.add(id);
+        }
+        return ids;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => { });
+    }
+}
 export class RunnerCore {
     io;
     identity;
@@ -276,6 +346,23 @@ export class RunnerCore {
     /** Set once the daemon confirms it persisted the resume token. */
     identityPersisted = false;
     identityInFlight = false;
+    /** OPR.0.7.0.2: the session header boundary; null until it has been read (read again until it can be). */
+    usageBoundary = null;
+    /** OPR.0.7.0.2 K4: the last credential observation, and each entry's provenance judged when first observed. */
+    lastCredentialEvidence = null;
+    /** Sticky for this process: what an observation showed Pi may have loaded (see credentialTaint). */
+    credentialTainted = null;
+    chargeProvenance = new Map();
+    /** OPR.0.7.0.2: a fork parent read is under way (at most one at a time). */
+    parentReadInFlight = false;
+    /** OPR.0.7.0.2: the last get_entries batch reported, replayed when a parent read completes. */
+    latestUsageEntries = [];
+    /** Entry ids the daemon has accepted with a known origin. Anything else is sent again on the next refresh;
+     *  the daemon stores each (session, entry) once regardless. */
+    postedUsageEntryIds = new Set();
+    /** #1275: OMP protocol v2. The limit offered while negotiating, then the decoder once OMP accepts. */
+    v2Limit = null;
+    frameDecoder = null;
     constructor(io, identity, opts = {}) {
         this.io = io;
         this.identity = identity;
@@ -287,14 +374,25 @@ export class RunnerCore {
     }
     /** Runner readiness is the sidecar's acknowledged get_state, not RPC transport ready. */
     isReady() { return this.ready; }
-    /** Kick off identity capture. Called once pi's RPC stream is up. */
-    start() {
+    /** Kick off identity capture. Called once pi's RPC stream is up; for OMP, with its `ready` frame. */
+    start(ready) {
+        // K4: the first credential observation, before Pi can make any request of this runner's.
+        if (this.opts.openRouterCharge && this.runtime === "pi" && this.io.credentialEvidence) {
+            // The production runner observes before it spawns Pi (launchCredentialEvidence), so Pi loads after it.
+            this.lastCredentialEvidence = this.opts.launchCredentialEvidence ?? this.io.credentialEvidence();
+            this.noteTaint(this.lastCredentialEvidence);
+        }
         // OMP's start is driven by the transport `ready` frame and must run once;
         // Pi keeps main's unconditional start.
         if (this.runtime === "omp") {
             if (this.started)
                 return;
             this.started = true;
+            // #1275: v1 caps a stdout line at 1 MiB, so a longer history fails get_entries. When OMP advertises
+            // protocol v2, negotiate it first: OMP runs commands in order, so the replies below can then arrive chunked.
+            this.v2Limit = ready ? ompProtocolV2Limit(ready) : null;
+            if (this.v2Limit !== null)
+                this.io.sendRpc({ type: "negotiate_protocol", protocolVersion: 2, id: NEGOTIATE_ID });
         }
         this.io.sendRpc({ type: "get_state", id: GET_STATE_ID });
         if (this.opts.catchUpSince) {
@@ -306,27 +404,58 @@ export class RunnerCore {
     }
     /** One LF-delimited JSONL record from pi stdout. */
     handlePiLine(rawLine) {
+        // #1275: under OMP's protocol v2 no stdout line may exceed the 1 MiB physical frame (its LF included); a longer
+        // one is refused before it is parsed. Its chunkId, if any, is read from the line's start only, so the rest of
+        // its sequence isn't reported again.
+        if (this.frameDecoder) {
+            const bytes = Buffer.byteLength(rawLine, "utf8") + 1;
+            if (bytes > OMP_MAX_FRAME_BYTES) {
+                const chunkId = /^\{"type":"rpc_chunk","chunkId":"([^"\\]{1,128})"/.exec(rawLine.slice(0, 200))?.[1];
+                this.reportDroppedFrame(this.frameDecoder.rejectLine(`a ${bytes}-byte line exceeds OMP's ${OMP_MAX_FRAME_BYTES}-byte frame limit`, chunkId));
+                return;
+            }
+        }
         const line = rawLine.trim();
-        if (!line)
+        if (!line) {
+            // Ignored as before, but a blank line still interrupts a pending v2 sequence: OMP never writes one inside it.
+            this.reportDroppedFrame(this.frameDecoder?.interrupt("a blank line"));
             return;
+        }
         let record;
         try {
             const parsed = JSON.parse(line);
-            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                // Not a frame: ignored as before, but it still interrupts a pending v2 sequence.
+                this.reportDroppedFrame(this.frameDecoder?.interrupt(`a ${parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed} line`));
                 return;
+            }
             record = parsed;
         }
         catch {
+            this.reportDroppedFrame(this.frameDecoder?.interrupt("a non-JSON line"));
             // Non-JSON noise on pi stdout — mirror it verbatim so nothing hides.
             this.io.mirrorLine(line);
             return;
         }
+        if (this.frameDecoder) {
+            const result = this.frameDecoder.push(record);
+            if ("dropped" in result)
+                this.reportDroppedFrame(result.dropped);
+            if (!("frame" in result))
+                return;
+            record = result.frame;
+        }
         if (record.type === "response") {
             this.handleResponse(record);
             return;
         }
         this.handleEvent(record);
     }
+    /** A frame that can't be reassembled is lost, and said so. If it was a get_entries reply, the cursor stays where it was. */
+    reportDroppedFrame(reason) {
+        if (reason)
+            this.io.mirrorLine(`[omp-runner] ERROR rpc frame: ${reason}; the chunked frame was dropped`);
+    }
     get runtime() { return this.opts.runtime ?? "pi"; }
     /** One aggregated paste block from pane stdin. */
     handleUserBlock(block) {
@@ -354,11 +483,23 @@ export class RunnerCore {
     /** Child process exit — honest, loud, durable. */
     handlePiExit(code) {
         this.ready = false;
+        this.reportDroppedFrame(this.frameDecoder?.incomplete());
         this.io.mirrorLine(`[${this.runtime}-runner] EXITED ${this.runtime} exited (code ${code ?? "unknown"})`);
         this.writeSidecar({ exited: { code, at: this.io.now() } });
         this.io.postActivity(this.activityPayload("Stop", `${this.runtime}_exited`));
     }
     handleResponse(record) {
+        if (record.id === NEGOTIATE_ID && this.v2Limit !== null) {
+            if (record.success === true) {
+                this.frameDecoder = new OmpFrameDecoder(this.v2Limit);
+            }
+            else {
+                // Advertised but refused: v1 as before, so a reply over 1 MiB still fails, visibly.
+                const detail = typeof record.error === "string" ? record.error : "refused";
+                this.io.mirrorLine(`[omp-runner] RPC protocol v2 not negotiated (${detail}); replies over 1 MiB will fail`);
+            }
+            return;
+        }
         if (record.success === false || record.error != null) {
             const detail = typeof record.error === "string" ? record.error : "request failed";
             const message = detail + (this.runtime === "pi" ? piCredentialHint(detail) : "");
@@ -408,9 +549,86 @@ export class RunnerCore {
                 this.lastEntryId = lastId;
                 this.writeSidecar({});
             }
+            this.reportUsageFacts(entries);
             return;
         }
     }
+    /** OPR.0.7.0.2: report usage from the persisted entries a get_entries response returned (catch-up after a
+     *  restart, or the refresh after each agent_end). Pi only, and only with --usage-facts. Never live updates. */
+    /** K4: what an observation shows Pi may hold for the rest of the process (an extension, a credential-bearing
+     *  models.json entry, or a reading that couldn't be made) is sticky at once. */
+    noteTaint(e) {
+        this.credentialTainted ??= credentialTaint(e)?.sticky ?? null;
+    }
+    reportUsageFacts(entries) {
+        if (!this.opts.usageFacts || this.runtime !== "pi" || !this.io.postUsageFacts)
+            return;
+        if (this.usageBoundary === null) {
+            const firstLine = this.sessionFile && this.io.readFirstLine ? this.io.readFirstLine(this.sessionFile) : null;
+            this.usageBoundary = firstLine ? parsePiSessionHeader(firstLine) : null;
+        }
+        this.latestUsageEntries = entries;
+        const { facts, malformed } = extractPiUsageFacts(entries, this.usageBoundary);
+        if (this.opts.openRouterCharge && this.io.credentialEvidence) {
+            // Each entry's credential is judged once, from the observations before and after it was first seen.
+            const now = this.io.credentialEvidence();
+            this.noteTaint(now);
+            for (const fact of facts) {
+                if (!this.chargeProvenance.has(fact.entryId)) {
+                    this.chargeProvenance.set(fact.entryId, this.credentialTainted
+                        ? { ok: false, reason: this.credentialTainted }
+                        : judgeChargeProvenance(this.lastCredentialEvidence, now, fact.entryTimestamp));
+                }
+            }
+            this.lastCredentialEvidence = now;
+        }
+        // A new entry often shares the fork header's millisecond, and so can a copied one: only the parent session's
+        // entry ids tell them apart. Read them in the background, only when such a tie needs deciding; meanwhile the
+        // tie goes as unknown. A complete answer is kept and these entries are reported again with it; anything
+        // else leaves the tie unknown, to be read again on a later refresh.
+        const boundary = this.usageBoundary;
+        if (boundary?.parentSession && !boundary.parentEntryIds && !this.parentReadInFlight && this.io.readSessionEntryIds
+            && facts.some((fact) => !this.postedUsageEntryIds.has(fact.entryId) && tiesPiForkHeader(fact.entryTimestamp, boundary))) {
+            this.parentReadInFlight = true;
+            void this.io.readSessionEntryIds(boundary.parentSession).then((parentEntryIds) => {
+                this.parentReadInFlight = false;
+                if (!parentEntryIds || this.usageBoundary !== boundary)
+                    return;
+                this.usageBoundary = { ...boundary, parentEntryIds };
+                // The latest batch, so a tie that arrived while the read was under way settles now too.
+                this.reportUsageFacts(this.latestUsageEntries);
+            }, () => { this.parentReadInFlight = false; });
+        }
+        const fresh = facts.filter((fact) => !this.postedUsageEntryIds.has(fact.entryId));
+        if (fresh.length === 0 && malformed === 0)
+            return;
+        void this.io.postUsageFacts({
+            sessionName: this.identity.sessionName,
+            nodeId: this.identity.nodeId,
+            generation: this.identity.generation,
+            piSessionId: this.sessionId,
+            sessionCreatedAt: this.usageBoundary?.createdAt ?? null,
+            forked: this.usageBoundary ? this.usageBoundary.parentSession !== null : null,
+            facts: fresh,
+            malformed,
+            ...(this.opts.openRouterCharge ? { wantCharged: true } : {}),
+        }).then((result) => {
+            // Only a stored fact with a known origin is done: a failed post, or an origin not settled yet (no readable
+            // header, or a tie with an unreadable parent), is sent again with the next refresh (the store upgrades an
+            // unknown origin once it is known).
+            if (result === false)
+                return;
+            for (const fact of fresh)
+                if (fact.origin !== "unknown")
+                    this.postedUsageEntryIds.add(fact.entryId);
+            // K4: the charge is looked up only for facts the daemon has stored, never for one it already has.
+            if (this.opts.openRouterCharge && this.sessionId && this.io.enqueueChargeLookups) {
+                this.io.enqueueChargeLookups(this.sessionId, fresh.map((fact) => ({
+                    fact, provenance: this.chargeProvenance.get(fact.entryId) ?? { ok: false, reason: "its credential wasn't observed" },
+                })), new Set(typeof result === "object" ? result.charged : []));
+            }
+        }, () => { });
+    }
     raiseAttention(subtype) {
         // Runtime failures outrank denied approvals. Only emit when the visible
         // attention changes or intervening activity replaced it.
@@ -598,6 +816,12 @@ export function parseRunnerArgs(argv) {
             case "--fork":
                 args.forkRef = next();
                 break;
+            case "--usage-facts":
+                args.usageFacts = true;
+                break;
+            case "--openrouter-charge":
+                args.openRouterCharge = true;
+                break;
             case "--approve":
                 args.trust = "approve";
                 break;
@@ -815,6 +1039,40 @@ export async function main(argv = process.argv.slice(2)) {
         }
         command = resolved.path;
     }
+    // OPR.0.7.0.2 K4: OpenRouter's charge, looked up with the key this runner forwarded to Pi, only for requests whose
+    // credential is established as that key by the observations before and after them.
+    const readMetadata = (file) => {
+        if (fs.statSync(file).size > 1024 * 1024)
+            throw new Error("Unbounded metadata");
+        return fs.readFileSync(file, "utf8");
+    };
+    const credentialEvidence = () => piCredentialEvidence({
+        agentDir: paths.agentDir, cwd: args.cwd, env: childEnv, now: () => Date.now(), readFile: readMetadata,
+        statId: (file) => {
+            try {
+                const st = fs.statSync(file);
+                return `${st.dev}:${st.ino}:${st.size}:${st.mtimeMs}`;
+            }
+            catch (error) {
+                if (error?.code === "ENOENT")
+                    return "absent";
+                throw error;
+            }
+        },
+        listDir: (dir) => {
+            try {
+                return fs.readdirSync(dir);
+            }
+            catch (error) {
+                if (error?.code === "ENOENT")
+                    return [];
+                throw error;
+            }
+        },
+    });
+    // Observed before Pi is spawned, so whatever Pi loads at its start was there for this observation to see
+    // (or was added after it, and is then seen by the next one).
+    const launchCredentialEvidence = args.openRouterCharge === true && runtime === "pi" ? credentialEvidence() : undefined;
     const child = spawn(command, childArgs, {
         cwd: args.cwd,
         env: childEnv,
@@ -822,6 +1080,28 @@ export async function main(argv = process.argv.slice(2)) {
     });
     // The child may close its pipe before the first RPC write completes.
     child.stdin.on("error", () => { });
+    const chargeLookup = new OpenRouterChargeLookup({
+        fetchGeneration: openRouterGenerationFetcher(() => childEnv["OPENROUTER_API_KEY"]),
+        postCharges: async (piSessionId, charges) => {
+            if (!endpoint || typeof fetch !== "function")
+                return false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            return fetch(new URL("/api/activity/pi-usage-charges", endpoint.baseUrl).toString(), {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${endpoint.token}` },
+                body: JSON.stringify({ sessionName: args.sessionName, nodeId: process.env.OPENRIG_NODE_ID, piSessionId, charges }),
+                signal: controller.signal,
+            }).then(async (res) => {
+                if (!res.ok)
+                    return false;
+                const reply = await res.json().catch(() => null);
+                return new Set(Array.isArray(reply?.acknowledged) ? reply.acknowledged.filter((id) => typeof id === "string") : []);
+            }, () => false).finally(() => clearTimeout(timeout));
+        },
+        schedule: (fn, ms) => { setTimeout(fn, ms).unref(); },
+        notice: (line) => { process.stdout.write(`${line}\n`); },
+    });
     const io = {
         sendRpc: (cmd) => {
             try {
@@ -862,12 +1142,52 @@ export async function main(argv = process.argv.slice(2)) {
         now: () => new Date().toISOString(),
         stopChild: () => { child.kill(); },
         sessionFileExists: (path) => fs.existsSync(path),
+        postUsageFacts: async (payload) => {
+            if (!endpoint || typeof fetch !== "function")
+                return false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            return fetch(new URL("/api/activity/pi-usage", endpoint.baseUrl).toString(), {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${endpoint.token}` },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            }).then(async (res) => {
+                if (!res.ok)
+                    return false;
+                const reply = await res.json().catch(() => null);
+                return { charged: Array.isArray(reply?.charged) ? reply.charged.filter((id) => typeof id === "string") : [] };
+            }, () => false /* best-effort: a later refresh re-sends what wasn't stored */).finally(() => clearTimeout(timeout));
+        },
+        ...(args.openRouterCharge === true && runtime === "pi" ? {
+            enqueueChargeLookups: (piSessionId, items, charged) => chargeLookup.enqueue(piSessionId, items, charged),
+            credentialEvidence,
+        } : {}),
+        readFirstLine: (path) => {
+            try {
+                const fd = fs.openSync(path, "r");
+                try {
+                    const buffer = Buffer.alloc(8192);
+                    const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+                    const text = buffer.subarray(0, read).toString("utf8");
+                    const end = text.indexOf("\n");
+                    return end >= 0 ? text.slice(0, end) : null;
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+            }
+            catch {
+                return null;
+            }
+        },
+        readSessionEntryIds: (path) => readPiSessionEntryIds(path),
     };
     const core = new RunnerCore(io, {
         sessionName: args.sessionName, nodeId: process.env.OPENRIG_NODE_ID, launchId: args.launchId,
         // Carry the emitting tenure; never infer it from a later daemon read or Pi event.
         generation: process.env.OPENRIG_OCCUPANT_GENERATION,
-    }, { catchUpSince, runtime });
+    }, { catchUpSince, runtime, usageFacts: args.usageFacts === true, openRouterCharge: args.openRouterCharge === true, launchCredentialEvidence });
     let transportUp = runtime === "pi";
     readline.createInterface({ input: child.stdout }).on("line", (line) => {
         if (runtime === "omp" && !core.isReady()) {
@@ -875,7 +1195,7 @@ export async function main(argv = process.argv.slice(2)) {
                 const frame = JSON.parse(line);
                 if (frame.type === "ready") {
                     transportUp = true;
-                    core.start();
+                    core.start(frame);
                 }
             }
             catch { /* surface non-JSON stdout through the core */ }