@getpaseo/server 0.1.62 → 0.1.65

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

@@ -10,8 +10,9 @@ import { getClaudeModels, normalizeClaudeRuntimeModelId } from "./claude/claude-
 import { parsePartialJsonObject } from "./claude/partial-json.js";
 import { ClaudeSidechainTracker } from "./claude/sidechain-tracker.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
-import { applyProviderEnv } from "../provider-launch-config.js";
+import { createProviderEnv, createProviderEnvSpec, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { execCommand, spawnProcess } from "../../../utils/spawn.js";
@@ -59,6 +60,38 @@ const INTERRUPT_TOOL_USE_PLACEHOLDER = "[Request interrupted by user for tool us
 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 resolvePathEnvKey() {
+    if (process.env["Path"] !== undefined)
+        return "Path";
+    if (process.env["PATH"] !== undefined)
+        return "PATH";
+    return null;
+}
+function errorToMessageString(error) {
+    if (typeof error === "string")
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    return "";
+}
+function firstStringField(input, primaryKey, secondaryKey) {
+    const primary = input[primaryKey];
+    if (typeof primary === "string")
+        return primary;
+    const secondary = input[secondaryKey];
+    if (typeof secondary === "string")
+        return secondary;
+    return undefined;
+}
+function extractSessionIdRaw(msg) {
+    if (typeof msg.session_id === "string")
+        return msg.session_id;
+    if (typeof msg.sessionId === "string")
+        return msg.sessionId;
+    if (typeof msg.session?.id === "string")
+        return msg.session.id;
+    return "";
+}
 function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
     const commandConfig = runtimeSettings?.command;
     if (!commandConfig || commandConfig.mode === "default") {
@@ -92,10 +125,11 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv
             const command = isDefaultRuntime ? process.execPath : resolved.command;
             const child = spawnProcess(command, resolved.args, {
                 cwd: spawnOptions.cwd,
-                env: {
-                    ...applyProviderEnv(spawnOptions.env, runtimeSettings),
-                    ...(launchEnv ?? {}),
-                },
+                ...createProviderEnvSpec({
+                    baseEnv: spawnOptions.env,
+                    runtimeSettings,
+                    overlays: [launchEnv],
+                }),
                 signal: spawnOptions.signal,
                 stdio: ["pipe", "pipe", "pipe"],
                 // Bypass cmd.exe on Windows: the SDK passes --mcp-config with inline JSON
@@ -332,6 +366,26 @@ export function extractUserMessageText(content) {
 function isMetadata(value) {
     return typeof value === "object" && value !== null;
 }
+function createDefaultToolUseCacheEntry(id, block) {
+    const nameFromBlock = typeof block.name === "string" && block.name.length > 0 ? block.name : "tool";
+    let server;
+    if (typeof block.server === "string" && block.server.length > 0) {
+        server = block.server;
+    }
+    else if (typeof block.name === "string" && block.name.length > 0) {
+        server = block.name;
+    }
+    else {
+        server = "tool";
+    }
+    return {
+        id,
+        name: nameFromBlock,
+        server,
+        classification: "generic",
+        started: false,
+    };
+}
 function readTrimmedString(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -728,31 +782,44 @@ function isSyntheticUserEntry(entry) {
     const candidate = entry;
     return candidate.isSynthetic === true || candidate.isMeta === true;
 }
+function firstTrimmedString(sources) {
+    for (const source of sources) {
+        const value = readTrimmedString(source);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
 export function readEventIdentifiers(message) {
     const root = message;
     const messageType = readTrimmedString(root.type);
     const streamEvent = root.event;
     const streamEventMessage = streamEvent?.message;
     const messageContainer = root.message;
+    const messageIdFromUuid = messageType === "user" ? root.uuid : undefined;
     return {
-        taskId: readTrimmedString(root.task_id) ??
-            readTrimmedString(streamEvent?.task_id) ??
-            readTrimmedString(streamEventMessage?.task_id) ??
-            readTrimmedString(messageContainer?.task_id) ??
-            null,
-        parentMessageId: readTrimmedString(root.parent_message_id) ??
-            readTrimmedString(streamEvent?.parent_message_id) ??
-            readTrimmedString(streamEventMessage?.parent_message_id) ??
-            readTrimmedString(messageContainer?.parent_message_id) ??
-            null,
-        messageId: readTrimmedString(root.message_id) ??
-            readTrimmedString(streamEvent?.message_id) ??
-            readTrimmedString(streamEventMessage?.id) ??
-            readTrimmedString(streamEventMessage?.message_id) ??
-            readTrimmedString(messageContainer?.id) ??
-            readTrimmedString(messageContainer?.message_id) ??
-            (messageType === "user" ? readTrimmedString(root.uuid) : null) ??
-            null,
+        taskId: firstTrimmedString([
+            root.task_id,
+            streamEvent?.task_id,
+            streamEventMessage?.task_id,
+            messageContainer?.task_id,
+        ]),
+        parentMessageId: firstTrimmedString([
+            root.parent_message_id,
+            streamEvent?.parent_message_id,
+            streamEventMessage?.parent_message_id,
+            messageContainer?.parent_message_id,
+        ]),
+        messageId: firstTrimmedString([
+            root.message_id,
+            streamEvent?.message_id,
+            streamEventMessage?.id,
+            streamEventMessage?.message_id,
+            messageContainer?.id,
+            messageContainer?.message_id,
+            messageIdFromUuid,
+        ]),
     };
 }
 const claudeDebug = process.env.PASEO_CLAUDE_DEBUG === "1";
@@ -781,7 +848,11 @@ export class ClaudeAgentClient {
         if (!merged.cwd) {
             throw new Error("Claude resume requires the original working directory in metadata");
         }
-        const mergedConfig = { ...merged, provider: "claude", cwd: merged.cwd };
+        const mergedConfig = {
+            ...merged,
+            provider: "claude",
+            cwd: merged.cwd,
+        };
         const claudeConfig = this.assertConfig(mergedConfig);
         return new ClaudeAgentSession(claudeConfig, {
             defaults: this.defaults,
@@ -804,17 +875,10 @@ export class ClaudeAgentClient {
         }
         const limit = options?.limit ?? 20;
         const candidates = await collectRecentClaudeSessions(projectsRoot, limit * 3);
-        const descriptors = [];
-        for (const candidate of candidates) {
-            const descriptor = await parseClaudeSessionDescriptor(candidate.path, candidate.mtime);
-            if (descriptor) {
-                descriptors.push(descriptor);
-            }
-            if (descriptors.length >= limit) {
-                break;
-            }
-        }
-        return descriptors;
+        const parsed = await Promise.all(candidates.map((candidate) => parseClaudeSessionDescriptor(candidate.path, candidate.mtime)));
+        return parsed
+            .filter((descriptor) => descriptor !== null)
+            .slice(0, limit);
     }
     async isAvailable() {
         const command = this.runtimeSettings?.command;
@@ -835,7 +899,10 @@ export class ClaudeAgentClient {
             let status = formatDiagnosticStatus(available);
             if (available) {
                 try {
-                    const models = await this.listModels({ cwd: os.homedir(), force: false });
+                    const models = await this.listModels({
+                        cwd: os.homedir(),
+                        force: false,
+                    });
                     modelsValue = String(models.length);
                 }
                 catch (error) {
@@ -871,16 +938,20 @@ export class ClaudeAgentClient {
 }
 async function resolveClaudeVersion(runtimeSettings) {
     const command = runtimeSettings?.command;
+    const envSpec = createProviderEnvSpec({ runtimeSettings });
     try {
         if (command?.mode === "replace") {
-            const { stdout } = await execCommand(command.argv[0], [...command.argv.slice(1), "--version"], { timeout: 5000 });
+            const { stdout } = await execCommand(command.argv[0], [...command.argv.slice(1), "--version"], { ...envSpec, timeout: 5000 });
             return stdout.trim() || null;
         }
         const executable = await findExecutable("claude");
         if (!executable) {
             return null;
         }
-        const { stdout } = await execCommand(executable, ["--version"], { timeout: 5000 });
+        const { stdout } = await execCommand(executable, ["--version"], {
+            ...envSpec,
+            timeout: 5000,
+        });
         return stdout.trim() || null;
     }
     catch {
@@ -891,7 +962,10 @@ async function resolveClaudeAuth(runtimeSettings) {
     const command = runtimeSettings?.command;
     const run = async (executable, args) => {
         try {
-            return await execCommand(executable, args, { timeout: 5000 });
+            return await execCommand(executable, args, {
+                ...createProviderEnvSpec({ runtimeSettings }),
+                timeout: 5000,
+            });
         }
         catch (error) {
             const err = error;
@@ -1048,11 +1122,17 @@ class ClaudeAgentSession {
                 kind,
                 input,
                 detail: toolDetail,
-                suggestions: options.suggestions?.map((suggestion) => ({ ...suggestion })),
+                suggestions: options.suggestions?.map((suggestion) => ({
+                    ...suggestion,
+                })),
                 actions: kind === "plan" ? buildClaudePlanPermissionActions(this.planResumeMode) : undefined,
                 metadata: Object.keys(metadata).length ? metadata : undefined,
             };
-            this.pushEvent({ type: "permission_requested", provider: "claude", request });
+            this.pushEvent({
+                type: "permission_requested",
+                provider: "claude",
+                request,
+            });
             return await new Promise((resolve, reject) => {
                 const cleanupFns = [];
                 const cleanup = () => {
@@ -1140,77 +1220,14 @@ class ClaudeAgentSession {
         return { ...info };
     }
     async run(prompt, options) {
-        const timeline = [];
-        let finalText = "";
-        let usage;
-        let turnId = null;
-        const bufferedEvents = [];
-        let settled = false;
-        let resolveCompletion;
-        let rejectCompletion;
-        const processEvent = (event) => {
-            if (settled) {
-                return;
-            }
-            const eventTurnId = event.turnId;
-            if (turnId && eventTurnId && eventTurnId !== turnId) {
-                return;
-            }
-            if (event.type === "timeline") {
-                timeline.push(event.item);
-                if (event.item.type === "assistant_message") {
-                    if (!finalText) {
-                        finalText = event.item.text;
-                    }
-                    else if (event.item.text.startsWith(finalText)) {
-                        finalText = event.item.text;
-                    }
-                    else {
-                        finalText += event.item.text;
-                    }
-                }
-                return;
-            }
-            if (event.type === "turn_completed") {
-                usage = event.usage;
-                settled = true;
-                resolveCompletion();
-                return;
-            }
-            if (event.type === "turn_failed") {
-                settled = true;
-                rejectCompletion(new Error(event.error));
-                return;
-            }
-            if (event.type === "turn_canceled") {
-                settled = true;
-                resolveCompletion();
-            }
-        };
-        const completion = new Promise((resolve, reject) => {
-            resolveCompletion = resolve;
-            rejectCompletion = reject;
+        const result = await runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.claudeSessionId ?? "",
+            reduceFinalText: appendOrReplaceGrowingAssistantMessage,
         });
-        const unsubscribe = this.subscribe((event) => {
-            if (!turnId) {
-                bufferedEvents.push(event);
-                return;
-            }
-            processEvent(event);
-        });
-        try {
-            const result = await this.startTurn(prompt, options);
-            turnId = result.turnId;
-            for (const event of bufferedEvents) {
-                processEvent(event);
-            }
-            if (!settled) {
-                await completion;
-            }
-        }
-        finally {
-            unsubscribe();
-        }
         this.cachedRuntimeInfo = {
             provider: "claude",
             sessionId: this.claudeSessionId,
@@ -1220,12 +1237,7 @@ class ClaudeAgentSession {
         if (!this.claudeSessionId) {
             throw new Error("Session ID not set after run completed");
         }
-        return {
-            sessionId: this.claudeSessionId,
-            finalText,
-            usage,
-            timeline,
-        };
+        return result;
     }
     async startTurn(prompt, _options) {
         if (this.closed) {
@@ -1328,8 +1340,8 @@ class ClaudeAgentSession {
         }
         const normalized = isPermissionMode(modeId) ? modeId : "default";
         const previousMode = this.currentMode;
-        const query = await this.ensureQuery();
-        await query.setPermissionMode(normalized);
+        const activeQuery = await this.ensureQuery();
+        await activeQuery.setPermissionMode(normalized);
         if (normalized === "plan") {
             if (previousMode !== "plan") {
                 this.planResumeMode = previousMode;
@@ -1342,8 +1354,8 @@ class ClaudeAgentSession {
     }
     async setModel(modelId) {
         const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
-        const query = await this.ensureQuery();
-        await query.setModel(normalizedModelId ?? undefined);
+        const activeQuery = await this.ensureQuery();
+        await activeQuery.setModel(normalizedModelId ?? undefined);
         this.config.model = normalizedModelId ?? undefined;
         this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
         this.lastRuntimeModel = null;
@@ -1577,8 +1589,8 @@ class ClaudeAgentSession {
     }
     async rewindFilesOnce(messageId) {
         try {
-            const query = await this.ensureFreshQuery();
-            return await query.rewindFiles(messageId, { dryRun: false });
+            const activeQuery = await this.ensureFreshQuery();
+            return await activeQuery.rewindFiles(messageId, { dryRun: false });
         }
         catch (error) {
             // The Claude SDK transport can close after a rewind call.
@@ -1669,9 +1681,6 @@ class ClaudeAgentSession {
             this.input = null;
             this.queryPumpPromise = null;
             this.queryRestartNeeded = false;
-            // Reset session identity for explicit restarts so the new query starts
-            // a fresh session rather than resuming the previous one.
-            this.claudeSessionId = null;
             oldInput?.end();
             oldQuery.close?.();
             try {
@@ -1681,10 +1690,8 @@ class ClaudeAgentSession {
                 /* ignore */
             }
         }
-        // When the pump died unexpectedly (query became null, e.g. after a session
-        // ID overwrite error), preserve claudeSessionId so buildOptions() passes
-        // resume: sessionId and the new query auto-resumes the previous session.
-        // For explicit restarts above, claudeSessionId was already cleared.
+        // Preserve claudeSessionId across query recreation so buildOptions() passes
+        // resume: sessionId and the new query continues the existing conversation.
         this.persistence = null;
         const input = createAsyncMessageInput();
         const options = await this.buildOptions();
@@ -1712,32 +1719,46 @@ class ClaudeAgentSession {
             this.logger.warn({ err: error, label }, "Claude query operation did not settle cleanly");
         }
     }
-    async buildOptions() {
+    resolveThinkingConfig() {
         const thinkingOptionId = this.config.thinkingOptionId && this.config.thinkingOptionId !== "default"
             ? this.config.thinkingOptionId
             : undefined;
-        let thinking;
-        let effort;
         if (thinkingOptionId && isClaudeThinkingEffort(thinkingOptionId)) {
-            thinking = { type: "adaptive" };
             // SDK 0.2.71 types `effort` as 'low' | 'medium' | 'high' | 'max'; Opus 4.7
             // adds 'xhigh' which the binary accepts but the typings don't yet expose.
-            effort = thinkingOptionId;
+            return {
+                thinking: { type: "adaptive" },
+                effort: thinkingOptionId,
+            };
         }
-        const appendedSystemPrompt = [
-            getOrchestratorModeInstructions(),
-            this.config.systemPrompt?.trim(),
-        ]
+        return { thinking: undefined, effort: undefined };
+    }
+    buildAppendedSystemPrompt() {
+        return [getOrchestratorModeInstructions(), this.config.systemPrompt?.trim()]
             .filter((entry) => typeof entry === "string" && entry.length > 0)
             .join("\n\n");
+    }
+    async buildOptions() {
+        const { thinking, effort } = this.resolveThinkingConfig();
+        const appendedSystemPrompt = this.buildAppendedSystemPrompt();
+        const extraClaudeOptions = this.config.extra?.claude;
+        const sdkEnv = createProviderEnv({
+            baseEnv: process.env,
+            runtimeSettings: this.runtimeSettings,
+            overlays: [
+                extraClaudeOptions?.env,
+                {
+                    // Increase MCP timeouts for long-running tool calls (10 minutes)
+                    MCP_TIMEOUT: "600000",
+                    MCP_TOOL_TIMEOUT: "600000",
+                },
+                this.launchEnv,
+            ],
+        });
         const claudeBinary = await findExecutable("claude");
         this.logger.debug({
             claudeBinary,
-            pathEnvKey: process.env["Path"] !== undefined
-                ? "Path"
-                : process.env["PATH"] !== undefined
-                    ? "PATH"
-                    : null,
+            pathEnvKey: resolvePathEnvKey(),
             pathIncludesClaudeLocalBin: (process.env["Path"] ?? process.env["PATH"] ?? "")
                 .toLowerCase()
                 .includes("\\.local\\bin"),
@@ -1765,13 +1786,6 @@ class ClaudeAgentSession {
                 this.captureStderr(data);
                 this.logger.error({ stderr: data.trim() }, "Claude Agent SDK stderr");
             },
-            env: {
-                ...process.env,
-                // Increase MCP timeouts for long-running tool calls (10 minutes)
-                MCP_TIMEOUT: "600000",
-                MCP_TOOL_TIMEOUT: "600000",
-                ...(this.launchEnv ?? {}),
-            },
             // Required for provider-level /rewind support.
             enableFileCheckpointing: true,
             // If we have a session ID from a previous query (e.g., after interrupt),
@@ -1779,7 +1793,8 @@ class ClaudeAgentSession {
             ...(this.claudeSessionId ? { resume: this.claudeSessionId } : {}),
             ...(thinking ? { thinking } : {}),
             ...(effort ? { effort } : {}),
-            ...this.config.extra?.claude,
+            ...extraClaudeOptions,
+            env: sdkEnv,
         };
         if (this.config.mcpServers) {
             base.mcpServers = this.normalizeMcpServers(this.config.mcpServers);
@@ -1826,7 +1841,7 @@ class ClaudeAgentSession {
                         },
                     });
                 }
-                else if (chunk.type === "github_pr" || chunk.type === "github_issue") {
+                else {
                     content.push({ type: "text", text: renderPromptAttachmentAsText(chunk) });
                 }
             }
@@ -1900,7 +1915,7 @@ class ClaudeAgentSession {
         if (this.getRecentStderrDiagnostic()) {
             return;
         }
-        const message = typeof error === "string" ? error : error instanceof Error ? error.message : "";
+        const message = errorToMessageString(error);
         if (!/\bprocess exited with code\b/i.test(message) &&
             !/\bterminated by signal\b/i.test(message)) {
             return;
@@ -1965,11 +1980,16 @@ class ClaudeAgentSession {
         if (consecutiveRecoveries >= 3) {
             return false;
         }
-        const message = typeof error === "string"
-            ? error
-            : error instanceof Error
-                ? `${error.message}\n${error.stack ?? ""}`
-                : JSON.stringify(error);
+        let message;
+        if (typeof error === "string") {
+            message = error;
+        }
+        else if (error instanceof Error) {
+            message = `${error.message}\n${error.stack ?? ""}`;
+        }
+        else {
+            message = JSON.stringify(error);
+        }
         return message.toLowerCase().includes("request was aborted");
     }
     finishForegroundTurn(event) {
@@ -2055,23 +2075,39 @@ class ClaudeAgentSession {
             return;
         }
         let consecutiveInterruptAbortRecoveries = 0;
+        const logRawMessage = (message) => {
+            if (!claudeDebug) {
+                return;
+            }
+            this.logger.trace({
+                claudeSessionId: this.claudeSessionId,
+                messageType: message.type,
+                messageSubtype: "subtype" in message ? message.subtype : undefined,
+                messageUuid: "uuid" in message ? message.uuid : undefined,
+            }, "Claude query pump: raw SDK message");
+        };
+        const handlePumpedMessage = async (message) => {
+            logRawMessage(message);
+            consecutiveInterruptAbortRecoveries = 0;
+            if (await this.handleMissingResumedConversation(message, activeQuery)) {
+                return true;
+            }
+            this.routeSdkMessageFromPump(message);
+            return false;
+        };
+        const drainActiveQuery = async () => {
+            for await (const message of activeQuery) {
+                if (await handlePumpedMessage(message)) {
+                    return true;
+                }
+            }
+            return false;
+        };
         try {
             while (!this.closed && this.query === activeQuery) {
                 try {
-                    for await (const message of activeQuery) {
-                        if (claudeDebug) {
-                            this.logger.trace({
-                                claudeSessionId: this.claudeSessionId,
-                                messageType: message.type,
-                                messageSubtype: "subtype" in message ? message.subtype : undefined,
-                                messageUuid: "uuid" in message ? message.uuid : undefined,
-                            }, "Claude query pump: raw SDK message");
-                        }
-                        consecutiveInterruptAbortRecoveries = 0;
-                        if (await this.handleMissingResumedConversation(message, activeQuery)) {
-                            return;
-                        }
-                        this.routeSdkMessageFromPump(message);
+                    if (await drainActiveQuery()) {
+                        return;
                     }
                     if (!this.closed && this.query === activeQuery) {
                         this.failActiveTurns("Claude stream ended before terminal result");
@@ -2101,7 +2137,16 @@ class ClaudeAgentSession {
             }
         }
     }
-    routeSdkMessageFromPump(message) {
+    isEchoedForegroundUserMessage(event) {
+        if (event.type !== "timeline" ||
+            event.item.type !== "user_message" ||
+            !this.activeForegroundTurnId ||
+            !this.lastForegroundPromptText) {
+            return false;
+        }
+        return event.item.text.trim() === this.lastForegroundPromptText.trim();
+    }
+    shouldSuppressStaleResult(message) {
         // Suppress stale results from interrupted requests. The cancel path already
         // emitted the terminal event; this result is leftover from the killed API
         // request. Consume the flag on ANY result so it doesn't linger.
@@ -2109,19 +2154,27 @@ class ClaudeAgentSession {
             this.pendingInterruptAbort = false;
             if (message.subtype !== "success") {
                 this.logger.debug("Suppressing stale non-success result from interrupted request");
-                return;
+                return true;
             }
         }
         if (message.type === "result" && message.subtype !== "success" && this.isAbortError(message)) {
             this.logger.debug("Suppressing abort result by content");
-            return;
+            return true;
         }
-        const isForeground = Boolean(this.activeForegroundTurnId);
-        const assistantishMessage = message.type === "assistant" ||
+        return false;
+    }
+    isAssistantishMessage(message) {
+        return (message.type === "assistant" ||
             message.type === "stream_event" ||
             message.type === "tool_progress" ||
-            (message.type === "system" && message.subtype === "task_notification");
-        if (!isForeground && assistantishMessage) {
+            (message.type === "system" && message.subtype === "task_notification"));
+    }
+    routeSdkMessageFromPump(message) {
+        if (this.shouldSuppressStaleResult(message)) {
+            return;
+        }
+        const isForeground = Boolean(this.activeForegroundTurnId);
+        if (!isForeground && this.isAssistantishMessage(message)) {
             this.startAutonomousTurn();
         }
         if (!isForeground && !this.autonomousTurn && message.type === "result") {
@@ -2152,17 +2205,7 @@ class ClaudeAgentSession {
             provider: "claude",
         }));
         // User message dedup: suppress echoed user messages that match the foreground prompt
-        const filteredMessageEvents = messageEvents.filter((event) => {
-            if (event.type === "timeline" &&
-                event.item.type === "user_message" &&
-                this.activeForegroundTurnId &&
-                this.lastForegroundPromptText) {
-                if (event.item.text.trim() === this.lastForegroundPromptText.trim()) {
-                    return false;
-                }
-            }
-            return true;
-        });
+        const filteredMessageEvents = messageEvents.filter((event) => !this.isEchoedForegroundUserMessage(event));
         const events = [...filteredMessageEvents, ...assistantTimelineEvents];
         if (events.length === 0) {
             return;
@@ -2183,7 +2226,7 @@ class ClaudeAgentSession {
         }
         this.dispatchEvents(events);
     }
-    async handleMissingResumedConversation(message, query) {
+    async handleMissingResumedConversation(message, activeQuery) {
         const staleResumeError = this.readMissingResumedConversationError(message);
         if (!staleResumeError) {
             return false;
@@ -2194,12 +2237,11 @@ class ClaudeAgentSession {
         }, "Claude resumed session no longer exists; invalidating persisted session");
         this.failActiveTurns(staleResumeError);
         this.input?.end();
-        await this.awaitWithTimeout(query.return?.(), "query pump return on missing resumed conversation");
-        if (this.query === query) {
+        await this.awaitWithTimeout(activeQuery.return?.(), "query pump return on missing resumed conversation");
+        if (this.query === activeQuery) {
             this.query = null;
             this.input = null;
         }
-        this.claudeSessionId = null;
         this.persistence = null;
         this.persistedHistory = [];
         this.historyPending = false;
@@ -2232,128 +2274,28 @@ class ClaudeAgentSession {
             return this.sidechainTracker.handleMessage(message, parentToolUseId);
         }
         const events = [];
-        const fallbackThreadSessionId = this.captureSessionIdFromMessage(message);
-        if (fallbackThreadSessionId) {
+        const sessionCapture = this.captureSessionIdFromMessage(message);
+        if (sessionCapture.notice) {
+            events.push({
+                type: "timeline",
+                provider: "claude",
+                item: sessionCapture.notice,
+            });
+        }
+        if (sessionCapture.threadStartedSessionId) {
             events.push({
                 type: "thread_started",
                 provider: "claude",
-                sessionId: fallbackThreadSessionId,
+                sessionId: sessionCapture.threadStartedSessionId,
             });
         }
         switch (message.type) {
             case "system":
-                if (message.subtype === "init") {
-                    const threadSessionId = this.handleSystemMessage(message);
-                    if (threadSessionId) {
-                        events.push({
-                            type: "thread_started",
-                            provider: "claude",
-                            sessionId: threadSessionId,
-                        });
-                    }
-                }
-                else if (message.subtype === "status") {
-                    const status = message.status;
-                    if (status === "compacting") {
-                        this.compacting = true;
-                        events.push({
-                            type: "timeline",
-                            item: { type: "compaction", status: "loading" },
-                            provider: "claude",
-                        });
-                    }
-                }
-                else if (message.subtype === "compact_boundary") {
-                    const compactMetadata = readCompactionMetadata(message);
-                    events.push({
-                        type: "timeline",
-                        item: {
-                            type: "compaction",
-                            status: "completed",
-                            trigger: compactMetadata?.trigger === "manual" ? "manual" : "auto",
-                            preTokens: compactMetadata?.preTokens,
-                        },
-                        provider: "claude",
-                    });
-                }
-                else if (message.subtype === "task_notification") {
-                    const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
-                    if (taskNotificationItem) {
-                        events.push({
-                            type: "timeline",
-                            item: taskNotificationItem,
-                            provider: "claude",
-                        });
-                    }
-                    const usage = readUsageFromTaskNotification(message);
-                    if (typeof usage === "number") {
-                        this.lastContextWindowUsedTokens = usage;
-                        events.push(this.createUsageUpdatedEvent(usage));
-                    }
-                }
-                else if (message.subtype === "task_progress") {
-                    this.lastContextWindowUsedTokens =
-                        readContextWindowUsedTokensFromTaskProgress(message) ??
-                            this.lastContextWindowUsedTokens;
-                    if (typeof this.lastContextWindowUsedTokens === "number") {
-                        events.push(this.createUsageUpdatedEvent(this.lastContextWindowUsedTokens));
-                    }
-                }
+                this.appendSystemMessageEvents(message, events);
                 break;
-            case "user": {
-                if (isSyntheticUserEntry(message)) {
-                    break;
-                }
-                if (this.compacting) {
-                    this.compacting = false;
-                    break;
-                }
-                const messageId = typeof message.uuid === "string" && message.uuid.length > 0 ? message.uuid : undefined;
-                this.rememberUserMessageId(messageId);
-                const content = message.message?.content;
-                const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
-                    content,
-                    messageId,
-                });
-                if (taskNotificationItem) {
-                    events.push({
-                        type: "timeline",
-                        item: taskNotificationItem,
-                        provider: "claude",
-                    });
-                    break;
-                }
-                if (typeof content === "string" && content.length > 0) {
-                    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, {
-                        textMessageType: "user_message",
-                    });
-                    for (const item of timelineItems) {
-                        if (item.type === "user_message" && messageId && !item.messageId) {
-                            events.push({
-                                type: "timeline",
-                                item: { ...item, messageId },
-                                provider: "claude",
-                            });
-                            continue;
-                        }
-                        events.push({ type: "timeline", item, provider: "claude" });
-                    }
-                }
+            case "user":
+                this.appendUserMessageEvents(message, events);
                 break;
-            }
             case "assistant": {
                 const timelineItems = this.mapBlocksToTimeline(message.message.content, {
                     suppressAssistantText: options?.suppressAssistantText ?? false,
@@ -2364,85 +2306,211 @@ class ClaudeAgentSession {
                 }
                 break;
             }
-            case "stream_event": {
-                const usageUpdatedEvent = this.trackStreamEventUsage(message.event);
-                if (usageUpdatedEvent) {
-                    events.push(usageUpdatedEvent);
-                }
-                const timelineItems = this.mapPartialEvent(message.event, {
-                    suppressAssistantText: options?.suppressAssistantText ?? false,
-                    suppressReasoning: options?.suppressReasoning ?? false,
-                });
-                for (const item of timelineItems) {
-                    events.push({ type: "timeline", item, provider: "claude" });
-                }
+            case "stream_event":
+                this.appendStreamEventEvents(message, events, options);
                 break;
-            }
-            case "result": {
-                const usage = this.convertUsage(message, message.modelUsage);
-                if (message.subtype === "success") {
-                    events.push({ type: "turn_completed", provider: "claude", usage });
-                }
-                else {
-                    const errorMessage = "errors" in message && Array.isArray(message.errors) && message.errors.length > 0
-                        ? message.errors.join("\n")
-                        : "Claude run failed";
-                    events.push(this.buildTurnFailedEvent(errorMessage));
-                }
+            case "result":
+                this.appendResultEvents(message, events);
                 break;
-            }
             default:
                 break;
         }
         return events;
     }
+    appendSystemMessageEvents(message, events) {
+        if (message.subtype === "init") {
+            const sessionUpdate = this.handleSystemMessage(message);
+            if (sessionUpdate.notice) {
+                events.push({
+                    type: "timeline",
+                    provider: "claude",
+                    item: sessionUpdate.notice,
+                });
+            }
+            if (sessionUpdate.threadStartedSessionId) {
+                events.push({
+                    type: "thread_started",
+                    provider: "claude",
+                    sessionId: sessionUpdate.threadStartedSessionId,
+                });
+            }
+            return;
+        }
+        if (message.subtype === "status") {
+            const status = message.status;
+            if (status === "compacting") {
+                this.compacting = true;
+                events.push({
+                    type: "timeline",
+                    item: { type: "compaction", status: "loading" },
+                    provider: "claude",
+                });
+            }
+            return;
+        }
+        if (message.subtype === "compact_boundary") {
+            const compactMetadata = readCompactionMetadata(message);
+            events.push({
+                type: "timeline",
+                item: {
+                    type: "compaction",
+                    status: "completed",
+                    trigger: compactMetadata?.trigger === "manual" ? "manual" : "auto",
+                    preTokens: compactMetadata?.preTokens,
+                },
+                provider: "claude",
+            });
+            return;
+        }
+        if (message.subtype === "task_notification") {
+            const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
+            if (taskNotificationItem) {
+                events.push({
+                    type: "timeline",
+                    item: taskNotificationItem,
+                    provider: "claude",
+                });
+            }
+            const usage = readUsageFromTaskNotification(message);
+            if (typeof usage === "number") {
+                this.lastContextWindowUsedTokens = usage;
+                events.push(this.createUsageUpdatedEvent(usage));
+            }
+            return;
+        }
+        if (message.subtype === "task_progress") {
+            this.lastContextWindowUsedTokens =
+                readContextWindowUsedTokensFromTaskProgress(message) ?? this.lastContextWindowUsedTokens;
+            if (typeof this.lastContextWindowUsedTokens === "number") {
+                events.push(this.createUsageUpdatedEvent(this.lastContextWindowUsedTokens));
+            }
+        }
+    }
+    appendUserMessageEvents(message, events) {
+        if (isSyntheticUserEntry(message)) {
+            return;
+        }
+        if (this.compacting) {
+            this.compacting = false;
+            return;
+        }
+        const messageId = typeof message.uuid === "string" && message.uuid.length > 0 ? message.uuid : undefined;
+        this.rememberUserMessageId(messageId);
+        const content = message.message?.content;
+        const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
+            content,
+            messageId,
+        });
+        if (taskNotificationItem) {
+            events.push({
+                type: "timeline",
+                item: taskNotificationItem,
+                provider: "claude",
+            });
+            return;
+        }
+        if (typeof content === "string" && content.length > 0) {
+            if (!isClaudeTranscriptNoiseText(content)) {
+                events.push({
+                    type: "timeline",
+                    item: {
+                        type: "user_message",
+                        text: content,
+                        ...(messageId ? { messageId } : {}),
+                    },
+                    provider: "claude",
+                });
+            }
+            return;
+        }
+        if (Array.isArray(content)) {
+            this.appendUserContentArrayEvents(content, messageId, events);
+        }
+    }
+    appendUserContentArrayEvents(content, messageId, events) {
+        const timelineItems = this.mapBlocksToTimeline(content, {
+            textMessageType: "user_message",
+        });
+        for (const item of timelineItems) {
+            if (item.type === "user_message" && messageId && !item.messageId) {
+                events.push({
+                    type: "timeline",
+                    item: { ...item, messageId },
+                    provider: "claude",
+                });
+                continue;
+            }
+            events.push({ type: "timeline", item, provider: "claude" });
+        }
+    }
+    appendStreamEventEvents(message, events, options) {
+        const usageUpdatedEvent = this.trackStreamEventUsage(message.event);
+        if (usageUpdatedEvent) {
+            events.push(usageUpdatedEvent);
+        }
+        const timelineItems = this.mapPartialEvent(message.event, {
+            suppressAssistantText: options?.suppressAssistantText ?? false,
+            suppressReasoning: options?.suppressReasoning ?? false,
+        });
+        for (const item of timelineItems) {
+            events.push({ type: "timeline", item, provider: "claude" });
+        }
+    }
+    appendResultEvents(message, events) {
+        const usage = this.convertUsage(message, message.modelUsage);
+        if (message.subtype === "success") {
+            events.push({ type: "turn_completed", provider: "claude", usage });
+            return;
+        }
+        const errorMessage = "errors" in message && Array.isArray(message.errors) && message.errors.length > 0
+            ? message.errors.join("\n")
+            : "Claude run failed";
+        events.push(this.buildTurnFailedEvent(errorMessage));
+    }
+    createClaudeSessionChangedNotice(oldSessionId, newSessionId) {
+        return {
+            type: "assistant_message",
+            text: `Claude switched to a new session: ${oldSessionId} -> ${newSessionId}`,
+        };
+    }
     captureSessionIdFromMessage(message) {
         const msg = message;
-        const sessionIdRaw = typeof msg.session_id === "string"
-            ? msg.session_id
-            : typeof msg.sessionId === "string"
-                ? msg.sessionId
-                : typeof msg.session?.id === "string"
-                    ? msg.session.id
-                    : "";
-        const sessionId = sessionIdRaw.trim();
+        const sessionId = extractSessionIdRaw(msg).trim();
         if (!sessionId) {
-            return null;
+            return { threadStartedSessionId: null, notice: null };
         }
         if (this.claudeSessionId === null) {
             this.claudeSessionId = sessionId;
             this.persistence = null;
-            return sessionId;
+            return { threadStartedSessionId: sessionId, notice: null };
         }
         if (this.claudeSessionId === sessionId) {
-            return null;
+            return { threadStartedSessionId: null, notice: null };
         }
+        const oldSessionId = this.claudeSessionId;
         // Session ID changed mid-stream (e.g. a hook caused Claude to restart
         // with a new session). Accept the new ID and continue — the turn should
         // not be failed just because the underlying subprocess cycled.
         this.logger.warn({ existingSessionId: this.claudeSessionId, newSessionId: sessionId }, "Claude session ID changed in message; accepting new session");
         this.claudeSessionId = sessionId;
         this.persistence = null;
-        return sessionId;
+        return {
+            threadStartedSessionId: sessionId,
+            notice: this.createClaudeSessionChangedNotice(oldSessionId, sessionId),
+        };
     }
     handleSystemMessage(message) {
         if (message.subtype !== "init") {
-            return null;
+            return { threadStartedSessionId: null, notice: null };
         }
         const msg = message;
-        const newSessionIdRaw = typeof msg.session_id === "string"
-            ? msg.session_id
-            : typeof msg.sessionId === "string"
-                ? msg.sessionId
-                : typeof msg.session?.id === "string"
-                    ? msg.session.id
-                    : "";
-        const newSessionId = newSessionIdRaw.trim();
+        const newSessionId = extractSessionIdRaw(msg).trim();
         if (!newSessionId) {
-            return null;
+            return { threadStartedSessionId: null, notice: null };
         }
         const existingSessionId = this.claudeSessionId;
         let threadStartedSessionId = null;
+        let notice = null;
         if (existingSessionId === null) {
             this.claudeSessionId = newSessionId;
             threadStartedSessionId = newSessionId;
@@ -2457,6 +2525,7 @@ class ClaudeAgentSession {
             this.logger.warn({ existingSessionId, newSessionId }, "Claude session ID changed in init message; accepting new session");
             this.claudeSessionId = newSessionId;
             threadStartedSessionId = newSessionId;
+            notice = this.createClaudeSessionChangedNotice(existingSessionId, newSessionId);
         }
         this.availableModes = DEFAULT_MODES;
         this.currentMode = message.permissionMode;
@@ -2476,7 +2545,7 @@ class ClaudeAgentSession {
             this.lastRuntimeModel = message.model;
             this.cachedRuntimeInfo = null;
         }
-        return threadStartedSessionId;
+        return { threadStartedSessionId, notice };
     }
     readMissingResumedConversationError(message) {
         if (message.type !== "result" || message.subtype !== "error_during_execution") {
@@ -2651,7 +2720,7 @@ class ClaudeAgentSession {
             }
             this.ingestPersistedHistory(fs.readFileSync(historyPath, "utf8"));
         }
-        catch (error) {
+        catch {
             // ignore history load failures
         }
     }
@@ -2734,50 +2803,16 @@ class ClaudeAgentSession {
         // 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 &&
-                        !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 });
-                        }
-                    }
-                    break;
-                case "thinking":
-                case "thinking_delta":
-                    if (block.thinking) {
-                        if (!suppressReasoning) {
-                            items.push({ type: "reasoning", text: block.thinking });
-                        }
-                    }
-                    break;
-                case "tool_use":
-                case "server_tool_use":
-                case "mcp_tool_use": {
-                    this.handleToolUseStart(block, items);
-                    break;
-                }
-                case "tool_result":
-                case "mcp_tool_result":
-                case "web_fetch_tool_result":
-                case "web_search_tool_result":
-                case "code_execution_tool_result":
-                case "bash_code_execution_tool_result":
-                case "text_editor_code_execution_tool_result": {
-                    this.handleToolResult(block, items);
-                    break;
-                }
-                default:
-                    break;
+            if (!isClaudeContentChunk(block)) {
+                continue;
             }
+            this.mapBlockToTimeline(block, {
+                items,
+                userTextParts,
+                textMessageType,
+                suppressText,
+                suppressReasoning,
+            });
         }
         if (textMessageType === "user_message" && userTextParts.length > 0) {
             items.unshift({
@@ -2787,6 +2822,53 @@ class ClaudeAgentSession {
         }
         return items;
     }
+    appendTextBlockToTimeline(block, context) {
+        const { items, userTextParts, textMessageType, suppressText } = context;
+        const text = typeof block.text === "string" ? block.text : "";
+        if (!text || text === INTERRUPT_TOOL_USE_PLACEHOLDER || isClaudeTranscriptNoiseText(text)) {
+            return;
+        }
+        if (textMessageType === "user_message") {
+            const trimmed = text.trim();
+            if (trimmed) {
+                userTextParts.push(trimmed);
+            }
+            return;
+        }
+        if (!suppressText) {
+            items.push({ type: "assistant_message", text });
+        }
+    }
+    mapBlockToTimeline(block, context) {
+        switch (block.type) {
+            case "text":
+            case "text_delta":
+                this.appendTextBlockToTimeline(block, context);
+                break;
+            case "thinking":
+            case "thinking_delta":
+                if (typeof block.thinking === "string" && block.thinking && !context.suppressReasoning) {
+                    context.items.push({ type: "reasoning", text: block.thinking });
+                }
+                break;
+            case "tool_use":
+            case "server_tool_use":
+            case "mcp_tool_use":
+                this.handleToolUseStart(block, context.items);
+                break;
+            case "tool_result":
+            case "mcp_tool_result":
+            case "web_fetch_tool_result":
+            case "web_search_tool_result":
+            case "code_execution_tool_result":
+            case "bash_code_execution_tool_result":
+            case "text_editor_code_execution_tool_result":
+                this.handleToolResult(block, context.items);
+                break;
+            default:
+                break;
+        }
+    }
     handleToolUseStart(block, items) {
         const entry = this.upsertToolUseEntry(block);
         if (!entry) {
@@ -2806,7 +2888,8 @@ class ClaudeAgentSession {
     }
     handleToolResult(block, items) {
         const entry = typeof block.tool_use_id === "string" ? this.toolUseCache.get(block.tool_use_id) : undefined;
-        const toolName = entry?.name ?? block.tool_name ?? "tool";
+        const blockToolName = typeof block.tool_name === "string" ? block.tool_name : undefined;
+        const toolName = entry?.name ?? blockToolName ?? "tool";
         const callId = typeof block.tool_use_id === "string" && block.tool_use_id.length > 0
             ? block.tool_use_id
             : (entry?.id ?? null);
@@ -2838,8 +2921,10 @@ class ClaudeAgentSession {
         if (block.is_error) {
             return undefined;
         }
-        const server = entry?.server ?? block.server ?? "tool";
-        const tool = entry?.name ?? block.tool_name ?? "tool";
+        const blockServer = typeof block.server === "string" ? block.server : undefined;
+        const blockToolName = typeof block.tool_name === "string" ? block.tool_name : undefined;
+        const server = entry?.server ?? blockServer ?? "tool";
+        const tool = entry?.name ?? blockToolName ?? "tool";
         const content = coerceToolResultContentToString(block.content);
         const input = entry?.input;
         // Build structured result based on tool type
@@ -2865,17 +2950,39 @@ class ClaudeAgentSession {
         }
         return Object.keys(result).length > 0 ? result : undefined;
     }
-    buildStructuredToolResult(server, tool, output, input) {
-        const normalizedServer = server.toLowerCase();
-        const normalizedTool = tool.toLowerCase();
-        // Command execution tools
+    isCommandExecutionTool(normalizedServer, normalizedTool, input) {
         if (normalizedServer.includes("bash") ||
             normalizedServer.includes("shell") ||
-            normalizedServer.includes("command") ||
-            normalizedTool.includes("bash") ||
+            normalizedServer.includes("command")) {
+            return true;
+        }
+        if (normalizedTool.includes("bash") ||
             normalizedTool.includes("shell") ||
-            normalizedTool.includes("command") ||
-            (input && (typeof input.command === "string" || Array.isArray(input.command)))) {
+            normalizedTool.includes("command")) {
+            return true;
+        }
+        return Boolean(input && (typeof input.command === "string" || Array.isArray(input.command)));
+    }
+    static isFileWriteTool(normalizedTool) {
+        return (normalizedTool.includes("write") ||
+            normalizedTool === "write_file" ||
+            normalizedTool === "create_file");
+    }
+    static isFileEditTool(normalizedTool) {
+        return (normalizedTool.includes("edit") ||
+            normalizedTool.includes("patch") ||
+            normalizedTool === "apply_patch" ||
+            normalizedTool === "apply_diff");
+    }
+    static isFileReadTool(normalizedTool) {
+        return (normalizedTool.includes("read") ||
+            normalizedTool === "read_file" ||
+            normalizedTool === "view_file");
+    }
+    buildStructuredToolResult(server, tool, output, input) {
+        const normalizedServer = server.toLowerCase();
+        const normalizedTool = tool.toLowerCase();
+        if (this.isCommandExecutionTool(normalizedServer, normalizedTool, input)) {
             const command = this.extractCommandText(input ?? {}) ?? "command";
             return {
                 type: "command",
@@ -2884,64 +2991,43 @@ class ClaudeAgentSession {
                 cwd: typeof input?.cwd === "string" ? input.cwd : undefined,
             };
         }
-        // File write tools (new files or complete replacements)
-        if (normalizedTool.includes("write") ||
-            normalizedTool === "write_file" ||
-            normalizedTool === "create_file") {
-            if (input && typeof input.file_path === "string") {
-                return {
-                    type: "file_write",
-                    filePath: input.file_path,
-                    oldContent: "",
-                    newContent: typeof input.content === "string" ? input.content : output,
-                };
-            }
+        if (ClaudeAgentSession.isFileWriteTool(normalizedTool) &&
+            input &&
+            typeof input.file_path === "string") {
+            return {
+                type: "file_write",
+                filePath: input.file_path,
+                oldContent: "",
+                newContent: typeof input.content === "string" ? input.content : output,
+            };
         }
-        // File edit/patch tools
-        if (normalizedTool.includes("edit") ||
-            normalizedTool.includes("patch") ||
-            normalizedTool === "apply_patch" ||
-            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;
-                return {
-                    type: "file_edit",
-                    filePath: input.file_path,
-                    diff: typeof input.patch === "string"
-                        ? input.patch
-                        : typeof input.diff === "string"
-                            ? input.diff
-                            : undefined,
-                    oldContent,
-                    newContent,
-                };
-            }
+        if (ClaudeAgentSession.isFileEditTool(normalizedTool) &&
+            input &&
+            typeof input.file_path === "string") {
+            // Support both old_str/new_str and old_string/new_string parameter names
+            const oldContent = firstStringField(input, "old_str", "old_string");
+            const newContent = firstStringField(input, "new_str", "new_string");
+            const diff = firstStringField(input, "patch", "diff");
+            return {
+                type: "file_edit",
+                filePath: input.file_path,
+                diff,
+                oldContent,
+                newContent,
+            };
         }
-        // File read tools
-        if (normalizedTool.includes("read") ||
-            normalizedTool === "read_file" ||
-            normalizedTool === "view_file") {
-            if (input && typeof input.file_path === "string") {
-                return {
-                    type: "file_read",
-                    filePath: input.file_path,
-                    content: output,
-                };
-            }
+        if (ClaudeAgentSession.isFileReadTool(normalizedTool) &&
+            input &&
+            typeof input.file_path === "string") {
+            return {
+                type: "file_read",
+                filePath: input.file_path,
+                content: output,
+            };
         }
         return undefined;
     }
-    mapPartialEvent(event, options) {
+    updatePartialEventToolState(event) {
         if (event.type === "content_block_start") {
             const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
             if (block?.type === "tool_use" &&
@@ -2950,22 +3036,30 @@ class ClaudeAgentSession {
                 this.toolUseIndexToId.set(event.index, block.id);
                 this.toolUseInputBuffers.delete(block.id);
             }
+            return false;
         }
-        else if (event.type === "content_block_delta") {
+        if (event.type === "content_block_delta") {
             const delta = isClaudeContentChunk(event.delta) ? event.delta : null;
             if (delta?.type === "input_json_delta") {
                 const partialJson = typeof delta.partial_json === "string" ? delta.partial_json : undefined;
                 this.handleToolInputDelta(event.index, partialJson);
-                return [];
+                return true;
             }
+            return false;
         }
-        else if (event.type === "content_block_stop" && typeof event.index === "number") {
+        if (event.type === "content_block_stop" && typeof event.index === "number") {
             const toolId = this.toolUseIndexToId.get(event.index);
             if (toolId) {
                 this.toolUseIndexToId.delete(event.index);
                 this.toolUseInputBuffers.delete(toolId);
             }
         }
+        return false;
+    }
+    mapPartialEvent(event, options) {
+        if (this.updatePartialEventToolState(event)) {
+            return [];
+        }
         switch (event.type) {
             case "content_block_start":
                 return isClaudeContentChunk(event.content_block)
@@ -2990,18 +3084,7 @@ class ClaudeAgentSession {
         if (!id) {
             return null;
         }
-        const existing = this.toolUseCache.get(id) ??
-            {
-                id,
-                name: typeof block.name === "string" && block.name.length > 0 ? block.name : "tool",
-                server: typeof block.server === "string" && block.server.length > 0
-                    ? block.server
-                    : typeof block.name === "string" && block.name.length > 0
-                        ? block.name
-                        : "tool",
-                classification: "generic",
-                started: false,
-            };
+        const existing = this.toolUseCache.get(id) ?? createDefaultToolUseCacheEntry(id, block);
         if (typeof block.name === "string" && block.name.length > 0) {
             existing.name = block.name;
         }
@@ -3225,37 +3308,47 @@ function normalizeHistoryBlocks(content) {
     }
     return null;
 }
-export function convertClaudeHistoryEntry(entry, mapBlocks) {
+function convertClaudeHistoryEntryPreamble(entry) {
     if (entry.type === "system" && entry.subtype === "compact_boundary") {
         const compactMetadata = readCompactionMetadata(entry);
-        return [
-            {
-                type: "compaction",
-                status: "completed",
-                trigger: compactMetadata?.trigger === "manual" ? "manual" : "auto",
-                preTokens: compactMetadata?.preTokens,
-            },
-        ];
+        return {
+            shortCircuit: [
+                {
+                    type: "compaction",
+                    status: "completed",
+                    trigger: compactMetadata?.trigger === "manual" ? "manual" : "auto",
+                    preTokens: compactMetadata?.preTokens,
+                },
+            ],
+        };
     }
     const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(entry);
     if (taskNotificationItem) {
-        return [taskNotificationItem];
+        return { shortCircuit: [taskNotificationItem] };
     }
     if (entry.isCompactSummary) {
-        return [];
+        return { shortCircuit: [] };
     }
     if (entry.type === "user" && isSyntheticUserEntry(entry)) {
-        return [];
+        return { shortCircuit: [] };
     }
     const message = entry?.message;
     if (!message || !("content" in message)) {
-        return [];
+        return { shortCircuit: [] };
     }
     const content = message.content;
     if ((entry.type === "user" || entry.type === "assistant") &&
         isClaudeTranscriptNoiseContent(content)) {
-        return [];
+        return { shortCircuit: [] };
+    }
+    return { proceed: { content } };
+}
+export function convertClaudeHistoryEntry(entry, mapBlocks) {
+    const preamble = convertClaudeHistoryEntryPreamble(entry);
+    if ("shortCircuit" in preamble) {
+        return preamble.shortCircuit;
     }
+    const { content } = preamble.proceed;
     const normalizedBlocks = normalizeHistoryBlocks(content);
     const contentValue = typeof content === "string" ? content : normalizedBlocks;
     const hasToolBlock = normalizedBlocks?.some((block) => hasToolLikeBlock(block)) ?? false;
@@ -3263,12 +3356,12 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
         ? entry.uuid
         : null;
     if (entry.type === "user") {
-        const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
+        const userTaskNotificationItem = mapTaskNotificationUserContentToToolCall({
             content,
             messageId: userMessageId,
         });
-        if (taskNotificationItem) {
-            return [taskNotificationItem];
+        if (userTaskNotificationItem) {
+            return [userTaskNotificationItem];
         }
     }
     const timeline = [];
@@ -3357,41 +3450,68 @@ async function collectRecentClaudeSessions(root, limit) {
     catch {
         return [];
     }
-    const candidates = [];
-    for (const dirName of projectDirs) {
+    const projectFileLists = await Promise.all(projectDirs.map(async (dirName) => {
         const projectPath = path.join(root, dirName);
-        let stats;
         try {
-            stats = await fsPromises.stat(projectPath);
+            const stats = await fsPromises.stat(projectPath);
+            if (!stats.isDirectory())
+                return { projectPath, files: [] };
+            const files = await fsPromises.readdir(projectPath);
+            return { projectPath, files };
         }
         catch {
-            continue;
+            return { projectPath, files: [] };
         }
-        if (!stats.isDirectory()) {
-            continue;
-        }
-        let files;
+    }));
+    const fileEntries = projectFileLists.flatMap(({ projectPath, files }) => files.filter((f) => f.endsWith(".jsonl")).map((f) => path.join(projectPath, f)));
+    const statResults = await Promise.all(fileEntries.map(async (fullPath) => {
         try {
-            files = await fsPromises.readdir(projectPath);
+            const fileStats = await fsPromises.stat(fullPath);
+            return { path: fullPath, mtime: fileStats.mtime };
         }
         catch {
-            continue;
+            return null;
         }
-        for (const file of files) {
-            if (!file.endsWith(".jsonl")) {
-                continue;
-            }
-            const fullPath = path.join(projectPath, file);
-            try {
-                const fileStats = await fsPromises.stat(fullPath);
-                candidates.push({ path: fullPath, mtime: fileStats.mtime });
-            }
-            catch {
-                // ignore stat errors for individual files
+    }));
+    const candidates = statResults.filter((entry) => entry !== null);
+    return candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(0, limit);
+}
+function isFinishedAccumulator(acc) {
+    return Boolean(acc.sessionId && acc.cwd && acc.title);
+}
+function applyClaudeSessionEntryToAccumulator(entryRaw, acc) {
+    if (!entryRaw || typeof entryRaw !== "object") {
+        return;
+    }
+    const entry = entryRaw;
+    if (entry.isSidechain) {
+        return;
+    }
+    if (entry.type === "user" && isSyntheticUserEntry(entry)) {
+        return;
+    }
+    if (!acc.sessionId && typeof entry.sessionId === "string") {
+        acc.sessionId = entry.sessionId;
+    }
+    if (!acc.cwd && typeof entry.cwd === "string") {
+        acc.cwd = entry.cwd;
+    }
+    if (entry.type === "user" && entry.message) {
+        const text = extractClaudeUserText(entry.message);
+        if (text) {
+            if (!acc.title) {
+                acc.title = text;
             }
+            acc.timeline.push({ type: "user_message", text });
+        }
+        return;
+    }
+    if (entry.type === "assistant" && entry.message) {
+        const text = extractClaudeUserText(entry.message);
+        if (text) {
+            acc.timeline.push({ type: "assistant_message", text });
         }
     }
-    return candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(0, limit);
 }
 async function parseClaudeSessionDescriptor(filePath, mtime) {
     let content;
@@ -3401,10 +3521,12 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
     catch {
         return null;
     }
-    let sessionId = null;
-    let cwd = null;
-    let title = null;
-    const timeline = [];
+    const acc = {
+        sessionId: null,
+        cwd: null,
+        title: null,
+        timeline: [],
+    };
     for (const rawLine of content.split(/\r?\n/)) {
         const line = rawLine.trim();
         if (!line)
@@ -3416,37 +3538,12 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
         catch {
             continue;
         }
-        if (entry?.isSidechain) {
-            continue;
-        }
-        if (entry?.type === "user" && isSyntheticUserEntry(entry)) {
-            continue;
-        }
-        if (!sessionId && typeof entry.sessionId === "string") {
-            sessionId = entry.sessionId;
-        }
-        if (!cwd && typeof entry.cwd === "string") {
-            cwd = entry.cwd;
-        }
-        if (entry.type === "user" && entry.message) {
-            const text = extractClaudeUserText(entry.message);
-            if (text) {
-                if (!title) {
-                    title = text;
-                }
-                timeline.push({ type: "user_message", text });
-            }
-        }
-        else if (entry.type === "assistant" && entry.message) {
-            const text = extractClaudeUserText(entry.message);
-            if (text) {
-                timeline.push({ type: "assistant_message", text });
-            }
-        }
-        if (sessionId && cwd && title) {
+        applyClaudeSessionEntryToAccumulator(entry, acc);
+        if (isFinishedAccumulator(acc)) {
             break;
         }
     }
+    const { sessionId, cwd, title, timeline } = acc;
     if (!sessionId || !cwd) {
         return null;
     }
@@ -3469,10 +3566,11 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
         timeline,
     };
 }
-function extractClaudeUserText(message) {
-    if (!message) {
+function extractClaudeUserText(messageRaw) {
+    if (!messageRaw || typeof messageRaw !== "object") {
         return null;
     }
+    const message = messageRaw;
     if (typeof message.content === "string") {
         const normalized = message.content.trim();
         return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
@@ -3483,7 +3581,9 @@ function extractClaudeUserText(message) {
     }
     if (Array.isArray(message.content)) {
         for (const block of message.content) {
-            if (block && typeof block.text === "string") {
+            if (block &&
+                typeof block === "object" &&
+                typeof block.text === "string") {
                 const normalized = block.text.trim();
                 if (normalized && !isClaudeTranscriptNoiseText(normalized)) {
                     return normalized;