wave-agent-sdk 0.17.9 → 0.17.11

package/src/managers/backgroundTaskManager.ts

@@ -68,7 +68,7 @@ export class BackgroundTaskManager {
       stdio: "pipe",
       detached: true,
       cwd: this.workdir,
-      env: this.container.get<Record<string, string>>("MergedEnv") || {
+      env: {
         ...process.env,
       },
     });

package/src/managers/bangManager.ts

@@ -48,7 +48,7 @@ export class BangManager {
         shell: true,
         stdio: "pipe",
         cwd: this.workdir,
-        env: this.container.get<Record<string, string>>("MergedEnv") || {
+        env: {
           ...process.env,
         },
       });

package/src/managers/hookManager.ts

@@ -988,9 +988,9 @@ export class HookManager {
       transcriptPath,
       cwd: this.workdir,
       endSource: source,
-      env:
-        this.container.get<Record<string, string>>("MergedEnv") ||
-        (process.env as Record<string, string>),
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
     };
 
     const results = await this.executeHooks("SessionEnd", context);
@@ -1060,9 +1060,9 @@ export class HookManager {
       transcriptPath,
       cwd: this.workdir,
       compactSummary,
-      env:
-        this.container.get<Record<string, string>>("MergedEnv") ||
-        (process.env as Record<string, string>),
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
     };
 
     const results = await this.executeHooks("PostCompact", context);

package/src/managers/mcpManager.ts

@@ -432,11 +432,9 @@ export class McpManager {
             `MCP server ${name} with type "stdio" requires a 'command'`,
           );
         }
-        const agentEnv =
-          this.container.get<Record<string, string>>("MergedEnv") ||
-          (process.env as Record<string, string>);
+
         const env: Record<string, string> = {
-          ...agentEnv,
+          ...(process.env as Record<string, string>),
           ...(server.config.env || {}),
         };
 

package/src/managers/messageManager.ts

@@ -308,14 +308,6 @@ export class MessageManager {
         return;
       }
 
