wave-agent-sdk 0.16.12 → 0.17.0

package/src/managers/backgroundTaskManager.ts

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

package/src/managers/bangManager.ts

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

package/src/managers/hookManager.ts

@@ -31,6 +31,9 @@ import { logger } from "../utils/globalLogger.js";
 
 export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
+  private programmaticHooks: PartialHookConfiguration = {};
+  private pluginHooks: PartialHookConfiguration = {};
+  private waveConfigHooks: PartialHookConfiguration = {};
   private readonly matcher: HookMatcher;
   private readonly workdir: string;
 
@@ -47,14 +50,16 @@ export class HookManager {
    * Load hook configuration from programmatic source (AgentOptions.hooks)
    */
   loadConfiguration(hooks?: PartialHookConfiguration): void {
-    const merged: PartialHookConfiguration = {};
+    this.programmaticHooks = {};
 
     if (hooks) {
-      this.mergeHooksConfiguration(merged, hooks);
+      this.mergeHooksConfiguration(this.programmaticHooks, hooks);
     }
 
     // Validate merged configuration
-    const validation = this.validatePartialConfiguration(merged);
+    const validation = this.validatePartialConfiguration(
+      this.programmaticHooks,
+    );
     if (!validation.valid) {
       throw new HookConfigurationError(
         "merged configuration",
@@ -62,7 +67,7 @@ export class HookManager {
       );
     }
 
-    this.configuration = merged;
+    this.rebuildConfiguration();
   }
 
   /**
@@ -71,8 +76,9 @@ export class HookManager {
    */
   loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      // Merge Wave configuration hooks with existing plugin hooks
-      // (plugin hooks were registered earlier via registerPluginHooks)
+      // Replace (not append) wave config hooks to avoid duplicates on reload
+      this.waveConfigHooks = {};
+
       if (waveConfig?.hooks) {
         const validation = this.validatePartialConfiguration(waveConfig.hooks);
         if (!validation.valid) {
@@ -81,11 +87,10 @@ export class HookManager {
             validation.errors,
           );
         }
-        if (!this.configuration) {
-          this.configuration = {};
-        }
-        this.mergeHooksConfiguration(this.configuration, waveConfig.hooks);
+        this.waveConfigHooks = { ...waveConfig.hooks };
       }
+
+      this.rebuildConfiguration();
     } catch (error) {
       // Re-throw configuration errors, but handle other errors gracefully
       if (error instanceof HookConfigurationError) {
@@ -98,6 +103,19 @@ export class HookManager {
     }
   }
 
+  /**
+   * Rebuild the full configuration from all sources:
+   * programmatic (AgentOptions.hooks) + plugin + wave config (settings.json)
+   * Order determines precedence on conflict (later sources append).
+   */
+  private rebuildConfiguration(): void {
+    const rebuilt: PartialHookConfiguration = {};
+    this.mergeHooksConfiguration(rebuilt, this.programmaticHooks);
+    this.mergeHooksConfiguration(rebuilt, this.pluginHooks);
+    this.mergeHooksConfiguration(rebuilt, this.waveConfigHooks);
+    this.configuration = Object.keys(rebuilt).length > 0 ? rebuilt : undefined;
+  }
+
   /**
    * Execute hooks for a specific event
    */
@@ -382,6 +400,16 @@ export class HookManager {
         messageManager.addErrorBlock(errorMessage);
         return { shouldBlock: false };
 
+      case "PreCompact":
+        // Non-blocking for compaction, show error in error block
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
+      case "PostCompact":
+        // Non-blocking for compaction, show error in error block
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
       default:
         return { shouldBlock: false };
     }
@@ -588,7 +616,9 @@ export class HookManager {
         event === "WorktreeCreate" ||
         event === "WorktreeRemove" ||
         event === "SessionStart" ||
-        event === "SessionEnd") &&
+        event === "SessionEnd" ||
+        event === "PreCompact" ||
+        event === "PostCompact") &&
       context.toolName !== undefined
     ) {
       logger?.warn(
@@ -671,7 +701,9 @@ export class HookManager {
       event === "WorktreeRemove" ||
       event === "CwdChanged" ||
       event === "SessionStart" ||
-      event === "SessionEnd"
+      event === "SessionEnd" ||
+      event === "PreCompact" ||
+      event === "PostCompact"
     ) {
       return true;
     }
@@ -734,7 +766,9 @@ export class HookManager {
         event === "WorktreeCreate" ||
         event === "WorktreeRemove" ||
         event === "SessionStart" ||
-        event === "SessionEnd") &&
+        event === "SessionEnd" ||
+        event === "PreCompact" ||
+        event === "PostCompact") &&
       config.matcher
     ) {
       errors.push(`${prefix}: Event ${event} should not have a matcher`);
@@ -778,6 +812,8 @@ export class HookManager {
           CwdChanged: 0,
           SessionStart: 0,
           SessionEnd: 0,
+          PreCompact: 0,
+          PostCompact: 0,
         },
       };
     }
