@rynx-ai/runtime 0.1.11-beta.25 → 0.1.11-beta.26

package/dist/input-resources.d.ts

@@ -3,6 +3,10 @@ import type { UserInput } from "./codex-app-server/protocol.js";
 /** Convert the provider-native user echo back to resource references. Unknown
  * local paths and remote URLs are deliberately omitted rather than exposed. */
 export declare function codexUserContent(input: readonly UserInput[]): UserContentPart[];
+/** Match the forwarder's public user echo shape exactly. Codex merges adjacent
+ * text inputs (including the internal file marker) into one string before the
+ * Host sees the completed userMessage item. */
+export declare function codexUserEchoContent(input: readonly UserInput[]): string | UserContentPart[] | undefined;
 /** Claude's native TUI has no structured image RPC. The target daemon supplies
  * only managed local paths and the marker makes the transcript echo reversible. */
 export declare function claudeInputText(input: RuntimeUserInput, attachmentToken?: string): string;

package/dist/input-resources.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { basename, extname } from "node:path";
 const CLAUDE_ATTACHMENT_TOKEN = "RYNX_ATTACHMENT_SET";
-const CLAUDE_ATTACHMENT_TOKEN_RE = /^\[RYNX_ATTACHMENT_SET (att_[0-9a-f-]{36}): inspect each RYNX_IMAGE_RESOURCE path with the Read tool before answering\.\]$/m;
+const CLAUDE_ATTACHMENT_TOKEN_RE = /^\[RYNX_ATTACHMENT_SET (att_[0-9a-f-]{36}): inspect each RYNX_IMAGE_RESOURCE or RYNX_FILE_RESOURCE path with the Read tool before answering\.\]$/m;
 /** Convert the provider-native user echo back to resource references. Unknown
  * local paths and remote URLs are deliberately omitted rather than exposed. */
 export function codexUserContent(input) {
@@ -20,21 +20,37 @@ export function codexUserContent(input) {
     }
     return parts;
 }
