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

package/dist/claude/native-bridge.d.ts

@@ -109,6 +109,8 @@ export interface HookEvent {
     /** Claude's session uuid — subagent hooks report a `subagents/…` transcript path. */
     sessionId?: string;
     source?: string;
+    /** Authoritative live background-shell count carried by a Stop hook. */
+    backgroundTaskCount?: number;
     payload: Record<string, unknown>;
 }
 /** Tail `hooks.jsonl` from a byte offset into parsed {@link HookEvent}s. */

package/dist/claude/native-bridge.js

@@ -267,6 +267,25 @@ function readJsonFile(path) {
 function asString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
+const TERMINAL_BACKGROUND_TASK_STATUSES = new Set([
+    "completed",
+    "failed",
+    "stopped",
+    "killed",
+]);
+function backgroundTaskCount(payload) {
+    if (payload.hook_event_name !== "Stop")
+        return undefined;
+    const tasks = payload.background_tasks;
+    if (!Array.isArray(tasks))
+        return 0;
+    return tasks.filter((task) => {
+        if (!task || typeof task !== "object" || Array.isArray(task))
+            return true;
+        const status = task.status;
+        return typeof status !== "string" || !TERMINAL_BACKGROUND_TASK_STATUSES.has(status);
+    }).length;
+}
 export function readClaudeState(bridgeDir) {
     const raw = readJsonFile(join(bridgeDir, STATE_FILE));
     if (!raw || typeof raw !== "object")
@@ -348,11 +367,15 @@ export function readHookEventsFrom(bridgeDir, byteOffset) {
         const payload = rec.payload;
         if (!payload || typeof payload !== "object")
             continue;
+        const liveBackgroundTasks = backgroundTaskCount(payload);
         events.push({
             eventName: asString(payload.hook_event_name),
             transcriptPath: asString(payload.transcript_path),
             sessionId: asString(payload.session_id),
             source: asString(payload.source),
+            ...(liveBackgroundTasks === undefined
+                ? {}
+                : { backgroundTaskCount: liveBackgroundTasks }),
             payload,
         });
     }

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.d.ts

@@ -21,7 +21,7 @@ export interface ClaudeForwarderSink {
     onInteraction(event: RuntimeInteractionEvent): void;
     /** The current turn finished (a new user prompt, or the inactivity backstop).
      *  `usage` carries the latest statusLine context/cost snapshot, when captured. */
-    onTurnEnd(usage?: Record<string, unknown>): void;
+    onTurnEnd(usage?: Record<string, unknown>, backgroundTaskCount?: number): void;
     /** The current turn ended because the user explicitly interrupted it. */
     onTurnInterrupted?(usage?: Record<string, unknown>): void;
     /** Escape was sent for the open Turn. Publish cancelled UI state immediately;
@@ -34,8 +34,9 @@ export interface ClaudeForwarderSink {
      *  assistant record and the two orderings race; finalizing here would split a
      *  late assistant record into its own turn. The turn is finalized by the next
      *  user prompt or the inactivity backstop, so a late record still joins it. */
-    onIdle(): void;
-    /** The current turn failed on the runtime (StopFailure hook). */
+    onIdle(backgroundTaskCount?: number): void;
+    /** Claude's current Turn or native runtime failed (StopFailure/pane exit).
+     * May fire between Turns so Session-level failure can retire stale liveness. */
     onTurnError(error: Error): void;
     /** Fired once SessionStart reveals claude's session id + transcript path, so
      *  the host can persist the id and release its readiness gate. */
@@ -115,6 +116,10 @@ export declare class ClaudeLiveSession {
     private lastActivityAt;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     private stopPendingAt;
+    /** Authoritative live background-shell count from the pending Stop hook. */
+    private stopBackgroundTaskCount;
+    /** Whether the pending Stop count already rode an immediate idle edge. */
+    private stopBackgroundTaskCountDelivered;
     /** An idle status from Claude's session metadata. The short delay keeps a
      * final transcript record in the response without letting stale tool state
      * override the provider's terminal status. */

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) {
@@ -177,6 +177,10 @@ export class ClaudeLiveSession {
     lastActivityAt = 0;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     stopPendingAt = null;
+    /** Authoritative live background-shell count from the pending Stop hook. */
+    stopBackgroundTaskCount;
+    /** Whether the pending Stop count already rode an immediate idle edge. */
+    stopBackgroundTaskCountDelivered = false;
     /** An idle status from Claude's session metadata. The short delay keeps a
      * final transcript record in the response without letting stale tool state
      * override the provider's terminal status. */
@@ -436,11 +440,15 @@ export class ClaudeLiveSession {
             if (ev.eventName === "StopFailure") {
                 this.stopSignalPending = false;
                 this.stopPendingAt = null;
+                this.stopBackgroundTaskCount = undefined;
+                this.stopBackgroundTaskCountDelivered = false;
                 this.turnFailurePending = new Error("claude turn failed");
             }
             else {
                 this.stopSignalPending = true;
                 this.stopPendingAt = this.now(); // close after a short grace (late assistant flush)
+                this.stopBackgroundTaskCount = ev.backgroundTaskCount ?? 0;
+                this.stopBackgroundTaskCountDelivered = false;
             }
         }
     }
@@ -452,7 +460,10 @@ export class ClaudeLiveSession {
             return;
         this.turnFailurePending = null;
         this.providerFailureSticky = true;
-        this.closeTurnError(error);
+        if (this.turnOpen)
+            this.closeTurnError(error);
+        else
+            this.sink.onTurnError(error);
     }
     /** Emit the Stop idle signal only after this tick has discovered native
      *  interactions. A pending question/permission is active execution, not idle. */
@@ -460,10 +471,10 @@ export class ClaudeLiveSession {
         if (!this.stopSignalPending)
             return;
         this.stopSignalPending = false;
-        if (this.statusPoller?.active)
-            return;
-        if (this.pendingInteractions.size === 0)
-            this.sink.onIdle();
+        if (this.pendingInteractions.size === 0) {
+            this.sink.onIdle(this.stopBackgroundTaskCount);
+            this.stopBackgroundTaskCountDelivered = true;
+        }
     }
     /** SessionStart drives discovery (first) and rotation (a later one with a NEW
      *  session id + transcript). `/clear` → source="clear"; `/fork` → source="resume"
@@ -907,6 +918,8 @@ export class ClaudeLiveSession {
                     this.providerIdleAt = null;
                     this.openToolIds.clear();
                     this.stopPendingAt = null;
+                    this.stopBackgroundTaskCount = undefined;
+                    this.stopBackgroundTaskCountDelivered = false;
                     this.sink.onTurnStart(this.currentTurnId);
                 }
                 this.sink.onUserMessage(content);
@@ -1040,6 +1053,11 @@ export class ClaudeLiveSession {
         this.stopPendingAt = null;
         if (status.runnerStatus === "running") {
             this.providerFailureSticky = false;
+            // A new native busy interval supersedes the prior Stop snapshot. The
+            // Session running edge clears its sticky tally; do not re-emit that old
+            // count if the previous transcript Turn closes a moment later.
+            this.stopBackgroundTaskCount = undefined;
+            this.stopBackgroundTaskCountDelivered = false;
         }
         else if (this.providerFailureSticky) {
             return;
@@ -1114,6 +1132,8 @@ export class ClaudeLiveSession {
         this.providerIdleAt = null;
         this.turnOpen = true;
         this.turnInterrupted = false;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
     /** Mirror a local `!` command as its own mini-turn: close any open turn, then
@@ -1162,7 +1182,10 @@ export class ClaudeLiveSession {
     /** Retire process-scoped metadata before classifying a terminal exit. */
     noteTerminalExit(error) {
         this.statusPoller?.retire();
-        return this.failOpenTurn(error);
+        const failedOpenTurn = this.failOpenTurn(error);
+        if (!failedOpenTurn)
+            this.sink.onTurnError(error);
+        return failedOpenTurn;
     }
     closeTurn() {
         if (!this.turnOpen)
@@ -1179,10 +1202,15 @@ export class ClaudeLiveSession {
         const interrupted = this.turnInterrupted;
         this.turnInterrupted = false;
         const usage = this.statusUsage();
+        const backgroundTaskCount = this.stopBackgroundTaskCountDelivered
+            ? undefined
+            : this.stopBackgroundTaskCount;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         if (interrupted && this.sink.onTurnInterrupted)
             this.sink.onTurnInterrupted(usage);
         else
-            this.sink.onTurnEnd(usage);
+            this.sink.onTurnEnd(usage, backgroundTaskCount);
     }
     closeTurnError(error) {
         if (!this.turnOpen)
@@ -1196,6 +1224,8 @@ export class ClaudeLiveSession {
         this.turnInterrupted = false;
         this.stopSignalPending = false;
         this.stopPendingAt = null;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         this.resetMessageCorrelation();
         this.sink.onTurnError(error);
     }

package/dist/claude/transcript.js

@@ -22,11 +22,32 @@ export function subagentTranscriptPath(parentTranscriptPath, agentId) {
     const dir = parentTranscriptPath.replace(/\.jsonl$/, "");
     return join(dir, "subagents", `agent-${agentId}.jsonl`);
 }
+function strippedImagePlaceholder(source) {
+    const mediaType = source.media_type;
+    const label = typeof mediaType === "string" && mediaType ? `${mediaType} image` : "image";
+    return `[${label} omitted from history to save context — re-run the tool call above (e.g. Read the same path) to view it again]`;
+}
+/** Remove Claude's inline image bytes before tool output reaches canonical
+ *  history. A Read image result can contain a full-resolution base64 payload;
+ *  replaying it as text only bloats the transcript, while the model cannot use
+ *  those encoded bytes as text. Keep a small, human-readable marker instead. */
+function stripInlineImageData(value) {
+    if (Array.isArray(value))
+        return value.map(stripInlineImageData);
+    if (!isObject(value))
+        return value;
+    const source = isObject(value.source) ? value.source : undefined;
+    if (value.type === "image" && source) {
+        return { type: "text", text: strippedImagePlaceholder(source) };
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, stripInlineImageData(nested)]));
+}
 function stringifyToolContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
+    const stripped = stripInlineImageData(content);
+    if (typeof stripped === "string")
+        return stripped;
+    if (Array.isArray(stripped)) {
+        return stripped
             .map((part) => part && typeof part === "object" && "text" in part
             ? String(part.text ?? "")
             : typeof part === "string"
@@ -34,18 +55,7 @@ function stringifyToolContent(content) {
                 : JSON.stringify(part))
             .join("");
     }
-    return content == null ? "" : JSON.stringify(content);
-}
-function toolLabel(name, input) {
-    if (input && typeof input === "object") {
-        const rec = input;
-        for (const key of ["command", "cmd", "path", "file_path", "pattern", "query"]) {
-            const v = rec[key];
-            if (typeof v === "string" && v)
-                return v;
-        }
-    }
-    return name ?? "tool";
+    return stripped == null ? "" : JSON.stringify(stripped);
 }
 const BASH_INPUT_RE = /<bash-input>([\s\S]*?)<\/bash-input>/;
 const BASH_STDOUT_RE = /<bash-stdout>([\s\S]*?)<\/bash-stdout>/;
@@ -132,7 +142,7 @@ export function parseTranscriptRecord(record, opts) {
                     type: "tool",
                     event: "on_tool_start",
                     name: block.name,
-                    input: { ...(isObject(block.input) ? block.input : {}), id: block.id, command: toolLabel(block.name, block.input) },
+                    input: { ...(isObject(block.input) ? block.input : {}), id: block.id },
                     data: { id: block.id },
                     ...parentTag,
                 });

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

@@ -1386,7 +1386,17 @@ export function buildTextUserInput(message) {
 export function buildRuntimeUserInput(input) {
     return input.content.map((part) => part.type === "text"
         ? { type: "text", text: part.text, text_elements: [] }
-        : { type: "localImage", path: part.path });
+        : part.type === "local_image"
+            ? { type: "localImage", path: part.path }
+            : {
+                type: "text",
+                text: `[[RYNX_FILE_RESOURCE ${JSON.stringify({
+                    path: part.path,
+                    ...(part.resource.filename ? { filename: part.resource.filename } : {}),
+                    mediaType: part.resource.mediaType,
+                })}]]\nInspect this absolute file path with the available file-reading tools before answering.`,
+                text_elements: [],
+            });
 }
 const defaultLogger = {
     log(entry) {

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. */
@@ -34,6 +34,9 @@ export interface CodexForwarderSink {
     onTurnObserved?(turnId?: string): void;
     /** One mapped event within the current turn. */
     onEvent(event: AgentEvent): void;
+    /** Turn-scoped content arrived while no Provider Turn is active. Attach it
+     * to that response without opening a Turn or changing Session status. */
+    onTurnContentEvent?(turnId: string | undefined, event: AgentEvent): void;
     /** Provider startup is session status, not a model item. Hosts that already
      * published the response can forward it without synthesizing another start. */
     onStatus?(note: string | undefined, statusKind?: "startup"): void;
@@ -49,6 +52,8 @@ export interface CodexForwarderSink {
     /** The user's turn text (sourced from codex's `userMessage` item), so a
      *  co-driving TUI's prompt is recorded even though this process never injected it. */
     onUserMessage?(content: string | UserContentPart[]): void;
+    /** Out-of-lifecycle counterpart of `onUserMessage`, scoped when possible. */
+    onTurnContentUserMessage?(turnId: string | undefined, content: string | UserContentPart[]): void;
     /** A managed Core fork also broadcasts `thread/started`, but does not switch
      * the source TUI. Discard that notification before changing the bound thread. */
     shouldIgnoreThreadStarted?(threadId: string, forkedFromId?: string): boolean;
@@ -58,6 +63,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 +116,11 @@ 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;
+    /** Latest aggregate diff per Turn. Codex republishes the complete diff after
+     * every edit; only the terminal snapshot belongs in transcript history. */
+    private readonly turnDiffByTurn;
+    private replayingBackfill;
     constructor(client: CodexAppServerClient, sink: CodexForwarderSink, options?: CodexSessionForwarderOptions);
     /** Begin mirroring. Idempotent. */
     start(): void;
@@ -136,6 +156,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;
@@ -164,6 +187,7 @@ export declare class CodexSessionForwarder {
     private completedItemKey;
     private advanceAnonCounter;
     private ensureTurn;
+    private consumeTurnDiff;
     /** Start (or confirm) the app-server's authoritative active turn. A newer
      * start supersedes an older response whose terminal edge arrived late; a
      * pending Traex completion is flushed first so its final item grace remains