@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/claude/native-integration.js

@@ -5,11 +5,12 @@
  * the Claude Code TUI feeds through its hooks + transcript:
  *
  *  - `hooks.jsonl` (bridge) — `SessionStart` reveals the transcript path + claude
- *    session id (discovery); `Stop`/`StopFailure` CLOSE the turn (authoritative).
+ *    session id; `StopFailure` supplies the failure edge and `Stop` carries the
+ *    legacy fallback boundary.
  *  - the transcript JSONL — the turn OPENS on a `role:user` prompt record and its
- *    assistant/tool records become {@link AgentEvent}s. (Turn framing is
- *    transcript-open + hook-close, matching the reference implementation re-audit; `running` is
- *    implicit between open and close, so no PTY watcher is needed.)
+ *    assistant/tool records become {@link AgentEvent}s.
+ *  - Claude's per-process session file — while readable, it is the source of
+ *    truth for running/idle and supersedes the hook/pane heuristics.
  *
  * The mapped events drive the SAME per-turn {@link SessionNormalizer} sink shape
  * the codex forwarder uses (see the host), so mirroring is identical downstream.
@@ -17,15 +18,29 @@
  * 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 { jsonlCursorFingerprint, interactionLeaseUpdatedAt, readClaimedInteractionResult, readClaudeStatus, readForwardState, readInteractionAcksFrom, readHookEventsFrom, readInteractionRequestsFrom, readJsonlFrom, readMessageDeltasFrom, resetForwardState, removeClaimedInteractionResult, removeInteractionLease, removeInteractionResult, scrubClaudeInteractionArtifacts, writeInteractionResult, writeForwardState, } 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;
 const INTERACTION_ACK_TIMEOUT_MS = 5_000;
+// Claude writes this synthetic user record after Escape (including a tool-use
+// interruption). It is lifecycle, not a new prompt. Kept aligned with
+// reference implementation's `_CLAUDE_INTERRUPT_RECORD_RE`.
+const CLAUDE_INTERRUPT_RECORD_RE = /^\[Request interrupted by user(?: for tool use)?\]$/;
 const INTERACTION_LEASE_TIMEOUT_MS = 30_000;
+const FORWARDER_RESTART_INITIAL_MS = 1_000;
+const FORWARDER_RESTART_MAX_MS = 30_000;
+const FORWARDER_HEALTHY_UPTIME_MS = 60_000;
 function processIsAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -47,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;
