wave-agent-sdk 0.14.1 → 0.14.3

package/src/managers/hookManager.ts

@@ -12,6 +12,7 @@ import {
   type ExtendedHookExecutionContext,
   type HookExecutionResult,
   type HookValidationResult,
+  type SessionEndSource,
   HookConfigurationError,
   isValidHookEvent,
   isValidHookEventConfig,
@@ -80,9 +81,8 @@ export class HookManager {
    */
   loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      this.configuration = waveConfig?.hooks || undefined;
-
-      // Validate the loaded configuration if it exists
+      // Merge Wave configuration hooks with existing plugin hooks
+      // (plugin hooks were registered earlier via registerPluginHooks)
       if (waveConfig?.hooks) {
         const validation = this.validatePartialConfiguration(waveConfig.hooks);
         if (!validation.valid) {
@@ -91,17 +91,18 @@ export class HookManager {
             validation.errors,
           );
         }
+        if (!this.configuration) {
+          this.configuration = {};
+        }
+        this.mergeHooksConfiguration(this.configuration, waveConfig.hooks);
       }
     } catch (error) {
-      // If loading fails, start with undefined configuration (no hooks)
-      this.configuration = undefined;
-
       // Re-throw configuration errors, but handle other errors gracefully
       if (error instanceof HookConfigurationError) {
         throw error;
       } else {
         logger?.warn(
-          `[HookManager] Failed to load configuration, continuing with no hooks: ${(error as Error).message}`,
+          `[HookManager] Failed to load configuration, continuing with existing hooks: ${(error as Error).message}`,
         );
       }
     }
@@ -298,6 +299,8 @@ export class HookManager {
         source: MessageSource.HOOK,
       });
     }
+    // For SessionStart, stdout is processed separately in executeSessionStartHooks
+    // For SessionEnd, stdout is ignored (fire-and-forget cleanup)
     // For other hook types (PreToolUse, PostToolUse, Stop, PermissionRequest), ignore stdout
   }
 
@@ -374,6 +377,16 @@ export class HookManager {
         messageManager.addErrorBlock(errorMessage);
         return { shouldBlock: false };
 
+      case "SessionStart":
+        // Non-blocking for startup, show error in error block
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
+      case "SessionEnd":
+        // Blocking error (exit code 2): show in error block, don't block shutdown
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
       default:
         return { shouldBlock: false };
     }
@@ -577,7 +590,9 @@ export class HookManager {
       (event === "UserPromptSubmit" ||
         event === "Stop" ||
         event === "SubagentStop" ||
-        event === "WorktreeCreate") &&
+        event === "WorktreeCreate" ||
+        event === "SessionStart" ||
+        event === "SessionEnd") &&
       context.toolName !== undefined
     ) {
       logger?.warn(
@@ -654,7 +669,9 @@ export class HookManager {
       event === "Stop" ||
       event === "SubagentStop" ||
       event === "WorktreeCreate" ||
-      event === "CwdChanged"
+      event === "CwdChanged" ||
+      event === "SessionStart" ||
+      event === "SessionEnd"
     ) {
       return true;
     }
@@ -714,7 +731,9 @@ export class HookManager {
       (event === "UserPromptSubmit" ||
         event === "Stop" ||
         event === "SubagentStop" ||
-        event === "WorktreeCreate") &&
+        event === "WorktreeCreate" ||
+        event === "SessionStart" ||
+        event === "SessionEnd") &&
       config.matcher
     ) {
       errors.push(`${prefix}: Event ${event} should not have a matcher`);
@@ -755,6 +774,8 @@ export class HookManager {
           PermissionRequest: 0,
           WorktreeCreate: 0,
           CwdChanged: 0,
+          SessionStart: 0,
+          SessionEnd: 0,
         },
       };
     }
@@ -768,6 +789,8 @@ export class HookManager {
       PermissionRequest: 0,
       WorktreeCreate: 0,
       CwdChanged: 0,
+      SessionStart: 0,
+      SessionEnd: 0,
     };
 
     let totalConfigs = 0;
@@ -844,4 +867,96 @@ export class HookManager {
 
     this.mergeHooksConfiguration(this.configuration, stampedHooks);
   }
