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

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). */
@@ -182,6 +182,9 @@ export class RunnerManager {
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
     mirrorListener = null;
+    /** Synchronous persistence hook for native collaboration-mode reflection.
+     * It runs before the event reaches the Session bus. */
+    collaborationModeListener = null;
     /** Sink for session rotations (claude `/clear`·`/fork`) — server records meta. */
     rotateListener = null;
     /** Session keys with a live codex forwarder — never reaped while present. */
@@ -349,6 +352,9 @@ export class RunnerManager {
     onMirror(listener) {
         this.mirrorListener = listener;
     }
+    onCollaborationMode(listener) {
+        this.collaborationModeListener = listener;
+    }
     /** Register the sink for session rotations (claude `/clear`·`/fork`): the server
      *  records the new session's meta (carry-over agent/model/title). */
     onRotate(listener) {
@@ -623,19 +629,19 @@ export class RunnerManager {
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId, input) {
+    injectMessage(localThreadId, input, options) {
         const admission = this.reserveAdmission();
-        return this.injectMessageAdmitted(localThreadId, input)
+        return this.injectMessageAdmitted(localThreadId, input, options)
             .finally(() => admission.release());
     }
-    injectMessageAdmitted(localThreadId, input) {
+    injectMessageAdmitted(localThreadId, input, options) {
         const sourceReservation = this.sourceForkReservations.get(localThreadId);
         if (sourceReservation) {
-            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input));
+            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input, options));
         }
         const reservation = this.forkReservations.get(localThreadId);
         if (reservation) {
-            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input));
+            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input, options));
         }
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
@@ -670,8 +676,8 @@ export class RunnerManager {
                 resolve(finish());
             });
             handle.transport.send(typeof input === "string"
-                ? { t: "inject", reqId, localThreadId, text: input }
-                : { t: "inject", reqId, localThreadId, input });
+                ? { t: "inject", reqId, localThreadId, text: input, ...(options ? { options } : {}) }
+                : { t: "inject", reqId, localThreadId, input, ...(options ? { options } : {}) });
         });
     }
     /**
@@ -723,6 +729,34 @@ export class RunnerManager {
             });
         });
     }
+    /** Update a loaded Codex-lineage native thread without spawning a runner. */
+    updateCollaborationMode(localThreadId, mode) {
+        const handle = this.handles.get(localThreadId);
+        if (!handle || handle.dead || !this.liveSessionKeys.has(localThreadId)) {
+            return Promise.reject(new AgentRuntimeError("Native Session is not live", 409, "native_session_not_live"));
+        }
+        handle.lastUsedAt = this.now();
+        const reqId = randomUUID();
+        return new Promise((resolve, reject) => {
+            handle.live.set(reqId, (reply) => {
+                if (reply.collaborationUpdated) {
+                    resolve();
+                    return;
+                }
+                reject(fromWireError(reply.error ?? {
+                    message: "Native collaboration mode update failed",
+                    code: "collaboration_mode_update_failed",
+                    statusCode: 503,
+                }));
+            });
+            handle.transport.send({
+                t: "collaboration.update",
+                reqId,
+                localThreadId,
+                mode,
+            });
+        });
+    }
     // ── AgentCapabilities ──────────────────────────────────────────────────────
     async listModels(runtime) {
         return listRuntimeModels(this.config, runtime ?? this.defaultRuntime);
@@ -1047,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)) {
@@ -1190,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));
@@ -1248,15 +1324,83 @@ export class RunnerManager {
                     return;
                 if (this.bufferForkTargetMessage(handle, msg))
                     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");
+                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;
+                }
+                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;
@@ -1275,6 +1419,15 @@ export class RunnerManager {
                     : { ok: msg.ok, error: msg.error });
                 return;
             }