@@ -794,6 +830,8 @@ export class HookManager {
       CwdChanged: 0,
       SessionStart: 0,
       SessionEnd: 0,
+      PreCompact: 0,
+      PostCompact: 0,
     };
 
     let totalConfigs = 0;
@@ -854,10 +892,6 @@ export class HookManager {
     pluginRoot: string,
     hooks: PartialHookConfiguration,
   ): void {
-    if (!this.configuration) {
-      this.configuration = {};
-    }
-
     // Stamp pluginRoot on each hook command
     const stampedHooks: PartialHookConfiguration = {};
     for (const [event, configs] of Object.entries(hooks)) {
@@ -868,7 +902,8 @@ export class HookManager {
       }));
     }
 
-    this.mergeHooksConfiguration(this.configuration, stampedHooks);
+    this.mergeHooksConfiguration(this.pluginHooks, stampedHooks);
+    this.rebuildConfiguration();
   }
 
   /**
@@ -948,9 +983,9 @@ export class HookManager {
       transcriptPath,
       cwd: this.workdir,
       endSource: source,
-      env: Object.fromEntries(
-        Object.entries(process.env).filter((e) => e[1] !== undefined),
-      ) as Record<string, string>,
+      env:
+        this.container.get<Record<string, string>>("MergedEnv") ||
+        (process.env as Record<string, string>),
     };
 
     const results = await this.executeHooks("SessionEnd", context);
@@ -962,4 +997,73 @@ export class HookManager {
 
     return results;
   }
+
+  /**
+   * Execute PreCompact hooks before compaction.
+   * Returns custom instructions from hook stdout.
+   */
+  async executePreCompactHooks(
+    sessionId: string,
+    transcriptPath: string,
+    customInstructions?: string,
+  ): Promise<{
+    results: HookExecutionResult[];
+    additionalInstructions?: string;
+  }> {
+    const context: ExtendedHookExecutionContext = {
+      event: "PreCompact",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: this.workdir,
+      compactInstructions: customInstructions,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
+    };
+
+    const results = await this.executeHooks("PreCompact", context);
+
+    let additionalInstructions: string | undefined;
+    for (const result of results) {
+      if (result.success && result.stdout?.trim()) {
+        const trimmed = result.stdout.trim();
+        additionalInstructions = additionalInstructions
+          ? additionalInstructions + "\n" + trimmed
+          : trimmed;
+      }
+    }
+
+    return { results, additionalInstructions };
+  }
+
+  /**
+   * Execute PostCompact hooks after compaction.
+   * Receives the compact summary text.
+   */
+  async executePostCompactHooks(
+    sessionId: string,
+    transcriptPath: string,
+    compactSummary: string,
+  ): Promise<HookExecutionResult[]> {
+    const context: ExtendedHookExecutionContext = {
+      event: "PostCompact",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: this.workdir,
+      compactSummary,
+      env:
+        this.container.get<Record<string, string>>("MergedEnv") ||
+        (process.env as Record<string, string>),
+    };
+
+    const results = await this.executeHooks("PostCompact", context);
+    if (results.length > 0) {
+      this.processHookResults("PostCompact", results);
+    }
+    return results;
+  }
 }