+/** Match the forwarder's public user echo shape exactly. Codex merges adjacent
+ * text inputs (including the internal file marker) into one string before the
+ * Host sees the completed userMessage item. */
+export function codexUserEchoContent(input) {
+    const parts = codexUserContent(input);
+    if (parts.length === 0)
+        return undefined;
+    if (parts.every((part) => part.type === "input_text")) {
+        const text = parts.map((part) => part.text).join("").trim();
+        return text || undefined;
+    }
+    return parts;
+}
 /** Claude's native TUI has no structured image RPC. The target daemon supplies
  * only managed local paths and the marker makes the transcript echo reversible. */
 export function claudeInputText(input, attachmentToken = `att_${randomUUID()}`) {
-    const images = input.content.filter((part) => part.type === "local_image");
+    const attachments = input.content.filter((part) => part.type !== "text");
     const text = input.content
         .filter((part) => part.type === "text")
         .map((part) => part.text)
         .join("");
-    if (images.length === 0)
+    if (attachments.length === 0)
         return text;
     if (!/^att_[0-9a-f-]{36}$/.test(attachmentToken)) {
         throw new Error("Claude attachment token is invalid");
     }
-    const preamble = `[${CLAUDE_ATTACHMENT_TOKEN} ${attachmentToken}: inspect each RYNX_IMAGE_RESOURCE path with the Read tool before answering.]`;
-    const markers = images.map((part) => `[[RYNX_IMAGE_RESOURCE ${JSON.stringify({ path: part.path })}]]`);
+    const preamble = `[${CLAUDE_ATTACHMENT_TOKEN} ${attachmentToken}: inspect each RYNX_IMAGE_RESOURCE or RYNX_FILE_RESOURCE path with the Read tool before answering.]`;
+    const markers = attachments.map((part) => `[[RYNX_${part.type === "local_image" ? "IMAGE" : "FILE"}_RESOURCE ${JSON.stringify({
+        path: part.path,
+        ...(part.resource.filename ? { filename: part.resource.filename } : {}),
+    })}]]`);
     return [preamble, ...markers, text]
         .filter((part, index) => index <= markers.length || part.length > 0)
         .join("\n");

package/dist/runner/child.d.ts

@@ -1,12 +1,3 @@
-/**
- * Child-side runner session. One per runner process (i.e. per session); owns the
- * single execution backend via the injected executor (a {@link LocalAgentHost}
- * in production, which in a per-session process holds exactly one backend). It
- * translates inbound {@link ToChild} control messages into the live co-drive
- * surface (bring up the session's forwarder + TUI, inject / interrupt turns) and
- * per-thread capabilities, answered against the same backend so the parent never
- * needs an app-server of its own.
- */
 import { type AgentCapabilities, type LiveSessionFailure, type ResolvedExecutionSnapshot, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import type { SessionEvent } from "@rynx-ai/core";
 import type { TerminalInjector } from "../claude/native-integration.js";
@@ -95,6 +86,8 @@ export declare class RunnerSession {
     private readonly cancelledTerminalOpens;
     /** Session ids with a live codex forwarder started here (stopped on shutdown). */
     private readonly liveIds;
+    private mirrorQueue;
+    private readonly mirrorImageAcks;
     /** Provider name retained for asynchronous Terminal-exit diagnostics. */
     private readonly liveRuntimes;
     private shuttingDown;
@@ -108,6 +101,10 @@ export declare class RunnerSession {
      *  new session AND tells the daemon to alias the runner (terminal transfer) so
      *  the new session stays injectable. */
     private mirrorChannel;
+    private enqueueMirror;
+    private sendMirroredEvent;
+    private sendMirrorImageFrame;
+    private rejectMirrorImageAcks;
     /**
      * Eagerly bring up a session's codex-native live view. Fresh sessions connect
      * the discovery listener before launching the detached TUI; known-thread

package/dist/runner/child.js

@@ -7,9 +7,10 @@
  * per-thread capabilities, answered against the same backend so the parent never
  * needs an app-server of its own.
  */
+import { randomUUID } from "node:crypto";
 import { AgentRuntimeError, } from "@rynx-ai/core";
 import { TerminalRegistry } from "../terminal/registry.js";
-import { toWireError, } from "./protocol.js";
+import { RUNNER_IMAGE_CHUNK_CHARS, RUNNER_IMAGE_MAX_RESULT_CHARS, toWireError, } from "./protocol.js";
 import { isCodexLineageProvider } from "./startup-policy.js";
 /** Maximum time for a fresh Codex-lineage TUI to publish its native thread. */
 const CODEX_THREAD_START_TIMEOUT_MS = 30_000;
@@ -48,6 +49,7 @@ const TRAEX_STARTUP_POLL_MS = 100;
 const TRAEX_AUTHORIZATION_POLL_MS = 500;
 const TRAEX_AUTHORIZATION_WAIT_MS = 15 * 60_000;
 const TRAEX_PROMPT_RETRY_MS = 500;
+const MIRROR_IMAGE_ACK_TIMEOUT_MS = 30_000;
 function normalizeTraexPane(pane) {
     return pane.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -63,6 +65,48 @@ function isTerminalProtocolResponse(input) {
     // Neither is evidence that the user has taken over startup prompt handling.
     return /^(?:\x1b\[(?:(?:\?|>)[0-9;]*c|[0-9;]*(?:n|R|t)|[IO])|\x1b\][0-9]+;[^\x07\x1b]*(?:\x07|\x1b\\))+$/.test(input);
 }
+function detachGeneratedImageResult(event) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return undefined;
+    }
+    const data = event.item.data;
+    const pending = data.__rynxGeneratedImage;
+    if (!pending?.result)
+        return undefined;
+    const { result, ...withoutResult } = pending;
+    return {
+        result,
+        event: {
+            ...event,
+            item: {
+                ...event.item,
+                data: {
+                    ...data,
+                    __rynxGeneratedImage: withoutResult,
+                },
+            },
+        },
+    };
+}
+function generatedImagePreviewUnavailable(event) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return event;
+    }
+    const data = event.item.data;
+    const { __rynxGeneratedImage: _omitted, ...publicData } = data;
+    return {
+        ...event,
+        item: {
+            ...event.item,
+            data: {
+                ...publicData,
+                output: `${event.item.data.output}\nImage preview unavailable.`.trim(),
+            },
+        },
+    };
+}
 export class RunnerSession {
     transport;
     executor;
@@ -78,6 +122,8 @@ export class RunnerSession {
     cancelledTerminalOpens = new Set();
     /** Session ids with a live codex forwarder started here (stopped on shutdown). */
     liveIds = new Set();
+    mirrorQueue = Promise.resolve();
+    mirrorImageAcks = new Map();
     /** Provider name retained for asynchronous Terminal-exit diagnostics. */
     liveRuntimes = new Map();
     shuttingDown = false;
@@ -90,10 +136,36 @@ export class RunnerSession {
                     transport.close();
                 });
         this.transport.onMessage((msg) => this.handle(msg));
+        this.transport.onClose((error) => {
+            this.rejectMirrorImageAcks(error ?? new Error("runner transport closed"));
+        });
         this.transport.send({ t: "ready" });
     }
     handle(msg) {
         switch (msg.t) {
+            case "mirror.image.ack": {
+                const pending = this.mirrorImageAcks.get(msg.transferId);
+                if (!pending)
+                    return;
+                if (pending.seq !== msg.seq) {
+                    pending.reject(new Error("generated image acknowledgement sequence changed"));
+                    return;
+                }
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                this.mirrorImageAcks.delete(msg.transferId);
+                pending.resolve();
+                return;
+            }
+            case "mirror.image.hold": {
+                const pending = this.mirrorImageAcks.get(msg.transferId);
+                if (!pending || pending.seq !== msg.seq)
+                    return;
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.timer = undefined;
+                return;
+            }
             case "cap":
                 void this.runCap(msg.capId, msg.name, msg.args);
                 return;
@@ -188,21 +260,92 @@ export class RunnerSession {
      *  the new session stays injectable. */
     mirrorChannel(localThreadId) {
         const target = { id: localThreadId };
-        const emit = (event) => this.transport.send({ t: "mirror", sessionId: target.id, event });
+        const emit = (event) => {
+            const sessionId = target.id;
+            this.enqueueMirror(() => this.sendMirroredEvent(sessionId, event));
+        };
         const retarget = (newId, meta) => {
             target.id = newId;
-            this.transport.send({
-                t: "rotate",
-                from: localThreadId,
-                to: newId,
-                kind: meta.kind,
-                workspace: meta.workspace,
-                execution: meta.execution,
-                ...(meta.parentSessionId ? { parentSessionId: meta.parentSessionId } : {}),
+            this.enqueueMirror(() => {
+                this.transport.send({
+                    t: "rotate",
+                    from: localThreadId,
+                    to: newId,
+                    kind: meta.kind,
+                    workspace: meta.workspace,
+                    execution: meta.execution,
+                    ...(meta.parentSessionId ? { parentSessionId: meta.parentSessionId } : {}),
+                });
             });
         };
         return { emit, retarget };
     }
+    enqueueMirror(operation) {
+        this.mirrorQueue = this.mirrorQueue.then(operation).catch((error) => {
+            if (!this.shuttingDown) {
+                this.rejectMirrorImageAcks(error instanceof Error ? error : new Error(String(error)));
+                this.shutdown();
+            }
+        });
+    }
+    async sendMirroredEvent(sessionId, event) {
+        const detached = detachGeneratedImageResult(event);
+        if (!detached) {
+            this.transport.send({ t: "mirror", sessionId, event });
+            return;
+        }
+        if (detached.result.length > RUNNER_IMAGE_MAX_RESULT_CHARS) {
+            this.transport.send({
+                t: "mirror",
+                sessionId,
+                event: generatedImagePreviewUnavailable(detached.event),
+            });
+            return;
+        }
+        const transferId = `img_${randomUUID()}`;
+        let seq = 0;
+        await this.sendMirrorImageFrame(transferId, seq, {
+            t: "mirror.image.begin",
+            transferId,
+            sessionId,
+            event: detached.event,
+            totalChars: detached.result.length,
+        });
+        for (let offset = 0; offset < detached.result.length; offset += RUNNER_IMAGE_CHUNK_CHARS) {
+            seq += 1;
+            await this.sendMirrorImageFrame(transferId, seq, {
+                t: "mirror.image.chunk",
+                transferId,
+                seq,
+                data: detached.result.slice(offset, offset + RUNNER_IMAGE_CHUNK_CHARS),
+            });
+        }
+        seq += 1;
+        await this.sendMirrorImageFrame(transferId, seq, {
+            t: "mirror.image.commit",
+            transferId,
+            seq,
+        });
+    }
+    sendMirrorImageFrame(transferId, seq, frame) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.mirrorImageAcks.delete(transferId);
+                reject(new Error("generated image transfer acknowledgement timed out"));
+            }, MIRROR_IMAGE_ACK_TIMEOUT_MS);
+            timer.unref?.();
+            this.mirrorImageAcks.set(transferId, { seq, resolve, reject, timer });
+            this.transport.send(frame);
+        });
+    }
+    rejectMirrorImageAcks(error) {
+        for (const pending of this.mirrorImageAcks.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.mirrorImageAcks.clear();
+    }
     /**
      * Eagerly bring up a session's codex-native live view. Fresh sessions connect
      * the discovery listener before launching the detached TUI; known-thread
@@ -626,6 +769,7 @@ export class RunnerSession {
         if (this.shuttingDown)
             return;
         this.shuttingDown = true;
+        this.rejectMirrorImageAcks(new Error("runner is shutting down"));
         this.stopLive();
         this.terminals.closeAll();
         this.liveProvider.finalizeStoppedLiveSessions?.();

package/dist/runner/manager.d.ts

@@ -229,7 +229,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * session's persistent codex forwarder (web- AND TUI-initiated turns). The
      * server wires this to `persistSessionEvent` (bus + canonical log).
      */
-    onMirror(listener: (sessionId: string, event: SessionEvent) => void): void;
+    onMirror(listener: (sessionId: string, event: SessionEvent) => void | Promise<void>): void;
     onCollaborationMode(listener: (sessionId: string, mode: SessionCollaborationMode) => void): void;
     /** Register the sink for session rotations (claude `/clear`·`/fork`): the server
      *  records the new session's meta (carry-over agent/model/title). */
@@ -331,6 +331,8 @@ export declare class RunnerManager implements AgentCapabilities {
     private bufferForkTargetMessage;
     private reservedForkTarget;
     private deliverForkBufferedMessage;
+    private deliverMirrorMessage;
+    private failMirrorImageTransfer;
     private deliverRotateMessage;
     private spawnHandle;
     private onChildMessage;

package/dist/runner/manager.js

@@ -23,7 +23,7 @@ import { AgentRuntimeError, } from "@rynx-ai/core";
 import { listRuntimeModels } from "../models-catalog.js";
 import { probeRuntimeStatus } from "../runtime-status.js";
 import { terminateTmuxServer, tmuxHasAttachedClient, tmuxWindowActivityAt, } from "../terminal/tmux.js";
-import { fromWireError, } from "./protocol.js";
+import { RUNNER_IMAGE_CHUNK_CHARS, RUNNER_IMAGE_MAX_RESULT_CHARS, fromWireError, } from "./protocol.js";
 import { isCodexLineageProvider, isManagedNativeProvider } from "./startup-policy.js";
 import { StdioRunnerTransport } from "./transport.js";
 /** Routing key for the shared capability runner (slash-command RPCs). */
@@ -1081,15 +1081,56 @@ export class RunnerManager {
         if (handle.dead)
             return;
         if (message.t === "mirror") {
-            this.observeHandleRuntimeEvent(handle, message.event);
-            this.mirrorListener?.(message.sessionId, message.event);
-            if (message.event.type === "response.created") {
-                this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
-            }
+            this.deliverMirrorMessage(handle, message);
             return;
         }
         this.deliverRotateMessage(handle, message);
     }
+    deliverMirrorMessage(handle, message) {
+        if (handle.dead)
+            return;
+        if (message.event.type === "session.collaboration_mode") {
+            this.collaborationModeListener?.(message.sessionId, message.event.mode);
+        }
+        this.observeHandleRuntimeEvent(handle, message.event);
+        let delivered;
+        try {
+            delivered = Promise.resolve(this.mirrorListener?.(message.sessionId, message.event));
+        }
+        catch (error) {
+            delivered = Promise.reject(error);
+        }
+        if (message.event.type === "response.created") {
+            // The listener projects response.created into SessionRuntimeIndex
+            // synchronously. Only then may the accepted terminal reservation drain
+            // into a maintenance activity snapshot.
+            this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
+        }
+        if (message.transferId && message.seq !== undefined) {
+            void delivered.then(() => {
+                if (!handle.dead) {
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: message.transferId,
+                        seq: message.seq,
+                    });
+                }
+            }, (error) => {
+                this.failMirrorImageTransfer(handle, `generated image publication failed: ${errorMessage(error)}`);
+            });
+        }
+        else {
+            void delivered.catch((error) => {
+                console.error(`Session mirror publication failed: ${errorMessage(error)}`);
+            });
+        }
+    }
+    failMirrorImageTransfer(handle, reason) {
+        handle.imageTransfers.clear();
+        void this.terminateHandle(handle, reason).catch((error) => {
+            logTerminationFailure(handle, error);
+        });
+    }
     deliverRotateMessage(handle, message) {
         if (this.forkReservations.has(message.to) ||
             this.sourceForkReservations.has(message.from)) {
@@ -1224,6 +1265,7 @@ export class RunnerManager {
             caps: new Map(),
             terminals: new Map(),
             live: new Map(),
+            imageTransfers: new Map(),
         };
         this.childHandles.add(handle);
         void completion.then(() => this.childHandles.delete(handle));
@@ -1282,18 +1324,83 @@ export class RunnerManager {
                     return;
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
-                if (msg.event.type === "session.collaboration_mode") {
-                    this.collaborationModeListener?.(msg.sessionId, msg.event.mode);
+                this.deliverMirrorMessage(handle, msg);
+                return;
+            case "mirror.image.begin": {
+                if (handle.dead ||
+                    handle.imageTransfers.has(msg.transferId) ||
+                    !Number.isSafeInteger(msg.totalChars) ||
+                    msg.totalChars <= 0 ||
+                    msg.totalChars > RUNNER_IMAGE_MAX_RESULT_CHARS ||
+                    !isDetachedGeneratedImageEvent(msg.event)) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer start");
+                    return;
                 }
-                this.observeHandleRuntimeEvent(handle, msg.event);
-                this.mirrorListener?.(msg.sessionId, msg.event);
-                if (msg.event.type === "response.created") {
-                    // The listener projects response.created into SessionRuntimeIndex
-                    // synchronously. Only then may the accepted terminal reservation
-                    // drain into a maintenance activity snapshot.
-                    this.settleTerminalInputHandoff(handle, msg.sessionId, "turn");
+                handle.imageTransfers.set(msg.transferId, {
+                    sessionId: msg.sessionId,
+                    event: msg.event,
+                    totalChars: msg.totalChars,
+                    receivedChars: 0,
+                    nextSeq: 1,
+                    chunks: [],
+                });
+                handle.transport.send({ t: "mirror.image.ack", transferId: msg.transferId, seq: 0 });
+                return;
+            }
+            case "mirror.image.chunk": {
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                if (handle.dead ||
+                    !transfer ||
+                    msg.seq !== transfer.nextSeq ||
+                    !msg.data ||
+                    msg.data.length > RUNNER_IMAGE_CHUNK_CHARS ||
+                    transfer.receivedChars + msg.data.length > transfer.totalChars) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer chunk");
+                    return;
+                }
+                transfer.chunks.push(msg.data);
+                transfer.receivedChars += msg.data.length;
+                transfer.nextSeq += 1;
+                handle.transport.send({
+                    t: "mirror.image.ack",
+                    transferId: msg.transferId,
+                    seq: msg.seq,
+                });
+                return;
+            }
+            case "mirror.image.commit": {
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                if (handle.dead ||
+                    !transfer ||
+                    msg.seq !== transfer.nextSeq ||
+                    transfer.receivedChars !== transfer.totalChars) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer commit");
+                    return;
+                }
+                handle.imageTransfers.delete(msg.transferId);
+                const event = attachGeneratedImageResult(transfer.event, transfer.chunks.join(""));
+                if (!event) {
+                    this.failMirrorImageTransfer(handle, "generated image transfer target changed");
+                    return;
                 }
+                const mirrored = {
+                    t: "mirror",
+                    sessionId: transfer.sessionId,
+                    event,
+                    transferId: msg.transferId,
+                    seq: msg.seq,
+                };
+                if (this.bufferForkTargetMessage(handle, mirrored)) {
+                    handle.transport.send({
+                        t: "mirror.image.hold",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                    });
+                    return;
+                }
+                this.deliverMirrorMessage(handle, mirrored);
                 return;
+            }
             case "rotate": {
                 if (handle.dead)
                     return;
@@ -1368,6 +1475,7 @@ export class RunnerManager {
         handle.caps.clear();
         handle.terminals.clear();
         handle.live.clear();
+        handle.imageTransfers.clear();
         handle.transport.close();
     }
     terminateHandle(handle, reason) {
@@ -1730,6 +1838,36 @@ function closeSessionContext(context) {
         }));
     }
 }
+function isDetachedGeneratedImageEvent(event) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return false;
+    }
+    const data = event.item.data;
+    return Boolean(data.__rynxGeneratedImage && data.__rynxGeneratedImage.result === undefined);
+}
+function attachGeneratedImageResult(event, result) {
+    if (!isDetachedGeneratedImageEvent(event))
+        return undefined;
+    const outputEvent = event;
+    const item = outputEvent.item;
+    if (item.type !== "function_call_output")
+        return undefined;
+    const data = item.data;
+    return {
+        ...outputEvent,
+        item: {
+            ...item,
+            data: {
+                ...data,
+                __rynxGeneratedImage: {
+                    ...data.__rynxGeneratedImage,
+                    result,
+                },
+            },
+        },
+    };
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/runner/protocol.d.ts

@@ -26,6 +26,14 @@ export type TerminalOpenErrorCode = "terminal_not_live" | "terminal_open_failed"
 /** Parent → child. Terminal PTY bytes ride `term.input` base64-encoded so the
  *  NDJSON line framing stays intact (raw bytes contain newlines). */
 export type ToChild = {
+    t: "mirror.image.ack";
+    transferId: string;
+    seq: number;
+} | {
+    t: "mirror.image.hold";
+    transferId: string;
+    seq: number;
+} | {
     t: "cap";
     capId: string;
     name: CapName;
@@ -151,6 +159,24 @@ export type FromChild = {
     t: "mirror";
     sessionId: string;
     event: SessionEvent;
+    /** Parent-local completion marker used after a chunked image is rebuilt. */
+    transferId?: string;
+    seq?: number;
+} | {
+    t: "mirror.image.begin";
+    transferId: string;
+    sessionId: string;
+    event: SessionEvent;
+    totalChars: number;
+} | {
+    t: "mirror.image.chunk";
+    transferId: string;
+    seq: number;
+    data: string;
+} | {
+    t: "mirror.image.commit";
+    transferId: string;
+    seq: number;
 }
 /** The session rotated to a fresh machine-session (claude `/clear`·`/fork`): the
  *  child re-pointed its mirror to `to` and asks the daemon to alias the runner
@@ -205,6 +231,11 @@ export type FromChild = {
     localThreadId: string;
     result: ResolveInteractionResult;
 };
+/** Internal runner wire bounds. Generated images are already subject to the
+ * Session image byte limit; chunks keep the NDJSON pipe and parser bounded and
+ * each chunk is acknowledged before the next is sent. */
+export declare const RUNNER_IMAGE_CHUNK_CHARS: number;
+export declare const RUNNER_IMAGE_MAX_RESULT_CHARS: number;
 /** Encode a message as a single NDJSON line (newline included). */
 export declare function encodeMessage(msg: ToChild | FromChild): string;
 /** Parse one NDJSON line; returns `null` for blank lines or malformed JSON. */

package/dist/runner/protocol.js

@@ -7,6 +7,11 @@
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
 import { AgentRuntimeError, } from "@rynx-ai/core";
+/** Internal runner wire bounds. Generated images are already subject to the
+ * Session image byte limit; chunks keep the NDJSON pipe and parser bounded and
+ * each chunk is acknowledged before the next is sent. */
+export const RUNNER_IMAGE_CHUNK_CHARS = 32 * 1024;
+export const RUNNER_IMAGE_MAX_RESULT_CHARS = 8 * 1024 * 1024;
 /** Encode a message as a single NDJSON line (newline included). */
 export function encodeMessage(msg) {
     return `${JSON.stringify(msg)}\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.25",
+  "version": "0.1.11-beta.26",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,7 +27,7 @@
     "node-pty": "1.2.0-beta.15",
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.25"
+    "@rynx-ai/core": "0.1.11-beta.26"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"