+
+  /**
+   * Execute SessionStart hooks during initialization.
+   * Collects additionalContext and initialUserMessage from hook stdout.
+   */
+  async executeSessionStartHooks(
+    source: "startup" | "resume" | "compact",
+    sessionId: string,
+    transcriptPath: string,
+    agentType?: string,
+  ): Promise<{
+    results: HookExecutionResult[];
+    additionalContext?: string;
+    initialUserMessage?: string;
+  }> {
+    const context: ExtendedHookExecutionContext = {
+      event: "SessionStart",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: this.workdir,
+      source,
+      agentType,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
+    };
+
+    const results = await this.executeHooks("SessionStart", context);
+
+    let additionalContext: string | undefined;
+    let initialUserMessage: string | undefined;
+
+    // Process stdout from successful hooks
+    for (const result of results) {
+      if (result.success && result.stdout?.trim()) {
+        const trimmed = result.stdout.trim();
+        // Try to parse as JSON for structured output
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (parsed.hookSpecificOutput?.additionalContext) {
+            additionalContext =
+              (additionalContext ? additionalContext + "\n" : "") +
+              parsed.hookSpecificOutput.additionalContext;
+          }
+          if (parsed.initialUserMessage) {
+            initialUserMessage = parsed.initialUserMessage;
+          }
+        } catch {
+          // Not JSON, treat as additional context
+          additionalContext =
+            (additionalContext ? additionalContext + "\n" : "") + trimmed;
+        }
+      }
+    }
+
+    return { results, additionalContext, initialUserMessage };
+  }
+
+  /**
+   * Execute SessionEnd hooks during agent destruction.
+   * Non-blocking: always continues shutdown even if hooks fail.
+   * No stdout processing needed (SessionEnd hooks are fire-and-forget cleanup).
+   */
+  async executeSessionEndHooks(
+    source: SessionEndSource,
+    sessionId: string,
+    transcriptPath: string,
+  ): Promise<HookExecutionResult[]> {
+    const context: ExtendedHookExecutionContext = {
+      event: "SessionEnd",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: this.workdir,
+      endSource: source,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
+    };
+
+    const results = await this.executeHooks("SessionEnd", context);
+
+    // Process results but never block shutdown
+    if (results.length > 0) {
+      this.processHookResults("SessionEnd", results);
+    }
+
+    return results;
+  }
 }

package/src/managers/messageManager.ts