package/src/managers/mcpManager.ts

@@ -369,63 +369,74 @@ export class McpManager {
             version: "1.0.0",
           },
           {
-            capabilities: {
-              tools: {},
-            },
+            capabilities: {},
           },
         );
 
-      if (server.config.url) {
+      const serverType = server.config.type;
+
+      if (serverType === "http" || (!serverType && server.config.url)) {
+        if (!server.config.url) {
+          throw new Error(
+            `MCP server ${name} with type "http" requires a 'url'`,
+          );
+        }
         const url = new URL(server.config.url);
         const headers = server.config.headers;
-
-        try {
-          logger?.debug(
-            `Attempting Streamable HTTP connection for ${name} at ${url.href}`,
+        logger?.debug(
+          `Connecting to MCP server ${name} using Streamable HTTP at ${url.href}`,
+        );
+        transport = new StreamableHTTPClientTransport(url, {
+          requestInit: { headers },
+        });
+        client = createClient();
+        await client.connect(transport);
+        const toolsResponse = await client.listTools();
+        tools =
+          toolsResponse.tools?.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+          })) || [];
+        logger?.info(`Connected to MCP server ${name} using Streamable HTTP`);
+      } else if (serverType === "sse") {
+        if (!server.config.url) {
+          throw new Error(
+            `MCP server ${name} with type "sse" requires a 'url'`,
           );
-          const streamableTransport = new StreamableHTTPClientTransport(url, {
-            requestInit: { headers },
-          });
-
-          const streamableClient = createClient();
-          await streamableClient.connect(streamableTransport);
-
-          // Try to list tools to verify connection works
-          const toolsResponse = await streamableClient.listTools();
-
-          transport = streamableTransport;
-          client = streamableClient;
-          tools =
-            toolsResponse.tools?.map((tool) => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })) || [];
-
-          logger?.info(`Connected to MCP server ${name} using Streamable HTTP`);
-        } catch (error) {
-          logger?.debug(
-            `Streamable HTTP failed for ${name}, falling back to SSE: ${error instanceof Error ? error.message : String(error)}`,
+        }
+        const url = new URL(server.config.url);
+        const headers = server.config.headers;
+        logger?.debug(
+          `Connecting to MCP server ${name} using SSE at ${url.href}`,
+        );
+        transport = new SSEClientTransport(url, {
+          requestInit: { headers },
+        });
+        client = createClient();
+        await client.connect(transport);
+        const toolsResponse = await client.listTools();
+        tools =
+          toolsResponse.tools?.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+          })) || [];
+        logger?.info(`Connected to MCP server ${name} using SSE`);
+      } else if (
+        serverType === "stdio" ||
+        (!serverType && server.config.command)
+      ) {
+        if (!server.config.command) {
+          throw new Error(
+            `MCP server ${name} with type "stdio" requires a 'command'`,
           );
-          transport = new SSEClientTransport(url, {
-            requestInit: { headers },
-          });
-          client = createClient();
-          await client.connect(transport);
-
-          const toolsResponse = await client.listTools();
-          tools =
-            toolsResponse.tools?.map((tool) => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })) || [];
-
-          logger?.info(`Connected to MCP server ${name} using SSE (fallback)`);
         }
-      } else if (server.config.command) {
+        const agentEnv =
+          this.container.get<Record<string, string>>("MergedEnv") ||
+          (process.env as Record<string, string>);
         const env: Record<string, string> = {
-          ...(process.env as Record<string, string>),
+          ...agentEnv,
           ...(server.config.env || {}),
         };
 
@@ -489,6 +500,11 @@ export class McpManager {
             description: tool.description,
             inputSchema: tool.inputSchema,
           })) || [];
