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

package/dist/claude/native-hook-main.js

@@ -176,6 +176,43 @@ function permissionRequest(id, payload, toolInput, suggestions) {
     const toolName = asString(payload.tool_name) ?? "tool";
     const command = asString(toolInput.command) ?? asString(toolInput.file_path);
     const cwd = asString(payload.cwd);
+    if (toolName === "ExitPlanMode") {
+        const plan = asString(toolInput.plan) ?? "Plan details were not provided by Claude.";
+        return {
+            interactionId: id,
+            kind: "permission",
+            title: "Plan review",
+            fields: [{
+                    id: "feedback",
+                    type: "text",
+                    label: "What should change about the plan?",
+                    required: false,
+                    multiline: true,
+                    placeholder: "Revision feedback (optional)",
+                }],
+            actions: [
+                {
+                    id: "allow_auto",
+                    label: "Yes, and use auto mode",
+                    style: "primary",
+                    requiresAnswers: false,
+                },
+                {
+                    id: "allow_manual",
+                    label: "Yes, manually approve edits",
+                    requiresAnswers: false,
+                },
+                {
+                    id: "deny_feedback",
+                    label: "Reject with feedback",
+                    style: "danger",
+                    requiresAnswers: false,
+                },
+            ],
+            context: { toolName, summary: plan },
+            createdAt: Date.now(),
+        };
+    }
     return {
         interactionId: id,
         kind: "permission",
@@ -261,6 +298,31 @@ function nativeVerdict(hookKind, payload, result, suggestions) {
                 },
             };
     }
+    if (toolName === "ExitPlanMode") {
+        const feedback = answerText(resolution.answers?.feedback).trim();
+        const behavior = resolution.actionId === "allow_auto" ||
+            resolution.actionId === "allow_manual"
+            ? "allow"
+            : "deny";
+        return {
+            hookSpecificOutput: {
+                hookEventName: "PermissionRequest",
+                decision: {
+                    behavior,
+                    ...(behavior === "deny" && feedback ? { message: feedback } : {}),
+                    ...(behavior === "allow"
+                        ? {
+                            updatedPermissions: [{
+                                    type: "setMode",
+                                    mode: resolution.actionId === "allow_auto" ? "auto" : "default",
+                                    destination: "session",
+                                }],
+                        }
+                        : {}),
+                },
+            },
+        };
+    }
     const suggestionMatch = /^allow_suggestion_(\d+)$/.exec(resolution.actionId);
     const suggestionIndex = suggestionMatch ? Number(suggestionMatch[1]) : -1;
     const selectedSuggestion = Number.isSafeInteger(suggestionIndex)

package/dist/claude/native-integration.js

@@ -29,7 +29,7 @@ const MAX_SUBMISSION_OBSERVATIONS = 64;
 const INTERACTION_ACK_TIMEOUT_MS = 5_000;
 // Claude writes this synthetic user record after Escape (including a tool-use
 // interruption). It is lifecycle, not a new prompt. Kept aligned with
