wave-agent-sdk 0.13.4 → 0.13.6

package/src/managers/hookManager.ts

@@ -166,28 +166,42 @@ export class HookManager {
             ? { timeout: hookCommand.timeout * 1000 }
             : undefined;
 
+          // Build execution context with WAVE_PLUGIN_ROOT if this is a plugin hook
+          let command = hookCommand.command;
+          const execContext: typeof context = hookCommand.pluginRoot
+            ? {
+                ...context,
+                env: {
+                  ...("env" in context ? (context.env ?? {}) : {}),
+                  WAVE_PLUGIN_ROOT: hookCommand.pluginRoot,
+                },
+              }
+            : context;
+
+          // Substitute ${WAVE_PLUGIN_ROOT} in the command string (same pattern as Claude Code)
+          if (hookCommand.pluginRoot) {
+            command = command.replace(
+              /\$\{WAVE_PLUGIN_ROOT\}/g,
+              hookCommand.pluginRoot,
+            );
+          }
+
           if (hookCommand.async) {
             // Execute async command without awaiting
-            executeCommand(hookCommand.command, context, options).catch(
-              (error) => {
-                const errorMessage =
-                  error instanceof Error
-                    ? error.message
-                    : "Unknown execution error";
-                logger?.error(
-                  `[HookManager] Async hook command ${commandIndex + 1} failed: ${errorMessage}`,
-                );
-              },
-            );
+            executeCommand(command, execContext, options).catch((error) => {
+              const errorMessage =
+                error instanceof Error
+                  ? error.message
+                  : "Unknown execution error";
+              logger?.error(
+                `[HookManager] Async hook command ${commandIndex + 1} failed: ${errorMessage}`,
+              );
+            });
             // Async hooks are not included in results to prevent blocking
             continue;
           }
 
-          const result = await executeCommand(
-            hookCommand.command,
-            context,
-            options,
-          );
+          const result = await executeCommand(command, execContext, options);
           results.push(result);
 
           // Continue with next command even if this one fails
@@ -639,7 +653,8 @@ export class HookManager {
       event === "UserPromptSubmit" ||
       event === "Stop" ||
       event === "SubagentStop" ||
-      event === "WorktreeCreate"
+      event === "WorktreeCreate" ||
+      event === "CwdChanged"
     ) {
       return true;
     }
@@ -739,6 +754,7 @@ export class HookManager {
           SubagentStop: 0,
           PermissionRequest: 0,
           WorktreeCreate: 0,
+          CwdChanged: 0,
         },
       };
     }
@@ -751,6 +767,7 @@ export class HookManager {
       SubagentStop: 0,
       PermissionRequest: 0,
       WorktreeCreate: 0,
+      CwdChanged: 0,
     };
 
     let totalConfigs = 0;
@@ -775,14 +792,56 @@ export class HookManager {
     };
   }
 
+  /**
+   * Execute CwdChanged hooks.
+   */
+  async executeCwdChangedHooks(
+    oldCwd: string,
+    newCwd: string,
+    sessionId: string,
+    transcriptPath: string,
+    env: Record<string, string>,
+  ): Promise<HookExecutionResult[]> {
+    const context: ExtendedHookExecutionContext = {
+      event: "CwdChanged",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: newCwd,
+      oldCwd,
+      newCwd,
+      env,
+    };
+    const results = await this.executeHooks("CwdChanged", context);
+    if (results.length > 0) {
+      // For CwdChanged hooks, we don't block, just log errors
+      this.processHookResults("CwdChanged", results);
+    }
+    return results;
+  }
+
   /**
    * Register hooks provided by a plugin
    */
