wave-agent-sdk 0.17.6 → 0.17.7

package/src/managers/slashCommandManager.ts

@@ -1,7 +1,5 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
-import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
-import type { TaskManager } from "../services/taskManager.js";
 import type { SlashCommand, CustomSlashCommand } from "../types/index.js";
 import { loadCustomSlashCommands } from "../utils/customCommands.js";
 
@@ -23,10 +21,6 @@ import {
 import type { SkillManager } from "./skillManager.js";
 import type { SkillMetadata } from "../types/skills.js";
 import type { SubagentManager } from "./subagentManager.js";
-import type { MemoryService } from "../services/memory.js";
-import type { HookManager } from "./hookManager.js";
-import type { GoalManager } from "./goalManager.js";
-
 import { logger } from "../utils/globalLogger.js";
 
 export interface SlashCommandManagerOptions {
@@ -48,7 +42,6 @@ export class SlashCommandManager {
   }
 
   public initialize(): void {
-    this.initializeBuiltinCommands();
     this.loadCustomCommands();
 
     // Listen for skill refreshes and update skill commands
@@ -68,14 +61,6 @@ export class SlashCommandManager {
     return this.container.get<AIManager>("AIManager")!;
   }
 
-  private get backgroundTaskManager(): BackgroundTaskManager {
-    return this.container.get<BackgroundTaskManager>("BackgroundTaskManager")!;
-  }
-
-  private get taskManager(): TaskManager {
-    return this.container.get<TaskManager>("TaskManager")!;
-  }
-
   private get skillManager(): SkillManager {
     return this.container.get<SkillManager>("SkillManager")!;
   }
@@ -84,206 +69,6 @@ export class SlashCommandManager {
     return this.container.get<SubagentManager>("SubagentManager")!;
   }
 
-  private get memoryService(): MemoryService {
-    return this.container.get<MemoryService>("MemoryService")!;
-  }
-
-  private get hookManager(): HookManager | undefined {
-    return this.container.get<HookManager>("HookManager");
-  }
-
-  private get goalManager(): GoalManager | undefined {
-    return this.container.get<GoalManager>("GoalManager");
-  }
-
-  private initializeBuiltinCommands(): void {
-    // 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 as 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 as 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?: string, signal?: AbortSignal) => {
-        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?: string) => {
-        const trimmed = args?.trim() ?? "";
-        return (
-          !trimmed ||
-          ["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed)
-        );
-      },
-      handler: async (args?: string) => {
-        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<
-              import("../types/permissions.js").PermissionMode
-            >("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 as Error).message}</system-reminder>`,
-            isMeta: true,
-          });
-        }
-      },
-    });
-  }
-
   /**
    * Load custom commands from filesystem
    */

package/src/managers/toolManager.ts

@@ -364,11 +364,7 @@ class ToolManager {
           return false;
         }
         if (effectivePermissionMode === "bypassPermissions") {
-          if (
-            tool.name === "ExitPlanMode" ||
-            tool.name === "AskUserQuestion" ||
-            tool.name === "EnterPlanMode"
-          ) {
+          if (tool.name === "ExitPlanMode") {
             return false;
           }
         }
@@ -376,10 +372,7 @@ class ToolManager {
           return effectivePermissionMode === "plan";
         }
         if (tool.name === "EnterPlanMode") {
-          return (
-            effectivePermissionMode !== "plan" &&
-            effectivePermissionMode !== "bypassPermissions"
-          );
+          return effectivePermissionMode !== "plan";
         }
         return true;
       })

package/src/prompts/planModeReminders.ts

@@ -106,26 +106,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: string): string {
-  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: string): string {
   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(