wave-agent-sdk 0.0.6 → 0.0.8

package/dist/managers/hookManager.d.ts

@@ -4,24 +4,17 @@
  * Central orchestrator for the hooks system. Handles configuration loading,
  * validation, and hook execution across all supported events.
  */
-import { type HookEvent, type HookConfiguration, type PartialHookConfiguration, type HookExecutionContext, type ExtendedHookExecutionContext, type HookExecutionResult, type ValidationResult } from "../types/hooks.js";
-import { type IHookMatcher } from "../utils/hookMatcher.js";
+import { type HookEvent, type WaveConfiguration, type PartialHookConfiguration, type HookExecutionContext, type ExtendedHookExecutionContext, type HookExecutionResult, type ValidationResult } from "../types/hooks.js";
+import { HookMatcher } from "../utils/hookMatcher.js";
 import type { Logger } from "../types/index.js";
 import type { MessageManager } from "./messageManager.js";
-export interface IHookManager {
-    loadConfiguration(userHooks?: PartialHookConfiguration, projectHooks?: PartialHookConfiguration): void;
-    loadConfigurationFromSettings(): void;
-    executeHooks(event: HookEvent, context: HookExecutionContext | ExtendedHookExecutionContext): Promise<HookExecutionResult[]>;
-    hasHooks(event: HookEvent, toolName?: string): boolean;
-    validateConfiguration(config: HookConfiguration): ValidationResult;
-    getConfiguration(): PartialHookConfiguration | undefined;
-}
-export declare class HookManager implements IHookManager {
+export declare class HookManager {
     private configuration;
+    private environmentVars;
     private readonly matcher;
     private readonly logger?;
     private readonly workdir;
-    constructor(workdir: string, matcher?: IHookMatcher, logger?: Logger);
+    constructor(workdir: string, matcher?: HookMatcher, logger?: Logger);
     /**
      * Load and merge hook configurations from user and project settings
      * Project settings take precedence over user settings
@@ -29,7 +22,7 @@ export declare class HookManager implements IHookManager {
     loadConfiguration(userHooks?: PartialHookConfiguration, projectHooks?: PartialHookConfiguration): void;
     /**
      * Load configuration from filesystem settings
-     * Automatically loads and merges user and project hooks configuration
+     * Automatically loads and merges user and project Wave configuration (hooks + environment)
      */
     loadConfigurationFromSettings(): void;
     /**
@@ -40,7 +33,7 @@ export declare class HookManager implements IHookManager {
      * Process hook execution results and determine appropriate actions
      * based on exit codes and hook event type
      */
-    processHookResults(event: HookEvent, results: HookExecutionResult[], messageManager?: MessageManager, toolId?: string, originalToolResult?: string): {
+    processHookResults(event: HookEvent, results: HookExecutionResult[], messageManager?: MessageManager, toolId?: string, toolParameters?: string): {
         shouldBlock: boolean;
         errorMessage?: string;
     };
@@ -61,9 +54,9 @@ export declare class HookManager implements IHookManager {
      */
     hasHooks(event: HookEvent, toolName?: string): boolean;
     /**
-     * Validate hook configuration structure and content
+     * Validate Wave configuration structure and content
      */
-    validateConfiguration(config: HookConfiguration): ValidationResult;
+    validateConfiguration(config: WaveConfiguration): ValidationResult;
     /**
      * Validate partial hook configuration structure and content
      */
@@ -72,6 +65,10 @@ export declare class HookManager implements IHookManager {
      * Get current configuration
      */
     getConfiguration(): PartialHookConfiguration | undefined;
+    /**
+     * Get current environment variables
+     */
+    getEnvironmentVars(): Record<string, string> | undefined;
     /**
      * Clear current configuration
      */

package/dist/managers/hookManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hookManager.d.ts","sourceRoot":"","sources":["../../src/managers/hookManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hookManager.d.ts","sourceRoot":"","sources":["../../src/managers/hookManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EAItB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,qBAAa,WAAW;IACtB,OAAO,CAAC,aAAa,CAAuC;IAC5D,OAAO,CAAC,eAAe,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAG/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,WAA+B,EACxC,MAAM,CAAC,EAAE,MAAM;IAOjB;;;OAGG;IACH,iBAAiB,CACf,SAAS,CAAC,EAAE,wBAAwB,EACpC,YAAY,CAAC,EAAE,wBAAwB,GACtC,IAAI;IAyBP;;;OAGG;IACH,6BAA6B,IAAI,IAAI;IA6CrC;;OAEG;IACG,YAAY,CAChB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,oBAAoB,GAAG,4BAA4B,GAC3D,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA0HjC;;;OAGG;IACH,kBAAkB,CAChB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,mBAAmB,EAAE,EAC9B,cAAc,CAAC,EAAE,cAAc,EAC/B,MAAM,CAAC,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,MAAM,GACtB;QACD,WAAW,EAAE,OAAO,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;IAuCD;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAezB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyD3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAQ9B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO;IAWtD;;OAEG;IACH,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,gBAAgB;IA8DlE;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAyCpC;;OAEG;IACH,gBAAgB,IAAI,wBAAwB,GAAG,SAAS;IAOxD;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAOxD;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAmDhC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,aAAa;IA4BrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;OAEG;IACH,qBAAqB,IAAI;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;KAC3C;CA6CF"}

package/dist/managers/hookManager.js

@@ -6,7 +6,8 @@
  */
 import { HookConfigurationError, isValidHookEvent, isValidHookEventConfig, } from "../types/hooks.js";
 import { HookMatcher } from "../utils/hookMatcher.js";
-import { executeCommand, isCommandSafe, loadMergedHooksConfig, } from "../services/hook.js";
+import { executeCommand, isCommandSafe, loadMergedWaveConfig, } from "../services/hook.js";
+import { MessageSource } from "../types/index.js";
 export class HookManager {
     constructor(workdir, matcher = new HookMatcher(), logger) {
         this.workdir = workdir;
@@ -36,26 +37,28 @@ export class HookManager {
     }
     /**
      * Load configuration from filesystem settings
-     * Automatically loads and merges user and project hooks configuration
+     * Automatically loads and merges user and project Wave configuration (hooks + environment)
      */
     loadConfigurationFromSettings() {
         try {
             this.logger?.debug(`[HookManager] Loading configuration...`);
-            const mergedConfig = loadMergedHooksConfig(this.workdir);
-            this.logger?.debug(`[HookManager] Merged config result:`, mergedConfig);
-            this.configuration = mergedConfig || undefined;
+            const mergedWaveConfig = loadMergedWaveConfig(this.workdir);
+            this.logger?.debug(`[HookManager] Merged config result:`, mergedWaveConfig);
+            this.configuration = mergedWaveConfig?.hooks || undefined;
+            this.environmentVars = mergedWaveConfig?.env || undefined;
             // Validate the loaded configuration if it exists
-            if (mergedConfig) {
-                const validation = this.validatePartialConfiguration(mergedConfig);
+            if (mergedWaveConfig?.hooks) {
+                const validation = this.validatePartialConfiguration(mergedWaveConfig.hooks);
                 if (!validation.valid) {
                     throw new HookConfigurationError("filesystem settings", validation.errors);
                 }
             }
-            this.logger?.debug(`[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig || {}).length} event types`);
+            this.logger?.debug(`[HookManager] Configuration loaded successfully with ${Object.keys(mergedWaveConfig?.hooks || {}).length} event types and ${Object.keys(this.environmentVars || {}).length} environment variables`);
         }
         catch (error) {
             // If loading fails, start with undefined configuration (no hooks)
             this.configuration = undefined;
+            this.environmentVars = undefined;
             // Re-throw configuration errors, but handle file system errors gracefully
             if (error instanceof HookConfigurationError) {
                 throw error;
@@ -107,14 +110,14 @@ export class HookManager {
                 const hookCommand = config.hooks[commandIndex];
                 try {
                     this.logger?.debug(`[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`);
-                    const result = await executeCommand(hookCommand.command, context);
+                    const result = await executeCommand(hookCommand.command, context, undefined, this.environmentVars);
                     results.push(result);
                     // Report individual command result
                     if (result.success) {
                         this.logger?.debug(`[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`);
                     }
                     else {
-                        this.logger?.warn(`[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`);
+                        this.logger?.debug(`[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`);
                     }
                     // Continue with next command even if this one fails
                     // This allows for non-critical hooks to fail without stopping the workflow
@@ -142,7 +145,7 @@ export class HookManager {
      * Process hook execution results and determine appropriate actions
      * based on exit codes and hook event type
      */
-    processHookResults(event, results, messageManager, toolId, originalToolResult) {
+    processHookResults(event, results, messageManager, toolId, toolParameters) {
         if (!messageManager || results.length === 0) {
             return { shouldBlock: false };
         }
@@ -151,7 +154,7 @@ export class HookManager {
         for (const result of results) {
             if (result.exitCode === 2) {
                 // Handle blocking error immediately and return
-                return this.handleBlockingError(event, result, messageManager, toolId, originalToolResult);
+                return this.handleBlockingError(event, result, messageManager, toolId, toolParameters);
             }
         }
         // Second pass: Process all non-blocking results
@@ -177,14 +180,17 @@ export class HookManager {
     handleHookSuccess(event, result, messageManager) {
         if (event === "UserPromptSubmit" && result.stdout?.trim()) {
             // Inject stdout as user message context for UserPromptSubmit
-            messageManager.addUserMessage(result.stdout.trim());
+            messageManager.addUserMessage({
+                content: result.stdout.trim(),
+                source: MessageSource.HOOK,
+            });
         }
         // For other hook types (PreToolUse, PostToolUse, Stop), ignore stdout
     }
     /**
      * Handle blocking error (exit code 2) - behavior varies by hook type
      */
-    handleBlockingError(event, result, messageManager, toolId, originalToolResult) {
+    handleBlockingError(event, result, messageManager, toolId, toolParameters) {
         const errorMessage = result.stderr?.trim() || "Hook execution failed";
         switch (event) {
             case "UserPromptSubmit":
@@ -199,26 +205,28 @@ export class HookManager {
                 // Block tool execution and show error to Wave Agent via tool block
                 if (toolId) {
                     messageManager.updateToolBlock({
-                        toolId,
+                        id: toolId,
+                        parameters: toolParameters || "",
                         result: errorMessage,
                         success: false,
                         error: "Hook blocked tool execution",
+                        stage: "end", // Hook blocking results in end stage with error
                     });
                 }
                 return { shouldBlock: true };
             case "PostToolUse":
-                // Show error to Wave Agent via tool block, execution continues
-                if (toolId && originalToolResult !== undefined) {
-                    messageManager.updateToolBlock({
-                        toolId,
-                        result: `${originalToolResult}\n\nHook feedback: ${errorMessage}`,
-                        success: false,
-                    });
-                }
+                // Show error to Wave Agent via user message and allow AI to continue
+                messageManager.addUserMessage({
+                    content: errorMessage,
+                    source: MessageSource.HOOK,
+                });
                 return { shouldBlock: false };
             case "Stop":
                 // Show error to Wave Agent via user message and block stopping to continue conversation
-                messageManager.addUserMessage(errorMessage);
+                messageManager.addUserMessage({
+                    content: errorMessage,
+                    source: MessageSource.HOOK,
+                });
                 return { shouldBlock: true, errorMessage };
             default:
                 return { shouldBlock: false };
@@ -243,35 +251,53 @@ export class HookManager {
         return eventConfigs.some((config) => this.configApplies(config, event, toolName));
     }
     /**
-     * Validate hook configuration structure and content
+     * Validate Wave configuration structure and content
      */
     validateConfiguration(config) {
         const errors = [];
         if (!config || typeof config !== "object") {
             return { valid: false, errors: ["Configuration must be an object"] };
         }
-        if (!config.hooks || typeof config.hooks !== "object") {
-            return {
-                valid: false,
-                errors: ["Configuration must have a hooks property"],
-            };
+        // Validate hooks if present
+        if (config.hooks) {
+            if (typeof config.hooks !== "object") {
+                errors.push("hooks property must be an object");
+            }
+            else {
+                // Validate each hook event
+                for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
+                    // Validate event name
+                    if (!isValidHookEvent(eventName)) {
+                        errors.push(`Invalid hook event: ${eventName}`);
+                        continue;
+                    }
+                    // Validate event configurations
+                    if (!Array.isArray(eventConfigs)) {
+                        errors.push(`Hook event ${eventName} must be an array of configurations`);
+                        continue;
+                    }
+                    eventConfigs.forEach((eventConfig, index) => {
+                        const configErrors = this.validateEventConfig(eventName, eventConfig, index);
+                        errors.push(...configErrors);
+                    });
+                }
+            }
         }
-        // Validate each hook event
-        for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
-            // Validate event name
-            if (!isValidHookEvent(eventName)) {
-                errors.push(`Invalid hook event: ${eventName}`);
-                continue;
+        // Validate environment variables if present
+        if (config.env) {
+            if (typeof config.env !== "object" || Array.isArray(config.env)) {
+                errors.push("env property must be an object");
             }
-            // Validate event configurations
-            if (!Array.isArray(eventConfigs)) {
-                errors.push(`Hook event ${eventName} must be an array of configurations`);
-                continue;
+            else {
+                for (const [key, value] of Object.entries(config.env)) {
+                    if (typeof key !== "string" || key.trim() === "") {
+                        errors.push(`Invalid environment variable key: ${key}`);
+                    }
+                    if (typeof value !== "string") {
+                        errors.push(`Environment variable ${key} must have a string value`);
+                    }
+                }
             }
-            eventConfigs.forEach((eventConfig, index) => {
-                const configErrors = this.validateEventConfig(eventName, eventConfig, index);
-                errors.push(...configErrors);
-            });
         }
         return {
             valid: errors.length === 0,
@@ -317,6 +343,15 @@ export class HookManager {
         // Deep clone to prevent external modification
         return JSON.parse(JSON.stringify(this.configuration));
     }
+    /**
+     * Get current environment variables
+     */
+    getEnvironmentVars() {
+        if (!this.environmentVars)
+            return undefined;
+        // Deep clone to prevent external modification
+        return JSON.parse(JSON.stringify(this.environmentVars));
+    }
     /**
      * Clear current configuration
      */
@@ -457,6 +492,7 @@ export class HookManager {
                     PostToolUse: 0,
                     UserPromptSubmit: 0,
                     Stop: 0,
+                    SubagentStop: 0,
                 },
             };
         }
@@ -465,6 +501,7 @@ export class HookManager {
             PostToolUse: 0,
             UserPromptSubmit: 0,
             Stop: 0,
+            SubagentStop: 0,
         };
         let totalConfigs = 0;
         let totalCommands = 0;

package/dist/managers/liveConfigManager.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Live Configuration Manager
+ *
+ * Orchestrates live configuration reload functionality including:
+ * - Hook configuration watching and reloading
+ * - Memory store management for AGENTS.md files
+ * - Coordination between file watchers and configuration updates
+ */
+import type { Logger } from "../types/index.js";
+export interface LiveConfigManagerOptions {
+    workdir: string;
+    logger?: Logger;
+    onConfigurationChanged?: () => void;
+    onMemoryStoreFileChanged?: (filePath: string, changeType: "add" | "change" | "unlink") => Promise<void>;
+}
+export declare class LiveConfigManager {
+    private readonly workdir;
+    private readonly logger?;
+    private readonly onConfigurationChanged?;
+    private readonly onMemoryStoreFileChanged?;
+    private configurationWatcher?;
+    private isInitialized;
+    constructor(options: LiveConfigManagerOptions);
+    /**
+     * Initialize live configuration management
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown live configuration management
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Initialize configuration watcher for hook settings
+     */
+    private initializeConfigurationWatcher;
+    /**
+     * Initialize memory store watching for AGENTS.md files
+     */
+    private initializeMemoryStoreWatching;
+    /**
+     * Handle configuration change events
+     */
+    private handleConfigurationChange;
+    /**
+     * Handle AGENTS.md file change events
+     */
+    private handleMemoryStoreFileChange;
+    /**
+     * Get initialization status
+     */
+    get initialized(): boolean;
+    /**
+     * Get configuration file paths for user and project settings
+     * Returns paths in priority order (local.json first, then .json)
+     */
+    private getConfigurationPaths;
+}
+//# sourceMappingURL=liveConfigManager.d.ts.map

package/dist/managers/liveConfigManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveConfigManager.d.ts","sourceRoot":"","sources":["../../src/managers/liveConfigManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAehD,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,MAAM,IAAI,CAAC;IACpC,wBAAwB,CAAC,EAAE,CACzB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAa;IACrD,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAGvB;IACnB,OAAO,CAAC,oBAAoB,CAAC,CAAuB;IACpD,OAAO,CAAC,aAAa,CAAkB;gBAE3B,OAAO,EAAE,wBAAwB;IAO7C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BjC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB/B;;OAEG;YACW,8BAA8B;IAoB5C;;OAEG;YACW,6BAA6B;IA4B3C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA8BjC;;OAEG;YACW,2BAA2B;IA8BzC;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CAQ9B"}

package/dist/managers/liveConfigManager.js

@@ -0,0 +1,160 @@
+/**
+ * Live Configuration Manager
+ *
+ * Orchestrates live configuration reload functionality including:
+ * - Hook configuration watching and reloading
+ * - Memory store management for AGENTS.md files
+ * - Coordination between file watchers and configuration updates
+ */
+import { ConfigurationWatcher, } from "../services/configurationWatcher.js";
+import { configResolver } from "../utils/configResolver.js";
+import { join } from "path";
+import { getUserConfigPaths, getProjectConfigPaths, } from "../utils/configPaths.js";
+import { CONFIGURATION_EVENTS } from "../constants/events.js";
+export class LiveConfigManager {
+    constructor(options) {
+        this.isInitialized = false;
+        this.workdir = options.workdir;
+        this.logger = options.logger;
+        this.onConfigurationChanged = options.onConfigurationChanged;
+        this.onMemoryStoreFileChanged = options.onMemoryStoreFileChanged;
+    }
+    /**
+     * Initialize live configuration management
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            this.logger?.debug("[LiveConfigManager] Already initialized");
+            return;
+        }
+        try {
+            // Initialize configuration watcher for hook settings
+            await this.initializeConfigurationWatcher();
+            // Initialize memory store watching for AGENTS.md if callback is available
+            if (this.onMemoryStoreFileChanged) {
+                await this.initializeMemoryStoreWatching();
+            }
+            this.isInitialized = true;
+            this.logger?.info("Live Config: Live configuration management initialized successfully");
+        }
+        catch (error) {
+            this.logger?.error(`Live Config: Failed to initialize: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Shutdown live configuration management
+     */
+    async shutdown() {
+        if (!this.isInitialized) {
+            return;
+        }
+        try {
+            if (this.configurationWatcher) {
+                await this.configurationWatcher.shutdown();
+                this.configurationWatcher = undefined;
+            }
+            this.isInitialized = false;
+            this.logger?.info("Live Config: Live configuration management shutdown completed");
+        }
+        catch (error) {
+            this.logger?.error(`Live Config: Error during shutdown: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Initialize configuration watcher for hook settings
+     */
+    async initializeConfigurationWatcher() {
+        this.configurationWatcher = new ConfigurationWatcher(this.workdir, this.logger);
+        // Set up configuration change handler using EventEmitter pattern
+        this.configurationWatcher.on(CONFIGURATION_EVENTS.CONFIGURATION_CHANGE, (event) => {
+            this.handleConfigurationChange(event);
+        });
+        // Initialize watching for user and project settings
+        const { userPaths, projectPaths } = this.getConfigurationPaths();
+        await this.configurationWatcher.initializeWatching(userPaths, projectPaths);
+        this.logger?.info("Live Config: Configuration watching initialized");
+    }
+    /**
+     * Initialize memory store watching for AGENTS.md files
+     */
+    async initializeMemoryStoreWatching() {
+        if (!this.onMemoryStoreFileChanged || !this.configurationWatcher) {
+            this.logger?.debug("Live Config: Memory store callback or configuration watcher not available, skipping AGENTS.md watching");
+            return;
+        }
+        try {
+            const agentsFilePath = join(this.workdir, "AGENTS.md");
+            // Add AGENTS.md to file watcher
+            await this.configurationWatcher.watchAdditionalFile(agentsFilePath, async (event) => {
+                await this.handleMemoryStoreFileChange(event);
+            });
+            this.logger?.info("Live Config: AGENTS.md file watching initialized");
+        }
+        catch (error) {
+            this.logger?.warn(`Live Config: Failed to initialize AGENTS.md watching: ${error.message}`);
+            // Don't throw - memory optimization is not critical for core functionality
+        }
+    }
+    /**
+     * Handle configuration change events
+     */
+    handleConfigurationChange(event) {
+        this.logger?.info(`Live Config: Configuration change detected: ${event.type} at ${event.path}`);
+        // Invalidate and refresh configuration cache for live environment variable updates
+        configResolver.invalidateCache(this.workdir);
+        configResolver.refreshCache(this.workdir);
+        // Trigger Agent configuration update callback if provided
+        if (this.onConfigurationChanged) {
+            try {
+                this.logger?.info("Live Config: Triggering Agent configuration update");
+                this.onConfigurationChanged();
+            }
+            catch (error) {
+                this.logger?.error(`Live Config: Error in configuration change callback: ${error.message}`);
+            }
+        }
+        // Log cache status after refresh
+        const cacheStatus = configResolver.getCacheStatus();
+        if (cacheStatus) {
+            this.logger?.info(`Live Config: Configuration cache refreshed - ${cacheStatus.envVarCount} environment variables loaded`);
+        }
+    }
+    /**
+     * Handle AGENTS.md file change events
+     */
+    async handleMemoryStoreFileChange(event) {
+        if (!this.onMemoryStoreFileChanged) {
+            return;
+        }
+        try {
+            this.logger?.info(`Live Config: AGENTS.md ${event.type} detected: ${event.path}`);
+            const changeType = event.type === "delete"
+                ? "unlink"
+                : event.type === "create"
+                    ? "add"
+                    : "change";
+            await this.onMemoryStoreFileChanged(event.path, changeType);
+            this.logger?.info(`Live Config: Memory store updated for AGENTS.md ${event.type}`);
+        }
+        catch (error) {
+            this.logger?.error(`Live Config: Failed to handle AGENTS.md file change: ${error.message}`);
+        }
+    }
+    /**
+     * Get initialization status
+     */
+    get initialized() {
+        return this.isInitialized;
+    }
+    /**
+     * Get configuration file paths for user and project settings
+     * Returns paths in priority order (local.json first, then .json)
+     */
+    getConfigurationPaths() {
+        const userPaths = getUserConfigPaths();
+        const projectPaths = getProjectConfigPaths(this.workdir);
+        return { userPaths, projectPaths };
+    }
+}