@superblocksteam/vite-plugin-file-sync 2.0.59-next.1 → 2.0.59-next.3

package/dist/ai-service/state-machine/handlers/llm-generating.js

@@ -1,50 +1,17 @@
+import path from "node:path";
 import { AiEntityType, AiMode, } from "@superblocksteam/library-shared/types";
-import { smoothStream, } from "ai";
+import { hasToolCall, } from "ai";
 import { getErrorMeta, getLogger } from "../../../util/logger.js";
 import { buildBaseSystemPrompt } from "../../agent/prompts/build-base-system-prompt.js";
-import { getToolCallArguments } from "../../agent/tool-message-utils.js";
 import { buildTools } from "../../agent/tools.js";
 import { processStreamChunk } from "../../agent/utils.js";
 import { LLMProviderError } from "../../llm/error.js";
-import { tracedStreamText } from "../../llmobs/helpers.js";
-import { processLLMConfig } from "../../util/llm-config-utils.js";
 import { safeJsonStringify } from "../../util/safe-stringify.js";
 import { hasToolSuccess } from "../../util/stop-condition.js";
-import { AGENT_PLANNED, APP_RUNTIME_UPDATED_WITHOUT_EDITS, LLM_ERRORED, USER_CANCELED, V3_AGENT_FINISHED, } from "../clark-fsm.js";
+import { AGENT_PLANNED, APP_RUNTIME_UPDATED_WITHOUT_EDITS, ClarkStateNames, LLM_ERRORED, USER_CANCELED, V3_AGENT_FINISHED, } from "../clark-fsm.js";
 import { getContextId } from "../helpers/context-id.js";
 import { transitionFrom } from "../helpers/transition.js";