@@ -74,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;
@@ -120,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;
@@ -143,10 +247,28 @@ export class ClaudeLiveSession {
     leaseUpdatedAt;
     started = false;
     stopped = false;
+    supervisorTask;
+    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. */
@@ -158,17 +280,40 @@ 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
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     syntheticTurn = false;
     lastActivityAt = 0;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     stopPendingAt = null;
+    /** Authoritative live background-shell count from the pending Stop hook. */
+    stopBackgroundTaskCount;
+    /** Whether the pending Stop count already rode an immediate idle edge. */
+    stopBackgroundTaskCountDelivered = false;
+    /** An idle status from Claude's session metadata. The short delay keeps a
+     * final transcript record in the response without letting stale tool state
+     * override the provider's terminal status. */
+    providerIdleAt = null;
+    statusPoller;
+    /** A failed hook is authoritative until the next running edge. Claude writes
+     * idle after failures too, so that trailing file update must not erase it. */
+    providerFailureSticky = false;
     /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
     openToolIds = new Set();
     /** Transcript-backed acknowledgements for web→TUI input. A direct idle
@@ -197,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();
@@ -206,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). */
@@ -228,7 +383,20 @@ 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;
+            this.hookEventCursor = hookState.eventCursor;
+        }
         // Resume path: bind the session id + restore the persisted forwarder cursor so
         // we continue from where a prior forwarder left off (no re-mirror on relaunch).
         if (opts.transcriptPath) {
@@ -237,6 +405,7 @@ export class ClaudeLiveSession {
                 this.seenClaudeSessionIds.add(opts.claudeSessionId);
             }
             this.restoreForwardState(opts.transcriptPath);
+            this.restoreSubagentForwardStates(opts.transcriptPath);
         }
     }
     /**
@@ -253,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). */
@@ -322,12 +527,14 @@ export class ClaudeLiveSession {
         if (this.started)
             return;
         this.started = true;
-        void this.loop();
+        this.supervisorTask = this.supervise();
     }
     stop() {
         if (this.stopped)
             return;
         this.stopped = true;
+        this.releaseSleep?.();
+        this.statusPoller?.retire();
         // A hook may have appended its request just before shutdown but not yet
         // reached a scheduled poll. Drain it so the subprocess receives cancellation
         // instead of remaining blocked until Claude's one-day hook timeout.
@@ -339,6 +546,24 @@ export class ClaudeLiveSession {
         this.closeTurn();
         this.scheduleClaimedInteractionScrubs();
     }
+    /** Wait for the supervised polling task to retire. Terminal teardown starts
+     * synchronously in {@link stop}; callers use this bounded join before their
+     * runner process exits. */
+    async waitForStop(timeoutMs = 5_000) {
+        const task = this.supervisorTask;
+        if (!task)
+            return;
+        let timer;
+        await Promise.race([
+            task,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+    }
     /** Phase two of runner shutdown. The caller must stop the Claude terminal
      * first so no hook can still be opening an atomically claimed answer. This is
      * synchronous because the runner process exits immediately afterwards. */
@@ -350,24 +575,80 @@ 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();
         this.pollAbandonedInteractions();
         this.flushTurnFailure();
         this.pollStatus();
+        this.pollSessionStatus();
         this.flushStopSignal();
         this.maybeIdleClose();
     }
+    /** Bind Claude's per-process session metadata after the terminal exists. */
+    attachStatusSource({ panePid, configDir, }) {
+        this.statusPoller?.retire();
+        this.statusPoller = new ClaudeSessionStatusPoller({
+            panePid,
+            sessionId: () => this.currentClaudeSessionId,
+            onStatus: (status) => this.handleSessionStatus(status),
+            ...(configDir ? { configDir } : {}),
+        });
+    }
+    async supervise() {
+        let backoffMs = FORWARDER_RESTART_INITIAL_MS;
+        while (!this.stopped) {
+            const startedAt = this.now();
+            let crashed;
+            try {
+                await this.loop();
+                if (!this.stopped) {
+                    console.warn("[claude-forwarder] polling loop returned unexpectedly; restarting");
+                }
+            }
+            catch (error) {
+                crashed = error;
+            }
+            if (this.stopped)
+                break;
+            if (this.now() - startedAt >= FORWARDER_HEALTHY_UPTIME_MS) {
+                backoffMs = FORWARDER_RESTART_INITIAL_MS;
+            }
+            if (crashed !== undefined) {
+                console.error(`[claude-forwarder] polling loop crashed; restarting in ${backoffMs}ms:`, crashed);
+            }
+            await this.sleepUntilWake(backoffMs);
+            backoffMs = Math.min(backoffMs * 2, FORWARDER_RESTART_MAX_MS);
+        }
+    }
     async loop() {
         while (!this.stopped) {
             try {
@@ -379,7 +660,7 @@ export class ClaudeLiveSession {
                 // per-iteration `except Exception` in the transcript forwarder loop.
                 console.error("[claude-forwarder] tick failed; continuing:", err);
             }
-            await new Promise((r) => setTimeout(r, this.pollMs));
+            await this.sleepUntilWake(this.pollMs);
         }
         // Catch a request appended while the loop was waking up to observe stopped.
         this.pollInteractions();
@@ -388,34 +669,355 @@ export class ClaudeLiveSession {
         this.closeTurn();
         this.scheduleClaimedInteractionScrubs();
     }
+    sleepUntilWake(delayMs) {
+        if (this.stopped)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const timer = setTimeout(done, delayMs);
+            timer.unref?.();
+            const self = this;
+            function done() {
+                if (self.releaseSleep === done)
+                    self.releaseSleep = undefined;
+                clearTimeout(timer);
+                resolve();
+            }
+            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() {
-        const { events, nextOffset } = readHookEventsFrom(this.bridgeDir, this.hooksOffset);
-        this.hooksOffset = nextOffset;
-        for (const ev of events)
-            this.handleHook(ev);
+        if (this.rotationPending || this.compactionHookPending || this.pendingTerminalHook)
+            return;
+        const { events } = readHookEventsFrom(this.bridgeDir, this.hooksOffset, this.hookEventCursor);
+        for (const ev of events) {
+            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;
+        const fingerprint = jsonlCursorFingerprint(`${this.bridgeDir}/${HOOKS_FILE}`, ev.byteOffset);
+        writeHookForwardState(this.bridgeDir, {
+            eventCursor: ev.eventCursor,
+            byteOffset: ev.byteOffset,
+            ...(fingerprint ? { cursorFingerprint: fingerprint } : {}),
+        });
     }
     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.
             if (ev.eventName === "StopFailure") {
                 this.stopSignalPending = false;
                 this.stopPendingAt = null;
+                this.stopBackgroundTaskCount = undefined;
+                this.stopBackgroundTaskCountDelivered = false;
                 this.turnFailurePending = new Error("claude turn failed");
             }
             else {
                 this.stopSignalPending = true;
                 this.stopPendingAt = this.now(); // close after a short grace (late assistant flush)
+                this.stopBackgroundTaskCount = ev.backgroundTaskCount ?? 0;
+                this.stopBackgroundTaskCountDelivered = false;
             }
         }
     }
+    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() {
@@ -423,16 +1025,67 @@ export class ClaudeLiveSession {
         if (!error)
             return;
         this.turnFailurePending = null;
-        this.closeTurnError(error);
+        this.providerFailureSticky = true;
+        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();
+        if (this.pendingInteractions.size === 0) {
+            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"
@@ -450,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();
@@ -506,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. */
@@ -787,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.
@@ -809,18 +1919,14 @@ 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)) {
+                this.noteInterrupted();
+                this.lastActivityAt = this.now();
+                return;
+            }
             const candidates = submissionCandidates(content);
             const queuedPromotion = rec.promptSource !== "typed" &&
                 candidates.some((candidate) => this.consumeQueuedPromotion(candidate));
@@ -834,38 +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 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.syntheticTurn = false;
-                    this.openToolIds.clear();
-                    this.stopPendingAt = null;
-                    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;
@@ -873,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) {
@@ -908,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. */
@@ -938,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",
@@ -956,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();
     }
@@ -978,6 +2131,34 @@ export class ClaudeLiveSession {
         if (status)
             this.latestStatus = status;
     }
+    pollSessionStatus() {
+        const poller = this.statusPoller;
+        if (!poller)
+            return;
+        const wasActive = poller.active;
+        poller.tick();
+        if (wasActive && !poller.active)
+            this.providerIdleAt = null;
+    }
+    handleSessionStatus(status) {
+        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
+            // Session running edge clears its sticky tally; do not re-emit that old
+            // count if the previous transcript Turn closes a moment later.
+            this.stopBackgroundTaskCount = undefined;
+            this.stopBackgroundTaskCountDelivered = false;
+        }
+        else if (this.providerFailureSticky) {
+            return;
+        }
+        this.sink.onStatus?.(status.runnerStatus, status.blockedOn);
+        this.providerIdleAt = status.runnerStatus === "idle" ? this.now() : null;
+    }
     /** A usage record from the latest statusLine snapshot (snake_case, the keys the
      *  normalizer's `turn_completed` + the web `readUsageTokens` read), or undefined
      *  if the statusLine hook has not fired yet. */
@@ -1035,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;
@@ -1042,18 +2242,37 @@ export class ClaudeLiveSession {
             this.currentTurnId = provisionalTurnId;
             this.syntheticTurn = true;
         }
+        this.providerIdleAt = null;
         this.turnOpen = true;
+        this.turnInterrupted = false;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
-    /** Mirror a local `!` command as its own mini-turn: close any open turn, then
-     *  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
@@ -1063,10 +2282,14 @@ export class ClaudeLiveSession {
      *  turn's close via the same short grace. The Escape has stopped claude, so this
      *  does not race a still-running response. */
     noteInterrupted() {
-        if (!this.turnOpen)
+        if (!this.turnOpen || this.turnInterrupted)
             return;
+        this.turnInterrupted = true;
+        this.sink.onTurnInterruptRequested?.();
         this.cancelPendingInteractions("turn_interrupted");
         this.stopSignalPending = false;
+        if (this.statusPoller?.active)
+            return;
         this.sink.onIdle();
         this.stopPendingAt = this.now();
     }
@@ -1077,7 +2300,22 @@ export class ClaudeLiveSession {
     isTurnOpen() {
         return this.turnOpen;
     }
-    closeTurn() {
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error) {
+        if (!this.turnOpen)
+            return false;
+        this.closeTurnError(error);
+        return true;
+    }
+    /** Retire process-scoped metadata before classifying a terminal exit. */
+    noteTerminalExit(error) {
+        this.statusPoller?.retire();
+        const failedOpenTurn = this.failOpenTurn(error);
+        if (!failedOpenTurn)
+            this.sink.onTurnError(error);
+        return failedOpenTurn;
+    }
+    closeTurn(reason) {
         if (!this.turnOpen)
             return;
         this.drainInteractionCommits();
@@ -1089,9 +2327,22 @@ export class ClaudeLiveSession {
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();
-        this.sink.onTurnEnd(this.statusUsage());
+        const interrupted = this.turnInterrupted;
+        this.turnInterrupted = false;
+        const usage = this.statusUsage();
+        const backgroundTaskCount = this.stopBackgroundTaskCountDelivered
+            ? undefined
+            : this.stopBackgroundTaskCount;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
+        if (interrupted && this.sink.onTurnInterrupted)
+            this.sink.onTurnInterrupted(usage);
+        else
+            this.sink.onTurnEnd(usage, backgroundTaskCount, reason);
+        if (!this.transcriptDeliveryPending)
+            this.persistForwardState();
     }
-    closeTurnError(error) {
+    closeTurnError(error, sourceId) {
         if (!this.turnOpen)
             return;
         this.drainInteractionCommits();
@@ -1100,10 +2351,16 @@ export class ClaudeLiveSession {
         this.currentTurnId = undefined;
         this.syntheticTurn = false;
         this.openToolIds.clear();
+        this.turnInterrupted = false;
         this.stopSignalPending = false;
         this.stopPendingAt = null;
+        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();
@@ -1112,6 +2369,14 @@ export class ClaudeLiveSession {
         this.streamedMessageText.clear();
     }
     maybeIdleClose() {
+        if (this.statusPoller?.active) {
+            if (this.turnOpen &&
+                this.providerIdleAt !== null &&
+                this.now() - this.providerIdleAt >= this.stopGraceMs) {
+                this.closeTurn();
+            }
+            return;
+        }
         if (!this.turnOpen ||
             this.openToolIds.size > 0 ||
             this.pendingInteractions.size > 0)
@@ -1132,14 +2397,79 @@ export class ClaudeLiveSession {
 /** Claude Code renders this glyph once the input box is mounted (ready-gate). */
 const CLAUDE_PROMPT_GLYPH = "❯";
 const CLAUDE_PROMPT_SCAN_TAIL_LINES = 5;
+const CLAUDE_BOX_RULE_CHARS = new Set([..."─━╭╮╰╯│┃╌╍"]);
+const CLAUDE_PASTED_PLACEHOLDER_PREFIX = "[Pasted text";
+const CLAUDE_DRAFT_NEEDLE_MAX_CHARS = 24;
+/** Claude-native readiness window: tmux may exist well before the
+ * first interactive composer mounts on a cold start. */
+const CLAUDE_PROMPT_READY_TIMEOUT_MS = 30_000;
+const CLAUDE_PASTE_COMMIT_TIMEOUT_MS = 5_000;
+const CLAUDE_PASTE_SETTLE_MS = 100;
+const CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS = 10_000;
+const CLAUDE_SUBMIT_RETRY_MS = 1_000;
+function selectedMenuRow(line, glyph) {
+    const index = line.indexOf(glyph);
+    if (index < 0)
+        return false;
+    return /^\d+\.\s/.test(line.slice(index + glyph.length).trimStart());
+}
+function boxRule(line) {
+    const text = line.trim();
+    return text.length >= 3 && [...text].every((character) => CLAUDE_BOX_RULE_CHARS.has(character));
+}
 /** The live composer sits at the bottom of the pane. Restricting readiness to
  * its trailing non-empty lines prevents an old prompt glyph in scrollback from
  * accepting input while Claude is still booting or showing another screen. */
 function claudePromptRendered(pane, glyph) {
     const nonEmpty = pane.split(/\r?\n/).filter((line) => line.trim());
-    return nonEmpty
-        .slice(-CLAUDE_PROMPT_SCAN_TAIL_LINES)
-        .some((line) => line.includes(glyph));
+    const tailStart = Math.max(0, nonEmpty.length - CLAUDE_PROMPT_SCAN_TAIL_LINES);
+    for (let index = tailStart; index < nonEmpty.length; index += 1) {
+        const line = nonEmpty[index] ?? "";
+        if (!line.includes(glyph))
+            continue;
+        const framed = nonEmpty.slice(index + 1).some(boxRule);
+        if (framed)
+            return true;
+        if (!selectedMenuRow(line, glyph))
+            return true;
+    }
+    // A fan-out of subagents can make the running footer arbitrarily tall. Above
+    // the fixed tail, only a prompt framed by the composer's closing rule counts.
+    for (let index = 0; index < tailStart; index += 1) {
+        const line = nonEmpty[index] ?? "";
+        if (line.includes(glyph) && nonEmpty.slice(index + 1).some(boxRule))
+            return true;
+    }
+    return false;
+}
+function draftNeedle(content) {
+    const normalized = content.replace(/\r\n?/g, "\n");
+    for (const rawLine of normalized.split("\n")) {
+        const control = rawLine.search(/[\x00-\x1f]/);
+        const line = (control >= 0 ? rawLine.slice(0, control) : rawLine).trim();
+        if (line)
+            return line.slice(0, CLAUDE_DRAFT_NEEDLE_MAX_CHARS);
+    }
+    return "";
+}
+function draftInInputBox(pane, glyph, needle) {
+    const lines = pane.split(/\r?\n/).filter((line) => line.includes(glyph));
+    const line = lines.at(-1);
+    if (!line)
+        return false;
+    const tail = line.slice(line.lastIndexOf(glyph) + glyph.length);
+    if (tail.includes(CLAUDE_PASTED_PLACEHOLDER_PREFIX))
+        return true;
+    return Boolean(needle) && tail.includes(needle);
+}
+function terminalFailureTail(pane) {
+    const lines = pane.split(/\r?\n/).filter((line) => line.trim()).slice(-12);
+    if (lines.length === 0)
+        return "";
+    let tail = lines.join("\n");
+    if (tail.length > 800)
+        tail = `…${tail.slice(-800)}`;
+    return `\nlast terminal output:\n${tail}`;
 }
 async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
     const deadline = now() + timeoutMs;
@@ -1159,9 +2489,9 @@ async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
  *
  * THROWS if the prompt never appears within the ready-gate window (reference implementation
  * `_wait_for_claude_prompt_ready` RAISE) — a not-ready pane is a hard error the
- * caller reports, NOT a signal to fall through to a second output path. With a
- * transcript observer, Enter is retried only when Claude has durably recorded
- * neither a direct user prompt nor a type-ahead enqueue.
+ * caller reports, NOT a signal to fall through to a second output path. Enter
+ * is retried only while the exact draft remains visible and Claude has durably
+ * recorded neither a direct user prompt nor a type-ahead enqueue.
  */
 export async function injectViaTerminal(injector, text, opts = {}) {
     const glyph = opts.promptGlyph ?? CLAUDE_PROMPT_GLYPH;
@@ -1180,12 +2510,23 @@ export async function injectViaTerminal(injector, text, opts = {}) {
     };
     // 1. Ready-gate. No prompt within the window → THROW (reference implementation RAISE): a
     //    not-ready pane is a hard error, never a fall-through-to-run signal.
-    const ready = await pollUntil(() => claudePromptRendered(injector.capturePane(), glyph), opts.promptTimeoutMs ?? 20_000, pollMs, now, sleep, signal);
+    let promptPolls = 0;
+    let emptyPromptPolls = 0;
+    let lastPromptPane = "";
+    const ready = await pollUntil(() => {
+        const pane = injector.capturePane();
+        promptPolls += 1;
+        if (pane.trim())
+            lastPromptPane = pane;
+        else
+            emptyPromptPolls += 1;
+        return claudePromptRendered(pane, glyph);
+    }, opts.promptTimeoutMs ?? CLAUDE_PROMPT_READY_TIMEOUT_MS, pollMs, now, sleep, signal);
     if (cancelled())
         return false;
     if (!ready) {
-        const tail = injector.capturePane().split("\n").slice(-5).join("\n");
-        throw new Error(`claude prompt not ready (no "${glyph}" within timeout)\npane tail:\n${tail}`);
+        throw new Error(`claude prompt not ready (no input composer within timeout; ${promptPolls} polls, ` +
+            `${emptyPromptPolls} empty captures)${terminalFailureTail(lastPromptPane)}`);
     }
     // 2. Clear leftover, then bracketed-paste the draft. A final "\" is Claude's
     // documented soft-newline escape: a bare submit Enter would consume it and
@@ -1193,30 +2534,47 @@ export async function injectViaTerminal(injector, text, opts = {}) {
     // the bracketed paste; normal messages must not gain an empty input row.
     injector.clearInputLine();
     injector.paste(text.endsWith("\\") ? `${text}\n` : text);
-    // 3. `paste-buffer` returns after tmux wrote the bracketed-paste frame. Give
-    // Claude a short, fixed settle window before the separate submit key; screen
-    // text is not used as an acknowledgement because submitted prompts remain in
-    // scrollback and are indistinguishable from an editable draft.
-    await sleep(opts.settleMs ?? 500);
+    // 3. tmux accepting `paste-buffer` does not mean Claude consumed it. Wait for
+    // the draft (or its large-paste placeholder) to appear in the live composer;
+    // otherwise Enter can be coalesced into the paste as a newline.
+    const needle = draftNeedle(text);
+    const draftSeen = await pollUntil(() => draftInInputBox(injector.capturePane(), glyph, needle), opts.pasteCommitMs ?? CLAUDE_PASTE_COMMIT_TIMEOUT_MS, pollMs, now, sleep, signal);
+    await sleep(opts.settleMs ?? CLAUDE_PASTE_SETTLE_MS);
     if (cancelled())
         return false; // Stop pressed mid-paste → don't submit
-    // 4. Submit. Without a transcript observer this remains a one-Enter
-    // best-effort operation. With one, a bounded retry handles an Enter swallowed
-    // by the TUI without ever consulting stale pane text. A direct prompt or
-    // queue enqueue ends the loop immediately.
+    // 4. Submit and verify. Retry only while this exact draft is still visible;
+    // once it leaves the composer, another Enter could hit a permission dialog or
+    // an empty prompt. Transcript acknowledgement is the strongest success proof.
     const observed = opts.submissionObserved;
-    const attempts = observed
-        ? Math.max(1, Math.floor(opts.maxSubmitAttempts ?? 2))
-        : 1;
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-        injector.sendEnter();
-        if (!observed)
+    let attempts = 1;
+    const maxAttempts = Math.max(1, Math.floor(opts.maxSubmitAttempts ?? Number.MAX_SAFE_INTEGER));
+    injector.sendEnter();
+    // Preserve the old blind-submit fallback when capture-pane cannot
+    // identify the draft; its absence would otherwise "prove" success trivially.
+    if (!draftSeen)
+        return true;
+    const deadline = now() + (opts.submitConfirmMs ?? CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS);
+    const retryMs = opts.submitRetryMs ?? CLAUDE_SUBMIT_RETRY_MS;
+    let lastEnterAt = now();
+    while (now() < deadline) {
+        if (cancelled())
+            return false;
+        if (observed?.())
             return true;
-        if (await pollUntil(observed, opts.submitConfirmMs ?? 2_000, pollMs, now, sleep, signal)) {
+        if (!draftInInputBox(injector.capturePane(), glyph, needle))
             return true;
+        if (now() - lastEnterAt >= retryMs && attempts < maxAttempts) {
+            injector.sendEnter();
+            attempts += 1;
+            lastEnterAt = now();
         }
-        if (cancelled())
-            return false;
+        await sleep(pollMs);
     }
-    return false;
+    if (observed?.())
+        return true;
+    if (!draftInInputBox(injector.capturePane(), glyph, needle))
+        return true;
+    throw new Error(`Claude Code did not accept the submitted message within ` +
+        `${opts.submitConfirmMs ?? CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS}ms ` +
+        "(the draft is still in the input box). The message was not delivered.");
 }