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

package/dist/claude/native-integration.js

@@ -18,11 +18,17 @@
  * backstop — but only when no tool call is still open, so a long Bash never trips
  * a false turn-end.
  */
-import { statSync } from "node:fs";
-import { parseTerminalCommand, parseTranscriptRecord, readSubagentEvents, subagentTranscriptPath, transcriptHasForkedFrom, } from "./transcript.js";
-import { HOOKS_FILE, jsonlCursorFingerprint, interactionLeaseUpdatedAt, readClaimedInteractionResult, readClaudeStatus, readForwardState, readHookForwardState, readInteractionAcksFrom, readHookEventsFrom, readInteractionRequestsFrom, readJsonlFrom, readMessageDeltasFrom, resetForwardState, removeClaimedInteractionResult, removeInteractionLease, removeInteractionResult, scrubClaudeInteractionArtifacts, writeInteractionResult, writeForwardState, writeHookForwardState, } from "./native-bridge.js";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { parseTerminalCommandFragments, parseTranscriptRecord, subagentTranscriptPath, transcriptHasForkedFrom, transcriptHasRecentLocalCommand, } from "./transcript.js";
+import { HOOKS_FILE, jsonlCursorFingerprint, interactionLeaseUpdatedAt, readClaimedInteractionResult, readClaudeState, readClaudeStatus, readCompactionForwardState, readDeltaForwardState, readForwardState, readHookForwardState, readInteractionAcksFrom, readHookEventsFrom, readInteractionRequestsFrom, readJsonlEntriesFrom, readMessageDeltasFrom, readSubagentForwardStates, readSubagentParentResponses, resetForwardState, resetSubagentForwardStates, removeClaimedInteractionResult, removeInteractionLease, removeInteractionResult, scrubClaudeInteractionArtifacts, writeInteractionResult, writeForwardState, writeDeltaForwardState, writeCompactionForwardState, writeHookForwardState, writeSubagentForwardStates, } from "./native-bridge.js";
 import { boundInteractionRequest, redactInteractionResolution, validateInteractionResolution, } from "../interactions.js";
 import { ClaudeSessionStatusPoller, } from "./session-status.js";
+function cloneTerminalCommand(command) {
+    return command
+        ? { command: command.command, ...(command.turnId ? { turnId: command.turnId } : {}) }
+        : undefined;
+}
 const MAX_SETTLED_INTERACTIONS = 512;
 const MAX_MESSAGE_CORRELATION_BACKLOG = 64;
 const MAX_SUBMISSION_OBSERVATIONS = 64;
@@ -56,6 +62,76 @@ function userStringContent(rec) {
         return undefined; // tool_result records are arrays
     return content.trim() || undefined;
 }
