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

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

@@ -1,4 +1,4 @@
-import { codexUserContent } from "../input-resources.js";
+import { codexUserEchoContent } from "../input-resources.js";
 import { codexResumeTerminalStatus, mapCodexItem, mapCodexNotification, } from "./mapping.js";
 const MCP_STARTUP_STATUS_METHOD = "mcpServer/startupStatus/updated";
 const MCP_TERMINAL_STATES = new Set(["ready", "failed", "cancelled"]);
@@ -13,14 +13,7 @@ function turnIdFrom(params) {
 function userMessageContent(item) {
     if (item.type !== "userMessage")
         return undefined;
-    const parts = codexUserContent(item.content);
-    if (parts.length === 0)
-        return undefined;
-    if (parts.every((part) => part.type === "input_text")) {
-        const text = parts.map((part) => part.text).join("").trim();
-        return text || undefined;
-    }
-    return parts;
+    return codexUserEchoContent(item.content);
 }
 /** Whether a notification implies the thread is now active (its first turn has
  *  begun, so the rollout exists). Mirrors reference implementation's `_event_indicates_thread_active`. */
@@ -59,6 +52,20 @@ function isTurnScopedMethod(method) {
 function canRecoverMissedTurnFrom(method) {
     return method === "item/agentMessage/delta" || method === "item/plan/delta";
 }
+/** Omnigent forwards these live deltas only for the bridge's exact active
+ * Codex turn. Assistant/plan deltas may recover a missed `turn/started` when
+ * fully scoped; command output never opens or recovers a Turn. */
+function requiresMatchingActiveTurn(method) {
+    return canRecoverMissedTurnFrom(method) || method === "item/commandExecution/outputDelta";
+}
+/** Content Omnigent forwards independently from the active-turn status edge. */
+function isIndependentTurnContent(method) {
+    return method === "item/started" ||
+        method === "item/reasoning/textDelta" ||
+        method === "item/reasoning/summaryTextDelta" ||
+        method === "item/fileChange/patchUpdated" ||
+        method === "turn/plan/updated";
+}
 export class CodexSessionForwarder {
     client;
     sink;
@@ -87,6 +94,9 @@ export class CodexSessionForwarder {
      *  (peek-then-advance; advanced only on a successful claim). reference implementation anon path. */
     anonCounters = new Map();
     pendingPlanImplementation = null;
+    /** Latest aggregate diff per Turn. Codex republishes the complete diff after
+     * every edit; only the terminal snapshot belongs in transcript history. */
+    turnDiffByTurn = new Map();
     replayingBackfill = false;
     constructor(client, sink, options = {}) {
         this.client = client;
@@ -122,6 +132,7 @@ export class CodexSessionForwarder {
         else {
             this.currentTurnIdValue = null;
         }
+        this.turnDiffByTurn.clear();
     }
     /** True while the provider owns an active turn, including the short interval
      * between injection acceptance and observer confirmation. */
@@ -251,6 +262,7 @@ export class CodexSessionForwarder {
                 }
                 this.currentTurnIdValue = null;
                 this.activeSignaled = false;
+                this.turnDiffByTurn.clear();
                 this.currentThreadIdValue = tid;
                 this.sink.onThreadStarted?.(tid, normalizedForkedFromId);
             }
@@ -289,6 +301,21 @@ export class CodexSessionForwarder {
         if (method === "queue/status" && this.currentTurnIdValue === null)
             return;
         const carriedTurnId = turnIdFrom(params);
+        if (method === "turn/diff/updated") {
+            if (!carriedTurnId)
+                return;
+            const update = params;
+            const diff = typeof update?.diff === "string"
+                ? update.diff
+                : typeof update?.unifiedDiff === "string"
+                    ? update.unifiedDiff
+                    : "";
+            if (diff)
+                this.turnDiffByTurn.set(carriedTurnId, diff);
+            else
+                this.turnDiffByTurn.delete(carriedTurnId);
+            return;
+        }
         if (method === "turn/started") {
             this.beginTurn(carriedTurnId);
             this.sink.onTurnObserved?.(carriedTurnId);
@@ -296,12 +323,21 @@ export class CodexSessionForwarder {
         }
         if (isTerminalTurnMethod(method)) {
             if (!this.terminalBoundaryMatchesActiveTurn(carriedTurnId, notificationThreadId)) {
+                const staleDiff = this.consumeTurnDiff(carriedTurnId);
+                if (staleDiff && carriedTurnId) {
+                    this.sink.onTurnContentEvent?.(carriedTurnId, staleDiff);
+                }
                 return;
             }
             const hadActiveTurn = this.currentTurnIdValue !== null;
             const hadOpenResponse = this.turnOpen;
             const mapped = mapCodexNotification(method, params);
+            const terminalTurnId = carriedTurnId ?? this.currentTurnIdValue;
+            const turnDiff = this.consumeTurnDiff(terminalTurnId);
             if (!hadActiveTurn && !hadOpenResponse) {
+                if (turnDiff && terminalTurnId) {
+                    this.sink.onTurnContentEvent?.(terminalTurnId, turnDiff);
+                }
                 const turn = params?.turn;
                 const recoveredStatus = mapped.fatalError ||
                     method === "turn/failed" ||
@@ -323,10 +359,18 @@ export class CodexSessionForwarder {
                 this.sink.onEvent(event);
             }
             this.scheduleCompletion(mapped.fatalError
-                ? { kind: "error", error: mapped.fatalError }
+                ? { kind: "error", error: mapped.fatalError, ...(turnDiff ? { turnDiff } : {}) }
                 : mapped.turnInterrupted
-                    ? { kind: "interrupted", ...(mapped.usage ? { usage: mapped.usage } : {}) }
-                    : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+                    ? {
+                        kind: "interrupted",
+                        ...(mapped.usage ? { usage: mapped.usage } : {}),
+                        ...(turnDiff ? { turnDiff } : {}),
+                    }
+                    : {
+                        kind: "end",
+                        ...(mapped.usage ? { usage: mapped.usage } : {}),
+                        ...(turnDiff ? { turnDiff } : {}),
+                    });
             return;
         }
         // A late event from an older turn must not replace the app-server's active
@@ -335,32 +379,66 @@ export class CodexSessionForwarder {
             this.currentTurnIdValue &&
             carriedTurnId !== this.currentTurnIdValue &&
             isTurnScopedMethod(method)) {
-            return;
+            // Durable completed items and passive content belong to their carried
+            // response even if a newer Turn is active. Only active-turn deltas and
+            // lifecycle edges are stale with respect to the newer Turn.
+            if (method === "item/completed") {
+                // Continue into the completed-item dedup/order path below.
+            }
+            else if (isIndependentTurnContent(method) && this.sink.onTurnContentEvent) {
+                const mapped = mapCodexNotification(method, params);
+                for (const event of mapped.events) {
+                    if (event.type !== "runtime_debug") {
+                        this.sink.onTurnContentEvent(carriedTurnId, event);
+                    }
+                }
+                return;
+            }
+            else {
+                return;
+            }
         }
-        if (carriedTurnId && this.currentTurnIdValue === null) {
-            if (canRecoverMissedTurnFrom(method)) {
-                if (!this.notificationMatchesCurrentThread(notificationThreadId))
+        if (requiresMatchingActiveTurn(method)) {
+            if (this.currentTurnIdValue !== null) {
+                // An id-less delta is not attributable to the active Turn. Omnigent's
+                // `_is_active_turn_delta` applies the same exact-id requirement.
+                if (carriedTurnId !== this.currentTurnIdValue)
                     return;
+            }
+            else if (carriedTurnId &&
+                canRecoverMissedTurnFrom(method) &&
+                this.notificationMatchesCurrentThread(notificationThreadId)) {
                 this.currentTurnIdValue = carriedTurnId;
                 this.ensureTurn();
             }
+            else {
+                return;
+            }
         }
         // Completed items (user echo, assistant, tool, reasoning) go through the
         // deduped path so a resume backfill and the live stream never double them.
         if (method === "item/completed") {
             const item = params?.item;
             if (item) {
+                if (carriedTurnId &&
+                    this.currentTurnIdValue &&
+                    carriedTurnId !== this.currentTurnIdValue) {
+                    // This is durable content for an older response, not an ordering
+                    // signal for the newer Turn's deferred assistant message.
+                    this.processCompletedItem(item, carriedTurnId);
+                    return;
+                }
                 if (this.shouldDeferAssistantMessage(item)) {
-                    this.deferAssistantMessage(item);
+                    this.deferAssistantMessage(item, carriedTurnId);
                     this.refreshCompletionGrace();
                     return;
                 }
-                // A late reasoning item belongs before the held final answer. Any other
-                // completed item establishes that the held message was not final and
-                // must retain its original position.
+                // Within one Turn, a late reasoning item belongs before the held final
+                // answer. Any other completed item establishes that the held message
+                // was not final and must retain its original position.
                 if (item.type !== "reasoning")
                     this.flushDeferredAssistantMessage();
-                this.processCompletedItem(item);
+                this.processCompletedItem(item, carriedTurnId);
                 this.refreshCompletionGrace();
                 return;
             }
@@ -375,6 +453,19 @@ export class CodexSessionForwarder {
         if (canonicalEvents.some((event) => event.type !== "reasoning_delta" && event.type !== "reasoning_completed")) {
             this.flushDeferredAssistantMessage();
         }
+        // Omnigent's item/content channel is independent from its turn-status
+        // channel. A scoped item or reasoning delta that arrives after the terminal
+        // edge remains visible, but must not synthesize another running response.
+        if (!this.turnOpen &&
+            this.currentTurnIdValue === null &&
+            !mapped.fatalError &&
+            canonicalEvents.length > 0 &&
+            this.sink.onTurnContentEvent) {
+            for (const event of canonicalEvents) {
+                this.sink.onTurnContentEvent(carriedTurnId, event);
+            }
+            return;
+        }
         if (canonicalEvents.length || mapped.turnCompleted || mapped.fatalError) {
             this.ensureTurn();
         }
@@ -433,6 +524,10 @@ export class CodexSessionForwarder {
         if (this.pendingPlanImplementation?.turnId === completedTurnId) {
             this.pendingPlanImplementation = null;
         }
+        if (completion.turnDiff)
+            this.sink.onEvent(completion.turnDiff);
+        if (completedTurnId)
+            this.turnDiffByTurn.delete(completedTurnId);
         this.turnOpen = false;
         this.currentTurnIdValue = null;
         this.pendingCompletionTurnId = null;
@@ -519,23 +614,30 @@ export class CodexSessionForwarder {
     }
     /** Map + emit one completed codex item, deduped by a TOTAL key and routing the
      *  user echo to {@link CodexForwarderSink.onUserMessage}. Shared by live + backfill. */
-    processCompletedItem(item) {
-        if (!this.claimCompletedItem(item))
+    processCompletedItem(item, completedTurnId) {
+        if (!this.claimCompletedItem(item, completedTurnId))
             return;
-        this.emitCompletedItem(item);
+        this.emitCompletedItem(item, completedTurnId);
     }
-    claimCompletedItem(item) {
-        const { key, isAnon } = this.completedItemKey(item);
+    claimCompletedItem(item, completedTurnId) {
+        const { key, isAnon } = this.completedItemKey(item, completedTurnId);
         if (this.seenCompletedItems.has(key))
             return false;
         this.seenCompletedItems.add(key);
         if (isAnon)
-            this.advanceAnonCounter();
+            this.advanceAnonCounter(completedTurnId);
         return true;
     }
-    emitCompletedItem(item) {
+    emitCompletedItem(item, completedTurnId) {
+        const outsideTurnLifecycle = !this.turnOpen || Boolean(completedTurnId &&
+            this.currentTurnIdValue &&
+            completedTurnId !== this.currentTurnIdValue);
         const userContent = userMessageContent(item);
         if (userContent !== undefined) {
+            if (outsideTurnLifecycle && this.sink.onTurnContentUserMessage) {
+                this.sink.onTurnContentUserMessage(completedTurnId, userContent);
+                return;
+            }
             this.ensureTurn();
             this.sink.onUserMessage?.(userContent);
             return;
@@ -552,6 +654,12 @@ export class CodexSessionForwarder {
         const canonicalEvents = mapped.events.filter((event) => event.type !== "runtime_debug");
         if (canonicalEvents.length === 0)
             return;
+        if (outsideTurnLifecycle && this.sink.onTurnContentEvent) {
+            for (const event of canonicalEvents) {
+                this.sink.onTurnContentEvent(completedTurnId, event);
+            }
+            return;
+        }
         this.ensureTurn();
         for (const event of canonicalEvents)
             this.sink.onEvent(event);
@@ -562,11 +670,11 @@ export class CodexSessionForwarder {
         }
         return Boolean(item.text?.trim());
     }
-    deferAssistantMessage(item) {
-        if (!this.claimCompletedItem(item))
+    deferAssistantMessage(item, turnId) {
+        if (!this.claimCompletedItem(item, turnId))
             return;
         this.flushDeferredAssistantMessage();
-        this.deferredAssistantMessage = item;
+        this.deferredAssistantMessage = { item, ...(turnId ? { turnId } : {}) };
         const graceMs = this.options.assistantMessageGraceMs ?? 0;
         this.assistantMessageTimer = setTimeout(() => this.flushDeferredAssistantMessage(), graceMs);
         this.assistantMessageTimer.unref?.();
@@ -575,26 +683,26 @@ export class CodexSessionForwarder {
         if (this.assistantMessageTimer)
             clearTimeout(this.assistantMessageTimer);
         this.assistantMessageTimer = null;
-        const item = this.deferredAssistantMessage;
+        const deferred = this.deferredAssistantMessage;
         this.deferredAssistantMessage = null;
-        if (item)
-            this.emitCompletedItem(item);
+        if (deferred)
+            this.emitCompletedItem(deferred.item, deferred.turnId);
     }
     /** Build a total dedup key for one completed item. Stable-id items use
      *  `threadId:turnId:item.id` — identical across replay + live, so the second
      *  delivery is dropped. Items without a codex id fall back to a per-(thread,turn)
      *  position counter (peeked here; advanced only on a successful claim, via
      *  {@link advanceAnonCounter}). Mirrors reference implementation `_completed_item_key`. */
-    completedItemKey(item) {
+    completedItemKey(item, completedTurnId) {
         const threadId = this.currentThreadIdValue ?? "thread";
-        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
+        const turnId = completedTurnId ?? this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
         if (item.id)
             return { key: `${threadId}:${turnId}:${item.id}`, isAnon: false };
         const n = this.anonCounters.get(`${threadId}:${turnId}`) ?? 0;
         return { key: `${threadId}:${turnId}:anon:${n}`, isAnon: true };
     }
-    advanceAnonCounter() {
-        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
+    advanceAnonCounter(completedTurnId) {
+        const turnId = completedTurnId ?? this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
         const k = `${this.currentThreadIdValue ?? "thread"}:${turnId}`;
         this.anonCounters.set(k, (this.anonCounters.get(k) ?? 0) + 1);
     }
@@ -604,6 +712,15 @@ export class CodexSessionForwarder {
             this.sink.onTurnStart(this.currentTurnIdValue ?? undefined);
         }
     }
+    consumeTurnDiff(turnId) {
+        if (!turnId)
+            return undefined;
+        const diff = this.turnDiffByTurn.get(turnId);
+        this.turnDiffByTurn.delete(turnId);
+        return diff
+            ? { type: "turn_diff", callId: `codex_turn_diff_${turnId}`, diff }
+            : undefined;
+    }
     /** 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

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

@@ -1,9 +1,3 @@
-/**
- * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
- * the executor so BOTH the per-turn executor and the persistent session
- * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
- * canonical log, reference implementation's codex-native model) share one mapping.
- */
 import type { AgentEvent } from "@rynx-ai/core";
 import type { ThreadItem } from "./protocol.js";
 export interface CodexMapResult {

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

@@ -1,3 +1,10 @@
+/**
+ * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
+ * the executor so BOTH the per-turn executor and the persistent session
+ * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
+ * canonical log, reference implementation's codex-native model) share one mapping.
+ */
+import { extname, isAbsolute } from "node:path";
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -115,6 +122,23 @@ function webSearchInput(item) {
     }
     return { id: item.id, query: item.query };
 }
+function fileChangeSummary(changes) {
+    const lines = [];
+    for (const change of changes) {
+        if (!isRecord(change))
+            continue;
+        const kind = isRecord(change.kind) && typeof change.kind.type === "string" && change.kind.type
+            ? change.kind.type
+            : "change";
+        lines.push(`${kind} ${String(change.path)}`);
+    }
+    return lines.join("\n");
+}
+function isSupportedAbsoluteImagePath(path) {
+    if (!isAbsolute(path))
+        return false;
+    return [".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"].includes(extname(path).toLowerCase());
+}
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export function mapCodexItem(method, item) {
     const events = [];
@@ -144,16 +168,18 @@ export function mapCodexItem(method, item) {
             return { events };
         }
         case "fileChange": {
+            const fileChange = item;
+            const changes = Array.isArray(fileChange.changes) ? fileChange.changes : [];
             events.push({
                 type: "tool",
                 event: isStart ? "on_tool_start" : "on_tool_end",
-                name: "file_change",
-                input: isStart ? { id: item.id } : undefined,
+                name: "apply_patch",
+                input: isStart || isEnd ? { id: item.id, ...(changes.length ? { changes } : {}) } : undefined,
                 output: isEnd
                     ? {
                         id: item.id,
-                        changes: item.changes,
-                        status: item.status,
+                        status: fileChange.status,
+                        aggregatedOutput: fileChangeSummary(changes),
                     }
                     : undefined,
                 data: { method, item },
@@ -199,6 +225,30 @@ export function mapCodexItem(method, item) {
             });
             return { events };
         }
+        case "imageGeneration": {
+            const image = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "image_generation",
+                input: isStart ? { id: image.id } : undefined,
+                output: isEnd
+                    ? {
+                        id: image.id,
+                        status: image.status,
+                        generatedImage: {
+                            ...(!image.savedPath || !isSupportedAbsoluteImagePath(image.savedPath)
+                                ? { result: image.result }
+                                : {}),
+                            revisedPrompt: image.revisedPrompt,
+                            ...(image.savedPath ? { savedPath: image.savedPath } : {}),
+                        },
+                    }
+                    : undefined,
+                data: { method, item: { ...image, result: image.result ? "[image data omitted]" : "" } },
+            });
+            return { events };
+        }
         case "agentMessage": {
             const text = item.text?.trim() ?? "";
             if (isEnd && text) {

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

@@ -267,7 +267,16 @@ export interface WebSearchItem extends ThreadItemBase {
         type: "other";
     } | null;
 }
-export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
+export interface ImageGenerationItem extends ThreadItemBase {
+    type: "imageGeneration";
+    status: string;
+    revisedPrompt: string | null;
+    /** Base64 image bytes supplied when no durable saved path is available. */
+    result: string;
+    /** Codex App Server guarantees this is absolute when present. */
+    savedPath?: string;
+}
+export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | ImageGenerationItem | (ThreadItemBase & Record<string, unknown>);
 export interface ThreadSummary {
     id?: string;
     threadId?: string;

package/dist/host.js

@@ -21,7 +21,7 @@ import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { providerAdditionalDirs, threadWorkspaceParams, turnWorkspaceParams, } from "./provider-workspace.js";
 import { ensureProjectTrusted } from "./claude/trust.js";
-import { claudeAttachmentToken, claudeInputText, runtimeUserContent, } from "./input-resources.js";
+import { claudeAttachmentToken, claudeInputText, codexUserEchoContent, runtimeUserContent, } from "./input-resources.js";
 import { claudeBridgeDir, prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
 import { ClaudeLiveSession, injectViaTerminal, } from "./claude/native-integration.js";
 import { buildClaudeHookSettings } from "./claude/native-hooks.js";
@@ -847,6 +847,9 @@ export class LocalAgentHost {
         };
         let normalizer = null;
         let currentResponseId = null;
+        /** State for content-only events, keyed by Provider response so consecutive
+         * late deltas retain one canonical item id without owning lifecycle. */
+        const contentNormalizers = new Map();
         const startNormalizer = (turnId) => {
             const responseId = turnId ? `resp_codex_${turnId}` : "resp_codex_native";
             if (normalizer && currentResponseId === responseId)
@@ -892,6 +895,40 @@ export class LocalAgentHost {
                 return;
             live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== responseId);
         };
+        const turnContentEvents = (turnId, produce) => {
+            const responseId = turnId ? `resp_codex_${turnId}` : "resp_codex_native";
+            let contentNormalizer = contentNormalizers.get(responseId);
+            if (!contentNormalizer) {
+                contentNormalizer = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: live.model || live.runtime,
+                });
+                contentNormalizers.set(responseId, contentNormalizer);
+            }
+            for (const event of produce(contentNormalizer)) {
+                // Omnigent posts item/transient content under the Turn's response id
+                // independently of lifecycle status. Reuse Rynx's canonical item
+                // normalization but suppress its synthetic lifecycle edges.
+                if (event.type !== "response.created" && event.type !== "session.status") {
+                    emitCurrent(event);
+                }
+            }
+        };
+        const observedUserContent = (content) => {
+            const normalizedContent = typeof content === "string"
+                ? [{ type: "input_text", text: content }]
+                : content;
+            const signature = JSON.stringify(normalizedContent);
+            const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature || entry.providerEchoSignature === signature);
+            if (pending?.state === "optimistic") {
+                live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
+                return null;
+            }
+            if (pending)
+                pending.observed = true;
+            return normalizedContent;
+        };
         const rememberSettledInteraction = (interactionId) => {
             live.settledInteractions.add(interactionId);
             if (live.settledInteractions.size <= MAX_CODEX_SETTLED_INTERACTIONS)
@@ -1186,26 +1223,27 @@ export class LocalAgentHost {
                 }
             },
             onUserMessage: (content) => {
-                const normalizedContent = typeof content === "string"
-                    ? [{ type: "input_text", text: content }]
-                    : content;
-                const signature = JSON.stringify(normalizedContent);
-                const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
-                if (pending?.state === "optimistic") {
-                    live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
+                const normalizedContent = observedUserContent(content);
+                if (!normalizedContent)
                     return;
-                }
-                if (pending)
-                    pending.observed = true;
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
+            onTurnContentUserMessage: (turnId, content) => {
+                const normalizedContent = observedUserContent(content);
+                if (!normalizedContent)
+                    return;
+                turnContentEvents(turnId, (n) => n.userInput(normalizedContent));
+            },
             onEvent: (event) => {
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.next(event))
                     emitCurrent(se);
             },
+            onTurnContentEvent: (turnId, event) => {
+                turnContentEvents(turnId, (n) => n.next(event));
+            },
             onStatus: (note, statusKind) => {
                 const responseId = currentResponseId ??
                     live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId;
@@ -1286,6 +1324,7 @@ export class LocalAgentHost {
             currentSessionId = newSessionId;
             normalizer = null;
             currentResponseId = null;
+            contentNormalizers.clear();
             live.pendingInjectedInputs = [];
             pendingRotationEvents = [];
             void this.sessionStore
@@ -1739,9 +1778,16 @@ export class LocalAgentHost {
                 return { outcome: "notReady" };
             const nativeInput = buildRuntimeUserInput(runtimeInput);
             const content = runtimeUserContent(runtimeInput);
+            const providerEcho = codexUserEchoContent(nativeInput);
+            const providerEchoContent = typeof providerEcho === "string"
+                ? [{ type: "input_text", text: providerEcho }]
+                : providerEcho;
             const pendingInput = {
                 content,
                 signature: JSON.stringify(content),
+                ...(providerEchoContent
+                    ? { providerEchoSignature: JSON.stringify(providerEchoContent) }
+                    : {}),
                 state: "awaiting",
                 observed: false,
             };
@@ -2315,7 +2361,7 @@ export class LocalAgentHost {
                 responseId,
             });
         };
-        const settleClaudeTurn = (interrupted, usage) => {
+        const settleClaudeTurn = (interrupted, usage, backgroundTaskCount) => {
             if (!normalizer)
                 return;
             const rid = currentResponseId;
@@ -2334,8 +2380,11 @@ export class LocalAgentHost {
                     for (const se of normalizer.next({ type: "turn_completed", usage }))
                         emitCurrent(se);
                 }
-                for (const se of normalizer.next({ type: "done" }))
-                    emitCurrent(se);
+                for (const se of normalizer.next({ type: "done" })) {
+                    emitCurrent(se.type === "session.status" && backgroundTaskCount !== undefined
+                        ? { ...se, backgroundTaskCount }
+                        : se);
+                }
             }
             live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
             normalizer = null;
@@ -2398,30 +2447,42 @@ export class LocalAgentHost {
                     ...(blockedOn ? { note: blockedOn } : {}),
                 });
             },
-            onTurnEnd: (usage) => settleClaudeTurn(false, usage),
+            onTurnEnd: (usage, backgroundTaskCount) => settleClaudeTurn(false, usage, backgroundTaskCount),
             onTurnInterrupted: (usage) => settleClaudeTurn(true, usage),
             onTurnInterruptRequested: () => {
                 const responseId = currentResponseId;
                 if (responseId)
                     live.publishInterrupted(responseId);
             },
-            onIdle: () => {
-                // Surface idle on the current turn WITHOUT finalizing it (see the sink's
-                // onIdle doc): a late assistant record still joins this response.
-                if (currentResponseId) {
+            onIdle: (backgroundTaskCount) => {
+                // Surface Stop even after its Turn has already closed: a later
+                // authoritative zero is what clears a sticky background-shell tally.
+                // When the Turn is still open, retain its identity without finalizing it
+                // so a late assistant record continues to join the same Response.
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(currentResponseId ? { responseId: currentResponseId } : {}),
+                    status: "idle",
+                    ...(backgroundTaskCount === undefined ? {} : { backgroundTaskCount }),
+                });
+            },
+            onTurnError: (error) => {
+                const message = error.message || "Agent turn failed";
+                if (!normalizer) {
+                    // Native pane/forwarder death is Session-level even when Claude is
+                    // between Turns. Omnigent publishes the same bare failed edge; the
+                    // explicit zero also retires any sticky background-shell tally.
                     emitCurrent({
                         type: "session.status",
                         sessionId: currentSessionId,
-                        responseId: currentResponseId,
-                        status: "idle",
+                        status: "failed",
+                        backgroundTaskCount: 0,
+                        note: message,
                     });
-                }
-            },
-            onTurnError: (error) => {
-                if (!normalizer)
                     return;
+                }
                 const rid = currentResponseId;
-                const message = error.message || "Agent turn failed";
                 for (const se of normalizer.fail({
                     code: "agent_error",
                     message,