+      } else if (serverType) {
+        // Unknown type value
+        throw new Error(
+          `MCP server ${name} has unknown type "${serverType}". Must be "stdio", "sse", or "http"`,
+        );
       } else {
         throw new Error(
           `MCP server ${name} configuration must include either 'command' or 'url'`,
@@ -798,7 +814,7 @@ export class McpManager {
             } else if (c.type === "resource") {
               textContent.push(`[Resource: ${c.resource?.uri || ""}]`);
             } else {
-              textContent.push(JSON.stringify(c));
+              textContent.push(JSON.stringify(c, null, 2));
             }
           },
         );

package/src/managers/messageManager.ts

@@ -241,6 +241,16 @@ export class MessageManager {
     this.filesInContext.add(normalizedPath);
   }
 
+  /**
+   * Checks if a file has been read or edited in this conversation.
+   */
+  public hasFileInContext(filePath: string): boolean {
+    const normalizedPath = isAbsolute(filePath)
+      ? relative(this.workdir, filePath)
+      : filePath;
+    return this.filesInContext.has(normalizedPath);
+  }
+
   /**
    * Extracts and adds file paths from a message's tool blocks.
    */

package/src/managers/permissionManager.ts

@@ -129,6 +129,8 @@ export class PermissionManager {
   private additionalDirectories: string[] = [];
   private systemAdditionalDirectories: string[] = [];
   private planFilePath?: string;
+  private hasExitedPlanMode: boolean = false;
+  private needsPlanModeExitAttachment: boolean = false;
   private workdir?: string;
   private worktreeName?: string;
   private mainRepoRoot?: string;
@@ -315,6 +317,22 @@ export class PermissionManager {
     return this.planFilePath;
   }
 
+  public setHasExitedPlanMode(value: boolean): void {
+    this.hasExitedPlanMode = value;
+  }
+
+  public hasExitedPlanModeInSession(): boolean {
+    return this.hasExitedPlanMode;
+  }
+
+  public setNeedsPlanModeExitAttachment(value: boolean): void {
+    this.needsPlanModeExitAttachment = value;
+  }
+
+  public getNeedsPlanModeExitAttachment(): boolean {
+    return this.needsPlanModeExitAttachment;
+  }
+
   /**
    * Public wrapper for isInsideSafeZone to check if a path is in the safe zone
    */

package/src/managers/planManager.ts

@@ -74,7 +74,13 @@ export class PlanManager {
       this.container.get<PermissionManager>("PermissionManager");
     const messageManager = this.container.get<MessageManager>("MessageManager");
 
+    const previousMode = this.container.get<PermissionMode>("PermissionMode");
+
     if (mode === "plan") {
+      // Entering plan mode: clear any pending exit attachment
+      // (prevents sending both plan_mode and plan_mode_exit on rapid toggle)
+      permissionManager?.setNeedsPlanModeExitAttachment(false);
+
       this.getOrGeneratePlanFilePath(messageManager?.getRootSessionId())
         .then(({ path }) => {
           logger?.debug("Plan file path generated", { path });
@@ -83,6 +89,11 @@ export class PlanManager {
         .catch((error) => {
           logger?.error("Failed to generate plan file path", error);
         });
+    } else if (previousMode === "plan") {
+      // Leaving plan mode: set flags for exit notification and re-entry detection
+      permissionManager?.setHasExitedPlanMode(true);
+      permissionManager?.setNeedsPlanModeExitAttachment(true);
+      permissionManager?.setPlanFilePath(undefined);
     } else {
       permissionManager?.setPlanFilePath(undefined);
     }

package/src/managers/pluginManager.ts

@@ -109,14 +109,60 @@ export class PluginManager {
           );
 
           if (isMarketplaceKnown) {
+            // Pre-check: verify the plugin still exists in the marketplace manifest
+            // before acquiring the lock in installPlugin (which can block ~8s during autoUpdate)
+            const marketplace = knownMarketplaces.find(
+              (m) => m.name === marketplaceName,
+            );
+            if (!marketplace) continue;
+            try {
+              const marketplacePath = marketplaceService.getMarketplacePath(
+                marketplace.source,
+              );
+              const manifest =
+                await marketplaceService.loadMarketplaceManifest(
+                  marketplacePath,
+                );
+              const pluginExists = manifest.plugins.some(
+                (p) => p.name === name,
+              );
+              if (!pluginExists) {
+                logger?.warn(
+                  `Plugin ${pluginId} is enabled but no longer exists in marketplace ${marketplaceName}. Removing from enabledPlugins.`,
+                );
+                await this.configurationService?.removeEnabledPlugin(
+                  this.workdir,
+                  "user",
+                  pluginId,
+                );
+                continue;
+              }
+            } catch {
+              // Manifest read failed (marketplace not cloned yet?) — fall through to installPlugin
+            }
+
             logger?.info(`Auto-installing missing plugin: ${pluginId}`);
             try {
               await marketplaceService.installPlugin(pluginId);
             } catch (installError) {
-              logger?.error(
-                `Failed to auto-install plugin ${pluginId}:`,
-                installError,
-              );
+              if (
+                installError instanceof Error &&
+                installError.message.includes("not found in marketplace")
+              ) {
+                logger?.warn(
+                  `Plugin ${pluginId} no longer found in marketplace. Removing from enabledPlugins.`,
+                );
+                await this.configurationService?.removeEnabledPlugin(
+                  this.workdir,
+                  "user",
+                  pluginId,
+                );
+              } else {
+                logger?.error(
+                  `Failed to auto-install plugin ${pluginId}:`,
+                  installError,
+                );
+              }
             }
           } else {
             logger?.warn(
@@ -132,7 +178,7 @@ export class PluginManager {
       for (const p of installedRegistry.plugins) {
         const pluginId = `${p.name}@${p.marketplace}`;
         if (this.enabledPlugins[pluginId] !== true) {
-          logger?.info(`Plugin ${pluginId} is not enabled via configuration`);
+          logger?.debug(`Plugin ${pluginId} is not enabled via configuration`);
           continue;
         }
         await this.loadSinglePlugin(p.cachePath);
@@ -203,7 +249,7 @@ export class PluginManager {
       }
 
       this.plugins.set(manifest.name, plugin);
-      logger?.info(`Loaded plugin: ${manifest.name} v${manifest.version}`);
+      logger?.debug(`Loaded plugin: ${manifest.name} v${manifest.version}`);
     } catch (error) {
       logger?.error(`Failed to load plugin from ${absolutePath}`, error);
     }

package/src/managers/slashCommandManager.ts

@@ -158,6 +158,23 @@ export class SlashCommandManager {
         }
       },
     });
+
+    // Register built-in compact command
+    this.registerCommand({
+      id: "compact",
+      name: "compact",
+      description: "Compact conversation history to reduce context usage",
+      handler: async (args?: string, signal?: AbortSignal) => {
+        this.aiManager.abortAIMessage();
+
+        const customInstructions = args?.trim() || undefined;
+
+        await this.aiManager.compactConversation({
+          customInstructions,
+          abortSignal: signal,
+        });
+      },
+    });
   }
 
   /**

package/src/managers/subagentManager.ts

@@ -287,6 +287,10 @@ export class SubagentManager {
     if (parentOptions) {
       const subagentOptions: import("../types/agent.js").AgentOptions = {
         ...parentOptions,
+        defaultHeaders: {
+          ...parentOptions.defaultHeaders,
+          ...parentOptions.subagentHeaders?.[parameters.subagent_type],
+        },
         callbacks: {
           ...parentOptions.callbacks,
           onLoadingChange: undefined,

package/src/prompts/index.ts

@@ -239,10 +239,6 @@ export function buildSystemPrompt(
     memory?: string;
     language?: string;
     isSubagent?: boolean;
-    planMode?: {
-      planFilePath: string;
-      planExists: boolean;
-    };
     autoMemory?: {
       directory: string;
       content: string;
@@ -269,10 +265,6 @@ export function buildSystemPrompt(
     prompt += `\n\n# Language\nAlways respond in ${options.language}. Use ${options.language} for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
   }
 
-  if (options.planMode) {
-    prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
-  }
-
   if (options.workdir) {
     const isGitRepo = isGitRepository(options.workdir);
     const platform = os.platform();