+function queuedCommandPrompt(rec) {
+    if (rec.type !== "attachment" || !isRecord(rec.attachment))
+        return undefined;
+    if (rec.attachment.type !== "queued_command" ||
+        rec.attachment.commandMode !== "prompt")
+        return undefined;
+    return typeof rec.attachment.prompt === "string" && rec.attachment.prompt
+        ? rec.attachment.prompt
+        : undefined;
+}
+function topLevelLocalCommand(rec) {
+    if (rec.subtype !== "local_command" || typeof rec.content !== "string")
+        return undefined;
+    return parseTerminalCommandFragments(rec.content);
+}
+function transcriptLocalCommand(rec) {
+    const stringContent = userStringContent(rec);
+    return topLevelLocalCommand(rec) ??
+        (stringContent === undefined ? undefined : parseTerminalCommandFragments(stringContent));
+}
+function terminalCommandData(fragments, priorCommand) {
+    return {
+        command: fragments.command ?? priorCommand ?? "",
+        ...(fragments.stdout !== undefined ? { stdout: fragments.stdout } : {}),
+        ...(fragments.stderr !== undefined ? { stderr: fragments.stderr } : {}),
+    };
+}
+const CLI_SCAFFOLDING_MARKERS = [
+    "<command-message>",
+    "<command-args>",
+    "<local-command-caveat>",
+    "<local-command-stdout>",
+    "<local-command-stderr>",
+];
+function isTaskNotificationText(text) {
+    const stripped = text.trimStart();
+    return stripped.startsWith("<task-notification>") &&
+        stripped.includes("<task-id>") &&
+        stripped.includes("</task-notification>");
+}
+function isClaudeUserScaffolding(text) {
+    const stripped = text.trimStart();
+    return stripped.includes("<command-name>") ||
+        CLI_SCAFFOLDING_MARKERS.some((marker) => stripped.startsWith(marker));
+}
+function userListTextMessages(rec) {
+    if (rec.type !== "user" || rec.message?.role !== "user")
+        return [];
+    const content = rec.message.content;
+    if (!Array.isArray(content))
+        return [];
+    const userTexts = [];
+    const messages = [];
+    for (const block of content) {
+        if (!isRecord(block) || block.type !== "text" || typeof block.text !== "string")
+            continue;
+        if (!block.text || isClaudeUserScaffolding(block.text))
+            continue;
+        if (isTaskNotificationText(block.text)) {
+            messages.push({ text: block.text, isMeta: true });
+        }
+        else {
+            userTexts.push(block.text);
+        }
+    }
+    if (userTexts.length > 0) {
+        messages.unshift({ text: userTexts.join(""), isMeta: false });
+    }
+    return messages;
+}
 function submissionText(value) {
     if (typeof value !== "string")
         return undefined;
@@ -83,15 +159,18 @@ function isRecord(value) {
 function readId(value) {
     return isRecord(value) && typeof value.id === "string" && value.id ? value.id : undefined;
 }
-/** Byte size of a file, or 0 if it can't be stat'd (used to start a fork tail at EOF). */
-function fileSize(path) {
+function fileByteSize(path) {
     try {
         return statSync(path).size;
     }
     catch {
-        return 0;
+        return undefined;
     }
 }
+/** Byte size of a file, or 0 if it can't be stat'd (used to start a fork tail at EOF). */
+function fileSize(path) {
+    return fileByteSize(path) ?? 0;
+}
 function readStr(value) {
     if (typeof value === "string" && value)
         return value;
@@ -129,17 +208,33 @@ function readTaskUpdates(rec) {
 function normalizeTodoStatus(status) {
     return status === "pending" || status === "in_progress" || status === "completed" ? status : undefined;
 }
-/** The `tool_use_id` of a record's tool_result block (the parent call it answers). */
-function toolResultCallId(rec) {
-    const content = rec.message?.content;
-    if (!Array.isArray(content))
+function readNativeSubagentMeta(path) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
         return undefined;
-    for (const block of content) {
-        if (isRecord(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
-            return block.tool_use_id;
-        }
     }
-    return undefined;
+    if (!isRecord(value))
+        return undefined;
+    const agentType = typeof value.agentType === "string" && value.agentType
+        ? value.agentType
+        : undefined;
+    const description = typeof value.description === "string" ? value.description : undefined;
+    const toolUseId = typeof value.toolUseId === "string" && value.toolUseId
+        ? value.toolUseId
+        : undefined;
+    return agentType && description !== undefined && toolUseId
+        ? { agentType, description, toolUseId }
+        : undefined;
+}
+function isSubagentTranscriptPath(path) {
+    return Boolean(path && /(?:^|[\\/])subagents(?:[\\/]|$)/u.test(path));
+}
+function transcriptSourceBase(rec, byteOffset, lineNumber) {
+    const stableId = rec.uuid || rec.requestId;
+    return stableId || `byte-${byteOffset}` || `line-${lineNumber}`;
 }
 export class ClaudeLiveSession {
     bridgeDir;
@@ -156,9 +251,24 @@ export class ClaudeLiveSession {
     releaseSleep;
     hooksOffset = 0;
     hookEventCursor = 0;
+    /** Rotation publication is a checkpoint barrier. No source is polled under
+     * either logical Session until the daemon confirms the new binding. */
+    rotationPending = false;
+    /** A non-rotation async hook (currently compaction completion) holds only the
+     * hook cursor and parent transcript. Native sub-agents, deltas, interactions,
+     * and live status continue to converge while its delivery retries. */
+    compactionHookPending = false;
+    pendingCompactionHook;
     interactionsOffset = 0;
     interactionAcksOffset = 0;
     transcriptOffset = 0;
+    committedTranscriptOffset = 0;
+    transcriptLineCursor = 0;
+    committedTranscriptLineCursor = 0;
+    transcriptDeliveryPending = false;
+    /** A transcript isCompactSummary boundary is currently in its durable lane.
+     * The completion-hook fallback must wait so the real summary remains primary. */
+    transcriptCompactionPending = false;
     /** Secondary dedup: source ids (record uuids) already forwarded, so a re-read
      *  (fingerprint reset / mid-poll death) doesn't re-emit. Persisted in the
      *  forwarder state; bounded there. */
@@ -170,11 +280,20 @@ export class ClaudeLiveSession {
     /** Persisted native id requested through `claude --resume`. */
     expectedClaudeSessionId;
     resumeAtEndOnDiscovery;
+    initialTranscriptOffsetOnDiscovery;
     /** Every claude session uuid seen — a resume into an UNSEEN id + a forkedFrom
      *  marker signals a `/fork` (vs. resuming a known branch). */
     seenClaudeSessionIds = new Set();
     turnOpen = false;
     currentTurnId;
+    /** Input half of a split Claude `!cmd`, plus the turn id its later output
+     * must reuse. Kept across a terminal Stop edge like the current terminal
+     * response id. */
+    activeTerminalCommand;
+    /** Split-command state at the latest individually handled source boundary.
+     * Parsing may run ahead through later records, so durable state must not use
+     * the mutable live value until those later items are ACKed too. */
+    committedTerminalCommand;
     /** The open turn received an explicit Escape/Stop and must close cancelled. */
     turnInterrupted = false;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
@@ -223,8 +342,17 @@ export class ClaudeLiveSession {
      *  append its request immediately before the failure hook lands; closing here
      *  would let the later interaction poll reopen an already-failed Turn. */
     turnFailurePending = null;
-    /** Sub-agent (Task) ids already forwarded — a Task tool_result is processed once. */
-    seenSubagents = new Set();
+    /** Stop/StopFailure owns the hook cursor until its terminal status reaches a
+     * handled delivery outcome. This preserves replay on runner restart. */
+    pendingTerminalHook;
+    terminalHookDelivery;
+    pendingTranscriptCompactions = [];
+    /** Claude Code native Task/Agent sidechains. Each child owns an independent
+     * cursor/retry lane so one unavailable delivery cannot block its siblings or
+     * the parent transcript. */
+    nativeSubagents = new Map();
+    nativeSubagentParentResponses = new Map();
+    subagentStateParentPath;
     /** The agent's task list, keyed by task id in creation order (claude
      *  `TaskCreate`/`TaskUpdate`). Emitted whole as a snapshot on any change. */
     todos = new Map();
@@ -232,6 +360,7 @@ export class ClaudeLiveSession {
      *  a turn's usage on close. undefined until the statusLine hook first fires. */
     latestStatus;
     deltasOffset = 0;
+    seenDeltaKeys = new Set();
     /** Finalized MessageDisplay ids in completion order, FIFO-mapped onto the
      *  transcript's assistant-text records so a streamed message and its final
      *  item share an itemId (message_id is absent from the transcript). */
@@ -254,7 +383,15 @@ export class ClaudeLiveSession {
             ((interactionId) => interactionLeaseUpdatedAt(this.bridgeDir, interactionId));
         this.expectedClaudeSessionId = opts.claudeSessionId;
         this.resumeAtEndOnDiscovery = opts.resumeAtEndOnDiscovery ?? false;
+        this.initialTranscriptOffsetOnDiscovery =
+            opts.initialTranscriptOffsetOnDiscovery === undefined
+                ? undefined
+                : Math.max(0, Math.trunc(opts.initialTranscriptOffsetOnDiscovery));
         this.transcriptPath = opts.transcriptPath;
+        for (const sessionId of readClaudeState(this.bridgeDir).seenClaudeSessionIds ?? []) {
+            this.seenClaudeSessionIds.add(sessionId);
+        }
+        this.deltasOffset = readDeltaForwardState(this.bridgeDir).byteOffset;
         const hookState = readHookForwardState(this.bridgeDir);
         if (hookState) {
             this.hooksOffset = hookState.byteOffset;
@@ -268,6 +405,7 @@ export class ClaudeLiveSession {
                 this.seenClaudeSessionIds.add(opts.claudeSessionId);
             }
             this.restoreForwardState(opts.transcriptPath);
+            this.restoreSubagentForwardStates(opts.transcriptPath);
         }
     }
     /**
@@ -284,23 +422,59 @@ export class ClaudeLiveSession {
             return false;
         for (const id of state.seenSourceIds)
             this.seenSourceIds.add(id);
+        const transcriptSize = fileByteSize(transcriptPath);
+        const transcriptMissing = transcriptSize === undefined;
         const fingerprint = jsonlCursorFingerprint(transcriptPath, state.byteOffset);
-        this.transcriptOffset =
-            fingerprint !== undefined && fingerprint === state.cursorFingerprint
-                ? state.byteOffset // cursor valid → resume here
-                : fileSize(transcriptPath); // truncated/replaced → skip to EOF
+        const cursorValid = fingerprint !== undefined && fingerprint === state.cursorFingerprint;
+        const adoptEmptyCursor = state.cursorFingerprint === undefined &&
+            state.byteOffset === 0 &&
+            (state.lineCursor ?? 0) === 0;
+        const restoreLogicalState = transcriptMissing || cursorValid || adoptEmptyCursor;
+        this.transcriptOffset = restoreLogicalState
+            ? state.byteOffset
+            : transcriptSize ?? 0; // truncated/replaced → skip to EOF
+        this.committedTranscriptOffset = this.transcriptOffset;
+        this.transcriptLineCursor = restoreLogicalState ? state.lineCursor ?? 0 : 0;
+        this.committedTranscriptLineCursor = this.transcriptLineCursor;
+        if (restoreLogicalState && state.activeTerminalCommand) {
+            this.activeTerminalCommand = cloneTerminalCommand(state.activeTerminalCommand);
+            this.committedTerminalCommand = cloneTerminalCommand(state.activeTerminalCommand);
+        }
+        if (restoreLogicalState && state.turnOpen) {
+            this.turnOpen = true;
+            this.currentTurnId = state.currentTurnId;
+            this.sink.onTurnStart(this.currentTurnId);
+        }
+        // Seed an adopted empty cursor, or rewrite the replacement state
+        // (EOF + seen ids only), so another crash cannot resurrect stale logical
+        // response or split-command state from a replaced transcript.
+        if (!transcriptMissing && !cursorValid)
+            this.persistForwardState();
         return true;
     }
     /** Persist the durable forwarder cursor (byte offset + seen ids + fingerprint). */
     persistForwardState() {
         if (!this.transcriptPath)
             return;
-        const fingerprint = jsonlCursorFingerprint(this.transcriptPath, this.transcriptOffset);
+        const fingerprint = jsonlCursorFingerprint(this.transcriptPath, this.committedTranscriptOffset);
         writeForwardState(this.bridgeDir, {
             transcriptPath: this.transcriptPath,
-            byteOffset: this.transcriptOffset,
+            byteOffset: this.committedTranscriptOffset,
+            lineCursor: this.committedTranscriptLineCursor,
             seenSourceIds: [...this.seenSourceIds],
             ...(fingerprint ? { cursorFingerprint: fingerprint } : {}),
+            ...(this.currentTurnId ? { currentTurnId: this.currentTurnId } : {}),
+            ...(this.committedTerminalCommand
+                ? { activeTerminalCommand: this.committedTerminalCommand }
+                : {}),
+            ...(this.turnOpen
+                ? {
+                    turnOpen: true,
+                    currentResponseId: this.currentTurnId
+                        ? `resp_claude_${this.currentTurnId}`
+                        : "resp_claude_native",
+                }
+                : {}),
         });
     }
     /** True once SessionStart bound the transcript (or a resume path was given). */
@@ -401,15 +575,34 @@ export class ClaudeLiveSession {
         this.claimedInteractions.clear();
         this.scheduledClaimScrubs.clear();
     }
-    /** One poll cycle (hooks → transcript → idle backstop). Exposed for tests to
+    /** One poll cycle (rotation/PreCompact prescan → transcript → hooks → live
+     * lanes → idle backstop). Exposed for tests to
      *  drive deterministically; the async {@link loop} just calls it on an interval. */
     tick() {
-        // Read the transcript first so a user record opens its Turn before any
-        // same-tick MessageDisplay chunks are handled. The correlation layer
-        // supports either completion order; this also lets pollDeltas safely drain
-        // late chunks while no Turn is open instead of leaking them into the next.
+        // Preserve the required phase order: rotation and PreCompact are pre-scanned,
+        // transcript items (including the real compact summary) run next, then the
+        // durable hook cursor catches up. This keeps completion hooks secondary
+        // without letting an older poison hook block clear/fork or token minting.
+        const hadTranscript = this.transcriptPath !== undefined;
+        this.prescanSessionRotation();
+        if (this.rotationPending)
+            return;
+        this.prescanPrecompactEdges();
+        // The hook and transcript compaction paths share one pending token. Do not
+        // let them race the same boundary, but do keep every independent live lane
+        // moving while the hook path waits for its ACK.
+        if (!this.compactionHookPending)
+            this.pollTranscript();
         this.pollHooks();
-        this.pollTranscript();
+        if (this.rotationPending)
+            return;
+        // Initial SessionStart is the only time the transcript path is unavailable
+        // during the pre-items phase. Once the hook discovers it, tail it in this
+        // same tick before Stop/StopFailure is flushed below.
+        if (!hadTranscript && this.transcriptPath && !this.compactionHookPending) {
+            this.pollTranscript();
+        }
+        this.pollNativeSubagents();
         this.pollDeltas();
         this.pollInteractions();
         this.drainInteractionCommits();
@@ -492,24 +685,126 @@ export class ClaudeLiveSession {
             this.releaseSleep = done;
         });
     }
+    /** Rotation is a control edge, not an ordinary hook-stream item. Scan past a
+     * held Stop/compaction cursor so an old retry can never strand the physical
+     * Claude process on a new Session while Rynx still targets the old one. */
+    prescanSessionRotation() {
+        if (this.rotationPending)
+            return;
+        const { events } = readHookEventsFrom(this.bridgeDir, this.hooksOffset, this.hookEventCursor);
+        const rotation = events.find((event) => this.isSessionRotationHook(event));
+        if (!rotation)
+            return;
+        // Abandon older hook deliveries. Their runner generation is cancelled by
+        // retargetMirror; the identity checks below prevent a late completion from
+        // moving the durable hook cursor backwards after the rotation commits.
+        this.pendingTerminalHook = undefined;
+        this.terminalHookDelivery = undefined;
+        this.stopSignalPending = false;
+        this.turnFailurePending = null;
+        this.pendingCompactionHook = undefined;
+        this.compactionHookPending = false;
+        const publication = this.handleSessionStart(rotation);
+        if (!publication || typeof publication.then !== "function") {
+            this.persistHookCursor(rotation);
+            return;
+        }
+        this.rotationPending = true;
+        void publication.then(() => this.persistHookCursor(rotation), (error) => {
+            console.error("[claude-forwarder] Session rotation publication failed; retaining hook cursor:", error);
+        }).finally(() => {
+            this.rotationPending = false;
+        });
+    }
+    /** Mint compaction tokens before transcript parsing without advancing the
+     * hook cursor. The ordinary hook pass later observes the same cursor-keyed
+     * edge and converges on the already-created token. */
+    prescanPrecompactEdges() {
+        const { events } = readHookEventsFrom(this.bridgeDir, this.hooksOffset, this.hookEventCursor);
+        for (const event of events) {
+            if (event.eventName === "PreCompact")
+                this.notePrecompact(event);
+        }
+    }
     pollHooks() {
+        if (this.rotationPending || this.compactionHookPending || this.pendingTerminalHook)
+            return;
         const { events } = readHookEventsFrom(this.bridgeDir, this.hooksOffset, this.hookEventCursor);
         for (const ev of events) {
-            // Rotation is an exactly-once edge. Persist it before the callback so a
-            // partial publication failure cannot create another replacement session
-            // when this forwarder (or its supervisor) restarts.
-            const rotation = ev.eventName === "SessionStart" && (ev.source === "clear" ||
-                (ev.source === "resume" && Boolean(ev.sessionId &&
-                    ev.transcriptPath &&
-                    !this.seenClaudeSessionIds.has(ev.sessionId) &&
-                    transcriptHasForkedFrom(ev.transcriptPath, ev.sessionId))));
-            if (rotation)
-                this.persistHookCursor(ev);
-            this.handleHook(ev);
-            if (!rotation)
-                this.persistHookCursor(ev);
+            if (this.transcriptCompactionPending &&
+                ev.eventName === "SessionStart" &&
+                ev.source === "compact") {
+                return;
+            }
+            const terminalHook = (ev.eventName === "Stop" || ev.eventName === "StopFailure") &&
+                !isSubagentTranscriptPath(ev.transcriptPath);
+            if (terminalHook) {
+                this.pendingTerminalHook = ev;
+                this.handleHook(ev);
+                // Interactions from the same filesystem window are discovered later in
+                // this tick. flushStopSignal/flushTurnFailure owns the cursor commit.
+                return;
+            }
+            const handled = this.handleHook(ev);
+            if (handled && typeof handled.then === "function") {
+                const rotation = this.isSessionRotationHook(ev);
+                if (rotation)
+                    this.rotationPending = true;
+                else {
+                    this.compactionHookPending = true;
+                    this.pendingCompactionHook = ev;
+                }
+                void handled.then(() => {
+                    if (rotation || this.pendingCompactionHook === ev)
+                        this.persistHookCursor(ev);
+                }, (error) => {
+                    console.error("[claude-forwarder] asynchronous hook publication failed; retaining hook cursor:", error);
+                }).finally(() => {
+                    if (rotation)
+                        this.rotationPending = false;
+                    else if (this.pendingCompactionHook === ev) {
+                        this.pendingCompactionHook = undefined;
+                        this.compactionHookPending = false;
+                    }
+                });
+                return;
+            }
+            this.persistHookCursor(ev);
         }
     }
+    isSessionRotationHook(ev) {
+        if (ev.eventName !== "SessionStart" || !this.transcriptPath || !ev.transcriptPath) {
+            return false;
+        }
+        if (!ev.sessionId || ev.sessionId === this.currentClaudeSessionId)
+            return false;
+        if (ev.source === "clear")
+            return true;
+        return this.isForkHookRecord(ev);
+    }
+    isForkHookRecord(ev) {
+        if (ev.payload.rynx_fork_detected === true &&
+            ev.eventName === "SessionStart" &&
+            ev.source === "resume")
+            return true;
+        if (ev.eventName !== "SessionStart" ||
+            ev.source !== "resume" ||
+            !ev.transcriptPath ||
+            !ev.sessionId)
+            return false;
+        const sourceSessionId = typeof ev.payload.rynx_previous_claude_session_id === "string"
+            ? ev.payload.rynx_previous_claude_session_id
+            : this.currentClaudeSessionId;
+        if (!sourceSessionId || sourceSessionId === ev.sessionId)
+            return false;
+        const wasSeen = typeof ev.payload.rynx_claude_session_was_seen === "boolean"
+            ? ev.payload.rynx_claude_session_was_seen
+            : this.seenClaudeSessionIds.has(ev.sessionId);
+        if (wasSeen)
+            return false;
+        return transcriptHasForkedFrom(ev.transcriptPath, ev.sessionId, sourceSessionId) || (ev.recordedAt !== undefined &&
+            transcriptHasRecentLocalCommand(ev.transcriptPath, ev.sessionId, ev.recordedAt));
+    }
     persistHookCursor(ev) {
         this.hooksOffset = ev.byteOffset;
         this.hookEventCursor = ev.eventCursor;
@@ -522,12 +817,22 @@ export class ClaudeLiveSession {
     }
     handleHook(ev) {
         if (ev.eventName === "SessionStart") {
-            this.handleSessionStart(ev);
+            return this.handleSessionStart(ev);
+        }
+        if (ev.eventName === "PreCompact") {
+            this.sink.onCompactionStatus?.("in_progress");
+            this.notePrecompact(ev);
+            return;
+        }
+        if (ev.eventName === "TaskCreated" ||
+            ev.eventName === "TaskCompleted" ||
+            ev.eventName === "PostToolUse") {
+            this.handleTodoHook(ev);
             return;
         }
         if (ev.eventName === "Stop" || ev.eventName === "StopFailure") {
             // Subagent stops (transcript_path under `subagents/`) don't end the parent turn.
-            if (ev.transcriptPath?.includes("/subagents/"))
+            if (isSubagentTranscriptPath(ev.transcriptPath))
                 return;
             // Stop only signals idle — it does NOT close the turn (see onIdle): closing
             // here would split a late-flushing assistant record into its own turn.
@@ -546,6 +851,173 @@ export class ClaudeLiveSession {
             }
         }
     }
+    handleTodoHook(ev) {
+        const payload = ev.payload;
+        if (ev.eventName === "TaskCreated") {
+            const id = readStr(payload.task_id);
+            if (!id)
+                return;
+            this.todos.set(id, {
+                id,
+                subject: readStr(payload.task_subject) ?? id,
+                status: "pending",
+            });
+            this.sink.onTodos([...this.todos.values()]);
+            return;
+        }
+        if (ev.eventName === "TaskCompleted") {
+            const id = readStr(payload.task_id);
+            const existing = id ? this.todos.get(id) : undefined;
+            if (!id || !existing)
+                return;
+            this.todos.set(id, {
+                id,
+                subject: existing.subject,
+                status: "completed",
+            });
+            this.sink.onTodos([...this.todos.values()]);
+            return;
+        }
+        if (ev.eventName !== "PostToolUse" || !isRecord(payload.tool_input))
+            return;
+        const input = payload.tool_input;
+        if (payload.tool_name === "TodoWrite" && Array.isArray(input.todos)) {
+            const snapshot = [];
+            for (const [index, raw] of input.todos.entries()) {
+                if (!isRecord(raw))
+                    continue;
+                const subject = readStr(raw.content) ?? readStr(raw.subject);
+                if (!subject)
+                    continue;
+                snapshot.push({
+                    id: readStr(raw.id) ?? `todo-${index}`,
+                    subject,
+                    status: normalizeTodoStatus(readStr(raw.status)) ?? "pending",
+                });
+            }
+            this.todos.clear();
+            for (const todo of snapshot)
+                this.todos.set(todo.id, todo);
+            this.sink.onTodos(snapshot);
+            return;
+        }
+        if (payload.tool_name !== "TaskUpdate")
+            return;
+        const id = readStr(input.taskId);
+        if (!id)
+            return;
+        const existing = this.todos.get(id);
+        if (!existing)
+            return;
+        if (input.status === "deleted") {
+            if (this.todos.delete(id))
+                this.sink.onTodos([...this.todos.values()]);
+            return;
+        }
+        this.todos.set(id, {
+            id,
+            subject: readStr(input.subject) ?? existing.subject,
+            status: normalizeTodoStatus(readStr(input.status)) ?? existing.status,
+        });
+        this.sink.onTodos([...this.todos.values()]);
+    }
+    compactionGeneration() {
+        return this.currentClaudeSessionId ?? this.transcriptPath ?? "unbound";
+    }
+    readCompactionState() {
+        return readCompactionForwardState(this.bridgeDir, this.compactionGeneration());
+    }
+    notePrecompact(ev) {
+        const state = this.readCompactionState();
+        if (ev.eventCursor <= state.lastPrecompactCursor)
+            return;
+        const sequence = state.lastSequence + 1;
+        writeCompactionForwardState(this.bridgeDir, {
+            generation: state.generation,
+            lastSequence: sequence,
+            persistedSequences: state.persistedSequences,
+            lastPrecompactCursor: ev.eventCursor,
+            pending: {
+                sequence,
+                ...(ev.sessionId ? { claudeSessionId: ev.sessionId } : {}),
+                ...(ev.transcriptPath ? { transcriptPath: ev.transcriptPath } : {}),
+            },
+        });
+    }
+    compactionPendingMatches(state, claudeSessionId, transcriptPath) {
+        const pending = state.pending;
+        if (!pending)
+            return false;
+        if (pending.claudeSessionId && claudeSessionId &&
+            pending.claudeSessionId !== claudeSessionId)
+            return false;
+        if (pending.transcriptPath && transcriptPath &&
+            pending.transcriptPath !== transcriptPath)
+            return false;
+        return !state.persistedSequences.includes(pending.sequence);
+    }
+    markCompactionPersisted(sequence, expectCompletionAck, generation = this.compactionGeneration()) {
+        if (this.compactionGeneration() !== generation)
+            return;
+        const state = this.readCompactionState();
+        if (state.generation !== generation)
+            return;
+        const persistedSequences = state.persistedSequences.includes(sequence)
+            ? state.persistedSequences
+            : [...state.persistedSequences, sequence].slice(-16);
+        writeCompactionForwardState(this.bridgeDir, {
+            generation: state.generation,
+            lastSequence: Math.max(state.lastSequence, sequence),
+            persistedSequences,
+            lastPrecompactCursor: state.lastPrecompactCursor,
+            ...(state.pending?.sequence !== sequence && state.pending
+                ? { pending: state.pending }
+                : {}),
+            ...(expectCompletionAck ? { expectCompletionAckSequence: sequence } : {}),
+        });
+    }
+    claimHookCompaction(ev) {
+        const state = this.readCompactionState();
+        if (this.compactionPendingMatches(state, ev.sessionId, ev.transcriptPath)) {
+            return state.pending.sequence;
+        }
+        if (state.expectCompletionAckSequence &&
+            state.persistedSequences.includes(state.expectCompletionAckSequence)) {
+            writeCompactionForwardState(this.bridgeDir, {
+                ...state,
+                expectCompletionAckSequence: undefined,
+            });
+            return undefined;
+        }
+        const sequence = state.lastSequence + 1;
+        writeCompactionForwardState(this.bridgeDir, {
+            generation: state.generation,
+            lastSequence: sequence,
+            persistedSequences: state.persistedSequences,
+            lastPrecompactCursor: state.lastPrecompactCursor,
+            pending: {
+                sequence,
+                ...(ev.sessionId ? { claudeSessionId: ev.sessionId } : {}),
+                ...(ev.transcriptPath ? { transcriptPath: ev.transcriptPath } : {}),
+            },
+        });
+        return sequence;
+    }
+    handleCompactionCompletionHook(ev) {
+        this.sink.onCompactionStatus?.("completed");
+        const generation = this.compactionGeneration();
+        const sequence = this.claimHookCompaction(ev);
+        if (sequence === undefined || !this.sink.onCompactionBoundary)
+            return;
+        const result = this.sink.onCompactionBoundary("[Claude Code compaction — context was compacted in the terminal]", sequence, "hook");
+        const finish = (handled) => {
+            // A bounded permanent hook-path rejection advances the hook but leaves
+            // the token for the primary transcript summary path.
+            if (handled)
+                this.markCompactionPersisted(sequence, false, generation);
+        };
+        return Promise.resolve(result).then(finish);
+    }
     /** Process a provider failure only after this tick has discovered every
      *  blocking request already appended by its hook subprocess. */
     flushTurnFailure() {
@@ -554,22 +1026,67 @@ export class ClaudeLiveSession {
             return;
         this.turnFailurePending = null;
         this.providerFailureSticky = true;
-        if (this.turnOpen)
-            this.closeTurnError(error);
-        else
-            this.sink.onTurnError(error);
+        const sourceId = this.pendingTerminalHook
+            ? `hook:${this.pendingTerminalHook.eventCursor}:${this.pendingTerminalHook.byteOffset}:failed`
+            : undefined;
+        const delivery = this.turnOpen
+            ? this.closeTurnError(error, sourceId)
+            : this.sink.onTurnError(error, sourceId);
+        if (this.pendingTerminalHook)
+            this.finishTerminalHookDelivery(delivery);
     }
     /** Emit the Stop idle signal only after this tick has discovered native
      *  interactions. A pending question/permission is active execution, not idle. */
     flushStopSignal() {
-        if (!this.stopSignalPending)
+        if (!this.stopSignalPending) {
+            if (this.pendingTerminalHook?.eventName === "Stop" && this.pendingInteractions.size > 0) {
+                this.persistHookCursor(this.pendingTerminalHook);
+                this.pendingTerminalHook = undefined;
+            }
             return;
+        }
         this.stopSignalPending = false;
         if (this.pendingInteractions.size === 0) {
-            this.sink.onIdle(this.stopBackgroundTaskCount);
+            const sourceId = this.pendingTerminalHook
+                ? `hook:${this.pendingTerminalHook.eventCursor}:${this.pendingTerminalHook.byteOffset}:idle`
+                : undefined;
+            const delivery = this.sink.onIdle(this.stopBackgroundTaskCount, sourceId);
             this.stopBackgroundTaskCountDelivered = true;
+            if (this.pendingTerminalHook)
+                this.finishTerminalHookDelivery(delivery);
+        }
+        else if (this.pendingTerminalHook) {
+            // A pending native interaction means Stop is not a real idle edge, but
+            // the hook record itself is handled and may advance.
+            this.persistHookCursor(this.pendingTerminalHook);
+            this.pendingTerminalHook = undefined;
         }
     }
+    finishTerminalHookDelivery(delivery) {
+        const hook = this.pendingTerminalHook;
+        if (!hook || this.terminalHookDelivery)
+            return;
+        this.terminalHookDelivery = hook;
+        void Promise.resolve(delivery).then(() => {
+            if (this.pendingTerminalHook !== hook)
+                return;
+            this.persistHookCursor(hook);
+            this.pendingTerminalHook = undefined;
+        }, (error) => {
+            if (this.pendingTerminalHook !== hook)
+                return;
+            console.error("[claude-forwarder] terminal hook delivery failed; retaining cursor:", error);
+            if (hook.eventName === "StopFailure") {
+                this.turnFailurePending = new Error("claude turn failed");
+            }
+            else {
+                this.stopSignalPending = true;
+            }
+        }).finally(() => {
+            if (this.terminalHookDelivery === hook)
+                this.terminalHookDelivery = undefined;
+        });
+    }
     /** SessionStart drives discovery (first) and rotation (a later one with a NEW
      *  session id + transcript). `/clear` → source="clear"; `/fork` → source="resume"
      *  into an unseen id with a forkedFrom marker. Any other new-transcript
@@ -586,52 +1103,113 @@ export class ClaudeLiveSession {
             }
             this.transcriptPath = ev.transcriptPath;
             this.transcriptOffset = 0;
+            this.committedTranscriptOffset = 0;
+            this.transcriptLineCursor = 0;
+            this.committedTranscriptLineCursor = 0;
             this.currentClaudeSessionId = ev.sessionId;
             if (ev.sessionId)
                 this.seenClaudeSessionIds.add(ev.sessionId);
             // Resume from the persisted cursor so a relaunched forwarder doesn't re-mirror
             // already-logged turns.
             const restored = this.restoreForwardState(ev.transcriptPath);
-            if (!restored && this.resumeAtEndOnDiscovery) {
+            this.restoreSubagentForwardStates(ev.transcriptPath);
+            if (!restored && this.initialTranscriptOffsetOnDiscovery !== undefined) {
+                this.transcriptOffset = Math.min(this.initialTranscriptOffsetOnDiscovery, fileSize(ev.transcriptPath));
+                this.committedTranscriptOffset = this.transcriptOffset;
+                // Seed the exact rotation boundary even when the transcript is empty or
+                // no bytes are consumed this tick. This closes a second-crash window
+                // between SessionStart discovery and the first target record.
+                this.persistForwardState();
+            }
+            else if (!restored && this.resumeAtEndOnDiscovery) {
                 this.transcriptOffset = fileSize(ev.transcriptPath);
+                this.committedTranscriptOffset = this.transcriptOffset;
+                // Persist the fallback baseline just like an exact prepared prefix.
+                // Otherwise a crash with the first new record still awaiting ACK can
+                // make the next launch seed at the newer EOF and lose that record.
+                this.persistForwardState();
             }
             if (!this.discovered && ev.sessionId) {
                 this.discovered = true;
                 this.sink.onSessionDiscovered?.(ev.sessionId, ev.transcriptPath);
             }
-            return;
+            return ev.source === "compact" ? this.handleCompactionCompletionHook(ev) : undefined;
         }
         // Drain the old transcript before a SessionStart switches paths so a slash
         // command recorded immediately before /clear or /fork can still
         // acknowledge the web submission.
         if (ev.transcriptPath !== this.transcriptPath)
             this.pollTranscript();
+        if (ev.source === "compact") {
+            const follow = () => {
+                if (ev.transcriptPath !== this.transcriptPath) {
+                    this.transcriptPath = ev.transcriptPath;
+                    this.transcriptOffset = 0;
+                    this.committedTranscriptOffset = 0;
+                    this.transcriptLineCursor = 0;
+                    this.committedTranscriptLineCursor = 0;
+                    this.seenSourceIds.clear();
+                    resetForwardState(this.bridgeDir);
+                    this.persistForwardState();
+                }
+            };
+            const completion = this.handleCompactionCompletionHook(ev);
+            if (completion && typeof completion.then === "function")
+                return completion.then(follow);
+            follow();
+            return;
+        }
         // Same session id (a plain re-announce) → nothing to do.
         if (!ev.sessionId || ev.sessionId === this.currentClaudeSessionId)
             return;
-        const wasSeen = this.seenClaudeSessionIds.has(ev.sessionId);
-        this.seenClaudeSessionIds.add(ev.sessionId);
         let kind;
         if (ev.source === "clear")
             kind = "clear";
-        else if (ev.source === "resume" && !wasSeen && transcriptHasForkedFrom(ev.transcriptPath, ev.sessionId)) {
+        else if (this.isForkHookRecord(ev))
             kind = "fork";
+        // Capture the target boundary at SessionStart, before target publication
+        // can wait or retry. Fork has copied source history up to this byte; clear
+        // has no inherited prefix. A later EOF would also include new target work.
+        const initialTranscriptOffset = kind === "fork" ? fileSize(ev.transcriptPath) : 0;
+        const commitRepoint = () => {
+            // A fork copies the source history into the new transcript; start at its
+            // END so those records aren't re-mirrored. A clear starts fresh at byte 0.
+            this.repointTranscript(ev.transcriptPath, initialTranscriptOffset);
+            this.currentClaudeSessionId = ev.sessionId;
+            this.seenClaudeSessionIds.add(ev.sessionId);
+        };
+        if (!kind) {
+            commitRepoint();
+            return;
         }
-        // A fork copies the source history into the new transcript; start at its END
-        // so those records aren't re-mirrored. A clear starts fresh at byte 0.
-        this.repointTranscript(ev.transcriptPath, kind === "fork");
-        this.currentClaudeSessionId = ev.sessionId;
-        if (kind)
-            this.sink.onSessionRotated?.(kind, ev.sessionId, ev.transcriptPath);
+        // Close the old Response before the host publishes session.rotated and
+        // retargets the IPC generation. The host serializes this settlement on the
+        // control lane so it cannot be cancelled into the new Session.
+        this.closeTurn("rotation");
+        // Do not switch source state or consume the hook until the host has
+        // persisted and published the logical Session rotation.
+        const publication = this.sink.onSessionRotated?.(kind, ev.sessionId, ev.transcriptPath, initialTranscriptOffset);
+        if (publication && typeof publication.then === "function") {
+            return publication.then(commitRepoint);
+        }
+        commitRepoint();
     }
     /** Switch the tailed transcript and reset per-session accumulators (the bridge
      *  files — hooks/deltas/status — are shared by the same claude process across a
      *  rotation, so their cursors are NOT reset). */
-    repointTranscript(newPath, atEof) {
+    repointTranscript(newPath, initialOffset) {
         this.closeTurn(); // finalize the prior session's last turn before switching
+        this.activeTerminalCommand = undefined;
+        this.committedTerminalCommand = undefined;
         this.transcriptPath = newPath;
-        this.transcriptOffset = atEof ? fileSize(newPath) : 0;
-        this.seenSubagents.clear();
+        this.transcriptOffset = Math.min(Math.max(0, initialOffset), fileSize(newPath));
+        this.committedTranscriptOffset = this.transcriptOffset;
+        this.transcriptLineCursor = 0;
+        this.committedTranscriptLineCursor = 0;
+        this.nativeSubagents.clear();
+        this.nativeSubagentParentResponses.clear();
+        this.subagentStateParentPath = newPath;
+        resetSubagentForwardStates(this.bridgeDir);
         this.todos.clear();
         this.pendingQueuedSubmissions.length = 0;
         this.resetMessageCorrelation();
@@ -642,16 +1220,366 @@ export class ClaudeLiveSession {
         resetForwardState(this.bridgeDir);
         this.persistForwardState();
     }
+    /** Revalidate the committed cursor every poll, not only after process restart.
+     * Claude may replace/truncate a transcript in place. Treat a stale
+     * nonzero fingerprint as a new file and skips to its current EOF while
+     * preserving the bounded seen set. A temporarily missing file keeps the
+     * cursor unchanged. */
+    validateLiveTranscriptCursor() {
+        const transcriptPath = this.transcriptPath;
+        if (!transcriptPath)
+            return;
+        const state = readForwardState(this.bridgeDir);
+        if (!state ||
+            state.transcriptPath !== transcriptPath ||
+            state.byteOffset !== this.committedTranscriptOffset)
+            return;
+        const currentFingerprint = jsonlCursorFingerprint(transcriptPath, this.committedTranscriptOffset);
+        if (currentFingerprint === undefined) {
+            if (fileByteSize(transcriptPath) === undefined)
+                return;
+        }
+        else if (state.cursorFingerprint === currentFingerprint) {
+            return;
+        }
+        else if (state.cursorFingerprint === undefined &&
+            this.committedTranscriptOffset === 0 &&
+            this.committedTranscriptLineCursor === 0) {
+            this.persistForwardState();
+            return;
+        }
+        console.warn("[claude-forwarder] transcript cursor fingerprint changed; skipping to current EOF");
+        this.closeTurn();
+        this.activeTerminalCommand = undefined;
+        this.committedTerminalCommand = undefined;
+        const endOffset = fileSize(transcriptPath);
+        this.transcriptOffset = endOffset;
+        this.committedTranscriptOffset = endOffset;
+        this.transcriptLineCursor = 0;
+        this.committedTranscriptLineCursor = 0;
+        this.persistForwardState();
+    }
     pollTranscript() {
-        if (!this.transcriptPath)
+        if (!this.transcriptPath || this.transcriptDeliveryPending)
             return;
-        const { records, nextOffset } = readJsonlFrom(this.transcriptPath, this.transcriptOffset);
+        this.validateLiveTranscriptCursor();
+        const transcriptPath = this.transcriptPath;
+        const { entries, nextOffset, nextLineCursor } = readJsonlEntriesFrom(transcriptPath, this.transcriptOffset, this.transcriptLineCursor);
         this.transcriptOffset = nextOffset;
-        for (const rec of records)
+        this.transcriptLineCursor = nextLineCursor;
+        this.pendingTranscriptCompactions = [];
+        const deliveries = [];
+        const fallbackSourceIds = [];
+        for (const entry of entries) {
+            const rec = entry.record;
+            const sourceBase = transcriptSourceBase(rec, entry.byteOffset, entry.lineNumber);
+            // Compatibility with the old record-level seen set. New writes persist
+            // per-item keys returned by onTranscriptRecordEnd.
+            if (this.seenSourceIds.has(sourceBase))
+                continue;
+            const terminalCheckpoint = this.terminalCommandCheckpointForRecord(rec);
+            this.sink.onTranscriptRecordStart?.(sourceBase, (sourceId) => this.seenSourceIds.has(sourceId), {
+                onHandled: (sourceId) => {
+                    this.rememberSourceId(sourceId);
+                    if (terminalCheckpoint) {
+                        this.committedTerminalCommand = cloneTerminalCommand(terminalCheckpoint.next);
+                    }
+                    this.persistForwardState();
+                },
+            });
             this.handleRecord(rec);
-        // Persist the durable cursor after consuming records so a relaunch resumes here.
-        if (records.length > 0)
+            const delivery = this.sink.onTranscriptRecordEnd?.();
+            if (delivery)
+                deliveries.push(delivery);
+            else
+                fallbackSourceIds.push(sourceBase);
+        }
+        const commit = (sourceGroups) => {
+            if (this.transcriptPath !== transcriptPath)
+                return;
+            for (const sourceId of [...fallbackSourceIds, ...sourceGroups.flat()]) {
+                this.rememberSourceId(sourceId);
+            }
+            this.committedTerminalCommand = cloneTerminalCommand(this.activeTerminalCommand);
+            this.committedTranscriptOffset = nextOffset;
+            this.committedTranscriptLineCursor = nextLineCursor;
             this.persistForwardState();
+        };
+        if (deliveries.length === 0 && this.pendingTranscriptCompactions.length === 0) {
+            if (nextOffset !== this.committedTranscriptOffset)
+                commit([]);
+            return;
+        }
+        const compactions = this.pendingTranscriptCompactions;
+        this.pendingTranscriptCompactions = [];
+        this.transcriptDeliveryPending = true;
+        this.transcriptCompactionPending = compactions.length > 0;
+        void Promise.all([
+            Promise.all(deliveries),
+            Promise.all(compactions.map(async ({ sequence, generation, delivery }) => {
+                if (!await delivery)
+                    throw new Error(`compaction ${sequence} delivery was not handled`);
+                this.markCompactionPersisted(sequence, true, generation);
+            })),
+        ]).then(([sourceGroups]) => commit(sourceGroups), (error) => {
+            if (this.transcriptPath !== transcriptPath)
+                return;
+            this.transcriptOffset = this.committedTranscriptOffset;
+            this.transcriptLineCursor = this.committedTranscriptLineCursor;
+            this.activeTerminalCommand = cloneTerminalCommand(this.committedTerminalCommand);
+            console.error("[claude-forwarder] transcript delivery failed; retrying window:", error);
+        }).finally(() => {
+            this.transcriptDeliveryPending = false;
+            this.transcriptCompactionPending = false;
+        });
+    }
+    rememberSourceId(sourceId) {
+        if (this.seenSourceIds.has(sourceId))
+            return;
+        this.seenSourceIds.add(sourceId);
+        while (this.seenSourceIds.size > 2_000) {
+            const oldest = this.seenSourceIds.values().next().value;
+            if (!oldest)
+                break;
+            this.seenSourceIds.delete(oldest);
+        }
+    }
+    restoreSubagentForwardStates(parentTranscriptPath) {
+        if (this.subagentStateParentPath === parentTranscriptPath)
+            return;
+        this.nativeSubagents.clear();
+        this.nativeSubagentParentResponses.clear();
+        this.subagentStateParentPath = parentTranscriptPath;
+        for (const [parentToolCallId, responseId] of readSubagentParentResponses(this.bridgeDir, parentTranscriptPath)) {
+            this.nativeSubagentParentResponses.set(parentToolCallId, responseId);
+            this.sink.onSubagentParentResponse?.(parentToolCallId, responseId);
+        }
+        for (const state of readSubagentForwardStates(this.bridgeDir, parentTranscriptPath)) {
+            this.nativeSubagents.set(state.agentId, {
+                agentId: state.agentId,
+                parentToolCallId: state.parentToolCallId,
+                ...(state.parentResponseId ? { parentResponseId: state.parentResponseId } : {}),
+                transcriptPath: state.transcriptPath,
+                readOffset: state.byteOffset,
+                committedOffset: state.byteOffset,
+                lineCursor: state.lineCursor ?? 0,
+                committedLineCursor: state.lineCursor ?? 0,
+                seenSourceIds: new Set(state.seenSourceIds),
+                deliveryPending: false,
+                ...(state.terminalCommand
+                    ? {
+                        terminalCommand: state.terminalCommand,
+                        committedTerminalCommand: state.terminalCommand,
+                    }
+                    : {}),
+            });
+            if (state.parentResponseId) {
+                this.sink.onSubagentParentResponse?.(state.parentToolCallId, state.parentResponseId);
+            }
+        }
+    }
+    persistSubagentForwardStates() {
+        const parentTranscriptPath = this.transcriptPath;
+        if (!parentTranscriptPath)
+            return;
+        const states = [...this.nativeSubagents.values()]
+            .sort((a, b) => a.agentId.localeCompare(b.agentId))
+            .map((state) => ({
+            agentId: state.agentId,
+            parentToolCallId: state.parentToolCallId,
+            ...(state.parentResponseId ? { parentResponseId: state.parentResponseId } : {}),
+            transcriptPath: state.transcriptPath,
+            byteOffset: state.committedOffset,
+            lineCursor: state.committedLineCursor,
+            seenSourceIds: [...state.seenSourceIds],
+            ...(state.committedTerminalCommand
+                ? { terminalCommand: state.committedTerminalCommand }
+                : {}),
+        }));
+        writeSubagentForwardStates(this.bridgeDir, parentTranscriptPath, states, this.nativeSubagentParentResponses);
+    }
+    pollNativeSubagents() {
+        const parentTranscriptPath = this.transcriptPath;
+        if (!parentTranscriptPath)
+            return;
+        this.restoreSubagentForwardStates(parentTranscriptPath);
+        const directory = join(parentTranscriptPath.replace(/\.jsonl$/, ""), "subagents");
+        let metaFiles;
+        try {
+            metaFiles = readdirSync(directory)
+                .filter((name) => /^agent-.+\.meta\.json$/.test(name))
+                .sort();
+        }
+        catch {
+            metaFiles = [];
+        }
+        for (const metaFile of metaFiles) {
+            const agentId = metaFile.slice("agent-".length, -".meta.json".length);
+            if (!agentId)
+                continue;
+            const meta = readNativeSubagentMeta(join(directory, metaFile));
+            if (!meta)
+                continue; // partial/malformed meta is retried next tick
+            const transcriptPath = subagentTranscriptPath(parentTranscriptPath, agentId);
+            let state = this.nativeSubagents.get(agentId);
+            if (!state) {
+                const parentResponseId = this.nativeSubagentParentResponses.get(meta.toolUseId) ??
+                    this.sink.resolveSubagentParentResponseId?.(meta.toolUseId);
+                state = {
+                    agentId,
+                    parentToolCallId: meta.toolUseId,
+                    ...(parentResponseId ? { parentResponseId } : {}),
+                    transcriptPath,
+                    readOffset: 0,
+                    committedOffset: 0,
+                    lineCursor: 0,
+                    committedLineCursor: 0,
+                    seenSourceIds: new Set(),
+                    deliveryPending: false,
+                };
+                this.nativeSubagents.set(agentId, state);
+            }
+        }
+        // Once registered, a child lane is owned by its persisted cursor. Claude
+        // may remove or temporarily rewrite the discovery meta while the child
+        // transcript is still growing; do not make continued delivery depend on
+        // rediscovering that meta on every poll.
+        for (const state of this.nativeSubagents.values()) {
+            if (!state.parentResponseId) {
+                const parentResponseId = this.nativeSubagentParentResponses.get(state.parentToolCallId) ?? this.sink.resolveSubagentParentResponseId?.(state.parentToolCallId);
+                if (parentResponseId) {
+                    state.parentResponseId = parentResponseId;
+                    this.nativeSubagentParentResponses.set(state.parentToolCallId, parentResponseId);
+                    this.sink.onSubagentParentResponse?.(state.parentToolCallId, parentResponseId);
+                    this.persistSubagentForwardStates();
+                }
+            }
+            else {
+                this.sink.onSubagentParentResponse?.(state.parentToolCallId, state.parentResponseId);
+            }
+            this.pollNativeSubagent(state);
+        }
+    }
+    pollNativeSubagent(state) {
+        if (state.deliveryPending)
+            return;
+        const size = fileByteSize(state.transcriptPath);
+        if (size === undefined)
+            return;
+        if (size < state.readOffset) {
+            // Sub-agent state has no transcript fingerprint. A truncation rewinds to zero;
+            // the bounded per-item seen set suppresses recent duplicates.
+            state.readOffset = 0;
+            state.committedOffset = 0;
+            state.lineCursor = 0;
+            state.committedLineCursor = 0;
+            state.terminalCommand = undefined;
+            state.committedTerminalCommand = undefined;
+        }
+        const { entries, nextOffset, nextLineCursor } = readJsonlEntriesFrom(state.transcriptPath, state.readOffset, state.lineCursor);
+        state.readOffset = nextOffset;
+        state.lineCursor = nextLineCursor;
+        const deliveries = [];
+        const fallbackSourceIds = [];
+        for (const entry of entries) {
+            const sourceBase = transcriptSourceBase(entry.record, entry.byteOffset, entry.lineNumber);
+            if (state.seenSourceIds.has(sourceBase))
+                continue;
+            const queuedPrompt = queuedCommandPrompt(entry.record);
+            const prompt = userStringContent(entry.record);
+            const localCommand = transcriptLocalCommand(entry.record);
+            const terminalCheckpoint = localCommand?.hasOutput
+                ? { next: undefined }
+                : localCommand?.command !== undefined
+                    ? { next: localCommand.command }
+                    : undefined;
+            this.sink.onTranscriptRecordStart?.(sourceBase, (sourceId) => state.seenSourceIds.has(sourceId), {
+                lane: `claude-subagent:${state.agentId}`,
+                deadLetterPath: join(this.bridgeDir, "dead_letter.jsonl"),
+                onHandled: (sourceId) => {
+                    if (!state.seenSourceIds.has(sourceId)) {
+                        state.seenSourceIds.add(sourceId);
+                        while (state.seenSourceIds.size > 2_000) {
+                            const oldest = state.seenSourceIds.values().next().value;
+                            if (!oldest)
+                                break;
+                            state.seenSourceIds.delete(oldest);
+                        }
+                    }
+                    if (terminalCheckpoint) {
+                        state.committedTerminalCommand = terminalCheckpoint.next;
+                    }
+                    this.persistSubagentForwardStates();
+                },
+            });
+            if (queuedPrompt !== undefined) {
+                this.sink.onSubagentUserMessage?.(queuedPrompt, state.parentToolCallId);
+            }
+            if (localCommand) {
+                this.sink.onSubagentTerminalCommand?.(terminalCommandData(localCommand, state.terminalCommand), state.parentToolCallId);
+                if (localCommand.command !== undefined)
+                    state.terminalCommand = localCommand.command;
+                if (localCommand.hasOutput)
+                    state.terminalCommand = undefined;
+            }
+            else if (prompt !== undefined && !isClaudeUserScaffolding(prompt)) {
+                if (isTaskNotificationText(prompt)) {
+                    this.sink.onMetaUserMessage?.(prompt, sourceBase, state.parentToolCallId);
+                }
+                else {
+                    this.sink.onSubagentUserMessage?.(prompt, state.parentToolCallId);
+                }
+            }
+            for (const message of userListTextMessages(entry.record)) {
+                if (message.isMeta) {
+                    this.sink.onMetaUserMessage?.(message.text, sourceBase, state.parentToolCallId);
+                }
+                else {
+                    this.sink.onSubagentUserMessage?.(message.text, state.parentToolCallId);
+                }
+            }
+            for (const event of parseTranscriptRecord(entry.record, {
+                parentToolUseId: state.parentToolCallId,
+            })) {
+                this.sink.onEvent(event);
+            }
+            const delivery = this.sink.onTranscriptRecordEnd?.();
+            if (delivery)
+                deliveries.push(delivery);
+            else
+                fallbackSourceIds.push(sourceBase);
+        }
+        const commit = (sourceGroups) => {
+            for (const sourceId of [...fallbackSourceIds, ...sourceGroups.flat()]) {
+                if (state.seenSourceIds.has(sourceId))
+                    continue;
+                state.seenSourceIds.add(sourceId);
+                while (state.seenSourceIds.size > 2_000) {
+                    const oldest = state.seenSourceIds.values().next().value;
+                    if (!oldest)
+                        break;
+                    state.seenSourceIds.delete(oldest);
+                }
+            }
+            state.committedTerminalCommand = state.terminalCommand;
+            state.committedOffset = nextOffset;
+            state.committedLineCursor = nextLineCursor;
+            this.persistSubagentForwardStates();
+        };
+        if (deliveries.length === 0) {
+            if (nextOffset !== state.committedOffset)
+                commit([]);
+            return;
+        }
+        state.deliveryPending = true;
+        void Promise.all(deliveries).then((sourceGroups) => commit(sourceGroups), (error) => {
+            state.readOffset = state.committedOffset;
+            state.lineCursor = state.committedLineCursor;
+            state.terminalCommand = state.committedTerminalCommand;
+            console.error(`[claude-forwarder] sub-agent ${state.agentId} delivery failed; retrying window:`, error);
+        }).finally(() => {
+            state.deliveryPending = false;
+        });
     }
     /** Tail blocking hook requests after transcript records, so an interaction
      *  emitted in the same poll attaches to the user Turn that caused it. */
@@ -923,11 +1851,57 @@ export class ClaudeLiveSession {
         if (oldest)
             this.settledInteractions.delete(oldest);
     }
+    /** State change represented by this record once its durable terminal item is
+     * handled. Parsing can run through multiple records before their deliveries
+     * settle, so this checkpoint is intentionally separate from the live state. */
+    terminalCommandCheckpointForRecord(rec) {
+        if (rec.isSidechain === true || rec.isCompactSummary === true || rec.isMeta === true) {
+            return undefined;
+        }
+        const localCommand = transcriptLocalCommand(rec);
+        if (localCommand) {
+            if (localCommand.hasOutput)
+                return { next: undefined };
+            if (localCommand.command !== undefined) {
+                const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
+                return {
+                    next: {
+                        command: localCommand.command,
+                        ...(turnId ? { turnId } : {}),
+                    },
+                };
+            }
+            return undefined;
+        }
+        return this.activeTerminalCommand ? { next: undefined } : undefined;
+    }
     handleRecord(rec) {
         if (rec.isSidechain === true)
             return; // sub-agent turns (Phase 9 forwards them)
+        if (rec.isCompactSummary === true) {
+            this.handleCompactSummary(rec);
+            return;
+        }
         if (rec.isMeta === true)
             return; // Claude-generated UI metadata, not a human message
+        const stringContent = userStringContent(rec);
+        const localCommand = transcriptLocalCommand(rec);
+        if (localCommand) {
+            this.emitTerminalCommand(rec, localCommand);
+            return;
+        }
+        if (this.activeTerminalCommand) {
+            this.closeTurn();
+            this.activeTerminalCommand = undefined;
+        }
+        const queuedPrompt = queuedCommandPrompt(rec);
+        if (queuedPrompt !== undefined) {
+            for (const candidate of submissionCandidates(queuedPrompt)) {
+                this.rememberSubmission(candidate);
+            }
+            this.emitUserMessageRecord(rec, queuedPrompt, false);
+            return;
+        }
         // Type-ahead is acknowledged at enqueue time. Its later
         // `promptSource:"queued"` user record must not count again: another
         // identical web message may already be awaiting its own acknowledgement.
@@ -945,17 +1919,7 @@ export class ClaudeLiveSession {
             }
             return;
         }
-        // Secondary dedup: skip a record whose source id was already forwarded (a
-        // re-read after a fingerprint reset). rynx emits a record's items atomically,
-        // so the record uuid is the source key (vs reference implementation's per-block key for its
-        // per-item POST). Records without a uuid fall through undeduped (rare).
-        const sourceId = typeof rec.uuid === "string" && rec.uuid ? rec.uuid : undefined;
-        if (sourceId) {
-            if (this.seenSourceIds.has(sourceId))
-                return;
-            this.seenSourceIds.add(sourceId);
-        }
-        const content = userStringContent(rec);
+        const content = stringContent;
         if (content !== undefined) {
             const firstLine = content.trim().split("\n", 1)[0] ?? "";
             if (CLAUDE_INTERRUPT_RECORD_RE.test(firstLine)) {
@@ -976,51 +1940,32 @@ export class ClaudeLiveSession {
                 for (const candidate of candidates)
                     this.rememberSubmission(candidate);
             }
-            // A local `!` command records its input+output as `<bash-*>` markers — mirror
-            // it as a self-contained terminal_command turn (before the prompt check, as
-            // it too is `<`-prefixed).
-            const term = parseTerminalCommand(content);
-            if (term) {
-                this.emitTerminalCommand(rec, term);
+            if (isClaudeUserScaffolding(content))
                 return;
+            if (isTaskNotificationText(content)) {
+                this.sink.onMetaUserMessage?.(content, rec.uuid ?? rec.requestId);
             }
-            // A real prompt (not an XML-marker bookkeeping record) opens a new turn.
-            if (!content.startsWith("<")) {
-                const queuedIntoOpenTurn = this.turnOpen && (queuedPromotion || rec.promptSource === "queued" || rec.promptSource === "sdk");
-                if (queuedIntoOpenTurn) {
-                    // Claude type-ahead is one native busy interval: enqueue now, promote
-                    // later, and emit one final Stop. Do not close/re-open the canonical
-                    // response when the promoted user record arrives mid-turn.
-                    this.sink.onUserMessage(content);
-                    this.lastActivityAt = this.now();
-                    return;
-                }
-                const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
-                if (this.turnOpen && this.syntheticTurn) {
-                    // A hook can flush just before the transcript's user record. The
-                    // interaction already opened a unique provisional response; adopt the
-                    // real turn id internally without closing/cancelling that same Turn.
-                    this.currentTurnId = turnId;
-                    this.syntheticTurn = false;
-                }
-                else {
-                    this.closeTurn();
-                    this.currentTurnId = turnId;
-                    this.turnOpen = true;
-                    this.turnInterrupted = false;
-                    this.syntheticTurn = false;
-                    this.providerIdleAt = null;
-                    this.openToolIds.clear();
-                    this.stopPendingAt = null;
-                    this.stopBackgroundTaskCount = undefined;
-                    this.stopBackgroundTaskCountDelivered = false;
-                    this.sink.onTurnStart(this.currentTurnId);
-                }
-                this.sink.onUserMessage(content);
-                this.lastActivityAt = this.now();
+            else {
+                this.emitUserMessageRecord(rec, content, queuedPromotion);
             }
             return; // string-content user record: prompt, terminal_command, or skipped marker
         }
+        for (const message of userListTextMessages(rec)) {
+            if (message.isMeta) {
+                this.sink.onMetaUserMessage?.(message.text, rec.uuid ?? rec.requestId);
+                continue;
+            }
+            const candidates = submissionCandidates(message.text);
+            const queuedPromotion = rec.promptSource !== "typed" &&
+                candidates.some((candidate) => this.consumeQueuedPromotion(candidate));
+            if (!queuedPromotion &&
+                rec.promptSource !== "queued" &&
+                rec.promptSource !== "sdk") {
+                for (const candidate of candidates)
+                    this.rememberSubmission(candidate);
+            }
+            this.emitUserMessageRecord(rec, message.text, queuedPromotion);
+        }
         const events = parseTranscriptRecord(rec);
         if (events.length === 0)
             return;
@@ -1028,15 +1973,75 @@ export class ClaudeLiveSession {
         for (const event of events) {
             const mapped = this.remapMessageItem(event);
             this.trackTool(mapped);
+            this.rememberNativeSubagentParentResponse(mapped);
             this.sink.onEvent(mapped);
         }
-        // A Task tool_result carries `toolUseResult.agentId` — replay the (now
-        // complete) sub-agent transcript nested under this parent Task call.
-        this.maybeForwardSubagent(rec);
         // TaskCreate/TaskUpdate records also refresh the task-list snapshot.
         this.maybeUpdateTodos(rec);
         this.lastActivityAt = this.now();
     }
+    emitUserMessageRecord(rec, content, queuedPromotion) {
+        const queuedIntoOpenTurn = this.turnOpen && (queuedPromotion || rec.promptSource === "queued" || rec.promptSource === "sdk");
+        if (queuedIntoOpenTurn) {
+            // Claude type-ahead is one native busy interval: enqueue now, promote
+            // later, and emit one final Stop. Do not close/re-open the canonical
+            // response when the promoted user record arrives mid-turn.
+            this.sink.onUserMessage(content);
+            this.lastActivityAt = this.now();
+            return;
+        }
+        const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
+        if (this.turnOpen && this.syntheticTurn) {
+            // A hook can flush just before the transcript's user record. The
+            // interaction already opened a unique provisional response; adopt the
+            // real turn id internally without closing/cancelling that same Turn.
+            this.currentTurnId = turnId;
+            this.syntheticTurn = false;
+        }
+        else {
+            this.closeTurn();
+            this.currentTurnId = turnId;
+            this.turnOpen = true;
+            this.turnInterrupted = false;
+            this.syntheticTurn = false;
+            this.providerIdleAt = null;
+            this.openToolIds.clear();
+            this.stopPendingAt = null;
+            this.stopBackgroundTaskCount = undefined;
+            this.stopBackgroundTaskCountDelivered = false;
+            this.sink.onTurnStart(this.currentTurnId);
+        }
+        this.sink.onUserMessage(content);
+        this.lastActivityAt = this.now();
+    }
+    handleCompactSummary(rec) {
+        const state = this.readCompactionState();
+        if (!this.compactionPendingMatches(state)) {
+            if (state.persistedSequences.length === 0 && !state.expectCompletionAckSequence) {
+                console.warn("[claude-forwarder] skipping isCompactSummary without a pending PreCompact token");
+            }
+            if (state.expectCompletionAckSequence) {
+                const { expectCompletionAckSequence: _omitted, ...withoutAck } = state;
+                writeCompactionForwardState(this.bridgeDir, withoutAck);
+            }
+            return;
+        }
+        const sequence = state.pending.sequence;
+        const content = rec.message?.content;
+        const summary = typeof content === "string"
+            ? content
+            : Array.isArray(content)
+                ? content.flatMap((block) => isRecord(block) && typeof block.text === "string" ? [block.text] : []).join("\n")
+                : "";
+        const delivery = this.sink.onCompactionBoundary?.(summary || "[Claude Code compaction — context was compacted in the terminal]", sequence, "transcript");
+        if (delivery === undefined)
+            return;
+        this.pendingTranscriptCompactions.push({
+            sequence,
+            generation: state.generation,
+            delivery: Promise.resolve(delivery),
+        });
+    }
     /** Fold a `TaskCreate` (new pending task) or `TaskUpdate` (status/subject/delete)
      *  record into the task list; on any change emit the whole list as a snapshot. */
     maybeUpdateTodos(rec) {
@@ -1063,28 +2068,6 @@ export class ClaudeLiveSession {
         if (changed)
             this.sink.onTodos([...this.todos.values()]);
     }
-    /** On a `Task` tool_result, replay the sub-agent's own transcript
-     *  (`subagents/agent-<agentId>.jsonl`) as events tagged with the parent Task
-     *  tool-use id, so the canonical layer nests them under that call. Fired once
-     *  per sub-agent (at tool_result time the file is complete — no live race). */
-    maybeForwardSubagent(rec) {
-        if (!this.transcriptPath)
-            return;
-        const result = rec.toolUseResult;
-        const agentId = isRecord(result) && typeof result.agentId === "string" ? result.agentId : undefined;
-        if (!agentId || this.seenSubagents.has(agentId))
-            return;
-        const parentToolUseId = toolResultCallId(rec);
-        if (!parentToolUseId)
-            return;
-        this.seenSubagents.add(agentId);
-        const file = subagentTranscriptPath(this.transcriptPath, agentId);
-        // Emit raw (no remap/track): sub-agent messages have their own itemIds and
-        // must not consume the parent's MessageDisplay FIFO, and their tool pairs are
-        // already complete so they need no open-tool tracking.
-        for (const event of readSubagentEvents(file, parentToolUseId))
-            this.sink.onEvent(event);
-    }
     /** Tail streamed assistant-text chunks (MessageDisplay) into live `token`
      *  events. Guarded on an open turn — deltas belong to the turn the user record
      *  opened; the offset advances only once processed. */
@@ -1093,9 +2076,21 @@ export class ClaudeLiveSession {
         this.deltasOffset = nextOffset;
         // MessageDisplay has no Turn id. Chunks observed while idle belong to the
         // Turn that just closed and must never be replayed into a later Turn.
-        if (!this.turnOpen)
+        if (!this.turnOpen) {
+            writeDeltaForwardState(this.bridgeDir, { byteOffset: nextOffset });
             return;
+        }
         for (const d of deltas) {
+            const key = `${d.messageId}:${d.index}`;
+            if (this.seenDeltaKeys.has(key))
+                continue;
+            this.seenDeltaKeys.add(key);
+            while (this.seenDeltaKeys.size > 5_000) {
+                const oldest = this.seenDeltaKeys.values().next().value;
+                if (!oldest)
+                    break;
+                this.seenDeltaKeys.delete(oldest);
+            }
             this.streamedMessageText.set(d.messageId, (this.streamedMessageText.get(d.messageId) ?? "") + d.delta);
             this.sink.onEvent({
                 type: "token",
@@ -1111,6 +2106,9 @@ export class ClaudeLiveSession {
                 this.finalizeMessageDisplay(d.messageId);
             }
         }
+        if (nextOffset > 0 || deltas.length > 0) {
+            writeDeltaForwardState(this.bridgeDir, { byteOffset: nextOffset });
+        }
         if (deltas.length)
             this.lastActivityAt = this.now();
     }
@@ -1143,8 +2141,10 @@ export class ClaudeLiveSession {
             this.providerIdleAt = null;
     }
     handleSessionStatus(status) {
-        this.stopSignalPending = false;
-        this.stopPendingAt = null;
+        if (this.pendingTerminalHook?.eventName !== "Stop") {
+            this.stopSignalPending = false;
+            this.stopPendingAt = null;
+        }
         if (status.runnerStatus === "running") {
             this.providerFailureSticky = false;
             // A new native busy interval supersedes the prior Stop snapshot. The
@@ -1216,6 +2216,25 @@ export class ClaudeLiveSession {
                 this.openToolIds.delete(id);
         }
     }
+    rememberNativeSubagentParentResponse(event) {
+        if (event.type !== "tool" || event.event !== "on_tool_start")
+            return;
+        const parentToolCallId = readId(event.input) ?? readId(event.data);
+        if (!parentToolCallId || this.nativeSubagentParentResponses.has(parentToolCallId))
+            return;
+        const responseId = this.currentTurnId
+            ? `resp_claude_${this.currentTurnId}`
+            : "resp_claude_native";
+        this.nativeSubagentParentResponses.set(parentToolCallId, responseId);
+        while (this.nativeSubagentParentResponses.size > 2_000) {
+            const oldest = this.nativeSubagentParentResponses.keys().next().value;
+            if (!oldest)
+                break;
+            this.nativeSubagentParentResponses.delete(oldest);
+        }
+        this.sink.onSubagentParentResponse?.(parentToolCallId, responseId);
+        this.persistSubagentForwardStates();
+    }
     ensureTurn(provisionalTurnId) {
         if (this.turnOpen)
             return;
@@ -1230,15 +2249,30 @@ export class ClaudeLiveSession {
         this.stopBackgroundTaskCountDelivered = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
-    /** Mirror a local `!` command as its own mini-turn: close any open turn, then
-     *  open→emit→close so it groups as one response with a stable id (the record
-     *  uuid) and never lingers "running" (input+output are complete in one record). */
-    emitTerminalCommand(rec, cmd) {
-        this.closeTurn();
-        const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
-        this.sink.onTurnStart(turnId);
-        this.sink.onTerminalCommand(cmd);
-        this.sink.onTurnEnd();
+    /** Mirror a Claude `!cmd` as one logical mini-turn even when input and output
+     * are separate transcript records. The output repeats the remembered command
+     * in Rynx's combined terminal item shape; the transcript projection merges
+     * that completion into the preceding command row. */
+    emitTerminalCommand(rec, fragments) {
+        if (fragments.command !== undefined) {
+            this.closeTurn();
+            const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
+            this.ensureTurn(turnId);
+            this.syntheticTurn = false;
+            this.activeTerminalCommand = { command: fragments.command, ...(turnId ? { turnId } : {}) };
+        }
+        else if (!this.turnOpen) {
+            const turnId = this.activeTerminalCommand?.turnId ??
+                (typeof rec.uuid === "string" ? rec.uuid : undefined);
+            this.ensureTurn(turnId);
+            this.syntheticTurn = false;
+        }
+        this.sink.onTerminalCommand(terminalCommandData(fragments, this.activeTerminalCommand?.command));
+        this.lastActivityAt = this.now();
+        if (fragments.hasOutput) {
+            this.closeTurn();
+            this.activeTerminalCommand = undefined;
+        }
     }
     /** The web Stop button interrupted this session (host sent Escape). claude
      *  records the interrupt in its own transcript but may not fire a Stop hook when
@@ -1281,7 +2315,7 @@ export class ClaudeLiveSession {
             this.sink.onTurnError(error);
         return failedOpenTurn;
     }
-    closeTurn() {
+    closeTurn(reason) {
         if (!this.turnOpen)
             return;
         this.drainInteractionCommits();
@@ -1304,9 +2338,11 @@ export class ClaudeLiveSession {
         if (interrupted && this.sink.onTurnInterrupted)
             this.sink.onTurnInterrupted(usage);
         else
-            this.sink.onTurnEnd(usage, backgroundTaskCount);
+            this.sink.onTurnEnd(usage, backgroundTaskCount, reason);
+        if (!this.transcriptDeliveryPending)
+            this.persistForwardState();
     }
-    closeTurnError(error) {
+    closeTurnError(error, sourceId) {
         if (!this.turnOpen)
             return;
         this.drainInteractionCommits();
@@ -1321,7 +2357,10 @@ export class ClaudeLiveSession {
         this.stopBackgroundTaskCount = undefined;
         this.stopBackgroundTaskCountDelivered = false;
         this.resetMessageCorrelation();
-        this.sink.onTurnError(error);
+        const delivery = this.sink.onTurnError(error, sourceId);
+        if (!this.transcriptDeliveryPending)
+            this.persistForwardState();
+        return delivery;
     }
     resetMessageCorrelation() {
         this.finalizedMessageIds.clear();