@getpaseo/server 0.1.30 → 0.1.33

package/dist/src/server/agent/providers/claude-agent.js

@@ -6,35 +6,14 @@ import os from "node:os";
 import path from "node:path";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
 import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
-import { isTaskNotificationUserContent, mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { coerceTaskNotificationHistoryRecordToSystemMessage, mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
 import { buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, listClaudeCatalogModels, } from "./claude/model-catalog.js";
 import { parsePartialJsonObject } from "./claude/partial-json.js";
-import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
-import { applyProviderEnv, } from "../provider-launch-config.js";
+import { ClaudeSidechainTracker } from "./claude/sidechain-tracker.js";
+import { applyProviderEnv } from "../provider-launch-config.js";
 import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
-/*
- * Routing invariant:
- * While a foreground Claude turn is active, identifier-less assistant/stream/result
- * events must stay attached to that foreground run unless we have explicit evidence
- * that a distinct autonomous run has started.
- *
- * We previously allowed task_notification metadata to reserve autonomous ownership,
- * then consumed that reservation on the next unbound chunk. In practice Claude often
- * emits task_notification records and foreground tool-use stream chunks interleaved
- * within the same turn. That let a foreground turn's terminal result get misrouted
- * into an autonomous side run, which stranded the agent in "running" because the
- * foreground stream never received turn_completed.
- *
- * The rule below is intentionally conservative: foreground turns get first claim on
- * same-turn traffic, and autonomous wake reservations are only consumed once no
- * foreground turn is active. This keeps task_notification advisory instead of letting
- * it steal ownership from the active user turn.
- */
 const fsPromises = promises;
-const CLAUDE_SETTING_SOURCES = [
-    "user",
-    "project",
-];
+const CLAUDE_SETTING_SOURCES = ["user", "project"];
 function normalizeModelIdCandidate(modelId) {
     if (typeof modelId !== "string") {
         return null;
@@ -175,6 +154,8 @@ const REWIND_COMMAND = {
     argumentHint: "[user_message_uuid]",
 };
 const INTERRUPT_TOOL_USE_PLACEHOLDER = "[Request interrupted by user for tool use]";
+const INTERRUPT_PLACEHOLDER_PATTERN = /^\[Request interrupted by user(?:[^\]]*)\]$/;
+const NO_RESPONSE_REQUESTED_PLACEHOLDER = "No response requested.";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
     const commandConfig = runtimeSettings?.command;
@@ -203,9 +184,7 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
             // The SDK defaults to spawning "node" via PATH lookup, which fails when
             // running from the managed runtime bundle where node isn't in PATH.
             // Always use process.execPath — the actual node binary running the daemon.
-            const command = resolved.command === spawnOptions.command
-                ? process.execPath
-                : resolved.command;
+            const command = resolved.command === spawnOptions.command ? process.execPath : resolved.command;
             return spawn(command, resolved.args, {
                 cwd: spawnOptions.cwd,
                 env: applyProviderEnv(spawnOptions.env, runtimeSettings),
@@ -228,32 +207,20 @@ function summarizeClaudeOptionsForLog(options) {
         const prompt = systemPromptRaw;
         const promptType = typeof prompt.type === "string" ? prompt.type : "custom";
         return {
-            mode: promptType === "preset"
-                ? "preset"
-                : "custom",
-            preset: typeof prompt.preset === "string" && prompt.preset.length > 0
-                ? prompt.preset
-                : null,
+            mode: promptType === "preset" ? "preset" : "custom",
+            preset: typeof prompt.preset === "string" && prompt.preset.length > 0 ? prompt.preset : null,
         };
     })();
-    const mcpServerNames = options.mcpServers
-        ? Object.keys(options.mcpServers).sort()
-        : [];
+    const mcpServerNames = options.mcpServers ? Object.keys(options.mcpServers).sort() : [];
     return {
         cwd: typeof options.cwd === "string" ? options.cwd : null,
-        permissionMode: typeof options.permissionMode === "string"
-            ? options.permissionMode
-            : null,
+        permissionMode: typeof options.permissionMode === "string" ? options.permissionMode : null,
         model: typeof options.model === "string" ? options.model : null,
         includePartialMessages: options.includePartialMessages === true,
-        settingSources: Array.isArray(options.settingSources)
-            ? options.settingSources
-            : [],
+        settingSources: Array.isArray(options.settingSources) ? options.settingSources : [],
         enableFileCheckpointing: options.enableFileCheckpointing === true,
         hasResume: typeof options.resume === "string" && options.resume.length > 0,
-        maxThinkingTokens: typeof options.maxThinkingTokens === "number"
-            ? options.maxThinkingTokens
-            : null,
+        maxThinkingTokens: typeof options.maxThinkingTokens === "number" ? options.maxThinkingTokens : null,
         hasEnv: !!options.env,
         envKeyCount: Object.keys(options.env ?? {}).length,
         hasMcpServers: mcpServerNames.length > 0,
@@ -338,10 +305,59 @@ function coerceToolResultContentToString(content) {
     }
     return deterministicStringify(content);
 }
+function normalizeClaudeTranscriptText(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function isClaudeInterruptPlaceholderText(value) {
+    const normalized = normalizeClaudeTranscriptText(value);
+    return normalized !== null && INTERRUPT_PLACEHOLDER_PATTERN.test(normalized);
+}
+function isClaudeNoResponsePlaceholderText(value) {
+    return normalizeClaudeTranscriptText(value) === NO_RESPONSE_REQUESTED_PLACEHOLDER;
+}
+function isClaudeTranscriptNoiseText(value) {
+    return isClaudeInterruptPlaceholderText(value) || isClaudeNoResponsePlaceholderText(value);
+}
+function collectClaudeTextContentParts(content) {
+    if (typeof content === "string") {
+        const normalized = normalizeClaudeTranscriptText(content);
+        return normalized ? [normalized] : [];
+    }
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            continue;
+        }
+        const text = normalizeClaudeTranscriptText(block.text);
+        if (text) {
+            parts.push(text);
+            continue;
+        }
+        const input = normalizeClaudeTranscriptText(block.input);
+        if (input) {
+            parts.push(input);
+        }
+    }
+    return parts;
+}
+function isClaudeTranscriptNoiseContent(content) {
+    const parts = collectClaudeTextContentParts(content);
+    return parts.length > 0 && parts.every((part) => isClaudeTranscriptNoiseText(part));
+}
 export function extractUserMessageText(content) {
     if (typeof content === "string") {
         const normalized = content.trim();
-        return normalized.length > 0 ? normalized : null;
+        if (!normalized || isClaudeTranscriptNoiseText(normalized)) {
+            return null;
+        }
+        return normalized;
     }
     if (!Array.isArray(content)) {
         return null;
@@ -353,12 +369,18 @@ export function extractUserMessageText(content) {
         }
         const text = typeof block.text === "string" ? block.text : undefined;
         if (text && text.trim()) {
-            parts.push(text.trim());
+            const trimmed = text.trim();
+            if (!isClaudeTranscriptNoiseText(trimmed)) {
+                parts.push(trimmed);
+            }
             continue;
         }
         const input = typeof block.input === "string" ? block.input : undefined;
         if (input && input.trim()) {
-            parts.push(input.trim());
+            const trimmed = input.trim();
+            if (!isClaudeTranscriptNoiseText(trimmed)) {
+                parts.push(trimmed);
+            }
         }
     }
     if (parts.length === 0) {
@@ -367,8 +389,6 @@ export function extractUserMessageText(content) {
     const combined = parts.join("\n\n").trim();
     return combined.length > 0 ? combined : null;
 }
-const MAX_SUB_AGENT_LOG_ENTRIES = 200;
-const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
 function isMetadata(value) {
     return typeof value === "object" && value !== null;
 }
@@ -508,179 +528,10 @@ function resolvePermissionKind(toolName, input) {
     }
     return "tool";
 }
-const ACTIVE_RUN_STATES = new Set([
-    "queued",
-    "awaiting_response",
-    "streaming",
-    "finalizing",
-]);
-class RunTracker {
-    constructor() {
-        this.runs = new Map();
-        this.runByTaskId = new Map();
-        this.runByParentMessageId = new Map();
-        this.runByMessageId = new Map();
-    }
-    createRun(input) {
-        const run = {
-            id: input.id,
-            owner: input.owner,
-            queue: input.queue,
-            state: "queued",
-            promptReplaySeen: input.promptReplaySeen ?? true,
-            taskIds: new Set(),
-            parentMessageIds: new Set(),
-            messageIds: new Set(),
-        };
-        this.runs.set(run.id, run);
-        return run;
-    }
-    getRun(runId) {
-        return this.runs.get(runId) ?? null;
-    }
-    getForegroundRun() {
-        for (const run of this.runs.values()) {
-            if (run.owner === "foreground" && this.isActive(run.state)) {
-                return run;
-            }
-        }
-        return null;
-    }
-    listActiveRuns(owner) {
-        const runs = [];
-        for (const run of this.runs.values()) {
-            if (!this.isActive(run.state)) {
-                continue;
-            }
-            if (owner && run.owner !== owner) {
-                continue;
-            }
-            runs.push(run);
-        }
-        return runs;
-    }
-    hasActiveRuns(owner) {
-        for (const run of this.runs.values()) {
-            if (!this.isActive(run.state)) {
-                continue;
-            }
-            if (owner && run.owner !== owner) {
-                continue;
-            }
-            return true;
-        }
-        return false;
-    }
-    getLatestActiveRun(owner) {
-        let latest = null;
-        for (const run of this.runs.values()) {
-            if (!this.isActive(run.state)) {
-                continue;
-            }
-            if (owner && run.owner !== owner) {
-                continue;
-            }
-            latest = run;
-        }
-        return latest;
-    }
-    isRunActive(run) {
-        if (!run) {
-            return false;
-        }
-        return this.isActive(run.state);
-    }
-    resolveByIdentifiers(identifiers) {
-        if (identifiers.taskId) {
-            const run = this.resolveMappedRun(this.runByTaskId, identifiers.taskId);
-            if (run) {
-                return { run, reason: "task_id" };
-            }
-        }
-        if (identifiers.parentMessageId) {
-            const run = this.resolveMappedRun(this.runByParentMessageId, identifiers.parentMessageId);
-            if (run) {
-                return { run, reason: "parent_message_id" };
-            }
-        }
-        if (identifiers.messageId) {
-            const run = this.resolveMappedRun(this.runByMessageId, identifiers.messageId);
-            if (run) {
-                return { run, reason: "message_id" };
-            }
-        }
-        return { run: null, reason: "metadata" };
-    }
-    bindIdentifiers(run, identifiers) {
-        if (identifiers.taskId) {
-            run.taskIds.add(identifiers.taskId);
-            this.runByTaskId.set(identifiers.taskId, run.id);
-        }
-        if (identifiers.parentMessageId) {
-            run.parentMessageIds.add(identifiers.parentMessageId);
-            this.runByParentMessageId.set(identifiers.parentMessageId, run.id);
-        }
-        if (identifiers.messageId) {
-            run.messageIds.add(identifiers.messageId);
-            this.runByMessageId.set(identifiers.messageId, run.id);
-        }
-    }
-    transition(run, nextState) {
-        run.state = nextState;
-    }
-    complete(run, terminalState) {
-        run.state = terminalState;
-        this.clearRunIndex(run);
-    }
-    deriveLifecycle(pendingPermissionCount) {
-        for (const run of this.runs.values()) {
-            if (this.isActive(run.state)) {
-                return "running";
-            }
-        }
-        if (pendingPermissionCount > 0) {
-            return "permission";
-        }
-        for (const run of this.runs.values()) {
-            if (run.state === "error") {
-                return "error";
-            }
-        }
-        return "idle";
-    }
-    resolveMappedRun(mapping, identifier) {
-        const runId = mapping.get(identifier);
-        if (!runId) {
-            return null;
-        }
-        const run = this.runs.get(runId);
-        if (!run || !this.isActive(run.state)) {
-            mapping.delete(identifier);
-            return null;
-        }
-        return run;
-    }
-    clearRunIndex(run) {
-        for (const taskId of run.taskIds) {
-            this.runByTaskId.delete(taskId);
-        }
-        for (const parentMessageId of run.parentMessageIds) {
-            this.runByParentMessageId.delete(parentMessageId);
-        }
-        for (const messageId of run.messageIds) {
-            this.runByMessageId.delete(messageId);
-        }
-        run.taskIds.clear();
-        run.parentMessageIds.clear();
-        run.messageIds.clear();
-    }
-    isActive(state) {
-        return ACTIVE_RUN_STATES.has(state);
-    }
-}
 class TimelineAssembler {
     constructor() {
         this.messages = new Map();
+        this.finalizedMessageIds = new Set();
         this.activeMessageByRun = new Map();
         this.syntheticMessageCounter = 0;
     }
@@ -700,6 +551,9 @@ class TimelineAssembler {
         if (!messageId) {
             return [];
         }
+        if (this.finalizedMessageIds.has(messageId)) {
+            return [];
+        }
         const state = this.ensureMessageState(messageId, runId);
         const fragments = this.extractFragments(message.message?.content);
         return this.applyAbsoluteFragments(state, fragments);
@@ -799,13 +653,16 @@ class TimelineAssembler {
         if (runId && this.activeMessageByRun.get(runId) === messageId) {
             this.activeMessageByRun.delete(runId);
         }
+        this.finalizedMessageIds.add(messageId);
+        this.messages.delete(messageId);
         return items;
     }
     emitNewContent(state) {
         const items = [];
         const nextAssistantText = state.assistantText.slice(state.emittedAssistantLength);
         if (nextAssistantText.length > 0 &&
-            nextAssistantText !== INTERRUPT_TOOL_USE_PLACEHOLDER) {
+            nextAssistantText !== INTERRUPT_TOOL_USE_PLACEHOLDER &&
+            !isClaudeTranscriptNoiseText(nextAssistantText)) {
             state.emittedAssistantLength = state.assistantText.length;
             items.push({ type: "assistant_message", text: nextAssistantText });
         }
@@ -886,28 +743,12 @@ class TimelineAssembler {
     }
     readMessageIdFromAssistantMessage(message) {
         const candidate = message;
-        return readTrimmedString(candidate.message_id) ??
-            readTrimmedString(candidate.message?.id) ??
-            null;
+        return (readTrimmedString(candidate.message_id) ?? readTrimmedString(candidate.message?.id) ?? null);
     }
     readMessageIdFromStreamEvent(event) {
         const message = event.message;
-        return (readTrimmedString(event.message_id) ??
-            readTrimmedString(message?.id) ??
-            null);
-    }
-}
-function isMetadataOnlySdkMessage(message) {
-    if (message.type === "system") {
-        return true;
-    }
-    if (message.type !== "user") {
-        return false;
-    }
-    if (isSyntheticUserEntry(message)) {
-        return true;
+        return readTrimmedString(event.message_id) ?? readTrimmedString(message?.id) ?? null;
     }
-    return isTaskNotificationUserContent(message.message?.content);
 }
 function isSyntheticUserEntry(entry) {
     if (!entry || typeof entry !== "object") {
@@ -1025,29 +866,30 @@ class ClaudeAgentSession {
         this.toolUseInputBuffers = new Map();
         this.pendingPermissions = new Map();
         this.activeForegroundTurn = null;
+        this.autonomousTurn = null;
         this.liveEventQueue = new Pushable();
-        this.runTracker = new RunTracker();
         this.timelineAssembler = new TimelineAssembler();
+        this.sidechainTracker = new ClaudeSidechainTracker({
+            getToolInput: (toolUseId) => this.toolUseCache.get(toolUseId)?.input ?? null,
+        });
         this.persistedHistory = [];
         this.historyPending = false;
+        this.historyOffsetSessionId = null;
+        this.historyReadOffsetBytes = 0;
+        this.historyLineFragment = "";
         this.turnState = "idle";
-        this.preReplayMetadataSeen = false;
-        this.pendingAutonomousWakeReservations = 0;
-        this.nextRunOrdinal = 1;
+        this.nextTurnOrdinal = 1;
         this.cancelCurrentTurn = null;
-        this.pendingInterruptPromise = null;
         this.activeTurnPromise = null;
         this.cachedRuntimeInfo = null;
         this.lastOptionsModel = null;
         this.selectableModelIds = buildClaudeSelectableModelIds();
         this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases();
-        this.activeSidechains = new Map();
         this.compacting = false;
         this.queryPumpPromise = null;
         this.queryRestartNeeded = false;
+        this.pendingInterruptAbort = false;
         this.userMessageIds = [];
-        this.localUserMessageIds = new Set();
-        this.suppressLocalReplayActivity = false;
         this.recentStderr = "";
         this.closed = false;
         this.handlePermissionRequest = async (toolName, input, options) => {
@@ -1202,34 +1044,25 @@ class ClaudeAgentSession {
         if (this.cancelCurrentTurn) {
             this.cancelCurrentTurn();
         }
-        this.suppressLocalReplayActivity = false;
-        this.pendingAutonomousWakeReservations = 0;
         const slashCommand = this.resolveSlashCommandInvocation(prompt);
         if (slashCommand?.commandName === REWIND_COMMAND_NAME) {
             yield* this.streamRewindCommand(slashCommand);
             return;
         }
-        await this.awaitPendingInterruptPromise();
-        if (this.turnState === "autonomous" &&
-            this.runTracker.hasActiveRuns("autonomous")) {
-            await this.transitionAutonomousToForeground();
+        if (this.autonomousTurn) {
+            this.completeAutonomousTurn();
         }
         const sdkMessage = this.toSdkUserMessage(prompt);
         const queue = new Pushable();
-        const run = this.createRun("foreground", queue);
-        this.runTracker.bindIdentifiers(run, {
-            taskId: null,
-            parentMessageId: null,
-            messageId: typeof sdkMessage.uuid === "string" ? sdkMessage.uuid : null,
-        });
         const foregroundTurn = {
-            runId: run.id,
+            id: this.createTurnId("foreground"),
             queue,
+            hasVisibleActivity: false,
         };
         this.activeForegroundTurn = foregroundTurn;
-        this.preReplayMetadataSeen = false;
         this.transitionTurnState("foreground", "foreground stream started");
         this.clearRecentStderr();
+        queue.push({ type: "turn_started", provider: "claude" });
         let finishedNaturally = false;
         let cancelIssued = false;
         let queueDrainedWithoutTerminal = false;
@@ -1240,19 +1073,16 @@ class ClaudeAgentSession {
                 return;
             }
             cancelIssued = true;
-            if (this.activeForegroundTurn?.runId === run.id) {
-                this.activeForegroundTurn = null;
-            }
             if (this.cancelCurrentTurn === requestCancel) {
                 this.cancelCurrentTurn = null;
             }
             this.rejectAllPendingPermissions(new Error("Permission request aborted"));
-            this.cancelRun(run, {
+            this.finishForegroundTurn({
                 type: "turn_canceled",
                 provider: "claude",
                 reason: "Interrupted",
             });
-            this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
+            void this.interruptActiveTurn().catch((error) => {
                 this.logger.warn({ err: error }, "Failed to interrupt during cancel");
             });
         };
@@ -1266,7 +1096,7 @@ class ClaudeAgentSession {
             this.input.push(sdkMessage);
         }
         catch (error) {
-            this.failRun(run, error instanceof Error ? error.message : "Claude stream failed");
+            this.finishForegroundTurn(this.buildTurnFailedEvent(error instanceof Error ? error.message : "Claude stream failed"));
             finishedNaturally = true;
         }
         try {
@@ -1306,16 +1136,8 @@ class ClaudeAgentSession {
             this.cancelCurrentTurn();
             return;
         }
-        const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
-        if (autonomousRuns.length > 0) {
-            this.flushPendingToolCalls();
-            for (const run of autonomousRuns) {
-                this.emitRunEvent(run, {
-                    type: "turn_canceled",
-                    provider: "claude",
-                    reason: "Interrupted",
-                });
-            }
+        if (this.autonomousTurn) {
+            this.cancelAutonomousTurn("Interrupted");
         }
         await this.interruptActiveTurn();
     }
@@ -1464,13 +1286,14 @@ class ClaudeAgentSession {
         this.cancelCurrentTurn?.();
         this.activeForegroundTurn?.queue.end();
         this.activeForegroundTurn = null;
+        this.autonomousTurn = null;
         this.cancelCurrentTurn = null;
         this.turnState = "idle";
-        this.suppressLocalReplayActivity = false;
-        this.pendingAutonomousWakeReservations = 0;
         this.liveEventQueue.end();
         this.activeTurnPromise = null;
+        this.sidechainTracker.clear();
         this.input?.end();
+        this.query?.close();
         await this.awaitWithTimeout(this.query?.interrupt?.(), "close query interrupt");
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
@@ -1512,15 +1335,11 @@ class ClaudeAgentSession {
         }
         const withoutPrefix = trimmed.slice(1);
         const firstWhitespaceIdx = withoutPrefix.search(/\s/);
-        const commandName = firstWhitespaceIdx === -1
-            ? withoutPrefix
-            : withoutPrefix.slice(0, firstWhitespaceIdx);
+        const commandName = firstWhitespaceIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, firstWhitespaceIdx);
         if (!commandName || commandName.includes("/")) {
             return null;
         }
-        const rawArgs = firstWhitespaceIdx === -1
-            ? ""
-            : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+        const rawArgs = firstWhitespaceIdx === -1 ? "" : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
         return rawArgs.length > 0
             ? { commandName, args: rawArgs, rawInput: trimmed }
             : { commandName, rawInput: trimmed };
@@ -1552,9 +1371,7 @@ class ClaudeAgentSession {
             yield {
                 type: "turn_failed",
                 provider: "claude",
-                error: error instanceof Error
-                    ? error.message
-                    : "Failed to rewind tracked files",
+                error: error instanceof Error ? error.message : "Failed to rewind tracked files",
             };
         }
     }
@@ -1592,8 +1409,7 @@ class ClaudeAgentSession {
             }
             return {
                 messageId: null,
-                error: rewindResult.error ??
-                    `No file checkpoint found for message ${candidate}.`,
+                error: rewindResult.error ?? `No file checkpoint found for message ${candidate}.`,
             };
         }
         const candidates = this.getRewindCandidateUserMessageIds();
@@ -1615,16 +1431,12 @@ class ClaudeAgentSession {
                 }
             }
             catch (error) {
-                lastError =
-                    error instanceof Error
-                        ? error.message
-                        : "Failed to rewind tracked files.";
+                lastError = error instanceof Error ? error.message : "Failed to rewind tracked files.";
             }
         }
         return {
             messageId: null,
-            error: lastError ??
-                "No rewind checkpoints are currently available for this session.",
+            error: lastError ?? "No rewind checkpoints are currently available for this session.",
         };
     }
     async rewindFilesOnce(messageId) {
@@ -1648,9 +1460,7 @@ class ClaudeAgentSession {
     getRewindCandidateUserMessageIds() {
         const candidates = [];
         const pushUnique = (value) => {
-            if (typeof value === "string" &&
-                value.length > 0 &&
-                !candidates.includes(value)) {
+            if (typeof value === "string" && value.length > 0 && !candidates.includes(value)) {
                 candidates.push(value);
             }
         };
@@ -1716,10 +1526,13 @@ class ClaudeAgentSession {
         }
         if (this.queryRestartNeeded && this.query) {
             this.input?.end();
+            this.query.close();
             try {
                 await this.query.return?.();
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             this.query = null;
             this.input = null;
             this.queryRestartNeeded = false;
@@ -1851,7 +1664,6 @@ class ClaudeAgentSession {
         }
         const messageId = randomUUID();
         this.rememberUserMessageId(messageId);
-        this.localUserMessageIds.add(messageId);
         return {
             type: "user",
             message: {
@@ -1863,24 +1675,6 @@ class ClaudeAgentSession {
             session_id: this.claudeSessionId ?? "",
         };
     }
-    async awaitPendingInterruptPromise() {
-        if (!this.pendingInterruptPromise) {
-            return;
-        }
-        await this.pendingInterruptPromise;
-        this.pendingInterruptPromise = null;
-    }
-    createRun(owner, queue) {
-        const runId = `${owner}-run-${this.nextRunOrdinal++}`;
-        const run = this.runTracker.createRun({
-            id: runId,
-            owner,
-            queue,
-            promptReplaySeen: owner === "autonomous",
-        });
-        this.logger.debug({ runId, owner, state: run.state }, "Created Claude run");
-        return run;
-    }
     transitionTurnState(next, reason) {
         if (this.turnState === next) {
             return;
@@ -1888,20 +1682,17 @@ class ClaudeAgentSession {
         this.logger.debug({ from: this.turnState, to: next, reason }, "Claude turn state transition");
         this.turnState = next;
     }
-    transitionTurnStateFromActiveRuns(reason) {
-        if (this.runTracker.hasActiveRuns("foreground")) {
+    syncTurnState(reason) {
+        if (this.activeForegroundTurn) {
             this.transitionTurnState("foreground", reason);
             return;
         }
-        if (this.runTracker.hasActiveRuns("autonomous")) {
+        if (this.autonomousTurn) {
             this.transitionTurnState("autonomous", reason);
             return;
         }
         this.transitionTurnState("idle", reason);
     }
-    failRun(run, errorMessage) {
-        this.emitRunEvent(run, this.buildTurnFailedEvent(errorMessage));
-    }
     buildTurnFailedEvent(errorMessage) {
         const normalized = errorMessage.trim() || "Claude run failed";
         const exitCodeMatch = normalized.match(/\bcode\s+(\d+)\b/i);
@@ -1927,274 +1718,106 @@ class ClaudeAgentSession {
         this.recentStderr = "";
     }
     getRecentStderrDiagnostic() {
-        const text = this.recentStderr.trim();
-        return text.length > 0 ? text : undefined;
+        return this.recentStderr.trim() || undefined;
     }
-    cancelRun(run, event) {
-        this.flushPendingToolCalls();
-        this.emitRunEvent(run, event);
+    createTurnId(owner) {
+        return `${owner}-turn-${this.nextTurnOrdinal++}`;
     }
-    emitRunEvent(run, event) {
-        if (event.type === "turn_started" ||
-            event.type === "turn_completed" ||
+    isTerminalTurnEvent(event) {
+        return (event.type === "turn_completed" ||
             event.type === "turn_failed" ||
-            event.type === "turn_canceled") {
-            this.logger.trace({
-                runId: run.id,
-                owner: run.owner,
-                runState: run.state,
-                eventType: event.type,
-                routedTo: run.owner === "foreground" && run.queue ? "foreground_queue" : "live_queue",
-            }, "Claude run event emitted");
-        }
-        if (run.owner === "foreground" && run.queue) {
-            run.queue.push(event);
-            if (event.type === "turn_completed" ||
-                event.type === "turn_failed" ||
-                event.type === "turn_canceled") {
-                run.queue.end();
-            }
-        }
-        else {
-            this.liveEventQueue.push(event);
-        }
-        this.handleRunTerminalEvent(run, event);
+            event.type === "turn_canceled");
     }
-    handleRunTerminalEvent(run, event) {
-        if (event.type === "turn_completed") {
-            this.runTracker.complete(run, "completed");
-        }
-        else if (event.type === "turn_failed") {
-            this.runTracker.complete(run, "error");
-        }
-        else if (event.type === "turn_canceled") {
-            this.runTracker.complete(run, "interrupted");
-        }
-        else {
-            return;
+    shouldRecoverInterruptedQueryAbort(error, consecutiveRecoveries) {
+        if (consecutiveRecoveries >= 3) {
+            return false;
         }
-        if (this.activeForegroundTurn?.runId === run.id) {
-            this.activeForegroundTurn = null;
-            this.preReplayMetadataSeen = false;
+        const message = typeof error === "string"
+            ? error
+            : error instanceof Error
+                ? `${error.message}\n${error.stack ?? ""}`
+                : JSON.stringify(error);
+        return message.toLowerCase().includes("request was aborted");
+    }
+    finishForegroundTurn(event) {
+        if (event.type === "turn_failed" || event.type === "turn_canceled") {
+            this.flushPendingToolCalls();
         }
-        this.logger.trace({
-            runId: run.id,
-            owner: run.owner,
-            eventType: event.type,
-            runState: run.state,
-            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
-        }, "Claude run terminal event handled");
-        this.transitionTurnStateFromActiveRuns(`run ${run.id} terminal`);
+        this.dispatchForegroundEvents([event]);
     }
-    async transitionAutonomousToForeground() {
-        const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
-        if (autonomousRuns.length === 0) {
-            this.transitionTurnStateFromActiveRuns("no autonomous runs to transition");
+    dispatchForegroundEvents(events) {
+        const foregroundTurn = this.activeForegroundTurn;
+        if (!foregroundTurn) {
+            this.dispatchLiveEvents(events);
             return;
         }
-        this.logger.debug({ runIds: autonomousRuns.map((run) => run.id) }, "Transitioning autonomous runs to foreground ownership");
-        this.flushPendingToolCalls();
-        for (const run of autonomousRuns) {
-            this.emitRunEvent(run, {
-                type: "turn_canceled",
-                provider: "claude",
-                reason: "Interrupted by foreground prompt",
-            });
-        }
-        this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
-            this.logger.warn({ err: error }, "Failed to interrupt autonomous run during foreground transition");
-        });
-        await this.awaitPendingInterruptPromise();
-        this.transitionTurnStateFromActiveRuns("autonomous interrupted for foreground");
-    }
-    routeMessage(normalized) {
-        if (normalized.metadataOnly) {
-            if ((normalized.message.type === "user" &&
-                isTaskNotificationUserContent(normalized.message.message?.content)) ||
-                (normalized.message.type === "system" &&
-                    normalized.message.subtype === "task_notification")) {
-                this.reserveAutonomousWake("task_notification");
-            }
-            this.notePreReplayMetadata(normalized.message);
-            return { run: null, reason: "metadata" };
-        }
-        const hasIdentifiers = Boolean(normalized.identifiers.taskId ||
-            normalized.identifiers.parentMessageId ||
-            normalized.identifiers.messageId);
-        const byIdentifiers = this.runTracker.resolveByIdentifiers(normalized.identifiers);
-        if (byIdentifiers.run) {
-            return byIdentifiers;
-        }
-        const foregroundRun = this.activeForegroundTurn
-            ? this.runTracker.getRun(this.activeForegroundTurn.runId)
-            : null;
-        // A previously unseen task_id during foreground ownership is deterministic
-        // evidence of a distinct autonomous wake/run, not foreground response text.
-        if (this.turnState === "foreground" &&
-            foregroundRun &&
-            normalized.identifiers.taskId) {
-            const incomingTaskId = normalized.identifiers.taskId;
-            // Foreground must claim its first task_id; otherwise early foreground
-            // result events can be misrouted to autonomous fallback runs.
-            if (foregroundRun.taskIds.size === 0) {
-                if (foregroundRun.state !== "finalizing") {
-                    return { run: foregroundRun, reason: "foreground" };
-                }
-            }
-            else if (foregroundRun.taskIds.has(incomingTaskId)) {
-                return { run: foregroundRun, reason: "foreground" };
-            }
-            const autonomousRun = this.createRun("autonomous", null);
-            this.emitRunEvent(autonomousRun, { type: "turn_started", provider: "claude" });
-            return { run: autonomousRun, reason: "task_id_new" };
-        }
-        if (this.turnState === "foreground" &&
-            foregroundRun &&
-            this.shouldPreferForegroundRun({
-                run: foregroundRun,
-                message: normalized.message,
-            })) {
-            return { run: foregroundRun, reason: "foreground" };
-        }
-        if (this.pendingAutonomousWakeReservations > 0 &&
-            !normalized.identifiers.taskId &&
-            !normalized.identifiers.parentMessageId &&
-            !normalized.identifiers.messageId) {
-            const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_unbound");
-            return {
-                run: reservedAutonomousRun,
-                reason: "reserved_autonomous",
-            };
-        }
-        if (!hasIdentifiers) {
-            const activeAutonomousRun = this.runTracker.getLatestActiveRun("autonomous");
-            if (activeAutonomousRun) {
-                return { run: activeAutonomousRun, reason: "unbound_autonomous" };
-            }
-            if (!foregroundRun &&
-                (normalized.message.type === "assistant" ||
-                    normalized.message.type === "stream_event" ||
-                    normalized.message.type === "result" ||
-                    normalized.message.type === "tool_progress")) {
-                const autonomousRun = this.claimOrCreateAutonomousRun("unbound_implicit");
-                return { run: autonomousRun, reason: "unbound_autonomous" };
-            }
-        }
-        if (this.pendingAutonomousWakeReservations > 0) {
-            const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_fallback");
-            return { run: reservedAutonomousRun, reason: "reserved_autonomous" };
-        }
-        this.logger.debug({
-            messageType: normalized.message.type,
-            hasIdentifiers,
-            taskId: normalized.identifiers.taskId,
-            parentMessageId: normalized.identifiers.parentMessageId,
-            messageId: normalized.identifiers.messageId,
-            turnState: this.turnState,
-            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
-        }, "Ignoring unmatched Claude SDK message without explicit run start signal");
-        return {
-            run: null,
-            reason: "ignored_unmatched",
-            dispatchWithoutRun: false,
-        };
-    }
-    shouldPreferForegroundRun(input) {
-        const { run, message } = input;
-        if (run.state === "completed" ||
-            run.state === "interrupted" ||
-            run.state === "error") {
-            return false;
+        let terminalSeen = false;
+        for (const event of events) {
+            foregroundTurn.queue.push(event);
+            terminalSeen || (terminalSeen = this.isTerminalTurnEvent(event));
         }
-        // Before prompt replay is observed, prefer foreground by default so the
-        // first turn cannot be stranded in autonomous fallback. If metadata churn
-        // was observed pre-replay, stay conservative and wait for replay.
-        if (!run.promptReplaySeen) {
-            if (this.isToolUseBoundaryStreamEvent(input.message)) {
-                return true;
-            }
-            // Keep pre-replay result events with the foreground run so stale result
-            // bursts cannot consume autonomous wake reservations.
-            if (message.type === "result") {
-                return true;
-            }
-            if (message.type === "assistant" ||
-                message.type === "stream_event" ||
-                message.type === "tool_progress") {
-                return !this.preReplayMetadataSeen;
-            }
-            return true;
+        if (!terminalSeen) {
+            return;
         }
-        if (run.state === "finalizing" &&
-            (message.type === "assistant" || message.type === "stream_event")) {
-            return false;
+        foregroundTurn.queue.end();
+        if (this.activeForegroundTurn === foregroundTurn) {
+            this.activeForegroundTurn = null;
         }
-        return true;
+        this.syncTurnState("foreground turn terminal");
     }
-    isToolUseBoundaryStreamEvent(message) {
-        if (message.type !== "stream_event") {
-            return false;
+    dispatchLiveEvents(events) {
+        let terminalSeen = false;
+        for (const event of events) {
+            this.liveEventQueue.push(event);
+            terminalSeen || (terminalSeen = this.isTerminalTurnEvent(event));
         }
-        const event = message.event;
-        if (!event || event.type !== "message_delta") {
-            return false;
+        if (terminalSeen && this.autonomousTurn) {
+            this.autonomousTurn = null;
+            this.syncTurnState("autonomous turn terminal");
         }
-        const delta = "delta" in event && event.delta && typeof event.delta === "object"
-            ? event.delta
-            : null;
-        return delta?.stop_reason === "tool_use";
     }
-    notePreReplayMetadata(message) {
-        if (this.turnState !== "foreground") {
+    startAutonomousTurn() {
+        if (this.autonomousTurn) {
             return;
         }
-        const foregroundRun = this.activeForegroundTurn
-            ? this.runTracker.getRun(this.activeForegroundTurn.runId)
-            : null;
-        if (!foregroundRun || foregroundRun.promptReplaySeen) {
+        this.autonomousTurn = {
+            id: this.createTurnId("autonomous"),
+        };
+        this.liveEventQueue.push({ type: "turn_started", provider: "claude" });
+        this.syncTurnState("autonomous turn started");
+    }
+    completeAutonomousTurn() {
+        if (!this.autonomousTurn) {
             return;
         }
-        // Most system metadata (init/hook callbacks/etc.) can precede the first prompt
-        // replay for a legitimate foreground run. Treating all of it as churn strands
-        // one-shot helper runs. task_notification is the exception: it represents
-        // background agent activity and should suppress pre-replay foreground routing.
-        if (message.type === "system" &&
-            message.subtype !== "task_notification") {
+        this.autonomousTurn = null;
+        this.liveEventQueue.push({ type: "turn_completed", provider: "claude" });
+        this.syncTurnState("autonomous turn completed");
+    }
+    cancelAutonomousTurn(reason) {
+        if (!this.autonomousTurn) {
             return;
         }
-        this.preReplayMetadataSeen = true;
-    }
-    reserveAutonomousWake(reason) {
-        this.pendingAutonomousWakeReservations += 1;
-        this.logger.debug({
+        this.flushPendingToolCalls();
+        this.autonomousTurn = null;
+        this.liveEventQueue.push({
+            type: "turn_canceled",
+            provider: "claude",
             reason,
-            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
-        }, "Reserved autonomous wake");
+        });
+        this.syncTurnState("autonomous turn canceled");
     }
-    claimOrCreateAutonomousRun(reason) {
-        const existing = this.runTracker.getLatestActiveRun("autonomous");
-        if (existing) {
-            if (this.pendingAutonomousWakeReservations > 0) {
-                this.pendingAutonomousWakeReservations -= 1;
-            }
-            this.logger.debug({
-                reason,
-                runId: existing.id,
-                pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
-            }, "Claimed autonomous wake reservation on existing run");
-            return existing;
+    failActiveTurns(errorMessage) {
+        const failure = this.buildTurnFailedEvent(errorMessage);
+        if (this.activeForegroundTurn) {
+            this.flushPendingToolCalls();
+            this.dispatchForegroundEvents([failure]);
+            return;
         }
-        const run = this.createRun("autonomous", null);
-        this.emitRunEvent(run, { type: "turn_started", provider: "claude" });
-        if (this.pendingAutonomousWakeReservations > 0) {
-            this.pendingAutonomousWakeReservations -= 1;
+        if (this.autonomousTurn) {
+            this.flushPendingToolCalls();
+            this.dispatchLiveEvents([failure]);
         }
-        this.logger.debug({
-            reason,
-            runId: run.id,
-            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
-        }, "Claimed autonomous wake reservation with new run");
-        return run;
     }
     startQueryPump() {
         if (this.closed || this.queryPumpPromise) {
@@ -2211,139 +1834,83 @@ class ClaudeAgentSession {
         });
     }
     async runQueryPump() {
-        while (!this.closed) {
-            if (!this.claudeSessionId && !this.activeForegroundTurn && !this.query) {
-                await this.waitForLiveHistoryPoll();
-                continue;
-            }
-            let q;
-            try {
-                q = await this.ensureQuery();
-            }
-            catch (error) {
-                this.logger.trace({ err: error }, "Failed to initialize Claude query pump");
-                await this.waitForLiveHistoryPoll();
-                continue;
-            }
-            let next;
-            try {
-                next = await q.next();
-                this.logger.trace({ claudeSessionId: this.claudeSessionId, next }, "Claude query pump raw next()");
-            }
-            catch (error) {
-                if (this.query !== q) {
-                    this.logger.trace({ err: error, staleQuery: true }, "Ignoring Claude query pump next() failure from replaced query");
-                    await this.awaitWithTimeout(q.return?.(), "query pump return after stale failure");
-                    continue;
-                }
-                this.logger.trace({ err: error }, "Claude query pump next() failed");
-                for (const run of this.runTracker.listActiveRuns()) {
-                    this.failRun(run, error instanceof Error ? error.message : "Claude stream failed");
-                }
-                this.input?.end();
-                await this.awaitWithTimeout(q.return?.(), "query pump return after failure");
-                if (this.query === q) {
-                    this.query = null;
-                    this.input = null;
-                }
-                await this.waitForLiveHistoryPoll();
-                continue;
-            }
-            if (next.done) {
-                if (this.query !== q) {
-                    this.logger.trace({
-                        claudeSessionId: this.claudeSessionId,
-                        activeRunCount: this.runTracker.listActiveRuns().length,
-                        staleQuery: true,
-                    }, "Ignoring replaced Claude query pump completion");
-                    await this.awaitWithTimeout(q.return?.(), "query pump return on stale done");
-                    continue;
-                }
-                this.logger.trace({
-                    claudeSessionId: this.claudeSessionId,
-                    activeRunCount: this.runTracker.listActiveRuns().length,
-                }, "Claude query pump next() returned done");
-                this.input?.end();
-                await this.awaitWithTimeout(q.return?.(), "query pump return on done");
-                if (this.query === q) {
-                    this.query = null;
-                    this.input = null;
+        let activeQuery;
+        try {
+            activeQuery = await this.ensureQuery();
+        }
+        catch (error) {
+            this.logger.trace({ err: error }, "Failed to initialize Claude query pump");
+            this.failActiveTurns(error instanceof Error ? error.message : "Claude stream failed");
+            return;
+        }
+        let consecutiveInterruptAbortRecoveries = 0;
+        try {
+            while (!this.closed && this.query === activeQuery) {
+                try {
+                    for await (const message of activeQuery) {
+                        consecutiveInterruptAbortRecoveries = 0;
+                        if (await this.handleMissingResumedConversation(message, activeQuery)) {
+                            return;
+                        }
+                        this.routeSdkMessageFromPump(message);
+                    }
+                    if (!this.closed && this.query === activeQuery) {
+                        this.failActiveTurns("Claude stream ended before terminal result");
+                    }
+                    return;
                 }
-                const activeRuns = this.runTracker.listActiveRuns();
-                if (activeRuns.length > 0) {
-                    for (const run of activeRuns) {
-                        this.failRun(run, "Claude stream ended before terminal result");
+                catch (error) {
+                    if (!this.closed &&
+                        this.query === activeQuery &&
+                        this.shouldRecoverInterruptedQueryAbort(error, consecutiveInterruptAbortRecoveries)) {
+                        consecutiveInterruptAbortRecoveries += 1;
+                        this.logger.debug({ recoveries: consecutiveInterruptAbortRecoveries }, "Recovering Claude query pump after interrupt abort");
+                        continue;
                     }
+                    if (!this.closed && this.query === activeQuery) {
+                        this.failActiveTurns(error instanceof Error ? error.message : "Claude stream failed");
+                    }
+                    return;
                 }
-                await this.waitForLiveHistoryPoll();
-                continue;
-            }
-            const sdkMessage = next.value;
-            if (!sdkMessage) {
-                continue;
-            }
-            if (this.query !== q) {
-                this.logger.trace({
-                    claudeSessionId: this.claudeSessionId,
-                    messageType: sdkMessage.type,
-                    staleQuery: true,
-                }, "Ignoring Claude SDK message from replaced query");
-                await this.awaitWithTimeout(q.return?.(), "query pump return on stale message");
-                continue;
-            }
-            if (await this.handleMissingResumedConversation(sdkMessage, q)) {
-                continue;
-            }
-            try {
-                this.routeSdkMessageFromPump(sdkMessage);
             }
-            catch (error) {
-                this.logger.trace({ err: error }, "Failed to route Claude SDK message from query pump");
+        }
+        finally {
+            if (this.query === activeQuery) {
+                this.query = null;
+                this.input = null;
             }
         }
     }
     routeSdkMessageFromPump(message) {
-        if (this.shouldSuppressLocalReplayActivity(message)) {
+        const routeToForeground = Boolean(this.activeForegroundTurn);
+        const assistantishMessage = message.type === "assistant" ||
+            message.type === "stream_event" ||
+            message.type === "tool_progress";
+        if (!routeToForeground && assistantishMessage) {
+            this.startAutonomousTurn();
+        }
+        if (!routeToForeground && !this.autonomousTurn && message.type === "result") {
             return;
         }
+        const turnId = this.activeForegroundTurn?.id ?? this.autonomousTurn?.id ?? null;
         const identifiers = readEventIdentifiers(message);
-        const metadataOnly = isMetadataOnlySdkMessage(message);
-        const route = this.routeMessage({
-            message,
-            identifiers,
-            metadataOnly,
-        });
-        const suppressTerminalEvents = this.shouldSuppressReplayResultTerminal({
-            run: route.run,
-            message,
-        });
         this.logger.trace({
             claudeSessionId: this.claudeSessionId,
             messageType: message.type,
-            routeReason: route.reason,
-            runId: route.run?.id ?? null,
-            runOwner: route.run?.owner ?? null,
-            suppressTerminalEvents,
-            metadataOnly,
+            routedTo: routeToForeground ? "foreground_queue" : "live_queue",
+            turnId,
         }, "Claude query pump routed SDK message");
-        if (route.run) {
-            this.transitionTurnStateFromActiveRuns(`routed via ${route.reason}`);
-            this.runTracker.bindIdentifiers(route.run, identifiers);
-            if (!suppressTerminalEvents) {
-                this.updateRunLifecycleForMessage(route.run, message, identifiers);
-            }
-        }
         const messageEvents = this.translateMessageToEvents(message, {
             suppressAssistantText: true,
             suppressReasoning: true,
-            suppressTerminalEvents,
         });
-        const assistantTimelineItems = this.timelineAssembler.consume({
+        const assistantTimelineEvents = this.timelineAssembler
+            .consume({
             message,
-            runId: route.run?.id ?? null,
+            runId: turnId,
             messageIdHint: identifiers.messageId,
-        });
-        const assistantTimelineEvents = assistantTimelineItems.map((item) => ({
+        })
+            .map((item) => ({
             type: "timeline",
             item,
             provider: "claude",
@@ -2352,16 +1919,26 @@ class ClaudeAgentSession {
         if (events.length === 0) {
             return;
         }
-        if (!route.run) {
-            if (route.dispatchWithoutRun === false) {
-                return;
-            }
-            this.dispatchMetadataEvents(events);
+        if (this.pendingInterruptAbort &&
+            message.type === "result" &&
+            events.some((event) => event.type === "turn_completed" || event.type === "turn_failed") &&
+            (!this.activeForegroundTurn || !this.activeForegroundTurn.hasVisibleActivity)) {
+            this.pendingInterruptAbort = false;
+            this.logger.debug("Suppressing stale Claude interrupt terminal result");
             return;
         }
-        for (const event of events) {
-            this.emitRunEvent(route.run, event);
+        if (this.activeForegroundTurn &&
+            events.some((event) => event.type === "timeline" ||
+                event.type === "permission_requested" ||
+                event.type === "permission_resolved")) {
+            this.activeForegroundTurn.hasVisibleActivity = true;
+            this.pendingInterruptAbort = false;
+        }
+        if (routeToForeground) {
+            this.dispatchForegroundEvents(events);
+            return;
         }
+        this.dispatchLiveEvents(events);
     }
     async handleMissingResumedConversation(message, query) {
         const staleResumeError = this.readMissingResumedConversationError(message);
@@ -2372,10 +1949,7 @@ class ClaudeAgentSession {
             claudeSessionId: this.claudeSessionId,
             error: staleResumeError,
         }, "Claude resumed session no longer exists; invalidating persisted session");
-        for (const run of this.runTracker.listActiveRuns()) {
-            this.failRun(run, staleResumeError);
-        }
-        this.transitionTurnStateFromActiveRuns("missing resumed conversation");
+        this.failActiveTurns(staleResumeError);
         this.input?.end();
         await this.awaitWithTimeout(query.return?.(), "query pump return on missing resumed conversation");
         if (this.query === query) {
@@ -2386,373 +1960,36 @@ class ClaudeAgentSession {
         this.persistence = null;
         this.persistedHistory = [];
         this.historyPending = false;
+        this.historyOffsetSessionId = null;
+        this.historyReadOffsetBytes = 0;
+        this.historyLineFragment = "";
         this.cachedRuntimeInfo = null;
         this.queryRestartNeeded = false;
+        this.autonomousTurn = null;
+        this.activeForegroundTurn = null;
+        this.syncTurnState("missing resumed conversation");
         return true;
     }
-    shouldSuppressReplayResultTerminal(input) {
-        const { run, message } = input;
-        if (!run || run.owner !== "foreground" || message.type !== "result") {
-            return false;
-        }
-        if (run.promptReplaySeen) {
-            return false;
-        }
-        if (run.state === "streaming" || run.state === "finalizing") {
-            return false;
-        }
-        const resultSubtype = "subtype" in message && typeof message.subtype === "string"
-            ? message.subtype
-            : null;
-        // Pre-replay success results are stale in practice (leftover from an
-        // earlier query segment) and must not end the current foreground run.
-        if (resultSubtype === "success") {
-            this.logger.trace({
-                runId: run.id,
-                runOwner: run.owner,
-                runState: run.state,
-                promptReplaySeen: run.promptReplaySeen,
-                resultSubtype,
-            }, "Suppressing pre-replay foreground success result terminal event");
-            return true;
-        }
-        // For non-success results, keep the metadata-churn guard to avoid
-        // suppressing legitimate hard failures.
-        return this.preReplayMetadataSeen;
-    }
-    dispatchMetadataEvents(events) {
-        for (const event of events) {
-            this.pushEvent(event);
-        }
-    }
-    updateRunLifecycleForMessage(run, message, identifiers) {
-        const previousState = run.state;
-        if (message.type === "user" &&
-            identifiers.messageId &&
-            run.messageIds.has(identifiers.messageId)) {
-            run.promptReplaySeen = true;
-            this.preReplayMetadataSeen = false;
-        }
-        if (run.state === "queued") {
-            this.runTracker.transition(run, "awaiting_response");
-        }
-        if (message.type === "assistant" ||
-            message.type === "stream_event" ||
-            message.type === "tool_progress") {
-            this.runTracker.transition(run, "streaming");
-            return;
-        }
-        if (message.type === "result") {
-            this.runTracker.transition(run, "finalizing");
-        }
-        else {
-            return;
-        }
-        if (run.state !== previousState) {
-            this.logger.trace({
-                runId: run.id,
-                owner: run.owner,
-                messageType: message.type,
-                previousState,
-                nextState: run.state,
-                taskId: identifiers.taskId,
-                parentMessageId: identifiers.parentMessageId,
-                messageId: identifiers.messageId,
-            }, "Updated Claude run lifecycle from SDK message");
-        }
-    }
-    shouldSuppressLocalReplayActivity(message) {
-        const localReplay = this.isLocalReplayUserMessage(message);
-        if (!this.activeForegroundTurn && localReplay) {
-            this.suppressLocalReplayActivity = true;
-            this.logger.debug({ uuid: message.uuid }, "Suppressing local replay user message from live pump");
-            return true;
-        }
-        if (!this.suppressLocalReplayActivity) {
-            return false;
-        }
-        // Suppress only replay scaffolding. Do not suppress autonomous
-        // assistant/result events; otherwise task-notification replies can be dropped.
-        if (localReplay) {
-            return true;
-        }
-        if (message.type === "system") {
-            return true;
-        }
-        const identifiers = readEventIdentifiers(message);
-        const hasIdentifiers = Boolean(identifiers.taskId || identifiers.parentMessageId || identifiers.messageId);
-        if (message.type !== "user" && !hasIdentifiers) {
-            if (this.pendingAutonomousWakeReservations > 0) {
-                this.suppressLocalReplayActivity = false;
-                return false;
-            }
-            return true;
-        }
-        if (message.type === "user") {
-            this.suppressLocalReplayActivity = false;
-            return false;
-        }
-        this.suppressLocalReplayActivity = false;
-        return false;
-    }
-    isLocalReplayUserMessage(message) {
-        if (message.type !== "user") {
-            return false;
-        }
-        const uuid = readTrimmedString(message.uuid);
-        if (!uuid) {
-            return false;
-        }
-        return this.localUserMessageIds.has(uuid);
-    }
     async interruptActiveTurn() {
         const queryToInterrupt = this.query;
         if (!queryToInterrupt || typeof queryToInterrupt.interrupt !== "function") {
             this.logger.trace("interruptActiveTurn: no query to interrupt");
             return;
         }
+        this.pendingInterruptAbort = true;
         try {
-            this.logger.trace("interruptActiveTurn: calling query.interrupt()...");
             await this.awaitWithTimeout(queryToInterrupt.interrupt(), "interruptActiveTurn query.interrupt()");
-            this.input?.end();
-            this.logger.trace("interruptActiveTurn: calling query.return()...");
-            await this.awaitWithTimeout(queryToInterrupt.return?.(), "interruptActiveTurn query.return()");
-            this.query = null;
-            this.input = null;
-            this.queryRestartNeeded = false;
         }
         catch (error) {
             this.logger.warn({ err: error }, "Failed to interrupt active turn");
-            this.input?.end();
-            if (this.query === queryToInterrupt) {
-                this.query = null;
-                this.input = null;
-            }
-            // Try to force-close the iterator to unblock the pump's q.next() call.
-            this.awaitWithTimeout(queryToInterrupt.return?.(), "interruptActiveTurn force return after failure").catch(() => { });
-            // Disown the current pump and start a fresh one immediately so
-            // autonomous wakes are not lost while waiting for the next user turn.
-            this.queryPumpPromise = null;
-            this.startQueryPump();
-        }
-    }
-    handleSidechainMessage(message, parentToolUseId) {
-        const state = this.activeSidechains.get(parentToolUseId) ??
-            {
-                actions: [],
-                actionKeys: [],
-                nextActionIndex: 1,
-                actionIndexByKey: new Map(),
-            };
-        this.activeSidechains.set(parentToolUseId, state);
-        const contextUpdated = this.updateSubAgentContextFromTaskInput(state, parentToolUseId);
-        const actionCandidates = this.extractSubAgentActionCandidates(message);
-        let actionUpdated = false;
-        for (const action of actionCandidates) {
-            if (this.appendSubAgentAction(state, action)) {
-                actionUpdated = true;
-            }
-        }
-        if (!contextUpdated && !actionUpdated) {
-            return [];
-        }
-        const toolCall = mapClaudeRunningToolCall({
-            name: "Task",
-            callId: parentToolUseId,
-            input: null,
-            output: null,
-        });
-        if (!toolCall) {
-            return [];
-        }
-        const detail = {
-            type: "sub_agent",
-            ...(state.subAgentType ? { subAgentType: state.subAgentType } : {}),
-            ...(state.description ? { description: state.description } : {}),
-            log: state.actions
-                .map((action) => action.summary
-                ? `[${action.toolName}] ${action.summary}`
-                : `[${action.toolName}]`)
-                .join("\n"),
-            actions: state.actions.map((action) => ({
-                index: action.index,
-                toolName: action.toolName,
-                ...(action.summary ? { summary: action.summary } : {}),
-            })),
-        };
-        return [
-            {
-                type: "timeline",
-                item: {
-                    ...toolCall,
-                    detail,
-                },
-                provider: "claude",
-            },
-        ];
-    }
-    updateSubAgentContextFromTaskInput(state, parentToolUseId) {
-        const taskInput = this.toolUseCache.get(parentToolUseId)?.input;
-        const nextSubAgentType = this.normalizeSubAgentText(taskInput?.subagent_type);
-        const nextDescription = this.normalizeSubAgentText(taskInput?.description);
-        let changed = false;
-        if (nextSubAgentType && nextSubAgentType !== state.subAgentType) {
-            state.subAgentType = nextSubAgentType;
-            changed = true;
-        }
-        if (nextDescription && nextDescription !== state.description) {
-            state.description = nextDescription;
-            changed = true;
-        }
-        return changed;
-    }
-    normalizeSubAgentText(value) {
-        const normalized = readTrimmedString(value)?.replace(/\s+/g, " ");
-        if (!normalized) {
-            return undefined;
-        }
-        if (normalized.length <= MAX_SUB_AGENT_SUMMARY_CHARS) {
-            return normalized;
-        }
-        return `${normalized.slice(0, MAX_SUB_AGENT_SUMMARY_CHARS)}...`;
-    }
-    extractSubAgentActionCandidates(message) {
-        if (message.type === "assistant") {
-            const content = message.message?.content;
-            if (!Array.isArray(content)) {
-                return [];
-            }
-            const actions = [];
-            for (const block of content) {
-                if (!isClaudeContentChunk(block) ||
-                    !(block.type === "tool_use" ||
-                        block.type === "mcp_tool_use" ||
-                        block.type === "server_tool_use") ||
-                    typeof block.name !== "string") {
-                    continue;
-                }
-                const key = readTrimmedString(block.id) ??
-                    `assistant:${block.name}:${actions.length}`;
-                actions.push({
-                    key,
-                    toolName: block.name,
-                    input: block.input ?? null,
-                });
-            }
-            return actions;
-        }
-        if (message.type === "stream_event") {
-            const event = message.event;
-            if (event.type !== "content_block_start") {
-                return [];
-            }
-            const block = isClaudeContentChunk(event.content_block)
-                ? event.content_block
-                : null;
-            if (!block ||
-                !(block.type === "tool_use" ||
-                    block.type === "mcp_tool_use" ||
-                    block.type === "server_tool_use") ||
-                typeof block.name !== "string") {
-                return [];
-            }
-            const key = readTrimmedString(block.id) ??
-                `stream:${block.name}:${typeof event.index === "number" ? event.index : 0}`;
-            return [
-                {
-                    key,
-                    toolName: block.name,
-                    input: block.input ?? null,
-                },
-            ];
-        }
-        if (message.type === "tool_progress") {
-            const toolName = readTrimmedString(message.tool_name);
-            if (!toolName) {
-                return [];
-            }
-            const key = readTrimmedString(message.tool_use_id) ?? `progress:${toolName}`;
-            return [{ key, toolName, input: null }];
-        }
-        return [];
-    }
-    appendSubAgentAction(state, candidate) {
-        const normalizedToolName = readTrimmedString(candidate.toolName);
-        if (!normalizedToolName) {
-            return false;
-        }
-        const summary = this.deriveSubAgentActionSummary(normalizedToolName, candidate.input);
-        const existingIndex = state.actionIndexByKey.get(candidate.key);
-        if (existingIndex !== undefined) {
-            const existing = state.actions[existingIndex];
-            if (!existing) {
-                return false;
-            }
-            const nextSummary = existing.summary ?? summary;
-            const unchanged = existing.toolName === normalizedToolName &&
-                existing.summary === nextSummary;
-            if (unchanged) {
-                return false;
-            }
-            state.actions[existingIndex] = {
-                ...existing,
-                toolName: normalizedToolName,
-                ...(nextSummary ? { summary: nextSummary } : {}),
-            };
-            return true;
-        }
-        const nextEntry = {
-            index: state.nextActionIndex,
-            toolName: normalizedToolName,
-            ...(summary ? { summary } : {}),
-        };
-        state.nextActionIndex += 1;
-        state.actions.push(nextEntry);
-        state.actionKeys.push(candidate.key);
-        this.trimSubAgentTail(state);
-        this.rebuildSubAgentActionIndex(state);
-        return true;
-    }
-    trimSubAgentTail(state) {
-        while (state.actions.length > MAX_SUB_AGENT_LOG_ENTRIES) {
-            state.actions.shift();
-            state.actionKeys.shift();
         }
     }
-    rebuildSubAgentActionIndex(state) {
-        state.actionIndexByKey.clear();
-        for (let index = 0; index < state.actionKeys.length; index += 1) {
-            const key = state.actionKeys[index];
-            if (key) {
-                state.actionIndexByKey.set(key, index);
-            }
-        }
-    }
-    deriveSubAgentActionSummary(toolName, input) {
-        const runningToolCall = mapClaudeRunningToolCall({
-            name: toolName,
-            callId: `sub-agent-summary-${toolName}`,
-            input,
-            output: null,
-        });
-        if (!runningToolCall) {
-            return undefined;
-        }
-        const display = buildToolCallDisplayModel({
-            name: runningToolCall.name,
-            status: runningToolCall.status,
-            error: runningToolCall.error,
-            detail: runningToolCall.detail,
-            metadata: runningToolCall.metadata,
-        });
-        return this.normalizeSubAgentText(display.summary);
-    }
     translateMessageToEvents(message, options) {
         const parentToolUseId = "parent_tool_use_id" in message
             ? message.parent_tool_use_id
             : null;
         if (parentToolUseId) {
-            return this.handleSidechainMessage(message, parentToolUseId);
+            return this.sidechainTracker.handleMessage(message, parentToolUseId);
         }
         const events = [];
         const fallbackThreadSessionId = this.captureSessionIdFromMessage(message);
@@ -2818,9 +2055,7 @@ class ClaudeAgentSession {
                     this.compacting = false;
                     break;
                 }
-                const messageId = typeof message.uuid === "string" && message.uuid.length > 0
-                    ? message.uuid
-                    : undefined;
+                const messageId = typeof message.uuid === "string" && message.uuid.length > 0 ? message.uuid : undefined;
                 this.rememberUserMessageId(messageId);
                 const content = message.message?.content;
                 const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
@@ -2836,19 +2071,22 @@ class ClaudeAgentSession {
                     break;
                 }
                 if (typeof content === "string" && content.length > 0) {
-                    // String content from user messages (e.g., local command output)
-                    events.push({
-                        type: "timeline",
-                        item: {
-                            type: "user_message",
-                            text: content,
-                            ...(messageId ? { messageId } : {}),
-                        },
-                        provider: "claude",
-                    });
+                    if (!isClaudeTranscriptNoiseText(content)) {
+                        events.push({
+                            type: "timeline",
+                            item: {
+                                type: "user_message",
+                                text: content,
+                                ...(messageId ? { messageId } : {}),
+                            },
+                            provider: "claude",
+                        });
+                    }
                 }
                 else if (Array.isArray(content)) {
-                    const timelineItems = this.mapBlocksToTimeline(content);
+                    const timelineItems = this.mapBlocksToTimeline(content, {
+                        textMessageType: "user_message",
+                    });
                     for (const item of timelineItems) {
                         if (item.type === "user_message" && messageId && !item.messageId) {
                             events.push({
@@ -2884,9 +2122,6 @@ class ClaudeAgentSession {
                 break;
             }
             case "result": {
-                if (options?.suppressTerminalEvents) {
-                    break;
-                }
                 const usage = this.convertUsage(message);
                 if (message.subtype === "success") {
                     events.push({ type: "turn_completed", provider: "claude", usage });
@@ -2948,18 +2183,14 @@ class ClaudeAgentSession {
         const existingSessionId = this.claudeSessionId;
         let threadStartedSessionId = null;
         if (existingSessionId === null) {
-            // First time setting session ID (empty → filled) - this is expected
             this.claudeSessionId = newSessionId;
             threadStartedSessionId = newSessionId;
             this.logger.debug({ sessionId: newSessionId }, "Claude session ID set for the first time");
         }
         else if (existingSessionId === newSessionId) {
-            // Same session ID - no-op, but log for visibility
             this.logger.debug({ sessionId: newSessionId }, "Claude session ID unchanged (same value)");
         }
         else {
-            // CRITICAL: Session ID is being overwritten with a different value
-            // This should NEVER happen and indicates a serious bug
             throw new Error(`CRITICAL: Claude session ID overwrite detected! ` +
                 `Existing: ${existingSessionId}, New: ${newSessionId}. ` +
                 `This indicates a session identity corruption bug.`);
@@ -2967,7 +2198,6 @@ class ClaudeAgentSession {
         this.availableModes = DEFAULT_MODES;
         this.currentMode = message.permissionMode;
         this.persistence = null;
-        // Capture actual model from SDK init message (not just the configured model)
         if (message.model) {
             const normalizedModel = normalizeClaudeRuntimeModelId({
                 runtimeModelId: message.model,
@@ -2978,7 +2208,6 @@ class ClaudeAgentSession {
             });
             this.logger.debug({ model: message.model, normalizedModel }, "Captured model from SDK init");
             this.lastOptionsModel = normalizedModel;
-            // Invalidate cached runtime info so it picks up the new model
             this.cachedRuntimeInfo = null;
         }
         return threadStartedSessionId;
@@ -3031,7 +2260,7 @@ class ClaudeAgentSession {
             }
         }
         this.toolUseCache.clear();
-        this.activeSidechains.clear();
+        this.sidechainTracker.clear();
     }
     pushToolCall(item, target) {
         if (!item) {
@@ -3046,15 +2275,8 @@ class ClaudeAgentSession {
     pushEvent(event) {
         const foregroundTurn = this.activeForegroundTurn;
         if (foregroundTurn) {
-            const run = this.runTracker.getRun(foregroundTurn.runId);
-            if (run &&
-                run.owner === "foreground" &&
-                run.queue === foregroundTurn.queue &&
-                this.runTracker.isRunActive(run)) {
-                foregroundTurn.queue.push(event);
-                return;
-            }
-            this.activeForegroundTurn = null;
+            foregroundTurn.queue.push(event);
+            return;
         }
         this.liveEventQueue.push(event);
     }
@@ -3072,47 +2294,125 @@ class ClaudeAgentSession {
             this.pendingPermissions.delete(id);
         }
     }
-    waitForLiveHistoryPoll() {
-        return new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    loadPersistedHistory(sessionId) {
+    loadPersistedHistory(sessionId, options) {
         try {
             const historyPath = this.resolveHistoryPath(sessionId);
             if (!historyPath || !fs.existsSync(historyPath)) {
                 return;
             }
-            const content = fs.readFileSync(historyPath, "utf8");
-            const timeline = [];
-            for (const line of content.split(/\n+/)) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    const entry = JSON.parse(trimmed);
-                    if (entry.isSidechain) {
-                        continue;
-                    }
-                    if (entry.type === "user" && typeof entry.uuid === "string") {
-                        this.rememberUserMessageId(entry.uuid);
-                    }
-                    const items = this.convertHistoryEntry(entry);
-                    if (items.length > 0) {
-                        timeline.push(...items);
-                    }
-                }
-                catch (error) {
-                    // ignore malformed history line
-                }
+            if (this.historyOffsetSessionId !== sessionId) {
+                this.historyOffsetSessionId = sessionId;
+                this.historyReadOffsetBytes = 0;
+                this.historyLineFragment = "";
             }
-            if (timeline.length > 0) {
-                this.persistedHistory = timeline;
-                this.historyPending = true;
+            const content = fs.readFileSync(historyPath);
+            if (content.byteLength < this.historyReadOffsetBytes) {
+                this.historyReadOffsetBytes = 0;
+                this.historyLineFragment = "";
             }
+            if (content.byteLength === this.historyReadOffsetBytes) {
+                return;
+            }
+            const unreadChunk = content.subarray(this.historyReadOffsetBytes).toString("utf8");
+            this.historyReadOffsetBytes = content.byteLength;
+            this.ingestPersistedHistoryChunk(unreadChunk, {
+                dispatchLive: options?.dispatchLive ?? false,
+            });
         }
         catch (error) {
             // ignore history load failures
         }
     }
+    ingestPersistedHistoryChunk(chunk, options) {
+        if (!chunk) {
+            return;
+        }
+        const combined = `${this.historyLineFragment}${chunk}`;
+        this.historyLineFragment = "";
+        const lines = combined.split(/\r?\n/);
+        const trailing = lines.pop() ?? "";
+        const timeline = [];
+        for (const line of lines) {
+            this.ingestPersistedHistoryLine(line, {
+                dispatchLive: options.dispatchLive,
+                timeline,
+            });
+        }
+        if (trailing.trim().length > 0) {
+            const handled = this.ingestPersistedHistoryLine(trailing, {
+                dispatchLive: options.dispatchLive,
+                timeline,
+            });
+            if (!handled) {
+                this.historyLineFragment = trailing;
+            }
+        }
+        if (!options.dispatchLive && timeline.length > 0) {
+            this.persistedHistory = [...this.persistedHistory, ...timeline];
+            this.historyPending = true;
+        }
+    }
+    ingestPersistedHistoryLine(line, options) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return true;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            return false;
+        }
+        if (entry.isSidechain) {
+            return true;
+        }
+        if (entry.type === "user" && typeof entry.uuid === "string") {
+            this.rememberUserMessageId(entry.uuid);
+        }
+        if (options.dispatchLive) {
+            this.dispatchPersistedHistoryEntry(entry);
+            return true;
+        }
+        const items = this.convertHistoryEntry(entry);
+        if (items.length > 0) {
+            options.timeline.push(...items);
+        }
+        return true;
+    }
+    dispatchPersistedHistoryEntry(entry) {
+        const liveMessage = this.normalizePersistedHistoryEntryToLiveMessage(entry);
+        if (liveMessage) {
+            this.routeSdkMessageFromPump(liveMessage);
+            return;
+        }
+        const items = this.convertHistoryEntry(entry);
+        for (const item of items) {
+            this.pushEvent({
+                type: "timeline",
+                item,
+                provider: "claude",
+            });
+        }
+    }
+    normalizePersistedHistoryEntryToLiveMessage(entry) {
+        const taskNotificationMessage = coerceTaskNotificationHistoryRecordToSystemMessage(entry);
+        if (taskNotificationMessage) {
+            return taskNotificationMessage;
+        }
+        const type = readTrimmedString(entry.type);
+        switch (type) {
+            case "assistant":
+            case "result":
+            case "stream_event":
+            case "system":
+            case "tool_progress":
+            case "user":
+                return entry;
+            default:
+                return null;
+        }
+    }
     resolveHistoryPath(sessionId) {
         const cwd = this.config.cwd;
         if (!cwd)
@@ -3126,25 +2426,50 @@ class ClaudeAgentSession {
     convertHistoryEntry(entry) {
         return convertClaudeHistoryEntry(entry, (content) => this.mapBlocksToTimeline(content));
     }
+    // Maps Claude content blocks into AgentTimelineItems.
+    //
+    // textMessageType controls what type text blocks emit:
+    //   - "assistant_message" (default): one item per text block (streaming granularity)
+    //   - "user_message": coalesces all text blocks into a single user_message
+    //     (matches extractUserMessageText semantics: trim each block, join with "\n\n")
+    //
+    // suppressAssistantText only applies when textMessageType is "assistant_message" — user text
+    // must never be suppressed since the TimelineAssembler only handles assistant text.
+    //
+    // NOTE: convertClaudeHistoryEntry uses extractUserMessageText directly instead of this function
+    // for user entries. Both paths must produce equivalent user_message items.
     mapBlocksToTimeline(content, options) {
-        const suppressAssistant = options?.suppressAssistantText ?? false;
+        const textMessageType = options?.textMessageType ?? "assistant_message";
+        const suppressText = textMessageType === "assistant_message" && (options?.suppressAssistantText ?? false);
         const suppressReasoning = options?.suppressReasoning ?? false;
         if (typeof content === "string") {
-            if (!content || content === INTERRUPT_TOOL_USE_PLACEHOLDER) {
+            if (!content ||
+                content === INTERRUPT_TOOL_USE_PLACEHOLDER ||
+                isClaudeTranscriptNoiseText(content)) {
                 return [];
             }
-            if (suppressAssistant) {
+            if (suppressText) {
                 return [];
             }
-            return [{ type: "assistant_message", text: content }];
+            return [{ type: textMessageType, text: content }];
         }
         const items = [];
+        // User SDK entries can arrive as multiple text blocks, but Paseo treats them as one message.
+        const userTextParts = [];
         for (const block of content) {
             switch (block.type) {
                 case "text":
                 case "text_delta":
-                    if (block.text && block.text !== INTERRUPT_TOOL_USE_PLACEHOLDER) {
-                        if (!suppressAssistant) {
+                    if (block.text &&
+                        block.text !== INTERRUPT_TOOL_USE_PLACEHOLDER &&
+                        !isClaudeTranscriptNoiseText(block.text)) {
+                        if (textMessageType === "user_message") {
+                            const trimmed = block.text.trim();
+                            if (trimmed) {
+                                userTextParts.push(trimmed);
+                            }
+                        }
+                        else if (!suppressText) {
                             items.push({ type: "assistant_message", text: block.text });
                         }
                     }
@@ -3177,6 +2502,12 @@ class ClaudeAgentSession {
                     break;
             }
         }
+        if (textMessageType === "user_message" && userTextParts.length > 0) {
+            items.unshift({
+                type: "user_message",
+                text: userTextParts.join("\n\n"),
+            });
+        }
         return items;
     }
     handleToolUseStart(block, items) {
@@ -3201,7 +2532,7 @@ class ClaudeAgentSession {
         const toolName = entry?.name ?? block.tool_name ?? "tool";
         const callId = typeof block.tool_use_id === "string" && block.tool_use_id.length > 0
             ? block.tool_use_id
-            : entry?.id ?? null;
+            : (entry?.id ?? null);
         // Extract output from block.content (SDK always returns content in string form)
         const output = this.buildToolOutput(block, entry);
         if (block.is_error) {
@@ -3223,7 +2554,7 @@ class ClaudeAgentSession {
         }
         if (typeof block.tool_use_id === "string") {
             this.toolUseCache.delete(block.tool_use_id);
-            this.activeSidechains.delete(block.tool_use_id);
+            this.sidechainTracker.delete(block.tool_use_id);
         }
     }
     buildToolOutput(block, entry) {
@@ -3296,12 +2627,24 @@ class ClaudeAgentSession {
             normalizedTool === "apply_diff") {
             if (input && typeof input.file_path === "string") {
                 // Support both old_str/new_str and old_string/new_string parameter names
-                const oldContent = typeof input.old_str === "string" ? input.old_str : typeof input.old_string === "string" ? input.old_string : undefined;
-                const newContent = typeof input.new_str === "string" ? input.new_str : typeof input.new_string === "string" ? input.new_string : undefined;
+                const oldContent = typeof input.old_str === "string"
+                    ? input.old_str
+                    : typeof input.old_string === "string"
+                        ? input.old_string
+                        : undefined;
+                const newContent = typeof input.new_str === "string"
+                    ? input.new_str
+                    : typeof input.new_string === "string"
+                        ? input.new_string
+                        : undefined;
                 return {
                     type: "file_edit",
                     filePath: input.file_path,
-                    diff: typeof input.patch === "string" ? input.patch : typeof input.diff === "string" ? input.diff : undefined,
+                    diff: typeof input.patch === "string"
+                        ? input.patch
+                        : typeof input.diff === "string"
+                            ? input.diff
+                            : undefined,
                     oldContent,
                     newContent,
                 };
@@ -3324,7 +2667,9 @@ class ClaudeAgentSession {
     mapPartialEvent(event, options) {
         if (event.type === "content_block_start") {
             const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
-            if (block?.type === "tool_use" && typeof event.index === "number" && typeof block.id === "string") {
+            if (block?.type === "tool_use" &&
+                typeof event.index === "number" &&
+                typeof block.id === "string") {
                 this.toolUseIndexToId.set(event.index, block.id);
                 this.toolUseInputBuffers.delete(block.id);
             }
@@ -3389,7 +2734,9 @@ class ClaudeAgentSession {
         else if (!existing.server) {
             existing.server = existing.name;
         }
-        if (block.type === "tool_use" || block.type === "mcp_tool_use" || block.type === "server_tool_use") {
+        if (block.type === "tool_use" ||
+            block.type === "mcp_tool_use" ||
+            block.type === "server_tool_use") {
             const input = this.normalizeToolInput(block.input);
             if (input) {
                 this.applyToolInput(existing, input);
@@ -3465,7 +2812,10 @@ class ClaudeAgentSession {
     }
     isCommandTool(name, input) {
         const normalized = name.toLowerCase();
-        if (normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+        if (normalized.includes("bash") ||
+            normalized.includes("shell") ||
+            normalized.includes("terminal") ||
+            normalized.includes("command")) {
             return true;
         }
         if (typeof input.command === "string" || Array.isArray(input.command)) {
@@ -3509,7 +2859,10 @@ class ClaudeAgentSession {
             const files = [];
             for (const value of input.files) {
                 if (typeof value === "string" && value.length > 0) {
-                    files.push({ path: this.relativizePath(value) ?? value, kind: this.detectFileKind(value) });
+                    files.push({
+                        path: this.relativizePath(value) ?? value,
+                        kind: this.detectFileKind(value),
+                    });
                 }
             }
             if (files.length > 0) {
@@ -3572,11 +2925,7 @@ function hasToolLikeBlock(block) {
     return type.includes("tool");
 }
 function readCompactionMetadata(source) {
-    const candidates = [
-        source.compact_metadata,
-        source.compactMetadata,
-        source.compactionMetadata,
-    ];
+    const candidates = [source.compact_metadata, source.compactMetadata, source.compactionMetadata];
     for (const candidate of candidates) {
         if (!candidate || typeof candidate !== "object") {
             continue;
@@ -3602,18 +2951,18 @@ function normalizeHistoryBlocks(content) {
 export function convertClaudeHistoryEntry(entry, mapBlocks) {
     if (entry.type === "system" && entry.subtype === "compact_boundary") {
         const compactMetadata = readCompactionMetadata(entry);
-        return [{
+        return [
+            {
                 type: "compaction",
                 status: "completed",
                 trigger: compactMetadata?.trigger === "manual" ? "manual" : "auto",
                 preTokens: compactMetadata?.preTokens,
-            }];
+            },
+        ];
     }
-    if (entry.type === "system") {
-        const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(entry);
-        if (taskNotificationItem) {
-            return [taskNotificationItem];
-        }
+    const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(entry);
+    if (taskNotificationItem) {
+        return [taskNotificationItem];
     }
     if (entry.isCompactSummary) {
         return [];
@@ -3626,10 +2975,12 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
         return [];
     }
     const content = message.content;
+    if ((entry.type === "user" || entry.type === "assistant") &&
+        isClaudeTranscriptNoiseContent(content)) {
+        return [];
+    }
     const normalizedBlocks = normalizeHistoryBlocks(content);
-    const contentValue = typeof content === "string"
-        ? content
-        : normalizedBlocks;
+    const contentValue = typeof content === "string" ? content : normalizedBlocks;
     const hasToolBlock = normalizedBlocks?.some((block) => hasToolLikeBlock(block)) ?? false;
     const userMessageId = entry.type === "user" && typeof entry.uuid === "string" && entry.uuid.length > 0
         ? entry.uuid
@@ -3762,9 +3113,7 @@ async function collectRecentClaudeSessions(root, limit) {
             }
         }
     }
-    return candidates
-        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-        .slice(0, limit);
+    return candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(0, limit);
 }
 async function parseClaudeSessionDescriptor(filePath, mtime) {
     let content;
@@ -3847,15 +3196,20 @@ function extractClaudeUserText(message) {
         return null;
     }
     if (typeof message.content === "string") {
-        return message.content.trim();
+        const normalized = message.content.trim();
+        return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
     }
     if (typeof message.text === "string") {
-        return message.text.trim();
+        const normalized = message.text.trim();
+        return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
     }
     if (Array.isArray(message.content)) {
         for (const block of message.content) {
             if (block && typeof block.text === "string") {
-                return block.text.trim();
+                const normalized = block.text.trim();
+                if (normalized && !isClaudeTranscriptNoiseText(normalized)) {
+                    return normalized;
+                }
             }
         }
     }