-  registerPluginHooks(hooks: PartialHookConfiguration): void {
+  registerPluginHooks(
+    pluginRoot: string,
+    hooks: PartialHookConfiguration,
+  ): void {
     if (!this.configuration) {
       this.configuration = {};
     }
 
-    this.mergeHooksConfiguration(this.configuration, hooks);
+    // Stamp pluginRoot on each hook command
+    const stampedHooks: PartialHookConfiguration = {};
+    for (const [event, configs] of Object.entries(hooks)) {
+      if (!isValidHookEvent(event)) continue;
+      stampedHooks[event] = configs.map((config) => ({
+        ...config,
+        hooks: config.hooks.map((cmd) => ({ ...cmd, pluginRoot })),
+      }));
+    }
+
+    this.mergeHooksConfiguration(this.configuration, stampedHooks);
   }
 }

package/src/managers/lspManager.ts

@@ -90,9 +90,30 @@ export class LspManager implements ILspManager {
     );
 
     try {
-      const proc = spawn(config.command, config.args || [], {
+      const env = { ...process.env, ...config.env };
+
+      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
+      let command = config.command;
+      let args = config.args || [];
+      if (config.pluginRoot) {
+        env.WAVE_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!),
+        );
+        // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+        if (config.env) {
+          for (const [key, value] of Object.entries(config.env)) {
+            env[key] = value.replace(
+              /\$\{WAVE_PLUGIN_ROOT\}/g,
+              config.pluginRoot!,
+            );
+          }
+        }
+      }
+      const proc = spawn(command, args, {
         cwd: config.workspaceFolder || this.workdir,
-        env: { ...process.env, ...config.env },
+        env,
         stdio: ["pipe", "pipe", "pipe"],
       });
 

package/src/managers/mcpManager.ts

@@ -348,13 +348,36 @@ export class McpManager {
           logger?.info(`Connected to MCP server ${name} using SSE (fallback)`);
         }
       } else if (server.config.command) {
+        const env: Record<string, string> = {
+          ...(process.env as Record<string, string>),
+          ...(server.config.env || {}),
+        };
+
+        // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
+        // (same pattern as Claude Code's substitutePluginVariables)
+        let command = server.config.command;
+        let args = server.config.args || [];
+        if (server.config.pluginRoot) {
+          env.WAVE_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!),
+          );
+          // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+          for (const [key, value] of Object.entries(server.config.env || {})) {
+            env[key] = value.replace(
+              /\$\{WAVE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+          }
+        }
         transport = new StdioClientTransport({
-          command: server.config.command,
-          args: server.config.args || [],
-          env: {
-            ...(process.env as Record<string, string>),
-            ...(server.config.env || {}),
-          },
+          command,
+          args,
+          env,
           cwd: this.workdir, // Use the agent's workdir as the process working directory
           stderr: "pipe", // Pipe stderr to capture it
         });

package/src/managers/messageManager.ts

