wave-agent-sdk 0.17.5 → 0.17.7

package/src/managers/lspManager.ts

@@ -92,22 +92,40 @@ export class LspManager implements ILspManager {
     try {
       const env = { ...process.env, ...config.env };
 
-      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
+      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
       let command = config.command;
       let args = config.args || [];
       if (config.pluginRoot) {
         env.WAVE_PLUGIN_ROOT = config.pluginRoot;
+        env.CLAUDE_PLUGIN_ROOT = config.pluginRoot;
         command = command.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, config.pluginRoot);
-        args = args.map((arg) =>
-          arg.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, config.pluginRoot!),
+        command = command.replace(
+          /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+          config.pluginRoot,
         );
-        // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+        args = args.map((arg) => {
+          let result = arg.replace(
+            /\$\{WAVE_PLUGIN_ROOT\}/g,
+            config.pluginRoot!,
+          );
+          result = result.replace(
+            /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+            config.pluginRoot!,
+          );
+          return result;
+        });
+        // Also expand plugin root in user-provided env values
         if (config.env) {
           for (const [key, value] of Object.entries(config.env)) {
-            env[key] = value.replace(
+            let expanded = value.replace(
               /\$\{WAVE_PLUGIN_ROOT\}/g,
               config.pluginRoot!,
             );
+            expanded = expanded.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              config.pluginRoot!,
+            );
+            env[key] = expanded;
           }
         }
       }

package/src/managers/mcpManager.ts

