@rynx-ai/runtime 0.1.11-beta.37 → 0.1.11-beta.39

package/dist/host.js

@@ -4,7 +4,7 @@ import { cp, mkdir, mkdtemp, realpath, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { buildAgentSkillEnvironment, hashPluginPackageTree, scanSkillsDir, SessionNormalizer, } from "@rynx-ai/core";
+import { buildAgentSkillEnvironment, hashPluginPackageTree, scanSkillsDir, SessionNormalizer, newSessionItemId, } from "@rynx-ai/core";
 import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
@@ -24,13 +24,34 @@ 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 { claudeBridgeDir, prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
+import { prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
 import { ClaudeLiveSession, injectViaTerminal, } from "./claude/native-integration.js";
 import { buildClaudeHookSettings } from "./claude/native-hooks.js";
 import { buildManagedClaudeSettings } from "./claude/settings.js";
 import { FileCodexSessionStore, resolveCodexSessionStorePath, } from "./codex-session-store.js";
 import { AgentRuntimeError as CodexRuntimeError } from "@rynx-ai/core";
 import { newSessionId as makeSessionId } from "@rynx-ai/core";
+function isDurableSessionEvent(event) {
+    return event.type === "response.output_item.done" ||
+        event.type === "session.input.consumed" ||
+        event.type === "session.interaction.requested" ||
+        event.type === "session.interaction.resolved" ||
+        event.type === "session.interaction.cancelled";
+}
+/**
+ * Events produced while a native Provider is crossing a logical Session
+ * rotation are normalized before the new Rynx id is known. Re-stamp both the
+ * envelope and any durable item before releasing that buffer into the target.
+ */
+function retargetSessionEvent(event, sessionId) {
+    const retargeted = structuredClone(event);
+    if (typeof retargeted.sessionId === "string")
+        retargeted.sessionId = sessionId;
+    if (retargeted.item && typeof retargeted.item.sessionId === "string") {
+        retargeted.item.sessionId = sessionId;
+    }
+    return retargeted;
+}
 import { resolveAllowedRoots, } from "@rynx-ai/core";
 export { FileCodexSessionStore, resolveCodexSessionStorePath, };
 // The runtime error type lives in @rynx-ai/core (as AgentRuntimeError) so channels
@@ -1364,6 +1385,9 @@ export class LocalAgentHost {
                 ...(previous?.runtimeHomeOwnerSessionId
                     ? { runtimeHomeOwnerSessionId: previous.runtimeHomeOwnerSessionId }
                     : {}),
+                ...(previous?.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: previous.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             }))
                 .then(() => {
@@ -1528,6 +1552,9 @@ export class LocalAgentHost {
                 ...(existing?.runtimeHomeOwnerSessionId
                     ? { runtimeHomeOwnerSessionId: existing.runtimeHomeOwnerSessionId }
                     : {}),
+                ...(existing?.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: existing.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             });
         })
@@ -2168,13 +2195,13 @@ export class LocalAgentHost {
         const effectiveSettings = applyClaudePermissionModeSnapshot(inheritedSettings, live.permissionMode);
         const hookPermissionMode = live.permissionMode;
         const hookSettings = buildClaudeHookSettings({
-            bridgeDir: claudeBridgeDir(localThreadId),
+            bridgeDir: live.bridgeDir,
             ...(hookPermissionMode ? { permissionMode: hookPermissionMode } : {}),
             messageDisplay: true,
             statusLine: true,
         });
         const settings = { ...effectiveSettings, ...hookSettings };
-        const settingsPath = writeManagedClaudeSettings(claudeBridgeDir(localThreadId), settings);
+        const settingsPath = writeManagedClaudeSettings(live.bridgeDir, settings);
         // The live session carries the daemon-owned execution state used by Chat.
         const args = buildClaudeTuiArgs({
             settingsJson: settingsPath,
@@ -2192,11 +2219,9 @@ export class LocalAgentHost {
                 : {}),
             additionalDirs: providerAdditionalDirs(live.workspace),
             ...(live.forkIntent
-                ? {
-                    resume: live.forkIntent.sourceClaudeSessionId,
-                    forkSession: true,
-                    sessionId: live.forkIntent.targetClaudeSessionId,
-                }
+                ? live.forkTranscriptPrepared
+                    ? { resume: live.forkIntent.targetClaudeSessionId }
+                    : { sessionId: live.forkIntent.targetClaudeSessionId }
                 : record?.codexSessionId
                     ? { resume: record.codexSessionId }
                     : {}),
@@ -2312,19 +2337,96 @@ export class LocalAgentHost {
             throw error;
         }
     }
+    /** Repair the only cross-process crash window in native rotation. A target
+     * started through the Session registry proves that logical publication is
+     * durable; a published target in turn proves its source must no longer own
+     * the shared live bridge. */
+    async reconcileClaudeNativeRotation(localThreadId, record) {
+        const records = await this.sessionStore.listAll();
+        let current = record;
+        const ownTarget = current?.nativeRotationSourceSessionId
+            ? current
+            : undefined;
+        let promotedOwnTarget = false;
+        const ownTargetSharedBridgeOwner = ownTarget?.bridgeOwnerSessionId;
+        if (ownTarget && !ownTarget.nativeRotationPublished) {
+            promotedOwnTarget = true;
+            current = {
+                ...ownTarget,
+                // Recovery cannot resume the interrupted physical handoff. Give the
+                // visible target its own bridge before publishing it, so a source that
+                // was reopened first can never share hooks/cursors with this process.
+                // The persisted initial transcript offset remains the replay boundary.
+                bridgeOwnerSessionId: ownTarget.localThreadId,
+                nativeRotationPublished: true,
+                updatedAt: new Date().toISOString(),
+            };
+            await this.sessionStore.set(current);
+        }
+        const linkedTarget = current?.nativeRotationTargetSessionId
+            ? records.find((candidate) => candidate.localThreadId === current?.nativeRotationTargetSessionId &&
+                candidate.nativeRotationPublished &&
+                candidate.nativeRotationSourceSessionId === localThreadId)
+            : undefined;
+        const legacyLatestTarget = records
+            .filter((candidate) => candidate.nativeRotationPublished &&
+            candidate.nativeRotationSourceSessionId === localThreadId)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) ||
+            b.localThreadId.localeCompare(a.localThreadId))[0];
+        // A Session can be both an inbound target (A→B) and later an outbound
+        // source (B→C). Its latest outbound edge is authoritative for reopening B;
+        // choosing B's older inbound marker would reopen the bridge now owned by C.
+        const publishedTarget = linkedTarget ?? legacyLatestTarget ??
+            (current?.nativeRotationSourceSessionId && current.nativeRotationPublished
+                ? current
+                : undefined);
+        if (publishedTarget) {
+            const source = await this.sessionStore.get(publishedTarget.nativeRotationSourceSessionId);
+            const kind = publishedTarget.nativeRotationKind ?? "clear";
+            const retiredBridgeOwner = `${source?.localThreadId ?? localThreadId}-${kind}-retired-${publishedTarget.localThreadId}`;
+            // A source can rotate more than once after its old conversation is
+            // reopened. Never let opening an historical target roll the source's
+            // authoritative outbound link back from S->T2 to the older S->T1 edge.
+            // Records written before nativeRotationTargetSessionId existed are only
+            // repairable when source and target still prove they share one bridge.
+            const sharedBridgeProof = promotedOwnTarget && publishedTarget.localThreadId === current?.localThreadId
+                ? ownTargetSharedBridgeOwner
+                : publishedTarget.bridgeOwnerSessionId;
+            const isAuthoritativeTarget = source && (source.nativeRotationTargetSessionId === publishedTarget.localThreadId ||
+                (!source.nativeRotationTargetSessionId &&
+                    source.bridgeOwnerSessionId === sharedBridgeProof));
+            if (isAuthoritativeTarget && source.bridgeOwnerSessionId !== retiredBridgeOwner) {
+                const retired = {
+                    ...source,
+                    bridgeOwnerSessionId: retiredBridgeOwner,
+                    nativeRotationTargetSessionId: publishedTarget.localThreadId,
+                    updatedAt: new Date().toISOString(),
+                };
+                await this.sessionStore.set(retired);
+                if (source.localThreadId === localThreadId)
+                    current = retired;
+            }
+        }
+        return current;
+    }
     async startLiveClaudeSession(localThreadId, emit, record, opts) {
         const retargetMirror = opts.retargetMirror;
+        record = await this.reconcileClaudeNativeRotation(localThreadId, record);
         const forkIntent = await this.sessionStore.getClaudeForkIntent?.(localThreadId) ?? null;
         if (forkIntent && forkIntent.targetSessionId !== localThreadId) {
             throw new CodexRuntimeError("Claude fork intent targets a different Session", 409, "invalid_fork_intent");
         }
-        const bridgeDir = prepareClaudeBridgeDir(localThreadId);
+        const runtimeHomeOwnerSessionId = record?.runtimeHomeOwnerSessionId ?? localThreadId;
+        const bridgeOwnerSessionId = record?.bridgeOwnerSessionId ?? runtimeHomeOwnerSessionId;
+        const bridgeDir = prepareClaudeBridgeDir(bridgeOwnerSessionId);
         const workspace = structuredClone(opts.workspace);
         const execution = structuredClone(opts.execution);
         if (execution.provider !== "claude") {
             throw new CodexRuntimeError(`cannot launch Claude from ${execution.provider} execution snapshot`, 422, "invalid_execution_snapshot");
         }
         const cwd = workspace.cwd;
+        const forkResumePrefixBytes = forkIntent?.forkTranscriptPrefixBytes;
+        const forkTranscriptPrepared = Boolean(forkIntent?.forkTranscriptPath);
         const hasSkillSnapshot = execution.skills.length > 0 || execution.pluginSkills.length > 0;
         let skillPlugin = hasSkillSnapshot
             ? await reuseClaudePlugin(localThreadId)
@@ -2356,13 +2458,65 @@ export class LocalAgentHost {
         let currentSessionId = localThreadId;
         let normalizer = null;
         let currentResponseId;
+        const subagentParentResponseIds = new Map();
+        const lateSubagentNormalizers = new Map();
         let pendingRotationEvents = null;
-        const emitCurrent = (event) => {
+        let rotationPublication = null;
+        let transcriptDelivery = null;
+        const emitRotationAware = (event, delivery) => {
             if (pendingRotationEvents) {
-                pendingRotationEvents.push(event);
+                pendingRotationEvents.push({ event, ...(delivery ? { delivery } : {}) });
                 return;
             }
-            emit(event);
+            return emit(event, delivery);
+        };
+        const publishForwarderFailure = (reason, responseId) => {
+            void Promise.resolve().then(() => emitRotationAware({
+                type: "session.status",
+                sessionId: currentSessionId,
+                ...(responseId ? { responseId } : {}),
+                status: "failed",
+                backgroundTaskCount: 0,
+                note: reason,
+            }, { policy: "best-effort", lane: "claude-forwarder-failure" })).catch((error) => {
+                console.error("[claude-forwarder] failed to publish poison-item status:", error);
+            });
+        };
+        const emitCurrent = (event, delivery) => {
+            if (pendingRotationEvents) {
+                pendingRotationEvents.push({ event, ...(delivery ? { delivery } : {}) });
+                return;
+            }
+            const source = transcriptDelivery;
+            if (source && isDurableSessionEvent(event)) {
+                const sourceId = `${source.sourceBase}:${source.nextItemIndex}:${event.item.type}`;
+                source.nextItemIndex += 1;
+                source.sourceIds.push(sourceId);
+                if (source.isHandled(sourceId))
+                    return;
+                const policy = delivery?.policy ?? "ordinary";
+                const pending = Promise.resolve(emit(event, {
+                    policy,
+                    sourceId,
+                    lane: delivery?.lane ?? source.lane,
+                    ...(policy === "ordinary"
+                        ? { deadLetterPath: delivery?.deadLetterPath ?? source.deadLetterPath }
+                        : {}),
+                    onOutcome: (outcome) => {
+                        delivery?.onOutcome?.(outcome);
+                        if (policy === "ordinary" &&
+                            outcome === "dropped" &&
+                            !source.lane.startsWith("claude-subagent:")) {
+                            publishForwarderFailure(`transcript item ${sourceId} rejected`, event.item.responseId);
+                        }
+                    },
+                })).then(() => {
+                    source.onHandled?.(sourceId);
+                });
+                source.pending.push(pending);
+                return pending;
+            }
+            return emit(event, delivery ?? { policy: "best-effort" });
         };
         const startNormalizer = (turnId) => {
             // turnId unknown → fixed literal (never random), aligning reference implementation `_response_id`.
@@ -2377,6 +2531,45 @@ export class LocalAgentHost {
             });
             return normalizer;
         };
+        const rememberSubagentParentResponse = (parentToolCallId, responseId) => {
+            if (subagentParentResponseIds.has(parentToolCallId))
+                return;
+            subagentParentResponseIds.set(parentToolCallId, responseId);
+            while (subagentParentResponseIds.size > 2_000) {
+                const oldest = subagentParentResponseIds.keys().next().value;
+                if (!oldest)
+                    break;
+                subagentParentResponseIds.delete(oldest);
+                lateSubagentNormalizers.delete(oldest);
+            }
+        };
+        const subagentNormalizer = (parentToolCallId) => {
+            let value = lateSubagentNormalizers.get(parentToolCallId);
+            if (!value) {
+                const responseId = subagentParentResponseIds.get(parentToolCallId) ??
+                    `resp_claude_parent_${createHash("sha256")
+                        .update(parentToolCallId)
+                        .digest("hex")
+                        .slice(0, 20)}`;
+                value = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: model || "claude",
+                });
+                lateSubagentNormalizers.set(parentToolCallId, value);
+            }
+            return value;
+        };
+        const emitSubagentEvents = (events) => {
+            for (const event of events) {
+                // Rynx keeps native child items nested in the parent Session, but its
+                // child normalizer remains
+                // lifecycle-isolated and must never open/reopen a parent Response.
+                if ((event.type === "response.created" || event.type === "session.status"))
+                    continue;
+                emitCurrent(event);
+            }
+        };
         const forwardInteraction = (event) => {
             const n = normalizer ?? startNormalizer(event.turnId);
             const agentEvent = event.type === "requested"
@@ -2392,8 +2585,20 @@ export class LocalAgentHost {
                         interactionId: event.interactionId,
                         ...(event.reason ? { reason: event.reason } : {}),
                     };
-            for (const se of n.next(agentEvent))
-                emitCurrent(se);
+            // Permission/question elicitation stays on a separate live hook
+            // side-channel rather than the durable transcript forwarder. Rynx stores
+            // a delivered card for UI replay, but intentionally does not make this
+            // bridge spool advance or block the transcript cursor.
+            for (const se of n.next(agentEvent)) {
+                try {
+                    void Promise.resolve(emitRotationAware(se, { policy: "best-effort", lane: "claude-interaction" })).catch((error) => {
+                        console.error("[claude-forwarder] interaction mirror failed:", error);
+                    });
+                }
+                catch (error) {
+                    console.error("[claude-forwarder] interaction mirror failed:", error);
+                }
+            }
         };
         let markReady;
         const ready = new Promise((resolve) => {
@@ -2408,7 +2613,10 @@ export class LocalAgentHost {
             workspace,
             execution,
             bridgeDir,
+            runtimeHomeOwnerSessionId,
+            bridgeOwnerSessionId,
             injectLock: Promise.resolve(),
+            rotationPending: false,
             pendingImageInputs: new Map(),
             pendingInjectedInputs: [],
             currentResponseId: () => currentResponseId,
@@ -2422,6 +2630,8 @@ export class LocalAgentHost {
             launchExtraArgs,
             permissionMode,
             ...(forkIntent ? { forkIntent } : {}),
+            ...(forkResumePrefixBytes !== undefined ? { forkResumePrefixBytes } : {}),
+            ...(forkTranscriptPrepared ? { forkTranscriptPrepared: true } : {}),
         };
         live.publishInterrupted = (responseId) => {
             if (live.interruptedResponseId === responseId)
@@ -2433,27 +2643,34 @@ export class LocalAgentHost {
                 responseId,
             });
         };
-        const settleClaudeTurn = (interrupted, usage, backgroundTaskCount) => {
+        const settleClaudeTurn = (interrupted, usage, backgroundTaskCount, reason) => {
             if (!normalizer)
                 return;
+            const settlementDelivery = reason === "rotation"
+                ? { policy: "best-effort", lane: "control" }
+                : undefined;
+            const publishSettlement = (event) => {
+                void emitCurrent(event, settlementDelivery);
+            };
             const rid = currentResponseId;
             if (interrupted) {
                 for (const se of normalizer.interrupt()) {
                     if (se.type === "session.interrupted" &&
                         live.interruptedResponseId === rid)
                         continue;
-                    emitCurrent(se);
+                    publishSettlement(se);
                 }
                 live.interruptedResponseId = undefined;
             }
             else {
                 // statusLine usage (context/cost) rides the turn's response.completed.
                 if (usage) {
-                    for (const se of normalizer.next({ type: "turn_completed", usage }))
-                        emitCurrent(se);
+                    for (const se of normalizer.next({ type: "turn_completed", usage })) {
+                        publishSettlement(se);
+                    }
                 }
                 for (const se of normalizer.next({ type: "done" })) {
-                    emitCurrent(se.type === "session.status" && backgroundTaskCount !== undefined
+                    publishSettlement(se.type === "session.status" && backgroundTaskCount !== undefined
                         ? { ...se, backgroundTaskCount }
                         : se);
                 }
@@ -2466,7 +2683,7 @@ export class LocalAgentHost {
             const pct = usage && typeof usage.used_percentage === "number" ? usage.used_percentage : undefined;
             if (!interrupted && rid && pct !== undefined && !live.contextWarned && pct >= CONTEXT_WARN_RATIO * 100) {
                 live.contextWarned = true;
-                emitCurrent({
+                publishSettlement({
                     type: "session.status",
                     sessionId: currentSessionId,
                     responseId: rid,
@@ -2476,6 +2693,30 @@ export class LocalAgentHost {
             }
         };
         const sink = {
+            onTranscriptRecordStart: (sourceBase, isHandled, delivery) => {
+                if (transcriptDelivery) {
+                    throw new Error("Claude transcript delivery record overlapped");
+                }
+                transcriptDelivery = {
+                    sourceBase,
+                    nextItemIndex: 0,
+                    isHandled,
+                    sourceIds: [],
+                    pending: [],
+                    lane: delivery?.lane ?? "claude-main",
+                    deadLetterPath: delivery?.deadLetterPath ??
+                        path.join(bridgeDir, "dead_letter.jsonl"),
+                    ...(delivery?.onHandled ? { onHandled: delivery.onHandled } : {}),
+                };
+            },
+            onTranscriptRecordEnd: async () => {
+                const source = transcriptDelivery;
+                if (!source)
+                    return [];
+                transcriptDelivery = null;
+                await Promise.all(source.pending);
+                return source.sourceIds;
+            },
             onTurnStart: (turnId) => startNormalizer(turnId),
             onUserMessage: (text) => {
                 const n = normalizer ?? startNormalizer();
@@ -2495,14 +2736,112 @@ export class LocalAgentHost {
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
+            onMetaUserMessage: (text, sourceKey, parentToolCallId) => {
+                const responseId = parentToolCallId
+                    ? subagentParentResponseIds.get(parentToolCallId) ??
+                        `resp_claude_parent_${createHash("sha256")
+                            .update(parentToolCallId)
+                            .digest("hex")
+                            .slice(0, 20)}`
+                    : `resp_claude_meta_${createHash("sha256")
+                        .update(sourceKey ?? text)
+                        .digest("hex")
+                        .slice(0, 20)}`;
+                const metaNormalizer = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: model || "claude",
+                });
+                for (const event of metaNormalizer.userInput(text, parentToolCallId)) {
+                    if (event.type !== "session.input.consumed" || event.item.type !== "message")
+                        continue;
+                    emitCurrent({
+                        ...event,
+                        item: {
+                            ...event.item,
+                            data: { ...event.item.data, isMeta: true },
+                        },
+                    });
+                }
+            },
+            onSubagentUserMessage: (text, parentToolCallId) => {
+                const nested = subagentNormalizer(parentToolCallId);
+                emitSubagentEvents(nested.userInput(text, parentToolCallId));
+            },
+            onSubagentTerminalCommand: (command, parentToolCallId) => {
+                const nested = subagentNormalizer(parentToolCallId);
+                emitSubagentEvents(nested.terminalCommand(command, parentToolCallId));
+            },
+            resolveSubagentParentResponseId: (parentToolCallId) => subagentParentResponseIds.get(parentToolCallId),
+            onSubagentParentResponse: (parentToolCallId, responseId) => {
+                rememberSubagentParentResponse(parentToolCallId, responseId);
+            },
             onTerminalCommand: (cmd) => {
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.terminalCommand(cmd))
                     emitCurrent(se);
             },
             onTodos: (todos) => emitCurrent({ type: "session.todos", sessionId: currentSessionId, todos }),
+            onCompactionStatus: (status) => {
+                void emitCurrent({
+                    type: `response.compaction.${status}`,
+                    sessionId: currentSessionId,
+                    ...(currentResponseId ? { responseId: currentResponseId } : {}),
+                }, { policy: "best-effort", lane: "claude-compaction" });
+            },
+            onCompactionBoundary: (summary, sequence, source) => {
+                let outcome;
+                const responseId = currentResponseId ?? "resp_claude_native";
+                const delivery = emitCurrent({
+                    type: "response.output_item.done",
+                    responseId,
+                    item: {
+                        id: newSessionItemId("compaction"),
+                        sessionId: currentSessionId,
+                        position: 0,
+                        responseId,
+                        status: "completed",
+                        createdAt: Date.now(),
+                        type: "compaction",
+                        data: { summary, sequence },
+                    },
+                }, {
+                    policy: source === "transcript" ? "compaction" : "compaction-hook",
+                    // A transcript compaction is still one ordered transcript record.
+                    // Only the independent hook boundary gets its own delivery lane.
+                    lane: source === "transcript" ? "claude-main" : "claude-compaction",
+                    onOutcome: (value) => { outcome = value; },
+                });
+                return Promise.resolve(delivery).then(() => outcome === undefined || outcome === "confirmed" || outcome === "ambiguous");
+            },
             onEvent: (event) => {
+                const parentToolCallId = "parentToolUseId" in event &&
+                    typeof event.parentToolUseId === "string"
+                    ? event.parentToolUseId
+                    : undefined;
+                if (parentToolCallId) {
+                    const nested = subagentNormalizer(parentToolCallId);
+                    emitSubagentEvents(nested.next(event));
+                    return;
+                }
                 const n = normalizer ?? startNormalizer();
+                if (currentResponseId &&
+                    event.type === "tool" &&
+                    event.event === "on_tool_start") {
+                    const input = typeof event.input === "object" && event.input !== null
+                        ? event.input
+                        : {};
+                    const data = typeof event.data === "object" && event.data !== null
+                        ? event.data
+                        : {};
+                    const parentId = typeof input.id === "string"
+                        ? input.id
+                        : typeof data.id === "string"
+                            ? data.id
+                            : undefined;
+                    if (parentId)
+                        rememberSubagentParentResponse(parentId, currentResponseId);
+                }
                 for (const se of n.next(event))
                     emitCurrent(se);
             },
@@ -2518,114 +2857,229 @@ export class LocalAgentHost {
                     ...(blockedOn ? { note: blockedOn } : {}),
                 });
             },
-            onTurnEnd: (usage, backgroundTaskCount) => settleClaudeTurn(false, usage, backgroundTaskCount),
+            onTurnEnd: (usage, backgroundTaskCount, reason) => settleClaudeTurn(false, usage, backgroundTaskCount, reason),
             onTurnInterrupted: (usage) => settleClaudeTurn(true, usage),
             onTurnInterruptRequested: () => {
                 const responseId = currentResponseId;
                 if (responseId)
                     live.publishInterrupted(responseId);
             },
-            onIdle: (backgroundTaskCount) => {
+            onIdle: (backgroundTaskCount, sourceId) => {
                 // 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({
+                return emitCurrent({
                     type: "session.status",
                     sessionId: currentSessionId,
                     ...(currentResponseId ? { responseId: currentResponseId } : {}),
                     status: "idle",
                     ...(backgroundTaskCount === undefined ? {} : { backgroundTaskCount }),
+                }, {
+                    policy: "terminal-status",
+                    lane: "claude-status",
+                    ...(sourceId ? { sourceId } : {}),
+                    onOutcome: (outcome) => {
+                        if (outcome === "dropped") {
+                            publishForwarderFailure(`hook status idle rejected`, currentResponseId);
+                        }
+                    },
                 });
             },
-            onTurnError: (error) => {
+            onTurnError: (error, sourceId) => {
                 const message = error.message || "Agent turn failed";
                 if (!normalizer) {
                     // Native pane/forwarder death is Session-level even when Claude is
                     // between Turns. Emit a bare failed edge; the
                     // explicit zero also retires any sticky background-shell tally.
-                    emitCurrent({
+                    return emitCurrent({
                         type: "session.status",
                         sessionId: currentSessionId,
                         status: "failed",
                         backgroundTaskCount: 0,
                         note: message,
+                    }, {
+                        policy: "terminal-status",
+                        lane: "claude-status",
+                        ...(sourceId ? { sourceId } : {}),
                     });
-                    return;
                 }
                 const rid = currentResponseId;
+                const deliveries = [];
+                let itemIndex = 0;
                 for (const se of normalizer.fail({
                     code: "agent_error",
                     message,
                     source: "execution",
                 })) {
-                    emitCurrent(se.type === "session.status"
+                    const event = se.type === "session.status"
                         ? { ...se, status: "failed", note: message }
-                        : se);
+                        : se;
+                    const durable = isDurableSessionEvent(event);
+                    const eventSourceId = sourceId
+                        ? `${sourceId}:${itemIndex++}:${durable && "item" in event ? event.item.type : event.type}`
+                        : undefined;
+                    const delivered = emitCurrent(event, {
+                        policy: durable ? "ordinary" : "terminal-status",
+                        lane: "claude-status",
+                        ...(eventSourceId ? { sourceId: eventSourceId } : {}),
+                        ...(durable
+                            ? { deadLetterPath: path.join(bridgeDir, "dead_letter.jsonl") }
+                            : {}),
+                    });
+                    if (delivered)
+                        deliveries.push(Promise.resolve(delivered));
                 }
                 live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
                 normalizer = null;
                 currentResponseId = undefined;
+                return Promise.all(deliveries).then(() => undefined);
             },
             onSessionDiscovered: (claudeSessionId) => this.onClaudeDiscovered(live, localThreadId, claudeSessionId),
             onSessionResumeError: (error) => {
                 live.error = error.message;
                 live.markFailed();
             },
-            onSessionRotated: (kind, claudeSessionId) => {
-                if (pendingRotationEvents) {
-                    live.error = "Claude reported another Session rotation before publication completed";
-                    live.markFailed();
-                    return;
+            onSessionRotated: (kind, claudeSessionId, _transcriptPath, initialTranscriptOffset) => {
+                let publication = rotationPublication?.claudeSessionId === claudeSessionId &&
+                    rotationPublication.kind === kind
+                    ? rotationPublication
+                    : null;
+                if (publication?.operation)
+                    return publication.operation;
+                if (publication?.completed)
+                    return Promise.resolve();
+                if (!publication && pendingRotationEvents) {
+                    return Promise.reject(new Error("Claude reported another Session rotation before publication completed"));
                 }
-                // The forwarder already closed the old turn (onTurnEnd) + re-pointed to the
-                // new transcript. Persist the Provider binding first, then announce on
-                // the OLD session and re-target the mirror. Events produced during the
-                // file-store commit are buffered so none can land under the old identity.
-                const previousSessionId = currentSessionId;
-                const newSessionId = makeSessionId();
-                currentSessionId = newSessionId;
-                normalizer = null;
-                currentResponseId = undefined;
-                live.contextWarned = false;
-                pendingRotationEvents = [];
-                this.liveClaudeSessions.set(newSessionId, live);
-                this.liveClaudeSessions.delete(previousSessionId);
-                void this.sessionStore
-                    .set({
-                    localThreadId: newSessionId,
-                    codexSessionId: claudeSessionId,
-                    ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
-                    updatedAt: new Date().toISOString(),
-                })
-                    .then(() => {
-                    emit({
-                        type: "session.rotated",
-                        sessionId: previousSessionId,
-                        newSessionId,
+                // Persist the Provider binding, then wait for the runner manager to
+                // publish and ACK the new alias. The parent announces the rotation on
+                // the OLD Session only after that target publication succeeds.
+                // The forwarder does not consume the SessionStart hook or switch source
+                // state until this operation resolves.
+                if (!publication) {
+                    // Claude has already crossed its physical clear/fork boundary by the
+                    // time this hook arrives. Fence injection synchronously, before the
+                    // first asynchronous target-store operation or IPC publication.
+                    live.rotationPending = true;
+                    publication = {
+                        claudeSessionId,
                         kind,
+                        initialTranscriptOffset,
+                        previousSessionId: currentSessionId,
+                        newSessionId: makeSessionId(),
+                    };
+                    rotationPublication = publication;
+                }
+                const { previousSessionId } = publication;
+                // An exact publication retry keeps events buffered during the failed
+                // attempt; they already belong to this same post-rotation target.
+                pendingRotationEvents ??= [];
+                const operation = this.sessionStore
+                    .findByCodexSessionId(claudeSessionId)
+                    .then(async (existingTarget) => {
+                    if (existingTarget &&
+                        existingTarget.localThreadId !== previousSessionId) {
+                        publication.newSessionId = existingTarget.localThreadId;
+                    }
+                    if (existingTarget?.nativeRotationInitialTranscriptOffset !== undefined) {
+                        publication.initialTranscriptOffset =
+                            existingTarget.nativeRotationInitialTranscriptOffset;
+                    }
+                    await this.sessionStore.set({
+                        localThreadId: publication.newSessionId,
+                        codexSessionId: claudeSessionId,
+                        ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
+                        runtimeHomeOwnerSessionId: live.runtimeHomeOwnerSessionId,
+                        bridgeOwnerSessionId: live.bridgeOwnerSessionId,
+                        nativeRotationSourceSessionId: previousSessionId,
+                        nativeRotationKind: kind,
+                        nativeRotationInitialTranscriptOffset: publication.initialTranscriptOffset,
+                        ...(existingTarget?.nativeRotationPublished
+                            ? { nativeRotationPublished: true }
+                            : {}),
+                        updatedAt: new Date().toISOString(),
                     });
-                    retargetMirror?.(newSessionId, {
+                })
+                    .then(async () => {
+                    const applyHostTarget = async () => {
+                        if (publication.hostApplied)
+                            return;
+                        const newSessionId = publication.newSessionId;
+                        const targetBinding = await this.sessionStore.get(newSessionId);
+                        if (targetBinding && !targetBinding.nativeRotationPublished) {
+                            await this.sessionStore.set({
+                                ...targetBinding,
+                                nativeRotationPublished: true,
+                                updatedAt: new Date().toISOString(),
+                            });
+                        }
+                        const sourceBinding = await this.sessionStore.get(previousSessionId);
+                        const retiredBridgeOwner = `${previousSessionId}-${kind}-retired-${newSessionId}`;
+                        if (sourceBinding &&
+                            sourceBinding.bridgeOwnerSessionId !== retiredBridgeOwner) {
+                            await this.sessionStore.set({
+                                ...sourceBinding,
+                                bridgeOwnerSessionId: retiredBridgeOwner,
+                                nativeRotationTargetSessionId: newSessionId,
+                                updatedAt: new Date().toISOString(),
+                            });
+                        }
+                        currentSessionId = newSessionId;
+                        normalizer = null;
+                        currentResponseId = undefined;
+                        live.contextWarned = false;
+                        this.liveClaudeSessions.set(newSessionId, live);
+                        this.liveClaudeSessions.delete(previousSessionId);
+                        const queued = pendingRotationEvents ?? [];
+                        pendingRotationEvents = null;
+                        live.rotationPending = false;
+                        publication.hostApplied = true;
+                        for (const entry of queued) {
+                            emit(retargetSessionEvent(entry.event, newSessionId), entry.delivery);
+                        }
+                    };
+                    await Promise.resolve(retargetMirror?.(publication.newSessionId, {
                         kind,
                         workspace: structuredClone(live.workspace),
                         execution: structuredClone(live.execution),
                         ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
-                    });
-                    const queued = pendingRotationEvents ?? [];
-                    pendingRotationEvents = null;
-                    for (const event of queued)
-                        emit(event);
+                        beforeApplied: applyHostTarget,
+                    }));
+                    if (!publication.hostApplied) {
+                        throw new Error("Claude retarget completed without applying the host target");
+                    }
+                    publication.completed = true;
                 })
                     .catch((error) => {
-                    pendingRotationEvents = null;
+                    // Keep the fence and buffered events across an exact publication
+                    // retry. Re-opening either here would leak post-clear work back to
+                    // the retired logical Session.
                     live.error = error instanceof Error ? error.message : String(error);
                     live.markFailed();
+                    if (typeof error === "object" &&
+                        error !== null &&
+                        "classification" in error &&
+                        error.classification === "permanent") {
+                        // A deterministic target-publication rejection cannot recover by
+                        // polling the same hook forever. Keep injection fenced and stop
+                        // the forwarder so restart/operator action is explicit.
+                        queueMicrotask(() => live.forwarder.stop());
+                    }
+                    throw error;
+                })
+                    .finally(() => {
+                    if (rotationPublication === publication) {
+                        delete publication.operation;
+                    }
                 });
+                publication.operation = operation;
+                return operation;
             },
         };
-        // Claude itself resolves `--resume <id>`. The SessionStart hook is the
-        // authoritative source for the actual transcript path; do not infer or
-        // generate Claude's private on-disk format here.
+        // Claude itself resolves `--resume <id>`. A managed fork pre-writes and
+        // measures its target prefix, but SessionStart remains authoritative for
+        // the transcript path the forwarder actually tails.
         live.forwarder = new ClaudeLiveSession({
             bridgeDir,
             sink,
@@ -2634,7 +3088,16 @@ export class LocalAgentHost {
                 : record?.codexSessionId
                     ? { claudeSessionId: record.codexSessionId }
                     : {}),
-            ...((forkIntent || record?.codexSessionId) ? { resumeAtEndOnDiscovery: true } : {}),
+            ...((record?.codexSessionId || forkTranscriptPrepared)
+                ? { resumeAtEndOnDiscovery: true }
+                : {}),
+            ...(forkResumePrefixBytes !== undefined
+                ? { initialTranscriptOffsetOnDiscovery: forkResumePrefixBytes }
+                : record?.nativeRotationInitialTranscriptOffset !== undefined
+                    ? {
+                        initialTranscriptOffsetOnDiscovery: record.nativeRotationInitialTranscriptOffset,
+                    }
+                    : {}),
         });
         this.liveClaudeSessions.set(localThreadId, live);
         live.forwarder.start();
@@ -2654,12 +3117,16 @@ export class LocalAgentHost {
         }
         live.discoveredReady = true;
         void this.sessionStore
-            .set({
+            .get(localThreadId)
+            .then((existing) => this.sessionStore.set({
+            ...existing,
             localThreadId,
             codexSessionId: claudeSessionId,
             ...(forkIntent ? { parentSessionId: forkIntent.sourceSessionId } : {}),
+            runtimeHomeOwnerSessionId: live.runtimeHomeOwnerSessionId,
+            bridgeOwnerSessionId: live.bridgeOwnerSessionId,
             updatedAt: new Date().toISOString(),
-        })
+        }))
             .then(() => this.sessionStore.deleteClaudeForkIntent?.(localThreadId))
             .then(() => live.markReady())
             .catch((error) => {
@@ -2673,15 +3140,24 @@ export class LocalAgentHost {
      *  appears (reference implementation RAISE), so a not-ready pane is a hard error — NOT a
      *  fall-through-to-run signal. Returns {@link InjectResult}. */
     injectClaude(live, localThreadId, text, pendingInput) {
+        if (live.rotationPending || live.stopped) {
+            return Promise.resolve({ outcome: "notReady" });
+        }
         const run = live.injectLock.then(async () => {
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
             const ready = await this.waitLiveReady(localThreadId, 60_000);
             if (!ready)
                 return { outcome: "notReady" };
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
             // Pane may have just relaunched — park until its injector re-attaches
             // (attachTerminalInjector resets it) instead of returning false → fallback.
             const injector = await this.waitInjector(live, 60_000);
             if (!injector)
                 return { outcome: "notReady" };
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
             const steered = live.forwarder.isTurnOpen();
             // Abortable: the web Stop button cancels an in-flight paste/submit (before
             // the message reaches claude) via interruptLive → injectAbort.abort().
@@ -2907,6 +3383,9 @@ export class LocalAgentHost {
                 codexSessionId: forkedThreadId,
                 parentSessionId: currentLocalThreadId,
                 runtimeHomeOwnerSessionId: sourceHomeOwner,
+                ...(record.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: record.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             });
             return { ok: true, data: undefined };