-function formatSummaryForAgents(latestSummary) {
-    if (!latestSummary) {
-        return null;
-    }
-    const parts = [];
-    if (latestSummary.outcome === "accepted") {
-        parts.push(`The user *accepted* the changes associated with the following summary. They have been applied to the application.`);
-    }
-    else if (latestSummary.outcome === "rejected") {
-        parts.push(`The user *rejected* the changes associated with the following summary. The changes were discarded.`);
-    }
-    if (latestSummary.summary) {
-        parts.push(`Summary: ${latestSummary.summary}`);
-    }
-    if (latestSummary.goals && latestSummary.goals.length > 0) {
-        parts.push(`User Goals: ${latestSummary.goals.join(", ")}`);
-    }
-    if (latestSummary.decisions && latestSummary.decisions.length > 0) {
-        parts.push(`Decisions: ${latestSummary.decisions.join(", ")}`);
-    }
-    if (latestSummary.adviceToAgents) {
-        parts.push(`Agent Advice: ${latestSummary.adviceToAgents}`);
-    }
-    if (latestSummary.relevantFilePaths &&
-        latestSummary.relevantFilePaths.length > 0) {
-        parts.push(`Relevant files:\n${latestSummary.relevantFilePaths
-            .map((path) => `- ${path}`)
-            .join("\n")}`);
-    }
-    return parts.length > 0 ? parts.join("\n\n") : null;
-}
-const buildUserMessage = (userPrompt, promptContext, planContext, mode, services) => {
+const buildUserMessage = (userPrompt, promptContext, planContext, mode, services, userChanges) => {
     const content = [];
     const focusedEntities = promptContext?.entities;
     const focusedEntitiesWithSemanticInfo = focusedEntities?.map((entity) => {
@@ -62,6 +29,38 @@ const buildUserMessage = (userPrompt, promptContext, planContext, mode, services
     const selectedIntegrations = promptContext?.integrations;
     const planApproved = planContext?.approved;
     const planSummary = planContext?.plan;
+    // Add user changes if present
+    if (userChanges && userChanges.length > 0) {
+        const appRootDirPath = services.appShell.appRootDirPath;
+        const changeDescriptions = userChanges.map((change) => {
+            switch (change.type) {
+                case "deleteComponents":
+                    return `- Deleted ${change.componentCount} component(s) from ${path.relative(appRootDirPath, change.path)}`;
+                case "createComponent":
+                    return `- Added a new component to ${path.relative(appRootDirPath, change.path)}`;
+                case "reparent":
+                    return `- Moved components in ${path.relative(appRootDirPath, change.path)}`;
+                case "batchUpdate": {
+                    const relativePaths = change.paths.map((p) => path.relative(appRootDirPath, p));
+                    return `- Made ${change.updateCount} changes to ${relativePaths.length > 1 ? `${relativePaths.length} files` : relativePaths[0]}`;
+                }
+                case "addPage":
+                    return `- Created a new page at ${path.relative(appRootDirPath, change.path)}`;
+                case "deletePage":
+                    return `- Deleted page at ${path.relative(appRootDirPath, change.path)}`;
+                case "apiUpdate":
+                    return `- Modified API "${change.apiName}"`;
+                case "apiDelete":
+                    return `- Deleted API "${change.apiName}"`;
+                case "fileChanged":
+                    return `- Edited code in ${path.relative(appRootDirPath, change.filePath)}`;
+            }
+        });
+        content.push({
+            type: "text",
+            text: `<recent_user_changes>\nSince your last interaction, the user has made the following changes:\n${changeDescriptions.join("\n")}\n\nThe current state of the application reflects all of these changes.\n</recent_user_changes>\n\n`,
+        });
+    }
     // Add focused entities if present
     if (focusedEntities?.length) {
         content.push({
@@ -117,446 +116,82 @@ const buildUserMessage = (userPrompt, promptContext, planContext, mode, services
     };
 };
 export const doLLMGenerating = (clark, services) => {
-    const { chatSessionStore } = services;
     const transitionTo = transitionFrom(clark);
     return async ({ event }) => {
         switch (event.type) {
             case AGENT_PLANNED: {
                 const { userPrompt, promptContext } = event;
-                const { abortController } = clark.context;
                 const provider = services.llmProvider.name;
-                const contextId = getContextId(clark, services);
-                const contextOptions = clark.context.llmConfig?.contextOptions;
-                // Generate a unique owner ID for this LLM generation session
-                const ownerId = `llm-generating-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-                // Acquire exclusive context access
-                const contextHandle = await services.contextManager.acquireContext(contextId, ownerId, {
-                    contextOptions,
-                    acquireOptions: {
-                        waitTimeoutMs: 30000, // Wait up to 30 seconds for context
-                        lockTimeoutMs: 600000, // Hold lock for up to 10 minutes
-                        retryIntervalMs: 100,
+                const mode = clark.context.currentMode;
+                const planContext = clark.context.planContext;
+                const planApproved = planContext?.approved;
+                const system = buildBaseSystemPrompt(mode);
+                const user = buildUserMessage(userPrompt, promptContext, planContext, mode, services, clark.context.userChanges);
+                const tools = await buildTools(clark, services);
+                const result = await clark.streamText(services, {
+                    user,
+                    system,
+                    tools,
+                    context: {
+                        contextId: getContextId(clark, services),
                     },
+                    stopWhen: [
+                        hasToolSuccess("build_finalize"),
+                        hasToolSuccess("exitPlanMode"),
+                        hasToolCall("askMultiChoice"),
+                        () => clark.state === ClarkStateNames.AwaitingUser,
+                    ],
                 });
                 try {
-                    const context = contextHandle.context;
-                    const mode = clark.context.currentMode;
-                    const planContext = clark.context.planContext;
-                    const planApproved = planContext?.approved;
-                    await chatSessionStore.getMessages();
-                    const latestSummary = await chatSessionStore.getLatestSummary();
-                    if (latestSummary) {
-                        context.seedIfEmpty({
-                            role: "user",
-                            content: `Reference the context from the previous exchange with the user, if relevant:\n\n${formatSummaryForAgents(latestSummary)}`,
-                        });
-                    }
-                    const systemPrompt = buildBaseSystemPrompt(mode);
-                    const system = {
-                        role: "system",
-                        content: systemPrompt,
-                    };
-                    context.setSystemPrompt(system);
-                    const prompt = buildUserMessage(userPrompt, promptContext, planContext, mode, services);
-                    context.startTurn(prompt);
-                    const messages = context.getMessages();
-                    const model = services.llmProvider.modelForClassification("broad_edit");
-                    // Process LLM configuration up front so we can log it once at the top
-                    const llmConfig = clark.context.llmConfig;
-                    const disabledTools = clark.context.llmConfig?.disabledTools;
-                    const { headers, thinkingEnabled, thinkingBudgetTokens, interleavedThinking, providerOptions, } = processLLMConfig(llmConfig, 5000, // default budget tokens
-                    `LLM Generating (model=${model.modelId}, disabledTools=${disabledTools?.length ? disabledTools.join(",") : "none"})`);
-                    const conversationId = Date.now();
-                    const startTimestamp = new Date().toISOString();
-                    const runTimestamp = clark.context.runTimestamp || startTimestamp;
-                    // Initialize log content
-                    const logRef = {
-                        content: `=== LLM CONVERSATION START [${conversationId}] ===\n`,
-                    };
-                    logRef.content += `Timestamp: ${startTimestamp}\n`;
-                    logRef.content += `Model: ${model.modelId}\n`;
-                    // Log AI provider config
-                    logRef.content += `Provider Config: provider=${llmConfig?.provider || "anthropic (default)"}, thinking=${thinkingEnabled}, budget=${thinkingBudgetTokens}, interleaved=${interleavedThinking}`;
-                    if (disabledTools?.length) {
-                        logRef.content += `, disabledTools=${disabledTools.join(",")}`;
+                    for await (const chunk of result.fullStream) {
+                        await processStreamChunk(chunk, clark, services);
                     }
-                    if (headers && Object.keys(headers).length > 0) {
-                        logRef.content += `, headers=${JSON.stringify(headers)}`;
-                    }
-                    logRef.content += `--- INPUT MESSAGES ---\n`;
-                    logRef.content += `[SYSTEM] ${systemPrompt}\n\n`;
-                    logRef.content += `[${system.role.toUpperCase()}] ${system.content}\n\n`;
-                    logRef.content += `--- USER INPUT ---\n`;
-                    logRef.content += `${userPrompt}\n\n`;
-                    if (promptContext) {
-                        if (promptContext.entities?.length) {
-                            logRef.content += `[FOCUSED ENTITIES] ${safeJsonStringify(promptContext.entities)}\n`;
-                        }
-                        if (promptContext.integrations?.length) {
-                            logRef.content += `[SELECTED INTEGRATIONS] ${safeJsonStringify(promptContext.integrations.map(({ id, name, type }) => ({ id, name, type })))}\n`;
-                        }
-                        if (promptContext.attachments?.length) {
-                            logRef.content += `[ATTACHMENTS] ${promptContext.attachments.length} attachment(s)\n`;
-                            promptContext.attachments.forEach((attachment, idx) => {
-                                logRef.content += `  ${idx + 1}. Type: ${attachment.type}\n`;
-                            });
-                        }
-                    }
-                    if (mode !== undefined) {
-                        logRef.content += `[MODE] ${mode === AiMode.PLAN ? "Plan" : "Build"} mode\n`;
-                    }
-                    if (planContext) {
-                        logRef.content += `[PLAN CONTEXT] Approved: ${planContext.approved}, Has Plan: ${!!planContext.plan}\n`;
+                }
+                catch (err) {
+                    let error;
+                    if (LLMProviderError.isInstance(err)) {
+                        error = err;
                     }
-                    logRef.content += `\n`;
-                    // Note: Input token count will be logged once LLM call begins
-                    // buildTools now returns filtered tools based on mode via registry
-                    const actualTools = await buildTools(clark, services, promptContext, logRef, disabledTools);
-                    logRef.content += `Mode: ${mode}, Available tools: ${Object.keys(actualTools).length}\n`;
-                    logRef.content += `Tools: ${Object.keys(actualTools).join(", ")}\n\n`;
-                    let stepCount = 0;
-                    // Track cumulative token usage across all steps
-                    let totalInputTokens = 0;
-                    let totalOutputTokens = 0;
-                    let totalCachedTokens = 0;
-                    services.clarkProfiler.startLLMWaiting({
-                        messages: messages,
-                        model: model.modelId,
-                    });
-                    let firstTokenReceived = false;
-                    let thinkingSpanActive = false;
-                    let textSpanActive = false;
-                    const allReasoningDeltas = [];
-                    let currentStepReasoningDeltas = [];
-                    let currentStepTextDeltas = [];
-                    getLogger().info(`CURRENT_MODE: ${mode}`);
-                    const build = tracedStreamText({
-                        abortSignal: abortController?.signal,
-                        model,
-                        providerOptions,
-                        headers,
-                        experimental_transform: [smoothStream({ chunking: "line" })],
-                        messages,
-                        tools: actualTools,
-                        prepareStep: async (step) => {
-                            context.startStep();
-                            const messages = context.getMessages();
-                            return { ...step, messages };
-                        },
-                        stopWhen: [
-                            hasToolSuccess("build_finalize"),
-                            hasToolSuccess("exitPlanMode"),
-                            hasToolSuccess("askMultiChoice"),
-                        ],
-                        onChunk: (chunkData) => {
-                            if (!firstTokenReceived) {
-                                firstTokenReceived = true;
-                                services.clarkProfiler.startLLMStreaming({
-                                    firstChunk: chunkData.chunk.type === "text-delta"
-                                        ? chunkData.chunk.text
-                                        : `[${chunkData.chunk.type}]`,
-                                });
-                            }
-                            if (chunkData.chunk.type === "reasoning-delta") {
-                                const thinkingTrack = "thinking";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .createTrack(thinkingTrack, "AI Thinking/Reasoning", "llm");
-                                allReasoningDeltas.push(chunkData.chunk.text);
-                                currentStepReasoningDeltas.push(chunkData.chunk.text);
-                                if (!thinkingSpanActive) {
-                                    thinkingSpanActive = true;
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .startFrame(`Thinking Step ${stepCount + 1}`, thinkingTrack, {
-                                        stepNumber: stepCount + 1,
-                                        chunkType: chunkData.chunk.type,
-                                    });
-                                }
-                            }
-                            if (chunkData.chunk.type === "text-delta") {
-                                const textTrack = "text_generation";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .createTrack(textTrack, "Text Generation", "llm");
-                                currentStepTextDeltas.push(chunkData.chunk.text);
-                                if (!textSpanActive) {
-                                    textSpanActive = true;
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .startFrame(`Text Generation Step ${stepCount + 1}`, textTrack, {
-                                        stepNumber: stepCount + 1,
-                                        firstTextDelta: chunkData.chunk.text.slice(0, 50) +
-                                            (chunkData.chunk.text.length > 50 ? "..." : ""),
-                                    });
-                                }
-                            }
-                        },
-                        onStepFinish: async (step) => {
-                            stepCount++;
-                            const stepTimestamp = new Date().toISOString();
-                            context.endStep(step.response.messages, step.usage);
-                            logRef.content += `--- OUTPUT STEP ${stepCount} [${stepTimestamp}] ---\n`;
-                            if (step.reasoning && thinkingSpanActive) {
-                                const thinkingTrack = "thinking";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .updateActiveFrameArgs(thinkingTrack, {
-                                    completeReasoningText: currentStepReasoningDeltas.join(" "),
-                                    reasoningLength: step.reasoning.length,
-                                    stepComplete: true,
-                                });
-                                services.clarkProfiler.getProfiler().endFrame(thinkingTrack);
-                                thinkingSpanActive = false;
-                                currentStepReasoningDeltas = [];
-                            }
-                            // Log token usage for this step and accumulate totals
-                            if (step.usage) {
-                                const stepInputTokens = step.usage.inputTokens ?? 0;
-                                const stepOutputTokens = step.usage.outputTokens ?? 0;
-                                const stepCachedTokens = step.usage.cachedInputTokens ?? 0;
-                                // Accumulate totals
-                                totalInputTokens += stepInputTokens;
-                                totalOutputTokens += stepOutputTokens;
-                                totalCachedTokens += stepCachedTokens;
-                                logRef.content += `[TOKEN USAGE] Input: ${stepInputTokens}, Output: ${stepOutputTokens}, Total: ${step.usage.totalTokens ?? 0}`;
-                                if (stepCachedTokens) {
-                                    logRef.content += `, Cached: ${stepCachedTokens}`;
-                                }
-                                logRef.content += `\n`;
-                            }
-                            const apiToolCall = step.toolCalls.find((toolCall) => toolCall.toolName === "build_generateApiSource");
-                            const apiName = apiToolCall?.input?.apiName;
-                            const apiGroup = apiName ? `api-${apiName}` : undefined;
-                            // Record tool calls FIRST before other messages to ensure proper ordering
-                            const toolsCalled = step.content
-                                .filter((c) => c.type === "tool-result")
-                                .map((c) => ({
-                                toolName: c.toolName,
-                                input: JSON.stringify(c.input),
-                                output: JSON.stringify(c.output, null, 2),
-                            }));
-                            if (toolsCalled.length > 0) {
-                                logRef.content += `[TOOLS CALLED]\n`;
-                                toolsCalled.forEach((tool, idx) => {
-                                    logRef.content += `  Tool ${idx + 1}: ${tool.toolName}\n`;
-                                    logRef.content += `    Input: ${tool.input}\n`;
-                                    logRef.content += `    Output: ${tool.output}\n`;
-                                });
-                                try {
-                                    await Promise.all(step.toolCalls.map(async (toolCall) => {
-                                        const args = await getToolCallArguments(toolCall.toolName, toolCall.input, clark);
-                                        await services.chatSessionStore.recordAssistant({
-                                            type: "tool",
-                                            tool: toolCall.toolName,
-                                            args: args,
-                                            ...(apiGroup && { group: apiGroup }),
-                                        });
-                                    }));
-                                }
-                                catch (error) {
-                                    getLogger().error("Failed to record tool calls", getErrorMeta(error));
-                                }
-                                // Record profiling events
-                                toolsCalled.forEach((tool, idx) => {
-                                    let parsedInput, parsedOutput;
-                                    try {
-                                        parsedInput = JSON.parse(tool.input);
-                                    }
-                                    catch {
-                                        parsedInput = tool.input;
-                                    }
-                                    try {
-                                        parsedOutput = JSON.parse(tool.output);
-                                    }
-                                    catch {
-                                        parsedOutput = tool.output;
-                                    }
-                                    services.clarkProfiler
-                                        .getProfiler()
-                                        .addInstantEvent(`Tool Call: ${tool.toolName}`, "llm", {
-                                        step: stepCount,
-                                        toolIndex: idx + 1,
-                                        toolName: tool.toolName,
-                                        input: parsedInput,
-                                        output: parsedOutput,
-                                        inputSize: tool.input.length,
-                                        outputSize: tool.output.length,
-                                    });
-                                });
-                            }
-                            // Record reasoning messages AFTER tool calls
-                            if (step.reasoning) {
-                                const reasoningLines = [
-                                    "[REASONING]",
-                                    ...step.reasoning.map(({ text }) => text),
-                                    "",
-                                ];
-                                logRef.content += reasoningLines.join("\n");
-                                const reasoningText = step.reasoning
-                                    .map(({ text }) => text)
-                                    .join("");
-                                if (reasoningText) {
-                                    try {
-                                        await services.chatSessionStore.recordAssistant({
-                                            type: "reasoning",
-                                            text: reasoningText,
-                                            ...(apiGroup && { group: apiGroup }),
-                                        });
-                                    }
-                                    catch (error) {
-                                        getLogger().error("Failed to record message from LLM", getErrorMeta(error));
-                                    }
-                                }
-                            }
-                            if (step.text && textSpanActive) {
-                                const textTrack = "text_generation";
-                                services.clarkProfiler
-                                    .getProfiler()
-                                    .updateActiveFrameArgs(textTrack, {
-                                    completeTextContent: currentStepTextDeltas.join(""),
-                                    finalText: step.text,
-                                    textLength: step.text.length,
-                                    stepComplete: true,
-                                });
-                                services.clarkProfiler.getProfiler().endFrame(textTrack);
-                                textSpanActive = false;
-                                currentStepTextDeltas = [];
-                            }
-                            // Record text messages AFTER tool calls and reasoning
-                            if (step.text) {
-                                logRef.content += `[ASSISTANT TEXT] ${step.text}\n`;
-                                try {
-                                    await services.chatSessionStore.recordAssistant({
-                                        type: "text",
-                                        text: step.text,
-                                        ...(apiGroup && { group: apiGroup }),
-                                    });
-                                }
-                                catch (error) {
-                                    getLogger().error("Failed to record message from LLM", getErrorMeta(error));
-                                }
-                            }
-                            logRef.content += `\n`;
-                        },
-                        onFinish: (result) => {
-                            context.endTurn(result.totalUsage);
-                        },
-                    }, clark.tracer, clark.logger);
-                    try {
-                        for await (const chunk of build.fullStream) {
-                            await processStreamChunk(chunk, clark, services, logRef);
-                        }
+                    else {
+                        error = new LLMProviderError({ provider, cause: err });
                     }
-                    catch (err) {
-                        let error;
-                        if (LLMProviderError.isInstance(err)) {
-                            error = err;
-                        }
-                        else {
-                            error = new LLMProviderError({ provider, cause: err });
-                        }
-                        if (error.type === "aborted") {
-                            getLogger().info("LLM generation aborted by user");
-                            void clark.send({
-                                type: USER_CANCELED,
-                            });
-                            return;
-                        }
-                        getLogger().error("LLM stream processing failed", getErrorMeta(error));
+                    if (error.type === "aborted") {
+                        getLogger().info("LLM generation aborted by user");
                         void clark.send({
-                            type: LLM_ERRORED,
-                            error,
+                            type: USER_CANCELED,
                         });
                         return;
                     }
-                    if (firstTokenReceived) {
-                        services.clarkProfiler.endFrame();
-                    }
-                    services.clarkProfiler.endFrame();
-                    if (thinkingSpanActive) {
-                        services.clarkProfiler.getProfiler().endFrame("thinking");
-                    }
-                    if (textSpanActive) {
-                        services.clarkProfiler.getProfiler().endFrame("text_generation");
-                    }
-                    const endTimestamp = new Date().toISOString();
-                    logRef.content += `=== LLM CONVERSATION END [${conversationId}] ===\n`;
-                    logRef.content += `End Timestamp: ${endTimestamp}\n`;
-                    logRef.content += `Total Steps: ${stepCount}\n`;
-                    // Log final token usage summary using accumulated totals
-                    const finalTotalTokens = totalInputTokens + totalOutputTokens;
-                    logRef.content += `[TOTAL TOKEN USAGE] Input: ${totalInputTokens}, Output: ${totalOutputTokens}, Total: ${finalTotalTokens}`;
-                    if (totalCachedTokens > 0) {
-                        logRef.content += `, Cached: ${totalCachedTokens}`;
-                    }
-                    logRef.content += `\n`;
-                    try {
-                        // Create TokenRequestData object from accumulated step data (not AI SDK usage which is only final step)
-                        const requestTokenData = {
-                            requestId: conversationId.toString(),
-                            inputTokens: totalInputTokens,
-                            outputTokens: totalOutputTokens,
-                            totalTokens: totalInputTokens + totalOutputTokens,
-                            cachedInputTokens: totalCachedTokens,
-                            model: model.modelId,
-                            startTime: startTimestamp,
-                            endTime: endTimestamp,
-                        };
-                        await clark.context.peer?.call.aiPushTokenUsage(requestTokenData);
-                    }
-                    catch (error) {
-                        // Token tracking is non-critical - log error but don't fail the AI request
-                        getLogger().warn("Failed to send token usage data", error instanceof Error ? error.message : String(error));
-                    }
-                    // Save the complete log using saveGeneratedArtifact
-                    try {
-                        const logArtifact = {
-                            type: "file",
-                            filePath: `llm-conversation-${conversationId}.log`,
-                            content: logRef.content,
-                        };
-                        const stepId = `llm-conversation-${conversationId}`;
-                        await services.appShell.saveGeneratedArtifact(logArtifact, stepId, runTimestamp);
-                        getLogger().debug("LLM conversation log saved");
-                    }
-                    catch (error) {
-                        getLogger().error("Failed to save LLM conversation log", {
-                            error: {
-                                kind: "SaveLogError",
-                                message: error instanceof Error ? error.message : String(error),
-                                stack: error instanceof Error ? error.stack : undefined,
-                            },
-                        });
-                    }
-                    // Check if there are local draft changes
-                    const hasLocalDraft = await services.draftInterface.hasLocalDraftChanges();
-                    // In PLAN mode, only proceed to draft state if:
-                    // 1. User has approved the plan
-                    // 2. There are actual file changes (hasLocalDraft === true)
-                    if (mode === AiMode.PLAN) {
-                        if (!planApproved || !hasLocalDraft) {
-                            void transitionTo({
-                                type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
-                            });
-                            return;
-                        }
-                        // If plan is approved and there are changes, fall through to create draft
-                    }
-                    if (hasLocalDraft) {
-                        void transitionTo({
-                            type: V3_AGENT_FINISHED,
-                        });
-                    }
-                    else {
+                    getLogger().error("LLM stream processing failed", getErrorMeta(error));
+                    void clark.send({
+                        type: LLM_ERRORED,
+                        error,
+                    });
+                    return;
+                }
+                // Check if there are local draft changes
+                const hasLocalDraft = await services.draftInterface.hasLocalDraftChanges();
+                // In PLAN mode, only proceed to draft state if:
+                // 1. User has approved the plan
+                // 2. There are actual file changes (hasLocalDraft === true)
+                if (mode === AiMode.PLAN) {
+                    if (!planApproved || !hasLocalDraft) {
                         void transitionTo({
                             type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
                         });
+                        return;
                     }
+                    // If plan is approved and there are changes, fall through to create draft
                 }
-                finally {
-                    // Always release the context lock when done
-                    contextHandle.release();
+                if (hasLocalDraft) {
+                    void transitionTo({
+                        type: V3_AGENT_FINISHED,
+                    });
+                }
+                else {
+                    void transitionTo({
+                        type: APP_RUNTIME_UPDATED_WITHOUT_EDITS,
+                    });
                 }
             }
         }