+            case "collaboration.updated": {
+                const resolve = handle.live.get(msg.reqId);
+                handle.live.delete(msg.reqId);
+                resolve?.({
+                    collaborationUpdated: msg.ok,
+                    ...(msg.error ? { error: msg.error } : {}),
+                });
+                return;
+            }
             case "interaction.resolved": {
                 const resolve = handle.live.get(msg.reqId);
                 handle.live.delete(msg.reqId);
@@ -1322,6 +1475,7 @@ export class RunnerManager {
         handle.caps.clear();
         handle.terminals.clear();
         handle.live.clear();
+        handle.imageTransfers.clear();
         handle.transport.close();
     }
     terminateHandle(handle, reason) {
@@ -1684,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

@@ -6,7 +6,7 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { AgentRuntimeError, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 export type { InjectOutcome, InjectResult } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
@@ -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;
@@ -88,6 +96,7 @@ export type ToChild = {
     t: "inject";
     reqId: string;
     localThreadId: string;
+    options?: RuntimeTurnOptions;
 } & ({
     input: RuntimeUserInput;
     text?: never;
@@ -95,6 +104,14 @@ export type ToChild = {
     text: string;
     input?: never;
 }))
+/** Apply a Codex-lineage collaboration mode to an already-loaded native
+ * thread. This control path never starts a runner or waits for a new Turn. */
+ | {
+    t: "collaboration.update";
+    reqId: string;
+    localThreadId: string;
+    mode: SessionCollaborationMode;
+}
 /** Interrupt the session's active turn — the web Stop button. codex: app-server
  *  `turn/interrupt`; claude: an Escape keystroke to the pane. The child replies
  *  `interrupted` (echoing `reqId`). */
@@ -142,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
@@ -184,12 +219,23 @@ export type FromChild = {
     localThreadId: string;
     ok: boolean;
     error?: WireError;
+} | {
+    t: "collaboration.updated";
+    reqId: string;
+    localThreadId: string;
+    ok: boolean;
+    error?: WireError;
 } | {
     t: "interaction.resolved";
     reqId: string;
     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/dist/terminal/registry.js

@@ -59,7 +59,7 @@ export class TerminalRegistry {
         const terminal = this.terminals.get(id);
         if (!terminal)
             return;
-        // Omnigent removes the resource from its registry before best-effort close.
+        // reference implementation removes the resource from its registry before best-effort close.
         this.terminals.delete(id);
         terminal.kill();
     }

package/dist/terminal/tmux.d.ts

@@ -14,7 +14,7 @@ export interface TerminalAttachment {
 /** Result of probing the inner tmux pane. `unknown` is deliberately distinct
  * from `dead`: a timed-out/unexecutable control command is inconclusive;
  * `dead` requires an explicit dead pane. The lifecycle watcher separately
- * mirrors Omnigent's capture failure path for a vanished server/session. */
+ * mirrors reference implementation's capture failure path for a vanished server/session. */
 export type TerminalLiveness = "alive" | "dead" | "unknown";
 /** Minimal node-pty surface (kept local so this module has no type dep on it). */
 interface PtyProcess {
@@ -67,7 +67,7 @@ export declare function tmuxWindowActivityAt(name: string, tmuxBin?: string): Pr
  * This remains authoritative if a parent-side attachment bookkeeping edge was
  * missed during a transport failure. */
 export declare function tmuxHasAttachedClient(name: string, tmuxBin?: string): Promise<boolean>;
-/** Best-effort close of one private tmux server. Mirrors Omnigent's bounded
+/** Best-effort close of one private tmux server. Mirrors reference implementation's bounded
  * `TerminalInstance.close`: attempt `kill-server`, then retire the private
  * socket regardless of command outcome. The registry has already forgotten
  * the resource, so cleanup failure is diagnostic rather than a second
@@ -93,7 +93,7 @@ export declare class TmuxTerminal {
      * out once per attached client. */
     private paneLivenessFlight?;
     /** Shared by lifecycle callers so capture + pane-dead remains one ordered
-     * Omnigent-style observation per Terminal. */
+     * reference implementation-style observation per Terminal. */
     private lifecycleLivenessFlight?;
     constructor(opts: TmuxTerminalOptions);
     /** tmux argv prefix targeting this terminal's private server. */
@@ -138,10 +138,10 @@ export declare class TmuxTerminal {
     /** Async pane-liveness probe — MUST NOT block the event loop. The attach
      *  pane-death watcher polls this on an interval; a synchronous `execFileSync`
      *  there stalls the runner child's event loop (freezing the PTY stream → the
-     *  terminal appears "stuck"). Exactly like Omnigent's definitive pane probe,
+     *  terminal appears "stuck"). Exactly like reference implementation's definitive pane probe,
      *  every command error is `unknown`; only `#{pane_dead}=1` is `dead`. */
     livenessAsync(): Promise<TerminalLiveness>;
-    /** Omnigent's always-on terminal lifecycle watcher first captures the pane:
+    /** reference implementation's always-on terminal lifecycle watcher first captures the pane:
      * a control command that ran and reports the target missing is terminal exit;
      * a probe that cannot spawn is inconclusive. If capture succeeds, the normal
      * definitive `pane_dead` probe distinguishes live from exited. */

package/dist/terminal/tmux.js

@@ -79,7 +79,7 @@ export function tmuxHasAttachedClient(name, tmuxBin = resolveTmuxBin()) {
         });
     });
 }
-/** Best-effort close of one private tmux server. Mirrors Omnigent's bounded
+/** Best-effort close of one private tmux server. Mirrors reference implementation's bounded
  * `TerminalInstance.close`: attempt `kill-server`, then retire the private
  * socket regardless of command outcome. The registry has already forgotten
  * the resource, so cleanup failure is diagnostic rather than a second
@@ -96,7 +96,7 @@ export function terminateTmuxServer(name, tmuxBin = resolveTmuxBin()) {
         });
     }
     catch {
-        // Omnigent treats close as best-effort and still retires the resource.
+        // reference implementation treats close as best-effort and still retires the resource.
     }
     try {
         unlinkSync(socketPath);
@@ -146,7 +146,7 @@ export class TmuxTerminal {
      * out once per attached client. */
     paneLivenessFlight;
     /** Shared by lifecycle callers so capture + pane-dead remains one ordered
-     * Omnigent-style observation per Terminal. */
+     * reference implementation-style observation per Terminal. */
     lifecycleLivenessFlight;
     constructor(opts) {
         this.name = opts.name;
@@ -285,7 +285,7 @@ export class TmuxTerminal {
     /** Async pane-liveness probe — MUST NOT block the event loop. The attach
      *  pane-death watcher polls this on an interval; a synchronous `execFileSync`
      *  there stalls the runner child's event loop (freezing the PTY stream → the
-     *  terminal appears "stuck"). Exactly like Omnigent's definitive pane probe,
+     *  terminal appears "stuck"). Exactly like reference implementation's definitive pane probe,
      *  every command error is `unknown`; only `#{pane_dead}=1` is `dead`. */
     livenessAsync() {
         if (!this.started)
@@ -320,7 +320,7 @@ export class TmuxTerminal {
         });
         return flight;
     }
-    /** Omnigent's always-on terminal lifecycle watcher first captures the pane:
+    /** reference implementation's always-on terminal lifecycle watcher first captures the pane:
      * a control command that ran and reports the target missing is terminal exit;
      * a probe that cannot spawn is inconclusive. If capture succeeds, the normal
      * definitive `pane_dead` probe distinguishes live from exited. */
@@ -340,7 +340,7 @@ export class TmuxTerminal {
                 }
                 this.lastPaneSnapshot = stdout.toString();
                 void this.livenessAsync().then((liveness) => {
-                    // A successful capture proves the target exists. Omnigent treats a
+                    // A successful capture proves the target exists. reference implementation treats a
                     // subsequent pane-dead probe failure as non-dead for this tick.
                     resolve(liveness === "dead" ? "dead" : "alive");
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.24",
+  "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.24"
+    "@rynx-ai/core": "0.1.11-beta.26"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"