@getpaseo/server 0.1.16 → 0.1.18

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

@@ -0,0 +1,3750 @@
+import { execSync, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { promises } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
+import { isTaskNotificationUserContent, mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, listClaudeCatalogModels, } from "./claude/model-catalog.js";
+import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
+import { applyProviderEnv, isProviderCommandAvailable, } 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,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+};
+const DEFAULT_MODES = [
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Prompts for permission the first time a tool is used",
+    },
+    {
+        id: "acceptEdits",
+        label: "Accept File Edits",
+        description: "Automatically approves edit-focused tools without prompting",
+    },
+    {
+        id: "plan",
+        label: "Plan Mode",
+        description: "Analyze the codebase without executing tools or edits",
+    },
+    {
+        id: "bypassPermissions",
+        label: "Bypass",
+        description: "Skip all permission prompts (use with caution)",
+    },
+];
+const VALID_CLAUDE_MODES = new Set(DEFAULT_MODES.map((mode) => mode.id));
+const REWIND_COMMAND_NAME = "rewind";
+const REWIND_COMMAND = {
+    name: REWIND_COMMAND_NAME,
+    description: "Rewind tracked files to a previous user message",
+    argumentHint: "[user_message_uuid]",
+};
+const INTERRUPT_TOOL_USE_PLACEHOLDER = "[Request interrupted by user for tool use]";
+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 resolveClaudeBinary() {
+    try {
+        const claudePath = execSync("which claude", { encoding: "utf8" }).trim();
+        if (claudePath) {
+            return claudePath;
+        }
+    }
+    catch {
+        // fall through
+    }
+    throw new Error("Claude CLI not found. Install claude or configure agents.providers.claude.command.mode='replace'.");
+}
+function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
+    const commandConfig = runtimeSettings?.command;
+    if (!commandConfig || commandConfig.mode === "default") {
+        return {
+            command: spawnOptions.command,
+            args: [...spawnOptions.args],
+        };
+    }
+    if (commandConfig.mode === "append") {
+        return {
+            command: spawnOptions.command,
+            args: [...(commandConfig.args ?? []), ...spawnOptions.args],
+        };
+    }
+    return {
+        command: commandConfig.argv[0],
+        args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
+    };
+}
+function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
+    const hasEnvOverrides = Object.keys(runtimeSettings?.env ?? {}).length > 0;
+    const commandMode = runtimeSettings?.command?.mode;
+    const needsCustomSpawn = hasEnvOverrides || commandMode === "append" || commandMode === "replace";
+    if (!needsCustomSpawn) {
+        return options;
+    }
+    return {
+        ...options,
+        spawnClaudeCodeProcess: (spawnOptions) => {
+            const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
+            return spawn(resolved.command, resolved.args, {
+                cwd: spawnOptions.cwd,
+                env: applyProviderEnv(spawnOptions.env, runtimeSettings),
+                signal: spawnOptions.signal,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        },
+    };
+}
+const MAX_RECENT_STDERR_CHARS = 4000;
+function summarizeClaudeOptionsForLog(options) {
+    const systemPromptRaw = options.systemPrompt;
+    const systemPromptSummary = (() => {
+        if (!systemPromptRaw) {
+            return { mode: "none", preset: null };
+        }
+        if (typeof systemPromptRaw === "string") {
+            return { mode: "string", preset: null };
+        }
+        const prompt = systemPromptRaw;
+        const promptType = typeof prompt.type === "string" ? prompt.type : "custom";
+        return {
+            mode: promptType === "preset"
+                ? "preset"
+                : "custom",
+            preset: typeof prompt.preset === "string" && prompt.preset.length > 0
+                ? prompt.preset
+                : null,
+        };
+    })();
+    const mcpServerNames = options.mcpServers
+        ? Object.keys(options.mcpServers).sort()
+        : [];
+    return {
+        cwd: typeof options.cwd === "string" ? options.cwd : null,
+        permissionMode: typeof options.permissionMode === "string"
+            ? options.permissionMode
+            : null,
+        model: typeof options.model === "string" ? options.model : null,
+        includePartialMessages: options.includePartialMessages === true,
+        settingSources: Array.isArray(options.settingSources)
+            ? options.settingSources
+            : [],
+        enableFileCheckpointing: options.enableFileCheckpointing === true,
+        hasResume: typeof options.resume === "string" && options.resume.length > 0,
+        maxThinkingTokens: typeof options.maxThinkingTokens === "number"
+            ? options.maxThinkingTokens
+            : null,
+        hasEnv: !!options.env,
+        envKeyCount: Object.keys(options.env ?? {}).length,
+        hasMcpServers: mcpServerNames.length > 0,
+        mcpServerNames,
+        systemPromptMode: systemPromptSummary.mode,
+        systemPromptPreset: systemPromptSummary.preset,
+        hasCanUseTool: typeof options.canUseTool === "function",
+        hasSpawnOverride: typeof options.spawnClaudeCodeProcess === "function",
+        hasStderrHandler: typeof options.stderr === "function",
+    };
+}
+function isToolResultTextBlock(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        value.type === "text" &&
+        typeof value.text === "string");
+}
+function normalizeForDeterministicString(value, seen) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (typeof value === "function") {
+        return "[function]";
+    }
+    if (typeof value === "symbol") {
+        return value.toString();
+    }
+    if (typeof value === "undefined") {
+        return "[undefined]";
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeForDeterministicString(entry, seen));
+    }
+    if (typeof value === "object") {
+        const objectValue = value;
+        if (seen.has(objectValue)) {
+            return "[circular]";
+        }
+        seen.add(objectValue);
+        const record = value;
+        const normalized = {};
+        for (const key of Object.keys(record).sort()) {
+            normalized[key] = normalizeForDeterministicString(record[key], seen);
+        }
+        seen.delete(objectValue);
+        return normalized;
+    }
+    return String(value);
+}
+function deterministicStringify(value) {
+    if (typeof value === "undefined") {
+        return "";
+    }
+    try {
+        const normalized = normalizeForDeterministicString(value, new WeakSet());
+        if (typeof normalized === "string") {
+            return normalized;
+        }
+        return JSON.stringify(normalized);
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return "[unserializable]";
+        }
+    }
+}
+function coerceToolResultContentToString(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content) && content.every((block) => isToolResultTextBlock(block))) {
+        return content.map((block) => block.text).join("");
+    }
+    return deterministicStringify(content);
+}
+export function extractUserMessageText(content) {
+    if (typeof content === "string") {
+        const normalized = content.trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            continue;
+        }
+        const text = typeof block.text === "string" ? block.text : undefined;
+        if (text && text.trim()) {
+            parts.push(text.trim());
+            continue;
+        }
+        const input = typeof block.input === "string" ? block.input : undefined;
+        if (input && input.trim()) {
+            parts.push(input.trim());
+        }
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    const combined = parts.join("\n\n").trim();
+    return combined.length > 0 ? combined : null;
+}
+const MAX_SUB_AGENT_LOG_ENTRIES = 200;
+const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
+function isMetadata(value) {
+    return typeof value === "object" && value !== null;
+}
+function readTrimmedString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isMcpServerConfig(value) {
+    if (!isMetadata(value)) {
+        return false;
+    }
+    const type = value.type;
+    if (type === "stdio") {
+        return typeof value.command === "string";
+    }
+    if (type === "http" || type === "sse") {
+        return typeof value.url === "string";
+    }
+    return false;
+}
+function isMcpServersRecord(value) {
+    if (!isMetadata(value)) {
+        return false;
+    }
+    for (const config of Object.values(value)) {
+        if (!isMcpServerConfig(config)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPermissionMode(value) {
+    return typeof value === "string" && VALID_CLAUDE_MODES.has(value);
+}
+function coerceSessionMetadata(metadata) {
+    if (!isMetadata(metadata)) {
+        return {};
+    }
+    const result = {};
+    if (metadata.provider === "claude" || metadata.provider === "codex") {
+        result.provider = metadata.provider;
+    }
+    if (typeof metadata.cwd === "string") {
+        result.cwd = metadata.cwd;
+    }
+    if (typeof metadata.modeId === "string") {
+        result.modeId = metadata.modeId;
+    }
+    if (typeof metadata.model === "string") {
+        result.model = metadata.model;
+    }
+    if (typeof metadata.title === "string" || metadata.title === null) {
+        result.title = metadata.title;
+    }
+    if (typeof metadata.approvalPolicy === "string") {
+        result.approvalPolicy = metadata.approvalPolicy;
+    }
+    if (typeof metadata.sandboxMode === "string") {
+        result.sandboxMode = metadata.sandboxMode;
+    }
+    if (typeof metadata.networkAccess === "boolean") {
+        result.networkAccess = metadata.networkAccess;
+    }
+    if (typeof metadata.webSearch === "boolean") {
+        result.webSearch = metadata.webSearch;
+    }
+    if (isMetadata(metadata.extra)) {
+        const extra = {};
+        if (isMetadata(metadata.extra.codex)) {
+            extra.codex = metadata.extra.codex;
+        }
+        if (isClaudeExtra(metadata.extra.claude)) {
+            extra.claude = metadata.extra.claude;
+        }
+        if (extra.codex || extra.claude) {
+            result.extra = extra;
+        }
+    }
+    if (typeof metadata.systemPrompt === "string") {
+        result.systemPrompt = metadata.systemPrompt;
+    }
+    if (isMcpServersRecord(metadata.mcpServers)) {
+        result.mcpServers = metadata.mcpServers;
+    }
+    return result;
+}
+function toClaudeSdkMcpConfig(config) {
+    switch (config.type) {
+        case "stdio":
+            return {
+                type: "stdio",
+                command: config.command,
+                args: config.args,
+                env: config.env,
+            };
+        case "http":
+            return {
+                type: "http",
+                url: config.url,
+                headers: config.headers,
+            };
+        case "sse":
+            return {
+                type: "sse",
+                url: config.url,
+                headers: config.headers,
+            };
+    }
+}
+function isClaudeContentChunk(value) {
+    return isMetadata(value) && typeof value.type === "string";
+}
+function isClaudeExtra(value) {
+    return isMetadata(value);
+}
+function isPermissionUpdate(value) {
+    if (!isMetadata(value)) {
+        return false;
+    }
+    const type = value.type;
+    if (type !== "addRules" && type !== "replaceRules" && type !== "removeRules") {
+        return false;
+    }
+    const rules = value.rules;
+    const behavior = value.behavior;
+    const destination = value.destination;
+    return Array.isArray(rules) && typeof behavior === "string" && typeof destination === "string";
+}
+function resolvePermissionKind(toolName, input) {
+    if (toolName === "ExitPlanMode")
+        return "plan";
+    if (toolName === "AskUserQuestion" && Array.isArray(input.questions)) {
+        return "question";
+    }
+    return "tool";
+}
+const ACTIVE_RUN_STATES = new Set([
+    "queued",
+    "awaiting_response",
+    "streaming",
+    "finalizing",
+]);
+class RunTracker {
+    constructor() {
+        this.runs = new Map();
+        this.runByTaskId = new Map();
+        this.runByParentMessageId = new Map();
+        this.runByMessageId = new Map();
+    }
+    createRun(input) {
+        const run = {
+            id: input.id,
+            owner: input.owner,
+            queue: input.queue,
+            state: "queued",
+            promptReplaySeen: input.promptReplaySeen ?? true,
+            taskIds: new Set(),
+            parentMessageIds: new Set(),
+            messageIds: new Set(),
+        };
+        this.runs.set(run.id, run);
+        return run;
+    }
+    getRun(runId) {
+        return this.runs.get(runId) ?? null;
+    }
+    getForegroundRun() {
+        for (const run of this.runs.values()) {
+            if (run.owner === "foreground" && this.isActive(run.state)) {
+                return run;
+            }
+        }
+        return null;
+    }
+    listActiveRuns(owner) {
+        const runs = [];
+        for (const run of this.runs.values()) {
+            if (!this.isActive(run.state)) {
+                continue;
+            }
+            if (owner && run.owner !== owner) {
+                continue;
+            }
+            runs.push(run);
+        }
+        return runs;
+    }
+    hasActiveRuns(owner) {
+        for (const run of this.runs.values()) {
+            if (!this.isActive(run.state)) {
+                continue;
+            }
+            if (owner && run.owner !== owner) {
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+    getLatestActiveRun(owner) {
+        let latest = null;
+        for (const run of this.runs.values()) {
+            if (!this.isActive(run.state)) {
+                continue;
+            }
+            if (owner && run.owner !== owner) {
+                continue;
+            }
+            latest = run;
+        }
+        return latest;
+    }
+    isRunActive(run) {
+        if (!run) {
+            return false;
+        }
+        return this.isActive(run.state);
+    }
+    resolveByIdentifiers(identifiers) {
+        if (identifiers.taskId) {
+            const run = this.resolveMappedRun(this.runByTaskId, identifiers.taskId);
+            if (run) {
+                return { run, reason: "task_id" };
+            }
+        }
+        if (identifiers.parentMessageId) {
+            const run = this.resolveMappedRun(this.runByParentMessageId, identifiers.parentMessageId);
+            if (run) {
+                return { run, reason: "parent_message_id" };
+            }
+        }
+        if (identifiers.messageId) {
+            const run = this.resolveMappedRun(this.runByMessageId, identifiers.messageId);
+            if (run) {
+                return { run, reason: "message_id" };
+            }
+        }
+        return { run: null, reason: "metadata" };
+    }
+    bindIdentifiers(run, identifiers) {
+        if (identifiers.taskId) {
+            run.taskIds.add(identifiers.taskId);
+            this.runByTaskId.set(identifiers.taskId, run.id);
+        }
+        if (identifiers.parentMessageId) {
+            run.parentMessageIds.add(identifiers.parentMessageId);
+            this.runByParentMessageId.set(identifiers.parentMessageId, run.id);
+        }
+        if (identifiers.messageId) {
+            run.messageIds.add(identifiers.messageId);
+            this.runByMessageId.set(identifiers.messageId, run.id);
+        }
+    }
+    transition(run, nextState) {
+        run.state = nextState;
+    }
+    complete(run, terminalState) {
+        run.state = terminalState;
+        this.clearRunIndex(run);
+    }
+    deriveLifecycle(pendingPermissionCount) {
+        for (const run of this.runs.values()) {
+            if (this.isActive(run.state)) {
+                return "running";
+            }
+        }
+        if (pendingPermissionCount > 0) {
+            return "permission";
+        }
+        for (const run of this.runs.values()) {
+            if (run.state === "error") {
+                return "error";
+            }
+        }
+        return "idle";
+    }
+    resolveMappedRun(mapping, identifier) {
+        const runId = mapping.get(identifier);
+        if (!runId) {
+            return null;
+        }
+        const run = this.runs.get(runId);
+        if (!run || !this.isActive(run.state)) {
+            mapping.delete(identifier);
+            return null;
+        }
+        return run;
+    }
+    clearRunIndex(run) {
+        for (const taskId of run.taskIds) {
+            this.runByTaskId.delete(taskId);
+        }
+        for (const parentMessageId of run.parentMessageIds) {
+            this.runByParentMessageId.delete(parentMessageId);
+        }
+        for (const messageId of run.messageIds) {
+            this.runByMessageId.delete(messageId);
+        }
+        run.taskIds.clear();
+        run.parentMessageIds.clear();
+        run.messageIds.clear();
+    }
+    isActive(state) {
+        return ACTIVE_RUN_STATES.has(state);
+    }
+}
+class TimelineAssembler {
+    constructor() {
+        this.messages = new Map();
+        this.activeMessageByRun = new Map();
+        this.syntheticMessageCounter = 0;
+    }
+    consume(input) {
+        if (input.message.type === "assistant") {
+            return this.consumeAssistantMessage(input.message, input.runId, input.messageIdHint ?? null);
+        }
+        if (input.message.type === "stream_event") {
+            return this.consumeStreamEvent(input.message, input.runId, input.messageIdHint ?? null);
+        }
+        return [];
+    }
+    consumeAssistantMessage(message, runId, messageIdHint) {
+        const messageId = this.readMessageIdFromAssistantMessage(message) ??
+            messageIdHint ??
+            this.resolveMessageId({ runId, createIfMissing: true, messageId: null });
+        if (!messageId) {
+            return [];
+        }
+        const state = this.ensureMessageState(messageId, runId);
+        const fragments = this.extractFragments(message.message?.content);
+        return this.applyAbsoluteFragments(state, fragments);
+    }
+    consumeStreamEvent(message, runId, messageIdHint) {
+        const event = message.event;
+        const eventType = readTrimmedString(event.type);
+        const streamEventMessageId = this.readMessageIdFromStreamEvent(event) ?? messageIdHint;
+        if (eventType === "message_start") {
+            const messageId = this.resolveMessageId({
+                runId,
+                createIfMissing: true,
+                messageId: streamEventMessageId,
+            });
+            if (!messageId) {
+                return [];
+            }
+            this.ensureMessageState(messageId, runId);
+            return [];
+        }
+        if (eventType === "message_stop") {
+            const messageId = this.resolveMessageId({
+                runId,
+                createIfMissing: false,
+                messageId: streamEventMessageId,
+            });
+            if (!messageId) {
+                return [];
+            }
+            return this.finalizeMessage(messageId, runId);
+        }
+        if (eventType === "content_block_start") {
+            return this.consumeDeltaContent(event.content_block, runId, streamEventMessageId);
+        }
+        if (eventType === "content_block_delta") {
+            return this.consumeDeltaContent(event.delta, runId, streamEventMessageId);
+        }
+        return [];
+    }
+    consumeDeltaContent(content, runId, messageIdHint) {
+        const fragments = this.extractFragments(content);
+        if (fragments.length === 0) {
+            return [];
+        }
+        const messageId = this.resolveMessageId({
+            runId,
+            createIfMissing: true,
+            messageId: messageIdHint,
+        });
+        if (!messageId) {
+            return [];
+        }
+        const state = this.ensureMessageState(messageId, runId);
+        return this.appendFragments(state, fragments);
+    }
+    appendFragments(state, fragments) {
+        for (const fragment of fragments) {
+            if (fragment.kind === "assistant") {
+                state.assistantText += fragment.text;
+            }
+            else {
+                state.reasoningText += fragment.text;
+            }
+        }
+        return this.emitNewContent(state);
+    }
+    applyAbsoluteFragments(state, fragments) {
+        const assistantText = fragments
+            .filter((fragment) => fragment.kind === "assistant")
+            .map((fragment) => fragment.text)
+            .join("");
+        const reasoningText = fragments
+            .filter((fragment) => fragment.kind === "reasoning")
+            .map((fragment) => fragment.text)
+            .join("");
+        if (assistantText.length > 0) {
+            if (!assistantText.startsWith(state.assistantText)) {
+                state.emittedAssistantLength = 0;
+            }
+            state.assistantText = assistantText;
+        }
+        if (reasoningText.length > 0) {
+            if (!reasoningText.startsWith(state.reasoningText)) {
+                state.emittedReasoningLength = 0;
+            }
+            state.reasoningText = reasoningText;
+        }
+        return this.emitNewContent(state);
+    }
+    finalizeMessage(messageId, runId) {
+        const state = this.messages.get(messageId);
+        if (!state) {
+            return [];
+        }
+        state.stopped = true;
+        const items = this.emitNewContent(state);
+        if (runId && this.activeMessageByRun.get(runId) === messageId) {
+            this.activeMessageByRun.delete(runId);
+        }
+        return items;
+    }
+    emitNewContent(state) {
+        const items = [];
+        const nextAssistantText = state.assistantText.slice(state.emittedAssistantLength);
+        if (nextAssistantText.length > 0 &&
+            nextAssistantText !== INTERRUPT_TOOL_USE_PLACEHOLDER) {
+            state.emittedAssistantLength = state.assistantText.length;
+            items.push({ type: "assistant_message", text: nextAssistantText });
+        }
+        const nextReasoningText = state.reasoningText.slice(state.emittedReasoningLength);
+        if (nextReasoningText.length > 0) {
+            state.emittedReasoningLength = state.reasoningText.length;
+            items.push({ type: "reasoning", text: nextReasoningText });
+        }
+        return items;
+    }
+    ensureMessageState(messageId, runId) {
+        const existing = this.messages.get(messageId);
+        if (existing) {
+            existing.stopped = false;
+            if (runId) {
+                this.activeMessageByRun.set(runId, messageId);
+            }
+            return existing;
+        }
+        const created = {
+            id: messageId,
+            assistantText: "",
+            reasoningText: "",
+            emittedAssistantLength: 0,
+            emittedReasoningLength: 0,
+            stopped: false,
+        };
+        this.messages.set(messageId, created);
+        if (runId) {
+            this.activeMessageByRun.set(runId, messageId);
+        }
+        return created;
+    }
+    resolveMessageId(input) {
+        if (input.messageId) {
+            return input.messageId;
+        }
+        if (input.runId) {
+            const active = this.activeMessageByRun.get(input.runId);
+            if (active) {
+                return active;
+            }
+        }
+        if (!input.createIfMissing) {
+            return null;
+        }
+        const synthetic = `synthetic-message-${++this.syntheticMessageCounter}`;
+        if (input.runId) {
+            this.activeMessageByRun.set(input.runId, synthetic);
+        }
+        return synthetic;
+    }
+    extractFragments(content) {
+        if (typeof content === "string") {
+            if (content.length === 0) {
+                return [];
+            }
+            return [{ kind: "assistant", text: content }];
+        }
+        const blocks = Array.isArray(content) ? content : [content];
+        const fragments = [];
+        for (const rawBlock of blocks) {
+            if (!isClaudeContentChunk(rawBlock)) {
+                continue;
+            }
+            if ((rawBlock.type === "text" || rawBlock.type === "text_delta") &&
+                typeof rawBlock.text === "string" &&
+                rawBlock.text.length > 0) {
+                fragments.push({ kind: "assistant", text: rawBlock.text });
+            }
+            if ((rawBlock.type === "thinking" || rawBlock.type === "thinking_delta") &&
+                typeof rawBlock.thinking === "string" &&
+                rawBlock.thinking.length > 0) {
+                fragments.push({ kind: "reasoning", text: rawBlock.thinking });
+            }
+        }
+        return fragments;
+    }
+    readMessageIdFromAssistantMessage(message) {
+        const candidate = message;
+        return readTrimmedString(candidate.message_id) ??
+            readTrimmedString(candidate.message?.id) ??
+            null;
+    }
+    readMessageIdFromStreamEvent(event) {
+        const message = event.message;
+        return (readTrimmedString(event.message_id) ??
+            readTrimmedString(message?.id) ??
+            null);
+    }
+}
+function isMetadataOnlySdkMessage(message) {
+    if (message.type === "system") {
+        return true;
+    }
+    if (message.type !== "user") {
+        return false;
+    }
+    if (isSyntheticUserEntry(message)) {
+        return true;
+    }
+    return isTaskNotificationUserContent(message.message?.content);
+}
+function isSyntheticUserEntry(entry) {
+    if (!entry || typeof entry !== "object") {
+        return false;
+    }
+    return entry.isSynthetic === true;
+}
+export function readEventIdentifiers(message) {
+    const root = message;
+    const messageType = readTrimmedString(root.type);
+    const streamEvent = root.event;
+    const streamEventMessage = streamEvent?.message;
+    const messageContainer = root.message;
+    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,
+    };
+}
+export class ClaudeAgentClient {
+    constructor(options) {
+        this.provider = "claude";
+        this.capabilities = CLAUDE_CAPABILITIES;
+        this.defaults = options.defaults;
+        this.logger = options.logger.child({ module: "agent", provider: "claude" });
+        this.runtimeSettings = options.runtimeSettings;
+        try {
+            this.claudePath = execSync("which claude", { encoding: "utf8" }).trim() || null;
+        }
+        catch {
+            this.claudePath = null;
+        }
+    }
+    async createSession(config) {
+        const claudeConfig = this.assertConfig(config);
+        return new ClaudeAgentSession(claudeConfig, {
+            defaults: this.defaults,
+            claudePath: this.claudePath,
+            runtimeSettings: this.runtimeSettings,
+            logger: this.logger,
+        });
+    }
+    async resumeSession(handle, overrides) {
+        const metadata = coerceSessionMetadata(handle.metadata);
+        const merged = { ...metadata, ...overrides };
+        if (!merged.cwd) {
+            throw new Error("Claude resume requires the original working directory in metadata");
+        }
+        const mergedConfig = { ...merged, provider: "claude", cwd: merged.cwd };
+        const claudeConfig = this.assertConfig(mergedConfig);
+        return new ClaudeAgentSession(claudeConfig, {
+            defaults: this.defaults,
+            claudePath: this.claudePath,
+            runtimeSettings: this.runtimeSettings,
+            handle,
+            logger: this.logger,
+        });
+    }
+    async listModels(_options) {
+        return listClaudeCatalogModels();
+    }
+    async listPersistedAgents(options) {
+        const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+        const projectsRoot = path.join(configDir, "projects");
+        if (!(await pathExists(projectsRoot))) {
+            return [];
+        }
+        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;
+    }
+    async isAvailable() {
+        const commandConfig = this.runtimeSettings?.command;
+        if (commandConfig?.mode === "replace") {
+            return isProviderCommandAvailable(commandConfig, resolveClaudeBinary);
+        }
+        return this.claudePath !== null;
+    }
+    assertConfig(config) {
+        if (config.provider !== "claude") {
+            throw new Error(`ClaudeAgentClient received config for provider '${config.provider}'`);
+        }
+        return { ...config, provider: "claude" };
+    }
+}
+class ClaudeAgentSession {
+    constructor(config, options) {
+        this.provider = "claude";
+        this.capabilities = CLAUDE_CAPABILITIES;
+        this.query = null;
+        this.input = null;
+        this.availableModes = DEFAULT_MODES;
+        this.toolUseCache = new Map();
+        this.toolUseIndexToId = new Map();
+        this.toolUseInputBuffers = new Map();
+        this.pendingPermissions = new Map();
+        this.activeForegroundTurn = null;
+        this.liveEventQueue = new Pushable();
+        this.runTracker = new RunTracker();
+        this.timelineAssembler = new TimelineAssembler();
+        this.persistedHistory = [];
+        this.historyPending = false;
+        this.turnState = "idle";
+        this.preReplayMetadataSeen = false;
+        this.pendingAutonomousWakeReservations = 0;
+        this.nextRunOrdinal = 1;
+        this.cancelCurrentTurn = null;
+        this.pendingInterruptPromise = null;
+        this.activeTurnPromise = null;
+        this.cachedRuntimeInfo = null;
+        this.lastOptionsModel = null;
+        this.selectableModelIds = buildClaudeSelectableModelIds();
+        this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases();
+        this.activeSidechains = new Map();
+        this.compacting = false;
+        this.queryPumpPromise = null;
+        this.queryRestartNeeded = false;
+        this.userMessageIds = [];
+        this.localUserMessageIds = new Set();
+        this.suppressLocalReplayActivity = false;
+        this.recentStderr = "";
+        this.closed = false;
+        this.handlePermissionRequest = async (toolName, input, options) => {
+            const requestId = `permission-${randomUUID()}`;
+            const kind = resolvePermissionKind(toolName, input);
+            const metadata = {};
+            if (options.toolUseID) {
+                metadata.toolUseId = options.toolUseID;
+            }
+            if (toolName === "ExitPlanMode" && typeof input.plan === "string") {
+                metadata.planText = input.plan;
+            }
+            const toolDetail = kind === "tool"
+                ? mapClaudeRunningToolCall({
+                    name: toolName,
+                    callId: options.toolUseID ?? requestId,
+                    input,
+                    output: null,
+                })?.detail
+                : undefined;
+            const request = {
+                id: requestId,
+                provider: "claude",
+                name: toolName,
+                kind,
+                input,
+                detail: toolDetail,
+                suggestions: options.suggestions?.map((suggestion) => ({ ...suggestion })),
+                metadata: Object.keys(metadata).length ? metadata : undefined,
+            };
+            this.pushEvent({ type: "permission_requested", provider: "claude", request });
+            return await new Promise((resolve, reject) => {
+                const cleanupFns = [];
+                const cleanup = () => {
+                    while (cleanupFns.length) {
+                        const fn = cleanupFns.pop();
+                        try {
+                            fn?.();
+                        }
+                        catch {
+                            // ignore cleanup errors
+                        }
+                    }
+                };
+                const abortHandler = () => {
+                    this.pendingPermissions.delete(requestId);
+                    cleanup();
+                    reject(new Error("Permission request aborted"));
+                };
+                if (options?.signal) {
+                    if (options.signal.aborted) {
+                        abortHandler();
+                        return;
+                    }
+                    options.signal.addEventListener("abort", abortHandler, { once: true });
+                    cleanupFns.push(() => options.signal?.removeEventListener("abort", abortHandler));
+                }
+                this.pendingPermissions.set(requestId, {
+                    request,
+                    resolve,
+                    reject,
+                    cleanup,
+                });
+            });
+        };
+        this.config = config;
+        this.defaults = options.defaults;
+        this.claudePath = options.claudePath;
+        this.runtimeSettings = options.runtimeSettings;
+        this.logger = options.logger;
+        const handle = options.handle;
+        if (handle) {
+            if (!handle.sessionId) {
+                throw new Error("Cannot resume: persistence handle has no sessionId");
+            }
+            this.claudeSessionId = handle.sessionId;
+            this.persistence = handle;
+            this.loadPersistedHistory(handle.sessionId);
+        }
+        else {
+            this.claudeSessionId = null;
+            this.persistence = null;
+        }
+        // Validate mode if provided
+        if (config.modeId && !VALID_CLAUDE_MODES.has(config.modeId)) {
+            const validModesList = Array.from(VALID_CLAUDE_MODES).join(", ");
+            throw new Error(`Invalid mode '${config.modeId}' for Claude provider. Valid modes: ${validModesList}`);
+        }
+        this.currentMode = isPermissionMode(config.modeId) ? config.modeId : "default";
+    }
+    get id() {
+        return this.claudeSessionId;
+    }
+    async getRuntimeInfo() {
+        if (this.cachedRuntimeInfo) {
+            return { ...this.cachedRuntimeInfo };
+        }
+        const info = {
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            model: this.lastOptionsModel,
+            modeId: this.currentMode ?? null,
+        };
+        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) {
+            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;
+                    }
+                }
+            }
+            else if (event.type === "turn_completed") {
+                usage = event.usage;
+            }
+            else if (event.type === "turn_failed") {
+                throw new Error(event.error);
+            }
+        }
+        this.cachedRuntimeInfo = {
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            model: this.lastOptionsModel,
+            modeId: this.currentMode ?? null,
+        };
+        if (!this.claudeSessionId) {
+            throw new Error("Session ID not set after run completed");
+        }
+        return {
+            sessionId: this.claudeSessionId,
+            finalText,
+            usage,
+            timeline,
+        };
+    }
+    async *stream(prompt, options) {
+        void options;
+        if (this.cancelCurrentTurn) {
+            this.cancelCurrentTurn();
+        }
+        this.suppressLocalReplayActivity = false;
+        this.pendingAutonomousWakeReservations = 0;
+        const slashCommand = this.resolveSlashCommandInvocation(prompt);
+        if (slashCommand?.commandName === REWIND_COMMAND_NAME) {
+            yield* this.streamRewindCommand(slashCommand);
+            return;
+        }
+        await this.awaitPendingInterruptPromise();
+        if (this.turnState === "autonomous" &&
+            this.runTracker.hasActiveRuns("autonomous")) {
+            await this.transitionAutonomousToForeground();
+        }
+        const sdkMessage = this.toSdkUserMessage(prompt);
+        const queue = new Pushable();
+        const run = this.createRun("foreground", queue);
+        this.runTracker.bindIdentifiers(run, {
+            taskId: null,
+            parentMessageId: null,
+            messageId: typeof sdkMessage.uuid === "string" ? sdkMessage.uuid : null,
+        });
+        const foregroundTurn = {
+            runId: run.id,
+            queue,
+        };
+        this.activeForegroundTurn = foregroundTurn;
+        this.preReplayMetadataSeen = false;
+        this.transitionTurnState("foreground", "foreground stream started");
+        this.clearRecentStderr();
+        let finishedNaturally = false;
+        let cancelIssued = false;
+        let queueDrainedWithoutTerminal = false;
+        const turnPromise = Promise.resolve();
+        this.activeTurnPromise = turnPromise;
+        const requestCancel = () => {
+            if (cancelIssued) {
+                return;
+            }
+            cancelIssued = true;
+            if (this.activeForegroundTurn?.runId === run.id) {
+                this.activeForegroundTurn = null;
+            }
+            if (this.cancelCurrentTurn === requestCancel) {
+                this.cancelCurrentTurn = null;
+            }
+            this.rejectAllPendingPermissions(new Error("Permission request aborted"));
+            this.cancelRun(run, {
+                type: "turn_canceled",
+                provider: "claude",
+                reason: "Interrupted",
+            });
+            this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
+                this.logger.warn({ err: error }, "Failed to interrupt during cancel");
+            });
+        };
+        this.cancelCurrentTurn = requestCancel;
+        try {
+            await this.ensureQuery();
+            if (!this.input) {
+                throw new Error("Claude session input stream not initialized");
+            }
+            this.startQueryPump();
+            this.input.push(sdkMessage);
+        }
+        catch (error) {
+            this.failRun(run, 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;
+            }
+        }
+    }
+    async interrupt() {
+        if (this.cancelCurrentTurn) {
+            this.cancelCurrentTurn();
+            return;
+        }
+        const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
+        if (autonomousRuns.length > 0) {
+            this.flushPendingToolCalls();
+            for (const run of autonomousRuns) {
+                this.emitRunEvent(run, {
+                    type: "turn_canceled",
+                    provider: "claude",
+                    reason: "Interrupted",
+                });
+            }
+        }
+        await this.interruptActiveTurn();
+    }
+    async *streamHistory() {
+        if (!this.historyPending || this.persistedHistory.length === 0) {
+            return;
+        }
+        const history = this.persistedHistory;
+        this.persistedHistory = [];
+        this.historyPending = false;
+        for (const item of history) {
+            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;
+    }
+    async getCurrentMode() {
+        return this.currentMode ?? null;
+    }
+    async setMode(modeId) {
+        // Validate mode
+        if (!VALID_CLAUDE_MODES.has(modeId)) {
+            const validModesList = Array.from(VALID_CLAUDE_MODES).join(", ");
+            throw new Error(`Invalid mode '${modeId}' for Claude provider. Valid modes: ${validModesList}`);
+        }
+        const normalized = isPermissionMode(modeId) ? modeId : "default";
+        const query = await this.ensureQuery();
+        await query.setPermissionMode(normalized);
+        this.currentMode = normalized;
+    }
+    async setModel(modelId) {
+        const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
+        const query = await this.ensureQuery();
+        await query.setModel(normalizedModelId ?? undefined);
+        this.config.model = normalizedModelId ?? undefined;
+        this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
+        this.cachedRuntimeInfo = null;
+        // Model change affects persistence metadata, so invalidate cached handle.
+        this.persistence = null;
+    }
+    async setThinkingOption(thinkingOptionId) {
+        const normalizedThinkingOptionId = typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0
+            ? thinkingOptionId
+            : null;
+        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 {
+            throw new Error(`Unknown thinking option: ${normalizedThinkingOptionId}`);
+        }
+        this.queryRestartNeeded = true;
+    }
+    getPendingPermissions() {
+        return Array.from(this.pendingPermissions.values()).map((entry) => entry.request);
+    }
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error(`No pending permission request with id '${requestId}'`);
+        }
+        this.pendingPermissions.delete(requestId);
+        pending.cleanup?.();
+        if (response.behavior === "allow") {
+            if (pending.request.kind === "plan") {
+                await this.setMode("acceptEdits");
+                this.pushToolCall(mapClaudeCompletedToolCall({
+                    name: "plan_approval",
+                    callId: pending.request.id,
+                    input: pending.request.input ?? null,
+                    output: { approved: true },
+                }));
+            }
+            const result = {
+                behavior: "allow",
+                updatedInput: response.updatedInput ?? pending.request.input ?? {},
+                updatedPermissions: this.normalizePermissionUpdates(response.updatedPermissions),
+            };
+            pending.resolve(result);
+        }
+        else {
+            if (pending.request.kind === "tool") {
+                this.pushToolCall(mapClaudeFailedToolCall({
+                    name: pending.request.name,
+                    callId: (typeof pending.request.metadata?.toolUseId === "string"
+                        ? pending.request.metadata.toolUseId
+                        : null) ?? pending.request.id,
+                    input: pending.request.input ?? null,
+                    output: null,
+                    error: { message: response.message ?? "Permission denied" },
+                }));
+            }
+            const result = {
+                behavior: "deny",
+                message: response.message ?? "Permission request denied",
+                interrupt: response.interrupt,
+            };
+            pending.resolve(result);
+        }
+        this.pushEvent({
+            type: "permission_resolved",
+            provider: "claude",
+            requestId,
+            resolution: response,
+        });
+    }
+    describePersistence() {
+        if (this.persistence) {
+            return this.persistence;
+        }
+        if (!this.claudeSessionId) {
+            return null;
+        }
+        this.persistence = {
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            nativeHandle: this.claudeSessionId,
+            metadata: this.config,
+        };
+        return this.persistence;
+    }
+    async close() {
+        this.logger.trace({
+            claudeSessionId: this.claudeSessionId,
+            turnState: this.turnState,
+            hasQuery: Boolean(this.query),
+            hasInput: Boolean(this.input),
+            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
+        }, "Claude session close: start");
+        this.closed = true;
+        this.rejectAllPendingPermissions(new Error("Claude session closed"));
+        this.cancelCurrentTurn?.();
+        this.activeForegroundTurn?.queue.end();
+        this.activeForegroundTurn = null;
+        this.cancelCurrentTurn = null;
+        this.turnState = "idle";
+        this.suppressLocalReplayActivity = false;
+        this.pendingAutonomousWakeReservations = 0;
+        this.liveEventQueue.end();
+        this.activeTurnPromise = null;
+        this.input?.end();
+        await this.awaitWithTimeout(this.query?.interrupt?.(), "close query interrupt");
+        await this.awaitWithTimeout(this.query?.return?.(), "close query return");
+        this.query = null;
+        this.input = null;
+        this.logger.trace({ claudeSessionId: this.claudeSessionId, turnState: this.turnState }, "Claude session close: completed");
+    }
+    async listCommands() {
+        const q = await this.ensureQuery();
+        const commands = await q.supportedCommands();
+        const commandMap = new Map();
+        for (const cmd of commands) {
+            if (!commandMap.has(cmd.name)) {
+                commandMap.set(cmd.name, {
+                    name: cmd.name,
+                    description: cmd.description,
+                    argumentHint: cmd.argumentHint,
+                });
+            }
+        }
+        if (!commandMap.has(REWIND_COMMAND_NAME)) {
+            commandMap.set(REWIND_COMMAND_NAME, REWIND_COMMAND);
+        }
+        return Array.from(commandMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    resolveSlashCommandInvocation(prompt) {
+        if (typeof prompt !== "string") {
+            return null;
+        }
+        const parsed = this.parseSlashCommandInput(prompt);
+        if (!parsed) {
+            return null;
+        }
+        return parsed.commandName === REWIND_COMMAND_NAME ? parsed : null;
+    }
+    parseSlashCommandInput(text) {
+        const trimmed = text.trim();
+        if (!trimmed.startsWith("/") || trimmed.length <= 1) {
+            return null;
+        }
+        const withoutPrefix = trimmed.slice(1);
+        const firstWhitespaceIdx = withoutPrefix.search(/\s/);
+        const commandName = firstWhitespaceIdx === -1
+            ? withoutPrefix
+            : withoutPrefix.slice(0, firstWhitespaceIdx);
+        if (!commandName || commandName.includes("/")) {
+            return null;
+        }
+        const rawArgs = firstWhitespaceIdx === -1
+            ? ""
+            : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+        return rawArgs.length > 0
+            ? { 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
+            : undefined;
+        const stats = [];
+        if (typeof fileCount === "number") {
+            stats.push(`${fileCount} file${fileCount === 1 ? "" : "s"}`);
+        }
+        if (typeof rewindResult.insertions === "number") {
+            stats.push(`${rewindResult.insertions} insertions`);
+        }
+        if (typeof rewindResult.deletions === "number") {
+            stats.push(`${rewindResult.deletions} deletions`);
+        }
+        if (stats.length > 0) {
+            return `Rewound tracked files to message ${targetUserMessageId} (${stats.join(", ")}).`;
+        }
+        return `Rewound tracked files to message ${targetUserMessageId}.`;
+    }
+    async attemptRewind(args) {
+        if (typeof args === "string" && args.trim().length > 0) {
+            const candidate = args.trim().split(/\s+/)[0] ?? "";
+            if (!UUID_PATTERN.test(candidate)) {
+                return {
+                    messageId: null,
+                    error: "Invalid message UUID. Usage: /rewind <user_message_uuid> or /rewind",
+                };
+            }
+            const rewindResult = await this.rewindFilesOnce(candidate);
+            if (rewindResult.canRewind) {
+                return { messageId: candidate, result: rewindResult };
+            }
+            return {
+                messageId: null,
+                error: rewindResult.error ??
+                    `No file checkpoint found for message ${candidate}.`,
+            };
+        }
+        const candidates = this.getRewindCandidateUserMessageIds();
+        if (candidates.length === 0) {
+            return {
+                messageId: null,
+                error: "No prior user message available to rewind. Use /rewind <user_message_uuid>.",
+            };
+        }
+        let lastError;
+        for (const candidate of candidates) {
+            try {
+                const rewindResult = await this.rewindFilesOnce(candidate);
+                if (rewindResult.canRewind) {
+                    return { messageId: candidate, result: rewindResult };
+                }
+                if (rewindResult.error) {
+                    lastError = rewindResult.error;
+                }
+            }
+            catch (error) {
+                lastError =
+                    error instanceof Error
+                        ? error.message
+                        : "Failed to rewind tracked files.";
+            }
+        }
+        return {
+            messageId: null,
+            error: lastError ??
+                "No rewind checkpoints are currently available for this session.",
+        };
+    }
+    async rewindFilesOnce(messageId) {
+        try {
+            const query = await this.ensureFreshQuery();
+            return await query.rewindFiles(messageId, { dryRun: false });
+        }
+        catch (error) {
+            // The Claude SDK transport can close after a rewind call.
+            // If that happens, mark the query stale so a follow-up attempt uses a fresh query.
+            this.queryRestartNeeded = true;
+            throw error;
+        }
+    }
+    async ensureFreshQuery() {
+        if (this.query) {
+            this.queryRestartNeeded = true;
+        }
+        return this.ensureQuery();
+    }
+    getRewindCandidateUserMessageIds() {
+        const candidates = [];
+        const pushUnique = (value) => {
+            if (typeof value === "string" &&
+                value.length > 0 &&
+                !candidates.includes(value)) {
+                candidates.push(value);
+            }
+        };
+        const historyIds = this.readUserMessageIdsFromHistoryFile();
+        for (let idx = historyIds.length - 1; idx >= 0; idx -= 1) {
+            pushUnique(historyIds[idx]);
+        }
+        for (let idx = this.persistedHistory.length - 1; idx >= 0; idx -= 1) {
+            const item = this.persistedHistory[idx];
+            if (item?.type === "user_message") {
+                pushUnique(item.messageId);
+            }
+        }
+        for (let idx = this.userMessageIds.length - 1; idx >= 0; idx -= 1) {
+            pushUnique(this.userMessageIds[idx]);
+        }
+        return candidates;
+    }
+    readUserMessageIdsFromHistoryFile() {
+        if (!this.claudeSessionId) {
+            return [];
+        }
+        const historyPath = this.resolveHistoryPath(this.claudeSessionId);
+        if (!historyPath || !fs.existsSync(historyPath)) {
+            return [];
+        }
+        try {
+            const ids = [];
+            const content = fs.readFileSync(historyPath, "utf8");
+            for (const line of content.split(/\n+/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const entry = JSON.parse(trimmed);
+                    if (entry?.type === "user" && typeof entry.uuid === "string") {
+                        ids.push(entry.uuid);
+                    }
+                }
+                catch {
+                    // ignore malformed lines
+                }
+            }
+            return ids;
+        }
+        catch {
+            return [];
+        }
+    }
+    rememberUserMessageId(messageId) {
+        if (typeof messageId !== "string" || messageId.length === 0) {
+            return;
+        }
+        const last = this.userMessageIds[this.userMessageIds.length - 1];
+        if (last === messageId) {
+            return;
+        }
+        this.userMessageIds.push(messageId);
+    }
+    async ensureQuery() {
+        if (this.query && !this.queryRestartNeeded) {
+            return this.query;
+        }
+        if (this.queryRestartNeeded && this.query) {
+            this.input?.end();
+            try {
+                await this.query.return?.();
+            }
+            catch { /* ignore */ }
+            this.query = null;
+            this.input = null;
+            this.queryRestartNeeded = false;
+        }
+        const input = new Pushable();
+        const options = this.buildOptions();
+        this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
+        this.input = input;
+        this.query = query({ prompt: input, 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
+        // control plane can cause those calls to wait behind supportedModels().
+        return this.query;
+    }
+    async awaitWithTimeout(promise, label) {
+        if (!promise) {
+            this.logger.trace({ label }, "Claude query operation skipped (no promise)");
+            return;
+        }
+        const startedAt = Date.now();
+        this.logger.trace({ label }, "Claude query operation wait start");
+        try {
+            await Promise.race([
+                promise,
+                new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error("timeout")), 3000);
+                }),
+            ]);
+            this.logger.trace({ label, durationMs: Date.now() - startedAt }, "Claude query operation settled");
+        }
+        catch (error) {
+            this.logger.warn({ err: error, label }, "Claude query operation did not settle cleanly");
+        }
+    }
+    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 appendedSystemPrompt = [
+            getOrchestratorModeInstructions(),
+            this.config.systemPrompt?.trim(),
+        ]
+            .filter((entry) => typeof entry === "string" && entry.length > 0)
+            .join("\n\n");
+        const base = {
+            cwd: this.config.cwd,
+            includePartialMessages: true,
+            permissionMode: this.currentMode,
+            agents: this.defaults?.agents,
+            canUseTool: this.handlePermissionRequest,
+            ...(this.claudePath ? { pathToClaudeCodeExecutable: this.claudePath } : {}),
+            // Use Claude Code preset system prompt and load CLAUDE.md files
+            // Append provider-agnostic system prompt and orchestrator instructions for agents.
+            systemPrompt: {
+                type: "preset",
+                preset: "claude_code",
+                append: appendedSystemPrompt,
+            },
+            settingSources: CLAUDE_SETTING_SOURCES,
+            stderr: (data) => {
+                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",
+            },
+            // 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 } : {}),
+            ...this.config.extra?.claude,
+        };
+        if (this.config.mcpServers) {
+            base.mcpServers = this.normalizeMcpServers(this.config.mcpServers);
+        }
+        if (this.config.model) {
+            base.model = this.config.model;
+        }
+        this.lastOptionsModel = base.model ?? null;
+        if (this.claudeSessionId) {
+            base.resume = this.claudeSessionId;
+        }
+        return this.applyRuntimeSettings(base);
+    }
+    applyRuntimeSettings(options) {
+        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings);
+    }
+    normalizeMcpServers(servers) {
+        const result = {};
+        for (const [name, config] of Object.entries(servers)) {
+            result[name] = toClaudeSdkMcpConfig(config);
+        }
+        return result;
+    }
+    toSdkUserMessage(prompt) {
+        const content = [];
+        if (Array.isArray(prompt)) {
+            for (const chunk of prompt) {
+                if (chunk.type === "text") {
+                    content.push({ type: "text", text: chunk.text });
+                }
+                else if (chunk.type === "image") {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: chunk.mimeType,
+                            data: chunk.data,
+                        },
+                    });
+                }
+            }
+        }
+        else {
+            content.push({ type: "text", text: prompt });
+        }
+        const messageId = randomUUID();
+        this.rememberUserMessageId(messageId);
+        this.localUserMessageIds.add(messageId);
+        return {
+            type: "user",
+            message: {
+                role: "user",
+                content,
+            },
+            parent_tool_use_id: null,
+            uuid: messageId,
+            session_id: this.claudeSessionId ?? "",
+        };
+    }
+    async awaitPendingInterruptPromise() {
+        if (!this.pendingInterruptPromise) {
+            return;
+        }
+        await this.pendingInterruptPromise;
+        this.pendingInterruptPromise = null;
+    }
+    createRun(owner, queue) {
+        const runId = `${owner}-run-${this.nextRunOrdinal++}`;
+        const run = this.runTracker.createRun({
+            id: runId,
+            owner,
+            queue,
+            promptReplaySeen: owner === "autonomous",
+        });
+        this.logger.debug({ runId, owner, state: run.state }, "Created Claude run");
+        return run;
+    }
+    transitionTurnState(next, reason) {
+        if (this.turnState === next) {
+            return;
+        }
+        this.logger.debug({ from: this.turnState, to: next, reason }, "Claude turn state transition");
+        this.turnState = next;
+    }
+    transitionTurnStateFromActiveRuns(reason) {
+        if (this.runTracker.hasActiveRuns("foreground")) {
+            this.transitionTurnState("foreground", reason);
+            return;
+        }
+        if (this.runTracker.hasActiveRuns("autonomous")) {
+            this.transitionTurnState("autonomous", reason);
+            return;
+        }
+        this.transitionTurnState("idle", reason);
+    }
+    failRun(run, errorMessage) {
+        this.emitRunEvent(run, this.buildTurnFailedEvent(errorMessage));
+    }
+    buildTurnFailedEvent(errorMessage) {
+        const normalized = errorMessage.trim() || "Claude run failed";
+        const exitCodeMatch = normalized.match(/\bcode\s+(\d+)\b/i);
+        const code = exitCodeMatch ? exitCodeMatch[1] : undefined;
+        const diagnostic = this.getRecentStderrDiagnostic();
+        return {
+            type: "turn_failed",
+            provider: "claude",
+            error: normalized,
+            ...(code ? { code } : {}),
+            ...(diagnostic ? { diagnostic } : {}),
+        };
+    }
+    captureStderr(data) {
+        const text = data.trim();
+        if (!text) {
+            return;
+        }
+        const combined = this.recentStderr ? `${this.recentStderr}\n${text}` : text;
+        this.recentStderr = combined.slice(-MAX_RECENT_STDERR_CHARS);
+    }
+    clearRecentStderr() {
+        this.recentStderr = "";
+    }
+    getRecentStderrDiagnostic() {
+        const text = this.recentStderr.trim();
+        return text.length > 0 ? text : undefined;
+    }
+    cancelRun(run, event) {
+        this.flushPendingToolCalls();
+        this.emitRunEvent(run, event);
+    }
+    emitRunEvent(run, event) {
+        if (event.type === "turn_started" ||
+            event.type === "turn_completed" ||
+            event.type === "turn_failed" ||
+            event.type === "turn_canceled") {
+            this.logger.trace({
+                runId: run.id,
+                owner: run.owner,
+                runState: run.state,
+                eventType: event.type,
+                routedTo: run.owner === "foreground" && run.queue ? "foreground_queue" : "live_queue",
+            }, "Claude run event emitted");
+        }
+        if (run.owner === "foreground" && run.queue) {
+            run.queue.push(event);
+            if (event.type === "turn_completed" ||
+                event.type === "turn_failed" ||
+                event.type === "turn_canceled") {
+                run.queue.end();
+            }
+        }
+        else {
+            this.liveEventQueue.push(event);
+        }
+        this.handleRunTerminalEvent(run, event);
+    }
+    handleRunTerminalEvent(run, event) {
+        if (event.type === "turn_completed") {
+            this.runTracker.complete(run, "completed");
+        }
+        else if (event.type === "turn_failed") {
+            this.runTracker.complete(run, "error");
+        }
+        else if (event.type === "turn_canceled") {
+            this.runTracker.complete(run, "interrupted");
+        }
+        else {
+            return;
+        }
+        if (this.activeForegroundTurn?.runId === run.id) {
+            this.activeForegroundTurn = null;
+            this.preReplayMetadataSeen = false;
+        }
+        this.logger.trace({
+            runId: run.id,
+            owner: run.owner,
+            eventType: event.type,
+            runState: run.state,
+            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
+        }, "Claude run terminal event handled");
+        this.transitionTurnStateFromActiveRuns(`run ${run.id} terminal`);
+    }
+    async transitionAutonomousToForeground() {
+        const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
+        if (autonomousRuns.length === 0) {
+            this.transitionTurnStateFromActiveRuns("no autonomous runs to transition");
+            return;
+        }
+        this.logger.debug({ runIds: autonomousRuns.map((run) => run.id) }, "Transitioning autonomous runs to foreground ownership");
+        this.flushPendingToolCalls();
+        for (const run of autonomousRuns) {
+            this.emitRunEvent(run, {
+                type: "turn_canceled",
+                provider: "claude",
+                reason: "Interrupted by foreground prompt",
+            });
+        }
+        this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
+            this.logger.warn({ err: error }, "Failed to interrupt autonomous run during foreground transition");
+        });
+        await this.awaitPendingInterruptPromise();
+        this.transitionTurnStateFromActiveRuns("autonomous interrupted for foreground");
+    }
+    routeMessage(normalized) {
+        if (normalized.metadataOnly) {
+            if (normalized.message.type === "user" &&
+                isTaskNotificationUserContent(normalized.message.message?.content)) {
+                this.reserveAutonomousWake("task_notification");
+            }
+            this.notePreReplayMetadata(normalized.message);
+            return { run: null, reason: "metadata" };
+        }
+        const hasIdentifiers = Boolean(normalized.identifiers.taskId ||
+            normalized.identifiers.parentMessageId ||
+            normalized.identifiers.messageId);
+        const byIdentifiers = this.runTracker.resolveByIdentifiers(normalized.identifiers);
+        if (byIdentifiers.run) {
+            return byIdentifiers;
+        }
+        if (this.turnState === "autonomous") {
+            const activeAutonomousRun = this.runTracker.getLatestActiveRun("autonomous");
+            if (activeAutonomousRun) {
+                return { run: activeAutonomousRun, reason: "unbound_autonomous" };
+            }
+        }
+        const foregroundRun = this.activeForegroundTurn
+            ? this.runTracker.getRun(this.activeForegroundTurn.runId)
+            : null;
+        // A previously unseen task_id during foreground ownership is deterministic
+        // evidence of a distinct autonomous wake/run, not foreground response text.
+        if (this.turnState === "foreground" &&
+            foregroundRun &&
+            normalized.identifiers.taskId) {
+            const incomingTaskId = normalized.identifiers.taskId;
+            // Foreground must claim its first task_id; otherwise early foreground
+            // result events can be misrouted to autonomous fallback runs.
+            if (foregroundRun.taskIds.size === 0) {
+                if (foregroundRun.state !== "finalizing") {
+                    return { run: foregroundRun, reason: "foreground" };
+                }
+            }
+            else if (foregroundRun.taskIds.has(incomingTaskId)) {
+                return { run: foregroundRun, reason: "foreground" };
+            }
+            const autonomousRun = this.createRun("autonomous", null);
+            this.emitRunEvent(autonomousRun, { type: "turn_started", provider: "claude" });
+            return { run: autonomousRun, reason: "task_id_new" };
+        }
+        if (this.turnState === "foreground" &&
+            foregroundRun &&
+            this.shouldPreferForegroundRun({
+                run: foregroundRun,
+                message: normalized.message,
+            })) {
+            return { run: foregroundRun, reason: "foreground" };
+        }
+        if (!hasIdentifiers) {
+            if (this.pendingAutonomousWakeReservations > 0) {
+                const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_unbound");
+                return {
+                    run: reservedAutonomousRun,
+                    reason: "unbound_autonomous",
+                };
+            }
+            const activeAutonomousRun = this.runTracker.getLatestActiveRun("autonomous");
+            if (activeAutonomousRun) {
+                return { run: activeAutonomousRun, reason: "unbound_autonomous" };
+            }
+        }
+        if (this.pendingAutonomousWakeReservations > 0) {
+            const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_fallback");
+            return { run: reservedAutonomousRun, reason: "fallback" };
+        }
+        const autonomousRun = this.createRun("autonomous", null);
+        this.emitRunEvent(autonomousRun, { type: "turn_started", provider: "claude" });
+        return { run: autonomousRun, reason: "fallback" };
+    }
+    shouldPreferForegroundRun(input) {
+        const { run, message } = input;
+        if (run.state === "completed" ||
+            run.state === "interrupted" ||
+            run.state === "error") {
+            return false;
+        }
+        // Before prompt replay is observed, prefer foreground by default so the
+        // first turn cannot be stranded in autonomous fallback. If metadata churn
+        // was observed pre-replay, stay conservative and wait for replay.
+        if (!run.promptReplaySeen) {
+            if (this.isToolUseBoundaryStreamEvent(input.message)) {
+                return true;
+            }
+            // Keep pre-replay result events with the foreground run so stale result
+            // bursts cannot consume autonomous wake reservations.
+            if (message.type === "result") {
+                return true;
+            }
+            if (message.type === "assistant" ||
+                message.type === "stream_event" ||
+                message.type === "tool_progress") {
+                return !this.preReplayMetadataSeen;
+            }
+            return true;
+        }
+        if (run.state === "finalizing" &&
+            (message.type === "assistant" || message.type === "stream_event")) {
+            return false;
+        }
+        return true;
+    }
+    isToolUseBoundaryStreamEvent(message) {
+        if (message.type !== "stream_event") {
+            return false;
+        }
+        const event = message.event;
+        if (!event || event.type !== "message_delta") {
+            return false;
+        }
+        const delta = "delta" in event && event.delta && typeof event.delta === "object"
+            ? event.delta
+            : null;
+        return delta?.stop_reason === "tool_use";
+    }
+    notePreReplayMetadata(message) {
+        if (this.turnState !== "foreground") {
+            return;
+        }
+        const foregroundRun = this.activeForegroundTurn
+            ? this.runTracker.getRun(this.activeForegroundTurn.runId)
+            : null;
+        if (!foregroundRun || foregroundRun.promptReplaySeen) {
+            return;
+        }
+        // System metadata (init/hook callbacks/etc.) can precede the first prompt
+        // replay for a legitimate foreground run. Treating that as churn strands
+        // one-shot helper runs in autonomous fallback.
+        if (message.type === "system") {
+            return;
+        }
+        this.preReplayMetadataSeen = true;
+    }
+    reserveAutonomousWake(reason) {
+        this.pendingAutonomousWakeReservations += 1;
+        this.logger.debug({
+            reason,
+            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
+        }, "Reserved autonomous wake");
+    }
+    claimOrCreateAutonomousRun(reason) {
+        const existing = this.runTracker.getLatestActiveRun("autonomous");
+        if (existing) {
+            if (this.pendingAutonomousWakeReservations > 0) {
+                this.pendingAutonomousWakeReservations -= 1;
+            }
+            this.logger.debug({
+                reason,
+                runId: existing.id,
+                pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
+            }, "Claimed autonomous wake reservation on existing run");
+            return existing;
+        }
+        const run = this.createRun("autonomous", null);
+        this.emitRunEvent(run, { type: "turn_started", provider: "claude" });
+        if (this.pendingAutonomousWakeReservations > 0) {
+            this.pendingAutonomousWakeReservations -= 1;
+        }
+        this.logger.debug({
+            reason,
+            runId: run.id,
+            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
+        }, "Claimed autonomous wake reservation with new run");
+        return run;
+    }
+    startQueryPump() {
+        if (this.closed || this.queryPumpPromise) {
+            return;
+        }
+        const pump = this.runQueryPump().catch((error) => {
+            this.logger.warn({ err: error }, "Claude query pump exited unexpectedly");
+        });
+        this.queryPumpPromise = pump;
+        pump.finally(() => {
+            if (this.queryPumpPromise === pump) {
+                this.queryPumpPromise = null;
+            }
+        });
+    }
+    async runQueryPump() {
+        while (!this.closed) {
+            if (!this.claudeSessionId && !this.activeForegroundTurn && !this.query) {
+                await this.waitForLiveHistoryPoll();
+                continue;
+            }
+            let q;
+            try {
+                q = await this.ensureQuery();
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Failed to initialize Claude query pump");
+                await this.waitForLiveHistoryPoll();
+                continue;
+            }
+            let next;
+            try {
+                next = await q.next();
+                this.logger.info({ claudeSessionId: this.claudeSessionId, next }, "Claude query pump raw next()");
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Claude query pump next() failed");
+                for (const run of this.runTracker.listActiveRuns()) {
+                    this.failRun(run, error instanceof Error ? error.message : "Claude stream failed");
+                }
+                this.input?.end();
+                await this.awaitWithTimeout(q.return?.(), "query pump return after failure");
+                if (this.query === q) {
+                    this.query = null;
+                    this.input = null;
+                }
+                await this.waitForLiveHistoryPoll();
+                continue;
+            }
+            if (next.done) {
+                this.logger.trace({
+                    claudeSessionId: this.claudeSessionId,
+                    activeRunCount: this.runTracker.listActiveRuns().length,
+                }, "Claude query pump next() returned done");
+                this.input?.end();
+                await this.awaitWithTimeout(q.return?.(), "query pump return on done");
+                if (this.query === q) {
+                    this.query = null;
+                    this.input = null;
+                }
+                const activeRuns = this.runTracker.listActiveRuns();
+                if (activeRuns.length > 0) {
+                    for (const run of activeRuns) {
+                        this.failRun(run, "Claude stream ended before terminal result");
+                    }
+                }
+                await this.waitForLiveHistoryPoll();
+                continue;
+            }
+            const sdkMessage = next.value;
+            if (!sdkMessage) {
+                continue;
+            }
+            try {
+                this.routeSdkMessageFromPump(sdkMessage);
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Failed to route Claude SDK message from query pump");
+            }
+        }
+    }
+    routeSdkMessageFromPump(message) {
+        if (this.shouldSuppressLocalReplayActivity(message)) {
+            return;
+        }
+        const identifiers = readEventIdentifiers(message);
+        const metadataOnly = isMetadataOnlySdkMessage(message);
+        const route = this.routeMessage({
+            message,
+            identifiers,
+            metadataOnly,
+        });
+        const suppressTerminalEvents = this.shouldSuppressReplayResultTerminal({
+            run: route.run,
+            message,
+        });
+        this.logger.trace({
+            claudeSessionId: this.claudeSessionId,
+            messageType: message.type,
+            routeReason: route.reason,
+            runId: route.run?.id ?? null,
+            runOwner: route.run?.owner ?? null,
+            suppressTerminalEvents,
+            metadataOnly,
+        }, "Claude query pump routed SDK message");
+        if (route.run) {
+            this.transitionTurnStateFromActiveRuns(`routed via ${route.reason}`);
+            this.runTracker.bindIdentifiers(route.run, identifiers);
+            if (!suppressTerminalEvents) {
+                this.updateRunLifecycleForMessage(route.run, message, identifiers);
+            }
+        }
+        const messageEvents = this.translateMessageToEvents(message, {
+            suppressAssistantText: true,
+            suppressReasoning: true,
+            suppressTerminalEvents,
+        });
+        const assistantTimelineItems = this.timelineAssembler.consume({
+            message,
+            runId: route.run?.id ?? null,
+            messageIdHint: identifiers.messageId,
+        });
+        const assistantTimelineEvents = assistantTimelineItems.map((item) => ({
+            type: "timeline",
+            item,
+            provider: "claude",
+        }));
+        const events = [...messageEvents, ...assistantTimelineEvents];
+        if (events.length === 0) {
+            return;
+        }
+        if (!route.run) {
+            this.dispatchMetadataEvents(events);
+            return;
+        }
+        for (const event of events) {
+            this.emitRunEvent(route.run, event);
+        }
+    }
+    shouldSuppressReplayResultTerminal(input) {
+        const { run, message } = input;
+        if (!run || run.owner !== "foreground" || message.type !== "result") {
+            return false;
+        }
+        if (run.promptReplaySeen) {
+            return false;
+        }
+        if (run.state === "streaming" || run.state === "finalizing") {
+            return false;
+        }
+        const resultSubtype = "subtype" in message && typeof message.subtype === "string"
+            ? message.subtype
+            : null;
+        // Pre-replay success results are stale in practice (leftover from an
+        // earlier query segment) and must not end the current foreground run.
+        if (resultSubtype === "success") {
+            this.logger.trace({
+                runId: run.id,
+                runOwner: run.owner,
+                runState: run.state,
+                promptReplaySeen: run.promptReplaySeen,
+                resultSubtype,
+            }, "Suppressing pre-replay foreground success result terminal event");
+            return true;
+        }
+        // For non-success results, keep the metadata-churn guard to avoid
+        // suppressing legitimate hard failures.
+        return this.preReplayMetadataSeen;
+    }
+    dispatchMetadataEvents(events) {
+        for (const event of events) {
+            this.pushEvent(event);
+        }
+    }
+    updateRunLifecycleForMessage(run, message, identifiers) {
+        const previousState = run.state;
+        if (message.type === "user" &&
+            identifiers.messageId &&
+            run.messageIds.has(identifiers.messageId)) {
+            run.promptReplaySeen = true;
+            this.preReplayMetadataSeen = false;
+        }
+        if (run.state === "queued") {
+            this.runTracker.transition(run, "awaiting_response");
+        }
+        if (message.type === "assistant" ||
+            message.type === "stream_event" ||
+            message.type === "tool_progress") {
+            this.runTracker.transition(run, "streaming");
+            return;
+        }
+        if (message.type === "result") {
+            this.runTracker.transition(run, "finalizing");
+        }
+        else {
+            return;
+        }
+        if (run.state !== previousState) {
+            this.logger.trace({
+                runId: run.id,
+                owner: run.owner,
+                messageType: message.type,
+                previousState,
+                nextState: run.state,
+                taskId: identifiers.taskId,
+                parentMessageId: identifiers.parentMessageId,
+                messageId: identifiers.messageId,
+            }, "Updated Claude run lifecycle from SDK message");
+        }
+    }
+    shouldSuppressLocalReplayActivity(message) {
+        const localReplay = this.isLocalReplayUserMessage(message);
+        if (!this.activeForegroundTurn && localReplay) {
+            this.suppressLocalReplayActivity = true;
+            this.logger.debug({ uuid: message.uuid }, "Suppressing local replay user message from live pump");
+            return true;
+        }
+        if (!this.suppressLocalReplayActivity) {
+            return false;
+        }
+        // Suppress only replay scaffolding. Do not suppress autonomous
+        // assistant/result events; otherwise task-notification replies can be dropped.
+        if (localReplay) {
+            return true;
+        }
+        if (message.type === "system") {
+            return true;
+        }
+        const identifiers = readEventIdentifiers(message);
+        const hasIdentifiers = Boolean(identifiers.taskId || identifiers.parentMessageId || identifiers.messageId);
+        if (message.type !== "user" && !hasIdentifiers) {
+            if (this.pendingAutonomousWakeReservations > 0) {
+                this.suppressLocalReplayActivity = false;
+                return false;
+            }
+            return true;
+        }
+        if (message.type === "user") {
+            this.suppressLocalReplayActivity = false;
+            return false;
+        }
+        this.suppressLocalReplayActivity = false;
+        return false;
+    }
+    isLocalReplayUserMessage(message) {
+        if (message.type !== "user") {
+            return false;
+        }
+        const uuid = readTrimmedString(message.uuid);
+        if (!uuid) {
+            return false;
+        }
+        return this.localUserMessageIds.has(uuid);
+    }
+    async interruptActiveTurn() {
+        const queryToInterrupt = this.query;
+        if (!queryToInterrupt || typeof queryToInterrupt.interrupt !== "function") {
+            this.logger.debug("interruptActiveTurn: no query to interrupt");
+            return;
+        }
+        try {
+            this.logger.debug("interruptActiveTurn: calling query.interrupt()...");
+            const t0 = Date.now();
+            await queryToInterrupt.interrupt();
+            this.logger.debug({ durationMs: Date.now() - t0 }, "interruptActiveTurn: query.interrupt() returned");
+            // After interrupt(), the query iterator is done (returns done: true).
+            // Clear it so ensureQuery() creates a fresh query for the next turn.
+            // Also end the input stream and call return() to clean up the SDK process.
+            this.input?.end();
+            this.logger.debug("interruptActiveTurn: calling query.return()...");
+            const t1 = Date.now();
+            await queryToInterrupt.return?.();
+            this.logger.debug({ durationMs: Date.now() - t1 }, "interruptActiveTurn: query.return() returned");
+            this.query = null;
+            this.input = null;
+            this.queryRestartNeeded = false;
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to interrupt active turn");
+            // If interrupt fails, the SDK iterator may remain in an indeterminate state.
+            // Force a teardown/recreate path so the next turn cannot reuse stale query state.
+            this.queryRestartNeeded = true;
+        }
+    }
+    handleSidechainMessage(message, parentToolUseId) {
+        const state = this.activeSidechains.get(parentToolUseId) ??
+            {
+                actions: [],
+                actionKeys: [],
+                nextActionIndex: 1,
+                actionIndexByKey: new Map(),
+            };
+        this.activeSidechains.set(parentToolUseId, state);
+        const contextUpdated = this.updateSubAgentContextFromTaskInput(state, parentToolUseId);
+        const actionCandidates = this.extractSubAgentActionCandidates(message);
+        let actionUpdated = false;
+        for (const action of actionCandidates) {
+            if (this.appendSubAgentAction(state, action)) {
+                actionUpdated = true;
+            }
+        }
+        if (!contextUpdated && !actionUpdated) {
+            return [];
+        }
+        const toolCall = mapClaudeRunningToolCall({
+            name: "Task",
+            callId: parentToolUseId,
+            input: null,
+            output: null,
+        });
+        if (!toolCall) {
+            return [];
+        }
+        const detail = {
+            type: "sub_agent",
+            ...(state.subAgentType ? { subAgentType: state.subAgentType } : {}),
+            ...(state.description ? { description: state.description } : {}),
+            log: state.actions
+                .map((action) => action.summary
+                ? `[${action.toolName}] ${action.summary}`
+                : `[${action.toolName}]`)
+                .join("\n"),
+            actions: state.actions.map((action) => ({
+                index: action.index,
+                toolName: action.toolName,
+                ...(action.summary ? { summary: action.summary } : {}),
+            })),
+        };
+        return [
+            {
+                type: "timeline",
+                item: {
+                    ...toolCall,
+                    detail,
+                },
+                provider: "claude",
+            },
+        ];
+    }
+    updateSubAgentContextFromTaskInput(state, parentToolUseId) {
+        const taskInput = this.toolUseCache.get(parentToolUseId)?.input;
+        const nextSubAgentType = this.normalizeSubAgentText(taskInput?.subagent_type);
+        const nextDescription = this.normalizeSubAgentText(taskInput?.description);
+        let changed = false;
+        if (nextSubAgentType && nextSubAgentType !== state.subAgentType) {
+            state.subAgentType = nextSubAgentType;
+            changed = true;
+        }
+        if (nextDescription && nextDescription !== state.description) {
+            state.description = nextDescription;
+            changed = true;
+        }
+        return changed;
+    }
+    normalizeSubAgentText(value) {
+        const normalized = readTrimmedString(value)?.replace(/\s+/g, " ");
+        if (!normalized) {
+            return undefined;
+        }
+        if (normalized.length <= MAX_SUB_AGENT_SUMMARY_CHARS) {
+            return normalized;
+        }
+        return `${normalized.slice(0, MAX_SUB_AGENT_SUMMARY_CHARS)}...`;
+    }
+    extractSubAgentActionCandidates(message) {
+        if (message.type === "assistant") {
+            const content = message.message?.content;
+            if (!Array.isArray(content)) {
+                return [];
+            }
+            const actions = [];
+            for (const block of content) {
+                if (!isClaudeContentChunk(block) ||
+                    !(block.type === "tool_use" ||
+                        block.type === "mcp_tool_use" ||
+                        block.type === "server_tool_use") ||
+                    typeof block.name !== "string") {
+                    continue;
+                }
+                const key = readTrimmedString(block.id) ??
+                    `assistant:${block.name}:${actions.length}`;
+                actions.push({
+                    key,
+                    toolName: block.name,
+                    input: block.input ?? null,
+                });
+            }
+            return actions;
+        }
+        if (message.type === "stream_event") {
+            const event = message.event;
+            if (event.type !== "content_block_start") {
+                return [];
+            }
+            const block = isClaudeContentChunk(event.content_block)
+                ? event.content_block
+                : null;
+            if (!block ||
+                !(block.type === "tool_use" ||
+                    block.type === "mcp_tool_use" ||
+                    block.type === "server_tool_use") ||
+                typeof block.name !== "string") {
+                return [];
+            }
+            const key = readTrimmedString(block.id) ??
+                `stream:${block.name}:${typeof event.index === "number" ? event.index : 0}`;
+            return [
+                {
+                    key,
+                    toolName: block.name,
+                    input: block.input ?? null,
+                },
+            ];
+        }
+        if (message.type === "tool_progress") {
+            const toolName = readTrimmedString(message.tool_name);
+            if (!toolName) {
+                return [];
+            }
+            const key = readTrimmedString(message.tool_use_id) ?? `progress:${toolName}`;
+            return [{ key, toolName, input: null }];
+        }
+        return [];
+    }
+    appendSubAgentAction(state, candidate) {
+        const normalizedToolName = readTrimmedString(candidate.toolName);
+        if (!normalizedToolName) {
+            return false;
+        }
+        const summary = this.deriveSubAgentActionSummary(normalizedToolName, candidate.input);
+        const existingIndex = state.actionIndexByKey.get(candidate.key);
+        if (existingIndex !== undefined) {
+            const existing = state.actions[existingIndex];
+            if (!existing) {
+                return false;
+            }
+            const nextSummary = existing.summary ?? summary;
+            const unchanged = existing.toolName === normalizedToolName &&
+                existing.summary === nextSummary;
+            if (unchanged) {
+                return false;
+            }
+            state.actions[existingIndex] = {
+                ...existing,
+                toolName: normalizedToolName,
+                ...(nextSummary ? { summary: nextSummary } : {}),
+            };
+            return true;
+        }
+        const nextEntry = {
+            index: state.nextActionIndex,
+            toolName: normalizedToolName,
+            ...(summary ? { summary } : {}),
+        };
+        state.nextActionIndex += 1;
+        state.actions.push(nextEntry);
+        state.actionKeys.push(candidate.key);
+        this.trimSubAgentTail(state);
+        this.rebuildSubAgentActionIndex(state);
+        return true;
+    }
+    trimSubAgentTail(state) {
+        while (state.actions.length > MAX_SUB_AGENT_LOG_ENTRIES) {
+            state.actions.shift();
+            state.actionKeys.shift();
+        }
+    }
+    rebuildSubAgentActionIndex(state) {
+        state.actionIndexByKey.clear();
+        for (let index = 0; index < state.actionKeys.length; index += 1) {
+            const key = state.actionKeys[index];
+            if (key) {
+                state.actionIndexByKey.set(key, index);
+            }
+        }
+    }
+    deriveSubAgentActionSummary(toolName, input) {
+        const runningToolCall = mapClaudeRunningToolCall({
+            name: toolName,
+            callId: `sub-agent-summary-${toolName}`,
+            input,
+            output: null,
+        });
+        if (!runningToolCall) {
+            return undefined;
+        }
+        const display = buildToolCallDisplayModel({
+            name: runningToolCall.name,
+            status: runningToolCall.status,
+            error: runningToolCall.error,
+            detail: runningToolCall.detail,
+            metadata: runningToolCall.metadata,
+        });
+        return this.normalizeSubAgentText(display.summary);
+    }
+    translateMessageToEvents(message, options) {
+        const parentToolUseId = "parent_tool_use_id" in message
+            ? message.parent_tool_use_id
+            : null;
+        if (parentToolUseId) {
+            return this.handleSidechainMessage(message, parentToolUseId);
+        }
+        const events = [];
+        const fallbackThreadSessionId = this.captureSessionIdFromMessage(message);
+        if (fallbackThreadSessionId) {
+            events.push({
+                type: "thread_started",
+                provider: "claude",
+                sessionId: fallbackThreadSessionId,
+            });
+        }
+        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",
+                        });
+                    }
+                }
+                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) {
+                    // String content from user messages (e.g., local command output)
+                    events.push({
+                        type: "timeline",
+                        item: {
+                            type: "user_message",
+                            text: content,
+                            ...(messageId ? { messageId } : {}),
+                        },
+                        provider: "claude",
+                    });
+                }
+                else if (Array.isArray(content)) {
+                    const timelineItems = this.mapBlocksToTimeline(content);
+                    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" });
+                    }
+                }
+                break;
+            }
+            case "assistant": {
+                const timelineItems = this.mapBlocksToTimeline(message.message.content, {
+                    suppressAssistantText: options?.suppressAssistantText ?? false,
+                    suppressReasoning: options?.suppressReasoning ?? false,
+                });
+                for (const item of timelineItems) {
+                    events.push({ type: "timeline", item, provider: "claude" });
+                }
+                break;
+            }
+            case "stream_event": {
+                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" });
+                }
+                break;
+            }
+            case "result": {
+                if (options?.suppressTerminalEvents) {
+                    break;
+                }
+                const usage = this.convertUsage(message);
+                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));
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        return events;
+    }
+    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();
+        if (!sessionId) {
+            return null;
+        }
+        if (this.claudeSessionId === null) {
+            this.claudeSessionId = sessionId;
+            this.persistence = null;
+            return sessionId;
+        }
+        if (this.claudeSessionId === sessionId) {
+            return null;
+        }
+        throw new Error(`CRITICAL: Claude session ID overwrite detected! ` +
+            `Existing: ${this.claudeSessionId}, New: ${sessionId}. ` +
+            `This indicates a session identity corruption bug.`);
+    }
+    handleSystemMessage(message) {
+        if (message.subtype !== "init") {
+            return 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();
+        if (!newSessionId) {
+            return null;
+        }
+        const existingSessionId = this.claudeSessionId;
+        let threadStartedSessionId = null;
+        if (existingSessionId === null) {
+            // First time setting session ID (empty → filled) - this is expected
+            this.claudeSessionId = newSessionId;
+            threadStartedSessionId = newSessionId;
+            this.logger.debug({ sessionId: newSessionId }, "Claude session ID set for the first time");
+        }
+        else if (existingSessionId === newSessionId) {
+            // Same session ID - no-op, but log for visibility
+            this.logger.debug({ sessionId: newSessionId }, "Claude session ID unchanged (same value)");
+        }
+        else {
+            // CRITICAL: Session ID is being overwritten with a different value
+            // This should NEVER happen and indicates a serious bug
+            throw new Error(`CRITICAL: Claude session ID overwrite detected! ` +
+                `Existing: ${existingSessionId}, New: ${newSessionId}. ` +
+                `This indicates a session identity corruption bug.`);
+        }
+        this.availableModes = DEFAULT_MODES;
+        this.currentMode = message.permissionMode;
+        this.persistence = null;
+        // Capture actual model from SDK init message (not just the configured model)
+        if (message.model) {
+            const normalizedModel = normalizeClaudeRuntimeModelId({
+                runtimeModelId: message.model,
+                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;
+            // Invalidate cached runtime info so it picks up the new model
+            this.cachedRuntimeInfo = null;
+        }
+        return threadStartedSessionId;
+    }
+    convertUsage(message) {
+        if (!message.usage) {
+            return undefined;
+        }
+        return {
+            inputTokens: message.usage.input_tokens,
+            cachedInputTokens: message.usage.cache_read_input_tokens,
+            outputTokens: message.usage.output_tokens,
+            totalCostUsd: message.total_cost_usd,
+        };
+    }
+    enqueueTimeline(item) {
+        this.pushEvent({ type: "timeline", item, provider: "claude" });
+    }
+    flushPendingToolCalls() {
+        for (const [id, entry] of this.toolUseCache) {
+            if (entry.started) {
+                this.pushToolCall(mapClaudeCanceledToolCall({
+                    name: entry.name,
+                    callId: id,
+                    input: entry.input ?? null,
+                    output: null,
+                }));
+            }
+        }
+        this.toolUseCache.clear();
+        this.activeSidechains.clear();
+    }
+    pushToolCall(item, target) {
+        if (!item) {
+            return;
+        }
+        if (target) {
+            target.push(item);
+            return;
+        }
+        this.enqueueTimeline(item);
+    }
+    pushEvent(event) {
+        const foregroundTurn = this.activeForegroundTurn;
+        if (foregroundTurn) {
+            const run = this.runTracker.getRun(foregroundTurn.runId);
+            if (run &&
+                run.owner === "foreground" &&
+                run.queue === foregroundTurn.queue &&
+                this.runTracker.isRunActive(run)) {
+                foregroundTurn.queue.push(event);
+                return;
+            }
+            this.activeForegroundTurn = null;
+        }
+        this.liveEventQueue.push(event);
+    }
+    normalizePermissionUpdates(updates) {
+        if (!updates || updates.length === 0) {
+            return undefined;
+        }
+        const normalized = updates.filter(isPermissionUpdate);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    rejectAllPendingPermissions(error) {
+        for (const [id, pending] of this.pendingPermissions) {
+            pending.cleanup?.();
+            pending.reject(error);
+            this.pendingPermissions.delete(id);
+        }
+    }
+    waitForLiveHistoryPoll() {
+        return new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    loadPersistedHistory(sessionId) {
+        try {
+            const historyPath = this.resolveHistoryPath(sessionId);
+            if (!historyPath || !fs.existsSync(historyPath)) {
+                return;
+            }
+            const content = fs.readFileSync(historyPath, "utf8");
+            const timeline = [];
+            for (const line of content.split(/\n+/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const entry = JSON.parse(trimmed);
+                    if (entry.isSidechain) {
+                        continue;
+                    }
+                    if (entry.type === "user" && typeof entry.uuid === "string") {
+                        this.rememberUserMessageId(entry.uuid);
+                    }
+                    const items = this.convertHistoryEntry(entry);
+                    if (items.length > 0) {
+                        timeline.push(...items);
+                    }
+                }
+                catch (error) {
+                    // ignore malformed history line
+                }
+            }
+            if (timeline.length > 0) {
+                this.persistedHistory = timeline;
+                this.historyPending = true;
+            }
+        }
+        catch (error) {
+            // ignore history load failures
+        }
+    }
+    resolveHistoryPath(sessionId) {
+        const cwd = this.config.cwd;
+        if (!cwd)
+            return null;
+        // Match Claude CLI's path sanitization: replace slashes, dots, and underscores with dashes
+        const sanitized = cwd.replace(/[\\/\.]/g, "-").replace(/_/g, "-");
+        const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+        const dir = path.join(configDir, "projects", sanitized);
+        return path.join(dir, `${sessionId}.jsonl`);
+    }
+    convertHistoryEntry(entry) {
+        return convertClaudeHistoryEntry(entry, (content) => this.mapBlocksToTimeline(content));
+    }
+    mapBlocksToTimeline(content, options) {
+        const suppressAssistant = options?.suppressAssistantText ?? false;
+        const suppressReasoning = options?.suppressReasoning ?? false;
+        if (typeof content === "string") {
+            if (!content || content === INTERRUPT_TOOL_USE_PLACEHOLDER) {
+                return [];
+            }
+            if (suppressAssistant) {
+                return [];
+            }
+            return [{ type: "assistant_message", text: content }];
+        }
+        const items = [];
+        for (const block of content) {
+            switch (block.type) {
+                case "text":
+                case "text_delta":
+                    if (block.text && block.text !== INTERRUPT_TOOL_USE_PLACEHOLDER) {
+                        if (!suppressAssistant) {
+                            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;
+            }
+        }
+        return items;
+    }
+    handleToolUseStart(block, items) {
+        const entry = this.upsertToolUseEntry(block);
+        if (!entry) {
+            return;
+        }
+        if (entry.started) {
+            return;
+        }
+        entry.started = true;
+        this.toolUseCache.set(entry.id, entry);
+        this.pushToolCall(mapClaudeRunningToolCall({
+            name: entry.name,
+            callId: entry.id,
+            input: entry.input ?? this.normalizeToolInput(block.input) ?? null,
+            output: null,
+        }), items);
+    }
+    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 callId = typeof block.tool_use_id === "string" && block.tool_use_id.length > 0
+            ? block.tool_use_id
+            : entry?.id ?? null;
+        // Extract output from block.content (SDK always returns content in string form)
+        const output = this.buildToolOutput(block, entry);
+        if (block.is_error) {
+            this.pushToolCall(mapClaudeFailedToolCall({
+                name: toolName,
+                callId,
+                input: entry?.input ?? null,
+                output: output ?? null,
+                error: block,
+            }), items);
+        }
+        else {
+            this.pushToolCall(mapClaudeCompletedToolCall({
+                name: toolName,
+                callId,
+                input: entry?.input ?? null,
+                output: output ?? null,
+            }), items);
+        }
+        if (typeof block.tool_use_id === "string") {
+            this.toolUseCache.delete(block.tool_use_id);
+            this.activeSidechains.delete(block.tool_use_id);
+        }
+    }
+    buildToolOutput(block, entry) {
+        if (block.is_error) {
+            return undefined;
+        }
+        const server = entry?.server ?? block.server ?? "tool";
+        const tool = entry?.name ?? block.tool_name ?? "tool";
+        const content = coerceToolResultContentToString(block.content);
+        const input = entry?.input;
+        // Build structured result based on tool type
+        const structured = this.buildStructuredToolResult(server, tool, content, input);
+        if (structured) {
+            return structured;
+        }
+        // Fallback format - try to parse JSON first
+        const result = {};
+        if (content.length > 0) {
+            try {
+                // If content is a JSON string, parse it
+                result.output = JSON.parse(content);
+            }
+            catch {
+                // If not JSON, return unchanged (no extra wrapping)
+                result.output = content;
+            }
+        }
+        // Preserve file changes tracked during tool execution
+        if (entry?.files?.length) {
+            result.files = entry.files;
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    buildStructuredToolResult(server, tool, output, input) {
+        const normalizedServer = server.toLowerCase();
+        const normalizedTool = tool.toLowerCase();
+        // Command execution tools
+        if (normalizedServer.includes("bash") ||
+            normalizedServer.includes("shell") ||
+            normalizedServer.includes("command") ||
+            normalizedTool.includes("bash") ||
+            normalizedTool.includes("shell") ||
+            normalizedTool.includes("command") ||
+            (input && (typeof input.command === "string" || Array.isArray(input.command)))) {
+            const command = this.extractCommandText(input ?? {}) ?? "command";
+            return {
+                type: "command",
+                command,
+                output,
+                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,
+                };
+            }
+        }
+        // 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,
+                };
+            }
+        }
+        // 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,
+                };
+            }
+        }
+        return undefined;
+    }
+    mapPartialEvent(event, options) {
+        if (event.type === "content_block_start") {
+            const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
+            if (block?.type === "tool_use" && typeof event.index === "number" && typeof block.id === "string") {
+                this.toolUseIndexToId.set(event.index, block.id);
+                this.toolUseInputBuffers.delete(block.id);
+            }
+        }
+        else 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 [];
+            }
+        }
+        else 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);
+            }
+        }
+        switch (event.type) {
+            case "content_block_start":
+                return isClaudeContentChunk(event.content_block)
+                    ? this.mapBlocksToTimeline([event.content_block], {
+                        suppressAssistantText: options?.suppressAssistantText,
+                        suppressReasoning: options?.suppressReasoning,
+                    })
+                    : [];
+            case "content_block_delta":
+                return isClaudeContentChunk(event.delta)
+                    ? this.mapBlocksToTimeline([event.delta], {
+                        suppressAssistantText: options?.suppressAssistantText,
+                        suppressReasoning: options?.suppressReasoning,
+                    })
+                    : [];
+            default:
+                return [];
+        }
+    }
+    upsertToolUseEntry(block) {
+        const id = typeof block.id === "string" ? block.id : undefined;
+        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,
+            };
+        if (typeof block.name === "string" && block.name.length > 0) {
+            existing.name = block.name;
+        }
+        if (typeof block.server === "string" && block.server.length > 0) {
+            existing.server = block.server;
+        }
+        else if (!existing.server) {
+            existing.server = existing.name;
+        }
+        if (block.type === "tool_use" || block.type === "mcp_tool_use" || block.type === "server_tool_use") {
+            const input = this.normalizeToolInput(block.input);
+            if (input) {
+                this.applyToolInput(existing, input);
+            }
+        }
+        this.toolUseCache.set(id, existing);
+        return existing;
+    }
+    handleToolInputDelta(index, partialJson) {
+        if (typeof index !== "number" || typeof partialJson !== "string") {
+            return;
+        }
+        const toolId = this.toolUseIndexToId.get(index);
+        if (!toolId) {
+            return;
+        }
+        const buffer = (this.toolUseInputBuffers.get(toolId) ?? "") + partialJson;
+        this.toolUseInputBuffers.set(toolId, buffer);
+        let parsed;
+        try {
+            parsed = JSON.parse(buffer);
+        }
+        catch {
+            return;
+        }
+        const entry = this.toolUseCache.get(toolId);
+        const normalized = this.normalizeToolInput(parsed);
+        if (!entry || !normalized) {
+            return;
+        }
+        this.applyToolInput(entry, normalized);
+        this.toolUseCache.set(toolId, entry);
+        this.pushToolCall(mapClaudeRunningToolCall({
+            name: entry.name,
+            callId: toolId,
+            input: normalized,
+            output: null,
+        }));
+    }
+    normalizeToolInput(input) {
+        if (!isMetadata(input)) {
+            return null;
+        }
+        return input;
+    }
+    applyToolInput(entry, input) {
+        entry.input = input;
+        if (this.isCommandTool(entry.name, input)) {
+            entry.classification = "command";
+            entry.commandText = this.extractCommandText(input) ?? entry.commandText;
+        }
+        else {
+            const files = this.extractFileChanges(input);
+            if (files?.length) {
+                entry.classification = "file_change";
+                entry.files = files;
+            }
+        }
+    }
+    isCommandTool(name, input) {
+        const normalized = name.toLowerCase();
+        if (normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+            return true;
+        }
+        if (typeof input.command === "string" || Array.isArray(input.command)) {
+            return true;
+        }
+        return false;
+    }
+    extractCommandText(input) {
+        const command = input.command;
+        if (typeof command === "string" && command.length > 0) {
+            return command;
+        }
+        if (Array.isArray(command)) {
+            const tokens = command.filter((value) => typeof value === "string");
+            if (tokens.length > 0) {
+                return tokens.join(" ");
+            }
+        }
+        if (typeof input.description === "string" && input.description.length > 0) {
+            return input.description;
+        }
+        return undefined;
+    }
+    extractFileChanges(input) {
+        if (typeof input.file_path === "string" && input.file_path.length > 0) {
+            const relative = this.relativizePath(input.file_path);
+            if (relative) {
+                return [{ path: relative, kind: this.detectFileKind(input.file_path) }];
+            }
+        }
+        if (typeof input.patch === "string" && input.patch.length > 0) {
+            const files = this.parsePatchFileList(input.patch);
+            if (files.length > 0) {
+                return files.map((entry) => ({
+                    path: this.relativizePath(entry.path) ?? entry.path,
+                    kind: entry.kind,
+                }));
+            }
+        }
+        if (Array.isArray(input.files)) {
+            const files = [];
+            for (const value of input.files) {
+                if (typeof value === "string" && value.length > 0) {
+                    files.push({ path: this.relativizePath(value) ?? value, kind: this.detectFileKind(value) });
+                }
+            }
+            if (files.length > 0) {
+                return files;
+            }
+        }
+        return undefined;
+    }
+    detectFileKind(filePath) {
+        try {
+            return fs.existsSync(filePath) ? "update" : "add";
+        }
+        catch {
+            return "update";
+        }
+    }
+    relativizePath(target) {
+        if (!target) {
+            return undefined;
+        }
+        const cwd = this.config.cwd;
+        if (cwd && target.startsWith(cwd)) {
+            const relative = path.relative(cwd, target);
+            return relative.length > 0 ? relative : path.basename(target);
+        }
+        return target;
+    }
+    parsePatchFileList(patch) {
+        const files = [];
+        const seen = new Set();
+        for (const line of patch.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            let kind = null;
+            let parsedPath = null;
+            if (trimmed.startsWith("*** Add File:")) {
+                kind = "add";
+                parsedPath = trimmed.replace("*** Add File:", "").trim();
+            }
+            else if (trimmed.startsWith("*** Delete File:")) {
+                kind = "delete";
+                parsedPath = trimmed.replace("*** Delete File:", "").trim();
+            }
+            else if (trimmed.startsWith("*** Update File:")) {
+                kind = "update";
+                parsedPath = trimmed.replace("*** Update File:", "").trim();
+            }
+            if (kind && parsedPath && !seen.has(`${kind}:${parsedPath}`)) {
+                seen.add(`${kind}:${parsedPath}`);
+                files.push({ path: parsedPath, kind });
+            }
+        }
+        return files;
+    }
+}
+function hasToolLikeBlock(block) {
+    if (!block || typeof block !== "object") {
+        return false;
+    }
+    const type = typeof block.type === "string" ? block.type.toLowerCase() : "";
+    return type.includes("tool");
+}
+function readCompactionMetadata(source) {
+    const candidates = [
+        source.compact_metadata,
+        source.compactMetadata,
+        source.compactionMetadata,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== "object") {
+            continue;
+        }
+        const metadata = candidate;
+        const trigger = typeof metadata.trigger === "string" ? metadata.trigger : undefined;
+        const preTokensRaw = metadata.preTokens ?? metadata.pre_tokens;
+        const preTokens = typeof preTokensRaw === "number" ? preTokensRaw : undefined;
+        return { trigger, preTokens };
+    }
+    return null;
+}
+function normalizeHistoryBlocks(content) {
+    if (Array.isArray(content)) {
+        const blocks = content.filter((entry) => isClaudeContentChunk(entry));
+        return blocks.length > 0 ? blocks : null;
+    }
+    if (isClaudeContentChunk(content)) {
+        return [content];
+    }
+    return null;
+}
+export function convertClaudeHistoryEntry(entry, mapBlocks) {
+    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,
+            }];
+    }
+    if (entry.type === "system") {
+        const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(entry);
+        if (taskNotificationItem) {
+            return [taskNotificationItem];
+        }
+    }
+    if (entry.isCompactSummary) {
+        return [];
+    }
+    if (entry.type === "user" && isSyntheticUserEntry(entry)) {
+        return [];
+    }
+    const message = entry?.message;
+    if (!message || !("content" in message)) {
+        return [];
+    }
+    const content = message.content;
+    const normalizedBlocks = normalizeHistoryBlocks(content);
+    const contentValue = typeof content === "string"
+        ? content
+        : normalizedBlocks;
+    const hasToolBlock = normalizedBlocks?.some((block) => hasToolLikeBlock(block)) ?? false;
+    const userMessageId = entry.type === "user" && typeof entry.uuid === "string" && entry.uuid.length > 0
+        ? entry.uuid
+        : null;
+    if (entry.type === "user") {
+        const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
+            content,
+            messageId: userMessageId,
+        });
+        if (taskNotificationItem) {
+            return [taskNotificationItem];
+        }
+    }
+    const timeline = [];
+    if (entry.type === "user") {
+        const text = extractUserMessageText(content);
+        if (text) {
+            timeline.push({
+                type: "user_message",
+                text,
+                ...(userMessageId ? { messageId: userMessageId } : {}),
+            });
+        }
+    }
+    if (hasToolBlock && normalizedBlocks) {
+        const mapped = mapBlocks(normalizedBlocks);
+        if (entry.type === "user") {
+            const toolItems = mapped.filter((item) => item.type === "tool_call");
+            return timeline.length ? [...timeline, ...toolItems] : toolItems;
+        }
+        return mapped;
+    }
+    if (entry.type === "assistant" && contentValue) {
+        return mapBlocks(contentValue);
+    }
+    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);
+                });
+            },
+        };
+    }
+}
+async function pathExists(target) {
+    try {
+        await fsPromises.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function collectRecentClaudeSessions(root, limit) {
+    let projectDirs;
+    try {
+        projectDirs = await fsPromises.readdir(root);
+    }
+    catch {
+        return [];
+    }
+    const candidates = [];
+    for (const dirName of projectDirs) {
+        const projectPath = path.join(root, dirName);
+        let stats;
+        try {
+            stats = await fsPromises.stat(projectPath);
+        }
+        catch {
+            continue;
+        }
+        if (!stats.isDirectory()) {
+            continue;
+        }
+        let files;
+        try {
+            files = await fsPromises.readdir(projectPath);
+        }
+        catch {
+            continue;
+        }
+        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
+            }
+        }
+    }
+    return candidates
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+        .slice(0, limit);
+}
+async function parseClaudeSessionDescriptor(filePath, mtime) {
+    let content;
+    try {
+        content = await fsPromises.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let sessionId = null;
+    let cwd = null;
+    let title = null;
+    const timeline = [];
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        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) {
+            break;
+        }
+    }
+    if (!sessionId || !cwd) {
+        return null;
+    }
+    const persistence = {
+        provider: "claude",
+        sessionId,
+        nativeHandle: sessionId,
+        metadata: {
+            provider: "claude",
+            cwd,
+        },
+    };
+    return {
+        provider: "claude",
+        sessionId,
+        cwd,
+        title: (title ?? "").trim() || `Claude session ${sessionId.slice(0, 8)}`,
+        lastActivityAt: mtime,
+        persistence,
+        timeline,
+    };
+}
+function extractClaudeUserText(message) {
+    if (!message) {
+        return null;
+    }
+    if (typeof message.content === "string") {
+        return message.content.trim();
+    }
+    if (typeof message.text === "string") {
+        return message.text.trim();
+    }
+    if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+            if (block && typeof block.text === "string") {
+                return block.text.trim();
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=claude-agent.js.map