@vetala/vetala 0.5.6 → 0.6.1

package/README.md

@@ -27,25 +27,26 @@ Current provider support includes Sarvam AI and OpenRouter.
 
 ## Patch Notes
 
-### v0.5.6
+### v0.6.1
 Added:
-- Turn deliberation with dynamic reasoning effort, visible planning/thinking summaries, and live execution phases in the TUI footer.
-- Clarification-first behavior for underspecified edit requests through stronger `ask_user` guidance.
+- Enhanced the core cognitive execution loop with explicit `Think -> Act -> Observe -> Reflect` guardrails.
+- Added a completion confidence and verification system requiring empirical proof before declaring tasks finished.
+- Migrated from hardcoded default plans to a dynamic, model-driven task planning system with granular state tracking.
+- Introduced a strict constraint to prevent "fake shell execution" and force the use of real filesystem tools over markdown code blocks.
 
 Patched:
-- `Ctrl+C` pause flow now interrupts active tool/model work more reliably and shows an immediate stopping modal.
-- Repo-wide search cancellation now propagates through the TypeScript backend and Go TUI worker path.
-- Non-trivial turns now surface reasoning and phase state more clearly during execution.
+- Added smart API error detection to immediately stop and alert the user on non-retryable OpenRouter guardrail, data policy, or auth errors instead of blind retrying.
 
-### v0.5.5
+### v0.6.0
 Added:
-- Deterministic skill routing with active-skill visibility in the UI.
-- Git-aware review flow upgrades with dedicated `/diff` and `/review` entry points.
+- Deliberation-aware TUI turns with thinking summaries, checkbox plans, and live reasoning/phase state.
+- Deterministic active-skill routing with richer pre-turn skill guidance and clearer skill visibility in the UI.
+- `Ctrl+K` full-turn log copy for sharing the latest prompt, plan, tool activity, and reply context.
 
 Patched:
-- Malformed tool calls are quarantined before they can poison session history.
-- `Ctrl+C` can now stop active repo search work instead of waiting for long searches to finish.
-- Explicit file-path prompts now steer toward `read_file`/`read_file_chunk` before repo-wide search.
+- Explicit file-path tasks now stay scoped to the named target instead of drifting into broad repo exploration.
+- Edit plans are evidence-driven, verification is file-targeted, and no-op edits are rejected instead of being reported as successful changes.
+- Tool interruption, repo search cancellation, malformed tool-call recovery, and post-tool activity updates are more reliable.
 
 ## Compatibility
 

package/dist/src/agent.d.ts