@@ -40,7 +40,7 @@ export interface McpManagerOptions {
  * Expand environment variables in a string value.
  * Supports ${VAR} and ${VAR:-default} patterns.
  */
-const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT"];
+const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"];
 
 export function expandEnvVars(value: string): string {
   return value.replace(/\$\{([^}]+)\}/g, (_match, expr: string) => {
@@ -440,25 +440,42 @@ export class McpManager {
           ...(server.config.env || {}),
         };
 
-        // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
-        // (same pattern as Claude Code's substitutePluginVariables)
+        // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
         let command = server.config.command;
         let args = server.config.args || [];
         if (server.config.pluginRoot) {
           env.WAVE_PLUGIN_ROOT = server.config.pluginRoot;
+          env.CLAUDE_PLUGIN_ROOT = server.config.pluginRoot;
           command = command.replace(
             /\$\{WAVE_PLUGIN_ROOT\}/g,
             server.config.pluginRoot,
           );
-          args = args.map((arg) =>
-            arg.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, server.config.pluginRoot!),
+          command = command.replace(
+            /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+            server.config.pluginRoot,
           );
-          // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+          args = args.map((arg) => {
+            let result = arg.replace(
+              /\$\{WAVE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            result = result.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            return result;
+          });
+          // Also expand plugin root in user-provided env values
           for (const [key, value] of Object.entries(server.config.env || {})) {
-            env[key] = value.replace(
+            let expanded = value.replace(
               /\$\{WAVE_PLUGIN_ROOT\}/g,
               server.config.pluginRoot!,
             );
+            expanded = expanded.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            env[key] = expanded;
           }
         }
         transport = new StdioClientTransport({

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;
+  }
 }

package/src/managers/skillManager.ts

@@ -29,6 +29,7 @@ import { logger } from "../utils/globalLogger.js";
  */
 export class SkillManager extends EventEmitter {
   private personalSkillsPath: string;
+  private personalClaudeSkillsPath: string;
   private scanTimeout: number;
   private workdir: string;
 
@@ -47,6 +48,8 @@ export class SkillManager extends EventEmitter {
     super();
     this.personalSkillsPath =
       options.personalSkillsPath || join(homedir(), ".wave", "skills");
+    this.personalClaudeSkillsPath =
+      options.personalClaudeSkillsPath || join(homedir(), ".claude", "skills");
     this.scanTimeout = options.scanTimeout || 5000;
     this.workdir = options.workdir || process.cwd();
     this.watchEnabled = options.watch ?? false;
@@ -127,7 +130,9 @@ export class SkillManager extends EventEmitter {
 
     const pathsToWatch = [
       this.personalSkillsPath,
+      this.personalClaudeSkillsPath,
       join(this.workdir, ".wave", "skills"),
+      join(this.workdir, ".claude", "skills"),
     ];
 
     logger?.debug(`Setting up skill watcher for: ${pathsToWatch.join(", ")}`);
@@ -220,6 +225,11 @@ export class SkillManager extends EventEmitter {
       "builtin",
     );
 
+    const personalClaudeCollection = await this.discoverSkillCollection(
+      this.personalClaudeSkillsPath,
+      "personal",
+    );
+
     const personalCollection = await this.discoverSkillCollection(
       this.personalSkillsPath,
       "personal",
@@ -232,10 +242,14 @@ export class SkillManager extends EventEmitter {
 
     return {
       builtinSkills: builtinCollection.skills,
-      personalSkills: personalCollection.skills,
+      personalSkills: new Map([
+        ...personalClaudeCollection.skills,
+        ...personalCollection.skills, // .wave overrides .claude
+      ]),
       projectSkills: projectCollection.skills,
       errors: [
         ...builtinCollection.errors,
+        ...personalClaudeCollection.errors,
         ...personalCollection.errors,
         ...projectCollection.errors,
       ],
@@ -256,77 +270,88 @@ export class SkillManager extends EventEmitter {
       errors: [],
     };
 
-    let skillsPath: string;
-    if (type === "personal") {
-      skillsPath = basePath;
-    } else if (type === "builtin") {
-      skillsPath = basePath;
+    if (type === "project") {
+      // Scan .claude/skills first, then .wave/skills (wave overrides)
+      const claudePath = join(basePath, ".claude", "skills");
+      const wavePath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(claudePath, collection);
+      await this.scanSkillPath(wavePath, collection);
     } else {
-      skillsPath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(basePath, collection);
     }
 
+    return collection;
+  }
+
+  private async scanSkillPath(
+    skillsPath: string,
+    collection: SkillCollection,
+  ): Promise<void> {
     try {
       const skillDirs = await this.findSkillDirectories(skillsPath);
       logger?.debug(
         `Found ${skillDirs.length} potential skill directories in ${skillsPath}`,
       );
+      await this.processSkillDirs(skillDirs, collection);
+    } catch (error) {
+      logger?.debug(
+        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
 
-      for (const skillDir of skillDirs) {
-        try {
-          const skillFilePath = join(skillDir, "SKILL.md");
+  private async processSkillDirs(
+    skillDirs: string[],
+    collection: SkillCollection,
+  ): Promise<void> {
+    for (const skillDir of skillDirs) {
+      try {
+        const skillFilePath = join(skillDir, "SKILL.md");
 
-          // Check if SKILL.md exists
-          try {
-            await stat(skillFilePath);
-          } catch {
-            continue; // Skip directories without SKILL.md
-          }
-
-          const parsed = parseSkillFile(skillFilePath, {
-            basePath: skillDir,
-            validateMetadata: true,
-          });
+        // Check if SKILL.md exists
+        try {
+          await stat(skillFilePath);
+        } catch {
+          continue; // Skip directories without SKILL.md
+        }
 
-          if (parsed.isValid) {
-            // Override the skill type with the collection type
-            const skillMetadata: SkillMetadata = {
-              ...parsed.skillMetadata,
-              type,
-            };
-
-            // Create full skill object with content
-            const skill: Skill = {
-              ...skillMetadata,
-              content: parsed.content,
-              frontmatter: parsed.frontmatter,
-              isValid: parsed.isValid,
-              errors: parsed.validationErrors,
-            };
-
-            collection.skills.set(skillMetadata.name, skillMetadata);
-            // Store the full skill content in the manager's skillContent map
-            this.skillContent.set(skillMetadata.name, skill);
-          } else {
-            collection.errors.push({
-              skillPath: skillDir,
-              message: parsed.validationErrors.join("; "),
-            });
-          }
-        } catch (error) {
+        const parsed = parseSkillFile(skillFilePath, {
+          basePath: skillDir,
+          validateMetadata: true,
+        });
+
+        if (parsed.isValid) {
+          // Override the skill type with the collection type
+          const skillMetadata: SkillMetadata = {
+            ...parsed.skillMetadata,
+            type: collection.type,
+          };
+
+          // Create full skill object with content
+          const skill: Skill = {
+            ...skillMetadata,
+            content: parsed.content,
+            frontmatter: parsed.frontmatter,
+            isValid: parsed.isValid,
+            errors: parsed.validationErrors,
+          };
+
+          collection.skills.set(skillMetadata.name, skillMetadata);
+          // Store the full skill content in the manager's skillContent map
+          this.skillContent.set(skillMetadata.name, skill);
+        } else {
           collection.errors.push({
             skillPath: skillDir,
-            message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+            message: parsed.validationErrors.join("; "),
           });
         }
+      } catch (error) {
+        collection.errors.push({
+          skillPath: skillDir,
+          message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+        });
       }
-    } catch (error) {
-      logger?.debug(
-        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
-      );
-      // Not an error - the directory might not exist yet
     }
-
-    return collection;
   }
 
   /**
@@ -450,15 +475,23 @@ export class SkillManager extends EventEmitter {
     // 1. Substitute parameters ($1, $ARGUMENTS, etc.)
     mainContent = substituteCommandParameters(mainContent, argsString);
 
-    // 2. Substitute ${WAVE_SKILL_DIR} with the skill's directory path
+    // 2. Substitute ${WAVE_SKILL_DIR} and ${CLAUDE_SKILL_DIR}
     mainContent = mainContent.replace(/\$\{WAVE_SKILL_DIR\}/g, skill.skillPath);
+    mainContent = mainContent.replace(
+      /\$\{CLAUDE_SKILL_DIR\}/g,
+      skill.skillPath,
+    );
 
-    // 3. Substitute ${WAVE_PLUGIN_ROOT} with the skill's plugin root path
+    // 3. Substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
     if (skill.pluginRoot) {
       mainContent = mainContent.replace(
         /\$\{WAVE_PLUGIN_ROOT\}/g,
         skill.pluginRoot,
       );
+      mainContent = mainContent.replace(
+        /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+        skill.pluginRoot,
+      );
     }
 
     return skillPath + mainContent;

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;
       })