@getpaseo/server 0.1.32 → 0.1.34

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

@@ -6,116 +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 { coerceTaskNotificationHistoryRecordToSystemMessage, mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
-import { buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, listClaudeCatalogModels, } from "./claude/model-catalog.js";
+import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { normalizeClaudeModelIdFromText, resolveClaudeModelsFromSdkModels, } from "./claude/sdk-model-resolver.js";
 import { parsePartialJsonObject } from "./claude/partial-json.js";
 import { ClaudeSidechainTracker } from "./claude/sidechain-tracker.js";
 import { applyProviderEnv } from "../provider-launch-config.js";
 import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
 const fsPromises = promises;
 const CLAUDE_SETTING_SOURCES = ["user", "project"];
-function normalizeModelIdCandidate(modelId) {
-    if (typeof modelId !== "string") {
-        return null;
-    }
-    const trimmed = modelId.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function pickSupportedModelId(supportedModelIds, candidate) {
-    const normalizedCandidate = normalizeModelIdCandidate(candidate);
-    if (!normalizedCandidate) {
-        return null;
-    }
-    return supportedModelIds.has(normalizedCandidate) ? normalizedCandidate : null;
-}
-function inferClaudeModelFamilyFromText(text) {
-    if (typeof text !== "string") {
-        return null;
-    }
-    const lowerText = text.toLowerCase();
-    if (lowerText.includes("sonnet")) {
-        return "sonnet";
-    }
-    if (lowerText.includes("opus")) {
-        return "opus";
-    }
-    if (lowerText.includes("haiku")) {
-        return "haiku";
-    }
-    return null;
-}
-function pickFamilyAliasModelId(familyAliases, family) {
-    if (!familyAliases) {
-        return null;
-    }
-    return normalizeModelIdCandidate(familyAliases.get(family) ?? null);
-}
-export function normalizeClaudeRuntimeModelId(options) {
-    const runtimeModel = options.runtimeModelId.trim();
-    if (!runtimeModel) {
-        return runtimeModel;
-    }
-    const supportedModelIds = options.supportedModelIds;
-    if (!supportedModelIds || supportedModelIds.size === 0) {
-        return runtimeModel;
-    }
-    if (supportedModelIds.has(runtimeModel)) {
-        return runtimeModel;
-    }
-    const runtimeFamily = inferClaudeModelFamilyFromText(runtimeModel);
-    const familyAlias = runtimeFamily
-        ? pickFamilyAliasModelId(options.supportedModelFamilyAliases, runtimeFamily)
-        : null;
-    if (runtimeFamily === "sonnet") {
-        const explicitSonnet = pickSupportedModelId(supportedModelIds, "sonnet");
-        if (explicitSonnet) {
-            return explicitSonnet;
-        }
-        if (familyAlias && supportedModelIds.has(familyAlias)) {
-            return familyAlias;
-        }
-        const defaultAlias = pickSupportedModelId(supportedModelIds, "default");
-        if (defaultAlias) {
-            return defaultAlias;
-        }
-    }
-    if (runtimeFamily === "opus") {
-        const alias = pickSupportedModelId(supportedModelIds, "opus");
-        if (alias) {
-            return alias;
-        }
-        if (familyAlias && supportedModelIds.has(familyAlias)) {
-            return familyAlias;
-        }
-    }
-    if (runtimeFamily === "haiku") {
-        const alias = pickSupportedModelId(supportedModelIds, "haiku");
-        if (alias) {
-            return alias;
-        }
-        if (familyAlias && supportedModelIds.has(familyAlias)) {
-            return familyAlias;
-        }
-    }
-    const configuredModelId = pickSupportedModelId(supportedModelIds, options.configuredModelId);
-    if (configuredModelId) {
-        return configuredModelId;
-    }
-    const currentModelId = pickSupportedModelId(supportedModelIds, options.currentModelId);
-    if (currentModelId) {
-        return currentModelId;
-    }
-    // If Claude reports a concrete family ID we can't map directly, prefer the
-    // provider default alias for unconfigured sessions so UI model/thinking state
-    // can still reconcile against the current model catalog.
-    const defaultAlias = pickSupportedModelId(supportedModelIds, "default");
-    const hasConfiguredModel = normalizeModelIdCandidate(options.configuredModelId) !== null;
-    const hasCurrentModel = normalizeModelIdCandidate(options.currentModelId) !== null;
-    if (runtimeFamily && defaultAlias && !hasConfiguredModel && !hasCurrentModel) {
-        return defaultAlias;
-    }
-    return runtimeModel;
-}
 const CLAUDE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -176,7 +74,7 @@ function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
         args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
     };
 }
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
+function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
     return {
         ...options,
         spawnClaudeCodeProcess: (spawnOptions) => {
@@ -185,16 +83,33 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
             // 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;
-            return spawn(command, resolved.args, {
+            const child = spawn(command, resolved.args, {
                 cwd: spawnOptions.cwd,
-                env: applyProviderEnv(spawnOptions.env, runtimeSettings),
+                env: {
+                    ...applyProviderEnv(spawnOptions.env, runtimeSettings),
+                    ...(launchEnv ?? {}),
+                },
                 signal: spawnOptions.signal,
                 stdio: ["pipe", "pipe", "pipe"],
             });
+            if (typeof options.stderr === "function") {
+                child.stderr?.on("data", (chunk) => {
+                    options.stderr?.(chunk.toString());
+                });
+            }
+            return child;
         },
     };
 }
+function createEmptyClaudePrompt() {
+    return (async function* empty() { })();
+}
+function isClaudeThinkingEffort(value) {
+    return value === "low" || value === "medium" || value === "high" || value === "max";
+}
 const MAX_RECENT_STDERR_CHARS = 4000;
+const STDERR_FLUSH_WAIT_MS = 150;
+const STDERR_FLUSH_POLL_INTERVAL_MS = 10;
 function summarizeClaudeOptionsForLog(options) {
     const systemPromptRaw = options.systemPrompt;
     const systemPromptSummary = (() => {
@@ -792,16 +707,17 @@ export class ClaudeAgentClient {
         this.runtimeSettings = options.runtimeSettings;
         this.queryFactory = options.queryFactory ?? query;
     }
-    async createSession(config) {
+    async createSession(config, launchContext) {
         const claudeConfig = this.assertConfig(config);
         return new ClaudeAgentSession(claudeConfig, {
             defaults: this.defaults,
             runtimeSettings: this.runtimeSettings,
+            launchEnv: launchContext?.env,
             logger: this.logger,
             queryFactory: this.queryFactory,
         });
     }
-    async resumeSession(handle, overrides) {
+    async resumeSession(handle, overrides, launchContext) {
         const metadata = coerceSessionMetadata(handle.metadata);
         const merged = { ...metadata, ...overrides };
         if (!merged.cwd) {
@@ -813,12 +729,37 @@ export class ClaudeAgentClient {
             defaults: this.defaults,
             runtimeSettings: this.runtimeSettings,
             handle,
+            launchEnv: launchContext?.env,
             logger: this.logger,
             queryFactory: this.queryFactory,
         });
     }
-    async listModels(_options) {
-        return listClaudeCatalogModels();
+    async listModels(options) {
+        const claudeQuery = this.queryFactory({
+            prompt: createEmptyClaudePrompt(),
+            options: applyRuntimeSettingsToClaudeOptions({
+                cwd: options?.cwd ?? process.cwd(),
+                permissionMode: "plan",
+                includePartialMessages: false,
+                settingSources: CLAUDE_SETTING_SOURCES,
+            }, this.runtimeSettings),
+        });
+        try {
+            const supportedModels = await claudeQuery.supportedModels();
+            return resolveClaudeModelsFromSdkModels(supportedModels);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to query Claude supportedModels()");
+            throw error;
+        }
+        finally {
+            try {
+                await claudeQuery.return?.();
+            }
+            catch {
+                // ignore control-plane shutdown errors
+            }
+        }
     }
     async listPersistedAgents(options) {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
@@ -865,30 +806,27 @@ class ClaudeAgentSession {
         this.toolUseIndexToId = new Map();
         this.toolUseInputBuffers = new Map();
         this.pendingPermissions = new Map();
-        this.activeForegroundTurn = null;
+        this.activeForegroundTurnId = null;
         this.autonomousTurn = null;
-        this.liveEventQueue = new Pushable();
+        this.subscribers = new Set();
         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.nextTurnOrdinal = 1;
         this.cancelCurrentTurn = null;
-        this.activeTurnPromise = null;
         this.cachedRuntimeInfo = null;
         this.lastOptionsModel = null;
-        this.selectableModelIds = buildClaudeSelectableModelIds();
-        this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases();
+        this.lastRuntimeModel = null;
         this.compacting = false;
         this.queryPumpPromise = null;
         this.queryRestartNeeded = false;
         this.pendingInterruptAbort = false;
+        this.lastForegroundPromptText = null;
+        this.foregroundHasVisibleActivity = false;
         this.userMessageIds = [];
         this.recentStderr = "";
         this.closed = false;
@@ -956,6 +894,7 @@ class ClaudeAgentSession {
             });
         };
         this.config = config;
+        this.launchEnv = options.launchEnv;
         this.defaults = options.defaults;
         this.runtimeSettings = options.runtimeSettings;
         this.logger = options.logger;
@@ -992,16 +931,34 @@ class ClaudeAgentSession {
             sessionId: this.claudeSessionId,
             model: this.lastOptionsModel,
             modeId: this.currentMode ?? null,
+            ...(this.lastRuntimeModel
+                ? {
+                    extra: {
+                        runtimeModel: this.lastRuntimeModel,
+                    },
+                }
+                : {}),
         };
         this.cachedRuntimeInfo = info;
         return { ...info };
     }
     async run(prompt, options) {
-        const events = this.stream(prompt, options);
         const timeline = [];
         let finalText = "";
         let usage;
-        for await (const event of events) {
+        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") {
@@ -1015,14 +972,48 @@ class ClaudeAgentSession {
                         finalText += event.item.text;
                     }
                 }
+                return;
             }
-            else if (event.type === "turn_completed") {
+            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 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);
             }
-            else if (event.type === "turn_failed") {
-                throw new Error(event.error);
+            if (!settled) {
+                await completion;
             }
         }
+        finally {
+            unsubscribe();
+        }
         this.cachedRuntimeInfo = {
             provider: "claude",
             sessionId: this.claudeSessionId,
@@ -1039,35 +1030,32 @@ class ClaudeAgentSession {
             timeline,
         };
     }
-    async *stream(prompt, options) {
-        void options;
-        if (this.cancelCurrentTurn) {
-            this.cancelCurrentTurn();
+    async startTurn(prompt, _options) {
+        if (this.closed) {
+            throw new Error("Claude session is closed");
+        }
+        if (this.activeForegroundTurnId) {
+            throw new Error("A foreground turn is already active");
         }
         const slashCommand = this.resolveSlashCommandInvocation(prompt);
         if (slashCommand?.commandName === REWIND_COMMAND_NAME) {
-            yield* this.streamRewindCommand(slashCommand);
-            return;
+            const turnId = this.createTurnId("foreground");
+            this.activeForegroundTurnId = turnId;
+            this.transitionTurnState("foreground", "rewind command");
+            void this.executeRewindTurn(turnId, slashCommand);
+            return { turnId };
         }
         if (this.autonomousTurn) {
             this.completeAutonomousTurn();
         }
         const sdkMessage = this.toSdkUserMessage(prompt);
-        const queue = new Pushable();
-        const foregroundTurn = {
-            id: this.createTurnId("foreground"),
-            queue,
-            hasVisibleActivity: false,
-        };
-        this.activeForegroundTurn = foregroundTurn;
-        this.transitionTurnState("foreground", "foreground stream started");
+        this.lastForegroundPromptText = this.extractPromptText(prompt);
+        const turnId = this.createTurnId("foreground");
+        this.activeForegroundTurnId = turnId;
+        this.foregroundHasVisibleActivity = false;
+        this.transitionTurnState("foreground", "foreground turn started");
         this.clearRecentStderr();
-        queue.push({ type: "turn_started", provider: "claude" });
-        let finishedNaturally = false;
         let cancelIssued = false;
-        let queueDrainedWithoutTerminal = false;
-        const turnPromise = Promise.resolve();
-        this.activeTurnPromise = turnPromise;
         const requestCancel = () => {
             if (cancelIssued) {
                 return;
@@ -1087,6 +1075,7 @@ class ClaudeAgentSession {
             });
         };
         this.cancelCurrentTurn = requestCancel;
+        this.notifySubscribers({ type: "turn_started", provider: "claude" });
         try {
             await this.ensureQuery();
             if (!this.input) {
@@ -1097,39 +1086,14 @@ class ClaudeAgentSession {
         }
         catch (error) {
             this.finishForegroundTurn(this.buildTurnFailedEvent(error instanceof Error ? error.message : "Claude stream failed"));
-            finishedNaturally = true;
-        }
-        try {
-            for await (const event of queue) {
-                const isTerminalEvent = event.type === "turn_completed" ||
-                    event.type === "turn_failed" ||
-                    event.type === "turn_canceled";
-                if (isTerminalEvent) {
-                    finishedNaturally = true;
-                }
-                yield event;
-                if (isTerminalEvent) {
-                    break;
-                }
-            }
-            if (!finishedNaturally && !cancelIssued) {
-                queueDrainedWithoutTerminal = true;
-            }
-        }
-        finally {
-            if (!finishedNaturally && !cancelIssued && !queueDrainedWithoutTerminal) {
-                requestCancel();
-            }
-            if (this.activeForegroundTurn === foregroundTurn) {
-                this.activeForegroundTurn = null;
-            }
-            if (this.cancelCurrentTurn === requestCancel) {
-                this.cancelCurrentTurn = null;
-            }
-            if (this.activeTurnPromise === turnPromise) {
-                this.activeTurnPromise = null;
-            }
         }
+        return { turnId };
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
     }
     async interrupt() {
         if (this.cancelCurrentTurn) {
@@ -1137,7 +1101,8 @@ class ClaudeAgentSession {
             return;
         }
         if (this.autonomousTurn) {
-            this.cancelAutonomousTurn("Interrupted");
+            this.flushPendingToolCalls();
+            this.completeAutonomousTurn();
         }
         await this.interruptActiveTurn();
     }
@@ -1152,14 +1117,6 @@ class ClaudeAgentSession {
             yield { type: "timeline", item, provider: "claude" };
         }
     }
-    async *streamLiveEvents() {
-        if (this.claudeSessionId) {
-            this.startQueryPump();
-        }
-        for await (const event of this.liveEventQueue) {
-            yield event;
-        }
-    }
     async getAvailableModes() {
         return this.availableModes;
     }
@@ -1183,6 +1140,7 @@ class ClaudeAgentSession {
         await query.setModel(normalizedModelId ?? undefined);
         this.config.model = normalizedModelId ?? undefined;
         this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
+        this.lastRuntimeModel = null;
         this.cachedRuntimeInfo = null;
         // Model change affects persistence metadata, so invalidate cached handle.
         this.persistence = null;
@@ -1194,11 +1152,8 @@ class ClaudeAgentSession {
         if (!normalizedThinkingOptionId || normalizedThinkingOptionId === "default") {
             this.config.thinkingOptionId = undefined;
         }
-        else if (normalizedThinkingOptionId === "on") {
-            this.config.thinkingOptionId = "on";
-        }
-        else if (normalizedThinkingOptionId === "off") {
-            this.config.thinkingOptionId = "off";
+        else if (isClaudeThinkingEffort(normalizedThinkingOptionId)) {
+            this.config.thinkingOptionId = normalizedThinkingOptionId;
         }
         else {
             throw new Error(`Unknown thinking option: ${normalizedThinkingOptionId}`);
@@ -1269,7 +1224,7 @@ class ClaudeAgentSession {
             provider: "claude",
             sessionId: this.claudeSessionId,
             nativeHandle: this.claudeSessionId,
-            metadata: this.config,
+            metadata: { ...this.config },
         };
         return this.persistence;
     }
@@ -1279,20 +1234,19 @@ class ClaudeAgentSession {
             turnState: this.turnState,
             hasQuery: Boolean(this.query),
             hasInput: Boolean(this.input),
-            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
+            hasActiveForegroundTurnId: Boolean(this.activeForegroundTurnId),
         }, "Claude session close: start");
         this.closed = true;
         this.rejectAllPendingPermissions(new Error("Claude session closed"));
         this.cancelCurrentTurn?.();
-        this.activeForegroundTurn?.queue.end();
-        this.activeForegroundTurn = null;
+        this.subscribers.clear();
+        this.activeForegroundTurnId = null;
         this.autonomousTurn = null;
         this.cancelCurrentTurn = null;
         this.turnState = "idle";
-        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;
@@ -1343,37 +1297,6 @@ class ClaudeAgentSession {
             ? { commandName, args: rawArgs, rawInput: trimmed }
             : { commandName, rawInput: trimmed };
     }
-    async *streamRewindCommand(invocation) {
-        yield { type: "turn_started", provider: "claude" };
-        try {
-            const rewindAttempt = await this.attemptRewind(invocation.args);
-            if (!rewindAttempt.messageId || !rewindAttempt.result) {
-                yield {
-                    type: "turn_failed",
-                    provider: "claude",
-                    error: rewindAttempt.error ??
-                        "No prior user message available to rewind. Use /rewind <user_message_uuid>.",
-                };
-                return;
-            }
-            yield {
-                type: "timeline",
-                provider: "claude",
-                item: {
-                    type: "assistant_message",
-                    text: this.buildRewindSuccessMessage(rewindAttempt.messageId, rewindAttempt.result),
-                },
-            };
-            yield { type: "turn_completed", provider: "claude" };
-        }
-        catch (error) {
-            yield {
-                type: "turn_failed",
-                provider: "claude",
-                error: error instanceof Error ? error.message : "Failed to rewind tracked files",
-            };
-        }
-    }
     buildRewindSuccessMessage(targetUserMessageId, rewindResult) {
         const fileCount = Array.isArray(rewindResult.filesChanged)
             ? rewindResult.filesChanged.length
@@ -1524,22 +1447,28 @@ class ClaudeAgentSession {
             return this.query;
         }
         if (this.queryRestartNeeded && this.query) {
-            this.input?.end();
+            const oldQuery = this.query;
+            const oldInput = this.input;
+            // Null out query/input BEFORE awaiting the old iterator's return so the
+            // old pump sees this.query !== activeQuery and skips failActiveTurns.
+            this.query = null;
+            this.input = null;
+            this.queryPumpPromise = null;
+            this.queryRestartNeeded = false;
+            oldInput?.end();
+            oldQuery.close?.();
             try {
-                await this.query.return?.();
+                await oldQuery.return?.();
             }
             catch {
                 /* ignore */
             }
-            this.query = null;
-            this.input = null;
-            this.queryRestartNeeded = false;
         }
-        const input = new Pushable();
+        const input = createAsyncMessageInput();
         const options = this.buildOptions();
         this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
         this.input = input;
-        this.query = this.queryFactory({ prompt: input, options });
+        this.query = this.queryFactory({ prompt: input.iterable, options });
         // Do not kick off background control-plane queries here. Methods like
         // supportedCommands()/setPermissionMode() may execute immediately after
         // ensureQuery() (for listCommands()/setMode()), and sharing the same query
@@ -1567,16 +1496,14 @@ class ClaudeAgentSession {
         }
     }
     buildOptions() {
-        const configuredThinkingOptionId = this.config.thinkingOptionId;
-        const thinkingOptionId = configuredThinkingOptionId && configuredThinkingOptionId !== "default"
-            ? configuredThinkingOptionId
-            : "off";
-        let maxThinkingTokens;
-        if (thinkingOptionId === "on") {
-            maxThinkingTokens = 10000;
-        }
-        else if (thinkingOptionId === "off") {
-            maxThinkingTokens = 0;
+        const thinkingOptionId = this.config.thinkingOptionId && this.config.thinkingOptionId !== "default"
+            ? this.config.thinkingOptionId
+            : undefined;
+        let thinking;
+        let effort;
+        if (thinkingOptionId && isClaudeThinkingEffort(thinkingOptionId)) {
+            thinking = { type: "adaptive" };
+            effort = thinkingOptionId;
         }
         const appendedSystemPrompt = [
             getOrchestratorModeInstructions(),
@@ -1607,13 +1534,15 @@ class ClaudeAgentSession {
                 // 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),
             // resume that session to continue the conversation history.
             ...(this.claudeSessionId ? { resume: this.claudeSessionId } : {}),
-            ...(maxThinkingTokens !== undefined ? { maxThinkingTokens } : {}),
+            ...(thinking ? { thinking } : {}),
+            ...(effort ? { effort } : {}),
             ...this.config.extra?.claude,
         };
         if (this.config.mcpServers) {
@@ -1629,7 +1558,7 @@ class ClaudeAgentSession {
         return this.applyRuntimeSettings(base);
     }
     applyRuntimeSettings(options) {
-        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings);
+        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings, this.launchEnv);
     }
     normalizeMcpServers(servers) {
         const result = {};
@@ -1681,7 +1610,7 @@ class ClaudeAgentSession {
         this.turnState = next;
     }
     syncTurnState(reason) {
-        if (this.activeForegroundTurn) {
+        if (this.activeForegroundTurnId) {
             this.transitionTurnState("foreground", reason);
             return;
         }
@@ -1691,6 +1620,10 @@ class ClaudeAgentSession {
         }
         this.transitionTurnState("idle", reason);
     }
+    isAbortError(message) {
+        const errors = "errors" in message && Array.isArray(message.errors) ? message.errors : [];
+        return errors.some((e) => /\baborted\b/i.test(e));
+    }
     buildTurnFailedEvent(errorMessage) {
         const normalized = errorMessage.trim() || "Claude run failed";
         const exitCodeMatch = normalized.match(/\bcode\s+(\d+)\b/i);
@@ -1718,6 +1651,22 @@ class ClaudeAgentSession {
     getRecentStderrDiagnostic() {
         return this.recentStderr.trim() || undefined;
     }
+    async awaitRecentStderrAfterProcessExit(error) {
+        if (this.getRecentStderrDiagnostic()) {
+            return;
+        }
+        const message = typeof error === "string" ? error : error instanceof Error ? error.message : "";
+        if (!/\bprocess exited with code\b/i.test(message) && !/\bterminated by signal\b/i.test(message)) {
+            return;
+        }
+        const startedAt = Date.now();
+        while (!this.closed && !this.getRecentStderrDiagnostic()) {
+            if (Date.now() - startedAt >= STDERR_FLUSH_WAIT_MS) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, STDERR_FLUSH_POLL_INTERVAL_MS));
+        }
+    }
     createTurnId(owner) {
         return `${owner}-turn-${this.nextTurnOrdinal++}`;
     }
@@ -1726,6 +1675,46 @@ class ClaudeAgentSession {
             event.type === "turn_failed" ||
             event.type === "turn_canceled");
     }
+    extractPromptText(prompt) {
+        if (typeof prompt === "string") {
+            return prompt;
+        }
+        const textParts = prompt
+            .filter((block) => block.type === "text")
+            .map((block) => block.text);
+        return textParts.length > 0 ? textParts.join("\n") : null;
+    }
+    async executeRewindTurn(_turnId, invocation) {
+        this.notifySubscribers({ type: "turn_started", provider: "claude" });
+        try {
+            const rewindAttempt = await this.attemptRewind(invocation.args);
+            if (!rewindAttempt.messageId || !rewindAttempt.result) {
+                this.finishForegroundTurn({
+                    type: "turn_failed",
+                    provider: "claude",
+                    error: rewindAttempt.error ??
+                        "No prior user message available to rewind. Use /rewind <user_message_uuid>.",
+                });
+                return;
+            }
+            this.notifySubscribers({
+                type: "timeline",
+                provider: "claude",
+                item: {
+                    type: "assistant_message",
+                    text: this.buildRewindSuccessMessage(rewindAttempt.messageId, rewindAttempt.result),
+                },
+            });
+            this.finishForegroundTurn({ type: "turn_completed", provider: "claude" });
+        }
+        catch (error) {
+            this.finishForegroundTurn({
+                type: "turn_failed",
+                provider: "claude",
+                error: error instanceof Error ? error.message : "Failed to rewind tracked files",
+            });
+        }
+    }
     shouldRecoverInterruptedQueryAbort(error, consecutiveRecoveries) {
         if (consecutiveRecoveries >= 3) {
             return false;
@@ -1741,37 +1730,29 @@ class ClaudeAgentSession {
         if (event.type === "turn_failed" || event.type === "turn_canceled") {
             this.flushPendingToolCalls();
         }
-        this.dispatchForegroundEvents([event]);
-    }
-    dispatchForegroundEvents(events) {
-        const foregroundTurn = this.activeForegroundTurn;
-        if (!foregroundTurn) {
-            this.dispatchLiveEvents(events);
-            return;
-        }
-        let terminalSeen = false;
-        for (const event of events) {
-            foregroundTurn.queue.push(event);
-            terminalSeen || (terminalSeen = this.isTerminalTurnEvent(event));
-        }
-        if (!terminalSeen) {
-            return;
-        }
-        foregroundTurn.queue.end();
-        if (this.activeForegroundTurn === foregroundTurn) {
-            this.activeForegroundTurn = null;
-        }
+        this.notifySubscribers(event);
+        this.activeForegroundTurnId = null;
+        this.lastForegroundPromptText = null;
+        this.cancelCurrentTurn = null;
         this.syncTurnState("foreground turn terminal");
     }
-    dispatchLiveEvents(events) {
+    dispatchEvents(events) {
         let terminalSeen = false;
         for (const event of events) {
-            this.liveEventQueue.push(event);
+            this.notifySubscribers(event);
             terminalSeen || (terminalSeen = this.isTerminalTurnEvent(event));
         }
-        if (terminalSeen && this.autonomousTurn) {
-            this.autonomousTurn = null;
-            this.syncTurnState("autonomous turn terminal");
+        if (terminalSeen) {
+            if (this.activeForegroundTurnId) {
+                this.activeForegroundTurnId = null;
+                this.lastForegroundPromptText = null;
+                this.cancelCurrentTurn = null;
+                this.syncTurnState("foreground turn terminal");
+            }
+            else if (this.autonomousTurn) {
+                this.autonomousTurn = null;
+                this.syncTurnState("autonomous turn terminal");
+            }
         }
     }
     startAutonomousTurn() {
@@ -1781,40 +1762,26 @@ class ClaudeAgentSession {
         this.autonomousTurn = {
             id: this.createTurnId("autonomous"),
         };
-        this.liveEventQueue.push({ type: "turn_started", provider: "claude" });
+        this.notifySubscribers({ type: "turn_started", provider: "claude" });
         this.syncTurnState("autonomous turn started");
     }
     completeAutonomousTurn() {
         if (!this.autonomousTurn) {
             return;
         }
+        this.notifySubscribers({ type: "turn_completed", provider: "claude" });
         this.autonomousTurn = null;
-        this.liveEventQueue.push({ type: "turn_completed", provider: "claude" });
         this.syncTurnState("autonomous turn completed");
     }
-    cancelAutonomousTurn(reason) {
-        if (!this.autonomousTurn) {
-            return;
-        }
-        this.flushPendingToolCalls();
-        this.autonomousTurn = null;
-        this.liveEventQueue.push({
-            type: "turn_canceled",
-            provider: "claude",
-            reason,
-        });
-        this.syncTurnState("autonomous turn canceled");
-    }
     failActiveTurns(errorMessage) {
         const failure = this.buildTurnFailedEvent(errorMessage);
-        if (this.activeForegroundTurn) {
-            this.flushPendingToolCalls();
-            this.dispatchForegroundEvents([failure]);
+        this.flushPendingToolCalls();
+        if (this.activeForegroundTurnId) {
+            this.finishForegroundTurn(failure);
             return;
         }
         if (this.autonomousTurn) {
-            this.flushPendingToolCalls();
-            this.dispatchLiveEvents([failure]);
+            this.dispatchEvents([failure]);
         }
     }
     startQueryPump() {
@@ -1846,6 +1813,12 @@ class ClaudeAgentSession {
             while (!this.closed && this.query === activeQuery) {
                 try {
                     for await (const message of activeQuery) {
+                        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;
@@ -1866,6 +1839,7 @@ class ClaudeAgentSession {
                         continue;
                     }
                     if (!this.closed && this.query === activeQuery) {
+                        await this.awaitRecentStderrAfterProcessExit(error);
                         this.failActiveTurns(error instanceof Error ? error.message : "Claude stream failed");
                     }
                     return;
@@ -1880,24 +1854,40 @@ class ClaudeAgentSession {
         }
     }
     routeSdkMessageFromPump(message) {
-        const routeToForeground = Boolean(this.activeForegroundTurn);
+        // 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.
+        if (message.type === "result" && this.pendingInterruptAbort) {
+            this.pendingInterruptAbort = false;
+            if (message.subtype !== "success") {
+                this.logger.debug("Suppressing stale non-success result from interrupted request");
+                return;
+            }
+        }
+        if (message.type === "result" &&
+            message.subtype !== "success" &&
+            this.isAbortError(message)) {
+            this.logger.debug("Suppressing abort result by content");
+            return;
+        }
+        const isForeground = Boolean(this.activeForegroundTurnId);
         const assistantishMessage = message.type === "assistant" ||
             message.type === "stream_event" ||
-            message.type === "tool_progress";
-        if (!routeToForeground && assistantishMessage) {
+            message.type === "tool_progress" ||
+            (message.type === "system" && message.subtype === "task_notification");
+        if (!isForeground && assistantishMessage) {
             this.startAutonomousTurn();
         }
-        if (!routeToForeground && !this.autonomousTurn && message.type === "result") {
+        if (!isForeground && !this.autonomousTurn && message.type === "result") {
             return;
         }
-        const turnId = this.activeForegroundTurn?.id ?? this.autonomousTurn?.id ?? null;
+        const turnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? null;
         const identifiers = readEventIdentifiers(message);
         this.logger.trace({
             claudeSessionId: this.claudeSessionId,
             messageType: message.type,
-            routedTo: routeToForeground ? "foreground_queue" : "live_queue",
             turnId,
-        }, "Claude query pump routed SDK message");
+        }, "Claude query pump: SDK message");
         const messageEvents = this.translateMessageToEvents(message, {
             suppressAssistantText: true,
             suppressReasoning: true,
@@ -1913,30 +1903,37 @@ class ClaudeAgentSession {
             item,
             provider: "claude",
         }));
-        const events = [...messageEvents, ...assistantTimelineEvents];
+        // 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 events = [...filteredMessageEvents, ...assistantTimelineEvents];
         if (events.length === 0) {
             return;
         }
         if (this.pendingInterruptAbort &&
             message.type === "result" &&
             events.some((event) => event.type === "turn_completed" || event.type === "turn_failed") &&
-            (!this.activeForegroundTurn || !this.activeForegroundTurn.hasVisibleActivity)) {
+            (!this.activeForegroundTurnId || !this.foregroundHasVisibleActivity)) {
             this.pendingInterruptAbort = false;
             this.logger.debug("Suppressing stale Claude interrupt terminal result");
             return;
         }
-        if (this.activeForegroundTurn &&
+        if (this.activeForegroundTurnId &&
             events.some((event) => event.type === "timeline" ||
                 event.type === "permission_requested" ||
                 event.type === "permission_resolved")) {
-            this.activeForegroundTurn.hasVisibleActivity = true;
-            this.pendingInterruptAbort = false;
+            this.foregroundHasVisibleActivity = true;
         }
-        if (routeToForeground) {
-            this.dispatchForegroundEvents(events);
-            return;
-        }
-        this.dispatchLiveEvents(events);
+        this.dispatchEvents(events);
     }
     async handleMissingResumedConversation(message, query) {
         const staleResumeError = this.readMissingResumedConversationError(message);
@@ -1958,13 +1955,10 @@ 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.activeForegroundTurnId = null;
         this.syncTurnState("missing resumed conversation");
         return true;
     }
@@ -2197,15 +2191,15 @@ class ClaudeAgentSession {
         this.currentMode = message.permissionMode;
         this.persistence = null;
         if (message.model) {
-            const normalizedModel = normalizeClaudeRuntimeModelId({
-                runtimeModelId: message.model,
-                supportedModelIds: this.selectableModelIds,
-                supportedModelFamilyAliases: this.selectableModelFamilyAliases,
-                configuredModelId: this.config.model ?? null,
-                currentModelId: this.lastOptionsModel,
-            });
-            this.logger.debug({ model: message.model, normalizedModel }, "Captured model from SDK init");
-            this.lastOptionsModel = normalizedModel;
+            const normalizedRuntimeModel = normalizeClaudeModelIdFromText(message.model);
+            this.logger.debug({ runtimeModel: message.model, normalizedRuntimeModel }, "Captured runtime model from SDK init");
+            if (normalizedRuntimeModel) {
+                this.lastOptionsModel = normalizedRuntimeModel;
+            }
+            else if (!this.lastOptionsModel) {
+                this.lastOptionsModel = this.config.model ?? null;
+            }
+            this.lastRuntimeModel = message.model;
             this.cachedRuntimeInfo = null;
         }
         return threadStartedSessionId;
@@ -2271,12 +2265,19 @@ class ClaudeAgentSession {
         this.enqueueTimeline(item);
     }
     pushEvent(event) {
-        const foregroundTurn = this.activeForegroundTurn;
-        if (foregroundTurn) {
-            foregroundTurn.queue.push(event);
-            return;
+        this.notifySubscribers(event);
+    }
+    notifySubscribers(event) {
+        const turnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id;
+        const tagged = turnId ? { ...event, turnId } : event;
+        for (const callback of this.subscribers) {
+            try {
+                callback(tagged);
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Subscriber callback threw");
+            }
         }
-        this.liveEventQueue.push(event);
     }
     normalizePermissionUpdates(updates) {
         if (!updates || updates.length === 0) {
@@ -2292,123 +2293,52 @@ class ClaudeAgentSession {
             this.pendingPermissions.delete(id);
         }
     }
-    loadPersistedHistory(sessionId, options) {
+    loadPersistedHistory(sessionId) {
         try {
             const historyPath = this.resolveHistoryPath(sessionId);
             if (!historyPath || !fs.existsSync(historyPath)) {
                 return;
             }
-            if (this.historyOffsetSessionId !== sessionId) {
-                this.historyOffsetSessionId = sessionId;
-                this.historyReadOffsetBytes = 0;
-                this.historyLineFragment = "";
-            }
-            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,
-            });
+            this.ingestPersistedHistory(fs.readFileSync(historyPath, "utf8"));
         }
         catch (error) {
             // ignore history load failures
         }
     }
-    ingestPersistedHistoryChunk(chunk, options) {
-        if (!chunk) {
+    ingestPersistedHistory(content) {
+        if (!content) {
             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,
-            });
+        for (const line of content.split(/\r?\n/)) {
+            this.ingestPersistedHistoryLine(line, 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) {
+        if (timeline.length > 0) {
             this.persistedHistory = [...this.persistedHistory, ...timeline];
             this.historyPending = true;
         }
     }
-    ingestPersistedHistoryLine(line, options) {
+    ingestPersistedHistoryLine(line, timeline) {
         const trimmed = line.trim();
         if (!trimmed) {
-            return true;
+            return;
         }
         let entry;
         try {
             entry = JSON.parse(trimmed);
         }
         catch {
-            return false;
+            return;
         }
         if (entry.isSidechain) {
-            return true;
+            return;
         }
         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;
+            timeline.push(...items);
         }
     }
     resolveHistoryPath(sessionId) {
@@ -3016,49 +2946,50 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
     }
     return timeline;
 }
-class Pushable {
-    constructor() {
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
-    }
-    push(item) {
-        if (this.closed) {
-            return;
-        }
-        if (this.resolvers.length > 0) {
-            const resolve = this.resolvers.shift();
-            resolve({ value: item, done: false });
-        }
-        else {
-            this.queue.push(item);
-        }
-    }
-    end() {
-        this.closed = true;
-        while (this.resolvers.length > 0) {
-            const resolve = this.resolvers.shift();
-            resolve({ value: undefined, done: true });
-        }
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    const value = this.queue.shift();
-                    if (value !== undefined) {
-                        return Promise.resolve({ value, done: false });
-                    }
-                }
-                if (this.closed) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise((resolve) => {
-                    this.resolvers.push(resolve);
-                });
+function createAsyncMessageInput() {
+    const queue = [];
+    const resolvers = [];
+    let closed = false;
+    return {
+        push(item) {
+            if (closed) {
+                return;
+            }
+            const resolve = resolvers.shift();
+            if (resolve) {
+                resolve({ value: item, done: false });
+                return;
+            }
+            queue.push(item);
+        },
+        end() {
+            closed = true;
+            while (resolvers.length > 0) {
+                const resolve = resolvers.shift();
+                resolve?.({ value: undefined, done: true });
+            }
+        },
+        iterable: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => {
+                        if (queue.length > 0) {
+                            const value = queue.shift();
+                            if (value !== undefined) {
+                                return Promise.resolve({ value, done: false });
+                            }
+                        }
+                        if (closed) {
+                            return Promise.resolve({ value: undefined, done: true });
+                        }
+                        return new Promise((resolve) => {
+                            resolvers.push(resolve);
+                        });
+                    },
+                };
             },
-        };
-    }
+        },
+    };
 }
 async function pathExists(target) {
     try {