-// Omnigent's `_CLAUDE_INTERRUPT_RECORD_RE`.
+// reference implementation's `_CLAUDE_INTERRUPT_RECORD_RE`.
 const CLAUDE_INTERRUPT_RECORD_RE = /^\[Request interrupted by user(?: for tool use)?\]$/;
 const INTERACTION_LEASE_TIMEOUT_MS = 30_000;
 function processIsAlive(pid) {

package/dist/codex-app-server/forwarder.d.ts

@@ -24,7 +24,7 @@
 import type { AgentEvent, UserContentPart } from "@rynx-ai/core";
 import type { CodexAppServerClient } from "./client.js";
 import type { McpStartupPlan } from "./mcp-startup.js";
-import type { ResumedTurn } from "./protocol.js";
+import type { CollaborationModeKind, ResumedTurn } from "./protocol.js";
 export interface CodexForwarderSink {
     /** A turn began. `turnId` is codex's turn id, used to derive a stable
      *  `responseId`. Start a fresh normalizer/response. */
@@ -58,6 +58,16 @@ export interface CodexForwarderSink {
     /** The thread showed activity (a turn/item began, so its rollout now exists).
      *  Fired once; lets a parked `thread/resume` retry (reference implementation's ready signal). */
     onThreadActive?(): void;
+    /** The native TUI or another app-server client changed collaboration mode. */
+    onCollaborationModeChanged?(mode: CollaborationModeKind): void;
+    /** Codex's terminal-local Plan picker is not emitted by app-server today.
+     * Synthesize it only after a live Plan item and its Turn both complete. */
+    onPlanImplementationPrompt?(prompt: CodexPlanImplementationPrompt): void;
+}
+export interface CodexPlanImplementationPrompt {
+    threadId: string;
+    turnId: string;
+    text: string;
 }
 export interface CodexSessionForwarderOptions {
     /** Some Codex-lineage runtimes publish the final item one frame after
@@ -101,6 +111,8 @@ export declare class CodexSessionForwarder {
     /** Per-(thread,turn) position counter for items lacking a stable codex id
      *  (peek-then-advance; advanced only on a successful claim). reference implementation anon path. */
     private readonly anonCounters;
+    private pendingPlanImplementation;
+    private replayingBackfill;
     constructor(client: CodexAppServerClient, sink: CodexForwarderSink, options?: CodexSessionForwarderOptions);
     /** Begin mirroring. Idempotent. */
     start(): void;
@@ -136,6 +148,9 @@ export declare class CodexSessionForwarder {
      * not doubled.
      */
     replayBackfill(turns: ResumedTurn[]): void;
+    /** Suppress our synthesized picker when a future app-server emits the native
+     * `plan_implementation` request itself. */
+    noteNativePlanImplementationPrompt(turnId?: string): void;
     /** Fail an open response exactly once when its observer or terminal exits. */
     failOpenTurn(error: Error): boolean;
     private handle;

package/dist/codex-app-server/forwarder.js

@@ -86,6 +86,8 @@ export class CodexSessionForwarder {
     /** Per-(thread,turn) position counter for items lacking a stable codex id
      *  (peek-then-advance; advanced only on a successful claim). reference implementation anon path. */
     anonCounters = new Map();
+    pendingPlanImplementation = null;
+    replayingBackfill = false;
     constructor(client, sink, options = {}) {
         this.client = client;
         this.sink = sink;
@@ -191,22 +193,37 @@ export class CodexSessionForwarder {
      * not doubled.
      */
     replayBackfill(turns) {
-        for (const turn of turns) {
-            const turnId = turn.id ?? turn.turnId;
-            if (turnId)
-                this.currentTurnIdValue = turnId;
-            this.ensureTurn();
-            for (const item of turn.items ?? [])
-                this.processCompletedItem(item);
-            if (codexResumeTerminalStatus(turn) === undefined)
-                continue;
-            const mapped = mapCodexNotification("turn/completed", { turn });
-            this.turnOpen = false;
-            this.currentTurnIdValue = null;
-            if (mapped.fatalError)
-                this.sink.onTurnError(mapped.fatalError);
-            else
-                this.sink.onTurnEnd(mapped.usage);
+        this.replayingBackfill = true;
+        try {
+            for (const turn of turns) {
+                const turnId = turn.id ?? turn.turnId;
+                if (turnId)
+                    this.currentTurnIdValue = turnId;
+                this.ensureTurn();
+                for (const item of turn.items ?? [])
+                    this.processCompletedItem(item);
+                if (codexResumeTerminalStatus(turn) === undefined)
+                    continue;
+                const mapped = mapCodexNotification("turn/completed", { turn });
+                this.turnOpen = false;
+                this.currentTurnIdValue = null;
+                if (mapped.fatalError)
+                    this.sink.onTurnError(mapped.fatalError);
+                else
+                    this.sink.onTurnEnd(mapped.usage);
+            }
+        }
+        finally {
+            this.replayingBackfill = false;
+        }
+    }
+    /** Suppress our synthesized picker when a future app-server emits the native
+     * `plan_implementation` request itself. */
+    noteNativePlanImplementationPrompt(turnId) {
+        if (!this.pendingPlanImplementation)
+            return;
+        if (!turnId || this.pendingPlanImplementation.turnId === turnId) {
+            this.pendingPlanImplementation = null;
         }
     }
     /** Fail an open response exactly once when its observer or terminal exits. */
@@ -248,6 +265,14 @@ export class CodexSessionForwarder {
             this.handleMcpStartupStatus(params);
             return;
         }
+        if (method === "thread/settings/updated") {
+            const threadSettings = params?.threadSettings;
+            const mode = (threadSettings?.collaborationMode ?? threadSettings?.collaboration_mode)?.mode;
+            if (mode === "plan" || mode === "default") {
+                this.sink.onCollaborationModeChanged?.(mode);
+            }
+            return;
+        }
         if (isThreadIdle(method, params) || isModelOutput(method, params)) {
             this.settleMcpStartup();
         }
@@ -400,6 +425,14 @@ export class CodexSessionForwarder {
     }
     settle(completion) {
         this.flushDeferredAssistantMessage();
+        const completedTurnId = this.pendingCompletionTurnId ?? this.currentTurnIdValue;
+        const planPrompt = completion.kind === "end" &&
+            this.pendingPlanImplementation?.turnId === completedTurnId
+            ? this.pendingPlanImplementation
+            : null;
+        if (this.pendingPlanImplementation?.turnId === completedTurnId) {
+            this.pendingPlanImplementation = null;
+        }
         this.turnOpen = false;
         this.currentTurnIdValue = null;
         this.pendingCompletionTurnId = null;
@@ -411,8 +444,11 @@ export class CodexSessionForwarder {
             else
                 this.sink.onTurnEnd(completion.usage);
         }
-        else
+        else {
             this.sink.onTurnEnd(completion.usage);
+            if (planPrompt)
+                this.sink.onPlanImplementationPrompt?.(planPrompt);
+        }
     }
     handleMcpStartupStatus(params) {
         const update = params;
@@ -504,6 +540,14 @@ export class CodexSessionForwarder {
             this.sink.onUserMessage?.(userContent);
             return;
         }
+        if (item.type === "plan" && !this.replayingBackfill) {
+            const text = item.text?.trim();
+            const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId;
+            const threadId = this.currentThreadIdValue;
+            if (text && turnId && threadId) {
+                this.pendingPlanImplementation = { threadId, turnId, text };
+            }
+        }
         const mapped = mapCodexItem("item/completed", item);
         const canonicalEvents = mapped.events.filter((event) => event.type !== "runtime_debug");
         if (canonicalEvents.length === 0)

package/dist/codex-app-server/mapping.js

@@ -208,7 +208,11 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "plan": {
-            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, item } });
+            const text = item.text?.trim() ?? "";
+            if (isEnd && text) {
+                events.push({ type: "message_completed", itemId: item.id, text });
+                return { events, finalText: text };
+            }
             return { events };
         }
         case "reasoning": {
@@ -276,6 +280,17 @@ export function mapCodexNotification(method, params) {
             }
             return { events };
         }
+        case "item/plan/delta": {
+            const delta = typed.params.delta ?? "";
+            if (delta) {
+                events.push({
+                    type: "token",
+                    text: delta,
+                    metadata: { source: "app_server", itemId: typed.params.itemId },
+                });
+            }
+            return { events };
+        }
         case "item/reasoning/summaryTextDelta":
         case "item/reasoning/textDelta": {
             const p = typed.params;

package/dist/codex-app-server/protocol.d.ts

@@ -87,6 +87,16 @@ export interface PermissionProfileModificationParams {
 export type PermissionSelection = string | PermissionProfileSelectionParams;
 /** Open since Codex App Server 0.144; values are advertised by `model/list`. */
 export type ReasoningEffort = string;
+export type CollaborationModeKind = "plan" | "default";
+/** Full Codex-lineage mode snapshot required by the App Server wire protocol. */
+export interface CollaborationMode {
+    mode: CollaborationModeKind;
+    settings: {
+        model: string;
+        reasoning_effort: ReasoningEffort | null;
+        developer_instructions: string | null;
+    };
+}
 export interface ThreadStartParams {
     model?: string | null;
     modelProvider?: string | null;
@@ -102,6 +112,8 @@ export interface ThreadStartParams {
     baseInstructions?: string | null;
     developerInstructions?: string | null;
     ephemeral?: boolean | null;
+    /** Native UI intent for a context-clearing fresh thread. */
+    sessionStartSource?: "clear" | string;
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
@@ -157,6 +169,7 @@ export interface TurnStartParams {
     permissions?: PermissionSelection | null;
     model?: string | null;
     effort?: ReasoningEffort | null;
+    collaborationMode?: CollaborationMode | null;
 }
 export interface TurnInterruptParams {
     threadId: string;
@@ -304,7 +317,7 @@ export interface ThreadSettingsUpdateParams {
     serviceTier?: string | null;
     effort?: ReasoningEffort | null;
     summary?: string | null;
-    collaborationMode?: Record<string, unknown> | null;
+    collaborationMode?: CollaborationMode | null;
     personality?: string | null;
 }
 export interface ModelListParams {
@@ -478,6 +491,14 @@ export interface QueueStatusNotificationParams {
 export type ServerNotification = {
     method: "thread/started";
     params: ThreadStartedNotificationParams;
+} | {
+    method: "thread/settings/updated";
+    params: {
+        threadId: string;
+        threadSettings: {
+            collaborationMode?: CollaborationMode | null;
+        } & Record<string, unknown>;
+    };
 } | {
     method: "turn/started";
     params: TurnStartedNotificationParams;
@@ -499,6 +520,9 @@ export type ServerNotification = {
 } | {
     method: "item/agentMessage/delta";
     params: AgentMessageDeltaNotificationParams;
+} | {
+    method: "item/plan/delta";
+    params: AgentMessageDeltaNotificationParams;
 } | {
     method: "item/reasoning/summaryTextDelta";
     params: ReasoningSummaryTextDeltaNotificationParams;

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeUserInput, type LiveSessionFailure, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
+import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type LiveSessionFailure, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
 import { type AgentRuntimeId } from "@rynx-ai/core";
 import { type AppConfig } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
@@ -189,6 +189,13 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private createAppServerClient;
     /** Resolve a pending native question/approval without opening a new Turn. */
     resolveInteraction(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
+    /** Apply collaboration mode to an already-loaded Codex-lineage thread. The
+     * caller persists only after this native RPC succeeds. */
+    updateCollaborationMode(localThreadId: string, mode: SessionCollaborationMode): Promise<void>;
+    /** Apply one explicit collaboration mode to the current native thread and
+     * remember only a successful RPC. A supplied client is already initialized
+     * and remains owned by its caller (used by cold-resume preload). */
+    private applyLiveCollaborationMode;
     /**
      * The command to run in a session's live terminal so it co-drives the codex
      * app-server thread (Phase D). Returns `null` when live-terminal is off, the
@@ -227,7 +234,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Fresh sessions already connected their discovery listener before launch;
      * this is therefore an idempotent no-op for them and for a healthy observer. */
     startLiveCodexObserver(localThreadId: string): void;
-    /** Omnigent treats the forwarder as a required component of one native
+    /** reference implementation treats the forwarder as a required component of one native
      * lifecycle: if its transport dies, it closes the app-server instead of
      * accepting turns that can no longer reach the canonical mirror. */
     private failObserverLifecycle;
@@ -237,7 +244,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Subscribe the forwarder connection to a thread (reference implementation's
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
-     * thread active, then retry. Like Omnigent, the first attempt always uses
+     * thread active, then retry. Like reference implementation, the first attempt always uses
      * `excludeTurns`: a known-session cold resume therefore never reconstructs
      * historical running/completed state. Only a fresh thread whose first attempt
      * failed as not-ready retries without `excludeTurns`, backfilling the newly
@@ -273,7 +280,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * forwarder). Park-until-ready (~60s), aligning reference implementation's executor waiting for
      * the bridge instead of a short race that falls back to a second output path.
      */
-    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string, options?: RuntimeTurnOptions): Promise<InjectResult>;
     /**
      * Interrupt the session's active turn — the web Stop button. codex: the
      * app-server `turn/interrupt` on the active `{threadId, turnId}` (exactly what
@@ -288,7 +295,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
         deferClaudeInteractionCleanup?: boolean;
     }): void;
     /** Tear down one codex-lineage native runtime without deleting its durable
-     * session-store binding. Omnigent couples its auxiliary Terminal, observer,
+     * session-store binding. reference implementation couples its auxiliary Terminal, observer,
      * forwarder and per-session app-server as one disposable runtime envelope;
      * the next message recreates that envelope and cold-resumes the native id. */
     teardownLiveCodexSession(localThreadId: string, error?: Error): boolean;
@@ -321,8 +328,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  would fail and (pre-reference implementation) fall through to a second output path. */
     private waitInjector;
     /** Attach a session's tmux pane injector (from the runner-child, which owns the
-     *  terminal registry — the host does not hold tmux). Ignored for codex sessions
-     *  (they inject via the app-server). Idempotent. */
+     *  terminal registry — the host does not hold tmux). Claude uses it for normal
+     *  message injection; Codex uses it only to dismiss the exact TUI-local Plan
+     *  picker after its synthetic Web form is submitted. Idempotent. */
     attachTerminalInjector(localThreadId: string, injector: TerminalInjector): void;
     /** Close an active native response when its terminal or runner disappears. */
     failLiveSession(localThreadId: string, error: Error): boolean;