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

package/dist/runner/child.d.ts

@@ -7,7 +7,7 @@
  * 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 RuntimeUserInput, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+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";
 import type { ResolveInteractionResult } from "../interactions.js";
@@ -54,15 +54,17 @@ interface LiveCodexProvider {
      * observer/forwarder, and evict the owned app-server while preserving the
      * durable native-session binding for a later cold resume. */
     teardownLiveCodexSession?(localThreadId: string, error?: Error): boolean;
-    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
+    injectMessage?(localThreadId: string, input: RuntimeUserInput | string, options?: RuntimeTurnOptions): Promise<InjectResult>;
+    updateCollaborationMode?(localThreadId: string, mode: SessionCollaborationMode): Promise<void>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;
     }): void;
     finalizeStoppedLiveSessions?(): void;
     resolveInteraction?(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
-    /** claude-native: hand the session's tmux pane injector to the host (which
-     *  doesn't own tmux). No-op for codex sessions (they inject via app-server). */
+    /** Hand the session's tmux pane injector to the host (which doesn't own
+     * tmux). Claude uses it for messages; Codex uses it only for TUI-local
+     * controls that the app-server cannot resolve, such as the final Plan picker. */
     attachTerminalInjector?(localThreadId: string, injector: TerminalInjector): void;
     /** Internal Provider operation used only by MachineSessionService through
      * RunnerManager. It is deliberately absent from public AgentCapabilities. */
@@ -120,6 +122,7 @@ export declare class RunnerSession {
      * already-rejected readiness promise. */
     private failCodexThreadStartup;
     private inject;
+    private updateCollaborationMode;
     private interruptLive;
     /** Launch (idempotently) the session's codex TUI pane from the executor's
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,

package/dist/runner/child.js

@@ -149,6 +149,9 @@ export class RunnerSession {
             case "inject":
                 void this.inject(msg);
                 return;
+            case "collaboration.update":
+                void this.updateCollaborationMode(msg);
+                return;
             case "live.interrupt":
                 void this.interruptLive(msg);
                 return;
@@ -274,7 +277,7 @@ export class RunnerSession {
                         : nativePhaseError(runtime, "native_terminal_launch_failed", "Terminal failed to launch", error);
                 }
             }
-            // Omnigent's known-thread path launches `codex --remote resume` first,
+            // reference implementation's known-thread path launches `codex --remote resume` first,
             // then creates `_codex_forward_known_thread` as background work. Keep the
             // ordering explicit here: observer connection failure cannot delay or
             // reject cold-resume admission.
@@ -377,7 +380,7 @@ export class RunnerSession {
         const provider = this.liveProvider;
         try {
             const input = msg.input ?? msg.text;
-            const result = (await provider.injectMessage?.(msg.localThreadId, input))
+            const result = (await provider.injectMessage?.(msg.localThreadId, input, msg.options))
                 ?? { outcome: "notLive" };
             // App-server injection is independent of the Terminal TUI startup, so it
             // must not cancel prompt handling for the pane that is still starting.
@@ -413,6 +416,29 @@ export class RunnerSession {
             });
         }
     }
+    async updateCollaborationMode(msg) {
+        try {
+            if (!this.liveProvider.updateCollaborationMode) {
+                throw new AgentRuntimeError("Native collaboration mode is unavailable", 409, "collaboration_mode_unavailable");
+            }
+            await this.liveProvider.updateCollaborationMode(msg.localThreadId, msg.mode);
+            this.transport.send({
+                t: "collaboration.updated",
+                reqId: msg.reqId,
+                localThreadId: msg.localThreadId,
+                ok: true,
+            });
+        }
+        catch (error) {
+            this.transport.send({
+                t: "collaboration.updated",
+                reqId: msg.reqId,
+                localThreadId: msg.localThreadId,
+                ok: false,
+                error: toWireError(error),
+            });
+        }
+    }
     async interruptLive(msg) {
         const provider = this.liveProvider;
         let ok = false;
@@ -472,7 +498,7 @@ export class RunnerSession {
                         ? terminal.isAliveAsync().then((alive) => alive ? "alive" : "dead")
                         : Promise.resolve(terminal.isAlive() ? "alive" : "dead");
             void probe.then((liveness) => {
-                // A failed pane probe is inconclusive. Only Omnigent's lifecycle
+                // A failed pane probe is inconclusive. Only reference implementation's lifecycle
                 // evidence — capture target gone or explicit pane_dead — may fail it.
                 if (liveness !== "dead" ||
                     this.shuttingDown ||

package/dist/runner/manager.d.ts

@@ -16,7 +16,7 @@
  * channel.
  */
 import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
-import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type LiveSessionFailure, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type LiveSessionFailure, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
 import { type CodexSessionStore } from "../host.js";
 import type { ResolveInteractionResult } from "../interactions.js";
 import { type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
@@ -73,7 +73,7 @@ export interface RunnerManagerOptions {
      * created for the runner child, with direct-child fallback. */
     signalChild?: (child: ChildProcess, signal: NodeJS.Signals, processGroup: boolean) => void;
     /** Injected for tests. Best-effort close of the deterministic private tmux
-     * server owned by a Session runner; Omnigent does not verify/retry close. */
+     * server owned by a Session runner; reference implementation does not verify/retry close. */
     terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
     /** Injected tmux `#{window_activity}` reader. Returns epoch seconds. */
     terminalWindowActivityAt?: (terminalName: string) => number | null | Promise<number | null>;
@@ -179,6 +179,9 @@ export declare class RunnerManager implements AgentCapabilities {
     private stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
     private mirrorListener;
+    /** Synchronous persistence hook for native collaboration-mode reflection.
+     * It runs before the event reaches the Session bus. */
+    private collaborationModeListener;
     /** Sink for session rotations (claude `/clear`·`/fork`) — server records meta. */
     private rotateListener;
     /** Session keys with a live codex forwarder — never reaped while present. */
@@ -227,6 +230,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * server wires this to `persistSessionEvent` (bus + canonical log).
      */
     onMirror(listener: (sessionId: string, event: SessionEvent) => 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). */
     onRotate(listener: (rotation: RotateInfo) => void | Promise<void>): void;
@@ -273,7 +277,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * 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: string, input: RuntimeUserInput | string): Promise<InjectResult>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string, options?: RuntimeTurnOptions): Promise<InjectResult>;
     private injectMessageAdmitted;
     /**
      * Interrupt a session's active live turn — the web Stop button (codex
@@ -283,6 +287,8 @@ export declare class RunnerManager implements AgentCapabilities {
     interruptLiveSession(localThreadId: string): Promise<boolean>;
     /** Resolve a native question/approval without ever spawning a new runner. */
     resolveInteraction(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
+    /** Update a loaded Codex-lineage native thread without spawning a runner. */
+    updateCollaborationMode(localThreadId: string, mode: SessionCollaborationMode): Promise<void>;
     listModels(runtime?: AgentRuntimeId): Promise<ModelListResponse | null>;
     getGoal(localThreadId: string): Promise<CapabilityResult<ThreadGoal | null>>;
     setGoal(localThreadId: string, objective: string): Promise<CapabilityResult>;
@@ -340,6 +346,7 @@ export declare class RunnerManager implements AgentCapabilities {
     private isNativePaneBusy;
     private isManagedNativeHandle;
     private failActiveResponses;
+    private interruptActiveResponses;
     /** Track the provider-authoritative response lifecycle. Native-pane busy
      * classification consumes this level directly; output volume is separately
      * grounded in tmux's own activity clock. */

package/dist/runner/manager.js

@@ -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);
@@ -1248,6 +1282,9 @@ 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.observeHandleRuntimeEvent(handle, msg.event);
                 this.mirrorListener?.(msg.sessionId, msg.event);
                 if (msg.event.type === "response.created") {
@@ -1275,6 +1312,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);
@@ -1335,6 +1381,7 @@ export class RunnerManager {
                 catch {
                     // The process signal below remains the authoritative shutdown path.
                 }
+                this.interruptActiveResponses(handle);
                 this.failHandle(handle, reason, { failActiveResponses: false });
             }
             this.signalChild(handle.child, "SIGTERM", handle.processGroup);
@@ -1477,6 +1524,18 @@ export class RunnerManager {
             });
         }
     }
+    interruptActiveResponses(handle) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            this.mirrorListener?.(sessionId, {
+                type: "session.interrupted",
+                sessionId,
+                responseId,
+            });
+        }
+    }
     /** Track the provider-authoritative response lifecycle. Native-pane busy
      * classification consumes this level directly; output volume is separately
      * grounded in tmux's own activity clock. */

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`. */
@@ -88,6 +88,7 @@ export type ToChild = {
     t: "inject";
     reqId: string;
     localThreadId: string;
+    options?: RuntimeTurnOptions;
 } & ({
     input: RuntimeUserInput;
     text?: never;
@@ -95,6 +96,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`). */
@@ -184,6 +193,12 @@ 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;

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.23",
+  "version": "0.1.11-beta.25",
   "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.23"
+    "@rynx-ai/core": "0.1.11-beta.25"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"