@best-agent/cli 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/best-agent-native-bridge.js

@@ -1,4645 +0,0 @@
-import { extractPromptText, normalizePromptContentParts } from "@best-agent/protocol";
-import { t } from "./dimsdk/i18n/index.js";
-import { normalizeAskUserQuestions } from "./dimsdk/ask-user.js";
-import { createMessageMutations } from "./dimsdk/core/store/message-mutations.js";
-import { withPerfSpan, withPerfSpanAsync } from "./dimsdk/core/observability/perf-log.js";
-import { createTranscriptProjector } from "./dimsdk/core/store/transcript-projector.js";
-import { createThinkingPartIdFromReasoningItem, createThinkingPartIdFromStream, } from "./dimsdk/core/transcript-part-id.js";
-import { canonicalToolName, toolSemantic } from "./dimsdk/core/tool-metadata.js";
-function isLlmDebugEnabled() {
-    const raw = String(process.env.BEST_AGENT_LLM_DEBUG ?? "")
-        .trim()
-        .toLowerCase();
-    return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
-}
-function logLlmDebug(eventName, payload) {
-    if (!isLlmDebugEnabled())
-        return;
-    try {
-        const timestamp = new Date().toISOString();
-        const suffix = payload === undefined ? "" : ` ${JSON.stringify(payload)}`;
-        console.warn(`[best-agent][llm][${timestamp}] ${eventName}${suffix}`);
-    }
-    catch {
-        console.warn(`[best-agent][llm] ${eventName}`);
-    }
-}
-function createPendingTurnState(input) {
-    return {
-        ...(input.action ? { action: input.action } : {}),
-        ...(input.approval ? { approval: input.approval } : {}),
-        childToolInputsByCallId: new Map(),
-        inputDeltasByCallId: new Map(),
-        promise: input.promise ?? Promise.resolve(),
-        reasoningPartIdByStreamId: new Map(),
-        reasoningSummaries: [],
-        reasoningTextByStreamId: new Map(),
-        sawReasoningTokens: false,
-        sawVisibleReasoning: false,
-        startedSubagentIds: new Set(),
-        startedToolCallIds: new Set(),
-        status: input.status,
-        streamedAgentTurnIds: new Set(),
-        streamedReasoning: false,
-        streamedChildToolCallIds: new Set(),
-        streamedToolInputCallIds: new Set(),
-        pendingSteerPrompts: [],
-        subagentDescriptionsById: new Map(),
-        ...(input.turnId ? { turnId: input.turnId } : {}),
-        toolInputsByCallId: new Map(),
-        toolNamesByCallId: new Map(),
-    };
-}
-function createAsyncQueue(opts) {
-    const state = {
-        closed: false,
-        pending: [],
-        waiters: [],
-    };
-    let closedNotified = false;
-    const notifyClosed = () => {
-        if (closedNotified)
-            return;
-        closedNotified = true;
-        opts?.onClose?.();
-    };
-    return {
-        close() {
-            if (state.closed)
-                return;
-            state.closed = true;
-            while (state.waiters.length > 0)
-                state.waiters.shift()?.({ done: true, value: undefined });
-            notifyClosed();
-        },
-        push(value) {
-            if (state.closed)
-                return;
-            const waiter = state.waiters.shift();
-            if (waiter) {
-                waiter({ done: false, value });
-                return;
-            }
-            state.pending.push(value);
-        },
-        [Symbol.asyncIterator]() {
-            return {
-                next() {
-                    if (state.pending.length > 0) {
-                        return Promise.resolve({
-                            done: false,
-                            value: state.pending.shift(),
-                        });
-                    }
-                    if (state.closed)
-                        return Promise.resolve({ done: true, value: undefined });
-                    return new Promise((resolve) => {
-                        state.waiters.push(resolve);
-                    });
-                },
-                return() {
-                    if (!state.closed) {
-                        state.closed = true;
-                        while (state.waiters.length > 0)
-                            state.waiters.shift()?.({ done: true, value: undefined });
-                    }
-                    notifyClosed();
-                    return Promise.resolve({ done: true, value: undefined });
-                },
-            };
-        },
-    };
-}
-function normalizeText(value) {
-    return String(value ?? "").trim();
-}
-function manualCompactionFailureCode(error) {
-    const raw = error && typeof error === "object"
-        ? normalizeText(error.errorCode ?? error.code)
-        : "";
-    if (raw === "REQUEST_BUDGET_EXCEEDED" || raw === "PROVIDER_CONTEXT_OVERFLOW") {
-        return "compact_token_limit";
-    }
-    return raw || undefined;
-}
-function runtimeErrorCode(error) {
-    if (!error || typeof error !== "object")
-        return "";
-    return normalizeText(error.errorCode ?? error.code);
-}
-function isApprovalNotFoundError(error) {
-    if (runtimeErrorCode(error) === "APPROVAL_NOT_FOUND")
-        return true;
-    return error instanceof Error && /\bApproval approval_[^\s]+ not found\b/.test(error.message);
-}
-function isHiddenRuntimeReasoningSummary(summary) {
-    return (/^The .+ profile selected tool [^:]+: .+/.test(summary) ||
-        /^The orchestrator profile started the .+ workflow\.$/.test(summary) ||
-        /^The orchestrator profile started the deep-research workflow with \d+ sub-questions\.$/.test(summary) ||
-        /^Deep research completed with \d+ evidence cards and \d+ sub-question failures\.$/.test(summary) ||
-        /^Workflow phase (explore|plan|build|verify) started under the .+ profile and is running in thread .+\.$/.test(summary) ||
-        /^Workflow phase (explore|plan|build|verify) result: [\s\S]+$/.test(summary) ||
-        /^Research sub-question .+ started in thread .+\.$/.test(summary) ||
-        /^Research sub-question .+ started under the .+ profile\.$/.test(summary) ||
-        /^Research sub-question .+ result: [\s\S]+$/.test(summary) ||
-        /^Research sub-question .+ failed: [\s\S]+$/.test(summary) ||
-        /^Coordinator worker .+ started under the .+ profile(?: and is running in thread .+)?\.$/.test(summary) ||
-        /^Coordinator worker .+ result: [\s\S]+$/.test(summary) ||
-        /^Coordinator worker .+ failed: [\s\S]+$/.test(summary) ||
-        /^Workflow child phase (explore|plan|build|verify) started under the .+ profile\.$/.test(summary));
-}
-function isDraftReasoningItem(item) {
-    return (item.status === "draft" ||
-        (normalizeText(item.status).length === 0 &&
-            normalizeText(item.content).length === 0 &&
-            isHiddenRuntimeReasoningSummary(item.summary)));
-}
-function hasVisibleReasoningText(value) {
-    return normalizeText(value).length > 0;
-}
-function normalizeReasoningDiagnosticState(value) {
-    const normalized = normalizeText(value);
-    if (normalized === "visible" || normalized === "tokens_only" || normalized === "none") {
-        return normalized;
-    }
-    return undefined;
-}
-function normalizeReasoningDiagnosticsByTurn(value) {
-    const record = asRecord(value);
-    const next = {};
-    for (const [turnId, state] of Object.entries(record)) {
-        const normalizedTurnId = normalizeText(turnId);
-        const normalizedState = normalizeReasoningDiagnosticState(state);
-        if (!normalizedTurnId || !normalizedState)
-            continue;
-        next[normalizedTurnId] = normalizedState;
-    }
-    return next;
-}
-function buildReasoningInfoPart(state) {
-    if (state === "visible") {
-        return {
-            _reasoning: state,
-            _tone: "success",
-            text: "",
-            type: "info",
-        };
-    }
-    if (state === "tokens_only") {
-        return {
-            _reasoning: state,
-            _tone: "warning",
-            text: "",
-            type: "info",
-        };
-    }
-    return {
-        _reasoning: state,
-        text: "",
-        type: "info",
-    };
-}
-function isBenignAskUserCancelInterruptError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const record = error;
-    const name = typeof record.name === "string" ? record.name : "";
-    const message = typeof record.message === "string" ? record.message : "";
-    const code = typeof record.code === "string" ? record.code : "";
-    return (name === "TurnTerminatedError" ||
-        message === "Turn terminated" ||
-        code === "TURN_NOT_ACTIVE" ||
-        code === "TURN_MISMATCH");
-}
-function asRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return {};
-    return value;
-}
-function bridgePartSubagentId(part) {
-    const record = asRecord(part);
-    const metaId = normalizeText(record._subagentId);
-    if (metaId)
-        return metaId;
-    if (part.type === "tool_call")
-        return normalizeText(part.call.subagentId);
-    if (part.type === "tool_output")
-        return normalizeText(part.subagentId);
-    if (part.type === "tool_result")
-        return normalizeText(part.result.subagentId);
-    if (part.type === "approve")
-        return normalizeText(part.request.subagentId);
-    return "";
-}
-function bridgeRelatedToolCallId(part) {
-    if (part.type === "tool_call")
-        return normalizeText(part.call.id);
-    if (part.type === "tool_output")
-        return normalizeText(part.toolCallId);
-    if (part.type === "tool_result")
-        return normalizeText(part.result.toolCallId);
-    if (part.type === "approve")
-        return normalizeText(part.request.toolCallId);
-    return "";
-}
-function isTerminalBridgeSubagentPart(part) {
-    if (part.type !== "info")
-        return false;
-    const record = asRecord(part);
-    const kind = normalizeText(record._subagent);
-    const state = normalizeText(record._subagentState);
-    return (kind === "finished" ||
-        state === "done" ||
-        state === "completed" ||
-        state === "failed" ||
-        state === "rejected");
-}
-function cleanupInterruptedBridgeAssistantMessage(messages, assistantId, unfinishedThinkingPartIds) {
-    const assistantIndex = messages.findIndex((message) => message.role === "assistant" && message.id === assistantId);
-    if (assistantIndex < 0)
-        return;
-    const assistant = messages[assistantIndex];
-    const thinkingIds = new Set(unfinishedThinkingPartIds.map(normalizeText).filter(Boolean));
-    const completedToolCallIds = new Set();
-    for (const part of assistant.parts) {
-        if (part.type === "tool_result") {
-            completedToolCallIds.add(normalizeText(part.result.toolCallId));
-        }
-    }
-    for (const message of messages) {
-        if (message.role === "tool")
-            completedToolCallIds.add(normalizeText(message.result.toolCallId));
-    }
-    const unfinishedToolCallIds = new Set();
-    const subagentIds = new Set();
-    const finishedSubagentIds = new Set();
-    for (const part of assistant.parts) {
-        const subagentId = bridgePartSubagentId(part);
-        if (subagentId)
-            subagentIds.add(subagentId);
-        if (subagentId && isTerminalBridgeSubagentPart(part))
-            finishedSubagentIds.add(subagentId);
-        if (part.type === "tool_call") {
-            const callId = normalizeText(part.call.id);
-            if (callId && !completedToolCallIds.has(callId))
-                unfinishedToolCallIds.add(callId);
-        }
-    }
-    const unfinishedSubagentIds = new Set([...subagentIds].filter((subagentId) => !finishedSubagentIds.has(subagentId)));
-    messages[assistantIndex] = {
-        ...assistant,
-        parts: assistant.parts.filter((part) => {
-            if (part.type === "thinking" && thinkingIds.has(normalizeText(part.partId)))
-                return false;
-            const subagentId = bridgePartSubagentId(part);
-            if (subagentId && unfinishedSubagentIds.has(subagentId))
-                return false;
-            const callId = bridgeRelatedToolCallId(part);
-            if (callId && unfinishedToolCallIds.has(callId))
-                return false;
-            return true;
-        }),
-    };
-    if (unfinishedToolCallIds.size === 0)
-        return;
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = messages[index];
-        if (message?.role === "tool" &&
-            unfinishedToolCallIds.has(normalizeText(message.result.toolCallId))) {
-            messages.splice(index, 1);
-        }
-    }
-}
-function bridgeAssistantHasMarkdownOutput(messages, assistantId) {
-    const message = messages.find((candidate) => candidate.role === "assistant" && candidate.id === assistantId);
-    return Boolean(message?.role === "assistant" &&
-        message.parts.some((part) => part.type === "markdown" && normalizeText(part.markdown)));
-}
-function bridgeInterruptedMarkdown(appendToExisting) {
-    const line = t("chatStatus.interruptedMarkdown");
-    return appendToExisting ? `\n\n${line}` : line;
-}
-function cloneJson(value) {
-    return JSON.parse(JSON.stringify(value ?? null));
-}
-function normalizePositiveNumber(value) {
-    const numeric = Number(value);
-    if (!Number.isFinite(numeric) || numeric <= 0)
-        return null;
-    return Math.floor(numeric);
-}
-function normalizeNonNegativeNumber(value) {
-    const numeric = Number(value);
-    if (!Number.isFinite(numeric) || numeric < 0)
-        return null;
-    return Math.floor(numeric);
-}
-function normalizeLastRequestBudget(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    const estimatedInputTokens = normalizeNonNegativeNumber(raw.estimatedInputTokens);
-    const autoBudgetOutcome = normalizeText(raw.autoBudgetOutcome) ||
-        (raw.usedAutoCompaction === true ? "compacted" : "not-needed");
-    const inputBudgetTokens = normalizePositiveNumber(raw.inputBudgetTokens);
-    const contextWindowTokens = normalizePositiveNumber(raw.contextWindowTokens);
-    const maxOutputTokens = normalizeNonNegativeNumber(raw.maxOutputTokens);
-    const protocolReserveTokens = normalizeNonNegativeNumber(raw.protocolReserveTokens);
-    const reservedOutputTokens = normalizeNonNegativeNumber(raw.reservedOutputTokens);
-    const thresholdTokens = normalizePositiveNumber(raw.thresholdTokens);
-    const maxInputTokens = normalizePositiveNumber(raw.maxInputTokens);
-    const triggerRatio = Number(raw.triggerRatio);
-    const updatedAtMs = normalizePositiveNumber(raw.updatedAtMs) ?? Date.now();
-    if (estimatedInputTokens == null ||
-        (autoBudgetOutcome !== "not-needed" &&
-            autoBudgetOutcome !== "compacted" &&
-            autoBudgetOutcome !== "failed-to-fit" &&
-            autoBudgetOutcome !== "budget-unknown")) {
-        return null;
-    }
-    return {
-        runId: normalizeText(raw.runId) || undefined,
-        requestId: normalizeText(raw.requestId) || undefined,
-        autoBudgetOutcome,
-        autoBudgetReasonCode: normalizeText(raw.autoBudgetReasonCode) || undefined,
-        budgetSource: normalizeText(raw.budgetSource) || undefined,
-        ...(contextWindowTokens != null ? { contextWindowTokens } : {}),
-        estimatedInputTokens,
-        ...(inputBudgetTokens != null ? { inputBudgetTokens } : {}),
-        ...(maxOutputTokens != null ? { maxOutputTokens } : {}),
-        ...(protocolReserveTokens != null ? { protocolReserveTokens } : {}),
-        ...(reservedOutputTokens != null ? { reservedOutputTokens } : {}),
-        ...(thresholdTokens != null ? { thresholdTokens } : {}),
-        ...(maxInputTokens != null ? { maxInputTokens } : {}),
-        ...(Number.isFinite(triggerRatio) && triggerRatio > 0 ? { triggerRatio } : {}),
-        usedAutoCompaction: raw.usedAutoCompaction === true,
-        updatedAt: normalizeText(raw.updatedAt) || undefined,
-        updatedAtMs,
-    };
-}
-function cliModeFromThreadMode(mode) {
-    return mode === "plan" ? "plan" : "agent";
-}
-function threadModeFromCliMode(modeId) {
-    return modeId === "plan" ? "plan" : "default";
-}
-function parseToolInput(input) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return {};
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-            return parsed;
-    }
-    catch { }
-    return { _raw: trimmed };
-}
-function readExplicitToolCallId(input) {
-    const callId = normalizeText(input.callId);
-    return callId || undefined;
-}
-function resolveToolItemCallId(input) {
-    return readExplicitToolCallId(input) ?? normalizeText(input.id);
-}
-function usageMetadataFromSessionUsage(usage) {
-    const promptTokens = Math.max(0, Math.floor(Number(usage.inputTokens ?? 0)));
-    const completionTokens = Math.max(0, Math.floor(Number(usage.outputTokens ?? 0)));
-    const reasoningTokens = Math.max(0, Math.floor(Number(usage.reasoningTokens ?? 0)));
-    const totalTokens = Math.max(0, Math.floor(Number(usage.totalTokens ?? 0)));
-    if (!Number.isFinite(totalTokens) || totalTokens <= 0)
-        return undefined;
-    return {
-        completionTokens,
-        promptTokens,
-        reasoningTokens,
-        totalTokens,
-    };
-}
-function hasReasoningTokens(usage) {
-    const reasoningTokens = Math.max(0, Math.floor(Number(usage?.reasoningTokens ?? 0)));
-    return reasoningTokens > 0;
-}
-function updatePendingReasoningTokens(pending, usage) {
-    if (hasReasoningTokens(usage))
-        pending.sawReasoningTokens = true;
-}
-function consumePendingSteerPrompt(pending, text) {
-    const normalizedText = normalizeText(text);
-    if (!normalizedText)
-        return false;
-    const index = pending.pendingSteerPrompts.findIndex((prompt) => normalizeText(prompt) === normalizedText);
-    if (index < 0)
-        return false;
-    pending.pendingSteerPrompts.splice(index, 1);
-    return true;
-}
-function resolvePendingReasoningDiagnostics(pending) {
-    if (pending.sawVisibleReasoning)
-        return { state: "visible" };
-    if (pending.sawReasoningTokens)
-        return { state: "tokens_only" };
-    return { state: "none" };
-}
-const AUTO_COMPACTION_TRIGGER_RATIO = 0.8;
-function resolveAutoCompactionThresholdTokens(maxInputTokens) {
-    const normalizedMaxInputTokens = Math.max(0, Math.floor(Number(maxInputTokens ?? 0)));
-    if (normalizedMaxInputTokens <= 0)
-        return 0;
-    return Math.max(1, Math.floor(normalizedMaxInputTokens * AUTO_COMPACTION_TRIGGER_RATIO));
-}
-function usageMetadataFromThreadUiMetadata(metadata) {
-    const usage = asRecord(metadata.usage);
-    const promptTokens = Math.max(0, Math.floor(Number(usage.promptTokens ?? usage.prompt_tokens ?? 0)));
-    const completionTokens = Math.max(0, Math.floor(Number(usage.completionTokens ?? usage.completion_tokens ?? 0)));
-    const reasoningTokens = Math.max(0, Math.floor(Number(usage.reasoningTokens ?? usage.reasoning_tokens ?? 0)));
-    const totalTokens = Math.max(0, Math.floor(Number(usage.totalTokens ?? usage.total_tokens ?? 0)));
-    if (totalTokens > 0) {
-        return {
-            completionTokens,
-            promptTokens,
-            reasoningTokens,
-            totalTokens,
-        };
-    }
-    if (promptTokens > 0 || completionTokens > 0) {
-        return {
-            completionTokens,
-            promptTokens,
-            reasoningTokens,
-            totalTokens: promptTokens + completionTokens,
-        };
-    }
-    return undefined;
-}
-function requestBudgetMetadataFromThreadUiMetadata(metadata) {
-    const budget = asRecord(metadata.lastRequestBudget);
-    const maxInputTokens = Math.max(0, Math.floor(Number(budget.inputBudgetTokens ?? budget.maxInputTokens ?? 0)));
-    return (normalizeLastRequestBudget({
-        autoBudgetOutcome: normalizeText(budget.autoBudgetOutcome) ||
-            (budget.usedAutoCompaction === true ? "compacted" : "not-needed"),
-        autoBudgetReasonCode: normalizeText(budget.autoBudgetReasonCode) || undefined,
-        budgetSource: normalizeText(budget.budgetSource) || undefined,
-        contextWindowTokens: budget.contextWindowTokens,
-        estimatedInputTokens: budget.estimatedInputTokens,
-        inputBudgetTokens: budget.inputBudgetTokens ?? maxInputTokens,
-        maxInputTokens,
-        maxOutputTokens: budget.maxOutputTokens,
-        protocolReserveTokens: budget.protocolReserveTokens,
-        reservedOutputTokens: budget.reservedOutputTokens,
-        thresholdTokens: budget.thresholdTokens ?? resolveAutoCompactionThresholdTokens(maxInputTokens),
-        triggerRatio: budget.triggerRatio ?? AUTO_COMPACTION_TRIGGER_RATIO,
-        updatedAt: normalizeText(budget.updatedAt) || undefined,
-        updatedAtMs: budget.updatedAtMs ?? Date.now(),
-        usedAutoCompaction: budget.usedAutoCompaction === true,
-        runId: normalizeText(budget.runId) || undefined,
-        requestId: normalizeText(budget.requestId) || undefined,
-    }) ?? undefined);
-}
-function restoreThreadUiMetricsIntoStore(store, thread) {
-    if (!store)
-        return;
-    const metadata = sessionUiMetadata(thread);
-    const usage = usageMetadataFromThreadUiMetadata(metadata);
-    const budget = requestBudgetMetadataFromThreadUiMetadata(metadata);
-    if (budget) {
-        if (typeof store.applyLastRequestBudget === "function")
-            store.applyLastRequestBudget(budget);
-        else if ("lastRequestBudget" in store.state)
-            store.state.lastRequestBudget = budget;
-    }
-    if (usage) {
-        if (typeof store.applyUsageFromSession === "function") {
-            store.applyUsageFromSession(usage);
-        }
-        else if (store.state.usage) {
-            store.state.usage.prompt_tokens = usage.promptTokens;
-            store.state.usage.completion_tokens = usage.completionTokens;
-            store.state.usage.total_tokens = usage.totalTokens;
-        }
-        return;
-    }
-    if (!budget || !store.state.usage)
-        return;
-    const fallbackPromptTokens = Math.max(0, Math.floor(Number(budget.estimatedInputTokens ?? 0)));
-    if (fallbackPromptTokens <= 0)
-        return;
-    if (typeof store.applyUsageFromSession === "function") {
-        store.applyUsageFromSession({
-            completionTokens: 0,
-            promptTokens: fallbackPromptTokens,
-            totalTokens: fallbackPromptTokens,
-        });
-    }
-    else {
-        store.state.usage.prompt_tokens = fallbackPromptTokens;
-        store.state.usage.completion_tokens = 0;
-        store.state.usage.total_tokens = fallbackPromptTokens;
-    }
-}
-function requestBudgetMetadataFromCompactedEvent(event) {
-    if (event.lastRequestBudget)
-        return normalizeLastRequestBudget(event.lastRequestBudget) ?? undefined;
-    const maxInputTokens = Math.max(0, Math.floor(Number(event.diagnostics.compaction.lastBudgetTokens ?? 0)));
-    const thresholdTokens = resolveAutoCompactionThresholdTokens(maxInputTokens);
-    const estimatedInputTokens = Math.max(0, Math.floor(Number(event.estimatedTokensAfter ?? event.diagnostics.compaction.lastEstimatedTokens ?? 0)));
-    if (!maxInputTokens || estimatedInputTokens == null)
-        return undefined;
-    return (normalizeLastRequestBudget({
-        autoBudgetOutcome: event.reason === "manual-user" ? "not-needed" : "compacted",
-        estimatedInputTokens,
-        inputBudgetTokens: maxInputTokens,
-        maxInputTokens,
-        thresholdTokens,
-        triggerRatio: AUTO_COMPACTION_TRIGGER_RATIO,
-        updatedAtMs: Date.now(),
-        usedAutoCompaction: event.reason !== "manual-user",
-    }) ?? undefined);
-}
-function syncStoreUsageMetrics(store, event) {
-    if (!store || store.state.sessionId !== event.threadId)
-        return;
-    const usage = usageMetadataFromSessionUsage(event.inclusive);
-    if (usage)
-        store.applyUsageFromSession?.(usage);
-    if (event.lastRequestBudget)
-        store.applyLastRequestBudget?.(event.lastRequestBudget);
-}
-function syncStoreBudgetMetrics(store, event) {
-    if (!store || store.state.sessionId !== event.threadId)
-        return;
-    const budget = requestBudgetMetadataFromCompactedEvent(event);
-    if (budget)
-        store.applyLastRequestBudget?.(budget);
-}
-function relationScopeLabel(relation) {
-    if (relation.kind === "workflow-phase")
-        return `${relation.workflowName}/${relation.phaseName}`;
-    if (relation.kind === "coordinator-worker")
-        return `${relation.workflowName}/${relation.workerId}`;
-    return `research/${relation.subquestionId}`;
-}
-function childScopeLabel(event) {
-    return relationScopeLabel(event.relation);
-}
-function parseIsoTimeMs(value) {
-    const text = normalizeText(value);
-    if (!text)
-        return undefined;
-    const ms = Date.parse(text);
-    return Number.isFinite(ms) ? ms : undefined;
-}
-function previewTraceText(value, max = 96) {
-    const firstLine = String(value ?? "")
-        .trim()
-        .split(/\r?\n/u)[0];
-    const compact = firstLine?.replace(/\s+/gu, " ").trim() ?? "";
-    if (!compact)
-        return undefined;
-    return compact.length > max ? `${compact.slice(0, max - 1)}…` : compact;
-}
-function sessionTraceEventTurnId(event) {
-    switch (event.type) {
-        case "turn.started":
-        case "turn.completed":
-        case "turn.interrupted":
-        case "turn.blocked":
-        case "turn.failed":
-        case "turn.reconciled":
-            return normalizeText(event.turn.id) || undefined;
-        case "run.started":
-        case "run.updated":
-        case "run.completed":
-        case "run.cancelled":
-        case "run.failed":
-            return normalizeText(event.run.turnId) || undefined;
-        case "step.started":
-        case "step.updated":
-        case "step.completed":
-            return normalizeText(event.step.turnId) || undefined;
-        case "phase.started":
-        case "phase.completed":
-        case "phase.reopened":
-        case "phase.blocked":
-        case "phase.failed":
-        case "turn.item.added":
-        case "turn.steered":
-        case "action.required":
-        case "thread.transcript.delta":
-        case "turn.text.delta":
-        case "turn.text.stream.reset":
-        case "turn.reasoning.started":
-        case "turn.reasoning.delta":
-        case "turn.reasoning.completed":
-        case "turn.tool-call.started":
-        case "turn.tool-call.delta":
-        case "turn.tool-output.delta":
-        case "workflow.phase.started":
-        case "workflow.phase.completed":
-        case "workflow.phase.failed":
-        case "child-task.started":
-        case "child-task.completed":
-        case "child-task.failed":
-        case "child-task.joined":
-        case "child-task.rejected":
-        case "coordinator.plan":
-        case "coordinator.synthesize":
-        case "coordinator.complete":
-        case "workspace.file.updated":
-        case "workspace.file.invalidated":
-        case "workspace.file.stale-write-rejected":
-        case "research.started":
-        case "research.subquestion.started":
-        case "research.subquestion.completed":
-        case "research.subquestion.failed":
-        case "research.evidence.added":
-        case "evidence.added":
-        case "research.synthesis.started":
-        case "research.audit.completed":
-        case "research.completed":
-        case "research.failed":
-        case "turn.queued":
-        case "turn.dequeued":
-        case "thread.forked":
-        case "thread.compacted":
-        case "thread.compaction.started":
-        case "thread.usage.updated":
-        case "routing.selected":
-        case "plan.started":
-        case "plan.updated":
-        case "plan.todo.updated":
-        case "plan.review_ready":
-        case "plan.approval.requested":
-            return normalizeText(event.turnId) || undefined;
-        case "approval.requested":
-            return normalizeText(event.approval.turnId) || undefined;
-        case "child-thread.item.added":
-            return normalizeText(event.parentTurnId) || undefined;
-        case "turn.queue.drained":
-        case "thread.archived":
-        case "thread.unarchived":
-        case "thread.purged":
-        case "plan.approved":
-        case "plan.rejected":
-        case "plan.handoff.ready":
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-function sessionTraceEventSummary(event) {
-    switch (event.type) {
-        case "turn.started":
-            return "turn started";
-        case "turn.completed":
-        case "turn.interrupted":
-        case "turn.blocked":
-        case "turn.failed":
-            return `turn ${event.turn.status}`;
-        case "run.started":
-            return `run started${event.run.phaseName ? ` · ${event.run.phaseName}` : ""}`;
-        case "run.updated":
-            return `run updated${event.run.phaseName ? ` · ${event.run.phaseName}` : ""}`;
-        case "run.completed":
-        case "run.cancelled":
-        case "run.failed":
-            return `run ${event.run.status}`;
-        case "step.started":
-        case "step.updated":
-        case "step.completed":
-            return `${event.step.kind} ${event.type.split(".").at(-1)}`;
-        case "phase.started":
-        case "phase.completed":
-        case "phase.reopened":
-        case "phase.blocked":
-        case "phase.failed":
-            return `${event.phaseName} ${event.type.split(".").at(-1)}`;
-        case "turn.item.added":
-            switch (event.item.kind) {
-                case "message":
-                    return `${event.item.role === "user" ? "user" : "assistant"} message${previewTraceText(event.item.text) ? ` · ${previewTraceText(event.item.text)}` : ""}`;
-                case "tool-call":
-                    return `tool call · ${event.item.toolName}`;
-                case "tool-result":
-                    return `tool result · ${event.item.toolName}`;
-                case "reasoning":
-                    return `reasoning${previewTraceText(event.item.summary) ? ` · ${previewTraceText(event.item.summary)}` : ""}`;
-                case "error":
-                    return `error${previewTraceText(event.item.message) ? ` · ${previewTraceText(event.item.message)}` : ""}`;
-                case "control":
-                    return `control · ${previewTraceText(event.item.summary) ?? event.item.action}`;
-            }
-        case "approval.requested":
-            return `approval requested · ${event.approval.group}/${event.approval.action}`;
-        case "action.required":
-            return `ask user · ${event.toolName}`;
-        case "thread.compaction.started":
-            return `compaction started · ${event.reason}`;
-        case "thread.compacted": {
-            const before = Number(event.estimatedTokensBefore ?? 0);
-            const after = Number(event.estimatedTokensAfter ?? 0);
-            return before > 0 && after > 0
-                ? `compacted · ${before} -> ${after}`
-                : `compacted · ${event.reason}`;
-        }
-        case "thread.usage.updated": {
-            const budget = event.lastRequestBudget;
-            const inputBudgetTokens = Math.floor(Number(budget?.inputBudgetTokens ?? budget?.maxInputTokens ?? 0));
-            return budget
-                ? `usage updated · ${Math.floor(budget.estimatedInputTokens)}/${inputBudgetTokens || 0}`
-                : "usage updated";
-        }
-        case "turn.text.delta":
-            return "assistant delta";
-        case "turn.text.stream.reset":
-            return "assistant stream reset";
-        case "turn.reasoning.started":
-            return "reasoning started";
-        case "turn.reasoning.delta":
-            return "reasoning delta";
-        case "turn.reasoning.completed":
-            return "reasoning completed";
-        case "turn.tool-call.started":
-            return `tool started · ${event.toolName}`;
-        case "turn.tool-call.delta":
-            return `tool delta · ${event.toolName}`;
-        case "turn.tool-output.delta":
-            return `tool output · ${event.toolName}`;
-        case "child-thread.item.added":
-            return `child ${childScopeLabel(event)} · ${event.item.kind}`;
-        case "child-task.started":
-        case "child-task.completed":
-        case "child-task.failed":
-        case "child-task.joined":
-        case "child-task.rejected":
-            return `${event.type.replace("child-task.", "child task ")} · ${previewTraceText(event.record.objective, 72) ?? event.record.profileName}`;
-        case "workflow.phase.started":
-        case "workflow.phase.completed":
-            return `${event.workflowName}/${event.phaseName} ${event.type.split(".").at(-1)}`;
-        case "workflow.phase.failed":
-            return `${event.workflowName}/${event.phaseName} failed · ${previewTraceText(event.message, 72) ?? event.failureKind}`;
-        case "research.started":
-            return `research started · ${previewTraceText(event.run.objective, 72) ?? event.run.runId}`;
-        case "research.completed":
-            return `research completed · ${previewTraceText(event.report.executiveSummary, 72) ?? event.runId}`;
-        case "research.failed":
-            return `research failed · ${previewTraceText(event.message, 72) ?? event.runId}`;
-        case "routing.selected":
-            return `routing selected · ${event.record.routingRole}/${event.record.model}`;
-        default:
-            return event.type;
-    }
-}
-function createSessionTraceBucket(id, kind, sequence, turnId) {
-    return {
-        id,
-        kind,
-        turnId,
-        status: kind === "session" ? "session" : "unknown",
-        userMessageCount: 0,
-        assistantMessageCount: 0,
-        compactionCount: 0,
-        events: [],
-        firstSeenSequence: sequence,
-        runIds: new Set(),
-        toolCallIds: new Set(),
-        childTaskIds: new Set(),
-    };
-}
-function collectSessionTraceItem(bucket, item) {
-    const createdAtMs = parseIsoTimeMs(item.createdAt);
-    if (createdAtMs != null) {
-        bucket.startedAt =
-            bucket.startedAt == null ? createdAtMs : Math.min(bucket.startedAt, createdAtMs);
-        bucket.firstSeenAt =
-            bucket.firstSeenAt == null ? createdAtMs : Math.min(bucket.firstSeenAt, createdAtMs);
-    }
-    if (item.kind === "message") {
-        if (item.role === "user") {
-            bucket.userMessageCount += 1;
-            bucket.promptPreview ??= previewTraceText(item.text);
-        }
-        else {
-            bucket.assistantMessageCount += 1;
-            bucket.assistantPreview ??= previewTraceText(item.text);
-        }
-        return;
-    }
-    if (item.kind === "tool-call") {
-        bucket.toolCallIds.add(normalizeText(item.callId) || normalizeText(item.id));
-    }
-}
-async function loadThreadTraceItems(runtime, threadId) {
-    const pages = [];
-    let beforeItemId;
-    while (true) {
-        const response = await runtime.getThreadHistory({
-            threadId,
-            ...(beforeItemId ? { beforeItemId: beforeItemId } : {}),
-            limit: 500,
-        });
-        pages.push([...response.items]);
-        if (!response.hasMore || !response.nextBeforeItemId)
-            break;
-        beforeItemId = response.nextBeforeItemId;
-    }
-    return pages.reverse().flat();
-}
-async function loadThreadTraceEvents(runtime, threadId) {
-    const events = [];
-    let afterSequence;
-    while (true) {
-        const response = await runtime.getThreadEvents({
-            threadId,
-            ...(afterSequence != null ? { afterSequence } : {}),
-            limit: 500,
-        });
-        events.push(...response.events);
-        if (!response.hasMore || response.nextAfterSequence == null)
-            break;
-        afterSequence = response.nextAfterSequence;
-    }
-    return events;
-}
-function buildSessionTrace(threadId, items, envelopes, processRecords = []) {
-    const sessionBucketId = "__session__";
-    const buckets = new Map();
-    const ensureBucket = (bucketId, kind, sequence, turnId) => {
-        const existing = buckets.get(bucketId);
-        if (existing)
-            return existing;
-        const bucket = createSessionTraceBucket(bucketId, kind, sequence, turnId);
-        buckets.set(bucketId, bucket);
-        return bucket;
-    };
-    for (const item of items) {
-        const turnId = normalizeText(item.turnId);
-        if (!turnId)
-            continue;
-        collectSessionTraceItem(ensureBucket(turnId, "turn", Number.MAX_SAFE_INTEGER, turnId), item);
-    }
-    for (const envelope of envelopes) {
-        const turnId = sessionTraceEventTurnId(envelope.event);
-        const bucket = ensureBucket(turnId || sessionBucketId, turnId ? "turn" : "session", envelope.sequence, turnId || undefined);
-        const at = parseIsoTimeMs(envelope.createdAt) ?? 0;
-        if (at > 0) {
-            bucket.firstSeenAt = bucket.firstSeenAt == null ? at : Math.min(bucket.firstSeenAt, at);
-        }
-        bucket.events.push({
-            at,
-            sequence: envelope.sequence,
-            summary: sessionTraceEventSummary(envelope.event),
-            type: envelope.event.type,
-        });
-        switch (envelope.event.type) {
-            case "turn.started":
-                bucket.status = envelope.event.turn.status;
-                bucket.startedAt ??= parseIsoTimeMs(envelope.event.turn.createdAt) ?? at;
-                break;
-            case "turn.completed":
-            case "turn.interrupted":
-            case "turn.blocked":
-            case "turn.failed":
-                bucket.status = envelope.event.turn.status;
-                bucket.completedAt =
-                    parseIsoTimeMs(envelope.event.turn.completedAt) ?? bucket.completedAt ?? at;
-                bucket.startedAt ??= parseIsoTimeMs(envelope.event.turn.createdAt) ?? at;
-                break;
-            case "run.started":
-            case "run.updated":
-            case "run.completed":
-            case "run.cancelled":
-            case "run.failed":
-                bucket.runIds.add(normalizeText(envelope.event.run.id));
-                bucket.startedAt ??= parseIsoTimeMs(envelope.event.run.startedAt) ?? at;
-                break;
-            case "turn.item.added":
-                collectSessionTraceItem(bucket, envelope.event.item);
-                break;
-            case "turn.tool-call.started":
-            case "turn.tool-call.delta":
-            case "turn.tool-output.delta":
-                bucket.toolCallIds.add(normalizeText(envelope.event.callId));
-                break;
-            case "child-thread.item.added":
-                bucket.childTaskIds.add(normalizeText(envelope.event.childThreadId) ||
-                    normalizeText(envelope.event.relation.correlationId));
-                break;
-            case "child-task.started":
-            case "child-task.completed":
-            case "child-task.failed":
-            case "child-task.joined":
-            case "child-task.rejected":
-                bucket.childTaskIds.add(normalizeText(envelope.event.record.childTaskId) ||
-                    normalizeText(envelope.event.record.childThreadId) ||
-                    normalizeText(envelope.event.record.correlationId));
-                break;
-            case "thread.compacted":
-                bucket.compactionCount += 1;
-                break;
-            default:
-                break;
-        }
-    }
-    const requests = [...buckets.values()]
-        .filter((bucket) => (bucket.kind === "session" ? bucket.events.length > 0 : true))
-        .sort((left, right) => {
-        const leftAt = left.startedAt ?? left.firstSeenAt ?? Number.MAX_SAFE_INTEGER;
-        const rightAt = right.startedAt ?? right.firstSeenAt ?? Number.MAX_SAFE_INTEGER;
-        if (leftAt !== rightAt)
-            return leftAt - rightAt;
-        return left.firstSeenSequence - right.firstSeenSequence;
-    })
-        .map((bucket, index) => ({
-        assistantMessageCount: bucket.assistantMessageCount,
-        assistantPreview: bucket.assistantPreview,
-        childTaskCount: bucket.childTaskIds.size,
-        compactionCount: bucket.compactionCount,
-        completedAt: bucket.completedAt,
-        eventCount: bucket.events.length,
-        events: bucket.events.map((event) => ({
-            at: event.at,
-            sequence: event.sequence,
-            summary: event.summary,
-            type: event.type,
-        })),
-        id: bucket.id,
-        index: index + 1,
-        kind: bucket.kind,
-        promptPreview: bucket.promptPreview,
-        runCount: bucket.runIds.size,
-        startedAt: bucket.startedAt,
-        status: bucket.status,
-        toolCallCount: bucket.toolCallIds.size,
-        turnId: bucket.turnId,
-        userMessageCount: bucket.userMessageCount,
-    }));
-    return {
-        eventCount: envelopes.length,
-        generatedAt: Date.now(),
-        processes: processRecords.map(toSessionTraceProcess),
-        requests,
-        threadId,
-    };
-}
-function toSessionTraceProcess(record) {
-    return {
-        command: record.command,
-        ...(record.completedAt ? { completedAt: record.completedAt } : {}),
-        cwd: record.cwd,
-        descendantPids: [...record.descendantPids],
-        ...(record.evictedAt ? { evictedAt: record.evictedAt } : {}),
-        exitCode: record.exitCode,
-        ...(record.owner
-            ? {
-                owner: {
-                    threadId: record.owner.threadId,
-                    ...(record.owner.toolCallId ? { toolCallId: record.owner.toolCallId } : {}),
-                    turnId: record.owner.turnId,
-                },
-            }
-            : {}),
-        ...(record.pid != null ? { pid: record.pid } : {}),
-        sessionId: record.sessionId,
-        ...(record.signalCode !== undefined ? { signalCode: record.signalCode } : {}),
-        ...(record.sigkillSentAt ? { sigkillSentAt: record.sigkillSentAt } : {}),
-        ...(record.sigtermSentAt ? { sigtermSentAt: record.sigtermSentAt } : {}),
-        startedAt: record.startedAt,
-        status: record.status,
-        ...(record.stopMethod ? { stopMethod: record.stopMethod } : {}),
-        ...(record.stopRequestedAt ? { stopRequestedAt: record.stopRequestedAt } : {}),
-        ...(record.stopVerifiedAt ? { stopVerifiedAt: record.stopVerifiedAt } : {}),
-        ...(record.survivingPids ? { survivingPids: [...record.survivingPids] } : {}),
-        updatedAt: record.updatedAt,
-    };
-}
-function subagentLineForItem(item) {
-    const at = parseIsoTimeMs(item.createdAt);
-    switch (item.kind) {
-        case "message":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "message",
-                label: item.role === "user" ? "user" : "assistant",
-                text: item.text,
-            };
-        case "reasoning":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "reasoning",
-                label: "thinking",
-                text: item.content || item.summary,
-            };
-        case "tool-call":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "tool-call",
-                label: `tool ${canonicalToolName(item.toolName)}`,
-                text: item.input,
-            };
-        case "tool-result":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "tool-result",
-                label: `${item.outcome} ${canonicalToolName(item.toolName)}`,
-                text: item.output,
-            };
-        case "error":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "error",
-                label: "error",
-                text: item.message,
-            };
-        case "control":
-            return {
-                ...(at != null ? { at } : {}),
-                id: item.id,
-                kind: "control",
-                label: item.action,
-                text: item.prompt ? `${item.summary}\n${item.prompt}` : item.summary,
-            };
-    }
-}
-function findPendingSubagentBlock(items) {
-    const pending = new Map();
-    for (const item of items) {
-        if (item.kind !== "control" || !item.requestId)
-            continue;
-        const requestId = String(item.requestId);
-        if (item.action === "approval-requested" || item.action === "action-requested") {
-            pending.set(requestId, item);
-            continue;
-        }
-        if (item.action === "approval-resolved" || item.action === "action-resolved") {
-            pending.delete(requestId);
-        }
-    }
-    return [...pending.values()].at(-1);
-}
-function findPendingSubagentSteers(items) {
-    const consumed = new Map();
-    for (const item of items) {
-        if (item.kind !== "message" || item.role !== "user")
-            continue;
-        const text = normalizeText(item.text);
-        if (!text)
-            continue;
-        const key = `${item.turnId}\n${text}`;
-        consumed.set(key, (consumed.get(key) ?? 0) + 1);
-    }
-    return items
-        .filter((item) => item.kind === "control" && item.action === "steer" && Boolean(normalizeText(item.prompt)))
-        .filter((item) => {
-        const key = `${item.turnId}\n${normalizeText(item.prompt)}`;
-        const count = consumed.get(key) ?? 0;
-        if (count <= 0)
-            return true;
-        consumed.set(key, count - 1);
-        return false;
-    })
-        .map((item) => {
-        const createdAt = parseIsoTimeMs(item.createdAt);
-        return {
-            ...(createdAt != null ? { createdAt } : {}),
-            id: item.id,
-            text: normalizeText(item.prompt),
-        };
-    });
-}
-function normalizeSubagentStatus(value) {
-    const text = normalizeText(value);
-    if (text === "running" ||
-        text === "paused" ||
-        text === "completed" ||
-        text === "failed" ||
-        text === "interrupted" ||
-        text === "blocked") {
-        return text;
-    }
-    return "unknown";
-}
-function isTerminalSubagentStatus(status) {
-    return (status === "completed" ||
-        status === "failed" ||
-        status === "interrupted" ||
-        status === "blocked");
-}
-function filterSubagentChildHistory(thread, turns, items, envelopes) {
-    const threadStartedAt = parseIsoTimeMs(thread.createdAt);
-    if (threadStartedAt == null)
-        return { envelopes, items, turns };
-    const childTurns = turns.filter((turn) => {
-        const startedAt = parseIsoTimeMs(turn.createdAt);
-        return startedAt == null || startedAt >= threadStartedAt;
-    });
-    const childTurnIds = new Set(childTurns.map((turn) => turn.id));
-    const childItems = items.filter((item) => {
-        if (childTurnIds.size > 0 && !childTurnIds.has(item.turnId))
-            return false;
-        const createdAt = parseIsoTimeMs(item.createdAt);
-        return createdAt == null || createdAt >= threadStartedAt;
-    });
-    const childEnvelopes = envelopes.filter((envelope) => {
-        if (childTurnIds.size === 0)
-            return true;
-        const turnId = sessionTraceEventTurnId(envelope.event);
-        return !turnId || childTurnIds.has(turnId);
-    });
-    return {
-        envelopes: childEnvelopes,
-        items: childItems,
-        turns: childTurns,
-    };
-}
-function turnsFromThreadEvents(envelopes) {
-    const byId = new Map();
-    for (const envelope of envelopes) {
-        const event = envelope.event;
-        if (event.type === "turn.started" ||
-            event.type === "turn.completed" ||
-            event.type === "turn.failed" ||
-            event.type === "turn.interrupted" ||
-            event.type === "turn.blocked" ||
-            event.type === "turn.reconciled") {
-            byId.set(event.turn.id, event.turn);
-        }
-    }
-    return [...byId.values()].sort((a, b) => {
-        const aMs = parseIsoTimeMs(a.createdAt) ?? 0;
-        const bMs = parseIsoTimeMs(b.createdAt) ?? 0;
-        return aMs - bMs;
-    });
-}
-function inferRunningSubagentTurnId(turns, items, envelopes) {
-    const terminalTurnIds = new Set(turns
-        .filter((turn) => isTerminalSubagentStatus(normalizeSubagentStatus(turn.status)))
-        .map((turn) => turn.id));
-    const unresolvedCallIds = new Set();
-    for (const item of items) {
-        if (item.kind === "tool-call") {
-            unresolvedCallIds.add(normalizeText(item.callId) || normalizeText(item.id));
-        }
-        else if (item.kind === "tool-result") {
-            unresolvedCallIds.delete(normalizeText(item.callId));
-        }
-    }
-    if (unresolvedCallIds.size > 0) {
-        const turnIdsWithLaterAssistantText = new Set();
-        for (let index = items.length - 1; index >= 0; index -= 1) {
-            const item = items[index];
-            if (item.kind === "message" && item.role !== "user" && normalizeText(item.text)) {
-                turnIdsWithLaterAssistantText.add(item.turnId);
-                continue;
-            }
-            if (terminalTurnIds.has(item.turnId))
-                continue;
-            if (item.kind !== "tool-call")
-                continue;
-            const callId = normalizeText(item.callId) || normalizeText(item.id);
-            if (unresolvedCallIds.has(callId) && !turnIdsWithLaterAssistantText.has(item.turnId)) {
-                return item.turnId;
-            }
-        }
-    }
-    for (let index = envelopes.length - 1; index >= 0; index -= 1) {
-        const turnId = sessionTraceEventTurnId(envelopes[index].event);
-        if (turnId && !terminalTurnIds.has(turnId))
-            return turnId;
-    }
-    return undefined;
-}
-function buildSubagentDetail(thread, turns, items, envelopes, pending = {}) {
-    const childHistory = filterSubagentChildHistory(thread, turns, items, envelopes);
-    const activeTurn = [...childHistory.turns].reverse().find((turn) => turn.status === "running");
-    const latestTurn = childHistory.turns.at(-1);
-    const pendingBlock = findPendingSubagentBlock(childHistory.items);
-    const pendingSteers = findPendingSubagentSteers(childHistory.items);
-    const fallbackStatus = normalizeSubagentStatus(latestTurn?.status ?? thread.status);
-    const inferredRunningTurnId = !pendingBlock && !activeTurn && fallbackStatus === "unknown"
-        ? inferRunningSubagentTurnId(childHistory.turns, childHistory.items, childHistory.envelopes)
-        : undefined;
-    const activeTurnId = activeTurn?.id ?? inferredRunningTurnId;
-    const status = pendingBlock
-        ? "paused"
-        : activeTurn
-            ? "running"
-            : inferredRunningTurnId
-                ? "running"
-                : fallbackStatus;
-    const projection = hydrateThreadItems({
-        events: childHistory.envelopes,
-        hideInitialUserMessages: true,
-        hideInterruptedStatus: true,
-        includeDraftReasoning: true,
-        items: childHistory.items,
-        renderPendingSteerControls: false,
-        ...(pending.pendingAction ? { pendingAction: pending.pendingAction } : {}),
-        ...(pending.pendingApproval ? { pendingApproval: pending.pendingApproval } : {}),
-        thread,
-        turns: childHistory.turns,
-    });
-    return {
-        ...(activeTurnId && !pendingBlock ? { activeTurnId } : {}),
-        ...(pendingBlock?.requestId ? { requestId: String(pendingBlock.requestId) } : {}),
-        ...(pendingBlock ? { pausedReason: pendingBlock.summary } : {}),
-        eventCount: childHistory.envelopes.length,
-        generatedAt: Date.now(),
-        itemCount: childHistory.items.length,
-        lines: childHistory.items.map(subagentLineForItem),
-        messages: projection.messages,
-        messageCount: projection.messages.length,
-        ...(pendingSteers.length ? { pendingSteers } : {}),
-        status,
-        steerable: status === "running" && Boolean(activeTurnId) && !pendingBlock,
-        threadId: thread.id,
-        title: thread.title,
-        toolCallCount: childHistory.items.filter((item) => item.kind === "tool-call").length,
-    };
-}
-function watchSubagentLiveEvents(runtime, threadId, input, onEvent) {
-    const turnIds = new Set();
-    const initialTurnId = normalizeText(input.turnId);
-    if (initialTurnId)
-        turnIds.add(initialTurnId);
-    const pendingSteerPrompts = [];
-    const reasoningPartIdByStreamId = new Map();
-    const reasoningTextByStreamId = new Map();
-    const turnsWithReasoningStreams = new Set();
-    const toolNamesByCallId = new Map();
-    let eventCount = 0;
-    const isTrackedTurn = (turnId) => {
-        const normalized = normalizeText(turnId);
-        return Boolean(normalized && turnIds.has(normalized));
-    };
-    const trackTurnId = (turnId) => {
-        const normalized = normalizeText(turnId);
-        if (!normalized)
-            return undefined;
-        const trackedTurnId = normalized;
-        turnIds.add(trackedTurnId);
-        return trackedTurnId;
-    };
-    const isDirectThreadEvent = (event) => normalizeText(event.threadId) === threadId;
-    const shouldTrackTurnEvent = (event) => {
-        if (isTrackedTurn(event.turnId))
-            return true;
-        if (!isDirectThreadEvent(event))
-            return false;
-        trackTurnId(event.turnId);
-        return true;
-    };
-    const isTrackedItemEvent = (event) => {
-        if (isTrackedTurn(event.turnId))
-            return true;
-        if (normalizeText(event.item?.threadId) !== threadId)
-            return false;
-        trackTurnId(event.turnId);
-        return true;
-    };
-    const emitStatus = (status, activeTurnId) => {
-        onEvent({
-            ...(activeTurnId ? { activeTurnId } : {}),
-            eventCount,
-            status,
-            steerable: status === "running" && Boolean(activeTurnId),
-            type: "subagent.status",
-        });
-    };
-    const consumeSteerPrompt = (text) => {
-        const normalizedText = normalizeText(text);
-        if (!normalizedText)
-            return false;
-        const index = pendingSteerPrompts.findIndex((prompt) => normalizeText(prompt) === normalizedText);
-        if (index < 0)
-            return false;
-        pendingSteerPrompts.splice(index, 1);
-        return true;
-    };
-    const unsubscribe = runtime.subscribe((envelope) => {
-        const event = envelope.event;
-        const createdAtMs = parseIsoTimeMs(envelope.createdAt) ?? undefined;
-        if (event.type === "turn.started" && event.turn.threadId === threadId) {
-            eventCount += 1;
-            const activeTurnId = trackTurnId(event.turn.id);
-            emitStatus("running", activeTurnId ?? event.turn.id);
-            return;
-        }
-        if ((event.type === "turn.completed" ||
-            event.type === "turn.failed" ||
-            event.type === "turn.interrupted" ||
-            event.type === "turn.blocked") &&
-            (event.turn.threadId === threadId || isTrackedTurn(event.turn.id))) {
-            eventCount += 1;
-            trackTurnId(event.turn.id);
-            emitStatus(normalizeSubagentStatus(event.turn.status), undefined);
-            return;
-        }
-        if (event.type === "turn.steered") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            const prompt = normalizeText(event.prompt);
-            if (!prompt)
-                return;
-            eventCount += 1;
-            pendingSteerPrompts.push(prompt);
-            onEvent({
-                content: prompt,
-                createdAtMs,
-                id: `${event.turnId}:${envelope.sequence}`,
-                type: "steer_queued",
-            });
-            return;
-        }
-        if (event.type === "turn.reasoning.started") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            turnsWithReasoningStreams.add(event.turnId);
-            const partId = createThinkingPartIdFromStream(event.turnId, event.streamId);
-            reasoningPartIdByStreamId.set(event.streamId, partId);
-            reasoningTextByStreamId.set(event.streamId, "");
-            onEvent({ partId, type: "thinking.started" });
-            return;
-        }
-        if (event.type === "turn.reasoning.delta") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            turnsWithReasoningStreams.add(event.turnId);
-            const partId = reasoningPartIdByStreamId.get(event.streamId) ??
-                createThinkingPartIdFromStream(event.turnId, event.streamId);
-            reasoningPartIdByStreamId.set(event.streamId, partId);
-            reasoningTextByStreamId.set(event.streamId, `${reasoningTextByStreamId.get(event.streamId) ?? ""}${event.delta}`);
-            onEvent({ delta: event.delta, partId, type: "thinking.delta" });
-            return;
-        }
-        if (event.type === "turn.reasoning.completed") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            turnsWithReasoningStreams.add(event.turnId);
-            const partId = reasoningPartIdByStreamId.get(event.streamId) ??
-                createThinkingPartIdFromStream(event.turnId, event.streamId);
-            const content = reasoningTextByStreamId.get(event.streamId);
-            reasoningPartIdByStreamId.delete(event.streamId);
-            reasoningTextByStreamId.delete(event.streamId);
-            onEvent({ ...(content ? { content } : {}), partId, type: "thinking.finished" });
-            return;
-        }
-        if (event.type === "turn.text.delta") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            onEvent({ delta: event.delta, streamId: event.streamId, type: "assistant.delta" });
-            return;
-        }
-        if (event.type === "turn.text.stream.reset") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            onEvent({ streamId: event.streamId, type: "assistant.reset" });
-            return;
-        }
-        if (event.type === "turn.tool-call.started") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            const toolName = canonicalToolName(event.toolName);
-            toolNamesByCallId.set(event.callId, toolName);
-            onEvent({
-                input: {},
-                originalEventType: "tool_call",
-                startedAtMs: createdAtMs,
-                toolCallId: event.callId,
-                toolName,
-                type: "tool.started",
-            });
-            return;
-        }
-        if (event.type === "turn.tool-call.delta") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            const toolName = canonicalToolName(event.toolName);
-            toolNamesByCallId.set(event.callId, toolName);
-            onEvent({
-                delta: event.delta,
-                kind: "input",
-                toolCallId: event.callId,
-                toolName,
-                type: "tool.delta",
-            });
-            return;
-        }
-        if (event.type === "turn.tool-output.delta") {
-            if (!shouldTrackTurnEvent(event))
-                return;
-            eventCount += 1;
-            const toolName = canonicalToolName(event.toolName);
-            toolNamesByCallId.set(event.callId, toolName);
-            onEvent({
-                delta: event.delta,
-                kind: "output",
-                toolCallId: event.callId,
-                toolName,
-                type: "tool.delta",
-            });
-            return;
-        }
-        if (event.type !== "turn.item.added" || !isTrackedItemEvent(event))
-            return;
-        eventCount += 1;
-        const item = event.item;
-        if (item.kind === "message" && item.role === "user") {
-            if (consumeSteerPrompt(item.text)) {
-                onEvent({
-                    content: item.text,
-                    createdAtMs: parseIsoTimeMs(item.createdAt) ?? createdAtMs,
-                    type: "steer_injected",
-                });
-            }
-            return;
-        }
-        if (item.kind === "message" && item.role === "agent") {
-            onEvent({
-                message: { content: item.text },
-                originalEventType: "thread_item_message",
-                type: "assistant.message",
-            });
-            return;
-        }
-        if (item.kind === "reasoning") {
-            if (turnsWithReasoningStreams.has(item.turnId) || isDraftReasoningItem(item))
-                return;
-            const content = item.content ?? item.summary;
-            if (!hasVisibleReasoningText(content))
-                return;
-            onEvent({
-                content,
-                partId: createThinkingPartIdFromReasoningItem(item.id),
-                type: "thinking.finished",
-            });
-            return;
-        }
-        if (item.kind === "tool-call") {
-            const toolCallId = resolveToolItemCallId(item);
-            const toolName = canonicalToolName(item.toolName);
-            toolNamesByCallId.set(toolCallId, toolName);
-            onEvent({
-                input: parseToolInput(item.input),
-                originalEventType: "tool_call_end",
-                startedAtMs: parseIsoTimeMs(item.createdAt) ?? createdAtMs,
-                toolCallId,
-                toolName,
-                type: "tool.started",
-            });
-            return;
-        }
-        if (item.kind === "tool-result") {
-            const toolCallId = readExplicitToolCallId(item) ?? normalizeText(item.id);
-            const toolName = canonicalToolName(item.toolName) || toolNamesByCallId.get(toolCallId) || toolCallId;
-            toolNamesByCallId.set(toolCallId, toolName);
-            onEvent({
-                ...(item.errorCode ? { errorCode: item.errorCode } : {}),
-                ...(item.failureKind ? { failureKind: item.failureKind } : {}),
-                isError: item.outcome === "error",
-                output: {
-                    output: item.output,
-                    ...(item.structuredContent !== undefined
-                        ? { structuredContent: item.structuredContent }
-                        : {}),
-                },
-                toolCallId,
-                toolName,
-                type: "tool.finished",
-            });
-            return;
-        }
-        if (item.kind === "control" && item.action === "steer" && item.prompt) {
-            const prompt = normalizeText(item.prompt);
-            if (!prompt)
-                return;
-            pendingSteerPrompts.push(prompt);
-            onEvent({
-                content: prompt,
-                createdAtMs: parseIsoTimeMs(item.createdAt) ?? createdAtMs,
-                id: item.id,
-                type: "steer_queued",
-            });
-            return;
-        }
-        if (item.kind === "error" && normalizeText(item.message)) {
-            onEvent({ message: item.message, type: "error.recorded" });
-        }
-    });
-    return unsubscribe;
-}
-function belongsToThread(event, threadId, turnId) {
-    switch (event.type) {
-        case "turn.started":
-            return event.turn.threadId === threadId;
-        case "turn.steered":
-        case "turn.item.added":
-            return turnId !== undefined && event.turnId === turnId;
-        case "turn.text.delta":
-        case "turn.text.stream.reset":
-        case "turn.reasoning.started":
-        case "turn.reasoning.delta":
-        case "turn.reasoning.completed":
-        case "turn.tool-call.started":
-        case "turn.tool-call.delta":
-        case "turn.tool-output.delta":
-            return turnId !== undefined && (event.turnId === turnId || event.parentTurnId === turnId);
-        case "approval.requested":
-            return (event.approval.threadId === threadId &&
-                (turnId === undefined || event.approval.turnId === turnId));
-        case "action.required":
-            return event.threadId === threadId && (turnId === undefined || event.turnId === turnId);
-        case "child-thread.item.added":
-            return turnId !== undefined && event.parentTurnId === turnId;
-        case "child-task.started":
-        case "child-task.completed":
-        case "child-task.failed":
-        case "child-task.joined":
-        case "child-task.rejected":
-            return turnId !== undefined && event.threadId === threadId && event.turnId === turnId;
-        case "thread.compaction.started":
-        case "thread.compacted":
-            return event.threadId === threadId && (turnId === undefined || event.turnId === turnId);
-        case "thread.usage.updated":
-            return (event.threadId === threadId &&
-                (turnId === undefined || event.turnId === undefined || event.turnId === turnId));
-        case "turn.completed":
-        case "turn.failed":
-        case "turn.interrupted":
-        case "turn.blocked":
-            return turnId !== undefined && event.turn.id === turnId;
-        default:
-            return false;
-    }
-}
-const VALID_SESSION_QUEUE_STATUSES = new Set([
-    "idle",
-    "running",
-    "paused_confirm",
-    "error",
-]);
-const VALID_SESSION_QUEUE_ERROR_CODES = new Set([
-    "network_error",
-    "timeout",
-    "canceled_by_user",
-    "rate_limited",
-    "config_unavailable",
-    "unknown",
-]);
-function defaultBridgeSessionUiMetadata() {
-    return {
-        lastErrorCode: undefined,
-        lastUpdatedAt: 0,
-        pinnedMessageIds: [],
-        queue: [],
-        queueLength: 0,
-        reasoningDiagnosticsByTurn: {},
-        status: "idle",
-        titleSuggestedAt: undefined,
-    };
-}
-function normalizeSessionQueueItem(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    const record = raw;
-    const id = normalizeText(record.id);
-    const text = normalizeText(record.text);
-    if (!id || !text)
-        return null;
-    const createdAt = Number(record.createdAt);
-    const steeredAt = Number(record.steeredAt);
-    const configRecord = asRecord(record.config);
-    const approvalsMode = configRecord.approvalsMode;
-    const normalizedApprovalsMode = approvalsMode === "auto" || approvalsMode === "normal" || approvalsMode === "strict"
-        ? approvalsMode
-        : undefined;
-    const config = Object.keys(configRecord).length > 0
-        ? {
-            model: normalizeText(configRecord.model) || undefined,
-            temperature: Number.isFinite(Number(configRecord.temperature))
-                ? Number(configRecord.temperature)
-                : undefined,
-            interleavedThinking: typeof configRecord.interleavedThinking === "boolean"
-                ? configRecord.interleavedThinking
-                : undefined,
-            approvalsMode: normalizedApprovalsMode,
-            providerId: normalizeText(configRecord.providerId) || undefined,
-        }
-        : undefined;
-    return {
-        id,
-        text,
-        createdAt: Number.isFinite(createdAt) ? createdAt : 0,
-        kind: normalizeText(record.kind) === "steer" ? "steer" : "user",
-        steeredAt: Number.isFinite(steeredAt) && steeredAt > 0 ? steeredAt : undefined,
-        ...(config ? { config } : {}),
-    };
-}
-function sessionUiMetadata(thread) {
-    const metadata = asRecord(thread.metadata);
-    const ui = asRecord(metadata.ui);
-    return {
-        ...defaultBridgeSessionUiMetadata(),
-        ...cloneJson(ui),
-    };
-}
-function normalizeBridgeSessionUiMetadata(raw) {
-    const base = defaultBridgeSessionUiMetadata();
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return base;
-    const record = raw;
-    const queue = Array.isArray(record.queue)
-        ? record.queue
-            .map(normalizeSessionQueueItem)
-            .filter((item) => item !== null)
-        : [];
-    return {
-        lastErrorCode: VALID_SESSION_QUEUE_ERROR_CODES.has(record.lastErrorCode)
-            ? record.lastErrorCode
-            : undefined,
-        lastUpdatedAt: Number.isFinite(Number(record.lastUpdatedAt)) ? Number(record.lastUpdatedAt) : 0,
-        pinnedMessageIds: Array.isArray(record.pinnedMessageIds)
-            ? record.pinnedMessageIds.map((id) => normalizeText(id)).filter(Boolean)
-            : [],
-        queue,
-        queueLength: queue.length,
-        reasoningDiagnosticsByTurn: normalizeReasoningDiagnosticsByTurn(record.reasoningDiagnosticsByTurn),
-        status: VALID_SESSION_QUEUE_STATUSES.has(record.status)
-            ? record.status
-            : base.status,
-        titleSuggestedAt: Number.isFinite(Number(record.titleSuggestedAt)) && Number(record.titleSuggestedAt) > 0
-            ? Number(record.titleSuggestedAt)
-            : undefined,
-    };
-}
-function sessionListMetadata(thread) {
-    const metadata = normalizeBridgeSessionUiMetadata(sessionUiMetadata(thread));
-    return {
-        lastUpdatedAt: typeof metadata.lastUpdatedAt === "number" ? metadata.lastUpdatedAt : undefined,
-        queue: Array.isArray(metadata.queue) ? metadata.queue : undefined,
-        queueLength: typeof metadata.queueLength === "number" ? metadata.queueLength : undefined,
-        reasoningDiagnosticsByTurn: Object.keys(metadata.reasoningDiagnosticsByTurn).length > 0
-            ? metadata.reasoningDiagnosticsByTurn
-            : undefined,
-        status: VALID_SESSION_QUEUE_STATUSES.has(metadata.status)
-            ? metadata.status
-            : undefined,
-    };
-}
-function sessionListUpdatedAt(thread, metadata) {
-    const metadataUpdatedAt = Number(metadata.lastUpdatedAt ?? 0);
-    if (Number.isFinite(metadataUpdatedAt) && metadataUpdatedAt > 0)
-        return metadataUpdatedAt;
-    const threadUpdatedAt = Date.parse(thread.updatedAt);
-    return Number.isFinite(threadUpdatedAt) ? threadUpdatedAt : 0;
-}
-function wrapSessionUiMetadata(metadata) {
-    const ui = asRecord(metadata.ui);
-    if (Object.keys(ui).length > 0)
-        return metadata;
-    return { ui: metadata };
-}
-function latestSummary(messages) {
-    const last = [...messages].reverse().find((message) => {
-        if (message.role === "user")
-            return message.content.trim().length > 0;
-        if (message.role === "tool")
-            return message.result.output.trim().length > 0;
-        return message.parts.some((part) => {
-            if (part.type === "markdown")
-                return part.markdown.trim().length > 0;
-            if (part.type === "tool_result")
-                return part.result.output.trim().length > 0;
-            return false;
-        });
-    });
-    const lastMessage = last?.role === "user"
-        ? last.content
-        : last?.role === "tool"
-            ? last.result.output
-            : last?.parts
-                .map((part) => {
-                if (part.type === "markdown")
-                    return part.markdown;
-                if (part.type === "tool_result")
-                    return part.result.output;
-                return "";
-            })
-                .join("\n")
-                .trim();
-    return {
-        lastMessage: lastMessage || undefined,
-        messageCount: messages.length,
-        summary: lastMessage?.split(/\r?\n/, 1)[0] ?? "(empty)",
-    };
-}
-function formatSessionTitle(text) {
-    const title = String(text ?? "")
-        .replace(/\s+/g, " ")
-        .trim();
-    return title.length <= 60 ? title : `${title.slice(0, 59)}…`;
-}
-function activeSessionTitle(threadTitle, messages) {
-    if (threadTitle !== "New Thread" || !messages?.length)
-        return threadTitle;
-    const firstUser = messages.find((message) => message.role === "user" && normalizeText(message.content).length > 0);
-    const derived = firstUser ? formatSessionTitle(firstUser.content) : "";
-    return derived || threadTitle;
-}
-function previewSummary(thread) {
-    const preview = String(thread.preview ?? "").trim();
-    return {
-        lastMessage: preview || undefined,
-        messageCount: Math.max(0, Number(thread.turnCount ?? 0) || 0),
-        summary: preview.split(/\r?\n/, 1)[0] ?? "(empty)",
-    };
-}
-async function collectSubagentThreadIds(runtime, threads) {
-    if (typeof runtime.getThreadDiagnostics !== "function")
-        return new Set();
-    const childCandidatesByParent = new Map();
-    for (const thread of threads) {
-        const parentThreadId = normalizeText(thread.forkedFromThreadId);
-        if (!parentThreadId)
-            continue;
-        let candidates = childCandidatesByParent.get(parentThreadId);
-        if (!candidates) {
-            candidates = new Set();
-            childCandidatesByParent.set(parentThreadId, candidates);
-        }
-        candidates.add(thread.id);
-    }
-    if (childCandidatesByParent.size === 0)
-        return new Set();
-    const subagentThreadIds = new Set();
-    await Promise.all([...childCandidatesByParent.entries()].map(async ([parentThreadId, candidates]) => {
-        try {
-            const diagnostics = await runtime.getThreadDiagnostics(parentThreadId);
-            for (const record of diagnostics.diagnostics.childTasks.records) {
-                const childThreadId = normalizeText(record.childThreadId);
-                if (childThreadId && candidates.has(childThreadId))
-                    subagentThreadIds.add(childThreadId);
-            }
-        }
-        catch { }
-        const remaining = new Set([...candidates].filter((childThreadId) => !subagentThreadIds.has(childThreadId)));
-        if (remaining.size === 0 || typeof runtime.getThreadHistory !== "function")
-            return;
-        try {
-            const history = await runtime.getThreadHistory({
-                threadId: parentThreadId,
-                limit: 1000,
-            });
-            for (const item of history.items) {
-                if (item.kind !== "control" || item.action !== "child-thread-started")
-                    continue;
-                const childThreadId = normalizeText(item.childThreadId);
-                if (childThreadId && remaining.has(childThreadId))
-                    subagentThreadIds.add(childThreadId);
-            }
-        }
-        catch { }
-    }));
-    return subagentThreadIds;
-}
-async function filterSessionThreads(runtime, threads) {
-    return await withPerfSpanAsync("filterSessionThreads", `threads=${threads.length}`, async () => {
-        if (String(process.env.BEST_AGENT_DISABLE_SUBAGENT_SESSION_FILTER ?? "").trim() === "1")
-            return [...threads];
-        const timeoutMsRaw = Number(process.env.BEST_AGENT_SESSION_FILTER_TIMEOUT_MS ?? 150);
-        const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? Math.floor(timeoutMsRaw) : 150;
-        let timeout;
-        const subagentThreadIds = await Promise.race([
-            collectSubagentThreadIds(runtime, threads),
-            new Promise((resolve) => {
-                timeout = setTimeout(() => resolve(new Set()), timeoutMs);
-            }),
-        ]).finally(() => {
-            if (timeout)
-                clearTimeout(timeout);
-        });
-        if (subagentThreadIds.size === 0)
-            return [...threads];
-        return threads.filter((thread) => !subagentThreadIds.has(thread.id));
-    });
-}
-const FAST_THREAD_RESUME_TURN_LIMIT = 80;
-const HISTORY_PAGE_TURN_LIMIT = 80;
-function isHiddenSubagentUserMessage(message) {
-    if (message.role !== "user")
-        return false;
-    const text = normalizeText(message.content);
-    return (text.includes("Execution constraints:") ||
-        text.includes("Persistence constraints:") ||
-        text.includes("Return findings in the transcript/evidence only") ||
-        text.includes("Do not write scratch or workspace files in this child thread") ||
-        text.startsWith("Continue the same assigned child task from the current thread and workspace state.") ||
-        text.includes("Runtime error (repairable provider):"));
-}
-function removeHiddenSubagentUserMessages(messages) {
-    return messages.filter((message) => !isHiddenSubagentUserMessage(message));
-}
-function hydrateThreadItems(input) {
-    const projectionState = {
-        layoutDirtyMessageId: null,
-        layoutDirtySeq: 0,
-        messages: [],
-        revertedMessages: [],
-        userHistory: [],
-    };
-    const mutations = createMessageMutations(projectionState);
-    const projector = createTranscriptProjector({
-        ...mutations,
-        state: projectionState,
-    });
-    const assistantIdsByTurn = new Map();
-    const assistantIdHistoryByTurn = new Map();
-    const assistantSegmentCountByTurn = new Map();
-    const hydratedUserTextByTurn = new Map();
-    const hydratedSubagentIdsByTurn = new Map();
-    const toolInputsByCallId = new Map();
-    const toolNamesByCallId = new Map();
-    const assistantIdByToolCallId = new Map();
-    const assistantSplitBoundariesByTurn = new Map();
-    const toolCallStartedAtMsByCallId = new Map();
-    for (const item of input.items) {
-        if (item.kind !== "tool-call")
-            continue;
-        const startedAtMs = parseIsoTimeMs(item.createdAt);
-        if (startedAtMs == null)
-            continue;
-        toolCallStartedAtMsByCallId.set(resolveToolItemCallId(item), startedAtMs);
-    }
-    const reasoningDiagnosticsByTurn = input.thread
-        ? normalizeBridgeSessionUiMetadata(sessionUiMetadata(input.thread)).reasoningDiagnosticsByTurn
-        : {};
-    const turnsById = new Map((input.turns ?? []).map((turn) => [turn.id, turn]));
-    const interruptedTurnIds = new Set(input.hideInterruptedStatus
-        ? []
-        : (input.turns ?? []).filter((turn) => turn.status === "interrupted").map((turn) => turn.id));
-    const startedReasoningStreamsByTurn = new Map();
-    const completedReasoningStreamsByTurn = new Map();
-    let approvalActive = null;
-    let paused = null;
-    for (const envelope of input.events ?? []) {
-        const event = envelope.event;
-        if (event.type === "turn.interrupted") {
-            if (!input.hideInterruptedStatus)
-                interruptedTurnIds.add(event.turn.id);
-            continue;
-        }
-        if (event.type !== "turn.reasoning.started" &&
-            event.type !== "turn.reasoning.delta" &&
-            event.type !== "turn.reasoning.completed") {
-            continue;
-        }
-        if ("parentTurnId" in event && event.parentTurnId)
-            continue;
-        const started = startedReasoningStreamsByTurn.get(event.turnId) ?? new Set();
-        started.add(event.streamId);
-        startedReasoningStreamsByTurn.set(event.turnId, started);
-        if (event.type === "turn.reasoning.completed") {
-            const completed = completedReasoningStreamsByTurn.get(event.turnId) ?? new Set();
-            completed.add(event.streamId);
-            completedReasoningStreamsByTurn.set(event.turnId, completed);
-        }
-    }
-    const markHydratedSubagent = (turnId, subagentId) => {
-        const set = hydratedSubagentIdsByTurn.get(turnId) ?? new Set();
-        set.add(subagentId);
-        hydratedSubagentIdsByTurn.set(turnId, set);
-    };
-    const hasHydratedSubagent = (turnId, subagentId) => hydratedSubagentIdsByTurn.get(turnId)?.has(subagentId) ?? false;
-    const ensureAssistantId = (turnId) => {
-        const existing = assistantIdsByTurn.get(turnId);
-        if (existing)
-            return existing;
-        const segment = assistantSegmentCountByTurn.get(turnId) ?? 0;
-        const assistantId = segment === 0 ? `assistant_${turnId}` : `assistant_${turnId}_${segment}`;
-        mutations.pushMessage({
-            id: assistantId,
-            parts: [{ text: "", type: "status" }],
-            role: "assistant",
-        });
-        assistantIdsByTurn.set(turnId, assistantId);
-        const history = assistantIdHistoryByTurn.get(turnId) ?? [];
-        history.push(assistantId);
-        assistantIdHistoryByTurn.set(turnId, history);
-        return assistantId;
-    };
-    const assistantHasRenderableContent = (assistantId) => {
-        const assistant = projectionState.messages.find((message) => message.id === assistantId && message.role === "assistant");
-        return Boolean(assistant?.parts.some((part) => part.type !== "status"));
-    };
-    const userTextBucketsForTurn = (turnId) => {
-        const existing = hydratedUserTextByTurn.get(turnId);
-        if (existing)
-            return existing;
-        const created = { real: new Set(), steer: new Set() };
-        hydratedUserTextByTurn.set(turnId, created);
-        return created;
-    };
-    const normalizedUserText = (text) => normalizeText(text);
-    const hasHydratedUserMessageForTurn = (turnId, text, kind) => {
-        const normalizedText = normalizedUserText(text);
-        if (!normalizedText)
-            return false;
-        const buckets = hydratedUserTextByTurn.get(turnId);
-        if (!buckets)
-            return false;
-        if (kind === "real")
-            return buckets.real.has(normalizedText);
-        if (kind === "steer")
-            return buckets.steer.has(normalizedText);
-        return buckets.real.has(normalizedText) || buckets.steer.has(normalizedText);
-    };
-    const hasAnyHydratedUserMessageForTurn = (turnId) => {
-        const buckets = hydratedUserTextByTurn.get(turnId);
-        return Boolean(buckets && (buckets.real.size > 0 || buckets.steer.size > 0));
-    };
-    const recordUserMessageForTurn = (turnId, text, kind) => {
-        const normalizedText = normalizedUserText(text);
-        if (!normalizedText)
-            return;
-        userTextBucketsForTurn(turnId)[kind].add(normalizedText);
-    };
-    const hasSourceUserMessageForTurn = (sourceItems, turnId, text) => {
-        const normalizedText = normalizeText(text);
-        if (!normalizedText)
-            return false;
-        for (const candidate of sourceItems) {
-            if (candidate?.kind === "message" &&
-                candidate.role === "user" &&
-                candidate.turnId === turnId &&
-                normalizeText(candidate.text) === normalizedText) {
-                return true;
-            }
-        }
-        return false;
-    };
-    const hasSourceSteerControlForTurn = (sourceItems, turnId, text) => {
-        const normalizedText = normalizeText(text);
-        if (!normalizedText)
-            return false;
-        for (const candidate of sourceItems) {
-            if (candidate?.kind === "control" &&
-                candidate.action === "steer" &&
-                candidate.turnId === turnId &&
-                normalizeText(candidate.prompt) === normalizedText) {
-                return true;
-            }
-        }
-        return false;
-    };
-    const pushUserMessageForTurn = (turnId, message, kind) => {
-        const assistantId = assistantIdsByTurn.get(turnId);
-        const assistantIndex = assistantId
-            ? projectionState.messages.findIndex((candidate) => candidate.id === assistantId)
-            : -1;
-        const shouldSplitAssistant = assistantId &&
-            assistantIndex >= 0 &&
-            assistantHasRenderableContent(assistantId) &&
-            (kind === "steer" || hasAnyHydratedUserMessageForTurn(turnId));
-        if (shouldSplitAssistant) {
-            if (typeof message.createdAtMs === "number" && Number.isFinite(message.createdAtMs)) {
-                const boundaries = assistantSplitBoundariesByTurn.get(turnId) ?? [];
-                boundaries.push({ assistantId, atMs: message.createdAtMs });
-                boundaries.sort((a, b) => a.atMs - b.atMs);
-                assistantSplitBoundariesByTurn.set(turnId, boundaries);
-            }
-            mutations.pushMessage(message);
-            const nextSegment = (assistantSegmentCountByTurn.get(turnId) ?? 0) + 1;
-            assistantSegmentCountByTurn.set(turnId, nextSegment);
-            assistantIdsByTurn.delete(turnId);
-        }
-        else if (assistantIndex >= 0) {
-            projectionState.messages.splice(assistantIndex, 0, message);
-        }
-        else {
-            mutations.pushMessage(message);
-        }
-        if (message.role === "user")
-            recordUserMessageForTurn(turnId, message.content, kind);
-    };
-    const assistantIdForToolCall = (turnId, callId, startedAtMs) => {
-        const existing = assistantIdByToolCallId.get(callId);
-        if (existing)
-            return existing;
-        if (typeof startedAtMs === "number" && Number.isFinite(startedAtMs)) {
-            const boundary = (assistantSplitBoundariesByTurn.get(turnId) ?? []).find((candidate) => startedAtMs <= candidate.atMs);
-            if (boundary) {
-                assistantIdByToolCallId.set(callId, boundary.assistantId);
-                return boundary.assistantId;
-            }
-        }
-        const assistantId = ensureAssistantId(turnId);
-        assistantIdByToolCallId.set(callId, assistantId);
-        return assistantId;
-    };
-    const applyPendingApproval = (pendingApproval) => {
-        approvalActive = pendingApproval;
-        const assistantId = ensureAssistantId(pendingApproval.turnId);
-        projector.apply(assistantId, {
-            actionId: pendingApproval.id,
-            args: toolInputsByCallId.get(pendingApproval.toolCallId) ?? {},
-            availableScopes: pendingApproval.availableScopes,
-            kind: "tool_approval",
-            permission: approvalPermission(pendingApproval.action),
-            reason: pendingApproval.reason,
-            riskLevel: pendingApproval.riskClass ?? approvalRiskLevel(pendingApproval.action),
-            toolCallId: pendingApproval.toolCallId,
-            toolName: toolNamesByCallId.get(pendingApproval.toolCallId) ??
-                canonicalToolName(pendingApproval.action),
-            type: "action.required",
-        });
-        paused = {
-            actionId: pendingApproval.id,
-            kind: "tool_approval",
-            toolCallId: pendingApproval.toolCallId,
-        };
-    };
-    const applyPendingAction = (pendingAction) => {
-        const assistantId = ensureAssistantId(pendingAction.turnId);
-        projector.apply(assistantId, {
-            actionId: pendingAction.actionId,
-            kind: "ask_user",
-            questions: pendingAction.questions,
-            ...(pendingAction.toolCallId ? { toolCallId: pendingAction.toolCallId } : {}),
-            toolName: pendingAction.toolName,
-            type: "action.required",
-        });
-        paused = {
-            actionId: pendingAction.actionId,
-            kind: "ask_user",
-            ...(pendingAction.toolCallId ? { toolCallId: pendingAction.toolCallId } : {}),
-            questions: normalizeAskUserQuestions(pendingAction.questions),
-        };
-    };
-    const eventHydratedItemIds = new Set();
-    const eventHydratedActionIds = new Set();
-    const eventHydratedApprovalIds = new Set();
-    const turnsWithReasoningStreams = new Set();
-    for (const envelope of input.events ?? []) {
-        const event = envelope.event;
-        if (event.type === "turn.reasoning.started" ||
-            event.type === "turn.reasoning.delta" ||
-            event.type === "turn.reasoning.completed") {
-            turnsWithReasoningStreams.add(event.turnId);
-        }
-    }
-    const applyItem = (item, sourceItems) => {
-        if (item.kind === "message" && item.role === "user") {
-            const isConsumedSteer = hasSourceSteerControlForTurn(sourceItems, item.turnId, item.text);
-            if (hasHydratedUserMessageForTurn(item.turnId, item.text, "steer") ||
-                hasHydratedUserMessageForTurn(item.turnId, item.text, "real")) {
-                return;
-            }
-            pushUserMessageForTurn(item.turnId, {
-                content: item.text,
-                ...(parseIsoTimeMs(item.createdAt) != null
-                    ? { createdAtMs: parseIsoTimeMs(item.createdAt) }
-                    : {}),
-                id: item.id,
-                ...(isConsumedSteer
-                    ? { metadata: { originalEventType: "steer_injected", steer: true } }
-                    : {}),
-                role: "user",
-            }, isConsumedSteer ? "steer" : "real");
-            return;
-        }
-        if (item.kind === "message" && item.role === "agent") {
-            projector.apply(ensureAssistantId(item.turnId), {
-                message: { content: item.text },
-                originalEventType: "thread_item_message",
-                type: "assistant.message",
-            });
-            return;
-        }
-        if (item.kind === "reasoning") {
-            if (isDraftReasoningItem(item) && !input.includeDraftReasoning)
-                return;
-            if (turnsWithReasoningStreams.has(item.turnId))
-                return;
-            projector.apply(ensureAssistantId(item.turnId), {
-                content: item.content ?? item.summary,
-                partId: createThinkingPartIdFromReasoningItem(item.id),
-                type: "thinking.finished",
-            });
-            return;
-        }
-        if (item.kind === "tool-call") {
-            const callId = resolveToolItemCallId(item);
-            const parsedInput = parseToolInput(item.input);
-            toolInputsByCallId.set(callId, parsedInput);
-            toolNamesByCallId.set(callId, canonicalToolName(item.toolName));
-            const toolAssistantId = assistantIdForToolCall(item.turnId, callId, parseIsoTimeMs(item.createdAt));
-            projector.apply(toolAssistantId, {
-                input: parsedInput,
-                originalEventType: "tool_call_end",
-                startedAtMs: parseIsoTimeMs(item.createdAt) ?? undefined,
-                toolCallId: callId,
-                toolName: canonicalToolName(item.toolName),
-                type: "tool.started",
-            });
-            return;
-        }
-        if (item.kind === "tool-result") {
-            const toolCallId = readExplicitToolCallId(item) ?? normalizeText(item.id);
-            toolNamesByCallId.set(toolCallId, canonicalToolName(item.toolName));
-            projector.apply(assistantIdForToolCall(item.turnId, toolCallId, toolCallStartedAtMsByCallId.get(toolCallId) ?? parseIsoTimeMs(item.createdAt)), {
-                ...(item.errorCode ? { errorCode: item.errorCode } : {}),
-                ...(item.failureKind ? { failureKind: item.failureKind } : {}),
-                isError: item.outcome === "error",
-                output: {
-                    output: item.output,
-                    ...(item.structuredContent !== undefined
-                        ? { structuredContent: item.structuredContent }
-                        : {}),
-                },
-                toolCallId,
-                toolName: canonicalToolName(item.toolName),
-                type: "tool.finished",
-            });
-            return;
-        }
-        if (item.kind === "control") {
-            if (item.action === "steer" && item.prompt) {
-                if (input.renderPendingSteerControls === true &&
-                    !hasHydratedUserMessageForTurn(item.turnId, item.prompt) &&
-                    !hasSourceUserMessageForTurn(sourceItems, item.turnId, item.prompt)) {
-                    pushUserMessageForTurn(item.turnId, {
-                        content: item.prompt,
-                        ...(parseIsoTimeMs(item.createdAt) != null
-                            ? { createdAtMs: parseIsoTimeMs(item.createdAt) }
-                            : {}),
-                        id: `${item.id}::steer`,
-                        metadata: {
-                            originalEventType: "steer_injected",
-                            pending: true,
-                            steer: true,
-                        },
-                        role: "user",
-                    }, "steer");
-                }
-                return;
-            }
-            if (item.action === "child-thread-started" && item.childThreadId) {
-                projector.apply(ensureAssistantId(item.turnId), {
-                    subagentId: item.childThreadId,
-                    taskDescription: normalizeText(item.summary) || item.childThreadId,
-                    type: "subagent.started",
-                });
-                markHydratedSubagent(item.turnId, item.childThreadId);
-                return;
-            }
-            if (item.action === "child-thread-paused" && item.childThreadId) {
-                if (!hasHydratedSubagent(item.turnId, item.childThreadId)) {
-                    projector.apply(ensureAssistantId(item.turnId), {
-                        subagentId: item.childThreadId,
-                        taskDescription: item.childThreadId,
-                        type: "subagent.started",
-                    });
-                    markHydratedSubagent(item.turnId, item.childThreadId);
-                }
-                projector.apply(ensureAssistantId(item.turnId), {
-                    ...(item.requestId ? { requestId: item.requestId } : {}),
-                    state: "paused",
-                    subagentId: item.childThreadId,
-                    type: "subagent.state",
-                });
-                paused = {
-                    actionId: item.requestId,
-                    childThreadId: item.childThreadId,
-                    kind: "subagent_wait",
-                };
-                return;
-            }
-            if (item.action === "child-thread-resumed" && item.childThreadId) {
-                if (!hasHydratedSubagent(item.turnId, item.childThreadId)) {
-                    projector.apply(ensureAssistantId(item.turnId), {
-                        subagentId: item.childThreadId,
-                        taskDescription: item.childThreadId,
-                        type: "subagent.started",
-                    });
-                    markHydratedSubagent(item.turnId, item.childThreadId);
-                }
-                projector.apply(ensureAssistantId(item.turnId), {
-                    ...(item.requestId ? { requestId: item.requestId } : {}),
-                    state: "running",
-                    subagentId: item.childThreadId,
-                    type: "subagent.state",
-                });
-                if (paused?.kind === "subagent_wait" &&
-                    paused.childThreadId === item.childThreadId &&
-                    (!item.requestId || paused.actionId === item.requestId)) {
-                    paused = null;
-                }
-                return;
-            }
-            if (item.action === "child-thread-completed" && item.childThreadId) {
-                projector.apply(ensureAssistantId(item.turnId), {
-                    subagentId: item.childThreadId,
-                    taskDescription: normalizeText(item.summary) || item.childThreadId,
-                    type: "subagent.started",
-                });
-                markHydratedSubagent(item.turnId, item.childThreadId);
-                projector.apply(ensureAssistantId(item.turnId), {
-                    state: "completed",
-                    subagentId: item.childThreadId,
-                    type: "subagent.finished",
-                });
-                if (paused?.kind === "subagent_wait" && paused.childThreadId === item.childThreadId) {
-                    paused = null;
-                }
-                return;
-            }
-        }
-        if (item.kind === "error") {
-            if (item.scope === "child-thread" && item.childThreadId) {
-                if (!hasHydratedSubagent(item.turnId, item.childThreadId)) {
-                    projector.apply(ensureAssistantId(item.turnId), {
-                        subagentId: item.childThreadId,
-                        taskDescription: item.childThreadId,
-                        type: "subagent.started",
-                    });
-                    markHydratedSubagent(item.turnId, item.childThreadId);
-                }
-                if (normalizeText(item.message)) {
-                    projector.apply(ensureAssistantId(item.turnId), {
-                        delta: item.message,
-                        stream: "error",
-                        subagentId: item.childThreadId,
-                        subagentTurnId: item.turnId,
-                        type: "subagent.output",
-                    });
-                }
-                projector.apply(ensureAssistantId(item.turnId), {
-                    state: "failed",
-                    subagentId: item.childThreadId,
-                    type: "subagent.finished",
-                });
-                if (paused?.kind === "subagent_wait" && paused.childThreadId === item.childThreadId) {
-                    paused = null;
-                }
-                return;
-            }
-            projector.apply(ensureAssistantId(item.turnId), {
-                message: item.message,
-                type: "error.recorded",
-            });
-        }
-    };
-    for (const envelope of input.events ?? []) {
-        const event = envelope.event;
-        if (event.type === "turn.reasoning.started" && !event.parentTurnId) {
-            projector.apply(ensureAssistantId(event.turnId), {
-                partId: createThinkingPartIdFromStream(event.turnId, event.streamId),
-                type: "thinking.started",
-            });
-            continue;
-        }
-        if (event.type === "turn.reasoning.delta" && !event.parentTurnId) {
-            projector.apply(ensureAssistantId(event.turnId), {
-                delta: event.delta,
-                partId: createThinkingPartIdFromStream(event.turnId, event.streamId),
-                type: "thinking.delta",
-            });
-            continue;
-        }
-        if (event.type === "turn.reasoning.completed" && !event.parentTurnId) {
-            projector.apply(ensureAssistantId(event.turnId), {
-                partId: createThinkingPartIdFromStream(event.turnId, event.streamId),
-                type: "thinking.finished",
-            });
-            continue;
-        }
-        if (event.type === "turn.tool-call.started" && !event.parentTurnId) {
-            toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-            const toolAssistantId = assistantIdForToolCall(event.turnId, event.callId, toolCallStartedAtMsByCallId.get(event.callId) ?? parseIsoTimeMs(envelope.createdAt));
-            projector.apply(toolAssistantId, {
-                input: {},
-                originalEventType: "tool_call",
-                toolCallId: event.callId,
-                toolName: canonicalToolName(event.toolName),
-                type: "tool.started",
-            });
-            continue;
-        }
-        if (event.type === "turn.tool-call.delta" && !event.parentTurnId) {
-            toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-            projector.apply(assistantIdForToolCall(event.turnId, event.callId, toolCallStartedAtMsByCallId.get(event.callId) ?? parseIsoTimeMs(envelope.createdAt)), {
-                delta: event.delta,
-                kind: "input",
-                toolCallId: event.callId,
-                toolName: canonicalToolName(event.toolName),
-                type: "tool.delta",
-            });
-            continue;
-        }
-        if (event.type === "turn.text.delta" && !event.parentTurnId) {
-            projector.apply(ensureAssistantId(event.turnId), {
-                delta: event.delta,
-                streamId: event.streamId,
-                type: "assistant.delta",
-            });
-            continue;
-        }
-        if (event.type === "turn.text.stream.reset" && !event.parentTurnId) {
-            projector.apply(ensureAssistantId(event.turnId), {
-                streamId: event.streamId,
-                type: "assistant.reset",
-            });
-            continue;
-        }
-        if (event.type === "turn.item.added") {
-            eventHydratedItemIds.add(event.item.id);
-            applyItem(event.item, input.items);
-            continue;
-        }
-        if (event.type === "approval.requested") {
-            if (input.pendingApproval?.id === event.approval.id) {
-                eventHydratedApprovalIds.add(event.approval.id);
-                applyPendingApproval(event.approval);
-            }
-            continue;
-        }
-        if (event.type === "action.required" && event.kind === "ask_user") {
-            if (input.pendingAction?.actionId === event.actionId) {
-                eventHydratedActionIds.add(event.actionId);
-                applyPendingAction({
-                    actionId: event.actionId,
-                    questions: event.questions,
-                    toolCallId: normalizeText(event.toolCallId) || undefined,
-                    toolName: canonicalToolName(event.toolName),
-                    turnId: event.turnId,
-                });
-            }
-        }
-    }
-    for (let itemIndex = 0; itemIndex < input.items.length; itemIndex++) {
-        const item = input.items[itemIndex];
-        if (eventHydratedItemIds.has(item.id))
-            continue;
-        applyItem(item, input.items);
-    }
-    if (input.pendingApproval && !eventHydratedApprovalIds.has(input.pendingApproval.id)) {
-        applyPendingApproval(input.pendingApproval);
-    }
-    if (input.pendingAction && !eventHydratedActionIds.has(input.pendingAction.actionId)) {
-        applyPendingAction(input.pendingAction);
-    }
-    const turnIdsToFinalize = new Set([
-        ...assistantIdHistoryByTurn.keys(),
-        ...assistantIdsByTurn.keys(),
-        ...interruptedTurnIds,
-    ]);
-    for (const turnId of turnIdsToFinalize) {
-        let interruptedAssistantId = assistantIdsByTurn.get(turnId);
-        if (interruptedTurnIds.has(turnId) && !interruptedAssistantId) {
-            interruptedAssistantId = ensureAssistantId(turnId);
-        }
-        if (interruptedTurnIds.has(turnId)) {
-            const assistantId = interruptedAssistantId ?? ensureAssistantId(turnId);
-            const startedReasoningStreams = startedReasoningStreamsByTurn.get(turnId) ?? new Set();
-            const completedReasoningStreams = completedReasoningStreamsByTurn.get(turnId) ?? new Set();
-            const unfinishedThinkingPartIds = [...startedReasoningStreams]
-                .filter((streamId) => !completedReasoningStreams.has(streamId))
-                .map((streamId) => createThinkingPartIdFromStream(turnId, streamId));
-            cleanupInterruptedBridgeAssistantMessage(projectionState.messages, assistantId, unfinishedThinkingPartIds);
-            const assistant = projectionState.messages.find((message) => message.id === assistantId && message.role === "assistant");
-            const alreadyMarked = assistant?.parts.some((part) => part.type === "markdown" &&
-                (String(part.markdown ?? "").includes(t("chatStatus.interruptedMarkdown")) ||
-                    String(part.markdown ?? "").includes("Interrupted") ||
-                    String(part.markdown ?? "").includes("已中断")));
-            if (!alreadyMarked) {
-                mutations.appendAssistantMarkdown(assistantId, bridgeInterruptedMarkdown(bridgeAssistantHasMarkdownOutput(projectionState.messages, assistantId)));
-            }
-        }
-        const assistantIds = assistantIdHistoryByTurn.get(turnId) ?? [];
-        for (const assistantId of assistantIds) {
-            const assistant = projectionState.messages.find((message) => message.id === assistantId && message.role === "assistant");
-            if (!assistant)
-                continue;
-            const hasContent = assistant.parts.some((part) => part.type !== "status");
-            if (!hasContent)
-                continue;
-            const hasVisibleReasoning = assistant.parts.some((part) => {
-                if (part.type !== "thinking")
-                    return false;
-                return hasVisibleReasoningText(part.content);
-            });
-            const turnStatus = turnsById.get(turnId)?.status;
-            const reasoningState = hasVisibleReasoning
-                ? "visible"
-                : reasoningDiagnosticsByTurn[turnId];
-            if (reasoningState) {
-                mutations.appendInfoPart(assistantId, "", buildReasoningInfoPart(reasoningState));
-            }
-            if (input.pendingApproval?.turnId === turnId) {
-                mutations.setAssistantStatus(assistantId, t("chatStatus.awaitingApproval"));
-            }
-            else if (input.pendingAction?.turnId === turnId) {
-                mutations.setAssistantStatus(assistantId, t("chatStatus.awaitingAnswers"));
-            }
-            else if (turnStatus === "completed") {
-                mutations.setAssistantStatus(assistantId, t("chatStatus.done"));
-            }
-            else if (turnStatus === "interrupted") {
-                mutations.setAssistantStatus(assistantId, t("chatStatus.interrupted"));
-            }
-            else if (turnStatus === "failed" || turnStatus === "blocked") {
-                mutations.setAssistantStatus(assistantId, t("chatStatus.error"));
-            }
-            mutations.compactSettledSubagentTranscript(assistantId);
-        }
-    }
-    const messages = input.hideInitialUserMessages
-        ? removeHiddenSubagentUserMessages(projectionState.messages)
-        : projectionState.messages;
-    return {
-        approvalActive,
-        messages,
-        paused,
-        userHistory: projectionState.userHistory,
-    };
-}
-async function loadThreadProjection(runtime, threadId, options) {
-    const mode = options?.mode ?? "full";
-    return await withPerfSpanAsync(`loadThreadProjection.${mode}`, `threadId=${threadId}`, async () => {
-        const resumed = await withPerfSpanAsync("runtime.resumeThread", `threadId=${threadId}`, () => mode === "fast"
-            ? runtime.resumeThread(threadId, { turnLimit: FAST_THREAD_RESUME_TURN_LIMIT })
-            : runtime.resumeThread(threadId));
-        const hydrated = { items: resumed.items, turns: resumed.turns };
-        const events = mode === "fast" ? [] : await loadThreadEventsForHydration(runtime, threadId);
-        const hydrateDetail = `threadId=${threadId},items=${hydrated.items.length}/${resumed.items.length}`;
-        const projection = withPerfSpan("hydrateThreadItems", hydrateDetail, () => hydrateThreadItems({
-            events,
-            items: hydrated.items,
-            ...(resumed.pendingAction ? { pendingAction: resumed.pendingAction } : {}),
-            ...(resumed.pendingApproval ? { pendingApproval: resumed.pendingApproval } : {}),
-            renderPendingSteerControls: true,
-            thread: resumed.thread,
-            turns: hydrated.turns,
-        }));
-        return {
-            ...projection,
-            ...(mode === "fast" && resumed.historyHasMore !== undefined
-                ? { historyHasMore: resumed.historyHasMore }
-                : {}),
-            ...(mode === "fast" && resumed.historyNextBeforeItemId
-                ? { historyNextBeforeItemId: resumed.historyNextBeforeItemId }
-                : {}),
-            ...(mode === "fast" && resumed.historyNextBeforeTurnId
-                ? { historyNextBeforeTurnId: resumed.historyNextBeforeTurnId }
-                : {}),
-        };
-    });
-}
-async function loadThreadEventsForHydration(runtime, threadId) {
-    return await withPerfSpanAsync("loadThreadEventsForHydration", `threadId=${threadId}`, async () => {
-        const getThreadEvents = runtime.getThreadEvents?.bind(runtime);
-        if (!getThreadEvents)
-            return [];
-        const events = [];
-        let afterSequence;
-        for (let page = 0; page < 100; page += 1) {
-            const response = await getThreadEvents({
-                ...(afterSequence !== undefined ? { afterSequence } : {}),
-                limit: 500,
-                threadId,
-            });
-            events.push(...response.events);
-            if (!response.hasMore || response.nextAfterSequence === undefined)
-                break;
-            afterSequence = response.nextAfterSequence;
-        }
-        return events;
-    });
-}
-function syncThreadMetadataIntoStore(store, thread, opts) {
-    if (!store)
-        return;
-    const incoming = normalizeBridgeSessionUiMetadata(sessionUiMetadata(thread));
-    let next = incoming;
-    if (opts?.preserveLocalSessionMeta && store.state.sessionMeta) {
-        const local = normalizeBridgeSessionUiMetadata(store.state.sessionMeta);
-        const incomingUpdatedAt = Number(incoming.lastUpdatedAt ?? 0);
-        const localUpdatedAt = Number(local.lastUpdatedAt ?? 0);
-        const preserveLocal = localUpdatedAt > incomingUpdatedAt ||
-            (local.queue.length > 0 &&
-                incoming.queue.length === 0 &&
-                localUpdatedAt >= incomingUpdatedAt);
-        if (preserveLocal)
-            next = local;
-    }
-    const target = store.state.sessionMeta;
-    if (target) {
-        target.queue = [...next.queue];
-        target.queueLength = next.queueLength;
-        target.status = next.status;
-        target.lastUpdatedAt = next.lastUpdatedAt;
-        target.lastErrorCode = next.lastErrorCode ?? undefined;
-        target.pinnedMessageIds = [...next.pinnedMessageIds];
-        target.titleSuggestedAt = next.titleSuggestedAt ?? undefined;
-        target.reasoningDiagnosticsByTurn = {
-            ...next.reasoningDiagnosticsByTurn,
-        };
-        return;
-    }
-    store.state.sessionMeta = next;
-}
-function clearStorePendingApproval(store) {
-    const approval = store.state.approval;
-    if (!approval?.active)
-        return false;
-    const active = asRecord(approval.active);
-    const activeId = normalizeText(active.id);
-    const activeToolCallId = normalizeText(active.toolCallId);
-    approval.active = null;
-    approval.pendingAutoRun = null;
-    if (Array.isArray(approval.queue))
-        approval.queue = [];
-    if (approval.decisions && typeof approval.decisions === "object")
-        approval.decisions = {};
-    if ("skipApproval" in approval)
-        approval.skipApproval = false;
-    const paused = asRecord(store.state.paused);
-    if (!paused.kind ||
-        paused.kind === "tool_approval" ||
-        normalizeText(paused.actionId) === activeId ||
-        normalizeText(paused.toolCallId) === activeToolCallId) {
-        store.state.paused = null;
-    }
-    store.state.runningAgentRound = false;
-    store.state.runningToolCallId = null;
-    if (activeId || activeToolCallId) {
-        store.state.messages = store.state.messages.map((message) => {
-            if (message.role !== "assistant")
-                return message;
-            let changed = false;
-            const parts = message.parts.map((part) => {
-                if (part.type !== "approve")
-                    return part;
-                const request = asRecord(part.request);
-                const sameRequest = (activeId && normalizeText(request.id) === activeId) ||
-                    (activeToolCallId && normalizeText(request.toolCallId) === activeToolCallId);
-                if (!sameRequest || request.status !== "pending")
-                    return part;
-                changed = true;
-                return {
-                    ...part,
-                    request: {
-                        ...part.request,
-                        status: "denied",
-                    },
-                };
-            });
-            return changed ? { ...message, parts } : message;
-        });
-    }
-    return true;
-}
-function applyThreadProjectionToStore(store, thread, projection) {
-    if (!store)
-        return;
-    if (typeof store.setCwd === "function") {
-        store.setCwd(thread.cwd);
-    }
-    else {
-        store.state.context = {
-            ...store.state.context,
-            cwd: thread.cwd,
-        };
-    }
-    if (typeof store.replaceMessages === "function") {
-        store.replaceMessages(projection.messages);
-    }
-    else {
-        store.state.messages = projection.messages;
-        if (Array.isArray(store.state.userHistory)) {
-            store.state.userHistory.splice(0, store.state.userHistory.length, ...projection.userHistory);
-        }
-        else {
-            store.state.userHistory = [...projection.userHistory];
-        }
-    }
-    store.state.paused = projection.paused;
-    store.state.runningAgentRound = false;
-    store.state.runningToolCallId = null;
-    store.state.sessionId = thread.id;
-    if (store.state.usage) {
-        store.state.usage.prompt_tokens = 0;
-        store.state.usage.completion_tokens = 0;
-        store.state.usage.total_tokens = 0;
-    }
-    if ("lastRequestBudget" in store.state)
-        store.state.lastRequestBudget = null;
-    restoreThreadUiMetricsIntoStore(store, thread);
-    if ("chromeVersion" in store.state && typeof store.state.chromeVersion === "number")
-        store.state.chromeVersion += 1;
-    syncThreadMetadataIntoStore(store, thread);
-    store.setMode?.(cliModeFromThreadMode(thread.mode));
-    if (store.state.ui)
-        store.state.ui.mode = cliModeFromThreadMode(thread.mode);
-    if (store.state.revertedMessages)
-        store.state.revertedMessages = [];
-    if (store.state.approval) {
-        store.state.approval.active = projection.approvalActive;
-        store.state.approval.pendingAutoRun = null;
-        if ("skipApproval" in store.state.approval)
-            store.state.approval.skipApproval = false;
-    }
-    if (store.state.thinking) {
-        store.state.thinking.active = false;
-        store.state.thinking.endedAt = null;
-        store.state.thinking.startedAt = null;
-    }
-    if (store.state.ui?.restore) {
-        store.state.ui.restore = { status: "idle", sessionId: thread.id };
-    }
-    if (store.state.ui?.activeSubagentIds) {
-        store.state.ui.activeSubagentIds = [];
-    }
-}
-function setThreadRestoreStatus(store, status, threadId) {
-    if (!store?.state.ui?.restore)
-        return;
-    if (status !== "loading" && store.state.ui.restore.sessionId !== threadId)
-        return;
-    store.state.ui.restore = { status, sessionId: threadId };
-}
-function approvalPermission(toolName) {
-    const semantic = toolSemantic(toolName);
-    return semantic === "read_like" || semantic === "search_like" ? "pass" : "require_action";
-}
-function approvalRiskLevel(toolName) {
-    switch (toolSemantic(toolName)) {
-        case "read_like":
-        case "search_like":
-            return "safe";
-        case "write_like":
-            return "high";
-        case "shell_like":
-            return "critical";
-        default:
-            return "medium";
-    }
-}
-function buildChildThreadText(event) {
-    const item = event.item;
-    if (item.kind === "tool-call")
-        return `${canonicalToolName(item.toolName)} ${item.input}`;
-    if (item.kind === "tool-result")
-        return item.output;
-    if (item.kind === "message" && item.role === "agent")
-        return item.text;
-    if (item.kind === "error")
-        return item.message;
-    return null;
-}
-function childTaskSubagentId(event) {
-    return (normalizeText(event.record.childThreadId) ||
-        normalizeText(event.record.childTaskId) ||
-        normalizeText(event.record.correlationId));
-}
-function childStreamSubagentId(event) {
-    return normalizeText(event.threadId);
-}
-function childThreadSubagentId(event) {
-    return normalizeText(event.childThreadId) || childScopeLabel(event);
-}
-function ensureSubagentStarted(queue, state, subagentId, taskDescription) {
-    const normalizedSubagentId = normalizeText(subagentId);
-    if (!normalizedSubagentId)
-        return;
-    const description = normalizeText(taskDescription);
-    if (description)
-        state.subagentDescriptionsById.set(normalizedSubagentId, description);
-    if (state.startedSubagentIds.has(normalizedSubagentId))
-        return;
-    state.startedSubagentIds.add(normalizedSubagentId);
-    queue.push({
-        subagentId: normalizedSubagentId,
-        taskDescription: description || state.subagentDescriptionsById.get(normalizedSubagentId) || undefined,
-        type: "subagent.started",
-    });
-}
-const SUBAGENT_TOOL_ACTIVITY_MIN_INTERVAL_MS = 500;
-function compactSubagentActivityText(value, max = 96) {
-    const normalized = String(value ?? "")
-        .replace(/\r/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!normalized)
-        return "";
-    if (normalized.length <= max)
-        return normalized;
-    if (max <= 1)
-        return normalized.slice(0, max);
-    return `${normalized.slice(0, max - 1).trimEnd()}…`;
-}
-function subagentToolInputSummary(input) {
-    const value = input.file_path ??
-        input.path ??
-        input.query ??
-        input.pattern ??
-        input.command ??
-        input.file ??
-        input.url;
-    if (Array.isArray(value))
-        return value.map((entry) => compactSubagentActivityText(entry, 40)).join(", ");
-    return compactSubagentActivityText(value, 60);
-}
-function formatSubagentToolActivityLabel(toolName, input, rawInput) {
-    const name = canonicalToolName(toolName) || normalizeText(toolName);
-    if (!name)
-        return "";
-    const summaryFromObject = input ? subagentToolInputSummary(input) : "";
-    let rawSummary = "";
-    if (!summaryFromObject && typeof rawInput === "string") {
-        const raw = rawInput.trim();
-        if (raw && !raw.startsWith("{") && !raw.startsWith("[")) {
-            rawSummary = compactSubagentActivityText(raw, 60);
-        }
-    }
-    const summary = summaryFromObject || rawSummary;
-    return compactSubagentActivityText(summary ? `${name} ${summary}` : name, 96);
-}
-function shouldEmitSubagentToolActivity(entry, label, force) {
-    if (!label)
-        return false;
-    const now = Date.now();
-    if (!force && entry.lastActivityLabel === label)
-        return false;
-    if (!force &&
-        typeof entry.lastActivityEmittedAtMs === "number" &&
-        now - entry.lastActivityEmittedAtMs < SUBAGENT_TOOL_ACTIVITY_MIN_INTERVAL_MS) {
-        return false;
-    }
-    entry.lastActivityLabel = label;
-    entry.lastActivityEmittedAtMs = now;
-    return true;
-}
-function emitSubagentToolActivity(queue, state, input) {
-    const callId = normalizeText(input.callId);
-    const subagentId = normalizeText(input.subagentId);
-    const toolName = canonicalToolName(input.toolName);
-    if (!callId || !subagentId || !toolName)
-        return;
-    const entry = state.childToolInputsByCallId.get(callId) ?? {
-        deltas: [],
-        subagentId,
-        toolName,
-    };
-    entry.subagentId = subagentId;
-    entry.subagentTurnId = normalizeText(input.subagentTurnId) || entry.subagentTurnId;
-    entry.toolName = toolName;
-    // Do not accumulate or join streamed child tool-call input here. Long-context
-    // subagents can stream huge JSON arguments; joining the whole prefix on every
-    // delta is O(n^2) and blocks the TUI before the projector can coalesce work.
-    if (typeof input.delta === "string" && input.delta.length > 0)
-        entry.deltas.length = 0;
-    state.childToolInputsByCallId.set(callId, entry);
-    state.streamedChildToolCallIds.add(callId);
-    const force = typeof input.delta !== "string";
-    const label = formatSubagentToolActivityLabel(toolName);
-    if (!shouldEmitSubagentToolActivity(entry, label, force))
-        return;
-    queue.push({
-        delta: label,
-        stream: "tool",
-        subagentId,
-        ...(entry.subagentTurnId ? { subagentTurnId: entry.subagentTurnId } : {}),
-        type: "subagent.output",
-    });
-}
-async function resumeBestAgentThread(runtime, threadId, requestedMode) {
-    const thread = await resolveBestAgentThread(runtime, threadId, requestedMode);
-    await runtime.resumeThread(thread.id);
-    return (await runtime.getThread({ threadId: thread.id })).thread;
-}
-async function resolveBestAgentThread(runtime, threadId, requestedMode) {
-    const detail = await runtime.getThread({ threadId });
-    let thread = detail.thread;
-    if (thread.status === "archived") {
-        await runtime.unarchiveThread(threadId);
-        thread = (await runtime.getThread({ threadId })).thread;
-    }
-    if (requestedMode && thread.mode !== requestedMode)
-        return (await runtime.setThreadMode({ mode: requestedMode, threadId })).thread;
-    return thread;
-}
-export async function resolveInitialBestAgentThread(runtime, options) {
-    if (options.resumeThreadId)
-        return resolveBestAgentThread(runtime, options.resumeThreadId, options.threadMode);
-    if (options.latest) {
-        const listed = await runtime.listThreads({ limit: 1 });
-        if (listed.threads[0])
-            return resolveBestAgentThread(runtime, listed.threads[0].id, options.threadMode);
-    }
-    const created = await runtime.startThread({ mode: options.threadMode });
-    return created.thread;
-}
-export function createBestAgentNativeBridge(options) {
-    const threadStates = new Map();
-    let storeRef = null;
-    let unsubscribeStoreRuntimeEvents = null;
-    let currentMode = cliModeFromThreadMode(options.threadMode);
-    let threadSwitchGeneration = 0;
-    const getThreadState = (threadId) => {
-        const existing = threadStates.get(threadId);
-        if (existing)
-            return existing;
-        const created = {};
-        threadStates.set(threadId, created);
-        return created;
-    };
-    const refreshAttachedStoreThread = (threadId) => {
-        const targetStore = storeRef;
-        if (!targetStore || targetStore.state.sessionId !== threadId)
-            return;
-        void options.runtime
-            .getThread({ threadId })
-            .then(({ thread }) => {
-            if (storeRef === targetStore && targetStore.state.sessionId === threadId) {
-                return switchAttachedStoreThread(thread, { mode: "fast" });
-            }
-        })
-            .catch(() => { });
-    };
-    const switchAttachedStoreThread = async (thread, opts) => {
-        const generation = opts?.generation ?? ++threadSwitchGeneration;
-        const targetStore = storeRef;
-        if (!targetStore)
-            return { applied: false, generation };
-        const projection = await loadThreadProjection(options.runtime, thread.id, {
-            mode: opts?.mode,
-        });
-        if (generation !== threadSwitchGeneration)
-            return { applied: false, generation };
-        if (storeRef !== targetStore)
-            return { applied: false, generation };
-        applyThreadProjectionToStore(targetStore, thread, projection);
-        getThreadState(thread.id).history = {
-            hasMore: Boolean(projection.historyHasMore),
-            ...(projection.historyNextBeforeItemId
-                ? { nextBeforeItemId: projection.historyNextBeforeItemId }
-                : {}),
-            ...(projection.historyNextBeforeTurnId
-                ? { nextBeforeTurnId: projection.historyNextBeforeTurnId }
-                : {}),
-        };
-        return { applied: true, generation };
-    };
-    const fastHistoryRestoreEnabled = () => String(process.env.BEST_AGENT_FAST_HISTORY_RESTORE ?? "").trim() !== "0";
-    const waitForPendingTurnToSettle = async (threadId, pending, timeoutMs = 1500) => {
-        const isSettled = () => {
-            const current = getThreadState(threadId).pendingTurn;
-            if (current !== pending)
-                return true;
-            return pending.status !== "running" && pending.status !== "paused" && !pending.resumeInFlight;
-        };
-        if (isSettled())
-            return;
-        await new Promise((resolve) => {
-            let settled = false;
-            let timeout;
-            let unsubscribe;
-            const finish = () => {
-                if (settled)
-                    return;
-                settled = true;
-                if (timeout)
-                    clearTimeout(timeout);
-                unsubscribe?.();
-                resolve();
-            };
-            unsubscribe = options.runtime.subscribe(({ event }) => {
-                if (!belongsToThread(event, threadId, pending.turnId)) {
-                    if (isSettled())
-                        finish();
-                    return;
-                }
-                if (event.type === "turn.completed" ||
-                    event.type === "turn.failed" ||
-                    event.type === "turn.interrupted" ||
-                    event.type === "turn.blocked") {
-                    finish();
-                }
-            });
-            timeout = setTimeout(finish, timeoutMs);
-            if (isSettled())
-                finish();
-        });
-    };
-    const hydrateThread = async (threadId) => (await loadThreadProjection(options.runtime, threadId)).messages;
-    const activeThreadId = () => {
-        const value = normalizeText(storeRef?.state.sessionId);
-        return value ? value : undefined;
-    };
-    const prependThreadHistoryPage = (store, messages) => {
-        const seen = new Set(store.state.messages.map((message) => String(message.id ?? "")));
-        const older = messages.filter((message) => {
-            const id = String(message.id ?? "");
-            if (!id || seen.has(id))
-                return false;
-            seen.add(id);
-            return true;
-        });
-        if (older.length === 0)
-            return false;
-        if (typeof store.replaceMessages === "function") {
-            store.replaceMessages([...older, ...store.state.messages]);
-        }
-        else {
-            store.state.messages.splice(0, 0, ...older);
-            if (Array.isArray(store.state.userHistory)) {
-                const userHistory = older
-                    .filter((message) => Boolean(message && message.role === "user"))
-                    .map((message) => message.content);
-                store.state.userHistory.splice(0, 0, ...userHistory);
-            }
-        }
-        if ("chromeVersion" in store.state && typeof store.state.chromeVersion === "number") {
-            store.state.chromeVersion += 1;
-        }
-        return true;
-    };
-    const loadMoreAttachedStoreHistory = async (threadId) => {
-        const targetStore = storeRef;
-        if (!targetStore || normalizeText(targetStore.state.sessionId) !== threadId)
-            return false;
-        const state = getThreadState(threadId);
-        const history = state.history;
-        if (!history?.hasMore || history.loading || !history.nextBeforeTurnId)
-            return false;
-        history.loading = true;
-        try {
-            const [response, detail] = await Promise.all([
-                options.runtime.getThreadHistory({
-                    beforeTurnId: history.nextBeforeTurnId,
-                    threadId,
-                    turnLimit: HISTORY_PAGE_TURN_LIMIT,
-                }),
-                options.runtime.getThread({ threadId }),
-            ]);
-            if (storeRef !== targetStore || normalizeText(targetStore.state.sessionId) !== threadId) {
-                return false;
-            }
-            const projection = hydrateThreadItems({
-                items: response.items,
-                renderPendingSteerControls: true,
-                thread: detail.thread,
-                turns: response.turns ?? [],
-            });
-            state.history = {
-                hasMore: response.hasMore,
-                ...(response.nextBeforeItemId ? { nextBeforeItemId: response.nextBeforeItemId } : {}),
-                ...(response.nextBeforeTurnId ? { nextBeforeTurnId: response.nextBeforeTurnId } : {}),
-            };
-            return prependThreadHistoryPage(targetStore, projection.messages);
-        }
-        finally {
-            const latest = getThreadState(threadId).history;
-            if (latest)
-                latest.loading = false;
-        }
-    };
-    const sessions = {
-        async createNew() {
-            const created = await options.runtime.startThread({
-                mode: threadModeFromCliMode(currentMode),
-            });
-            const switched = await switchAttachedStoreThread(created.thread);
-            if (switched.applied)
-                currentMode = cliModeFromThreadMode(created.thread.mode);
-        },
-        async delete(threadId) {
-            await options.runtime.purgeThread(threadId);
-            threadStates.delete(threadId);
-            if (!storeRef || storeRef.state.sessionId !== threadId)
-                return;
-            const listed = await options.runtime.listThreads({ limit: 1 });
-            if (listed.threads[0]) {
-                const switched = await switchAttachedStoreThread(listed.threads[0], { mode: "fast" });
-                if (switched.applied)
-                    currentMode = cliModeFromThreadMode(listed.threads[0].mode);
-                return;
-            }
-            const created = await options.runtime.startThread({
-                mode: threadModeFromCliMode(currentMode),
-            });
-            const switched = await switchAttachedStoreThread(created.thread);
-            if (switched.applied)
-                currentMode = cliModeFromThreadMode(created.thread.mode);
-        },
-        async fork() {
-            const currentThreadId = normalizeText(storeRef?.state.sessionId);
-            if (!currentThreadId)
-                return;
-            const forked = await options.runtime.forkThread({
-                threadId: currentThreadId,
-            });
-            const switched = await switchAttachedStoreThread(forked.thread, { mode: "fast" });
-            if (switched.applied)
-                currentMode = cliModeFromThreadMode(forked.thread.mode);
-        },
-        async get(threadId, getOptions) {
-            try {
-                const thread = (await options.runtime.getThread({ threadId: threadId })).thread;
-                if (!getOptions?.includeMessages)
-                    return thread;
-                const projection = await loadThreadProjection(options.runtime, threadId);
-                return { ...thread, messages: projection.messages };
-            }
-            catch {
-                return null;
-            }
-        },
-        async trace(threadId) {
-            try {
-                const normalizedThreadId = threadId;
-                const diagnosticsPromise = typeof options.runtime.getThreadDiagnostics === "function"
-                    ? options.runtime.getThreadDiagnostics(normalizedThreadId).catch(() => undefined)
-                    : Promise.resolve(undefined);
-                const [items, events, diagnostics] = await Promise.all([
-                    loadThreadTraceItems(options.runtime, normalizedThreadId),
-                    loadThreadTraceEvents(options.runtime, normalizedThreadId),
-                    diagnosticsPromise,
-                ]);
-                return buildSessionTrace(normalizedThreadId, items, events, diagnostics?.diagnostics.processes?.records ?? []);
-            }
-            catch {
-                return null;
-            }
-        },
-        async subagent(threadId) {
-            try {
-                const normalizedThreadId = threadId;
-                const [resumed, events] = await Promise.all([
-                    options.runtime.resumeThread(normalizedThreadId),
-                    loadThreadTraceEvents(options.runtime, normalizedThreadId),
-                ]);
-                return buildSubagentDetail(resumed.thread, resumed.turns, resumed.items, events, {
-                    ...(resumed.pendingAction ? { pendingAction: resumed.pendingAction } : {}),
-                    ...(resumed.pendingApproval ? { pendingApproval: resumed.pendingApproval } : {}),
-                });
-            }
-            catch {
-                return null;
-            }
-        },
-        watchSubagent(threadId, watchOptions, onEvent) {
-            return watchSubagentLiveEvents(options.runtime, threadId, watchOptions, onEvent);
-        },
-        async steerSubagent(threadId, turnId, prompt) {
-            const normalizedPrompt = normalizeText(prompt);
-            if (!normalizedPrompt)
-                return { message: "Missing steer prompt.", ok: false, status: "unknown" };
-            const normalizedThreadId = threadId;
-            const normalizedTurnId = turnId;
-            const response = await options.runtime.steerTurn(normalizedThreadId, normalizedTurnId, normalizedPrompt);
-            const status = normalizeSubagentStatus(response?.turn?.status);
-            return { ok: true, status: status === "unknown" ? "running" : status };
-        },
-        async loadMoreHistory(threadId) {
-            const normalizedThreadId = normalizeText(threadId);
-            if (!normalizedThreadId)
-                return false;
-            return loadMoreAttachedStoreHistory(normalizedThreadId);
-        },
-        async list() {
-            return await withPerfSpanAsync("native.sessions.list", undefined, async () => {
-                const listed = await options.runtime.listThreads({ limit: 50 });
-                const threads = await filterSessionThreads(options.runtime, listed.threads);
-                const activeId = activeThreadId();
-                return Promise.all(threads.map(async (thread) => {
-                    const activeMessages = activeId && thread.id === activeId && storeRef?.state.messages.length
-                        ? storeRef.state.messages
-                        : null;
-                    const summary = activeMessages ? latestSummary(activeMessages) : previewSummary(thread);
-                    const metadata = sessionListMetadata(thread);
-                    return {
-                        cwd: thread.cwd,
-                        id: thread.id,
-                        lastUpdatedAt: metadata.lastUpdatedAt,
-                        lastMessage: summary.lastMessage,
-                        messageCount: summary.messageCount,
-                        queue: metadata.queue,
-                        queueLength: metadata.queueLength,
-                        reasoningDiagnosticsByTurn: metadata.reasoningDiagnosticsByTurn,
-                        summary: summary.summary,
-                        status: metadata.status ?? thread.status,
-                        title: activeSessionTitle(thread.title, activeMessages),
-                        updatedAt: sessionListUpdatedAt(thread, metadata),
-                    };
-                }));
-            });
-        },
-        async rename(threadId, title) {
-            const renamed = await options.runtime.renameThread(threadId, title);
-            if (!storeRef || storeRef.state.sessionId !== threadId)
-                return;
-            const switched = await switchAttachedStoreThread(renamed.thread, { mode: "fast" });
-            if (switched.applied)
-                currentMode = cliModeFromThreadMode(renamed.thread.mode);
-        },
-        async reload(threadId) {
-            const normalizedThreadId = threadId;
-            const thread = await resolveBestAgentThread(options.runtime, normalizedThreadId);
-            if (!storeRef || storeRef.state.sessionId !== threadId)
-                return false;
-            const switched = await switchAttachedStoreThread(thread, { mode: "fast" });
-            if (switched.applied)
-                currentMode = cliModeFromThreadMode(thread.mode);
-            return switched.applied;
-        },
-        async updateMetadata(threadId, metadata) {
-            const updated = await options.runtime.updateThreadMetadata(threadId, wrapSessionUiMetadata(metadata));
-            if (!storeRef || storeRef.state.sessionId !== threadId)
-                return;
-            syncThreadMetadataIntoStore(storeRef, updated.thread, {
-                preserveLocalSessionMeta: true,
-            });
-        },
-        async use(threadId) {
-            await withPerfSpanAsync("sessions.use", `threadId=${normalizeText(threadId)}`, async () => {
-                const normalized = normalizeText(threadId);
-                if (!normalized)
-                    return;
-                if (storeRef &&
-                    normalizeText(storeRef.state.sessionId) === normalized &&
-                    storeRef.state.messages.length > 0) {
-                    return;
-                }
-                const restoreStore = storeRef;
-                setThreadRestoreStatus(restoreStore, "loading", normalized);
-                try {
-                    const thread = await resolveBestAgentThread(options.runtime, normalized);
-                    const useFastProjection = Boolean(storeRef) && fastHistoryRestoreEnabled();
-                    const generation = ++threadSwitchGeneration;
-                    const switched = await switchAttachedStoreThread(thread, {
-                        generation,
-                        mode: useFastProjection ? "fast" : "full",
-                    });
-                    if (!switched.applied) {
-                        setThreadRestoreStatus(restoreStore, "idle", normalized);
-                        return;
-                    }
-                    currentMode = cliModeFromThreadMode(thread.mode);
-                }
-                catch (error) {
-                    setThreadRestoreStatus(restoreStore, "idle", normalized);
-                    throw error;
-                }
-            });
-        },
-    };
-    const createSession = (threadId) => {
-        const clearBackgroundTracking = (pending) => {
-            pending.backgroundUnsubscribe?.();
-            pending.backgroundUnsubscribe = undefined;
-        };
-        const clearPendingTurnIfTerminal = (pending) => {
-            if (pending.status === "completed" ||
-                pending.status === "failed" ||
-                pending.status === "interrupted") {
-                const state = getThreadState(threadId);
-                if (state.pendingTurn === pending)
-                    state.pendingTurn = undefined;
-            }
-        };
-        const persistTurnReasoningDiagnostics = async (pending, diagnostics) => {
-            if (!pending.turnId)
-                return;
-            try {
-                const updated = await options.runtime.updateThreadMetadata(threadId, {
-                    ui: {
-                        reasoningDiagnosticsByTurn: {
-                            [pending.turnId]: diagnostics.state,
-                        },
-                    },
-                });
-                if (!storeRef || storeRef.state.sessionId !== threadId)
-                    return;
-                syncThreadMetadataIntoStore(storeRef, updated.thread, {
-                    preserveLocalSessionMeta: true,
-                });
-            }
-            catch { }
-        };
-        const startDetachedTracking = (pending) => {
-            clearBackgroundTracking(pending);
-            if (pending.status !== "running")
-                return;
-            if (pending.turnId) {
-                const detach = options.runtime.markTurnDetached?.(threadId, pending.turnId);
-                void detach?.catch(() => { });
-            }
-            pending.backgroundUnsubscribe = options.runtime.subscribe(({ event }) => {
-                if (!belongsToThread(event, threadId, pending.turnId))
-                    return;
-                if (event.type === "turn.started") {
-                    pending.turnId = event.turn.id;
-                    const detach = options.runtime.markTurnDetached?.(threadId, event.turn.id);
-                    void detach?.catch(() => { });
-                    return;
-                }
-                if (event.type === "turn.item.added" && event.item.kind === "error") {
-                    pending.error = event.item;
-                    return;
-                }
-                if (event.type === "turn.item.added" &&
-                    event.item.kind === "reasoning" &&
-                    !isDraftReasoningItem(event.item) &&
-                    hasVisibleReasoningText(event.item.content ?? event.item.summary)) {
-                    pending.sawVisibleReasoning = true;
-                    return;
-                }
-                if ((event.type === "turn.reasoning.delta" || event.type === "turn.reasoning.completed") &&
-                    !event.parentTurnId) {
-                    const currentReasoning = event.type === "turn.reasoning.delta"
-                        ? event.delta
-                        : pending.reasoningTextByStreamId.get(event.streamId);
-                    if (hasVisibleReasoningText(currentReasoning))
-                        pending.sawVisibleReasoning = true;
-                    return;
-                }
-                if (event.type === "thread.usage.updated") {
-                    pending.latestUsage = usageMetadataFromSessionUsage(event.inclusive);
-                    updatePendingReasoningTokens(pending, event.last);
-                    return;
-                }
-                if (event.type === "approval.requested") {
-                    pending.approval = event.approval;
-                    pending.status = "paused";
-                    clearBackgroundTracking(pending);
-                    return;
-                }
-                if (event.type === "action.required" && event.kind === "ask_user") {
-                    pending.action = {
-                        actionId: event.actionId,
-                        questions: event.questions,
-                        toolCallId: normalizeText(event.toolCallId) || undefined,
-                        toolName: canonicalToolName(event.toolName),
-                    };
-                    pending.status = "paused";
-                    clearBackgroundTracking(pending);
-                    return;
-                }
-                if (event.type === "turn.completed") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.resumeInFlight = false;
-                    pending.status = "completed";
-                    void persistTurnReasoningDiagnostics(pending, resolvePendingReasoningDiagnostics(pending));
-                    clearBackgroundTracking(pending);
-                    clearPendingTurnIfTerminal(pending);
-                    return;
-                }
-                if (event.type === "turn.interrupted") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.resumeInFlight = false;
-                    pending.status = "interrupted";
-                    void persistTurnReasoningDiagnostics(pending, resolvePendingReasoningDiagnostics(pending));
-                    clearBackgroundTracking(pending);
-                    clearPendingTurnIfTerminal(pending);
-                    return;
-                }
-                if (event.type === "turn.failed" || event.type === "turn.blocked") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.resumeInFlight = false;
-                    pending.status = "failed";
-                    void persistTurnReasoningDiagnostics(pending, resolvePendingReasoningDiagnostics(pending));
-                    clearBackgroundTracking(pending);
-                    clearPendingTurnIfTerminal(pending);
-                }
-            });
-        };
-        const streamPendingTurn = async function* (pending, input) {
-            let finish = null;
-            const queue = createAsyncQueue({
-                onClose: () => {
-                    finish?.({ detach: true });
-                },
-            });
-            clearBackgroundTracking(pending);
-            let abortRequested = false;
-            let catchUpComplete = input.attachAfterSequence == null;
-            const bufferedEnvelopes = [];
-            let settled = false;
-            let approvalResumeWatchdog;
-            finish = (opts2) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (approvalResumeWatchdog)
-                    clearTimeout(approvalResumeWatchdog);
-                unsubscribe();
-                input.signal?.removeEventListener("abort", onAbort);
-                if (opts2?.detach && pending.status === "running" && !pending.resumeInFlight) {
-                    startDetachedTracking(pending);
-                }
-                queue.close();
-            };
-            const onAbort = () => {
-                abortRequested = true;
-                finish?.({ detach: true });
-            };
-            const flushPendingReasoningSummaries = () => {
-                if (pending.streamedReasoning || pending.reasoningSummaries.length === 0)
-                    return;
-                const summaries = pending.reasoningSummaries.map(normalizeText).filter(Boolean);
-                pending.reasoningSummaries = [];
-                logLlmDebug("bridge.reasoning.summary.flush", {
-                    summaries,
-                    threadId,
-                    turnId: pending.turnId,
-                });
-                for (const summary of summaries) {
-                    queue.push({
-                        message: {
-                            content: "",
-                            thinking: summary,
-                        },
-                        type: "assistant.message",
-                    });
-                }
-            };
-            const shouldFlushPendingReasoningSummaries = (event) => {
-                switch (event.type) {
-                    case "turn.text.delta":
-                    case "turn.text.stream.reset":
-                    case "turn.tool-call.started":
-                    case "turn.tool-call.delta":
-                    case "turn.tool-output.delta":
-                    case "child-task.started":
-                    case "child-task.completed":
-                    case "child-task.joined":
-                    case "child-task.failed":
-                    case "child-task.rejected":
-                    case "child-thread.item.added":
-                    case "approval.requested":
-                    case "turn.completed":
-                    case "turn.interrupted":
-                    case "turn.blocked":
-                    case "turn.failed":
-                        return true;
-                    case "action.required":
-                        return true;
-                    case "turn.item.added":
-                        return event.item.kind !== "reasoning";
-                    default:
-                        return false;
-                }
-            };
-            const processEnvelope = (envelope, opts2) => {
-                const { event, sequence } = envelope;
-                const eventCreatedAtMs = parseIsoTimeMs(envelope.createdAt) ?? undefined;
-                if (event.type === "turn.reasoning.started" ||
-                    event.type === "turn.reasoning.delta" ||
-                    event.type === "turn.reasoning.completed" ||
-                    event.type === "turn.text.delta" ||
-                    event.type === "turn.text.stream.reset" ||
-                    event.type === "turn.item.added") {
-                    const debugEvent = event;
-                    const isChildEvent = typeof debugEvent.parentTurnId === "string" && debugEvent.parentTurnId.length > 0;
-                    logLlmDebug("bridge.event", {
-                        event: event.type === "turn.item.added"
-                            ? {
-                                itemKind: event.item.kind,
-                                role: "role" in event.item ? event.item.role : undefined,
-                                summaryChars: "summary" in event.item && typeof event.item.summary === "string"
-                                    ? event.item.summary.length
-                                    : undefined,
-                                textChars: "text" in event.item && typeof event.item.text === "string"
-                                    ? event.item.text.length
-                                    : undefined,
-                                type: event.type,
-                            }
-                            : isChildEvent
-                                ? {
-                                    callId: typeof debugEvent.callId === "string" ? debugEvent.callId : undefined,
-                                    deltaChars: typeof debugEvent.delta === "string" ? debugEvent.delta.length : undefined,
-                                    parentTurnId: debugEvent.parentTurnId,
-                                    relation: typeof debugEvent.relation === "string" ? debugEvent.relation : undefined,
-                                    streamId: typeof debugEvent.streamId === "string" ? debugEvent.streamId : undefined,
-                                    turnId: typeof debugEvent.turnId === "string" ? debugEvent.turnId : undefined,
-                                    type: event.type,
-                                }
-                                : event,
-                        threadId,
-                        turnId: pending.turnId,
-                    });
-                }
-                if (!belongsToThread(event, threadId, pending.turnId))
-                    return;
-                if (opts2?.trackSequence !== false)
-                    pending.lastDeliveredSequence = sequence;
-                if (event.type === "turn.started") {
-                    pending.turnId = event.turn.id;
-                    return;
-                }
-                if (event.type === "turn.steered") {
-                    const prompt = normalizeText(event.prompt);
-                    if (prompt)
-                        pending.pendingSteerPrompts.push(prompt);
-                    return;
-                }
-                if (event.type === "turn.reasoning.started") {
-                    if (!event.parentTurnId) {
-                        pending.streamedReasoning = true;
-                        pending.reasoningSummaries = [];
-                        const partId = createThinkingPartIdFromStream(event.turnId, event.streamId);
-                        pending.reasoningPartIdByStreamId.set(event.streamId, partId);
-                        pending.reasoningTextByStreamId.set(event.streamId, "");
-                        queue.push({ type: "thinking.started", partId });
-                    }
-                    else if (event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                    }
-                    return;
-                }
-                if (event.type === "turn.reasoning.delta") {
-                    if (!event.parentTurnId) {
-                        pending.streamedReasoning = true;
-                        pending.reasoningSummaries = [];
-                        if (hasVisibleReasoningText(event.delta))
-                            pending.sawVisibleReasoning = true;
-                        const partId = pending.reasoningPartIdByStreamId.get(event.streamId) ??
-                            createThinkingPartIdFromStream(event.turnId, event.streamId);
-                        pending.reasoningPartIdByStreamId.set(event.streamId, partId);
-                        const nextText = `${pending.reasoningTextByStreamId.get(event.streamId) ?? ""}${event.delta}`;
-                        pending.reasoningTextByStreamId.set(event.streamId, nextText);
-                        queue.push({ partId, delta: event.delta, type: "thinking.delta" });
-                    }
-                    else if (event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                    }
-                    return;
-                }
-                if (event.type === "turn.reasoning.completed") {
-                    if (!event.parentTurnId) {
-                        pending.streamedReasoning = true;
-                        pending.reasoningSummaries = [];
-                        const partId = pending.reasoningPartIdByStreamId.get(event.streamId) ??
-                            createThinkingPartIdFromStream(event.turnId, event.streamId);
-                        const finalReasoning = pending.reasoningTextByStreamId.get(event.streamId);
-                        if (hasVisibleReasoningText(finalReasoning))
-                            pending.sawVisibleReasoning = true;
-                        queue.push({
-                            partId,
-                            content: finalReasoning || undefined,
-                            type: "thinking.finished",
-                        });
-                        pending.reasoningPartIdByStreamId.delete(event.streamId);
-                        pending.reasoningTextByStreamId.delete(event.streamId);
-                    }
-                    else if (event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                    }
-                    return;
-                }
-                if (shouldFlushPendingReasoningSummaries(event))
-                    flushPendingReasoningSummaries();
-                if (event.type === "turn.text.delta") {
-                    pending.streamedAgentTurnIds.add(event.turnId);
-                    if (event.parentTurnId && event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                        queue.push({
-                            delta: event.delta,
-                            stream: "text",
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            type: "subagent.output",
-                        });
-                        return;
-                    }
-                    const delta = event.delta;
-                    queue.push({ delta, streamId: event.streamId, type: "assistant.delta" });
-                    return;
-                }
-                if (event.type === "turn.text.stream.reset") {
-                    if (event.parentTurnId && event.relation) {
-                        return;
-                    }
-                    pending.streamedAgentTurnIds.delete(event.turnId);
-                    queue.push({ streamId: event.streamId, type: "assistant.reset" });
-                    return;
-                }
-                if (event.type === "turn.tool-call.started") {
-                    if (event.parentTurnId && event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                        pending.childToolInputsByCallId.set(event.callId, {
-                            deltas: [],
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            toolName: canonicalToolName(event.toolName),
-                        });
-                        pending.toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-                        queue.push({
-                            input: {},
-                            originalEventType: "tool_call",
-                            startedAtMs: eventCreatedAtMs,
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            toolCallId: event.callId,
-                            toolName: canonicalToolName(event.toolName),
-                            type: "tool.started",
-                        });
-                        emitSubagentToolActivity(queue, pending, {
-                            callId: event.callId,
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            toolName: event.toolName,
-                        });
-                        return;
-                    }
-                    pending.toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-                    pending.startedToolCallIds.add(event.callId);
-                    pending.inputDeltasByCallId.set(event.callId, {
-                        deltas: [],
-                        toolName: canonicalToolName(event.toolName),
-                    });
-                    queue.push({
-                        input: {},
-                        originalEventType: "tool_call",
-                        startedAtMs: eventCreatedAtMs,
-                        toolCallId: event.callId,
-                        toolName: canonicalToolName(event.toolName),
-                        type: "tool.started",
-                    });
-                    return;
-                }
-                if (event.type === "turn.tool-call.delta") {
-                    if (event.parentTurnId && event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                        pending.toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-                        queue.push({
-                            delta: event.delta,
-                            kind: "input",
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            toolCallId: event.callId,
-                            toolName: canonicalToolName(event.toolName),
-                            type: "tool.delta",
-                        });
-                        if (!pending.childToolInputsByCallId.has(event.callId)) {
-                            emitSubagentToolActivity(queue, pending, {
-                                callId: event.callId,
-                                subagentId,
-                                subagentTurnId: event.turnId,
-                                toolName: event.toolName,
-                            });
-                        }
-                        else {
-                            pending.streamedChildToolCallIds.add(event.callId);
-                        }
-                        return;
-                    }
-                    const callId = event.callId;
-                    const existing = pending.inputDeltasByCallId.get(callId) ?? {
-                        deltas: [],
-                        toolName: canonicalToolName(event.toolName),
-                    };
-                    existing.toolName = canonicalToolName(event.toolName);
-                    existing.deltas.push(event.delta);
-                    pending.toolNamesByCallId.set(callId, existing.toolName);
-                    pending.inputDeltasByCallId.set(callId, existing);
-                    pending.streamedToolInputCallIds.add(callId);
-                    queue.push({
-                        delta: event.delta,
-                        kind: "input",
-                        toolCallId: callId,
-                        toolName: existing.toolName,
-                        type: "tool.delta",
-                    });
-                    return;
-                }
-                if (event.type === "turn.tool-output.delta") {
-                    if (event.parentTurnId && event.relation) {
-                        const subagentId = childStreamSubagentId(event);
-                        ensureSubagentStarted(queue, pending, subagentId, relationScopeLabel(event.relation));
-                        pending.toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-                        queue.push({
-                            delta: event.delta,
-                            kind: "output",
-                            subagentId,
-                            subagentTurnId: event.turnId,
-                            toolCallId: event.callId,
-                            toolName: canonicalToolName(event.toolName),
-                            type: "tool.delta",
-                        });
-                        return;
-                    }
-                    pending.toolNamesByCallId.set(event.callId, canonicalToolName(event.toolName));
-                    queue.push({
-                        delta: event.delta,
-                        kind: "output",
-                        toolCallId: event.callId,
-                        toolName: canonicalToolName(event.toolName),
-                        type: "tool.delta",
-                    });
-                    return;
-                }
-                if (event.type === "child-task.started") {
-                    ensureSubagentStarted(queue, pending, childTaskSubagentId(event), event.record.objective);
-                    return;
-                }
-                if (event.type === "child-task.completed" || event.type === "child-task.joined") {
-                    const subagentId = childTaskSubagentId(event);
-                    ensureSubagentStarted(queue, pending, subagentId, event.record.objective);
-                    queue.push({ state: "completed", subagentId, type: "subagent.finished" });
-                    return;
-                }
-                if (event.type === "child-task.failed" || event.type === "child-task.rejected") {
-                    const subagentId = childTaskSubagentId(event);
-                    ensureSubagentStarted(queue, pending, subagentId, event.record.objective);
-                    queue.push({
-                        state: event.type === "child-task.failed" ? "failed" : "rejected",
-                        subagentId,
-                        type: "subagent.finished",
-                    });
-                    return;
-                }
-                if (event.type === "turn.item.added") {
-                    const item = event.item;
-                    if (item.kind === "reasoning") {
-                        logLlmDebug("bridge.reasoning.item.added", {
-                            content: item.content,
-                            draft: item.status === "draft",
-                            pendingStreamedReasoning: pending.streamedReasoning,
-                            summary: item.summary,
-                            threadId,
-                            turnId: pending.turnId,
-                        });
-                        if (!isDraftReasoningItem(item) &&
-                            hasVisibleReasoningText(item.content ?? item.summary))
-                            pending.sawVisibleReasoning = true;
-                        if (!pending.streamedReasoning && !isDraftReasoningItem(item))
-                            pending.reasoningSummaries.push(item.content ?? item.summary);
-                        return;
-                    }
-                    if (item.kind === "message" && item.role === "user") {
-                        if (consumePendingSteerPrompt(pending, item.text)) {
-                            queue.push({
-                                content: item.text,
-                                createdAtMs: parseIsoTimeMs(item.createdAt) ?? eventCreatedAtMs,
-                                type: "steer_injected",
-                            });
-                        }
-                        return;
-                    }
-                    if (item.kind === "message" && item.role === "agent") {
-                        queue.push({
-                            message: { content: item.text },
-                            originalEventType: "thread_item_message",
-                            type: "assistant.message",
-                        });
-                        return;
-                    }
-                    if (item.kind === "tool-call") {
-                        const toolCallId = resolveToolItemCallId(item);
-                        const toolName = canonicalToolName(item.toolName);
-                        pending.toolNamesByCallId.set(toolCallId, toolName);
-                        const input = parseToolInput(item.input);
-                        pending.toolInputsByCallId.set(toolCallId, input);
-                        queue.push({
-                            input,
-                            originalEventType: pending.startedToolCallIds.has(toolCallId)
-                                ? "tool_call_end"
-                                : "tool_call",
-                            startedAtMs: parseIsoTimeMs(item.createdAt) ?? eventCreatedAtMs,
-                            toolCallId,
-                            toolName,
-                            type: "tool.started",
-                        });
-                        pending.startedToolCallIds.delete(toolCallId);
-                        const pendingInput = pending.inputDeltasByCallId.get(toolCallId);
-                        if (pendingInput && !pending.streamedToolInputCallIds.has(toolCallId)) {
-                            for (const delta of pendingInput.deltas) {
-                                queue.push({
-                                    delta,
-                                    kind: "input",
-                                    toolCallId,
-                                    toolName,
-                                    type: "tool.delta",
-                                });
-                            }
-                        }
-                        pending.inputDeltasByCallId.delete(toolCallId);
-                        pending.streamedToolInputCallIds.delete(toolCallId);
-                        return;
-                    }
-                    if (item.kind === "tool-result") {
-                        const toolCallId = readExplicitToolCallId(item) ?? normalizeText(item.id);
-                        const toolName = canonicalToolName(item.toolName);
-                        pending.toolNamesByCallId.set(toolCallId, toolName);
-                        queue.push({
-                            ...(item.errorCode ? { errorCode: item.errorCode } : {}),
-                            ...(item.failureKind ? { failureKind: item.failureKind } : {}),
-                            isError: item.outcome === "error",
-                            output: {
-                                output: item.output,
-                                ...(item.structuredContent !== undefined
-                                    ? { structuredContent: item.structuredContent }
-                                    : {}),
-                            },
-                            toolCallId,
-                            toolName,
-                            type: "tool.finished",
-                        });
-                        return;
-                    }
-                    if (item.kind === "control" &&
-                        item.action === "child-thread-paused" &&
-                        item.childThreadId) {
-                        ensureSubagentStarted(queue, pending, item.childThreadId, pending.subagentDescriptionsById.get(item.childThreadId) ?? item.childThreadId);
-                        queue.push({
-                            ...(item.requestId ? { requestId: item.requestId } : {}),
-                            state: "paused",
-                            subagentId: item.childThreadId,
-                            type: "subagent.state",
-                        });
-                        return;
-                    }
-                    if (item.kind === "control" &&
-                        item.action === "child-thread-resumed" &&
-                        item.childThreadId) {
-                        ensureSubagentStarted(queue, pending, item.childThreadId, pending.subagentDescriptionsById.get(item.childThreadId) ?? item.childThreadId);
-                        queue.push({
-                            ...(item.requestId ? { requestId: item.requestId } : {}),
-                            state: "running",
-                            subagentId: item.childThreadId,
-                            type: "subagent.state",
-                        });
-                        return;
-                    }
-                    if (item.kind === "control" &&
-                        item.action === "child-thread-completed" &&
-                        item.childThreadId) {
-                        const subagentId = item.childThreadId;
-                        const compactSummary = normalizeText(item.summary) ||
-                            pending.subagentDescriptionsById.get(subagentId) ||
-                            subagentId;
-                        ensureSubagentStarted(queue, pending, subagentId, compactSummary);
-                        queue.push({
-                            subagentId,
-                            taskDescription: compactSummary,
-                            type: "subagent.started",
-                        });
-                        queue.push({ state: "completed", subagentId, type: "subagent.finished" });
-                        return;
-                    }
-                    if (item.kind === "error") {
-                        if (item.scope === "child-thread" && item.childThreadId) {
-                            pending.error = item;
-                            ensureSubagentStarted(queue, pending, item.childThreadId, pending.subagentDescriptionsById.get(item.childThreadId) ?? item.childThreadId);
-                            if (normalizeText(item.message)) {
-                                queue.push({
-                                    delta: item.message,
-                                    stream: "error",
-                                    subagentId: item.childThreadId,
-                                    subagentTurnId: event.turnId,
-                                    type: "subagent.output",
-                                });
-                            }
-                            queue.push({
-                                state: "failed",
-                                subagentId: item.childThreadId,
-                                type: "subagent.finished",
-                            });
-                            return;
-                        }
-                        pending.error = item;
-                    }
-                    return;
-                }
-                if (event.type === "child-thread.item.added") {
-                    const subagentId = childThreadSubagentId(event);
-                    ensureSubagentStarted(queue, pending, subagentId, pending.subagentDescriptionsById.get(subagentId) ?? childScopeLabel(event));
-                    if (event.item.kind === "tool-call") {
-                        const callId = resolveToolItemCallId(event.item);
-                        const toolName = canonicalToolName(event.item.toolName);
-                        const input = parseToolInput(event.item.input);
-                        pending.toolNamesByCallId.set(callId, toolName);
-                        pending.toolInputsByCallId.set(callId, input);
-                        queue.push({
-                            input,
-                            originalEventType: pending.streamedChildToolCallIds.has(callId)
-                                ? "tool_call_end"
-                                : "tool_call",
-                            startedAtMs: parseIsoTimeMs(event.item.createdAt) ?? eventCreatedAtMs,
-                            subagentId,
-                            subagentTurnId: event.childTurnId,
-                            toolCallId: callId,
-                            toolName,
-                            type: "tool.started",
-                        });
-                        queue.push({
-                            delta: buildChildThreadText(event) ?? formatSubagentToolActivityLabel(toolName, input),
-                            stream: "tool",
-                            subagentId,
-                            subagentTurnId: event.childTurnId,
-                            type: "subagent.output",
-                        });
-                        return;
-                    }
-                    if (event.item.kind === "message" && event.item.role === "agent") {
-                        const text = buildChildThreadText(event);
-                        if (text) {
-                            queue.push({
-                                delta: text,
-                                stream: "text",
-                                subagentId,
-                                subagentTurnId: event.childTurnId,
-                                type: "subagent.output",
-                            });
-                        }
-                        return;
-                    }
-                    if (event.item.kind === "tool-result") {
-                        const toolCallId = readExplicitToolCallId(event.item) ?? normalizeText(event.item.id);
-                        const toolName = canonicalToolName(event.item.toolName) ||
-                            pending.toolNamesByCallId.get(toolCallId) ||
-                            toolCallId;
-                        pending.toolNamesByCallId.set(toolCallId, toolName);
-                        queue.push({
-                            ...(event.item.errorCode ? { errorCode: event.item.errorCode } : {}),
-                            ...(event.item.failureKind ? { failureKind: event.item.failureKind } : {}),
-                            isError: event.item.outcome === "error",
-                            output: {
-                                output: event.item.output,
-                                ...(event.item.structuredContent !== undefined
-                                    ? { structuredContent: event.item.structuredContent }
-                                    : {}),
-                            },
-                            subagentId,
-                            subagentTurnId: event.childTurnId,
-                            toolCallId,
-                            toolName,
-                            type: "tool.finished",
-                        });
-                        if (event.item.outcome === "error") {
-                            queue.push({
-                                delta: `${toolName} error`,
-                                stream: "error",
-                                subagentId,
-                                subagentTurnId: event.childTurnId,
-                                type: "subagent.output",
-                            });
-                        }
-                        return;
-                    }
-                    if (event.item.kind === "error") {
-                        const text = buildChildThreadText(event);
-                        if (!text)
-                            return;
-                        queue.push({
-                            delta: text,
-                            stream: "error",
-                            subagentId,
-                            subagentTurnId: event.childTurnId,
-                            type: "subagent.output",
-                        });
-                    }
-                    return;
-                }
-                if (event.type === "approval.requested") {
-                    pending.approval = event.approval;
-                    pending.status = "paused";
-                    const childTool = pending.childToolInputsByCallId.get(event.approval.toolCallId);
-                    const toolCallId = normalizeText(event.approval.toolCallId);
-                    const toolName = pending.toolNamesByCallId.get(event.approval.toolCallId) ??
-                        childTool?.toolName ??
-                        canonicalToolName(event.approval.action);
-                    if (toolCallId && !pending.toolNamesByCallId.has(toolCallId)) {
-                        queue.push({
-                            input: pending.toolInputsByCallId.get(toolCallId) ?? {},
-                            originalEventType: "tool_call",
-                            ...(childTool?.subagentId ? { subagentId: childTool.subagentId } : {}),
-                            toolCallId,
-                            toolName,
-                            type: "tool.started",
-                        });
-                    }
-                    queue.push({
-                        actionId: event.approval.id,
-                        args: pending.toolInputsByCallId.get(event.approval.toolCallId),
-                        availableScopes: event.approval.availableScopes,
-                        kind: "tool_approval",
-                        permission: approvalPermission(toolName),
-                        reason: event.approval.reason,
-                        riskLevel: event.approval.riskClass ?? approvalRiskLevel(toolName),
-                        ...(childTool?.subagentId ? { subagentId: childTool.subagentId } : {}),
-                        toolCallId: event.approval.toolCallId,
-                        toolName,
-                        type: "action.required",
-                    });
-                    queue.close();
-                    return;
-                }
-                if (event.type === "action.required" && event.kind === "ask_user") {
-                    const toolCallId = normalizeText(event.toolCallId) || undefined;
-                    const toolName = canonicalToolName(event.toolName);
-                    if (toolCallId && !pending.toolNamesByCallId.has(toolCallId)) {
-                        pending.toolNamesByCallId.set(toolCallId, toolName);
-                        pending.toolInputsByCallId.set(toolCallId, {});
-                        queue.push({
-                            input: {},
-                            originalEventType: "tool_call",
-                            toolCallId,
-                            toolName,
-                            type: "tool.started",
-                        });
-                    }
-                    pending.action = {
-                        actionId: event.actionId,
-                        questions: event.questions,
-                        toolCallId,
-                        toolName,
-                    };
-                    pending.status = "paused";
-                    queue.push({
-                        actionId: event.actionId,
-                        kind: "ask_user",
-                        questions: event.questions,
-                        toolCallId,
-                        toolName,
-                        type: "action.required",
-                    });
-                    queue.close();
-                    return;
-                }
-                if (event.type === "thread.usage.updated") {
-                    pending.latestUsage = usageMetadataFromSessionUsage(event.inclusive);
-                    updatePendingReasoningTokens(pending, event.last);
-                    queue.push({
-                        lastRequestBudget: event.lastRequestBudget
-                            ? cloneJson(event.lastRequestBudget)
-                            : undefined,
-                        type: "usage.updated",
-                        usage: pending.latestUsage,
-                    });
-                    return;
-                }
-                if (event.type === "thread.compaction.started") {
-                    queue.push({
-                        state: "started",
-                        tokensBefore: event.estimatedTokensBefore,
-                        trigger: event.reason === "manual-user" ? "manual" : "auto",
-                        type: "context.compression",
-                    });
-                    return;
-                }
-                if (event.type === "thread.compacted") {
-                    const manualCompaction = event.reason === "manual-user";
-                    const maxInputTokens = Math.max(0, Math.floor(Number(event.diagnostics.compaction.lastBudgetTokens ?? 0)));
-                    queue.push({
-                        diagnostics: {
-                            autoCompactAttempt: {
-                                compactedMessageCount: event.summary.compactedMessageCount,
-                                estimatedInputTokens: event.estimatedTokensBefore,
-                                estimatedInputTokensAfter: event.estimatedTokensAfter,
-                                estimatedSavedTokens: event.estimatedTokensAfter !== undefined &&
-                                    event.estimatedTokensBefore !== undefined
-                                    ? Math.max(0, event.estimatedTokensBefore - event.estimatedTokensAfter)
-                                    : undefined,
-                                maxInputTokens,
-                                thresholdTokens: resolveAutoCompactionThresholdTokens(maxInputTokens),
-                                status: "compacted",
-                                trigger: manualCompaction ? "manual" : "threshold",
-                            },
-                        },
-                        state: "completed",
-                        tokensAfter: event.estimatedTokensAfter,
-                        tokensBefore: event.estimatedTokensBefore,
-                        trigger: manualCompaction ? "manual" : "auto",
-                        type: "context.compression",
-                    });
-                    return;
-                }
-                if (event.type === "turn.completed") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.interruptRequested = false;
-                    pending.status = "completed";
-                    const reasoningDiagnostics = resolvePendingReasoningDiagnostics(pending);
-                    void persistTurnReasoningDiagnostics(pending, reasoningDiagnostics);
-                    queue.push({
-                        reasoningDiagnostics,
-                        status: "completed",
-                        type: "run.finished",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                    return;
-                }
-                if (event.type === "turn.interrupted") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.interruptRequested = false;
-                    pending.status = "interrupted";
-                    const reasoningDiagnostics = resolvePendingReasoningDiagnostics(pending);
-                    void persistTurnReasoningDiagnostics(pending, reasoningDiagnostics);
-                    queue.push({
-                        reasoningDiagnostics,
-                        status: "interrupted",
-                        type: "run.finished",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                    return;
-                }
-                if (event.type === "turn.failed" || event.type === "turn.blocked") {
-                    pending.action = undefined;
-                    pending.approval = undefined;
-                    pending.interruptRequested = false;
-                    pending.status = "failed";
-                    const reasoningDiagnostics = resolvePendingReasoningDiagnostics(pending);
-                    void persistTurnReasoningDiagnostics(pending, reasoningDiagnostics);
-                    queue.push({
-                        error: pending.error ??
-                            new Error(event.type === "turn.blocked" ? "Turn blocked." : "Turn failed."),
-                        reasoningDiagnostics,
-                        type: "run.error",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                }
-            };
-            const unsubscribe = options.runtime.subscribe((envelope) => {
-                if (!catchUpComplete) {
-                    bufferedEnvelopes.push(envelope);
-                    return;
-                }
-                processEnvelope(envelope);
-            });
-            input.signal?.addEventListener("abort", onAbort);
-            if (input.attachAfterSequence != null && pending.turnId) {
-                const attach = options.runtime.markTurnAttached?.(threadId, pending.turnId);
-                void attach?.catch(() => { });
-            }
-            if (abortRequested) {
-                finish({ detach: true });
-            }
-            else if (input.attachAfterSequence != null) {
-                try {
-                    const response = await options.runtime.getThreadEvents({
-                        afterSequence: input.attachAfterSequence,
-                        threadId,
-                    });
-                    const envelopes = [...response.events, ...bufferedEnvelopes].sort((a, b) => a.sequence - b.sequence);
-                    const seen = new Set();
-                    for (const envelope of envelopes) {
-                        if (seen.has(envelope.sequence))
-                            continue;
-                        seen.add(envelope.sequence);
-                        processEnvelope(envelope);
-                    }
-                }
-                finally {
-                    catchUpComplete = true;
-                    bufferedEnvelopes.length = 0;
-                }
-            }
-            if (input.steerPrompt) {
-                if (!pending.turnId) {
-                    queue.push({
-                        error: new Error("Turn is not steerable yet."),
-                        reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                        type: "run.error",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                }
-                else {
-                    void options.runtime
-                        .steerTurn(threadId, pending.turnId, input.steerPrompt)
-                        .catch((error) => {
-                        pending.error = error;
-                        pending.status = "failed";
-                        queue.push({
-                            error,
-                            reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                            type: "run.error",
-                            usage: pending.latestUsage,
-                        });
-                        finish?.();
-                    });
-                }
-            }
-            if (pending.approval && typeof input.approved === "boolean") {
-                const approvalId = pending.approval.id;
-                const approvalScope = input.approved && input.alwaysAllowForConversation === true
-                    ? pending.approval.availableScopes.includes("thread")
-                        ? "thread"
-                        : pending.approval.availableScopes.includes("session")
-                            ? "session"
-                            : "once"
-                    : "once";
-                const approvalSequence = pending.lastDeliveredSequence ?? 0;
-                const reportApprovalResumeError = (error) => {
-                    if (isApprovalNotFoundError(error)) {
-                        pending.error = error;
-                        pending.resumeInFlight = false;
-                        pending.status = "failed";
-                        refreshAttachedStoreThread(threadId);
-                        finish?.();
-                        return;
-                    }
-                    pending.error = error;
-                    pending.status = "failed";
-                    queue.push({
-                        error,
-                        reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                        type: "run.error",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                };
-                pending.approval = undefined;
-                pending.status = "running";
-                void options.runtime
-                    .respondToApprovalWithScope(approvalId, input.approved ? "allow" : "reject", approvalScope)
-                    .then(() => {
-                    if (!input.approved)
-                        return;
-                    approvalResumeWatchdog = setTimeout(() => {
-                        if (settled || pending.status !== "running")
-                            return;
-                        if ((pending.lastDeliveredSequence ?? 0) > approvalSequence)
-                            return;
-                        void options.runtime
-                            .respondToApprovalWithScope(approvalId, "allow", approvalScope)
-                            .catch(reportApprovalResumeError);
-                    }, 750);
-                    approvalResumeWatchdog.unref?.();
-                })
-                    .catch(reportApprovalResumeError);
-            }
-            if (pending.action && input.rejected) {
-                pending.action = undefined;
-                pending.interruptRequested = true;
-                pending.status = "running";
-                if (!pending.turnId) {
-                    pending.interruptRequested = false;
-                    pending.error = new Error("Turn is not interruptible yet.");
-                    pending.status = "failed";
-                    queue.push({
-                        error: pending.error,
-                        reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                        type: "run.error",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                }
-                else {
-                    void options.runtime
-                        .interruptTurn(threadId, pending.turnId)
-                        .catch(async (error) => {
-                        if (isBenignAskUserCancelInterruptError(error)) {
-                            pending.interruptRequested = false;
-                            pending.status = "interrupted";
-                            const reasoningDiagnostics = resolvePendingReasoningDiagnostics(pending);
-                            void persistTurnReasoningDiagnostics(pending, reasoningDiagnostics);
-                            queue.push({
-                                reasoningDiagnostics,
-                                status: "interrupted",
-                                type: "run.finished",
-                                usage: pending.latestUsage,
-                            });
-                            finish?.();
-                            return;
-                        }
-                        pending.interruptRequested = false;
-                        pending.error = error;
-                        pending.status = "failed";
-                        queue.push({
-                            error,
-                            reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                            type: "run.error",
-                            usage: pending.latestUsage,
-                        });
-                        finish?.();
-                    });
-                }
-            }
-            if (pending.action && input.answers) {
-                const actionId = pending.action.actionId;
-                pending.action = undefined;
-                pending.resumeInFlight = true;
-                void options.runtime
-                    .respondToAction(actionId, input.answers)
-                    .catch((error) => {
-                    pending.error = error;
-                    pending.status = "failed";
-                    queue.push({
-                        error,
-                        reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                        type: "run.error",
-                        usage: pending.latestUsage,
-                    });
-                    finish?.();
-                })
-                    .finally(() => {
-                    pending.resumeInFlight = false;
-                });
-            }
-            void pending.promise.catch((error) => {
-                pending.error = error;
-                if (pending.status === "paused" ||
-                    pending.interruptRequested ||
-                    pending.status === "interrupted") {
-                    return;
-                }
-                pending.status = "failed";
-                clearBackgroundTracking(pending);
-                clearPendingTurnIfTerminal(pending);
-                if (settled)
-                    return;
-                queue.push({
-                    error,
-                    reasoningDiagnostics: resolvePendingReasoningDiagnostics(pending),
-                    type: "run.error",
-                    usage: pending.latestUsage,
-                });
-                finish?.();
-            });
-            for await (const message of queue)
-                yield message;
-            clearPendingTurnIfTerminal(pending);
-        };
-        const recoverPausedTurnForResume = async (input) => {
-            const resumed = await options.runtime.resumeThread(threadId);
-            if (input.kind === "ask_user") {
-                const action = resumed.pendingAction;
-                if (!action || action.actionId !== input.actionId)
-                    return null;
-                return createPendingTurnState({
-                    action: {
-                        actionId: action.actionId,
-                        questions: action.questions,
-                        ...(action.toolCallId ? { toolCallId: action.toolCallId } : {}),
-                        toolName: action.toolName,
-                    },
-                    status: "paused",
-                    turnId: action.turnId,
-                });
-            }
-            const approval = resumed.pendingApproval;
-            if (!approval || approval.id !== input.actionId)
-                return null;
-            return createPendingTurnState({
-                approval,
-                status: "paused",
-                turnId: approval.turnId,
-            });
-        };
-        return {
-            id: threadId,
-            async *run(input, runOptions) {
-                const threadState = getThreadState(threadId);
-                const metadata = input.metadata;
-                const attach = Boolean(metadata?.attach || metadata?.resume);
-                const steer = Boolean(metadata?.steer);
-                if (steer &&
-                    (threadState.pendingTurn?.status === "running" || threadState.pendingTurn?.resumeInFlight)) {
-                    const prompt = extractPromptText(input.content);
-                    if (!prompt) {
-                        yield { error: new Error("Missing steer prompt."), type: "run.error" };
-                        return;
-                    }
-                    yield* streamPendingTurn(threadState.pendingTurn, {
-                        signal: runOptions?.signal,
-                        steerPrompt: prompt,
-                    });
-                    return;
-                }
-                if (attach) {
-                    const pending = threadState.pendingTurn;
-                    if (!pending || (pending.status !== "running" && !pending.resumeInFlight)) {
-                        yield {
-                            error: new Error("Thread does not have a running turn to attach."),
-                            type: "run.error",
-                        };
-                        return;
-                    }
-                    yield* streamPendingTurn(pending, {
-                        attachAfterSequence: pending.lastDeliveredSequence,
-                        signal: runOptions?.signal,
-                    });
-                    return;
-                }
-                if (threadState.pendingTurn?.status === "running" ||
-                    threadState.pendingTurn?.resumeInFlight) {
-                    const stuckPending = threadState.pendingTurn;
-                    // If the running turn was detached after an abort (e.g. user pressed Ctrl+C after
-                    // submitting ask_user answers), wait for it to settle before blocking the new message.
-                    if (stuckPending.backgroundUnsubscribe && !stuckPending.resumeInFlight) {
-                        await waitForPendingTurnToSettle(threadId, stuckPending);
-                    }
-                    if (threadState.pendingTurn === stuckPending &&
-                        (stuckPending.status === "running" || stuckPending.resumeInFlight)) {
-                        yield { error: new Error("Thread already has a running turn."), type: "run.error" };
-                        return;
-                    }
-                    if (threadState.pendingTurn) {
-                        yield { error: new Error("Thread already has a running turn."), type: "run.error" };
-                        return;
-                    }
-                    // pendingTurn was cleared — fall through to start the new turn
-                }
-                const prompt = extractPromptText(input.content);
-                const promptContent = normalizePromptContentParts(input.content);
-                if (!prompt && !promptContent?.length) {
-                    yield { error: new Error("Missing user prompt."), type: "run.error" };
-                    return;
-                }
-                const promise = options.runtime.runTurn({
-                    agentProfile: options.agentProfile,
-                    prompt,
-                    ...(promptContent?.length ? { promptContent } : {}),
-                    threadId,
-                });
-                void promise.catch(() => { });
-                const pending = createPendingTurnState({
-                    promise,
-                    status: "running",
-                });
-                threadState.pendingTurn = pending;
-                yield* streamPendingTurn(pending, { signal: runOptions?.signal });
-            },
-            async *resume(input, resumeOptions) {
-                const threadState = getThreadState(threadId);
-                let pending = threadState.pendingTurn;
-                if (!pending || pending.status !== "paused") {
-                    const recovered = await recoverPausedTurnForResume(input).catch(() => null);
-                    if (!recovered) {
-                        yield { error: new Error("Session is not paused."), type: "run.error" };
-                        return;
-                    }
-                    pending = recovered;
-                    threadState.pendingTurn = recovered;
-                }
-                if (input.kind === "tool_approval") {
-                    yield* streamPendingTurn(pending, {
-                        alwaysAllowForConversation: input.alwaysAllowForConversation,
-                        approved: input.approved,
-                        reason: input.reason,
-                        signal: resumeOptions?.signal,
-                    });
-                    return;
-                }
-                yield* streamPendingTurn(pending, {
-                    answers: input.answers ?? {},
-                    rejected: input.rejected,
-                    signal: resumeOptions?.signal,
-                });
-            },
-            async setMode(modeId) {
-                await options.runtime.setThreadMode({
-                    mode: threadModeFromCliMode(modeId),
-                    threadId,
-                });
-            },
-            async steer(input) {
-                const pending = getThreadState(threadId).pendingTurn;
-                const prompt = normalizeText(input);
-                if (!pending?.turnId || pending.status !== "running" || !prompt)
-                    return false;
-                try {
-                    await options.runtime.steerTurn(threadId, pending.turnId, prompt);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            },
-            async triggerManualCompaction() {
-                try {
-                    const compacted = await options.runtime.compactThread({ threadId });
-                    const maxInputTokens = Math.max(0, Math.floor(Number(compacted.diagnostics.compaction.lastBudgetTokens ?? 0)));
-                    return {
-                        event: {
-                            diagnostics: {
-                                notification: {
-                                    maxInputTokens,
-                                    thresholdTokens: resolveAutoCompactionThresholdTokens(maxInputTokens),
-                                },
-                            },
-                            tokensAfter: compacted.diagnostics.compaction.lastEstimatedTokens,
-                        },
-                        messageCount: compacted.summary.compactedMessageCount,
-                        success: true,
-                    };
-                }
-                catch (error) {
-                    const errorCode = manualCompactionFailureCode(error);
-                    return {
-                        error: error instanceof Error ? error.message : String(error),
-                        ...(errorCode ? { errorCode } : {}),
-                        success: false,
-                    };
-                }
-            },
-            async updateConfig(input) {
-                const nextMode = normalizeText(input.modeId);
-                if (nextMode === "agent" || nextMode === "plan") {
-                    await options.runtime.setThreadMode({
-                        mode: threadModeFromCliMode(nextMode),
-                        threadId,
-                    });
-                }
-                const metadata = asRecord(input.metadata);
-                if (Object.keys(metadata).length > 0)
-                    await options.runtime.updateThreadMetadata(threadId, metadata);
-            },
-        };
-    };
-    const agentSessions = {
-        async create() {
-            return createSession((await options.runtime.startThread({ mode: threadModeFromCliMode(currentMode) })).thread.id);
-        },
-        async destroy(sessionId) {
-            await options.runtime.purgeThread(sessionId);
-        },
-        async get(sessionId) {
-            try {
-                return (await options.runtime.getThread({ threadId: sessionId })).thread;
-            }
-            catch {
-                return null;
-            }
-        },
-        async interrupt(sessionId) {
-            const pending = getThreadState(sessionId).pendingTurn;
-            if (!pending?.turnId)
-                return false;
-            await options.runtime.interruptTurn(sessionId, pending.turnId);
-            await waitForPendingTurnToSettle(sessionId, pending);
-            return true;
-        },
-        async list() {
-            const listed = await options.runtime.listThreads({ limit: 50 });
-            return await filterSessionThreads(options.runtime, listed.threads);
-        },
-        async rename(sessionId, title) {
-            await options.runtime.renameThread(sessionId, title);
-        },
-        async updateMetadata(sessionId, metadata) {
-            await options.runtime.updateThreadMetadata(sessionId, wrapSessionUiMetadata(metadata));
-        },
-    };
-    const agent = {
-        ensureSession: async (input) => {
-            const requestedSessionId = normalizeText(input?.sessionId);
-            if (requestedSessionId) {
-                try {
-                    const thread = await resumeBestAgentThread(options.runtime, requestedSessionId, threadModeFromCliMode(input?.modeId ?? currentMode));
-                    if (input?.metadata && typeof input.metadata === "object")
-                        await options.runtime.updateThreadMetadata(thread.id, input.metadata);
-                    return createSession(thread.id);
-                }
-                catch { }
-            }
-            const created = await options.runtime.startThread({
-                mode: threadModeFromCliMode(input?.modeId ?? currentMode),
-            });
-            if (input?.metadata && typeof input.metadata === "object")
-                await options.runtime.updateThreadMetadata(created.thread.id, input.metadata);
-            return createSession(created.thread.id);
-        },
-        getMode() {
-            return currentMode;
-        },
-        invalidateSession(sessionId) {
-            threadStates.delete(sessionId);
-            if (storeRef?.state.sessionId !== sessionId)
-                return;
-            storeRef.state.paused = null;
-            storeRef.state.runningAgentRound = false;
-            storeRef.state.runningToolCallId = null;
-        },
-        openSession: async (sessionId) => {
-            const normalizedSessionId = normalizeText(sessionId);
-            if (!normalizedSessionId)
-                return null;
-            try {
-                await options.runtime.getThread({ threadId: normalizedSessionId });
-                return createSession(normalizedSessionId);
-            }
-            catch {
-                return null;
-            }
-        },
-        sessions: agentSessions,
-        setMode(modeId) {
-            if (currentMode === modeId)
-                return;
-            currentMode = modeId;
-            const threadId = activeThreadId();
-            if (!threadId)
-                return;
-            void options.runtime
-                .setThreadMode({
-                mode: threadModeFromCliMode(modeId),
-                threadId,
-            })
-                .then(async ({ thread }) => {
-                if (!storeRef || storeRef.state.sessionId !== thread.id)
-                    return;
-                await switchAttachedStoreThread(thread, { mode: "fast" });
-            })
-                .catch(() => { });
-        },
-        async steerSession(sessionId, input) {
-            const pendingTurn = getThreadState(sessionId).pendingTurn;
-            const prompt = input.trim();
-            if (!pendingTurn?.turnId || pendingTurn.status !== "running" || prompt.length === 0)
-                return false;
-            try {
-                await options.runtime.steerTurn(sessionId, pendingTurn.turnId, prompt);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-        async triggerManualCompression(sessionId) {
-            const threadId = (normalizeText(sessionId) || activeThreadId());
-            if (!threadId) {
-                return {
-                    error: "No active session.",
-                    errorCode: "THREAD_NOT_FOUND",
-                    success: false,
-                };
-            }
-            return await createSession(threadId).triggerManualCompaction();
-        },
-    };
-    return {
-        agent,
-        attachStore(store) {
-            unsubscribeStoreRuntimeEvents?.();
-            storeRef = store;
-            currentMode = cliModeFromThreadMode(store.state.ui?.mode === "plan" ? "plan" : options.threadMode);
-            unsubscribeStoreRuntimeEvents = options.runtime.subscribe(({ event }) => {
-                if (event.type === "thread.usage.updated") {
-                    syncStoreUsageMetrics(storeRef, event);
-                    return;
-                }
-                if (event.type === "thread.compacted")
-                    syncStoreBudgetMetrics(storeRef, event);
-                if (event.type === "turn.completed" ||
-                    event.type === "turn.interrupted" ||
-                    event.type === "turn.failed" ||
-                    event.type === "turn.blocked") {
-                    const threadId = event.turn.threadId;
-                    if (storeRef?.state.sessionId !== threadId)
-                        return;
-                    const pending = getThreadState(threadId).pendingTurn;
-                    if (pending?.turnId === event.turn.id) {
-                        pending.action = undefined;
-                        pending.approval = undefined;
-                        pending.resumeInFlight = false;
-                        pending.status =
-                            event.type === "turn.completed"
-                                ? "completed"
-                                : event.type === "turn.interrupted"
-                                    ? "interrupted"
-                                    : "failed";
-                        getThreadState(threadId).pendingTurn = undefined;
-                    }
-                    if (!clearStorePendingApproval(storeRef))
-                        return;
-                    refreshAttachedStoreThread(threadId);
-                }
-            });
-        },
-        hydrateThread,
-        sessions,
-    };
-}
-export const createGoatChainBridge = createBestAgentNativeBridge;
-export const resolveInitialGoatChainThread = resolveInitialBestAgentThread;
-//# sourceMappingURL=best-agent-native-bridge.js.map