wave-agent-sdk 0.10.4 → 0.11.1

package/dist/utils/subagentParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+KD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAsBlC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}
+{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAwLD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAsBlC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}

package/dist/utils/subagentParser.js

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync, statSync } from "fs";
-import { join, extname } from "path";
+import { join, extname, basename } from "path";
 import { logger } from "./globalLogger.js";
+import { getBuiltinSubagentsDir } from "./configPaths.js";
 /**
  * Parse YAML frontmatter from markdown file content
  */
@@ -85,10 +86,19 @@ function parseSubagentFile(filePath, scope) {
     try {
         const content = readFileSync(filePath, "utf-8");
         const { frontmatter, body } = parseFrontmatter(content);
+        // Use filename as default name if not specified in frontmatter
+        if (!frontmatter.name) {
+            frontmatter.name = basename(filePath, extname(filePath));
+        }
         validateConfiguration(frontmatter, filePath);
         if (!body.trim()) {
             throw new Error(`Empty system prompt in ${filePath}`);
         }
+        let priority = 1;
+        if (scope === "user")
+            priority = 2;
+        if (scope === "builtin")
+            priority = 3;
         return {
             name: frontmatter.name,
             description: frontmatter.description,
@@ -97,7 +107,7 @@ function parseSubagentFile(filePath, scope) {
             systemPrompt: body,
             filePath,
             scope,
-            priority: scope === "project" ? 1 : 2,
+            priority,
         };
     }
     catch (error) {
@@ -137,9 +147,9 @@ function scanSubagentDirectory(dirPath, scope) {
 export async function loadSubagentConfigurations(workdir) {
     const projectDir = join(workdir, ".wave", "agents");
     const userDir = join(process.env.HOME || "~", ".wave", "agents");
+    const builtinDir = getBuiltinSubagentsDir();
     // Load configurations from all sources
-    const { getBuiltinSubagents } = await import("./builtinSubagents.js");
-    const builtinConfigs = getBuiltinSubagents();
+    const builtinConfigs = scanSubagentDirectory(builtinDir, "builtin");
     const projectConfigs = scanSubagentDirectory(projectDir, "project");
     const userConfigs = scanSubagentDirectory(userDir, "user");
     // Merge configurations, with project configs taking highest precedence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.10.4",
+  "version": "0.11.1",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -24,11 +24,13 @@
     "bin",
     "vendor",
     "scripts",
+    "builtin",
     "README.md"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.18.2",
     "chokidar": "^5.0.0",
+    "cron-parser": "^5.5.0",
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
     "minimatch": "^10.0.3",
@@ -47,7 +49,7 @@
   "license": "MIT",
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
-    "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && cp -r src/builtin-skills dist/builtin-skills",
+    "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "type-check": "tsc --noEmit --incremental",
     "watch": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
     "test": "vitest run --reporter=dot",

package/src/agent.ts

@@ -6,6 +6,7 @@ import { SubagentManager } from "./managers/subagentManager.js";
 import { McpManager } from "./managers/mcpManager.js";
 import { LspManager } from "./managers/lspManager.js";
 import { BangManager } from "./managers/bangManager.js";
+import { CronManager } from "./managers/cronManager.js";
 import { BackgroundTaskManager } from "./managers/backgroundTaskManager.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
 import { PluginManager } from "./managers/pluginManager.js";
@@ -56,6 +57,7 @@ export class Agent {
   private slashCommandManager: SlashCommandManager; // Add slash command manager instance
   private pluginManager: PluginManager; // Add plugin manager instance
   private skillManager: SkillManager; // Add skill manager instance
+  private cronManager: CronManager; // Add cron manager instance
   private hookManager: HookManager; // Add hooks manager instance
   private reversionManager: ReversionManager;
   private memoryRuleManager: MemoryRuleManager; // Add memory rule manager instance
@@ -168,6 +170,7 @@ export class Agent {
     this.slashCommandManager = this.container.get("SlashCommandManager")!;
     this.pluginManager = this.container.get("PluginManager")!;
     this.bangManager = this.container.get("BangManager")!;
+    this.cronManager = this.container.get("CronManager")!;
 
     // Set initial permission mode if provided
     if (options.permissionMode) {
@@ -411,8 +414,8 @@ export class Agent {
     await this.bangManager?.executeCommand(command);
   }
 
-  public clearMessages(): void {
-    this.messageManager.clearMessages();
+  public async clearMessages(): Promise<void> {
+    await this.slashCommandManager.executeCommand("clear");
   }
 
   /** Unified interrupt method, interrupts both AI messages and command execution */
@@ -460,6 +463,7 @@ export class Agent {
     this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
     this.abortBashCommand();
     this.abortSlashCommand();
+    this.cronManager.stop();
     // Cleanup background task manager
     this.backgroundTaskManager.cleanup();
     // Cleanup MCP connections
@@ -484,16 +488,6 @@ export class Agent {
     // Cleanup memory store
   }
 
-  /**
-   * Get a subagent instance by its ID
-   * @param subagentId - The ID of the subagent instance
-   */
-  public getSubagentInstance(
-    subagentId: string,
-  ): import("./managers/subagentManager.js").SubagentInstance | null {
-    return this.subagentManager.getInstance(subagentId);
-  }
-
   /**
    * Trigger the rewind UI callback
    */
@@ -688,6 +682,17 @@ export class Agent {
     await this.permissionManager.addPermissionRule(rule);
   }
 
+  /**
+   * Get subagent instance by ID
+   * @param subagentId - The ID of the subagent instance
+   * @returns The subagent instance or null if not found
+   */
+  public getSubagentInstance(
+    subagentId: string,
+  ): import("./managers/subagentManager.js").SubagentInstance | null {
+    return this.subagentManager.getInstance(subagentId);
+  }
+
   /**
    * Get the current task list ID
    */

package/src/constants/tools.ts

@@ -15,3 +15,6 @@ export const TASK_GET_TOOL_NAME = "TaskGet";
 export const TASK_UPDATE_TOOL_NAME = "TaskUpdate";
 export const TASK_LIST_TOOL_NAME = "TaskList";
 export const WRITE_TOOL_NAME = "Write";
+export const CRON_CREATE_TOOL_NAME = "CronCreate";
+export const CRON_DELETE_TOOL_NAME = "CronDelete";
+export const CRON_LIST_TOOL_NAME = "CronList";

package/src/index.ts

@@ -7,6 +7,7 @@ export * from "./constants/tools.js";
 // Export main agent
 export * from "./agent.js";
 export * from "./core/plugin.js";
+export * from "./managers/cronManager.js";
 
 // Export all utilities
 export * from "./utils/bashParser.js";

package/src/managers/aiManager.ts

@@ -8,6 +8,7 @@ import type {
   ModelConfig,
   Usage,
   PermissionMode,
+  Message,
 } from "../types/index.js";
 import type { ToolManager } from "./toolManager.js";
 import type { ToolContext, ToolResult } from "../tools/types.js";
@@ -160,26 +161,18 @@ export class AIManager {
   /**
    * Get filtered tool configuration based on tools list
    */
-  private getFilteredToolsConfig(tools?: string[]) {
+  private getFilteredToolsConfig() {
     // Get available subagents and skills for dynamic prompts
     const availableSubagents = this.subagentManager?.getConfigurations();
     const availableSkills = this.skillManager
       ?.getAvailableSkills()
       .filter((skill) => !skill.disableModelInvocation);
 
-    const allTools = this.toolManager.getToolsConfig({
+    return this.toolManager.getToolsConfig({
       availableSubagents,
       availableSkills,
       workdir: this.workdir,
     });
-
-    // If no tools specified, return all tools
-    if (!tools || tools.length === 0) {
-      return allTools;
-    }
-
-    // Filter tools
-    return allTools.filter((tool) => tools.includes(tool.function.name));
   }
 
   public setIsLoading(isLoading: boolean): void {
@@ -336,18 +329,10 @@ export class AIManager {
       model?: string;
       /** Rules for automatic tool approval (e.g., "Bash(git status*)") */
       allowedRules?: string[];
-      /** List of tools available to the AI (e.g., ["Bash", "Read"]) */
-      tools?: string[];
       maxTokens?: number;
     } = {},
   ): Promise<void> {
-    const {
-      recursionDepth = 0,
-      model,
-      allowedRules,
-      tools,
-      maxTokens,
-    } = options;
+    const { recursionDepth = 0, model, allowedRules, maxTokens } = options;
 
     // Only check isLoading for the initial call (recursionDepth === 0)
     if (recursionDepth === 0 && this.isLoading) {
@@ -401,7 +386,7 @@ export class AIManager {
       const currentMode = this.permissionManager?.getCurrentEffectiveMode(
         this.getModelConfig().permissionMode,
       );
-      const toolsConfig = this.getFilteredToolsConfig(tools);
+      const toolsConfig = this.getFilteredToolsConfig();
       const toolNames = new Set(toolsConfig.map((t) => t.function.name));
       const filteredToolPlugins = this.toolManager
         .getTools()
@@ -489,7 +474,6 @@ export class AIManager {
             name: toolCall.name,
             parameters: toolCall.parameters,
             parametersChunk: toolCall.parametersChunk,
-            compactParams: toolCall.parameters?.split("\n").pop()?.slice(-30),
             stage: toolCall.stage || "streaming", // Default to streaming if stage not provided
           });
         };
@@ -655,7 +639,18 @@ export class AIManager {
               toolArgs,
             );
 
-            // Emit running stage for non-streaming tool calls (tool execution about to start)
+            // Emit start stage for non-streaming tool calls
+            if (!this.stream) {
+              this.messageManager.updateToolBlock({
+                id: toolId,
+                stage: "start",
+                name: toolName,
+                compactParams,
+                parameters: argsString,
+              });
+            }
+
+            // Emit running stage (tool execution about to start)
             this.messageManager.updateToolBlock({
               id: toolId,
               stage: "running",
@@ -717,6 +712,7 @@ export class AIManager {
                 error: toolResult.error,
                 stage: "end",
                 name: toolName,
+                compactParams,
                 shortResult: toolResult.shortResult,
                 isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
                 startLineNumber: toolResult.startLineNumber,
@@ -803,12 +799,65 @@ export class AIManager {
             });
           }
 
+          // Duplicate Tool Call Detection
+          if (toolCalls.length > 0) {
+            const messages = this.messageManager.getMessages();
+            // Find the most recent assistant message BEFORE the current one that has tool blocks
+            // The current assistant message is messages[messages.length - 1]
+            let previousAssistantWithTools: Message | undefined;
+            for (let i = messages.length - 2; i >= 0; i--) {
+              const msg = messages[i];
+              if (
+                msg.role === "assistant" &&
+                msg.blocks.some((b) => b.type === "tool")
+              ) {
+                previousAssistantWithTools = msg;
+                break;
+              }
+            }
+
+            if (previousAssistantWithTools) {
+              const previousToolBlocks =
+                previousAssistantWithTools.blocks.filter(
+                  (b): b is import("../types/messaging.js").ToolBlock =>
+                    b.type === "tool",
+                );
+
+              for (const currentToolCall of toolCalls) {
+                const currentName = currentToolCall.function?.name;
+                const currentArgs = currentToolCall.function?.arguments;
+
+                const isDuplicate = previousToolBlocks.some(
+                  (prevBlock) =>
+                    prevBlock.name === currentName &&
+                    prevBlock.parameters === currentArgs,
+                );
+
+                if (isDuplicate && currentName) {
+                  const toolId = currentToolCall.id;
+                  const lastMessage = messages[messages.length - 1];
+                  const toolBlock = lastMessage.blocks.find(
+                    (b): b is import("../types/messaging.js").ToolBlock =>
+                      b.type === "tool" && b.id === toolId,
+                  );
+                  if (toolBlock) {
+                    const warning = `\n\nNote: You just called this tool with the same arguments in the previous turn. Please ensure you are not in a loop and consider if you need to change your approach.`;
+                    this.messageManager.updateToolBlock({
+                      id: toolId,
+                      result: (toolBlock.result || "") + warning,
+                      stage: "end",
+                    });
+                  }
+                }
+              }
+            }
+          }
+
           // Recursively call AI service, increment recursion depth, and pass same configuration
           await this.sendAIMessage({
             recursionDepth: recursionDepth + 1,
             model,
             allowedRules,
-            tools,
             maxTokens,
           });
         }
@@ -861,7 +910,6 @@ export class AIManager {
               recursionDepth: 0,
               model,
               allowedRules,
-              tools,
               maxTokens,
             });
           }

package/src/managers/cronManager.ts

@@ -0,0 +1,167 @@
+import { Container } from "../utils/container.js";
+import { CronJob } from "../types/cron.js";
+import { AIManager } from "./aiManager.js";
+import { MessageManager } from "./messageManager.js";
+import { CronExpressionParser } from "cron-parser";
+import { logger } from "../utils/globalLogger.js";
+
+export class CronManager {
+  private jobs = new Map<string, CronJob>();
+  private interval: NodeJS.Timeout | null = null;
+
+  constructor(private container: Container) {}
+
+  private get aiManager(): AIManager {
+    return this.container.get<AIManager>("AIManager")!;
+  }
+
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
+  }
+
+  public start(): void {
+    if (this.interval) return;
+    this.interval = setInterval(() => this.checkJobs(), 60000); // Check every minute
+  }
+
+  public stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+
+  public createJob(
+    job: Omit<CronJob, "id" | "createdAt" | "nextRun" | "periodMs">,
+  ): CronJob {
+    const id = Math.random().toString(36).substring(2, 11);
+    const createdAt = Date.now();
+
+    const interval = CronExpressionParser.parse(job.cron);
+    const nextRunDate = interval.next().toDate();
+    const nextRun = nextRunDate.getTime();
+
+    // Calculate periodMs
+    const secondRunDate = interval.next().toDate();
+    const periodMs = secondRunDate.getTime() - nextRunDate.getTime();
+
+    // Apply Jitter
+    const jitteredNextRun = this.applyJitter(
+      nextRun,
+      periodMs,
+      job.recurring,
+      nextRunDate,
+      id,
+    );
+
+    const newJob: CronJob = {
+      ...job,
+      id,
+      createdAt,
+      nextRun: jitteredNextRun,
+      periodMs,
+    };
+
+    this.jobs.set(id, newJob);
+    return newJob;
+  }
+
+  public deleteJob(id: string): boolean {
+    return this.jobs.delete(id);
+  }
+
+  public listJobs(): CronJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  private applyJitter(
+    nextRun: number,
+    periodMs: number,
+    recurring: boolean,
+    nextRunDate: Date,
+    id: string,
+  ): number {
+    const deterministicRandom = this.getDeterministicRandom(id);
+    if (recurring) {
+      // Recurring: Random delay up to 10% of period (max 15 min)
+      const maxJitter = Math.min(periodMs * 0.1, 15 * 60 * 1000);
+      return nextRun + deterministicRandom * maxJitter;
+    } else {
+      // One-shot: Random early fire up to 90s if scheduled on :00 or :30
+      const minutes = nextRunDate.getMinutes();
+      const seconds = nextRunDate.getSeconds();
+      if ((minutes === 0 || minutes === 30) && seconds === 0) {
+        return nextRun - deterministicRandom * 90 * 1000;
+      }
+    }
+    return nextRun;
+  }
+
+  private getDeterministicRandom(id: string): number {
+    let hash = 0;
+    for (let i = 0; i < id.length; i++) {
+      const char = id.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0; // Convert to 32bit integer
+    }
+    // Use a simple LCG-like approach to get a value between 0 and 1
+    const x = Math.sin(hash) * 10000;
+    return x - Math.floor(x);
+  }
+
+  private async checkJobs(): Promise<void> {
+    const now = Date.now();
+    const aiManager = this.aiManager;
+    const messageManager = this.messageManager;
+
+    for (const [id, job] of this.jobs.entries()) {
+      // Expiration: Recurring jobs MUST auto-expire after 7 days
+      if (job.recurring && now - job.createdAt > 7 * 24 * 60 * 60 * 1000) {
+        this.jobs.delete(id);
+        continue;
+      }
+
+      if (now >= job.nextRun) {
+        // Idle-Check: Only fire jobs if AIManager.isLoading is false
+        if (aiManager.isLoading) {
+          logger?.debug(`CronManager: Skipping job ${id} because AI is busy`);
+          continue;
+        }
+
+        logger?.info(`CronManager: Firing job ${id}: ${job.prompt}`);
+
+        // Execution
+        messageManager.addUserMessage({ content: job.prompt });
+        aiManager.sendAIMessage().catch((err) => {
+          logger?.error(`CronManager: Failed to execute job ${id}`, err);
+        });
+
+        if (job.recurring) {
+          // Schedule next run
+          try {
+            const interval = CronExpressionParser.parse(job.cron, {
+              currentDate: new Date(job.nextRun + 1000),
+            });
+            const nextRunDate = interval.next().toDate();
+            const nextRun = nextRunDate.getTime();
+            job.nextRun = this.applyJitter(
+              nextRun,
+              job.periodMs,
+              true,
+              nextRunDate,
+              id,
+            );
+          } catch (e) {
+            logger?.error(
+              `CronManager: Failed to parse cron for recurring job ${id}`,
+              e,
+            );
+            this.jobs.delete(id);
+          }
+        } else {
+          this.jobs.delete(id);
+        }
+      }
+    }
+  }
+}

package/src/managers/hookManager.ts

@@ -236,13 +236,17 @@ export class HookManager {
     for (const result of results) {
       if (result.exitCode === 2) {
         // Handle blocking error immediately and return
-        return this.handleBlockingError(
+        const blockingResult = this.handleBlockingError(
           event,
           result,
           messageManager,
           toolId,
           toolParameters,
         );
+        return {
+          shouldBlock: blockingResult.shouldBlock,
+          errorMessage: blockingResult.errorMessage,
+        };
       }
     }
 
@@ -280,7 +284,7 @@ export class HookManager {
         source: MessageSource.HOOK,
       });
     }
-    // For other hook types (PreToolUse, PostToolUse, Stop), ignore stdout
+    // For other hook types (PreToolUse, PostToolUse, Stop, PermissionRequest), ignore stdout
   }
 
   /**
@@ -338,10 +342,10 @@ export class HookManager {
         });
         return { shouldBlock: true, errorMessage };
 
-      case "Notification":
-        // For notification hooks with exit code 2, only show stderr in error block
+      case "PermissionRequest":
+        // For permission request hooks with exit code 2, show stderr in error block and block (deny) permission
         messageManager.addErrorBlock(errorMessage);
-        return { shouldBlock: false };
+        return { shouldBlock: true, errorMessage };
 
       case "SubagentStop":
         // Similar to Stop, show error and allow blocking
@@ -544,7 +548,11 @@ export class HookManager {
     }
 
     // Validate tool-specific requirements
-    if (event === "PreToolUse" || event === "PostToolUse") {
+    if (
+      event === "PreToolUse" ||
+      event === "PostToolUse" ||
+      event === "PermissionRequest"
+    ) {
       if (!context.toolName || typeof context.toolName !== "string") {
         errors.push(`${event} event requires a valid toolName in context`);
       }
@@ -554,7 +562,6 @@ export class HookManager {
     if (
       (event === "UserPromptSubmit" ||
         event === "Stop" ||
-        event === "Notification" ||
         event === "SubagentStop" ||
         event === "WorktreeCreate") &&
       context.toolName !== undefined
@@ -631,7 +638,6 @@ export class HookManager {
     if (
       event === "UserPromptSubmit" ||
       event === "Stop" ||
-      event === "Notification" ||
       event === "SubagentStop" ||
       event === "WorktreeCreate"
     ) {
@@ -639,7 +645,11 @@ export class HookManager {
     }
 
     // For tool-based events, check matcher if present
-    if (event === "PreToolUse" || event === "PostToolUse") {
+    if (
+      event === "PreToolUse" ||
+      event === "PostToolUse" ||
+      event === "PermissionRequest"
+    ) {
       if (!config.matcher) {
         // No matcher means applies to all tools
         return true;
@@ -673,7 +683,12 @@ export class HookManager {
     }
 
     // Validate matcher requirements
-    if ((event === "PreToolUse" || event === "PostToolUse") && config.matcher) {
+    if (
+      (event === "PreToolUse" ||
+        event === "PostToolUse" ||
+        event === "PermissionRequest") &&
+      config.matcher
+    ) {
       if (!this.matcher.isValidPattern(config.matcher)) {
         errors.push(`${prefix}: Invalid matcher pattern: ${config.matcher}`);
       }
@@ -683,7 +698,6 @@ export class HookManager {
     if (
       (event === "UserPromptSubmit" ||
         event === "Stop" ||
-        event === "Notification" ||
         event === "SubagentStop" ||
         event === "WorktreeCreate") &&
       config.matcher
@@ -723,7 +737,7 @@ export class HookManager {
           UserPromptSubmit: 0,
           Stop: 0,
           SubagentStop: 0,
-          Notification: 0,
+          PermissionRequest: 0,
           WorktreeCreate: 0,
         },
       };
@@ -735,7 +749,7 @@ export class HookManager {
       UserPromptSubmit: 0,
       Stop: 0,
       SubagentStop: 0,
-      Notification: 0,
+      PermissionRequest: 0,
       WorktreeCreate: 0,
     };
 

package/src/managers/liveConfigManager.ts

@@ -258,8 +258,8 @@ export class LiveConfigManager {
 
       // Update permission manager if available
       if (this.permissionManager) {
-        this.permissionManager.updateConfiguredDefaultMode(
-          this.currentConfiguration.permissions?.defaultMode,
+        this.permissionManager.updateConfiguredPermissionMode(
+          this.currentConfiguration.permissions?.permissionMode,
         );
         this.permissionManager.updateAllowedRules(
           this.currentConfiguration.permissions?.allow || [],