@@ -654,6 +654,25 @@ export class MessageManager {
     const lastMessage = this.messages[this.messages.length - 1];
     if (lastMessage.role !== "assistant") return;
 
+    // Finalize any streaming reasoning blocks before text content arrives
+    const reasoningIndex = lastMessage.blocks.findIndex(
+      (block) =>
+        block.type === "reasoning" &&
+        (block as { stage?: string }).stage === "streaming",
+    );
+    if (reasoningIndex >= 0) {
+      const reasoningBlock = lastMessage.blocks[reasoningIndex] as {
+        type: "reasoning";
+        content: string;
+        stage?: string;
+      };
+      lastMessage.blocks[reasoningIndex] = {
+        type: "reasoning" as const,
+        content: reasoningBlock.content,
+        stage: "end" as const,
+      };
+    }
+
     // Get the current content to calculate the chunk
     const textBlockIndex = lastMessage.blocks.findIndex(
       (block) => block.type === "text",
@@ -705,6 +724,25 @@ export class MessageManager {
     const lastMessage = this.messages[this.messages.length - 1];
     if (lastMessage.role !== "assistant") return;
 
+    // Finalize any streaming text blocks before reasoning content arrives
+    const textIndex = lastMessage.blocks.findIndex(
+      (block) =>
+        block.type === "text" &&
+        (block as { stage?: string }).stage === "streaming",
+    );
+    if (textIndex >= 0) {
+      const textBlock = lastMessage.blocks[textIndex] as {
+        type: "text";
+        content: string;
+        stage?: string;
+      };
+      lastMessage.blocks[textIndex] = {
+        type: "text" as const,
+        content: textBlock.content,
+        stage: "end" as const,
+      };
+    }
+
     // Get the current reasoning content to calculate the chunk
     const reasoningBlockIndex = lastMessage.blocks.findIndex(
       (block) => block.type === "reasoning",

package/src/managers/messageQueue.ts

@@ -0,0 +1,41 @@
+export interface QueuedMessage {
+  type?: "message" | "bang";
+  content: string;
+  images?: Array<{ path: string; mimeType: string }>;
+  longTextMap?: Record<string, string>;
+}
+
+export class MessageQueue {
+  private queue: QueuedMessage[] = [];
+  onMessageEnqueued?: () => void;
+
+  enqueue(message: QueuedMessage): void {
+    this.queue.push(message);
+    this.onMessageEnqueued?.();
+  }
+
+  dequeue(): QueuedMessage | null {
+    return this.queue.shift() ?? null;
+  }
+
+  clear(): void {
+    this.queue = [];
+  }
+
+  hasPending(): boolean {
+    return this.queue.length > 0;
+  }
+
+  getQueue(): QueuedMessage[] {
+    return [...this.queue];
+  }
+
+  removeAt(index: number): boolean {
+    if (index < 0 || index >= this.queue.length) {
+      return false;
+    }
+    this.queue.splice(index, 1);
+    this.onMessageEnqueued?.();
+    return true;
+  }
+}

package/src/managers/permissionManager.ts

@@ -113,8 +113,6 @@ export interface PermissionManagerOptions {
   additionalDirectories?: string[];
   /** System additional directories (persistent across reloads) */
   systemAdditionalDirectories?: string[];
-  /** The main working directory */
-  workdir?: string;
   /** Path to the current plan file */
   planFilePath?: string;
   /** Optional logger */
@@ -130,10 +128,10 @@ export class PermissionManager {
   private temporaryRules: string[] = [];
   private additionalDirectories: string[] = [];
   private systemAdditionalDirectories: string[] = [];
-  private workdir?: string;
   private planFilePath?: string;
   private worktreeName?: string;
   private mainRepoRoot?: string;
+  private originalWorkdir?: string;
   private onConfiguredPermissionModeChange?: (mode: PermissionMode) => void;
   private _logger?: Logger;
 
@@ -146,7 +144,6 @@ export class PermissionManager {
     this.deniedRules = options.deniedRules || [];
     this.instanceAllowedRules = options.instanceAllowedRules || [];
     this.instanceDeniedRules = options.instanceDeniedRules || [];
-    this.workdir = options.workdir;
     this.planFilePath = options.planFilePath;
     this._logger = options.logger;
     this.updateAdditionalDirectories(options.additionalDirectories || []);
@@ -156,6 +153,14 @@ export class PermissionManager {
 
     this.worktreeName = this.container.get<string>("WorktreeName");
     this.mainRepoRoot = this.container.get<string>("MainRepoRoot");
+    this.originalWorkdir = this.container.get<string>("Workdir");
+  }
+
+  /**
+   * Resolve the working directory from the DI container
+   */
+  private getWorkdir(): string | undefined {
+    return this.container.get<string>("Workdir");
   }
 
   /**
@@ -272,9 +277,10 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
+    const workdir = this.originalWorkdir;
     this.additionalDirectories = directories.map((dir) => {
-      if (this.workdir && !path.isAbsolute(dir)) {
-        return path.resolve(this.workdir, dir);
+      if (workdir && !path.isAbsolute(dir)) {
+        return path.resolve(workdir, dir);
       }
       return path.resolve(dir);
     });
@@ -284,9 +290,10 @@ export class PermissionManager {
    * Add a system-level additional directory that is persistent across configuration reloads
    */
   public addSystemAdditionalDirectory(directory: string): void {
+    const workdir = this.originalWorkdir;
     const resolvedPath =
-      this.workdir && !path.isAbsolute(directory)
-        ? path.resolve(this.workdir, directory)
+      workdir && !path.isAbsolute(directory)
+        ? path.resolve(workdir, directory)
         : path.resolve(directory);
 
     if (!this.systemAdditionalDirectories.includes(resolvedPath)) {
@@ -294,13 +301,6 @@ export class PermissionManager {
     }
   }
 
-  /**
-   * Update the working directory
-   */
-  updateWorkdir(workdir: string): void {
-    this.workdir = workdir;
-  }
-
   /**
    * Set the current plan file path
    */
@@ -322,7 +322,7 @@ export class PermissionManager {
     targetPath: string,
     workdir?: string,
   ): { isInside: boolean; resolvedPath: string } {
-    const effectiveWorkdir = workdir || this.workdir;
+    const effectiveWorkdir = this.originalWorkdir || workdir;
 
     // Resolve the target path relative to effectiveWorkdir if it's not absolute
     const absolutePath =
@@ -432,21 +432,25 @@ export class PermissionManager {
     }
 
     // 0. Check worktree safety for Write and Edit tools
+    const currentWorkdir = this.getWorkdir();
     if (
       this.worktreeName &&
       this.mainRepoRoot &&
-      this.workdir &&
+      currentWorkdir &&
       (context.toolName === WRITE_TOOL_NAME ||
         context.toolName === EDIT_TOOL_NAME)
     ) {
       const targetPath = context.toolInput?.file_path as string | undefined;
       if (targetPath) {
-        const absoluteTargetPath = path.resolve(this.workdir, targetPath);
+        const absoluteTargetPath = path.resolve(currentWorkdir, targetPath);
         const isInsideMainRepo = isPathInside(
           absoluteTargetPath,
           this.mainRepoRoot,
         );
-        const isInsideWorktree = isPathInside(absoluteTargetPath, this.workdir);
+        const isInsideWorktree = isPathInside(
+          absoluteTargetPath,
+          currentWorkdir,
+        );
 
         // If it's inside the main repo but NOT inside the current worktree
         if (isInsideMainRepo && !isInsideWorktree) {
@@ -455,11 +459,11 @@ export class PermissionManager {
             targetPath,
             worktreeName: this.worktreeName,
             mainRepoRoot: this.mainRepoRoot,
-            workdir: this.workdir,
+            workdir: currentWorkdir,
           });
           return {
             behavior: "deny",
-            message: `Access denied: You are currently in a worktree session ("${this.worktreeName}"). Modifying files in the main repository (outside the worktree) is not allowed. Please only modify files within the worktree directory: ${this.workdir}`,
+            message: `Access denied: You are currently in a worktree session ("${this.worktreeName}"). Modifying files in the main repository (outside the worktree) is not allowed. Please only modify files within the worktree directory: ${currentWorkdir}`,
           };
         }
       }
@@ -808,12 +812,13 @@ export class PermissionManager {
         }
 
         // If direct match fails, try matching relative path if targetPath is absolute and pattern is relative
+        const currentWorkdir = this.getWorkdir();
         if (
           path.isAbsolute(targetPath) &&
           !path.isAbsolute(pattern) &&
-          this.workdir
+          currentWorkdir
         ) {
-          const relativePath = path.relative(this.workdir, targetPath);
+          const relativePath = path.relative(currentWorkdir, targetPath);
           // Ensure the path is not outside the workdir (doesn't start with ..)
           if (
             !relativePath.startsWith("..") &&
@@ -1056,7 +1061,8 @@ export class PermissionManager {
    * @param rule - The rule to add (e.g., "Bash(ls)")
    */
   public async addPermissionRule(rule: string): Promise<void> {
-    if (!this.workdir) {
+    const workdir = this.originalWorkdir;
+    if (!workdir) {
       throw new Error("Working directory not set in PermissionManager");
     }
 
@@ -1065,7 +1071,7 @@ export class PermissionManager {
     const bashMatch = rule.match(/^Bash\((.*)\)$/);
     if (bashMatch) {
       const command = bashMatch[1];
-      rulesToAdd = this.expandBashRule(command, this.workdir);
+      rulesToAdd = this.expandBashRule(command, workdir);
     }
 
     const configurationService = this.container.get<ConfigurationService>(
@@ -1085,7 +1091,7 @@ export class PermissionManager {
         // 3. Persist to settings.local.json
         try {
           if (configurationService) {
-            await configurationService.addAllowedRule(this.workdir, ruleToAdd);
+            await configurationService.addAllowedRule(workdir, ruleToAdd);
             this._logger?.debug("Persistent permission rule added", {
               rule: ruleToAdd,
             });

package/src/managers/pluginManager.ts

@@ -171,7 +171,8 @@ export class PluginManager {
 
       if (this.lspManager && plugin.lspConfig) {
         for (const [language, config] of Object.entries(plugin.lspConfig)) {
-          this.lspManager.registerServer(language, config);
+          const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
+          this.lspManager.registerServer(language, configWithPluginRoot);
         }
       }
 
@@ -179,12 +180,13 @@ export class PluginManager {
         for (const [name, config] of Object.entries(
           plugin.mcpConfig.mcpServers,
         )) {
-          this.mcpManager.addServer(name, config);
+          const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
+          this.mcpManager.addServer(name, configWithPluginRoot);
         }
       }
 
       if (this.hookManager && plugin.hooksConfig) {
-        this.hookManager.registerPluginHooks(plugin.hooksConfig);
+        this.hookManager.registerPluginHooks(plugin.path, plugin.hooksConfig);
       }
 
       this.plugins.set(manifest.name, plugin);

package/src/managers/skillManager.ts

@@ -443,6 +443,14 @@ export class SkillManager extends EventEmitter {
     // 2. Substitute ${WAVE_SKILL_DIR} with the skill's directory path
     mainContent = mainContent.replace(/\$\{WAVE_SKILL_DIR\}/g, skill.skillPath);
 
+    // 3. Substitute ${WAVE_PLUGIN_ROOT} with the skill's plugin root path
+    if (skill.pluginRoot) {
+      mainContent = mainContent.replace(
+        /\$\{WAVE_PLUGIN_ROOT\}/g,
+        skill.pluginRoot,
+      );
+    }
+
     return header + description + skillPath + mainContent;
   }
 
@@ -493,6 +501,7 @@ export class SkillManager extends EventEmitter {
         disableModelInvocation: skill.disableModelInvocation,
         userInvocable: skill.userInvocable,
         pluginName,
+        pluginRoot: skill.pluginRoot,
       };
       // Update the skill object itself to have the namespaced name
       skill.name = namespacedName;

package/src/managers/slashCommandManager.ts

@@ -248,6 +248,8 @@ export class SlashCommandManager {
                   },
                 );
 
+                // Show loading while subagent runs
+                this.aiManager.setIsLoading(true);
                 try {
                   const result = await this.subagentManager.executeAgent(
                     instance,
@@ -261,7 +263,11 @@ export class SlashCommandManager {
                     messageId,
                     result,
                     stage: "end",
+                    success: true,
                   });
+
+                  // Trigger AI to process the tool result
+                  await this.aiManager.sendAIMessage();
                 } finally {
                   this.subagentManager.cleanupInstance(instance.subagentId);
                 }
@@ -271,6 +277,7 @@ export class SlashCommandManager {
                   id: toolBlockId,
                   messageId,
                   stage: "end",
+                  success: false,
                   error: error instanceof Error ? error.message : String(error),
                 });
                 throw error; // Re-throw to be caught by outer catch for logging/error block
@@ -279,6 +286,7 @@ export class SlashCommandManager {
             }
 
             // Non-forked skill: execute and trigger AI response
+            this.aiManager.setIsLoading(true);
             const result = await this.skillManager.executeSkill({
               skill_name: skill.name,
               args,
@@ -296,10 +304,9 @@ export class SlashCommandManager {
               allowedRules: result.allowedTools,
             });
           } catch (error) {
-            logger?.error(
-              `Failed to execute skill command '${skill.name}':`,
-              error,
-            );
+            this.aiManager.setIsLoading(false);
+
+            logger?.error(error);
             this.messageManager.addErrorBlock(
               `Failed to execute skill command '${skill.name}': ${
                 error instanceof Error ? error.message : String(error)
@@ -490,6 +497,9 @@ export class SlashCommandManager {
     args?: string,
   ): Promise<void> {
     try {
+      // Set loading early so UI shows feedback during bash execution
+      this.aiManager.setIsLoading(true);
+
       // Parse bash commands from the content
       const { commands, processedContent } = parseBashCommands(content);
 
@@ -519,6 +529,8 @@ export class SlashCommandManager {
         allowedRules: config?.allowedTools,
       });
     } catch (error) {
+      this.aiManager.setIsLoading(false);
+
       logger?.error(
         `Failed to execute custom command '${commandName}':`,
         error,

package/src/managers/subagentManager.ts

@@ -243,7 +243,6 @@ export class SubagentManager {
     const parentPermissionManager =
       this.container.get<PermissionManager>("PermissionManager");
     const subagentPermissionManager = new PermissionManager(subagentContainer, {
-      workdir: this.workdir,
       configuredPermissionMode:
         parameters.permissionModeOverride ??
         parentPermissionManager?.getConfiguredPermissionMode(),
@@ -263,6 +262,15 @@ export class SubagentManager {
     });
     subagentContainer.register("PermissionManager", subagentPermissionManager);
 
+    // Register the permission mode override in the subagent container so it
+    // shadows the inherited parent value during tool execution
+    if (parameters.permissionModeOverride) {
+      subagentContainer.register(
+        "PermissionMode",
+        parameters.permissionModeOverride,
+      );
+    }
+
     // Track this subagent's PermissionManager for rule sync
     this.subagentPermissionManagers.set(subagentId, subagentPermissionManager);
 
@@ -399,6 +407,7 @@ export class SubagentManager {
         instance.backgroundTaskId = taskId;
 
         // Execute in background
+        // Note: notification enqueueing is handled by internalExecute when instance.backgroundTaskId is set
         (async () => {
           try {
             const result = await this.internalExecute(
@@ -413,17 +422,6 @@ export class SubagentManager {
               task.endTime = Date.now();
               task.runtime = task.endTime - startTime;
             }
-
-            // Enqueue completion notification
-            const notificationQueue = this.container.has("NotificationQueue")
-              ? this.container.get<NotificationQueue>("NotificationQueue")
-              : undefined;
-            if (notificationQueue) {
-              const summary = `Agent task "${instance.description}" completed`;
-              notificationQueue.enqueue(
-                `<task-notification>\n<task-id>${taskId}</task-id>\n<task-type>agent</task-type>\n<status>completed</status>\n<summary>${summary}</summary>\n</task-notification>`,
-              );
-            }
           } catch (error) {
             const task = backgroundTaskManager?.getTask(taskId);
             if (task) {
@@ -433,19 +431,6 @@ export class SubagentManager {
               task.endTime = Date.now();
               task.runtime = task.endTime - startTime;
             }
-
-            // Enqueue error notification
-            const notificationQueue = this.container.has("NotificationQueue")
-              ? this.container.get<NotificationQueue>("NotificationQueue")
-              : undefined;
-            if (notificationQueue) {
-              const errorMsg =
-                error instanceof Error ? error.message : String(error);
-              const summary = `Agent task "${instance.description}" failed: ${errorMsg}`;
-              notificationQueue.enqueue(
-                `<task-notification>\n<task-id>${taskId}</task-id>\n<task-type>agent</task-type>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
-              );
-            }
           }
         })();
 

package/src/services/autoMemoryService.ts

@@ -160,6 +160,7 @@ export class AutoMemoryService {
           "Grep",
           `Write(${memoryDir}/**/*)`,
           `Edit(${memoryDir}/**/*)`,
+          `Bash(rm ${memoryDir}/**/*)`,
         ],
         model: "fastModel", // Use fast model for background tasks to reduce latency and cost
         permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user