@@ -45,6 +45,17 @@ export declare class Agent {
     private turnDeliberationPrompt;
     private turnReasoningEffort;
     private turnReasoningLabel;
+    private turnPlan;
+    private turnPlanSignature;
+    private turnPlanInspected;
+    private turnPlanHasMutation;
+    private turnPlanHasVerification;
+    private turnTaskKind;
+    private turnTargets;
+    private turnChangedFiles;
+    private turnVerificationRecords;
+    private turnNoOpEdits;
+    private turnVerificationNudges;
     constructor(options: AgentOptions);
     get session(): SessionState;
     requestStop(): void;
@@ -55,9 +66,15 @@ export declare class Agent {
     private appendAndRenderAssistantMessage;
     private persistedMessage;
     private systemPrompt;
+    private currentExecutionPrompt;
+    private pendingVerificationPrompt;
     private beginRequest;
     private endRequest;
     private throwIfStopped;
+    private advanceCurrentPlan;
+    private observeToolResult;
+    private finalizeCurrentPlan;
+    private setTurnPlan;
 }
 export declare class AgentInterruptedError extends Error {
     constructor();

package/dist/src/agent.js

@@ -1,9 +1,17 @@
 import { compactConversation } from "./context-memory.js";
-import { analyzeTurnDeliberation, phaseForTool } from "./deliberation.js";
+import { advanceTurnPlan, analyzeTurnDeliberation, cloneTurnPlan, phaseForTool, updateTurnPlan } from "./deliberation.js";
 import { loadMemoriesPrompt, loadRulesPrompt } from "./context-files.js";
 import { appendHistoryEntry } from "./history-store.js";
 import { createProviderClient, getProviderDefinition, providerLabel, withSystemMessage } from "./providers/index.js";
 import { createSearchProvider } from "./search-provider.js";
+import { formatTurnTargetList, resolveTurnTargets } from "./turn-targets.js";
+const EMPTY_TURN_TARGETS = {
+    taskKind: "chat",
+    explicitPaths: [],
+    explicitFiles: [],
+    explicitDirs: [],
+    preferredRoot: null
+};
 export class Agent {
     options;
     client;
@@ -14,6 +22,17 @@ export class Agent {
     turnDeliberationPrompt = null;
     turnReasoningEffort = null;
     turnReasoningLabel = "none";
+    turnPlan = null;
+    turnPlanSignature = "";
+    turnPlanInspected = false;
+    turnPlanHasMutation = false;
+    turnPlanHasVerification = false;
+    turnTaskKind = "chat";
+    turnTargets = EMPTY_TURN_TARGETS;
+    turnChangedFiles = new Set();
+    turnVerificationRecords = [];
+    turnNoOpEdits = [];
+    turnVerificationNudges = 0;
     constructor(options) {
         this.options = options;
         this.client = createProviderClient(options.config.providers[options.session.provider]);
@@ -31,6 +50,16 @@ export class Agent {
         this.activeTurnController = turnController;
         this.stopRequested = false;
         try {
+            this.turnPlanInspected = false;
+            this.turnPlanHasMutation = false;
+            this.turnPlanHasVerification = false;
+            this.turnTaskKind = "chat";
+            this.turnTargets = EMPTY_TURN_TARGETS;
+            this.turnChangedFiles.clear();
+            this.turnVerificationRecords = [];
+            this.turnNoOpEdits = [];
+            this.turnVerificationNudges = 0;
+            this.setTurnPlan(null);
             const userMessage = this.persistedMessage({
                 role: "user",
                 content: userInput
@@ -55,6 +84,8 @@ export class Agent {
                 configuredEffort: providerDefinition.supportsReasoningEffort ? this.options.config.reasoningEffort : null,
                 activeSkills: turnSkillContext.labels
             });
+            this.turnTaskKind = deliberation.taskKind;
+            this.turnTargets = await resolveTurnTargets(userInput, deliberation.taskKind, this.options.pathPolicy, this.options.session.workspaceRoot);
             this.turnDeliberationPrompt = deliberation.guidance;
             this.turnReasoningEffort = providerDefinition.supportsReasoningEffort ? deliberation.reasoningEffort : null;
             this.turnReasoningLabel = deliberation.reasoningLabel;
@@ -62,7 +93,11 @@ export class Agent {
             if (deliberation.shouldShowThinking && deliberation.thinkingSummary) {
                 this.options.ui.printThinking(deliberation.thinkingSummary);
             }
+            if (deliberation.plan) {
+                this.advanceCurrentPlan("inspect", deliberation.plan);
+            }
             if (!provider.authValue) {
+                this.setTurnPlan(null);
                 const missingAuthMessage = provider.authSource === "stored_hash"
                     ? `A stored SHA-256 fingerprint exists for ${providerDefinition.label}, but the raw credential is not available in this process. Use /model to enter the key again or set ${providerDefinition.auth.envVars.join(", ")}.`
                     : `${providerDefinition.label} credentials are missing. Set ${providerDefinition.auth.envVars.join(", ")} and try again.`;
@@ -100,15 +135,23 @@ export class Agent {
                     }
                     consecutiveApiErrors += 1;
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (consecutiveApiErrors >= 3) {
-                        await this.appendAndRenderAssistantMessage(`I've encountered multiple consecutive API errors and must stop. Last error: ${errorMessage}`, true);
+                    const isNonRetryable = errorMessage.includes("guardrail") ||
+                        errorMessage.includes("policy") ||
+                        errorMessage.includes("unauthorized") ||
+                        errorMessage.includes("401") ||
+                        errorMessage.includes("403");
+                    if (consecutiveApiErrors >= 3 || isNonRetryable) {
+                        const finalMessage = isNonRetryable
+                            ? `I encountered a non-retryable API error: ${errorMessage}. Please check your provider settings or guardrail restrictions.`
+                            : `I've encountered multiple consecutive API errors and must stop. Last error: ${errorMessage}`;
+                        await this.appendAndRenderAssistantMessage(finalMessage, true);
                         return;
                     }
                     this.options.ui.warn(`API Error: ${errorMessage}`);
                     this.options.ui.activity("Retrying automatically...");
                     const syntheticUserMessage = this.persistedMessage({
                         role: "user",
-                        content: `SYSTEM ALERT: The previous generation failed with an API error: ${errorMessage}\nIf you were generating a large file, you likely hit the maximum output token limit. Please try breaking your response down, or use the append_to_file tool to write large files in chunks.`
+                        content: `SYSTEM ALERT: The previous generation failed with an API error: ${errorMessage}\nIf this error persists, consider breaking your request into smaller parts or checking your model configuration.`
                     });
                     await this.options.sessionStore.appendMessage(this.options.session, syntheticUserMessage);
                     continue;
@@ -149,17 +192,56 @@ export class Agent {
                     content: turn.content || null,
                     tool_calls: partitionedToolCalls.validToolCalls.length > 0 ? partitionedToolCalls.validToolCalls : null
                 });
+                // Extract thinking summary from content if not already set
+                if (turn.content && !this.turnPlanInspected) {
+                    const lines = turn.content.split("\n");
+                    const thinkingLines = lines.filter(l => l.trim().startsWith("- ") || l.trim().startsWith("* "));
+                    if (thinkingLines.length > 0) {
+                        this.options.ui.printThinking(thinkingLines.slice(0, 3).join("\n"));
+                    }
+                }
                 await this.options.sessionStore.appendMessage(this.options.session, assistantMessage);
                 if (partitionedToolCalls.validToolCalls.length === 0) {
+                    if (this.turnTaskKind !== "chat") {
+                        const verificationPrompt = this.pendingVerificationPrompt();
+                        if (verificationPrompt) {
+                            this.turnVerificationNudges += 1;
+                            await this.options.sessionStore.appendMessage(this.options.session, this.persistedMessage({
+                                role: "user",
+                                content: verificationPrompt
+                            }));
+                            continue;
+                        }
+                        // Force the use of task_completed for non-chat tasks if they just wrote text
+                        const textContent = (turn.content || "").toLowerCase();
+                        const looksLikeCodeBlock = textContent.includes("```");
+                        if (this.turnVerificationNudges < 3 && !textContent.includes("task_completed")) {
+                            this.turnVerificationNudges += 1;
+                            const pushback = looksLikeCodeBlock
+                                ? "SYSTEM ALERT: You provided a code block in your response instead of using a tool to write it. You MUST use 'replace_in_file' or 'write_file' to apply these changes. Do not just write code in markdown."
+                                : "SYSTEM ALERT: You stopped calling tools. If you are finished with the task, you MUST call the `task_completed` tool to formalize completion. If you are not finished, please use the appropriate tools to continue.";
+                            this.options.ui.warn("Agent stopped prematurely. Nudging to use tools or task_completed...");
+                            await this.options.sessionStore.appendMessage(this.options.session, this.persistedMessage({
+                                role: "user",
+                                content: pushback
+                            }));
+                            continue;
+                        }
+                    }
+                    this.finalizeCurrentPlan();
                     this.options.ui.endAssistantTurn();
                     return;
                 }
                 let suppressedRepeats = 0;
+                let taskCompletedCalled = false;
                 for (const toolCall of partitionedToolCalls.validToolCalls) {
                     this.throwIfStopped();
                     this.options.ui.printToolCall(toolCall);
                     const signature = toolCallSignature(toolCall);
                     let result;
+                    if (toolCall.function.name === "task_completed") {
+                        taskCompletedCalled = true;
+                    }
                     if (seenToolCalls.has(signature)) {
                         suppressedRepeats += 1;
                         this.options.ui.activity(`Skipping repeated ${toolCall.function.name} call.`);
@@ -174,7 +256,7 @@ export class Agent {
                         this.options.ui.updateTurnState(this.turnReasoningLabel, phaseForTool(toolCall.function.name));
                         this.options.ui.activity(`Running ${toolCall.function.name}.`);
                         const toolSpec = this.options.tools.getTool(toolCall.function.name);
-                        const isMutating = toolSpec && !toolSpec.readOnly;
+                        const isMutating = Boolean(toolSpec && !toolSpec.readOnly);
                         try {
                             result = await this.options.tools.execute(toolCall, this.toolContext(turnController));
                         }
@@ -185,6 +267,7 @@ export class Agent {
                             }
                             throw error;
                         }
+                        this.observeToolResult(toolCall, isMutating, result);
                         if (result.isError) {
                             seenToolCalls.delete(signature);
                         }
@@ -194,12 +277,19 @@ export class Agent {
                     }
                     this.throwIfStopped();
                     this.options.ui.printToolResult(result.summary, result.isError, result.content);
+                    this.options.ui.activity("Thinking...");
                     await this.options.sessionStore.appendMessage(this.options.session, this.persistedMessage({
                         role: "tool",
                         content: result.content,
                         tool_call_id: toolCall.id
                     }));
                 }
+                // If the agent successfully completed the task this turn, exit the loop cleanly.
+                if (taskCompletedCalled) {
+                    this.finalizeCurrentPlan();
+                    this.options.ui.endAssistantTurn();
+                    return;
+                }
                 if (shouldInjectRepeatWarning(suppressedRepeats, repeatWarningInjected)) {
                     repeatWarningInjected += 1;
                     const warning = this.persistedMessage({
@@ -219,6 +309,15 @@ export class Agent {
             this.turnDeliberationPrompt = null;
             this.turnReasoningEffort = null;
             this.turnReasoningLabel = "none";
+            this.turnTaskKind = "chat";
+            this.turnTargets = EMPTY_TURN_TARGETS;
+            this.turnChangedFiles.clear();
+            this.turnVerificationRecords = [];
+            this.turnNoOpEdits = [];
+            this.turnVerificationNudges = 0;
+            this.turnPlanInspected = false;
+            this.turnPlanHasMutation = false;
+            this.turnPlanHasVerification = false;
             this.options.ui.updateTurnState(null, null);
         }
     }
@@ -288,6 +387,14 @@ export class Agent {
         return {
             cwd: process.cwd(),
             workspaceRoot: this.options.session.workspaceRoot,
+            turn: {
+                taskKind: this.turnTaskKind,
+                explicitPaths: [...this.turnTargets.explicitPaths],
+                explicitFiles: [...this.turnTargets.explicitFiles],
+                explicitDirs: [...this.turnTargets.explicitDirs],
+                preferredRoot: this.turnTargets.preferredRoot,
+                changedFiles: [...this.turnChangedFiles]
+            },
             lifecycle: {
                 signal: turnController.signal,
                 throwIfAborted: () => {
@@ -371,11 +478,43 @@ export class Agent {
             `Active provider: ${providerLabel(this.options.session.provider)}`,
             `Active model: ${this.options.session.model}`,
             `Allowed roots right now: ${this.options.pathPolicy.allowedRoots().join(", ")}`,
+            "",
+            "=== CORE EXECUTION LOOP (THINK -> ACT -> OBSERVE -> REFLECT) ===",
+            "1. You do not just run tools once and stop. You operate in a sustained, multi-step execution loop.",
+            "2. For every step, you MUST maintain a mental state of what you have tried, what succeeded, and what failed. Do not repeat the exact same failed actions.",
+            "3. Before executing any tool, explicitly evaluate whether it is the most strategic choice (e.g., use fast searches before reading entire files).",
+            "4. You MUST generate a concise, bulleted thinking summary and a structured plan (sub-tasks) at the beginning of your response to inform the user of your intent.",
+            "5. NEVER write code blocks in your markdown response as a way of delivering fixes. You MUST use 'replace_in_file' or 'write_file' tools to apply changes directly to the file system.",
+            "6. NEVER hallucinate or claim you ran a test or command (like 'npm start' or 'tsc') unless you actually executed it using the 'run_shell' tool.",
+            "",
+            "=== GOAL AWARENESS & LONG-HORIZON STABILITY ===",
+            "1. Deconstruct complex requests into explicit sub-tasks. Maintain an internal tracker of these tasks.",
+            "2. Do not treat generic 'inspect, decide, execute' as a real plan. Formulate specific, verifiable steps.",
+            "3. Continuously re-evaluate your progress toward the ultimate goal. If you are drifting, explicitly correct your course.",
+            "",
+            "=== FAILURE HANDLING & ADAPTIVE STRATEGY ===",
+            "1. Errors are not just noise; they are critical signals. If a tool call or compilation fails, deeply analyze WHY it failed.",
+            "2. You MUST NOT brute-force the same approach if it fails twice. Pivot to an entirely different strategy.",
+            "3. Persist memory of failures across your turn to prevent repeating mistakes.",
+            "",
+            "=== CONTEXT INTELLIGENCE & VERIFICATION DEPTH ===",
+            "1. Be ruthless about context. Only read files and lines that are strictly necessary.",
+            "2. You MUST empirically verify all changes. Do not claim a change works unless you have run a test, compiled the code, or executed a script that proves it.",
+            "3. Validate the environment and edge cases before declaring completion.",
+            "",
+            "=== COMPLETION CONFIDENCE ===",
+            "1. Before ending your turn, internally evaluate your Confidence Score (0-100%).",
+            "2. If your confidence is below 95%, you must gather more information, run more tests, or ask the user for clarification before stopping.",
+            "",
+            "=== BASE RULES ===",
             "When using tools, emit valid JSON object arguments only.",
             "Prefer smaller tool calls over giant payloads. Break large refactors and large apply_patch edits into multiple steps.",
             "When the user names a concrete file path, read that file directly with read_file or read_file_chunk before considering search_repo.",
-            "For non-trivial tasks, form a concise plan before acting and execute it incrementally.",
+            "If the user named concrete files or directories, stay scoped to them unless you have concrete evidence that broader repo context is required.",
+            "When active skill guidance is already injected below, use it directly. Do not call the skill tool again unless you need a specific deeper file that is not already summarized.",
             "If the target, scope, or acceptance criteria remain unclear after initial inspection, use ask_user before editing.",
+            "For source-file edits, prefer targeted diagnostics on the named file or changed file before and after editing when available.",
+            "Do not claim a build, test, or diagnostics check verified your change unless the tool output explicitly supports that claim.",
             "For Git-aware tasks, prefer the dedicated git tools over ad-hoc shell commands.",
             "For change review, start with git_review targeting the full worktree so you cover staged, unstaged, and untracked files.",
             "For branch review, compare against the merge base with the requested base branch instead of assuming HEAD~1 or the previous commit.",
@@ -389,12 +528,25 @@ export class Agent {
             lines.push("", rulesPrompt);
         }
         lines.push("", skillInventory);
+        if (this.turnTargets.explicitPaths.length > 0) {
+            lines.push("", [
+                "Concrete turn targets:",
+                `- named targets: ${formatTurnTargetList(this.turnTargets.explicitPaths, this.options.session.workspaceRoot)}`,
+                this.turnTargets.preferredRoot
+                    ? `- preferred root: ${formatTurnTargetList([this.turnTargets.preferredRoot], this.options.session.workspaceRoot)}`
+                    : "- preferred root: (none)"
+            ].join("\n"));
+        }
         if (this.turnSkillPrompt) {
             lines.push("", this.turnSkillPrompt);
         }
         if (this.turnDeliberationPrompt) {
             lines.push("", this.turnDeliberationPrompt);
         }
+        const executionPrompt = this.currentExecutionPrompt();
+        if (executionPrompt) {
+            lines.push("", executionPrompt);
+        }
         if (persistentMemory) {
             lines.push("", persistentMemory);
         }
@@ -403,6 +555,58 @@ export class Agent {
         }
         return lines.join("\n");
     }
+    currentExecutionPrompt() {
+        const lines = [];
+        if (this.turnChangedFiles.size > 0) {
+            lines.push(`- changed files: ${formatTurnTargetList([...this.turnChangedFiles], this.options.session.workspaceRoot)}`);
+        }
+        if (this.turnVerificationRecords.length > 0) {
+            const latest = this.turnVerificationRecords[this.turnVerificationRecords.length - 1];
+            lines.push(`- latest verification: ${latest.toolName} -> ${latest.trusted ? "trusted" : "untrusted"} / ${latest.passed ? "passed" : "failed"}`);
+            if (latest.reason) {
+                lines.push(`- verification note: ${latest.reason}`);
+            }
+        }
+        else if (this.turnChangedFiles.size > 0) {
+            lines.push("- verification: none yet");
+        }
+        if (this.turnNoOpEdits.length > 0) {
+            lines.push(`- no-op edit attempts: ${this.turnNoOpEdits.length}`);
+        }
+        if (lines.length === 0) {
+            return null;
+        }
+        return [
+            "Current turn execution state:",
+            ...lines,
+            "- Only summarize changes that actually happened in the changed files listed above.",
+            "- If verification is missing or untrusted, verify first or explicitly say so."
+        ].join("\n");
+    }
+    pendingVerificationPrompt() {
+        if (this.turnTaskKind !== "edit" || !this.turnPlanHasMutation || this.turnPlanHasVerification) {
+            return null;
+        }
+        if (this.turnVerificationNudges >= 3) {
+            return null;
+        }
+        const changedFiles = [...this.turnChangedFiles];
+        const targets = changedFiles.length > 0 ? changedFiles : this.turnTargets.explicitFiles;
+        const formattedTargets = formatTurnTargetList(targets, this.options.session.workspaceRoot);
+        if (this.turnVerificationNudges >= 2) {
+            return [
+                "SYSTEM ALERT: Trustworthy verification is still missing for this edit.",
+                `Changed or named targets: ${formattedTargets}.`,
+                "If you cannot verify in this environment, say that explicitly and do not claim the change is verified or all tests passed."
+            ].join("\n");
+        }
+        return [
+            "SYSTEM ALERT: You changed files but have not yet produced trustworthy verification for them.",
+            `Changed or named targets: ${formattedTargets}.`,
+            "Before finalizing, run get_diagnostics on the changed file or run a build/test/check command that actually validates the changed scope.",
+            "Do not claim success until verification is trustworthy."
+        ].join("\n");
+    }
     beginRequest() {
         const controller = new AbortController();
         this.activeRequestController = controller;
@@ -418,6 +622,111 @@ export class Agent {
             throw new AgentInterruptedError();
         }
     }
+    advanceCurrentPlan(stage, planOverride) {
+        const next = advanceTurnPlan(planOverride ?? this.turnPlan, stage);
+        this.setTurnPlan(next);
+    }
+    observeToolResult(toolCall, isMutating, result) {
+        const toolName = toolCall.function.name;
+        const phase = phaseForTool(toolName);
+        const meta = result.meta;
+        if (toolName === "update_task_state" && !result.isError) {
+            try {
+                const args = JSON.parse(toolCall.function.arguments);
+                if (Array.isArray(args.sub_tasks)) {
+                    const nextPlan = this.turnPlan ? cloneTurnPlan(this.turnPlan) : {
+                        taskKind: this.turnTaskKind,
+                        title: "Dynamic Plan",
+                        explanation: args.current_goal,
+                        steps: []
+                    };
+                    nextPlan.steps = args.sub_tasks.map((st) => ({
+                        id: st.id || "step-" + Math.random().toString(36).slice(2, 7),
+                        label: st.label,
+                        status: st.status
+                    }));
+                    this.setTurnPlan(nextPlan);
+                }
+            }
+            catch (e) {
+                // Ignore malformed arguments for plan updates
+            }
+        }
+        if (meta?.noOp) {
+            this.turnNoOpEdits.push(result.summary);
+        }
+        for (const changedFile of meta?.changedFiles ?? []) {
+            this.turnChangedFiles.add(changedFile);
+        }
+        if (meta?.verification) {
+            this.turnVerificationRecords.push({
+                ...meta.verification,
+                toolName
+            });
+        }
+        const inspected = meta?.inspectedPaths?.length ? meta.inspectedPaths : [];
+        if ((inspected.length > 0 || (phase === "inspecting" && !result.isError)) && !this.turnPlanInspected) {
+            this.turnPlanInspected = true;
+            this.setTurnPlan(updateTurnPlan(this.turnPlan, {
+                completed: ["inspect"],
+                inProgress: "decide"
+            }));
+        }
+        if (isMutating && !result.isError && (meta?.changedFiles?.length ?? 0) > 0) {
+            this.turnPlanHasMutation = true;
+            this.setTurnPlan(updateTurnPlan(this.turnPlan, {
+                completed: ["inspect", "decide"],
+                inProgress: "execute"
+            }));
+        }
+        if (meta?.verification &&
+            meta.verification.trusted &&
+            meta.verification.passed &&
+            this.turnPlanHasMutation) {
+            this.turnPlanHasVerification = true;
+            this.setTurnPlan(updateTurnPlan(this.turnPlan, {
+                completed: ["inspect", "decide", "execute"],
+                inProgress: "summarize"
+            }));
+        }
+    }
+    finalizeCurrentPlan() {
+        if (!this.turnPlan) {
+            return;
+        }
+        if (this.turnPlan.taskKind === "edit") {
+            if (this.turnPlanHasMutation && this.turnPlanHasVerification) {
+                this.advanceCurrentPlan("complete");
+                return;
+            }
+            if (this.turnPlanHasMutation) {
+                this.setTurnPlan(updateTurnPlan(this.turnPlan, {
+                    completed: ["inspect", "decide", "execute"],
+                    inProgress: null
+                }));
+                return;
+            }
+            if (this.turnPlanInspected) {
+                this.setTurnPlan(updateTurnPlan(this.turnPlan, {
+                    completed: ["inspect"],
+                    inProgress: "decide"
+                }));
+            }
+            return;
+        }
+        if (this.turnPlanInspected) {
+            this.advanceCurrentPlan("complete");
+        }
+    }
+    setTurnPlan(plan) {
+        this.turnPlan = cloneTurnPlan(plan);
+        const signature = this.turnPlan ? JSON.stringify(this.turnPlan) : "";
+        if (signature === this.turnPlanSignature) {
+            return;
+        }
+        this.turnPlanSignature = signature;
+        this.options.ui.updatePlan(cloneTurnPlan(this.turnPlan));
+    }
 }
 export class AgentInterruptedError extends Error {
     constructor() {