wave-agent-sdk 0.17.6 → 0.17.7

package/dist/managers/slashCommandManager.js

@@ -13,7 +13,6 @@ export class SlashCommandManager {
         this.workdir = options.workdir;
     }
     initialize() {
-        this.initializeBuiltinCommands();
         this.loadCustomCommands();
         // Listen for skill refreshes and update skill commands
         const skillManager = this.container.get("SkillManager");
@@ -29,181 +28,12 @@ export class SlashCommandManager {
     get aiManager() {
         return this.container.get("AIManager");
     }
-    get backgroundTaskManager() {
-        return this.container.get("BackgroundTaskManager");
-    }
-    get taskManager() {
-        return this.container.get("TaskManager");
-    }
     get skillManager() {
         return this.container.get("SkillManager");
     }
     get subagentManager() {
         return this.container.get("SubagentManager");
     }
-    get memoryService() {
-        return this.container.get("MemoryService");
-    }
-    get hookManager() {
-        return this.container.get("HookManager");
-    }
-    get goalManager() {
-        return this.container.get("GoalManager");
-    }
-    initializeBuiltinCommands() {
-        // Register built-in clear command
-        this.registerCommand({
-            id: "clear",
-            name: "clear",
-            description: "Clear conversation history and reset session",
-            immediate: true,
-            handler: async () => {
-                this.aiManager.abortAIMessage();
-                // Clear any active goal
-                this.goalManager?.clearGoal();
-                // Capture old session info before clearing
-                const oldSessionId = this.messageManager.getSessionId();
-                const transcriptPath = this.messageManager.getTranscriptPath();
-                // Run SessionEnd hooks (cleanup before clear)
-                if (this.hookManager) {
-                    try {
-                        await this.hookManager.executeSessionEndHooks("clear", oldSessionId, transcriptPath);
-                    }
-                    catch (error) {
-                        logger?.warn(`SessionEnd hooks on clear failed: ${error.message}`);
-                    }
-                }
-                // Clear messages and generate new session
-                this.messageManager.clearMessages();
-                this.memoryService.clearCache();
-                await this.taskManager.syncWithSession();
-                // Run SessionStart hooks (restore context for new session)
-                if (this.hookManager) {
-                    try {
-                        const newSessionId = this.messageManager.getSessionId();
-                        const sessionStartResult = await this.hookManager.executeSessionStartHooks("clear", newSessionId, this.messageManager.getTranscriptPath());
-                        // Inject additionalContext as a meta user message
-                        if (sessionStartResult.additionalContext) {
-                            this.messageManager.addUserMessage({
-                                content: `<system-reminder>\nSessionStart hook additional context: ${sessionStartResult.additionalContext}\n</system-reminder>`,
-                                isMeta: true,
-                            });
-                        }
-                        // Inject initialUserMessage as a meta user message
-                        if (sessionStartResult.initialUserMessage) {
-                            this.messageManager.addUserMessage({
-                                content: sessionStartResult.initialUserMessage,
-                                isMeta: true,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        logger?.warn(`SessionStart hooks on clear failed: ${error.message}`);
-                    }
-                }
-            },
-        });
-        // Register built-in compact command
-        this.registerCommand({
-            id: "compact",
-            name: "compact",
-            description: "Compact conversation history to reduce context usage",
-            immediate: true,
-            handler: async (args, signal) => {
-                this.aiManager.abortAIMessage();
-                const customInstructions = args?.trim() || undefined;
-                await this.aiManager.compactConversation({
-                    customInstructions,
-                    abortSignal: signal,
-                });
-            },
-        });
-        // Register built-in goal command
-        this.registerCommand({
-            id: "goal",
-            name: "goal",
-            description: "Set, check, or clear an autonomous goal for the session",
-            immediate: (args) => {
-                const trimmed = args?.trim() ?? "";
-                return (!trimmed ||
-                    ["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed));
-            },
-            handler: async (args) => {
-                const goalManager = this.goalManager;
-                if (!goalManager) {
-                    this.messageManager.addUserMessage({
-                        content: "Goal manager is not available",
-                        isMeta: true,
-                    });
-                    return;
-                }
-                const trimmed = args?.trim() ?? "";
-                // Clear aliases
-                if (["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed)) {
-                    if (goalManager.isGoalActive()) {
-                        goalManager.clearGoal();
-                        this.messageManager.addUserMessage({
-                            content: "<system-reminder>Goal cleared.</system-reminder>",
-                            isMeta: true,
-                        });
-                    }
-                    else {
-                        this.messageManager.addUserMessage({
-                            content: "<system-reminder>No active goal to clear.</system-reminder>",
-                            isMeta: true,
-                        });
-                    }
-                    return;
-                }
-                // Show status
-                if (!trimmed) {
-                    if (goalManager.isGoalActive()) {
-                        this.messageManager.addUserMessage({
-                            content: `<system-reminder>${goalManager.getStatusString()}</system-reminder>`,
-                            isMeta: true,
-                        });
-                    }
-                    else {
-                        this.messageManager.addUserMessage({
-                            content: "<system-reminder>No active goal. Use /goal <condition> to set one.</system-reminder>",
-                            isMeta: true,
-                        });
-                    }
-                    return;
-                }
-                // Check plan mode
-                const permissionMode = this.container.has("PermissionMode")
-                    ? this.container.get("PermissionMode")
-                    : undefined;
-                if (permissionMode === "plan") {
-                    this.messageManager.addUserMessage({
-                        content: "<system-reminder>Cannot set a goal in plan mode. Exit plan mode first.</system-reminder>",
-                        isMeta: true,
-                    });
-                    return;
-                }
-                // Set goal
-                try {
-                    goalManager.setGoal(trimmed);
-                    this.messageManager.addUserMessage({
-                        content: `<system-reminder>Goal set: ${trimmed}. The agent will work autonomously until this goal is achieved.</system-reminder>`,
-                        isMeta: true,
-                    });
-                    // Add the goal as a user directive to start working
-                    this.messageManager.addUserMessage({
-                        content: trimmed,
-                    });
-                    this.aiManager.sendAIMessage();
-                }
-                catch (error) {
-                    this.messageManager.addUserMessage({
-                        content: `<system-reminder>Failed to set goal: ${error.message}</system-reminder>`,
-                        isMeta: true,
-                    });
-                }
-            },
-        });
-    }
     /**
      * Load custom commands from filesystem
      */

package/dist/managers/toolManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolManager.d.ts","sourceRoot":"","sources":["../../src/managers/toolManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA6B7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAIlD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wDAAwD;IACxD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;GAKG;AACH,cAAM,WAAW;IACf,OAAO,CAAC,aAAa,CAAiC;IACtD,OAAO,CAAC,KAAK,CAAC,CAAW;IACzB,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,SAAS,CAAY;gBAEjB,OAAO,EAAE,kBAAkB;IAMvC,OAAO,KAAK,UAAU,GAErB;IAED;;OAEG;IACI,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAIvC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,sBAAsB,IAAI,IAAI;IA0CrC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;;;;;;;;;;;OAYG;IACG,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IAqJtB,IAAI,IAAI,UAAU,EAAE;IAYpB,cAAc,CAAC,OAAO,CAAC,EAAE;QACvB,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;QAC7C,eAAe,CAAC,EAAE,aAAa,EAAE,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,GAAG,0BAA0B,EAAE;IAuDhC;;OAEG;IACI,QAAQ,IAAI,UAAU,EAAE;IAI/B;;OAEG;IACI,iBAAiB,IAAI,cAAc;IAa1C;;;OAGG;IACI,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAIpD;;OAEG;IACI,oBAAoB,IAAI,iBAAiB,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,IACjB,OAAO,4BAA4B,EAAE,WAAW,GAChD,SAAS;CAKd;AAGD,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"toolManager.d.ts","sourceRoot":"","sources":["../../src/managers/toolManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA6B7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAIlD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wDAAwD;IACxD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;GAKG;AACH,cAAM,WAAW;IACf,OAAO,CAAC,aAAa,CAAiC;IACtD,OAAO,CAAC,KAAK,CAAC,CAAW;IACzB,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,SAAS,CAAY;gBAEjB,OAAO,EAAE,kBAAkB;IAMvC,OAAO,KAAK,UAAU,GAErB;IAED;;OAEG;IACI,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAIvC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,sBAAsB,IAAI,IAAI;IA0CrC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;;;;;;;;;;;OAYG;IACG,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IAqJtB,IAAI,IAAI,UAAU,EAAE;IAYpB,cAAc,CAAC,OAAO,CAAC,EAAE;QACvB,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;QAC7C,eAAe,CAAC,EAAE,aAAa,EAAE,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,GAAG,0BAA0B,EAAE;IAgDhC;;OAEG;IACI,QAAQ,IAAI,UAAU,EAAE;IAI/B;;OAEG;IACI,iBAAiB,IAAI,cAAc;IAa1C;;;OAGG;IACI,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAIpD;;OAEG;IACI,oBAAoB,IAAI,iBAAiB,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,IACjB,OAAO,4BAA4B,EAAE,WAAW,GAChD,SAAS;CAKd;AAGD,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/managers/toolManager.js

@@ -272,9 +272,7 @@ class ToolManager {
                 return false;
             }
             if (effectivePermissionMode === "bypassPermissions") {
-                if (tool.name === "ExitPlanMode" ||
-                    tool.name === "AskUserQuestion" ||
-                    tool.name === "EnterPlanMode") {
+                if (tool.name === "ExitPlanMode") {
                     return false;
                 }
             }
@@ -282,8 +280,7 @@ class ToolManager {
                 return effectivePermissionMode === "plan";
             }
             if (tool.name === "EnterPlanMode") {
-                return (effectivePermissionMode !== "plan" &&
-                    effectivePermissionMode !== "bypassPermissions");
+                return effectivePermissionMode !== "plan";
             }
             return true;
         })

package/dist/prompts/planModeReminders.d.ts

@@ -1,6 +1,5 @@
 export declare function wrapInSystemReminder(content: string): string;
 export declare function buildPlanModeReminder(planFilePath: string, planExists: boolean, isSubagent?: boolean): string;
-export declare function buildPlanModeSparseReminder(planFilePath: string): string;
 export declare function buildPlanModeReEntryReminder(planFilePath: string): string;
 export declare function buildExitedPlanModeReminder(planFilePath?: string, planExists?: boolean): string;
 //# sourceMappingURL=planModeReminders.d.ts.map

package/dist/prompts/planModeReminders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planModeReminders.d.ts","sourceRoot":"","sources":["../../src/prompts/planModeReminders.ts"],"names":[],"mappings":"AAYA,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,OAAO,EACnB,UAAU,GAAE,OAAe,GAC1B,MAAM,CAsFR;AAED,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAIxE;AAED,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAczE;AAED,wBAAgB,2BAA2B,CACzC,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,OAAO,GACnB,MAAM,CAIR"}
+{"version":3,"file":"planModeReminders.d.ts","sourceRoot":"","sources":["../../src/prompts/planModeReminders.ts"],"names":[],"mappings":"AAYA,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,OAAO,EACnB,UAAU,GAAE,OAAe,GAC1B,MAAM,CAsFR;AAED,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAQzE;AAED,wBAAgB,2BAA2B,CACzC,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,OAAO,GACnB,MAAM,CAIR"}

package/dist/prompts/planModeReminders.js

@@ -87,23 +87,14 @@ This is critical - your turn should only end with either using the ${ASK_USER_QU
 
 NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications using the ${ASK_USER_QUESTION_TOOL_NAME} tool. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.`);
 }
-export function buildPlanModeSparseReminder(planFilePath) {
-    return wrapInSystemReminder(`Plan mode still active (see full instructions earlier in conversation). Read-only except plan file at ${planFilePath}. End turns with ${ASK_USER_QUESTION_TOOL_NAME} or ${EXIT_PLAN_MODE_TOOL_NAME}.`);
-}
 export function buildPlanModeReEntryReminder(planFilePath) {
     return wrapInSystemReminder(`## Re-entering Plan Mode
 
-You are returning to plan mode after having previously exited it. A plan file exists at ${planFilePath} from your previous planning session.
+You are returning to plan mode. A plan file exists at ${planFilePath} from your previous session.
 
-**Before proceeding with any new planning, you should:**
 1. Read the existing plan file to understand what was previously planned
-2. Evaluate the user's current request against that plan
-3. Decide how to proceed:
-   - **Different task**: If the user's request is for a different task—even if it's similar or related—start fresh by overwriting the existing plan
-   - **Same task, continuing**: If this is explicitly a continuation or refinement of the exact same task, modify the existing plan while cleaning up outdated or irrelevant sections
-4. Continue on with the plan process and most importantly you should always edit the plan file one way or the other before calling ${EXIT_PLAN_MODE_TOOL_NAME}
-
-Treat this as a fresh planning session. Do not assume the existing plan is relevant without evaluating it first.`);
+2. Decide: if the user's request is a different task, start fresh by overwriting the plan; if it's a continuation, modify the existing plan
+3. Edit the plan file as needed, then call ${EXIT_PLAN_MODE_TOOL_NAME}`);
 }
 export function buildExitedPlanModeReminder(planFilePath, planExists) {
     return wrapInSystemReminder(`## Exited Plan Mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.17.6",
+  "version": "0.17.7",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -685,7 +685,152 @@ export class Agent {
   }
 
   public async clearMessages(): Promise<void> {
-    await this.slashCommandManager.executeCommand("clear");
+    this.aiManager.abortAIMessage();
+
+    // Clear any active goal
+    this.goalManager.clearGoal();
+
+    // Capture old session info before clearing
+    const oldSessionId = this.messageManager.getSessionId();
+    const transcriptPath = this.messageManager.getTranscriptPath();
+
+    // Run SessionEnd hooks (cleanup before clear)
+    try {
+      await this.hookManager.executeSessionEndHooks(
+        "clear",
+        oldSessionId,
+        transcriptPath,
+      );
+    } catch (error) {
+      this.logger?.warn(
+        `SessionEnd hooks on clear failed: ${(error as Error).message}`,
+      );
+    }
+
+    // Clear messages and generate new session
+    this.messageManager.clearMessages();
+    const memoryService =
+      this.container.get<import("./services/memory.js").MemoryService>(
+        "MemoryService",
+      );
+    memoryService?.clearCache();
+    await this.taskManager.syncWithSession();
+
+    // Run SessionStart hooks (restore context for new session)
+    try {
+      const newSessionId = this.messageManager.getSessionId();
+      const sessionStartResult =
+        await this.hookManager.executeSessionStartHooks(
+          "clear",
+          newSessionId,
+          this.messageManager.getTranscriptPath(),
+        );
+
+      // Inject additionalContext as a meta user message
+      if (sessionStartResult.additionalContext) {
+        this.messageManager.addUserMessage({
+          content: `<system-reminder>\nSessionStart hook additional context: ${sessionStartResult.additionalContext}\n</system-reminder>`,
+          isMeta: true,
+        });
+      }
+
+      // Inject initialUserMessage as a meta user message
+      if (sessionStartResult.initialUserMessage) {
+        this.messageManager.addUserMessage({
+          content: sessionStartResult.initialUserMessage,
+          isMeta: true,
+        });
+      }
+    } catch (error) {
+      this.logger?.warn(
+        `SessionStart hooks on clear failed: ${(error as Error).message}`,
+      );
+    }
+
+    await this.messageManager.saveSession();
+  }
+
+  /**
+   * Compact conversation history to reduce context usage
+   * @param customInstructions - Optional custom instructions for compaction
+   */
+  public async compact(customInstructions?: string): Promise<void> {
+    this.aiManager.abortAIMessage();
+
+    await this.aiManager.compactConversation({
+      customInstructions,
+    });
+
+    await this.messageManager.saveSession();
+  }
+
+  /**
+   * Set an autonomous goal for the session
+   * @param condition - The goal condition to achieve
+   */
+  public async setGoal(condition: string): Promise<void> {
+    // Check plan mode
+    if (this.getPermissionMode() === "plan") {
+      this.messageManager.addUserMessage({
+        content:
+          "<system-reminder>Cannot set a goal in plan mode. Exit plan mode first.</system-reminder>",
+        isMeta: true,
+      });
+      return;
+    }
+
+    this.goalManager.setGoal(condition);
+    this.messageManager.addUserMessage({
+      content: `<system-reminder>Goal set: ${condition}. The agent will work autonomously until this goal is achieved.</system-reminder>`,
+      isMeta: true,
+    });
+    // Add the goal as a user directive to start working
+    this.messageManager.addUserMessage({
+      content: condition,
+    });
+    this.aiManager.sendAIMessage();
+
+    await this.messageManager.saveSession();
+  }
+
+  /**
+   * Clear the current autonomous goal
+   */
+  public async clearGoal(): Promise<void> {
+    if (this.goalManager.isGoalActive()) {
+      this.goalManager.clearGoal();
+      this.messageManager.addUserMessage({
+        content: "<system-reminder>Goal cleared.</system-reminder>",
+        isMeta: true,
+      });
+    } else {
+      this.messageManager.addUserMessage({
+        content: "<system-reminder>No active goal to clear.</system-reminder>",
+        isMeta: true,
+      });
+    }
+
+    await this.messageManager.saveSession();
+  }
+
+  /**
+   * Show the current goal status
+   */
+  public async showGoalStatus(): Promise<void> {
+    if (this.goalManager.isGoalActive()) {
+      this.messageManager.addUserMessage({
+        content: `<system-reminder>${this.goalManager.getStatusString()}</system-reminder>`,
+        isMeta: true,
+      });
+    } else {
+      this.messageManager.addUserMessage({
+        content:
+          "<system-reminder>No active goal. Use /goal <condition> to set one.</system-reminder>",
+        isMeta: true,
+      });
+    }
+
+    await this.messageManager.saveSession();
   }
 
   /** Unified interrupt method, interrupts both AI messages and command execution */

package/src/managers/aiManager.ts

@@ -26,7 +26,6 @@ import type { SkillManager } from "./skillManager.js";
 import { buildSystemPrompt } from "../prompts/index.js";
 import {
   buildPlanModeReminder,
-  buildPlanModeSparseReminder,
   buildPlanModeReEntryReminder,
   buildExitedPlanModeReminder,
 } from "../prompts/planModeReminders.js";
@@ -138,6 +137,14 @@ export class AIManager {
     return this.container.get<PermissionManager>("PermissionManager");
   }
 
+  private get planManager():
+    | import("./planManager.js").PlanManager
+    | undefined {
+    return this.container.get<import("./planManager.js").PlanManager>(
+      "PlanManager",
+    );
+  }
+
   private get configurationService(): ConfigurationService {
     return this.container.get<ConfigurationService>("ConfigurationService")!;
   }
@@ -253,7 +260,6 @@ export class AIManager {
       this.permissionManager.setNeedsPlanModeExitAttachment(false);
     }
 
-    // Handle plan mode reminders
     if (currentMode !== "plan") return messages;
 
     const planFilePath = this.permissionManager.getPlanFilePath();
@@ -261,83 +267,27 @@ export class AIManager {
 
     const planExists = existsSync(planFilePath);
 
-    // Check for re-entry: flag is set AND plan file exists
-    if (this.permissionManager.hasExitedPlanModeInSession() && planExists) {
-      messages.push({
-        role: "user",
-        content: buildPlanModeReEntryReminder(planFilePath),
-      });
-      this.permissionManager.setHasExitedPlanMode(false); // One-time
-    }
-
-    // Count plan_mode system-reminders in existing messages to determine full vs sparse
-    // and count human turns since last reminder for throttling
-    const recentApiMessages = this.messageManager.getMessages();
-    let planModeReminderCount = 0;
-    let humanTurnsSinceLastReminder = 0;
-    let foundLastReminder = false;
-
-    for (let i = recentApiMessages.length - 1; i >= 0; i--) {
-      const msg = recentApiMessages[i];
-      if (msg.role === "user" && !msg.isMeta) {
-        // Count human turns (non-meta user messages without tool results)
-        const hasToolResult = msg.blocks?.some(
-          (b: { type: string }) => b.type === "tool",
-        );
-        if (!hasToolResult) {
-          if (!foundLastReminder) {
-            humanTurnsSinceLastReminder++;
-          }
-        }
-      }
-      // Check for existing plan mode system-reminders
-      if (msg.role === "user" && msg.isMeta) {
-        const textContent = msg.blocks
-          ?.filter((b) => b.type === "text")
-          .map((b) => ("content" in b ? b.content : ""))
-          .join("");
-        if (
-          textContent?.includes("Plan mode is active") ||
-          textContent?.includes("Plan mode still active")
-        ) {
-          planModeReminderCount++;
-          if (!foundLastReminder) {
-            foundLastReminder = true;
-          }
-        }
+    // One-time plan entry reminder
+    const planMgr = this.planManager;
+    if (planMgr?.isPlanEntryReminderPending()) {
+      if (this.permissionManager.hasExitedPlanModeInSession() && planExists) {
+        // Re-entry: use small reminder
+        messages.push({
+          role: "user",
+          content: buildPlanModeReEntryReminder(planFilePath),
+        });
+      } else {
+        // First entry: use full reminder
+        messages.push({
+          role: "user",
+          content: buildPlanModeReminder(
+            planFilePath,
+            planExists,
+            !!this.subagentType,
+          ),
+        });
       }
-    }
-
-    // Throttle: only inject every 5 human turns (but always inject on first turn)
-    const TURNS_BETWEEN_REMINDERS = 5;
-    const FULL_REMINDER_EVERY_N = 5;
-
-    if (
-      foundLastReminder &&
-      humanTurnsSinceLastReminder < TURNS_BETWEEN_REMINDERS
-    ) {
-      return messages; // Throttled — skip reminder
-    }
-
-    // Determine full vs sparse
-    // Every 5th reminder is full; rest are sparse
-    const reminderNumber = planModeReminderCount + 1;
-    const isFull = reminderNumber % FULL_REMINDER_EVERY_N === 1;
-
-    if (isFull) {
-      messages.push({
-        role: "user",
-        content: buildPlanModeReminder(
-          planFilePath,
-          planExists,
-          !!this.subagentType,
-        ),
-      });
-    } else {
-      messages.push({
-        role: "user",
-        content: buildPlanModeSparseReminder(planFilePath),
-      });
+      planMgr.consumePlanEntryReminder();
     }
 
     return messages;

package/src/managers/messageManager.ts

@@ -548,11 +548,6 @@ export class MessageManager {
     this.setSessionId(generateSessionId());
     this.parentSessionId = oldSessionId;
 
-    // Trigger task list update if this is the main session to ensure continuity
-    if (this.sessionType === "main") {
-      this.callbacks.onSessionIdChange?.(this.sessionId);
-    }
-
     // Set new message list
     this.setMessages(newMessages);
 

package/src/managers/permissionManager.ts

@@ -31,6 +31,7 @@ import {
   EDIT_TOOL_NAME,
   WRITE_TOOL_NAME,
   READ_TOOL_NAME,
+  ASK_USER_QUESTION_TOOL_NAME,
 } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
 import { ConfigurationService } from "../services/configurationService.js";
@@ -440,8 +441,14 @@ export class PermissionManager {
     }
 
     // 1. If bypassPermissions mode, always allow
+    // Exception: tools that require user interaction (e.g. AskUserQuestion)
+    // must still prompt the user, matching Claude Code's requiresUserInteraction behavior.
     if (context.permissionMode === "bypassPermissions") {
-      return { behavior: "allow" };
+      const requiresUserInteraction =
+        context.toolName === ASK_USER_QUESTION_TOOL_NAME;
+      if (!requiresUserInteraction) {
+        return { behavior: "allow" };
+      }
     }
 
     // 1.0 Check worktree safety for Write and Edit tools

package/src/managers/planManager.ts

@@ -16,6 +16,7 @@ import { logger } from "../utils/globalLogger.js";
 export class PlanManager {
   private planDir: string;
   private currentPlanFilePath: string | null = null;
+  private planEntryReminderPending: boolean = false;
 
   constructor(private container: Container) {
     this.planDir = path.join(os.homedir(), ".wave", "plans");
@@ -80,6 +81,7 @@ export class PlanManager {
       // Entering plan mode: clear any pending exit attachment
       // (prevents sending both plan_mode and plan_mode_exit on rapid toggle)
       permissionManager?.setNeedsPlanModeExitAttachment(false);
+      this.planEntryReminderPending = true;
 
       this.getOrGeneratePlanFilePath(messageManager?.getRootSessionId())
         .then(({ path }) => {
@@ -94,8 +96,17 @@ export class PlanManager {
       permissionManager?.setHasExitedPlanMode(true);
       permissionManager?.setNeedsPlanModeExitAttachment(true);
       permissionManager?.setPlanFilePath(undefined);
+      this.planEntryReminderPending = false;
     } else {
       permissionManager?.setPlanFilePath(undefined);
     }
   }
+
+  public isPlanEntryReminderPending(): boolean {
+    return this.planEntryReminderPending;
+  }
+
+  public consumePlanEntryReminder(): void {
+    this.planEntryReminderPending = false;
+  }
 }