@bbigbang/agent-node 0.1.0

package/dist/claudeDirectRuntime.js

@@ -0,0 +1,1960 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { clearAcpSessionId, getLatestClaudeSessionUserMessage, getSession, insertClaudeSessionUserMessage, log, updateClaudeSessionControls, updateSessionRuntimeState, } from '@bbigbang/runtime-acp';
+import { buildInlineTextAttachmentPreview, formatAttachmentTextReference, promptAlreadyReferencesAttachment, resolveClaudeInlineImageAttachment, resolveLocalAttachmentPath, } from './attachmentInput.js';
+import { extractAttachmentIdFromUri, RuntimeAttachmentMaterializer, } from './attachmentMaterializer.js';
+import { buildClaudeSessionControlState, isClaudeSessionCommandName, isClaudeSessionModelId, isClaudeSessionModeId, normalizeClaudeSessionModeId, } from './claudeSessionControls.js';
+import { buildBigbangMessageSendRepairGuidance, getBigbangMessageSendInfo, } from './bigbangMessageSendDetection.js';
+import { buildDreamMemoryWriteRepairPrompt, buildDreamWatermarkRepairPrompt, } from '@bbigbang/memory';
+import { executeDreamMemoryConsolidationFallback, executeDreamWatermarkFallback, readDreamAuthTokenFromEnv, } from './dreamMemoryFallback.js';
+import { buildDreamAdditionalDisallowedTools, evaluateDreamToolPermission, isDreamMemoryWatermarkTool, isDreamMemoryWriteTool, } from './dreamToolPolicy.js';
+const CLAUDE_SETTING_SOURCES = ['user', 'project'];
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const CLAUDE_STEER_CONSUME_TIMEOUT_MS = 5 * 60_000;
+const CLAUDE_ASSET_FETCH_TIMEOUT_MS = 15_000;
+// If no event arrives within this window the model is considered hung; the stream is interrupted and the run is marked failed.
+const CLAUDE_STREAM_IDLE_TIMEOUT_MS = 10 * 60_000;
+const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'max']);
+const CLAUDE_ASSISTANT_TEXT_REPAIR_MAX_ATTEMPTS = 2;
+const DREAM_MEMORY_WRITE_REPAIR_MAX_ATTEMPTS = 4;
+const CLAUDE_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your previous turn emitted ordinary assistant text directly instead of sending it through the platform chat tool. '
+    + 'The user cannot see plain assistant text from that turn. Do not run tools, inspect files, revise prior work, or do more work. '
+    + 'Your only allowed user-visible action now is exactly one successful {toolName}(content="...", kind="final") call using the intended reply below. '
+    + 'If the captured text is incomplete, reconstruct only the complete intended user-visible reply from the current conversation context. '
+    + 'Do not emit ordinary assistant text again.';
+const CLAUDE_BIGBANG_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your previous turn emitted ordinary assistant text directly or failed to prove delivery through `bigbang message send`. '
+    + 'The user cannot see plain assistant text from that turn. Do not inspect files, revise prior work, or do more work. '
+    + 'Your only allowed user-visible action now is exactly one successful shell command using `bigbang message send --kind final`. '
+    + 'If captured text is provided below, send that intended reply; otherwise reconstruct only the complete intended user-visible reply from the current conversation context. '
+    + 'Do not emit ordinary assistant text again.';
+const CLAUDE_BIGBANG_PROGRESS_ALREADY_DELIVERED_FINAL_GUIDANCE = 'A visible progress message was already delivered successfully in this run. The final message is still required for completion proof, but it must be a concise completion marker and must not repeat the already posted progress content. Prefer a short final such as "已完成，详见上面的进度消息。".';
+// Tool kinds that may write to the workspace and therefore need the workspace
+// write lock before we let Claude SDK execute them.
+const CLAUDE_WORKSPACE_WRITE_TOOL_KINDS = new Set([
+    'edit',
+    'delete',
+    'move',
+    'execute',
+]);
+const CLAUDE_WORKSPACE_READ_TOOL_KINDS = new Set([
+    'read',
+    'search',
+]);
+const CLAUDE_DISALLOWED_TOOLS_BY_KIND = {
+    read: ['Read'],
+    edit: ['Edit', 'MultiEdit', 'Write', 'NotebookEdit'],
+    search: ['Grep', 'Glob', 'LS'],
+    execute: ['Bash', 'KillBash'],
+    think: ['Task', 'TodoWrite'],
+    fetch: ['WebFetch', 'WebSearch'],
+    switch_mode: ['ExitPlanMode'],
+};
+class ClaudeInputQueue {
+    messages = [];
+    waiters = [];
+    closed = false;
+    enqueue(message) {
+        return this.enqueueItem({ message });
+    }
+    enqueueAndWaitConsumed(message, timeoutMs = CLAUDE_STEER_CONSUME_TIMEOUT_MS) {
+        return new Promise((resolve) => {
+            const item = {
+                message,
+                onConsumed: resolve,
+            };
+            if (!this.enqueueItem(item)) {
+                this.settleItem(item, false);
+                return;
+            }
+            if (timeoutMs > 0 && !item.settled) {
+                item.timer = setTimeout(() => {
+                    this.removeItem(item);
+                    this.settleItem(item, false);
+                }, timeoutMs);
+            }
+        });
+    }
+    enqueueItem(item) {
+        if (this.closed)
+            return false;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value: item.message, done: false });
+            this.settleItem(item, true);
+            return true;
+        }
+        this.messages.push(item);
+        return true;
+    }
+    settleItem(item, consumed) {
+        if (item.settled)
+            return;
+        item.settled = true;
+        if (item.timer) {
+            clearTimeout(item.timer);
+            item.timer = undefined;
+        }
+        item.onConsumed?.(consumed);
+    }
+    removeItem(item) {
+        const index = this.messages.indexOf(item);
+        if (index >= 0) {
+            this.messages.splice(index, 1);
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        while (this.messages.length > 0) {
+            const item = this.messages.shift();
+            if (item)
+                this.settleItem(item, false);
+        }
+        while (this.waiters.length > 0) {
+            this.waiters.shift()?.({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                while (this.messages.length > 0) {
+                    const nextMessage = this.messages.shift();
+                    if (!nextMessage || nextMessage.settled)
+                        continue;
+                    this.settleItem(nextMessage, true);
+                    return { value: nextMessage.message, done: false };
+                }
+                if (this.closed)
+                    return { value: undefined, done: true };
+                return await new Promise((resolve) => {
+                    this.waiters.push(resolve);
+                });
+            },
+        };
+    }
+}
+export class ClaudeDirectRuntime {
+    db;
+    sessionKey;
+    bindingKey;
+    workspaceRoot;
+    env;
+    disabledToolKinds;
+    channelBridgeMcpEntry;
+    agentSurfaceMode;
+    toolAuth;
+    workspaceLockManager;
+    attachmentMaterializer;
+    queryImpl;
+    sessionId;
+    sessionSystemPromptText = null;
+    useAgentRuntimeConfig = false;
+    agentModelId = null;
+    agentReasoningEffort = null;
+    claudeModeId = 'default';
+    claudeModelId = null;
+    activeRunId = null;
+    activeQuery = null;
+    activeSink = null;
+    activeUiMode = 'summary';
+    activeClaudeModeId = null;
+    cancelRequested = false;
+    streamIdleTimedOut = false;
+    pendingToolCalls = new Map();
+    suppressedToolResultIds = new Set();
+    pendingPermission = null;
+    activeInputQueue = null;
+    activeSteerInputQueue = null;
+    deliveredFinalChatMessage = false;
+    deliveredProgressChatMessage = false;
+    receivedRuntimeOutput = false;
+    assistantTextRepairAttempts = 0;
+    assistantTextRepairSourceText = null;
+    currentTurnAssistantTextBuffer = '';
+    currentTurnAssistantTextRepairTriggered = false;
+    currentTurnBigbangMessageSendFailures = [];
+    lastBigbangMessageSendFailureForRepair = null;
+    planApprovalDenied = false;
+    activeTurnWorkspaceLease = null;
+    activeTurnWorkspaceLeasePromise = null;
+    workspaceLockAbortController = null;
+    activeDreamMode = false;
+    dreamMemoryWriteObserved = false;
+    dreamWatermarkObserved = false;
+    dreamTurnCompleted = false;
+    dreamMemoryRepairAttempts = 0;
+    activeDreamContextText = null;
+    dreamCachedAuthToken = null;
+    preservedChatSessionId = null;
+    preservedChatSystemPromptText = null;
+    constructor(params) {
+        this.db = params.db;
+        this.sessionKey = params.sessionKey;
+        this.bindingKey = params.bindingKey?.trim() || null;
+        this.workspaceRoot = params.workspaceRoot;
+        this.env = { ...(params.env ?? {}) };
+        this.useAgentRuntimeConfig = hasAgentRuntimeConfigInput(params);
+        this.agentModelId = normalizeOptionalString(params.model);
+        this.agentReasoningEffort = normalizeClaudeReasoningEffort(params.reasoningEffort);
+        this.disabledToolKinds = [...(params.disabledToolKinds ?? [])];
+        this.channelBridgeMcpEntry = params.channelBridgeMcpEntry;
+        this.agentSurfaceMode = params.agentSurfaceMode ?? 'mcp';
+        this.toolAuth = params.toolAuth ?? null;
+        this.workspaceLockManager = params.workspaceLockManager;
+        this.attachmentMaterializer = new RuntimeAttachmentMaterializer({
+            sessionKey: this.sessionKey,
+            runtimeLabel: 'claude-sdk',
+            assetAccessConfig: params.assetAccessConfig,
+            assetCacheRoot: params.assetCacheRoot,
+            fetchTimeoutMs: params.assetFetchTimeoutMs ?? CLAUDE_ASSET_FETCH_TIMEOUT_MS,
+            isCancelled: () => this.cancelRequested,
+            onMaterialized: params.onAssetMaterialized,
+        });
+        this.queryImpl = params.queryImpl ?? query;
+        const existingSession = getSession(this.db, this.sessionKey);
+        this.sessionId = existingSession?.acpSessionId?.trim() || null;
+        this.sessionSystemPromptText = existingSession?.systemPromptText?.trim() || null;
+        this.claudeModeId = normalizeClaudeSessionModeId(existingSession?.claudeModeId ?? null);
+        this.claudeModelId = isClaudeSessionModelId(existingSession?.claudeModelId ?? null)
+            ? existingSession?.claudeModelId ?? null
+            : null;
+    }
+    hasPendingPermission() {
+        return Boolean(this.pendingPermission);
+    }
+    updateConfig(config) {
+        this.useAgentRuntimeConfig = true;
+        this.agentModelId = normalizeOptionalString(config.model);
+        this.agentReasoningEffort = normalizeClaudeReasoningEffort(config.reasoningEffort);
+        this.disabledToolKinds = [...(config.disabledToolKinds ?? [])];
+        if (config.envVars) {
+            this.env = { ...config.envVars };
+        }
+    }
+    async respondToPermission(requestId, decision, selectedActionId, responseText, _answers) {
+        const pending = this.pendingPermission;
+        if (!pending || pending.requestId !== requestId)
+            return false;
+        if (pending.kind === 'plan') {
+            if (decision === 'deny' || selectedActionId === 'reject') {
+                this.planApprovalDenied = true;
+                pending.settleDeny('Plan rejected by user.', true);
+                return true;
+            }
+            if (selectedActionId === 'continue_planning') {
+                pending.settleDeny(buildClaudeContinuePlanningMessage(responseText), false);
+                this.sendPlanPhaseBestEffort('planning');
+                return true;
+            }
+            if (decision === 'allow' && selectedActionId === 'implement') {
+                pending.settleAllow();
+                this.sendPlanPhaseBestEffort('implementation');
+                return true;
+            }
+            pending.settleDeny('Plan approval requires an explicit implement, continue planning, or reject action.');
+            return true;
+        }
+        if (decision === 'allow') {
+            pending.settleAllow();
+        }
+        else {
+            pending.settleDeny('Denied by user.');
+        }
+        return true;
+    }
+    async cancelCurrentRun(runId) {
+        if (this.activeRunId !== runId) {
+            return false;
+        }
+        this.cancelRequested = true;
+        this.activeInputQueue?.close();
+        this.attachmentMaterializer.abort();
+        this.abortWorkspaceLockWait();
+        this.rejectPendingPermission('Permission request cancelled.');
+        if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+            await this.activeQuery.interrupt();
+        }
+        return true;
+    }
+    async steerCurrentRun(runId, promptText, attachments) {
+        if (this.activeRunId !== runId || this.cancelRequested)
+            return false;
+        if (this.deliveredFinalChatMessage)
+            return false;
+        const inputQueue = this.activeInputQueue ?? this.activeSteerInputQueue;
+        if (!inputQueue)
+            return false;
+        const materializedAttachments = attachments?.length
+            ? await this.materializeAssetAttachments(attachments, runId)
+            : [];
+        if (!promptText?.trim() && materializedAttachments.length === 0)
+            return false;
+        const consumed = await inputQueue.enqueueAndWaitConsumed({
+            ...this.toSdkUserMessage(promptText, materializedAttachments),
+            isSynthetic: true,
+            priority: 'now',
+        });
+        return consumed;
+    }
+    async getClaudeControls() {
+        return this.buildClaudeControls();
+    }
+    async setClaudeMode(modeId) {
+        if (!isClaudeSessionModeId(modeId)) {
+            throw new Error(`Unsupported Claude mode: ${modeId}`);
+        }
+        this.claudeModeId = modeId;
+        updateClaudeSessionControls(this.db, {
+            sessionKey: this.sessionKey,
+            claudeModeId: this.claudeModeId,
+            claudeModelId: this.claudeModelId,
+        });
+        return this.buildClaudeControls();
+    }
+    async setClaudeModel(modelId) {
+        const normalizedModelId = modelId?.trim() ? modelId.trim() : null;
+        if (normalizedModelId && !isClaudeSessionModelId(normalizedModelId)) {
+            throw new Error(`Unsupported Claude model: ${normalizedModelId}`);
+        }
+        this.claudeModelId = normalizedModelId;
+        updateClaudeSessionControls(this.db, {
+            sessionKey: this.sessionKey,
+            claudeModeId: this.claudeModeId,
+            claudeModelId: this.claudeModelId,
+        });
+        return this.buildClaudeControls();
+    }
+    async executeClaudeCommand(commandName, args) {
+        if (!isClaudeSessionCommandName(commandName)) {
+            throw new Error(`Unsupported Claude command: ${commandName}`);
+        }
+        switch (commandName) {
+            case 'rewind':
+                return this.executeRewindCommand(args);
+            default:
+                throw new Error(`Unsupported Claude command: ${commandName}`);
+        }
+    }
+    async close() {
+        this.cancelRequested = true;
+        this.activeInputQueue?.close();
+        this.attachmentMaterializer.abort();
+        this.abortWorkspaceLockWait();
+        this.rejectPendingPermission('Permission request cancelled.');
+        if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+            await this.activeQuery.interrupt().catch(() => { });
+        }
+        this.releaseActiveTurnWorkspaceLock();
+        this.activeQuery = null;
+        this.activeInputQueue = null;
+        this.activeSteerInputQueue = null;
+        this.activeRunId = null;
+        this.activeSink = null;
+        this.deliveredProgressChatMessage = false;
+        this.pendingToolCalls.clear();
+        this.suppressedToolResultIds.clear();
+    }
+    async prompt(params) {
+        if (this.activeRunId) {
+            throw new Error('Claude SDK runtime already has an active run.');
+        }
+        this.activeRunId = params.runId;
+        this.activeSink = params.sink;
+        this.activeUiMode = params.uiMode;
+        this.activeDreamMode = params.dreamMode === true;
+        if (this.activeDreamMode) {
+            this.preservedChatSessionId = this.sessionId;
+            this.preservedChatSystemPromptText = this.sessionSystemPromptText;
+            this.sessionId = null;
+            this.dreamMemoryWriteObserved = false;
+            this.dreamWatermarkObserved = false;
+            this.dreamTurnCompleted = false;
+            this.dreamMemoryRepairAttempts = 0;
+            this.activeDreamContextText = params.contextText?.trim() || null;
+            this.dreamCachedAuthToken = readDreamAuthTokenFromEnv(this.env);
+        }
+        this.cancelRequested = false;
+        this.streamIdleTimedOut = false;
+        this.deliveredFinalChatMessage = false;
+        this.deliveredProgressChatMessage = false;
+        this.receivedRuntimeOutput = false;
+        this.clearAssistantTextRepairState();
+        this.planApprovalDenied = false;
+        this.currentTurnBigbangMessageSendFailures = [];
+        this.activeClaudeModeId = params.runtimeOverrides?.planMode === true
+            ? 'plan'
+            : this.getEffectivePermissionMode();
+        this.pendingToolCalls.clear();
+        this.suppressedToolResultIds.clear();
+        const isFreshSession = !this.sessionId;
+        const effectiveContextText = isFreshSession
+            ? joinPromptContext(params.resumeContextText, params.recoveryContextText, params.contextText)
+            : joinPromptContext(params.contextText);
+        const effectiveSystemPromptText = params.systemPromptText?.trim() || undefined;
+        const promptAttachments = params.attachments ?? params.promptResources;
+        const materializedAttachments = promptAttachments?.length
+            ? await this.materializeAssetAttachments(promptAttachments, params.runId)
+            : [];
+        if (this.cancelRequested) {
+            const cancelledSessionId = this.sessionId ?? '';
+            this.activeRunId = null;
+            this.activeSink = null;
+            this.activeUiMode = 'summary';
+            this.activeClaudeModeId = null;
+            this.cancelRequested = false;
+            return {
+                stopReason: 'cancelled',
+                isFreshSession,
+                sessionId: cancelledSessionId,
+                effectiveSystemPromptText,
+                effectiveContextText: effectiveContextText || undefined,
+            };
+        }
+        const sdkMessage = this.toSdkUserMessage(joinPromptContext(effectiveContextText, params.promptText), materializedAttachments);
+        const inputQueue = new ClaudeInputQueue();
+        inputQueue.enqueue(sdkMessage);
+        let preparedSessionId = null;
+        let finalStopReason = 'completed';
+        let finalError = null;
+        const dreamModeRun = this.activeDreamMode;
+        const syncPreparedSession = async () => {
+            if (dreamModeRun)
+                return;
+            if (!this.sessionId || preparedSessionId === this.sessionId)
+                return;
+            preparedSessionId = this.sessionId;
+            this.sessionSystemPromptText = effectiveSystemPromptText ?? null;
+            updateSessionRuntimeState(this.db, {
+                sessionKey: this.sessionKey,
+                acpSessionId: this.sessionId,
+                systemPromptText: effectiveSystemPromptText ?? null,
+            });
+            await params.onPrepared?.({
+                sessionId: this.sessionId,
+                isFreshSession,
+                effectiveSystemPromptText,
+                effectiveContextText: effectiveContextText || undefined,
+            });
+        };
+        try {
+            let promptInput = inputQueue;
+            let promptInputQueue = inputQueue;
+            while (true) {
+                this.resetAssistantTextRepairTurnState();
+                this.currentTurnBigbangMessageSendFailures = [];
+                finalStopReason = 'completed';
+                finalError = null;
+                const activeQuery = this.queryImpl({
+                    prompt: promptInput,
+                    options: this.buildOptions(effectiveSystemPromptText, this.activeClaudeModeId, dreamModeRun),
+                });
+                this.activeQuery = activeQuery;
+                this.activeInputQueue = promptInputQueue;
+                this.activeSteerInputQueue = promptInputQueue;
+                let streamIdleTimer = null;
+                try {
+                    const armIdleTimer = () => {
+                        if (streamIdleTimer)
+                            clearTimeout(streamIdleTimer);
+                        streamIdleTimer = setTimeout(async () => {
+                            this.streamIdleTimedOut = true;
+                            if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+                                await this.activeQuery.interrupt().catch(() => { });
+                            }
+                        }, CLAUDE_STREAM_IDLE_TIMEOUT_MS);
+                    };
+                    armIdleTimer();
+                    for await (const message of activeQuery) {
+                        armIdleTimer();
+                        this.captureSessionId(message);
+                        await syncPreparedSession();
+                        await this.handleSdkMessage(message, params.sink);
+                        if (dreamModeRun && this.dreamMemoryWriteObserved && this.dreamWatermarkObserved) {
+                            this.dreamTurnCompleted = true;
+                            if (this.activeQuery && typeof this.activeQuery.interrupt === 'function') {
+                                await this.activeQuery.interrupt().catch(() => { });
+                            }
+                            finalStopReason = 'end_turn';
+                            break;
+                        }
+                        if (message.type === 'result') {
+                            if (this.cancelRequested) {
+                                finalStopReason = 'cancelled';
+                            }
+                            else if (message.subtype === 'success') {
+                                finalStopReason = 'completed';
+                            }
+                            else {
+                                finalStopReason = 'failed';
+                                finalError = readSdkResultError(message) ?? 'Claude SDK run failed';
+                                if (this.isBenignPostFinalMessageAbort(finalError)) {
+                                    finalStopReason = 'completed';
+                                    finalError = null;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    const errorMessage = String(error?.message ?? error);
+                    if (this.dreamTurnCompleted) {
+                        finalStopReason = 'end_turn';
+                        finalError = null;
+                    }
+                    else if (this.streamIdleTimedOut) {
+                        finalStopReason = 'failed';
+                        finalError = `Model stream idle for ${CLAUDE_STREAM_IDLE_TIMEOUT_MS / 60_000} minutes with no events — possible hang`;
+                    }
+                    else if (this.cancelRequested) {
+                        finalStopReason = 'cancelled';
+                    }
+                    else if (this.planApprovalDenied) {
+                        finalStopReason = 'approval_denied';
+                    }
+                    else if (this.currentTurnAssistantTextRepairTriggered && isAbortLikeError(error)) {
+                        finalStopReason = 'interrupted';
+                        finalError = null;
+                    }
+                    else if (isAbortLikeError(error) && this.isBenignPostFinalMessageAbort(errorMessage)) {
+                        finalStopReason = 'completed';
+                        finalError = null;
+                    }
+                    else if (isAbortLikeError(error)) {
+                        finalStopReason = 'cancelled';
+                    }
+                    else {
+                        finalStopReason = 'failed';
+                        finalError = errorMessage;
+                    }
+                }
+                finally {
+                    if (streamIdleTimer)
+                        clearTimeout(streamIdleTimer);
+                    this.streamIdleTimedOut = false;
+                    this.releaseActiveTurnWorkspaceLock();
+                    this.rejectPendingPermission('Permission request cancelled.');
+                    await this.flushPendingToolCalls(params.sink, finalStopReason === 'cancelled' ? 'cancelled' : 'failed', finalError);
+                    this.activeQuery = null;
+                    if (promptInputQueue) {
+                        promptInputQueue.close();
+                        if (this.activeInputQueue === promptInputQueue) {
+                            this.activeInputQueue = null;
+                        }
+                        if (this.activeSteerInputQueue === promptInputQueue) {
+                            this.activeSteerInputQueue = null;
+                        }
+                    }
+                    else {
+                        this.activeInputQueue = null;
+                        this.activeSteerInputQueue = null;
+                    }
+                }
+                const repairText = !dreamModeRun && !this.cancelRequested && !this.deliveredFinalChatMessage
+                    ? this.getPendingAssistantTextRepairSource()
+                    : null;
+                if (repairText) {
+                    finalError = null;
+                    if (!this.sessionId) {
+                        finalStopReason = 'failed';
+                        finalError = 'Claude SDK assistant text repair cannot continue without a session id.';
+                        break;
+                    }
+                    if (this.assistantTextRepairAttempts >= CLAUDE_ASSISTANT_TEXT_REPAIR_MAX_ATTEMPTS) {
+                        finalStopReason = 'failed';
+                        finalError = 'Claude SDK assistant text repair exceeded retry cap.';
+                        break;
+                    }
+                    this.assistantTextRepairAttempts += 1;
+                    const repairQueue = new ClaudeInputQueue();
+                    repairQueue.enqueue(this.toSdkUserMessage(this.buildAssistantTextRepairPrompt(repairText)));
+                    promptInput = repairQueue;
+                    promptInputQueue = repairQueue;
+                    continue;
+                }
+                const dreamNeedsRepair = dreamModeRun
+                    && !this.cancelRequested
+                    && !finalError
+                    && (!this.dreamMemoryWriteObserved || !this.dreamWatermarkObserved);
+                if (dreamNeedsRepair && this.dreamMemoryRepairAttempts < DREAM_MEMORY_WRITE_REPAIR_MAX_ATTEMPTS) {
+                    this.dreamMemoryRepairAttempts += 1;
+                    const repairQueue = new ClaudeInputQueue();
+                    const repairPrompt = !this.dreamMemoryWriteObserved
+                        ? buildDreamMemoryWriteRepairPrompt(this.activeDreamContextText ?? undefined)
+                        : buildDreamWatermarkRepairPrompt(this.activeDreamContextText ?? undefined);
+                    repairQueue.enqueue(this.toSdkUserMessage(repairPrompt));
+                    promptInput = repairQueue;
+                    promptInputQueue = repairQueue;
+                    continue;
+                }
+                break;
+            }
+        }
+        finally {
+            if (dreamModeRun && !this.cancelRequested && !finalError) {
+                if (this.dreamMemoryWriteObserved && !this.dreamWatermarkObserved) {
+                    const watermarkOk = await executeDreamWatermarkFallback({
+                        env: this.env,
+                        workspaceRoot: this.workspaceRoot,
+                        contextText: this.activeDreamContextText,
+                        sink: params.sink,
+                        authToken: this.dreamCachedAuthToken,
+                    });
+                    if (watermarkOk) {
+                        this.dreamWatermarkObserved = true;
+                    }
+                }
+                else if (!this.dreamMemoryWriteObserved) {
+                    const fallback = await executeDreamMemoryConsolidationFallback({
+                        env: this.env,
+                        workspaceRoot: this.workspaceRoot,
+                        contextText: this.activeDreamContextText,
+                        sink: params.sink,
+                        authToken: this.dreamCachedAuthToken,
+                    });
+                    if (fallback.wroteMemory) {
+                        this.dreamMemoryWriteObserved = true;
+                    }
+                    if (fallback.advancedWatermark) {
+                        this.dreamWatermarkObserved = true;
+                    }
+                }
+            }
+            this.activeRunId = null;
+            this.activeSink = null;
+            this.activeUiMode = 'summary';
+            if (dreamModeRun) {
+                this.sessionId = this.preservedChatSessionId;
+                this.sessionSystemPromptText = this.preservedChatSystemPromptText;
+            }
+            this.activeDreamMode = false;
+            this.dreamCachedAuthToken = null;
+            this.preservedChatSessionId = null;
+            this.preservedChatSystemPromptText = null;
+            this.activeClaudeModeId = null;
+            this.cancelRequested = false;
+            this.streamIdleTimedOut = false;
+        }
+        if (finalError && this.isBenignPostFinalMessageAbort(finalError)) {
+            finalStopReason = 'completed';
+            finalError = null;
+        }
+        if (this.planApprovalDenied) {
+            finalStopReason = 'approval_denied';
+            finalError = null;
+        }
+        if (dreamModeRun && !finalError && !this.deliveredFinalChatMessage) {
+            finalStopReason = 'end_turn';
+        }
+        if (finalError) {
+            this.deliveredFinalChatMessage = false;
+            this.deliveredProgressChatMessage = false;
+            this.receivedRuntimeOutput = false;
+            this.clearAssistantTextRepairState();
+            if (!dreamModeRun && isMissingResumeError(finalError)) {
+                this.sessionId = null;
+                clearAcpSessionId(this.db, this.sessionKey);
+            }
+            throw new Error(finalError);
+        }
+        if (dreamModeRun) {
+            this.deliveredFinalChatMessage = false;
+            this.deliveredProgressChatMessage = false;
+            this.receivedRuntimeOutput = false;
+            this.clearAssistantTextRepairState();
+            return {
+                stopReason: finalStopReason,
+                isFreshSession: !this.sessionId,
+                sessionId: this.sessionId ?? '',
+                effectiveSystemPromptText,
+                effectiveContextText: effectiveContextText || undefined,
+            };
+        }
+        if (!this.sessionId) {
+            this.deliveredFinalChatMessage = false;
+            this.deliveredProgressChatMessage = false;
+            this.receivedRuntimeOutput = false;
+            this.clearAssistantTextRepairState();
+            throw new Error('Claude SDK run completed without a session id.');
+        }
+        await syncPreparedSession();
+        if (finalStopReason === 'completed' && sdkMessage.uuid) {
+            insertClaudeSessionUserMessage(this.db, {
+                sessionKey: this.sessionKey,
+                runId: params.runId,
+                messageUuid: sdkMessage.uuid,
+            });
+        }
+        this.deliveredFinalChatMessage = false;
+        this.deliveredProgressChatMessage = false;
+        this.receivedRuntimeOutput = false;
+        this.clearAssistantTextRepairState();
+        return {
+            stopReason: finalStopReason,
+            isFreshSession,
+            sessionId: this.sessionId,
+            effectiveSystemPromptText,
+            effectiveContextText: effectiveContextText || undefined,
+        };
+    }
+    buildOptions(systemPromptText, modeId = this.claudeModeId, dreamMode = false) {
+        const effectiveSystemPromptText = systemPromptText?.trim() || this.sessionSystemPromptText || undefined;
+        const effectiveEnv = {
+            ...process.env,
+            ...this.env,
+        };
+        const effectiveModelId = this.resolveEffectiveModelId(effectiveEnv);
+        const effectiveDisabledToolKinds = dreamMode
+            ? this.disabledToolKinds.filter((kind) => kind !== 'execute')
+            : this.disabledToolKinds;
+        const disallowedTools = [
+            ...buildClaudeDisallowedTools(effectiveDisabledToolKinds),
+            ...(dreamMode ? buildDreamAdditionalDisallowedTools() : []),
+        ];
+        const base = {
+            cwd: this.workspaceRoot,
+            permissionMode: modeId,
+            ...(modeId === 'bypassPermissions' ? { allowDangerouslySkipPermissions: true } : {}),
+            canUseTool: this.handlePermissionRequest,
+            ...(disallowedTools.length > 0 ? { disallowedTools } : {}),
+            settingSources: [...CLAUDE_SETTING_SOURCES],
+            systemPrompt: effectiveSystemPromptText
+                ? { type: 'preset', preset: 'claude_code', append: effectiveSystemPromptText }
+                : { type: 'preset', preset: 'claude_code' },
+            env: {
+                ...effectiveEnv,
+                MCP_TIMEOUT: '600000',
+                MCP_TOOL_TIMEOUT: '600000',
+            },
+            enableFileCheckpointing: true,
+            ...(effectiveModelId ? { model: effectiveModelId } : {}),
+            ...(this.agentReasoningEffort ? { effort: this.agentReasoningEffort } : {}),
+            ...(this.sessionId && !dreamMode ? { resume: this.sessionId } : {}),
+        };
+        if (this.channelBridgeMcpEntry) {
+            const normalized = toClaudeSdkMcpConfig(this.channelBridgeMcpEntry);
+            if (normalized) {
+                base.mcpServers = {
+                    [this.channelBridgeMcpEntry.name]: normalized,
+                };
+            }
+        }
+        return base;
+    }
+    resolveEffectiveModelId(env) {
+        const envModel = normalizeOptionalString(env.ANTHROPIC_MODEL);
+        if (envModel)
+            return envModel;
+        if (normalizeOptionalString(env.ANTHROPIC_DEFAULT_OPUS_MODEL)
+            || normalizeOptionalString(env.ANTHROPIC_DEFAULT_SONNET_MODEL)
+            || normalizeOptionalString(env.ANTHROPIC_DEFAULT_HAIKU_MODEL)) {
+            return null;
+        }
+        if (this.useAgentRuntimeConfig) {
+            return this.agentModelId;
+        }
+        return this.agentModelId ?? this.claudeModelId;
+    }
+    resolveDisplayedEffectiveModelId(env) {
+        return normalizeOptionalString(env.ANTHROPIC_MODEL)
+            ?? normalizeOptionalString(env.ANTHROPIC_DEFAULT_OPUS_MODEL)
+            ?? normalizeOptionalString(env.ANTHROPIC_DEFAULT_SONNET_MODEL)
+            ?? normalizeOptionalString(env.ANTHROPIC_DEFAULT_HAIKU_MODEL)
+            ?? this.resolveEffectiveModelId(env);
+    }
+    getEffectivePermissionMode() {
+        return 'bypassPermissions';
+    }
+    handlePermissionRequest = async (toolName, input, options) => {
+        const toolKind = resolveClaudeToolKind(toolName);
+        const effectiveModeId = this.activeClaudeModeId ?? this.claudeModeId;
+        const isExitPlanRequest = isClaudePlanApprovalTool(toolName, toolKind);
+        const isPlanExitRequest = effectiveModeId === 'plan' && isExitPlanRequest;
+        const planText = isPlanExitRequest ? extractClaudePlanText(input) : null;
+        const isPlanApprovalRequest = isPlanExitRequest && Boolean(planText);
+        const permissionInput = isExitPlanRequest && !isPlanApprovalRequest
+            ? stripClaudeExitPlanAllowedPrompts(input)
+            : input;
+        if (isClaudePlatformChatTool(toolName, this.channelBridgeMcpEntry?.name)) {
+            if (this.activeDreamMode) {
+                return {
+                    behavior: 'deny',
+                    message: 'Dream mode cannot send chat messages.',
+                    toolUseID: options.toolUseID,
+                };
+            }
+            return {
+                behavior: 'allow',
+                updatedInput: permissionInput,
+                toolUseID: options.toolUseID,
+            };
+        }
+        if (this.activeDreamMode) {
+            const dreamDecision = evaluateDreamToolPermission({
+                toolName,
+                input: permissionInput,
+                toolKind,
+            });
+            if (dreamDecision === 'deny_blocked_memory') {
+                return {
+                    behavior: 'deny',
+                    message: 'Dream mode blocks unrelated memory MCP tools; use bigbang memory * shell commands.',
+                    toolUseID: options.toolUseID,
+                };
+            }
+            if (dreamDecision === 'deny_memory_read') {
+                return {
+                    behavior: 'deny',
+                    message: 'Dream mode blocks bigbang memory list/search; create or update draft nodes directly from the provided new messages.',
+                    toolUseID: options.toolUseID,
+                };
+            }
+            if (dreamDecision === 'allow') {
+                return {
+                    behavior: 'allow',
+                    updatedInput: permissionInput,
+                    toolUseID: options.toolUseID,
+                };
+            }
+            if (dreamDecision === 'deny_execute') {
+                return {
+                    behavior: 'deny',
+                    message: 'Dream mode only allows bigbang memory write shell commands via Bash.',
+                    toolUseID: options.toolUseID,
+                };
+            }
+            return {
+                behavior: 'deny',
+                message: 'Dream mode blocks exploration tools; use Bash with bigbang memory node create/update/edge create or dream-watermark.',
+                toolUseID: options.toolUseID,
+            };
+        }
+        if (toolKind && this.disabledToolKinds.includes(toolKind)) {
+            return {
+                behavior: 'deny',
+                message: `Tool kind disabled by platform policy: ${toolKind}`,
+                toolUseID: options.toolUseID,
+            };
+        }
+        const targetsWorkspace = Boolean(toolKind) && claudeToolTargetsWorkspace(toolKind, permissionInput, this.workspaceRoot);
+        const needsWorkspaceWriteLock = Boolean(toolKind) && CLAUDE_WORKSPACE_WRITE_TOOL_KINDS.has(toolKind) && targetsWorkspace;
+        const needsWorkspaceReadBarrier = Boolean(toolKind) && CLAUDE_WORKSPACE_READ_TOOL_KINDS.has(toolKind) && targetsWorkspace;
+        // Check ToolAuth persistent policy before interactive permission flow
+        if (this.toolAuth && this.bindingKey && toolKind) {
+            const context = buildClaudeToolMatchContext(toolName, permissionInput, toolKind, this.workspaceRoot);
+            const policy = this.toolAuth.evaluatePersistentPolicy(this.bindingKey, toolKind, context);
+            if (policy === 'allow') {
+                if (needsWorkspaceWriteLock) {
+                    try {
+                        await this.ensureActiveTurnWorkspaceWriteLock();
+                    }
+                    catch (error) {
+                        return {
+                            behavior: 'deny',
+                            message: `Workspace lock unavailable: ${String(error?.message ?? error)}`,
+                            interrupt: true,
+                            toolUseID: options.toolUseID,
+                        };
+                    }
+                }
+                else if (needsWorkspaceReadBarrier) {
+                    try {
+                        await this.waitForWorkspaceWritesBeforeRead();
+                    }
+                    catch (error) {
+                        return {
+                            behavior: 'deny',
+                            message: `Workspace lock unavailable: ${String(error?.message ?? error)}`,
+                            interrupt: true,
+                            toolUseID: options.toolUseID,
+                        };
+                    }
+                }
+                return {
+                    behavior: 'allow',
+                    updatedInput: permissionInput,
+                    toolUseID: options.toolUseID,
+                };
+            }
+            if (policy === 'reject') {
+                return {
+                    behavior: 'deny',
+                    message: `Tool rejected by persistent policy: ${toolKind}`,
+                    toolUseID: options.toolUseID,
+                };
+            }
+        }
+        const sink = this.activeSink;
+        const requestPermission = sink?.requestPermission;
+        if (!requestPermission) {
+            return {
+                behavior: 'deny',
+                message: 'Permission UI unavailable.',
+                toolUseID: options.toolUseID,
+            };
+        }
+        if (this.pendingPermission) {
+            return {
+                behavior: 'deny',
+                message: 'Another permission request is already pending.',
+                interrupt: true,
+                toolUseID: options.toolUseID,
+            };
+        }
+        const requestId = options.toolUseID || `perm-${randomUUID()}`;
+        const toolTitle = options.title || options.displayName || toolName;
+        return await new Promise((resolve) => {
+            let settled = false;
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.pendingPermission = null;
+                options.signal.removeEventListener('abort', onAbort);
+                resolve(result);
+            };
+            const onAbort = () => {
+                settle({
+                    behavior: 'deny',
+                    message: 'Permission request cancelled.',
+                    interrupt: true,
+                    toolUseID: options.toolUseID,
+                });
+            };
+            this.pendingPermission = {
+                requestId,
+                kind: isPlanApprovalRequest ? 'plan' : 'tool',
+                settleAllow: () => {
+                    if (!needsWorkspaceWriteLock && !needsWorkspaceReadBarrier) {
+                        settle({
+                            behavior: 'allow',
+                            updatedInput: permissionInput,
+                            toolUseID: options.toolUseID,
+                        });
+                        return;
+                    }
+                    const lockAction = needsWorkspaceWriteLock
+                        ? this.ensureActiveTurnWorkspaceWriteLock()
+                        : this.waitForWorkspaceWritesBeforeRead();
+                    lockAction.then(() => {
+                        settle({
+                            behavior: 'allow',
+                            updatedInput: permissionInput,
+                            toolUseID: options.toolUseID,
+                        });
+                    }).catch((error) => {
+                        settle({
+                            behavior: 'deny',
+                            message: `Workspace lock unavailable: ${String(error?.message ?? error)}`,
+                            interrupt: true,
+                            toolUseID: options.toolUseID,
+                        });
+                    });
+                },
+                settleDeny: (message, interrupt = false) => {
+                    settle({
+                        behavior: 'deny',
+                        message,
+                        interrupt,
+                        toolUseID: options.toolUseID,
+                    });
+                },
+            };
+            options.signal.addEventListener('abort', onAbort, { once: true });
+            void requestPermission({
+                uiMode: this.activeUiMode,
+                sessionKey: this.sessionKey,
+                requestId,
+                toolTitle: isPlanApprovalRequest ? 'Claude plan approval' : toolTitle,
+                toolKind,
+                toolName: isPlanApprovalRequest ? 'plan' : toolTitle,
+                toolArgs: isPlanApprovalRequest ? { plan: planText ?? '', rawInput: input } : buildPermissionArgs(permissionInput, options),
+                ...(isPlanApprovalRequest
+                    ? {
+                        approvalKind: 'plan',
+                        title: 'Plan',
+                        description: 'Review the proposed plan before implementation starts.',
+                        input: { plan: planText ?? '' },
+                        actions: buildPlanApprovalActions(),
+                    }
+                    : {}),
+            }).catch((error) => {
+                settle({
+                    behavior: 'deny',
+                    message: String(error?.message ?? error ?? 'Failed to deliver permission request.'),
+                    interrupt: true,
+                    toolUseID: options.toolUseID,
+                });
+            });
+        });
+    };
+    shouldEnforceToolReplyContract() {
+        if (this.activeDreamMode)
+            return false;
+        return this.agentSurfaceMode === 'bigbang'
+            || (this.agentSurfaceMode === 'mcp' && Boolean(this.channelBridgeMcpEntry));
+    }
+    getPlatformSendMessageToolName() {
+        const serverName = this.channelBridgeMcpEntry?.name?.trim() || 'chat';
+        return `mcp__${serverName}__send_message`;
+    }
+    buildCurrentTurnBigbangRepairGuidance() {
+        if (this.agentSurfaceMode !== 'bigbang')
+            return null;
+        const currentFailures = this.currentTurnBigbangMessageSendFailures;
+        const latestFinalFailure = [...currentFailures].reverse().find((failure) => failure.messageKind === 'final');
+        const selectedFailure = latestFinalFailure ?? currentFailures.at(-1) ?? this.lastBigbangMessageSendFailureForRepair;
+        if (!selectedFailure)
+            return null;
+        this.lastBigbangMessageSendFailureForRepair = selectedFailure;
+        return buildBigbangMessageSendRepairGuidance(selectedFailure.failureKind);
+    }
+    buildAssistantTextRepairPrompt(assistantText) {
+        if (this.agentSurfaceMode === 'bigbang') {
+            return [
+                CLAUDE_BIGBANG_ASSISTANT_TEXT_REPAIR_PROMPT,
+                this.deliveredProgressChatMessage ? CLAUDE_BIGBANG_PROGRESS_ALREADY_DELIVERED_FINAL_GUIDANCE : null,
+                this.buildCurrentTurnBigbangRepairGuidance(),
+                '',
+                'Previous plain assistant text:',
+                '',
+                assistantText,
+            ].filter((line) => typeof line === 'string').join('\n');
+        }
+        const toolName = this.getPlatformSendMessageToolName();
+        return [
+            CLAUDE_ASSISTANT_TEXT_REPAIR_PROMPT.replaceAll('{toolName}', toolName),
+            '',
+            'Previous plain assistant text:',
+            '',
+            assistantText,
+        ].join('\n');
+    }
+    resetAssistantTextRepairTurnState() {
+        this.currentTurnAssistantTextBuffer = '';
+        this.currentTurnAssistantTextRepairTriggered = false;
+    }
+    clearAssistantTextRepairState() {
+        this.assistantTextRepairAttempts = 0;
+        this.assistantTextRepairSourceText = null;
+        this.lastBigbangMessageSendFailureForRepair = null;
+        this.resetAssistantTextRepairTurnState();
+    }
+    getPendingAssistantTextRepairSource() {
+        if (this.currentTurnAssistantTextRepairTriggered) {
+            return normalizeOptionalString(this.currentTurnAssistantTextBuffer)
+                ?? normalizeOptionalString(this.assistantTextRepairSourceText);
+        }
+        if (this.agentSurfaceMode === 'bigbang' && this.currentTurnBigbangMessageSendFailures.length > 0) {
+            return '[No plain assistant text was captured; send the final user-visible result using the current conversation context.]';
+        }
+        if (this.agentSurfaceMode === 'bigbang'
+            && this.activeClaudeModeId !== 'plan'
+            && !this.deliveredFinalChatMessage) {
+            return '[No final user-visible reply was delivered; send the final result using the current conversation context.]';
+        }
+        return null;
+    }
+    async handleAssistantText(text, sink) {
+        if (this.activeDreamMode) {
+            return;
+        }
+        if (!this.shouldEnforceToolReplyContract()) {
+            this.receivedRuntimeOutput = true;
+            await sink.sendText(text);
+            return;
+        }
+        this.receivedRuntimeOutput = true;
+        await sink.sendActivityText?.(text);
+        if (this.deliveredFinalChatMessage) {
+            return;
+        }
+        if (text.trim().length === 0) {
+            return;
+        }
+        this.currentTurnAssistantTextBuffer += text;
+        this.assistantTextRepairSourceText = this.currentTurnAssistantTextBuffer;
+        if (!this.currentTurnAssistantTextRepairTriggered) {
+            this.currentTurnAssistantTextRepairTriggered = true;
+            this.activeInputQueue?.close();
+            await this.activeQuery?.interrupt().catch(() => { });
+        }
+    }
+    async handleSdkMessage(message, sink) {
+        if (message.type === 'assistant') {
+            const assistantMessage = message;
+            const blocks = Array.isArray(assistantMessage.message?.content) ? assistantMessage.message?.content : [];
+            let sawFinalChatToolUseInAssistantMessage = false;
+            for (const block of blocks) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const typed = block;
+                if (typed.type === 'text' && typeof typed.text === 'string' && typed.text.length > 0) {
+                    if (sawFinalChatToolUseInAssistantMessage) {
+                        this.receivedRuntimeOutput = true;
+                        await sink.sendActivityText?.(typed.text);
+                        if (typed.text.trim().length > 0) {
+                            this.currentTurnAssistantTextBuffer += typed.text;
+                            this.assistantTextRepairSourceText = this.currentTurnAssistantTextBuffer;
+                            this.currentTurnAssistantTextRepairTriggered = true;
+                        }
+                        continue;
+                    }
+                    await this.handleAssistantText(typed.text, sink);
+                    continue;
+                }
+                if ((typed.type === 'thinking' || typed.type === 'redacted_thinking') && typeof typed.thinking === 'string') {
+                    this.receivedRuntimeOutput = true;
+                    await sink.sendThinkingText?.(typed.thinking);
+                    continue;
+                }
+                if (typed.type === 'tool_use') {
+                    const name = typeof typed.name === 'string' ? typed.name : 'tool';
+                    const input = typed.input ?? null;
+                    const bigbangMessageSend = getClaudeBigbangMessageSendInfo(name, input);
+                    if (this.deliveredFinalChatMessage || sawFinalChatToolUseInAssistantMessage) {
+                        const toolCallId = typeof typed.id === 'string' ? typed.id : null;
+                        if (toolCallId) {
+                            this.suppressedToolResultIds.add(toolCallId);
+                        }
+                        this.receivedRuntimeOutput = true;
+                        await sink.sendActivityText?.(`Ignored post-final Claude tool use: ${name}`);
+                        continue;
+                    }
+                    this.receivedRuntimeOutput = true;
+                    const toolCallId = typeof typed.id === 'string' ? typed.id : `tool-${randomUUID()}`;
+                    if ((this.agentSurfaceMode === 'mcp' && name === this.getPlatformSendMessageToolName() && isFinalChatSendMessageInput(input))
+                        || (this.agentSurfaceMode === 'bigbang' && bigbangMessageSend?.kind === 'final')) {
+                        sawFinalChatToolUseInAssistantMessage = true;
+                    }
+                    this.pendingToolCalls.set(toolCallId, { name, input });
+                    await sink.sendUi?.({
+                        kind: 'tool',
+                        mode: 'summary',
+                        title: name,
+                        input,
+                        toolCallId,
+                        stage: 'start',
+                    });
+                }
+            }
+            return;
+        }
+        if (message.type === 'user') {
+            const userMessage = message;
+            const blocks = Array.isArray(userMessage.message?.content) ? userMessage.message?.content : [];
+            for (const block of blocks) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const typed = block;
+                if (typed.type !== 'tool_result')
+                    continue;
+                const toolCallId = typeof typed.tool_use_id === 'string' ? typed.tool_use_id : null;
+                if (!toolCallId)
+                    continue;
+                if (this.suppressedToolResultIds.has(toolCallId)) {
+                    this.suppressedToolResultIds.delete(toolCallId);
+                    this.receivedRuntimeOutput = true;
+                    await sink.sendActivityText?.(`Ignored post-final Claude tool result: ${toolCallId}`);
+                    continue;
+                }
+                const existing = this.pendingToolCalls.get(toolCallId);
+                if (this.deliveredFinalChatMessage) {
+                    this.receivedRuntimeOutput = true;
+                    await sink.sendActivityText?.(`Ignored post-final Claude tool result: ${toolCallId}`);
+                    continue;
+                }
+                const title = existing?.name ?? 'tool';
+                const output = extractToolResultText(typed.content);
+                const status = typed.is_error === true ? 'failed' : 'completed';
+                this.receivedRuntimeOutput = true;
+                if (this.activeDreamMode && status === 'completed') {
+                    if (isDreamMemoryWriteTool(title, existing?.input)) {
+                        this.dreamMemoryWriteObserved = true;
+                    }
+                    if (isDreamMemoryWatermarkTool(title, existing?.input)) {
+                        this.dreamWatermarkObserved = true;
+                    }
+                }
+                const bigbangMessageSend = existing
+                    ? getClaudeBigbangMessageSendInfo(existing.name, existing.input, output, {
+                        status,
+                        success: status === 'completed',
+                    })
+                    : null;
+                if (this.agentSurfaceMode === 'bigbang') {
+                    if (bigbangMessageSend?.success === true) {
+                        this.lastBigbangMessageSendFailureForRepair = null;
+                        if (bigbangMessageSend.kind === 'progress') {
+                            this.deliveredProgressChatMessage = true;
+                        }
+                    }
+                    else if (bigbangMessageSend?.failureKind) {
+                        this.currentTurnBigbangMessageSendFailures.push({
+                            messageKind: bigbangMessageSend.kind,
+                            failureKind: bigbangMessageSend.failureKind,
+                        });
+                    }
+                }
+                const nonPostedResult = isNonPostedSendMessageResult(typed.content)
+                    || isNonPostedSendMessageResult(output);
+                const deliveredFinalReply = status === 'completed'
+                    && !nonPostedResult
+                    && ((this.agentSurfaceMode === 'mcp'
+                        && title === this.getPlatformSendMessageToolName()
+                        && isFinalChatSendMessageInput(existing?.input))
+                        || (this.agentSurfaceMode === 'bigbang'
+                            && bigbangMessageSend?.success === true
+                            && bigbangMessageSend.kind === 'final'));
+                if (deliveredFinalReply) {
+                    this.deliveredFinalChatMessage = true;
+                }
+                await sink.sendUi?.({
+                    kind: 'tool',
+                    mode: 'summary',
+                    title,
+                    output,
+                    toolCallId,
+                    stage: 'complete',
+                    status,
+                });
+                this.pendingToolCalls.delete(toolCallId);
+                if (deliveredFinalReply) {
+                    this.pendingToolCalls.clear();
+                    this.activeInputQueue?.close();
+                    await this.activeQuery?.interrupt().catch(() => { });
+                }
+            }
+            return;
+        }
+        if (message.type === 'system') {
+            const typed = message;
+            switch (typed.subtype) {
+                case 'status': {
+                    const detail = describeClaudeStatus(typed);
+                    if (detail) {
+                        await sink.sendUi?.({
+                            kind: 'plan',
+                            mode: 'summary',
+                            title: 'Claude status',
+                            detail,
+                            silent: true,
+                        });
+                    }
+                    return;
+                }
+                case 'notification': {
+                    if (typeof typed.text === 'string' && typed.text.trim()) {
+                        await sink.sendUi?.({
+                            kind: 'plan',
+                            mode: 'summary',
+                            title: 'Notification',
+                            detail: typed.text,
+                            silent: true,
+                        });
+                    }
+                    return;
+                }
+                case 'task_started': {
+                    await sink.sendUi?.({
+                        kind: 'task',
+                        mode: 'summary',
+                        title: 'Task started',
+                        detail: typeof typed.description === 'string' ? typed.description : undefined,
+                        silent: true,
+                    });
+                    return;
+                }
+                case 'task_progress': {
+                    const detail = typeof typed.description === 'string'
+                        ? typed.description
+                        : typeof typed.summary === 'string'
+                            ? typed.summary
+                            : undefined;
+                    await sink.sendUi?.({
+                        kind: 'task',
+                        mode: 'summary',
+                        title: 'Task progress',
+                        detail,
+                        silent: true,
+                    });
+                    return;
+                }
+                case 'task_updated': {
+                    const detail = formatClaudeTaskPatch(typed.patch);
+                    await sink.sendUi?.({
+                        kind: 'task',
+                        mode: 'summary',
+                        title: 'Task updated',
+                        detail,
+                        silent: true,
+                    });
+                    return;
+                }
+                case 'task_notification': {
+                    await sink.sendUi?.({
+                        kind: 'task',
+                        mode: 'summary',
+                        title: `Task ${String(typed.status ?? 'updated')}`,
+                        detail: typeof typed.summary === 'string' ? typed.summary : undefined,
+                        silent: true,
+                    });
+                    return;
+                }
+                default:
+                    return;
+            }
+        }
+        if (message.type === 'tool_progress') {
+            const typed = message;
+            const toolName = typeof typed.tool_name === 'string' ? typed.tool_name : 'tool';
+            const elapsed = typeof typed.elapsed_time_seconds === 'number'
+                ? `${typed.elapsed_time_seconds.toFixed(1)}s elapsed`
+                : undefined;
+            await sink.sendUi?.({
+                kind: 'task',
+                mode: 'summary',
+                title: `${toolName} running`,
+                detail: elapsed,
+                silent: true,
+            });
+        }
+    }
+    isBenignPostFinalMessageAbort(message) {
+        return this.deliveredFinalChatMessage
+            && (isClaudeSdkPostFinalMessageAbort(message) || isAbortLikeError(message));
+    }
+    rejectPendingPermission(message) {
+        const pending = this.pendingPermission;
+        if (!pending)
+            return;
+        pending.settleDeny(message, true);
+    }
+    sendPlanPhaseBestEffort(phase) {
+        const sink = this.activeSink;
+        if (!sink?.sendUi)
+            return;
+        try {
+            void sink.sendUi({
+                kind: 'plan_phase',
+                mode: this.activeUiMode,
+                phase,
+            }).catch((error) => {
+                log.warn('[claude-sdk] failed to send plan phase event', {
+                    phase,
+                    error: String(error?.message ?? error),
+                });
+            });
+        }
+        catch (error) {
+            log.warn('[claude-sdk] failed to send plan phase event', {
+                phase,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    /** Acquire the workspace write lock the first time this turn requests a write
+     *  tool. Subsequent writes within the same turn reuse the same lease. The
+     *  lease is released in the prompt() finally block. Mirrors the Codex App
+     *  Server pattern.
+     */
+    async ensureActiveTurnWorkspaceWriteLock() {
+        if (!this.workspaceLockManager)
+            return;
+        if (this.activeTurnWorkspaceLease)
+            return;
+        if (this.activeTurnWorkspaceLeasePromise) {
+            await this.activeTurnWorkspaceLeasePromise;
+            return;
+        }
+        const abortController = new AbortController();
+        this.workspaceLockAbortController = abortController;
+        const acquirePromise = (async () => {
+            const lease = await this.workspaceLockManager.acquire(this.workspaceRoot, {
+                signal: abortController.signal,
+            });
+            this.activeTurnWorkspaceLease = lease;
+        })();
+        this.activeTurnWorkspaceLeasePromise = acquirePromise;
+        try {
+            await acquirePromise;
+        }
+        finally {
+            if (this.workspaceLockAbortController === abortController) {
+                this.workspaceLockAbortController = null;
+            }
+            if (this.activeTurnWorkspaceLeasePromise === acquirePromise) {
+                this.activeTurnWorkspaceLeasePromise = null;
+            }
+        }
+    }
+    async waitForWorkspaceWritesBeforeRead() {
+        if (!this.workspaceLockManager)
+            return;
+        await this.ensureActiveTurnWorkspaceWriteLock();
+    }
+    abortWorkspaceLockWait() {
+        const controller = this.workspaceLockAbortController;
+        if (!controller)
+            return;
+        this.workspaceLockAbortController = null;
+        controller.abort();
+    }
+    releaseActiveTurnWorkspaceLock() {
+        this.activeTurnWorkspaceLeasePromise = null;
+        const lease = this.activeTurnWorkspaceLease;
+        if (!lease)
+            return;
+        this.activeTurnWorkspaceLease = null;
+        try {
+            lease.release();
+        }
+        catch (error) {
+            log.warn('[claude-direct] failed to release workspace lock', {
+                sessionKey: this.sessionKey,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    async flushPendingToolCalls(sink, status, output) {
+        if (this.pendingToolCalls.size === 0)
+            return;
+        for (const [toolCallId, entry] of this.pendingToolCalls.entries()) {
+            await sink.sendUi?.({
+                kind: 'tool',
+                mode: 'summary',
+                title: entry.name,
+                output: output ?? (status === 'cancelled' ? 'Cancelled' : 'Failed'),
+                toolCallId,
+                stage: 'complete',
+                status,
+            });
+        }
+        this.pendingToolCalls.clear();
+    }
+    captureSessionId(message) {
+        const candidate = readSessionId(message);
+        if (candidate) {
+            this.sessionId = candidate;
+        }
+    }
+    buildClaudeControls() {
+        const effectiveEnv = {
+            ...process.env,
+            ...this.env,
+        };
+        return buildClaudeSessionControlState({
+            sessionId: this.sessionId,
+            modeId: this.claudeModeId,
+            modelId: this.claudeModelId,
+            effectiveModelId: this.resolveDisplayedEffectiveModelId(effectiveEnv),
+        });
+    }
+    async executeRewindCommand(args) {
+        if (!this.sessionId) {
+            throw new Error('Claude rewind is only available after the conversation has started.');
+        }
+        const requestedUuid = args?.trim() ?? '';
+        const targetUserMessageUuid = requestedUuid
+            ? validateClaudeUserMessageUuid(requestedUuid)
+            : this.resolveLatestRewindCandidate();
+        const controlQuery = this.queryImpl({
+            prompt: emptyPromptIterable(),
+            options: this.buildOptions(),
+        });
+        try {
+            const result = await controlQuery.rewindFiles(targetUserMessageUuid, { dryRun: false });
+            if (!result.canRewind) {
+                throw new Error(result.error?.trim() || 'Claude could not rewind files for that message.');
+            }
+            const fileCount = result.filesChanged?.length ?? 0;
+            const summaryParts = [
+                `Rewound tracked files to ${targetUserMessageUuid}.`,
+                fileCount > 0 ? `${fileCount} file${fileCount === 1 ? '' : 's'} changed.` : 'No file changes were needed.',
+            ];
+            if ((result.insertions ?? 0) > 0 || (result.deletions ?? 0) > 0) {
+                summaryParts.push(`Diff summary: +${result.insertions ?? 0} / -${result.deletions ?? 0}.`);
+            }
+            return {
+                commandName: 'rewind',
+                ok: true,
+                targetUserMessageUuid,
+                canRewind: true,
+                filesChanged: result.filesChanged,
+                insertions: result.insertions,
+                deletions: result.deletions,
+                summary: summaryParts.join(' '),
+            };
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            if (isMissingResumeError(message)) {
+                this.sessionId = null;
+                clearAcpSessionId(this.db, this.sessionKey);
+            }
+            throw new Error(message);
+        }
+        finally {
+            controlQuery.close();
+        }
+    }
+    resolveLatestRewindCandidate() {
+        const latest = getLatestClaudeSessionUserMessage(this.db, this.sessionKey);
+        if (!latest?.messageUuid) {
+            throw new Error('No rewind checkpoint is available for this Claude SDK session yet.');
+        }
+        return latest.messageUuid;
+    }
+    async materializeAssetAttachments(attachments, runId) {
+        return this.attachmentMaterializer.materialize(attachments, { runId });
+    }
+    toSdkUserMessage(promptText, attachments) {
+        return {
+            type: 'user',
+            message: {
+                role: 'user',
+                content: buildClaudeUserContent(promptText, attachments),
+            },
+            parent_tool_use_id: null,
+            uuid: randomUUID(),
+            session_id: this.sessionId ?? '',
+        };
+    }
+}
+function joinPromptContext(...parts) {
+    return parts
+        .map((value) => value?.trim() ?? '')
+        .filter(Boolean)
+        .join('\n\n');
+}
+function emptyPromptIterable() {
+    return {
+        async *[Symbol.asyncIterator]() {
+            return;
+        },
+    };
+}
+function buildClaudeUserContent(promptText, attachments) {
+    const blocks = [];
+    const trimmedPrompt = promptText.trim();
+    if (trimmedPrompt) {
+        blocks.push({ type: 'text', text: trimmedPrompt });
+    }
+    for (const [index, attachment] of (attachments ?? []).entries()) {
+        const inlineImage = resolveClaudeInlineImageAttachment(attachment);
+        if (inlineImage) {
+            blocks.push({
+                type: 'text',
+                text: formatClaudeImageAttachmentIntro(attachment, index, inlineImage.path, inlineImage.mediaType),
+            });
+            try {
+                blocks.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: inlineImage.mediaType,
+                        data: fs.readFileSync(inlineImage.path).toString('base64'),
+                    },
+                });
+            }
+            catch {
+                blocks.push({
+                    type: 'text',
+                    text: formatAttachmentTextReference(attachment, index, inlineImage.path, normalizeOptionalString(attachment.assetId)),
+                });
+            }
+            continue;
+        }
+        const localPath = normalizeOptionalString(attachment.preferredLocalPath) ?? resolveLocalAttachmentPath(attachment);
+        const attachmentId = normalizeOptionalString(attachment.assetId) ?? extractAttachmentIdFromUri(attachment.uri);
+        if (!localPath && attachmentId && promptAlreadyReferencesAttachment(trimmedPrompt, attachmentId)) {
+            continue;
+        }
+        const preview = localPath ? safelyBuildInlineTextAttachmentPreview(attachment, localPath, index) : null;
+        blocks.push({
+            type: 'text',
+            text: preview ?? formatAttachmentTextReference(attachment, index, localPath, attachmentId),
+        });
+    }
+    if (blocks.length === 0) {
+        blocks.push({ type: 'text', text: '' });
+    }
+    return blocks;
+}
+function formatClaudeImageAttachmentIntro(attachment, index, localPath, mediaType) {
+    const filename = normalizeOptionalString(attachment.filename);
+    return `Attachment ${index + 1}${filename ? ` (${filename})` : ''}: local_path="${localPath}" (${mediaType}). Inline image follows.`;
+}
+function safelyBuildInlineTextAttachmentPreview(attachment, localPath, index) {
+    try {
+        return buildInlineTextAttachmentPreview(attachment, localPath, index);
+    }
+    catch {
+        return null;
+    }
+}
+function toClaudeSdkMcpConfig(entry) {
+    if ('command' in entry) {
+        return {
+            type: 'stdio',
+            command: entry.command,
+            args: [...entry.args],
+            env: Object.fromEntries((entry.env ?? []).map((item) => [item.name, item.value])),
+        };
+    }
+    if (entry.type === 'http' || entry.type === 'sse') {
+        return {
+            type: entry.type,
+            url: entry.url,
+            headers: Object.fromEntries((entry.headers ?? []).map((item) => [item.name, item.value])),
+        };
+    }
+    return null;
+}
+function readSessionId(message) {
+    const candidate = message;
+    const raw = typeof candidate.session_id === 'string'
+        ? candidate.session_id
+        : typeof candidate.sessionId === 'string'
+            ? candidate.sessionId
+            : typeof candidate.session?.id === 'string'
+                ? candidate.session.id
+                : '';
+    const sessionId = raw.trim();
+    return sessionId || null;
+}
+function readSdkResultError(message) {
+    const typed = message;
+    if (Array.isArray(typed.errors) && typed.errors.length > 0) {
+        const combined = typed.errors.filter((value) => typeof value === 'string').join('\n').trim();
+        if (combined)
+            return combined;
+    }
+    const result = message.result;
+    return typeof result === 'string' && result.trim() ? result.trim() : null;
+}
+function validateClaudeUserMessageUuid(value) {
+    if (!UUID_PATTERN.test(value)) {
+        throw new Error('Claude rewind expects a valid user message UUID.');
+    }
+    return value;
+}
+function isAbortLikeError(error) {
+    const message = String(error?.message ?? error ?? '');
+    return /\babort(ed)?\b/i.test(message) || /\binterrupt(ed)?\b/i.test(message);
+}
+function isMissingResumeError(message) {
+    return /No conversation found with session ID:/i.test(message);
+}
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim() ?? '';
+    return trimmed ? trimmed : null;
+}
+function hasAgentRuntimeConfigInput(params) {
+    return Object.prototype.hasOwnProperty.call(params, 'model')
+        || Object.prototype.hasOwnProperty.call(params, 'reasoningEffort')
+        || Object.prototype.hasOwnProperty.call(params, 'claudePermissionMode');
+}
+function normalizeClaudeReasoningEffort(value) {
+    const trimmed = value?.trim() ?? '';
+    return CLAUDE_REASONING_EFFORTS.has(trimmed) ? trimmed : null;
+}
+function isClaudeSdkPostFinalMessageAbort(message) {
+    return message.includes('[ede_diagnostic]') && /Request was aborted/i.test(message);
+}
+function isFinalChatSendMessageInput(input) {
+    if (!input || typeof input !== 'object')
+        return false;
+    const kind = input.kind;
+    return typeof kind === 'string' && kind.trim() === 'final';
+}
+function getClaudeBigbangMessageSendInfo(toolName, input, outputText, result) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const command = normalizeOptionalString(input.command);
+    if (!command)
+        return null;
+    const normalizedToolName = toolName.trim().toLowerCase();
+    if (normalizedToolName !== 'bash' && normalizedToolName !== 'shell')
+        return null;
+    return getBigbangMessageSendInfo({
+        type: 'commandExecution',
+        command,
+        status: result?.status,
+        success: result?.success,
+        aggregatedOutput: outputText ?? null,
+    });
+}
+function isHeldStaleSendMessageResult(value) {
+    if (isHeldStaleResultShape(value))
+        return true;
+    const text = typeof value === 'string' ? value : JSON.stringify(value ?? '');
+    return text.includes('Draft held; nothing was posted')
+        || text.includes('Your draft was not sent because newer messages exist on this surface');
+}
+function isNonPostedSendMessageResult(value) {
+    if (isHeldStaleSendMessageResult(value))
+        return true;
+    const text = typeof value === 'string' ? value : JSON.stringify(value ?? '');
+    return text.includes('Nothing was confirmed posted')
+        || text.includes('success without a messageId');
+}
+function isHeldStaleResultShape(value, depth = 0) {
+    if (depth > 4 || value == null)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((item) => isHeldStaleResultShape(item, depth + 1));
+    }
+    if (typeof value !== 'object')
+        return false;
+    const record = value;
+    if (record.held === true && record.stale === true)
+        return true;
+    for (const key of ['structuredContent', 'result', 'data', 'content', 'text', 'output']) {
+        if (isHeldStaleResultShape(record[key], depth + 1))
+            return true;
+    }
+    return false;
+}
+function isClaudePlanApprovalTool(toolName, toolKind) {
+    return toolKind === 'switch_mode' && toolName.trim().toLowerCase() === 'exitplanmode';
+}
+function extractClaudePlanText(input) {
+    const direct = extractPlanLikeText(input, 0);
+    if (direct)
+        return direct;
+    if (typeof input === 'string')
+        return input.trim() || null;
+    return null;
+}
+function stripClaudeExitPlanAllowedPrompts(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return input;
+    if (!Object.prototype.hasOwnProperty.call(input, 'allowedPrompts'))
+        return input;
+    const { allowedPrompts: _allowedPrompts, ...rest } = input;
+    return rest;
+}
+function extractPlanLikeText(value, depth) {
+    if (depth > 4 || value == null)
+        return null;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((item) => extractPlanLikeText(item, depth + 1))
+            .filter((item) => Boolean(item));
+        return parts.length > 0 ? parts.join('\n') : null;
+    }
+    if (typeof value !== 'object')
+        return null;
+    const record = value;
+    for (const key of ['plan', 'proposedPlan', 'proposed_plan', 'markdown', 'content', 'text']) {
+        const text = extractPlanLikeText(record[key], depth + 1);
+        if (text)
+            return text;
+    }
+    return null;
+}
+function buildClaudeContinuePlanningMessage(responseText) {
+    const feedback = responseText?.trim();
+    return feedback
+        ? `Please continue planning and revise the plan with this feedback: ${feedback}`
+        : 'Please continue planning and revise the plan further.';
+}
+function buildPlanApprovalActions() {
+    return [
+        { id: 'reject', label: 'Reject', variant: 'danger' },
+        {
+            id: 'continue_planning',
+            label: 'Continue planning',
+            variant: 'secondary',
+            requiresInput: true,
+            inputPlaceholder: 'Tell the agent what to change or clarify in the plan...',
+        },
+        { id: 'implement', label: 'Implement', variant: 'primary' },
+    ];
+}
+function extractToolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return stringifyToolResultFallback(content);
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const typed = block;
+        if (typeof typed.text === 'string' && typed.text.trim()) {
+            parts.push(typed.text);
+            continue;
+        }
+        if (typeof typed.input === 'string' && typed.input.trim()) {
+            parts.push(typed.input);
+        }
+    }
+    return parts.join('\n\n') || stringifyToolResultFallback(content);
+}
+function stringifyToolResultFallback(content) {
+    if (content == null)
+        return '';
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+function describeClaudeStatus(message) {
+    const status = typeof message.status === 'string' ? message.status : null;
+    if (status === 'compacting')
+        return 'Compacting context';
+    if (status === 'requesting')
+        return 'Preparing next model request';
+    if (typeof message.compact_error === 'string' && message.compact_error.trim()) {
+        return `Compaction error: ${message.compact_error}`;
+    }
+    return undefined;
+}
+function formatClaudeTaskPatch(patch) {
+    if (!patch || typeof patch !== 'object')
+        return undefined;
+    const typed = patch;
+    const parts = [];
+    if (typeof typed.status === 'string')
+        parts.push(`status=${typed.status}`);
+    if (typeof typed.description === 'string' && typed.description.trim())
+        parts.push(typed.description);
+    if (typeof typed.error === 'string' && typed.error.trim())
+        parts.push(`error=${typed.error}`);
+    return parts.length > 0 ? parts.join(' • ') : undefined;
+}
+function buildClaudeToolMatchContext(_toolName, input, toolKind, workspaceRoot) {
+    const params = {};
+    if (toolKind === 'read' || toolKind === 'edit' || toolKind === 'delete' || toolKind === 'move') {
+        if (typeof input.file_path === 'string') {
+            params.file = input.file_path;
+        }
+    }
+    if (toolKind === 'execute') {
+        if (typeof input.command === 'string') {
+            params.command = input.command;
+        }
+    }
+    if (typeof input.pattern === 'string') {
+        params.pattern = input.pattern;
+    }
+    if (typeof input.query === 'string') {
+        params.query = input.query;
+    }
+    if (typeof input.text === 'string') {
+        params.text = input.text;
+    }
+    return {
+        params,
+        workspaceRoot,
+    };
+}
+function claudeToolTargetsWorkspace(toolKind, input, workspaceRoot) {
+    if (toolKind === 'execute') {
+        const cwd = normalizeUnknownString(input.cwd) ?? normalizeUnknownString(input.workdir);
+        if (cwd && isPathInsideOrEqual(cwd, workspaceRoot))
+            return true;
+        const command = normalizeUnknownString(input.command);
+        return !cwd || Boolean(command && command.replace(/\\ /g, ' ').includes(path.resolve(workspaceRoot)));
+    }
+    const paths = [
+        normalizeUnknownString(input.file_path),
+        normalizeUnknownString(input.filePath),
+        normalizeUnknownString(input.path),
+        normalizeUnknownString(input.cwd),
+        normalizeUnknownString(input.directory),
+    ].filter((value) => Boolean(value));
+    if (paths.length === 0) {
+        return toolKind === 'search';
+    }
+    return paths.some((value) => pathTargetsWorkspace(value, workspaceRoot, workspaceRoot));
+}
+function normalizeUnknownString(value) {
+    return typeof value === 'string' ? normalizeOptionalString(value) : null;
+}
+function pathTargetsWorkspace(value, cwd, workspaceRoot) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        return false;
+    const candidate = path.isAbsolute(normalized)
+        ? normalized
+        : path.resolve(cwd, normalized);
+    return isPathInsideOrEqual(candidate, workspaceRoot);
+}
+function isPathInsideOrEqual(candidatePath, rootPath) {
+    const candidate = path.resolve(candidatePath);
+    const root = path.resolve(rootPath);
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function resolveClaudeToolKind(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'read')
+        return 'read';
+    if (normalized === 'edit' || normalized === 'multiedit' || normalized === 'write' || normalized === 'notebookedit')
+        return 'edit';
+    if (normalized === 'grep' || normalized === 'glob' || normalized === 'ls')
+        return 'search';
+    if (normalized === 'bash' || normalized === 'killbash')
+        return 'execute';
+    if (normalized === 'webfetch' || normalized === 'websearch')
+        return 'fetch';
+    if (normalized === 'exitplanmode')
+        return 'switch_mode';
+    if (normalized === 'task' || normalized === 'todowrite')
+        return 'think';
+    return 'other';
+}
+function buildClaudeDisallowedTools(disabledToolKinds) {
+    const out = [];
+    const seen = new Set();
+    for (const kind of disabledToolKinds) {
+        for (const toolName of CLAUDE_DISALLOWED_TOOLS_BY_KIND[kind] ?? []) {
+            const key = toolName.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(toolName);
+        }
+    }
+    return out;
+}
+function isClaudePlatformChatTool(toolName, channelBridgeServerName) {
+    const serverName = channelBridgeServerName?.trim().toLowerCase();
+    if (!serverName)
+        return false;
+    return toolName.trim().toLowerCase() === `mcp__${serverName}__send_message`;
+}
+function buildPermissionArgs(input, options) {
+    const meta = {
+        toolUseId: options.toolUseID,
+    };
+    if (typeof options.title === 'string' && options.title.trim())
+        meta.title = options.title;
+    if (typeof options.displayName === 'string' && options.displayName.trim())
+        meta.displayName = options.displayName;
+    if (typeof options.description === 'string' && options.description.trim())
+        meta.description = options.description;
+    if (typeof options.blockedPath === 'string' && options.blockedPath.trim())
+        meta.blockedPath = options.blockedPath;
+    if (typeof options.decisionReason === 'string' && options.decisionReason.trim())
+        meta.decisionReason = options.decisionReason;
+    if (Array.isArray(options.suggestions) && options.suggestions.length > 0)
+        meta.suggestions = options.suggestions;
+    return {
+        input,
+        _permission: meta,
+    };
+}