@@ -47,8 +47,8 @@ export interface MessageManagerCallbacks {
   onAssistantReasoningUpdated?: (chunk: string, accumulated: string) => void;
   onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
   onErrorBlockAdded?: (error: string) => void;
-  onCompressBlockAdded?: (content: string) => void;
-  onCompressionStateChange?: (isCompressing: boolean) => void;
+  onCompactBlockAdded?: (content: string) => void;
+  onCompactionStateChange?: (isCompacting: boolean) => void;
   // Bang callback
   onAddBangMessage?: (command: string) => void;
   onUpdateBangMessage?: (command: string, output: string) => void;
@@ -92,6 +92,8 @@ export class MessageManager {
   private filesInContext: Set<string> = new Set(); // Track files mentioned in the conversation
   private recentFileReads: Map<string, { content: string; timestamp: number }> =
     new Map(); // Track file read contents
+  private invokedSkills: Map<string, { skillName: string; timestamp: number }> =
+    new Map(); // Track invoked skill names
   private sessionType: "main" | "subagent";
   private subagentType?: string;
   private _usages: Usage[] = [];
@@ -270,12 +272,14 @@ export class MessageManager {
     for (const message of newMessages) {
       this.addPathsFromMessage(message);
       this.extractFileReadsFromMessage(message);
+      this.extractSkillInvocationsFromMessage(message);
     }
 
     // Also check if the last message was updated (common for tool blocks)
     if (messages.length > 0 && messages.length === oldLength) {
       this.addPathsFromMessage(messages[messages.length - 1]);
       this.extractFileReadsFromMessage(messages[messages.length - 1]);
+      this.extractSkillInvocationsFromMessage(messages[messages.length - 1]);
     }
 
     this.callbacks.onMessagesChange?.([...messages]);
@@ -494,31 +498,31 @@ export class MessageManager {
   }
 
   /**
-   * Compress messages and update session, delete compressed messages, only keep compressed messages and last 3 messages
+   * Compact messages and update session, delete compacted messages, only keep compacted messages and last 3 messages
    */
-  public compressMessagesAndUpdateSession(
-    compressedContent: string,
+  public compactMessagesAndUpdateSession(
+    compactedContent: string,
     usage?: Usage,
   ): void {
     // Get last 2 API rounds to preserve (structurally safe boundary)
     const lastThreeMessages = getLastApiRounds(this.messages, 2);
 
-    // Create compressed message
-    const compressMessage: Message = {
+    // Create compacted message
+    const compactMessage: Message = {
       id: generateMessageId(),
       role: "assistant",
       blocks: [
         {
-          type: "compress",
-          content: compressedContent,
+          type: "compact",
+          content: compactedContent,
           sessionId: this.sessionId,
         },
       ],
       ...(usage && { usage }),
     };
 
-    // Build new message array: keep the compressed message and last 3 messages
-    const newMessages: Message[] = [compressMessage, ...lastThreeMessages];
+    // Build new message array: keep the compacted message and last 3 messages
+    const newMessages: Message[] = [compactMessage, ...lastThreeMessages];
 
     // Update sessionId and parentSessionId
     const oldSessionId = this.sessionId;
@@ -539,15 +543,15 @@ export class MessageManager {
       this.addPathsFromMessage(message);
     }
 
-    // Scan compressedContent for file mentions
+    // Scan compactedContent for file mentions
     const fileMentionRegex = /(?:^|\s)@([\w.\-/]+)/g;
     let match;
-    while ((match = fileMentionRegex.exec(compressedContent)) !== null) {
+    while ((match = fileMentionRegex.exec(compactedContent)) !== null) {
       this.touchFile(match[1]);
     }
 
-    // Trigger compression callback
-    this.callbacks.onCompressBlockAdded?.(compressedContent);
+    // Trigger compaction callback
+    this.callbacks.onCompactBlockAdded?.(compactedContent);
   }
 
   public addFileHistoryBlock(
@@ -861,7 +865,7 @@ export class MessageManager {
     let targetSessionId = this.sessionId;
     let targetIndexInSession = index;
 
-    // We need to be careful here because loadFullMessageThread might have removed "compress" blocks
+    // We need to be careful here because loadFullMessageThread might have removed "compact" blocks
     // Let's re-calculate based on the actual messages returned.
     // Actually, it's easier to just load sessions one by one again or keep track of counts.
 
@@ -883,19 +887,19 @@ export class MessageManager {
       if (!sessionData) continue;
 
       const sessionMessages = sessionData.messages;
-      // If this is not the first session in the thread, it might have a compress block at the start
+      // If this is not the first session in the thread, it might have a compact block at the start
       // that was removed in getFullMessageThread.
-      const hasCompressBlock = sessionMessages[0]?.blocks.some(
-        (b) => b.type === "compress",
+      const hasCompactBlock = sessionMessages[0]?.blocks.some(
+        (b) => b.type === "compact",
       );
       const effectiveMessages =
-        hasCompressBlock && sid !== sessionIds[0]
+        hasCompactBlock && sid !== sessionIds[0]
           ? sessionMessages.slice(1)
           : sessionMessages;
 
       if (remainingIndex < effectiveMessages.length) {
         targetSessionId = sid;
-        targetIndexInSession = hasCompressBlock
+        targetIndexInSession = hasCompactBlock
           ? remainingIndex + 1
           : remainingIndex;
         break;
@@ -938,7 +942,7 @@ export class MessageManager {
 
     // Update in-memory messages to the truncated session messages
     // We do NOT include ancestor messages here to avoid exceeding context limits.
-    // The 'compress' block at the start of the session (if any) already summarizes them.
+    // The 'compact' block at the start of the session (if any) already summarizes them.
     this.setMessages(newMessagesInSession);
 
     // Update saved message count
@@ -1056,4 +1060,54 @@ export class MessageManager {
     }
     return result;
   }
+
+  /**
+   * Extract skill invocations from tool blocks in a message.
+   */
+  private extractSkillInvocationsFromMessage(message: Message): void {
+    for (const block of message.blocks) {
+      if (
+        block.type === "tool" &&
+        block.name === "Skill" &&
+        block.stage === "end" &&
+        block.parameters
+      ) {
+        try {
+          const params = JSON.parse(block.parameters) as Record<
+            string,
+            unknown
+          >;
+          const skillName = params.skill_name as string | undefined;
+          if (skillName) {
+            this.invokedSkills.set(skillName, {
+              skillName,
+              timestamp: Date.now(),
+            });
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+    }
+  }
+
+  /**
+   * Get recently invoked skill names, sorted by timestamp (newest first).
+   * @param maxSkills - Maximum number of skills to return
+   * @returns Array of skill names sorted by recency
+   */
+  public getInvokedSkillNames(maxSkills = 10): string[] {
+    const sorted = Array.from(this.invokedSkills.entries())
+      .sort(([, a], [, b]) => b.timestamp - a.timestamp)
+      .slice(0, maxSkills);
+
+    return sorted.map(([, { skillName }]) => skillName);
+  }
+
+  /**
+   * Clear all invoked skills (e.g., after compaction).
+   */
+  public clearInvokedSkills(): void {
+    this.invokedSkills.clear();
+  }
 }

package/src/managers/pluginManager.ts

@@ -7,6 +7,7 @@ import { HookManager } from "./hookManager.js";
 import { LspManager } from "./lspManager.js";
 import { McpManager } from "./mcpManager.js";
 import { SlashCommandManager } from "./slashCommandManager.js";
+import { SubagentManager } from "./subagentManager.js";
 import { MarketplaceService } from "../services/MarketplaceService.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { Container } from "../utils/container.js";
@@ -53,6 +54,10 @@ export class PluginManager {
     return this.container.get<ConfigurationService>("ConfigurationService");
   }
 
+  private get subagentManager(): SubagentManager | undefined {
+    return this.container.get<SubagentManager>("SubagentManager");
+  }
+
   /**
    * Update enabled plugins configuration
    */
@@ -155,6 +160,7 @@ export class PluginManager {
         path: absolutePath,
         commands: PluginLoader.loadCommands(absolutePath),
         skills: await PluginLoader.loadSkills(absolutePath),
+        agents: await PluginLoader.loadAgents(absolutePath),
         lspConfig: await PluginLoader.loadLspConfig(absolutePath),
         mcpConfig: await PluginLoader.loadMcpConfig(absolutePath),
         hooksConfig: await PluginLoader.loadHooksConfig(absolutePath),
@@ -192,6 +198,10 @@ export class PluginManager {
         this.hookManager.registerPluginHooks(plugin.path, plugin.hooksConfig);
       }
 
+      if (this.subagentManager && plugin.agents.length > 0) {
+        this.subagentManager.registerPluginAgents(plugin.name, plugin.agents);
+      }
+
       this.plugins.set(manifest.name, plugin);
       logger?.info(`Loaded plugin: ${manifest.name} v${manifest.version}`);
     } catch (error) {

package/src/managers/subagentManager.ts

@@ -187,10 +187,57 @@ export class SubagentManager {
    * Find subagent by exact name match
    */
   async findSubagent(name: string) {
+    // Check cached configurations first (includes plugin agents)
+    if (this.cachedConfigurations !== null) {
+      const cached = this.cachedConfigurations.find(
+        (config) => config.name === name,
+      );
+      if (cached) return cached;
+    }
+    // Fall back to filesystem scan for non-plugin agents
     const { findSubagentByName } = await import("../utils/subagentParser.js");
     return findSubagentByName(name, this.workdir);
   }
 
+  /**
+   * Register plugin agents into the cached configurations.
+   * Names each agent as `pluginName:agentName` to avoid collisions.
+   */
+  registerPluginAgents(
+    pluginName: string,
+    agents: SubagentConfiguration[],
+  ): void {
+    if (this.cachedConfigurations === null) {
+      // Should not happen if initialization order is correct
+      this.cachedConfigurations = [];
+    }
+
+    // Remove any previously registered agents for this plugin (by name prefix)
+    this.cachedConfigurations = this.cachedConfigurations.filter(
+      (config) => !config.name.startsWith(`${pluginName}:`),
+    );
+
+    for (const agent of agents) {
+      const namespacedName = `${pluginName}:${agent.name}`;
+      const namespacedAgent: SubagentConfiguration = {
+        ...agent,
+        name: namespacedName,
+        // Safety net: substitute any remaining ${WAVE_PLUGIN_ROOT} placeholders
+        systemPrompt: agent.systemPrompt.replace(
+          /\$\{WAVE_PLUGIN_ROOT\}/g,
+          agent.pluginRoot ?? "",
+        ),
+      };
+      this.cachedConfigurations!.push(namespacedAgent);
+    }
+
+    // Re-sort by priority then name
+    this.cachedConfigurations!.sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.name.localeCompare(b.name);
+    });
+  }
+
   /**
    * Create a new subagent instance with isolated managers
    */

package/src/prompts/index.ts

@@ -179,7 +179,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
 
-export const COMPRESS_MESSAGES_SYSTEM_PROMPT = `You are continuing work on a software engineering task. Write a detailed continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary.
+export const COMPACT_MESSAGES_SYSTEM_PROMPT = `You are continuing work on a software engineering task. Write a detailed continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary.
 
 First, write your analysis in <analysis> tags as a thinking scratchpad:
 - Chronologically review the conversation