-      // Filter out meta messages
-      const meaningfulMessages = unsavedMessages.filter((m) => !m.isMeta);
-
-      if (meaningfulMessages.length === 0) {
-        // No meaningful messages to save
-        return;
-      }
-
       // Create session if needed (only when we have messages to save)
       if (this.savedMessageCount === 0) {
         // This is the first time saving messages, so create the session
@@ -325,7 +317,7 @@ export class MessageManager {
       // Use JSONL format for new sessions
       await appendMessages(
         this.sessionId,
-        meaningfulMessages, // Only append meaningful messages
+        unsavedMessages,
         this.workdir,
         this.sessionType,
         this.rootSessionId,

package/src/managers/toolManager.ts

@@ -356,24 +356,12 @@ class ToolManager {
   }): ChatCompletionFunctionTool[] {
     const permissionManager =
       this.container.get<PermissionManager>("PermissionManager");
-    const effectivePermissionMode = this.getPermissionMode();
     const builtInToolsConfig = Array.from(this.toolsRegistry.values())
       .filter((tool) => {
         // If tool is explicitly denied by name in permission rules, filter it out
         if (permissionManager?.isToolDenied(tool.name)) {
           return false;
         }
-        if (effectivePermissionMode === "bypassPermissions") {
-          if (tool.name === "ExitPlanMode") {
-            return false;
-          }
-        }
-        if (tool.name === "ExitPlanMode") {
-          return effectivePermissionMode === "plan";
-        }
-        if (tool.name === "EnterPlanMode") {
-          return effectivePermissionMode !== "plan";
-        }
         return true;
       })
       .map((tool) => {
@@ -408,6 +396,24 @@ class ToolManager {
     return Array.from(this.toolsRegistry.values());
   }
 
+  /**
+   * Check whether a tool is safe to execute in parallel with other tools.
+   * Built-in tools default to safe (parallel); Edit and Write opt out.
+   * MCP tools are conservatively non-safe (can't inspect side effects).
+   */
+  public isConcurrencySafe(name: string): boolean {
+    // MCP tools are conservatively non-safe
+    if (this.mcpManager.isMcpTool(name)) {
+      return false;
+    }
+    const plugin = this.toolsRegistry.get(name);
+    if (plugin) {
+      return plugin.isConcurrencySafe ?? true;
+    }
+    // Unknown tools are conservatively non-safe
+    return false;
+  }
+
   /**
    * Get the current permission mode
    */

package/src/services/aiService.ts

@@ -12,8 +12,7 @@ import { addOnceAbortListener } from "../utils/abortUtils.js";
 import type { GatewayConfig, ModelConfig } from "../types/index.js";
 import { ConfigurationError, CONFIG_ERRORS } from "../types/index.js";
 import {
-  transformMessagesForClaudeCache,
-  addCacheControlToLastTool,
+  transformMessagesForExplicitCache,
   supportsPromptCaching,
   extendUsageWithCacheMetrics,
   type ClaudeUsage,
@@ -282,15 +281,10 @@ export async function callAgent(
     processedTools = tools;
 
     if (supportsPromptCaching(currentModel)) {
-      openaiMessages = transformMessagesForClaudeCache(
+      openaiMessages = transformMessagesForExplicitCache(
         openaiMessages,
         currentModel,
       );
-
-      // Apply cache control to tools separately
-      if (tools && tools.length > 0) {
-        processedTools = addCacheControlToLastTool(tools);
-      }
     }
 
     // Get model configuration - use injected modelConfig with optional override
@@ -845,6 +839,7 @@ export async function compactMessages(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
+    fastModelConfig: _fastModelConfig,
     ...extraParams
   } = modelConfig;
   void _model;
@@ -852,10 +847,16 @@ export async function compactMessages(
   void _maxTokens;
   void _permissionMode;
 
+  // When a fast model override is provided, use the fast model's hyperparams
+  // (if configured); otherwise fall back to the agent model's extraParams.
+  const activeExtraParams = options.model
+    ? _fastModelConfig || {}
+    : extraParams;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 8192,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   try {
@@ -961,6 +962,7 @@ export async function processWebContent(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
+    fastModelConfig: _fastModelConfig,
     ...extraParams
   } = modelConfig;
   void _model;
@@ -968,10 +970,16 @@ export async function processWebContent(
   void _maxTokens;
   void _permissionMode;
 
+  // When a fast model override is provided, use the fast model's hyperparams
+  // (if configured); otherwise fall back to the agent model's extraParams.
+  const activeExtraParams = options.model
+    ? _fastModelConfig || {}
+    : extraParams;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   try {
@@ -1177,17 +1185,20 @@ export async function evaluateGoal(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
-    ...extraParams
+    fastModelConfig: _fastModelConfig,
   } = modelConfig;
   void _model;
   void _fastModel;
   void _maxTokens;
   void _permissionMode;
 
+  // evaluateGoal always uses the fast model; use its hyperparams if configured.
+  const activeExtraParams = _fastModelConfig || {};
+
   const openaiModelConfig = getModelConfig(model, {
     temperature: 0,
     max_tokens: 200,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   // Strip images from messages to reduce token usage (same as compact)

package/src/services/authService.ts

@@ -19,16 +19,12 @@ import * as os from "os";
 import { randomBytes } from "crypto";
 import { createServer, Server } from "http";
 import { URL } from "url";
-import { execFile } from "child_process";
-import { promisify } from "util";
 import type { AuthConfig, AuthUser, TokenResponse } from "../types/auth.js";
 import { logger } from "../utils/globalLogger.js";
 
 /** Persistent anonymous ID for telemetry fallback when SSO is not authenticated. */
 let _anonymousId: string | undefined;
 
-const execFileAsync = promisify(execFile);
-
 export class AuthService {
   private static instance: AuthService;
   private _serverUrl: string | undefined;
@@ -274,15 +270,8 @@ export class AuthService {
         const callbackUrl = `http://127.0.0.1:${port}`;
         const authUrl = `${serverUrl}/login?callback_url=${encodeURIComponent(callbackUrl)}`;
 
-        // Notify caller of the auth URL
+        // Notify caller of the auth URL; caller is responsible for opening browser
         options?.onAuthUrl?.(authUrl);
-
-        // Try to open browser; if it fails, keep server alive for manual visit
-        try {
-          await this.openBrowser(authUrl);
-        } catch {
-          // Browser not available — server stays alive
-        }
       });
 
       // If manual code reading is provided, race between server callback and user input
@@ -315,25 +304,6 @@ export class AuthService {
     });
   }
 
-  private async openBrowser(url: string): Promise<void> {
-    const platform = process.platform;
-    let command: string;
-    let args: string[];
-
-    if (platform === "darwin") {
-      command = "open";
-      args = [url];
-    } else if (platform === "win32") {
-      command = "cmd";
-      args = ["/c", "start", "", url];
-    } else {
-      command = "xdg-open";
-      args = [url];
-    }
-
-    await execFileAsync(command, args);
-  }
-
   isSSOAuthenticated(): boolean {
     const config = this.loadAuth();
     if (!config.SSO_TOKEN) return false;

package/src/services/configurationService.ts

@@ -532,6 +532,27 @@ export class ConfigurationService {
       permissionMode: permissionMode ?? this.options.permissionMode,
     };
 
+    // Resolve fast model hyperparams from models[fastModel], stripping
+    // structural fields so only hyperparameters remain. Set on baseConfig
+    // before the modelSpecificConfig spread so it isn't overwritten.
+    const fastModelConfigSource =
+      resolvedFastModel &&
+      this.currentConfiguration?.models?.[resolvedFastModel];
+    if (fastModelConfigSource) {
+      const {
+        model: _fm,
+        fastModel: _ffm,
+        maxTokens: _fmt,
+        permissionMode: _fpm,
+        ...fastHyperparams
+      } = fastModelConfigSource;
+      void _fm;
+      void _ffm;
+      void _fmt;
+      void _fpm;
+      baseConfig.fastModelConfig = fastHyperparams;
+    }
+
     // Merge model-specific settings from configuration
     const modelSpecificConfig =
       resolvedAgentModel &&

package/src/services/fileWatcher.ts

@@ -22,6 +22,8 @@ export interface FileWatcherConfig {
   maxRetries: number; // Default: 3
   fallbackPolling: boolean; // Default: false
   ignoreTempFiles: boolean; // Default: true
+  depth: number; // default: 5
+  ignored: string[]; // default: ['**/node_modules/**', '**/.git/**', '**/*.swp', '**/*~']
 }
 
 export interface FileWatcherStatus {
@@ -59,6 +61,8 @@ export class FileWatcherService extends EventEmitter {
       maxRetries: 3,
       fallbackPolling: false,
       ignoreTempFiles: true,
+      depth: 5,
+      ignored: ["**/node_modules/**", "**/.git/**", "**/*.swp", "**/*~"],
       ...config,
     };
   }
@@ -185,6 +189,8 @@ export class FileWatcherService extends EventEmitter {
         this.globalWatcher = chokidar.watch([], {
           persistent: true,
           ignoreInitial: true,
+          depth: entry.config.depth,
+          ignored: entry.config.ignored,
           awaitWriteFinish: {
             stabilityThreshold: entry.config.stabilityThreshold,
             pollInterval: entry.config.pollInterval,
@@ -262,7 +268,15 @@ export class FileWatcherService extends EventEmitter {
 
     this.globalWatcher.on("error", (err: unknown) => {
       const error = err instanceof Error ? err : new Error(String(err));
-      this.logger?.error(`FileWatcher: File watcher error: ${error.message}`);
+      const isEMFILE = (error as NodeJS.ErrnoException).code === "EMFILE";
+      if (isEMFILE) {
+        this.logger?.warn(
+          "FileWatcher: Too many open files (EMFILE). " +
+            "Consider increasing the limit: `ulimit -n 10240` (macOS) or `ulimit -n 65536` (Linux).",
+        );
+      } else {
+        this.logger?.error(`FileWatcher: File watcher error: ${error.message}`);
+      }
       this.emit("watcherError", error);
     });
   }

package/src/services/jsonlHandler.ts

@@ -229,19 +229,7 @@ export class JsonlHandler {
     // Extract filename from path
     const filename = filePath.split("/").pop() || "";
 
-    // New timestamp-prefixed format
-    const newSubagentMatch = filename.match(
-      /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/,
-    );
-    if (newSubagentMatch) {
-      return { sessionId: newSubagentMatch[1], sessionType: "subagent" };
-    }
-    const newMainMatch = filename.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
-    if (newMainMatch) {
-      return { sessionId: newMainMatch[1], sessionType: "main" };
-    }
-
-    // Old UUID format (backward compat)
+    // Check if it's a subagent session
     const subagentMatch = filename.match(
       /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
     );
@@ -252,6 +240,7 @@ export class JsonlHandler {
       };
     }
 
+    // Check if it's a main session
     const mainMatch = filename.match(
       /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
     );
@@ -271,26 +260,18 @@ export class JsonlHandler {
    * @returns True if valid, false otherwise
    */
   isValidSessionFilename(filename: string): boolean {
-    // New timestamp-prefixed format patterns
-    const newFormatPattern = /^(\d{14}-[0-9a-f]{8})\.jsonl$/;
-    const newSubagentPattern = /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/;
-    // Old UUID format patterns (backward compat)
+    // UUID validation patterns
     const uuidPattern =
       /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
     const subagentPattern =
       /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
 
-    return (
-      newFormatPattern.test(filename) ||
-      newSubagentPattern.test(filename) ||
-      uuidPattern.test(filename) ||
-      subagentPattern.test(filename)
-    );
+    return uuidPattern.test(filename) || subagentPattern.test(filename);
   }
 
   /**
    * Generate simple filename for sessions
-   * @param sessionId - Session identifier (timestamp-prefixed or legacy UUID format)
+   * @param sessionId - UUID session identifier
    * @param sessionType - Type of session ("main" or "subagent")
    * @returns Generated filename
    */
@@ -298,11 +279,10 @@ export class JsonlHandler {
     sessionId: string,
     sessionType: "main" | "subagent",
   ): string {
-    // Validate sessionId is either new timestamp-prefixed format or legacy UUID
-    const newFormatPattern = /^\d{14}-[0-9a-f]{8}$/;
+    // Validate sessionId is a valid UUID
     const uuidPattern =
       /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-    if (!newFormatPattern.test(sessionId) && !uuidPattern.test(sessionId)) {
+    if (!uuidPattern.test(sessionId)) {
       throw new Error(`Invalid session ID format: ${sessionId}`);
     }
 

package/src/services/session.ts

@@ -63,43 +63,11 @@ export interface SessionIndex {
 }
 
 /**
- * Generate a new session ID with a timestamp prefix for sortability
- * Format: {YYYYMMDDHHmmss}-{8hex} (e.g. 20260527143025-a1b2c3d4)
- * @returns Timestamp-prefixed session ID string
+ * Generate a new session ID using Node.js native crypto.randomUUID()
+ * @returns UUID string for session identification
  */
 export function generateSessionId(): string {
-  const now = new Date();
-  const ts = [
-    now.getFullYear(),
-    String(now.getMonth() + 1).padStart(2, "0"),
-    String(now.getDate()).padStart(2, "0"),
-    String(now.getHours()).padStart(2, "0"),
-    String(now.getMinutes()).padStart(2, "0"),
-    String(now.getSeconds()).padStart(2, "0"),
-  ].join("");
-  const shortId = randomUUID().slice(0, 8);
-  return `${ts}-${shortId}`;
-}
-
-/**
- * Parse the timestamp prefix from a session ID back into a Date
- * Format: {YYYYMMDDHHmmss}-{8hex} (e.g. 20260527143025-a1b2c3d4)
- * @returns Date from the session ID timestamp prefix
- */
-export function parseSessionIdTimestamp(sessionId: string): Date {
-  const match = sessionId.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/);
-  if (!match) {
-    return new Date(); // Fallback to now for legacy UUID-format session IDs
-  }
-  const [, year, month, day, hour, minute, second] = match;
-  return new Date(
-    Number(year),
-    Number(month) - 1,
-    Number(day),
-    Number(hour),
-    Number(minute),
-    Number(second),
-  );
+  return randomUUID();
 }
 
 /**
@@ -293,9 +261,9 @@ export async function appendMessages(
       (await getFirstMessageContent(sessionId, workdir)) || undefined;
   }
 
-  // Derive createdAt from session ID timestamp if not in index
+  // Derive createdAt from session ID if not in index
   if (!createdAt) {
-    createdAt = new Date(parseSessionIdTimestamp(sessionId));
+    createdAt = new Date();
   }
 
   await updateSessionIndex(projectDir.encodedPath, {
@@ -520,17 +488,15 @@ export async function listSessionsFromJsonl(
       try {
         const filePath = join(projectDir.encodedPath, file);
 
-        // Validate main session filename format (new timestamp format or legacy UUID)
-        const newFormatMatch = file.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
+        // Validate main session filename format (UUID.jsonl)
         const uuidMatch = file.match(
           /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
         );
-        const match = newFormatMatch || uuidMatch;
-        if (!match) {
+        if (!uuidMatch) {
           continue; // Skip invalid filenames
         }
 
-        const sessionId = match[1];
+        const sessionId = uuidMatch[1];
 
         // PERFORMANCE OPTIMIZATION: Only read the last message for timestamps and tokens
         const jsonlHandler = new JsonlHandler();
@@ -557,7 +523,7 @@ export async function listSessionsFromJsonl(
           sessionType: "main",
           subagentType: undefined, // No longer stored in metadata
           workdir: projectDir.originalPath,
-          createdAt: new Date(parseSessionIdTimestamp(sessionId)),
+          createdAt: new Date(),
           lastActiveAt,
           latestTotalTokens: lastMessage?.usage
             ? extractLatestTotalTokens([lastMessage])
@@ -720,24 +686,17 @@ export async function cleanupExpiredSessionsFromJsonl(
             );
             const indexContent = await fs.readFile(indexPath, "utf8");
             const index = JSON.parse(indexContent) as SessionIndex;
-            // New timestamp-prefixed format patterns
-            const newMainMatch = file.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
-            const newSubagentMatch = file.match(
-              /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/,
-            );
-            // Old UUID format patterns (backward compat)
             const uuidMatch = file.match(
-              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
             );
             const subagentMatch = file.match(
-              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
             );
-            const sessionId =
-              newMainMatch?.[1] ??
-              newSubagentMatch?.[1] ??
-              uuidMatch?.[1] ??
-              subagentMatch?.[1] ??
-              null;
+            const sessionId = uuidMatch
+              ? uuidMatch[1]
+              : subagentMatch
+                ? subagentMatch[1]
+                : null;
 
             if (sessionId && index.sessions[sessionId]) {
               delete index.sessions[sessionId];

package/src/tools/bashTool.ts

@@ -240,7 +240,9 @@ The working directory persists between commands. Try to maintain your current wo
         stdio: "pipe",
         detached: true,
         cwd: context.workdir,
-        env: context.env || { ...process.env },
+        env: {
+          ...process.env,
+        },
       });
 
       let outputBuffer = "";

package/src/tools/editTool.ts

@@ -1,4 +1,5 @@
-import { readFile, writeFile } from "fs/promises";
+import { readFile, writeFile, stat } from "fs/promises";
+import { createHash } from "crypto";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
@@ -21,6 +22,7 @@ function formatCompactParams(
  */
 export const editTool: ToolPlugin = {
   name: EDIT_TOOL_NAME,
+  isConcurrencySafe: false,
   formatCompactParams,
   prompt: () =>
     `Performs exact string replacements in files.
@@ -137,6 +139,22 @@ Usage:
         };
       }
 
+      // Staleness check: file must not have been modified since last Read
+      if (context.readFileState) {
+        const state = context.readFileState.get(resolvedPath);
+        if (state) {
+          const currentStats = await stat(resolvedPath);
+          if (currentStats.mtime.getTime() !== state.mtime) {
+            return {
+              success: false,
+              content: "",
+              error:
+                "File has been unexpectedly modified since last read. Read it again before editing it.",
+            };
+          }
+        }
+      }
+
       // Normalize line endings for matching
       const normalizedContent = originalContent.replace(/\r\n/g, "\n");
       const normalizedOldString = oldString.replace(/\r\n/g, "\n");
@@ -240,6 +258,18 @@ Usage:
         };
       }
 
+      // Update readFileState so subsequent serialized edits see fresh state
+      if (context.readFileState) {
+        const newStats = await stat(resolvedPath);
+        const hash = createHash("sha256").update(newContent).digest("hex");
+        context.readFileState.set(resolvedPath, {
+          mtime: newStats.mtime.getTime(),
+          hash,
+          offset: undefined,
+          limit: undefined,
+        });
+      }
+
       const shortResult = replaceAll
         ? `Replaced ${replacementCount} instances`
         : "Text replaced successfully";

package/src/tools/enterPlanMode.ts

@@ -49,6 +49,15 @@ export const enterPlanModeTool: ToolPlugin = {
     context: ToolContext,
   ): Promise<ToolResult> => {
     try {
+      // Runtime guard: tool is always visible but only works outside plan mode
+      if (context.permissionMode === "plan") {
+        return {
+          success: false,
+          content: "Already in plan mode. Use ExitPlanMode to exit.",
+          error: "Already in plan mode",
+        };
+      }
+
       if (!context.permissionManager) {
         return {
           success: false,

package/src/tools/exitPlanMode.ts

@@ -52,6 +52,16 @@ Ensure your plan is complete and unambiguous:
     context: ToolContext,
   ): Promise<ToolResult> => {
     try {
+      // Runtime guard: tool is always visible but only works in plan mode
+      if (context.permissionMode !== "plan") {
+        return {
+          success: false,
+          content:
+            "Not in plan mode. ExitPlanMode can only be used when actively in plan mode.",
+          error: "Not in plan mode",
+        };
+      }
+
       if (!context.permissionManager) {
         return {
           success: false,