@defai.digital/automatosx 5.3.3 → 5.3.4

package/dist/index.js

@@ -802,8 +802,77 @@ var init_path_resolver = __esm({
   }
 });
 
-// src/providers/base-provider.ts
+// src/core/cli-provider-detector.ts
 import { existsSync as existsSync5 } from "fs";
+import { delimiter } from "path";
+import { spawn, spawnSync } from "child_process";
+function findOnPath(cmdBase) {
+  const isWindows = process.platform === "win32";
+  if (isWindows) {
+    return findOnPathWindows(cmdBase);
+  }
+  return findOnPathUnix(cmdBase);
+}
+function findOnPathWindows(cmdBase) {
+  try {
+    const where = spawnSync("where", [cmdBase], {
+      windowsHide: true,
+      timeout: 3e3
+    });
+    if (where.status === 0) {
+      const lines = where.stdout.toString().split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+      const firstPath = lines[0];
+      if (firstPath) {
+        logger.debug("Found via where.exe", { cmdBase, path: firstPath });
+        return { found: true, path: firstPath };
+      }
+    }
+  } catch (error) {
+    logger.debug("where.exe failed, falling back to PATH scan", { error });
+  }
+  const pathext = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").toUpperCase().split(";").filter(Boolean);
+  const pathEntries = (process.env.PATH || "").split(delimiter).filter(Boolean);
+  for (const dir of pathEntries) {
+    for (const ext of pathext) {
+      const fullPath = `${dir}\\${cmdBase}${ext}`;
+      if (existsSync5(fullPath)) {
+        logger.debug("Found via PATH \xD7 PATHEXT", { cmdBase, path: fullPath });
+        return { found: true, path: fullPath };
+      }
+    }
+    const pathWithoutExt = `${dir}\\${cmdBase}`;
+    if (existsSync5(pathWithoutExt)) {
+      logger.debug("Found via PATH (no ext)", { cmdBase, path: pathWithoutExt });
+      return { found: true, path: pathWithoutExt };
+    }
+  }
+  return { found: false };
+}
+function findOnPathUnix(cmdBase) {
+  try {
+    const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
+    if (which.status === 0) {
+      const path3 = which.stdout.toString().trim();
+      if (path3) {
+        logger.debug("Found via which", { cmdBase, path: path3 });
+        return { found: true, path: path3 };
+      }
+    }
+  } catch (error) {
+    logger.debug("which failed", { cmdBase, error });
+  }
+  return { found: false };
+}
+var init_cli_provider_detector = __esm({
+  "src/core/cli-provider-detector.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+  }
+});
+
+// src/providers/base-provider.ts
+import { existsSync as existsSync6 } from "fs";
 var BaseProvider;
 var init_base_provider = __esm({
   "src/providers/base-provider.ts"() {
@@ -811,6 +880,7 @@ var init_base_provider = __esm({
     init_esm_shims();
     init_logger();
     init_cache();
+    init_cli_provider_detector();
     BaseProvider = class {
       config;
       health;
@@ -962,7 +1032,7 @@ var init_base_provider = __esm({
             logger.warn("Home directory shortcut detected (~)", { path: path3 });
             return false;
           }
-          return existsSync5(path3);
+          return existsSync6(path3);
         } catch (error) {
           logger.debug(`Error checking path existence`, {
             path: path3,
@@ -1022,8 +1092,8 @@ var init_base_provider = __esm({
        */
       async getProviderVersion(command) {
         try {
-          const { spawnSync } = await import("child_process");
-          const result = spawnSync(command, ["--version"], {
+          const { spawnSync: spawnSync2 } = await import("child_process");
+          const result = spawnSync2(command, ["--version"], {
             encoding: "utf8",
             timeout: 5e3,
             stdio: "pipe"
@@ -1041,41 +1111,20 @@ var init_base_provider = __esm({
       }
       /**
        * Check if the CLI command is available in the system (standard PATH detection)
+       * Uses cross-platform detection from cli-provider-detector for Windows compatibility
        */
       async checkCLIAvailability() {
         try {
-          const { spawn } = await import("child_process");
-          return new Promise((resolve10) => {
-            const child = spawn(this.config.command, ["--version"], {
-              stdio: "ignore",
-              timeout: 5e3
-            });
-            let resolved = false;
-            child.on("close", (code) => {
-              if (!resolved) {
-                resolved = true;
-                resolve10(code === 0 || code === 1);
-              }
-            });
-            child.on("error", (error) => {
-              if (!resolved) {
-                resolved = true;
-                if (error.code === "ENOENT") {
-                  logger.warn(`CLI command not found: ${this.config.command}`);
-                  resolve10(false);
-                } else {
-                  resolve10(true);
-                }
-              }
-            });
-            setTimeout(() => {
-              if (!resolved) {
-                resolved = true;
-                child.kill();
-                resolve10(false);
-              }
-            }, 5e3);
+          const result = findOnPath(this.config.command);
+          if (!result.found) {
+            logger.warn(`CLI command not found: ${this.config.command}`);
+            return false;
+          }
+          logger.debug(`Provider ${this.config.name} found on PATH`, {
+            command: this.config.command,
+            path: result.path
           });
+          return true;
         } catch (error) {
           logger.error(`Error checking CLI availability: ${error.message}`);
           return false;
@@ -1419,7 +1468,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        * Model selection is delegated to CLI's own defaults
        */
       async executeRealCLI(prompt, request) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         return new Promise((resolve10, reject) => {
           let stdout = "";
           let stderr = "";
@@ -1427,7 +1476,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
           const args = this.buildCLIArgs(request);
           let child;
           try {
-            child = spawn(this.config.command, args, {
+            child = spawn2(this.config.command, args, {
               stdio: ["pipe", "pipe", "pipe"],
               // Use pipe for stdin
               env: process.env
@@ -1720,7 +1769,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        * Model selection is delegated to CLI's own defaults
        */
       async executeRealCLI(prompt, request) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         return new Promise((resolve10, reject) => {
           let stdout = "";
           let stderr = "";
@@ -1728,7 +1777,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
           const args = [];
           args.push("--approval-mode", "auto_edit");
           args.push(prompt);
-          const child = spawn(this.config.command, args, {
+          const child = spawn2(this.config.command, args, {
             stdio: ["pipe", "pipe", "pipe"],
             env: process.env
           });
@@ -1951,14 +2000,14 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        * Model and other parameters are passed via -c (config override) or specific flags
        */
       async executeRealCLI(prompt, request) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         return new Promise((resolve10, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
           const args = this.buildCLIArgs(request);
           args.push(prompt);
-          const child = spawn(this.config.command, args, {
+          const child = spawn2(this.config.command, args, {
             stdio: ["pipe", "pipe", "pipe"],
             env: process.env
           });
@@ -2116,7 +2165,7 @@ This is a placeholder streaming response.`;
        * Execute real streaming CLI
        */
       async executeStreamingCLI(prompt, request, options) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         const startTime = Date.now();
         return new Promise((resolve10, reject) => {
           let fullOutput = "";
@@ -2126,7 +2175,7 @@ This is a placeholder streaming response.`;
           const args = this.buildCLIArgs(request);
           args.push("--stream");
           args.push(prompt);
-          const child = spawn(this.config.command, args, {
+          const child = spawn2(this.config.command, args, {
             stdio: ["pipe", "pipe", "pipe"],
             env: process.env
           });
@@ -4417,9 +4466,9 @@ async function initializeGitRepository(projectDir) {
       logger.info("Git repository already exists, skipping initialization");
       return;
     }
-    const { spawn } = await import("child_process");
+    const { spawn: spawn2 } = await import("child_process");
     await new Promise((resolve10, reject) => {
-      const child = spawn("git", ["init"], {
+      const child = spawn2("git", ["init"], {
         cwd: projectDir,
         stdio: "pipe"
       });
@@ -4531,12 +4580,12 @@ var listCommand = {
 };
 async function listAgents(pathResolver) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync11 } = await import("fs");
+  const { existsSync: existsSync12 } = await import("fs");
   const projectDir = await detectProjectRoot();
   const examplesDir = join3(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync11(agentsDir)) {
+    if (existsSync12(agentsDir)) {
       const files = await readdir2(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -4548,7 +4597,7 @@ async function listAgents(pathResolver) {
         }
       }
     }
-    if (existsSync11(examplesDir)) {
+    if (existsSync12(examplesDir)) {
       const files = await readdir2(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -8490,6 +8539,377 @@ var DelegationParser = class {
   }
 };
 
+// src/core/timeout-manager.ts
+init_esm_shims();
+
+// src/core/warning-emitter.ts
+init_esm_shims();
+init_logger();
+import { EventEmitter } from "events";
+var WarningEmitter = class extends EventEmitter {
+  constructor() {
+    super();
+    this.setupDefaultHandler();
+  }
+  /**
+   * Setup default warning handler
+   *
+   * Registers a default handler that logs timeout warnings to console.
+   * This handler is always registered and cannot be removed.
+   *
+   * @private
+   */
+  setupDefaultHandler() {
+    this.on("timeout-warning", (event) => {
+      this.logWarning(event);
+    });
+  }
+  /**
+   * Log timeout warning
+   *
+   * Formats and logs a timeout warning message with relevant details.
+   *
+   * @param event - Timeout warning event data
+   * @private
+   */
+  logWarning(event) {
+    const elapsedSeconds = Math.floor(event.elapsedMs / 1e3);
+    const remainingSeconds = Math.floor(event.remainingMs / 1e3);
+    const totalSeconds = Math.floor(event.timeoutMs / 1e3);
+    const message = [
+      `\u26A0\uFE0F  Timeout Warning: Agent "${event.agentName}" has been running for ${elapsedSeconds}s`,
+      `   Task: ${this.truncateTask(event.taskDescription)}`,
+      `   Remaining time: ${remainingSeconds}s (${this.formatTime(remainingSeconds)})`,
+      `   Total timeout: ${totalSeconds}s (${this.formatTime(totalSeconds)})`
+    ].join("\n");
+    logger.warn(message);
+  }
+  /**
+   * Truncate task description
+   *
+   * Truncates long task descriptions to keep warning messages concise.
+   *
+   * @param task - Task description
+   * @param maxLength - Maximum length (default: 80)
+   * @returns Truncated task description
+   * @private
+   */
+  truncateTask(task, maxLength = 80) {
+    if (task.length <= maxLength) {
+      return task;
+    }
+    return task.substring(0, maxLength - 3) + "...";
+  }
+  /**
+   * Format time in human-readable format
+   *
+   * Converts seconds to a human-readable format (e.g., "5m 30s", "1h 15m").
+   *
+   * @param seconds - Time in seconds
+   * @returns Formatted time string
+   * @private
+   */
+  formatTime(seconds) {
+    if (seconds < 60) {
+      return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+      return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+  }
+  /**
+   * Emit timeout warning
+   *
+   * Convenience method to emit a timeout warning event.
+   *
+   * @param event - Timeout warning event data
+   */
+  emitWarning(event) {
+    this.emit("timeout-warning", event);
+  }
+};
+
+// src/core/timeout-manager.ts
+init_logger();
+var DEFAULT_TIMEOUT = 15e5;
+var DEFAULT_WARNING_THRESHOLD = 0.8;
+var MIN_WARNING_THRESHOLD = 0.5;
+var MAX_WARNING_THRESHOLD = 0.95;
+var TimeoutManager = class {
+  config;
+  warningEmitter;
+  /**
+   * Create a timeout manager
+   *
+   * @param config - Timeout configuration
+   */
+  constructor(config) {
+    this.config = this.validateConfig(config);
+    this.warningEmitter = new WarningEmitter();
+  }
+  /**
+   * Validate timeout configuration
+   *
+   * Ensures configuration values are valid and within acceptable ranges.
+   *
+   * @param config - Timeout configuration to validate
+   * @returns Validated configuration
+   * @throws Error if configuration is invalid
+   * @private
+   */
+  validateConfig(config) {
+    if (config.warningThreshold !== void 0) {
+      if (config.warningThreshold < MIN_WARNING_THRESHOLD || config.warningThreshold > MAX_WARNING_THRESHOLD) {
+        throw new Error(
+          `Warning threshold must be between ${MIN_WARNING_THRESHOLD} and ${MAX_WARNING_THRESHOLD}`
+        );
+      }
+    }
+    if (config.global !== void 0 && config.global <= 0) {
+      throw new Error("Global timeout must be positive");
+    }
+    if (config.teams) {
+      for (const [team, timeout] of Object.entries(config.teams)) {
+        if (timeout <= 0) {
+          throw new Error(`Team timeout for '${team}' must be positive`);
+        }
+      }
+    }
+    if (config.agents) {
+      for (const [agent, timeout] of Object.entries(config.agents)) {
+        if (timeout <= 0) {
+          throw new Error(`Agent timeout for '${agent}' must be positive`);
+        }
+      }
+    }
+    return config;
+  }
+  /**
+   * Resolve final timeout value
+   *
+   * Resolves the final timeout value based on the priority chain:
+   * 1. Runtime override (CLI flag)
+   * 2. Agent-level config (agent YAML)
+   * 3. Team-level config (team config)
+   * 4. Global config (config file)
+   * 5. Default value (hardcoded)
+   *
+   * @param context - Timeout resolution context
+   * @returns Resolved timeout configuration
+   *
+   * @example
+   * ```typescript
+   * const resolved = manager.resolve({
+   *   agentName: 'backend',
+   *   teamName: 'engineering',
+   *   runtimeTimeout: 1800000
+   * });
+   * ```
+   */
+  resolve(context) {
+    if (context.runtimeTimeout !== void 0) {
+      logger.debug("Timeout resolved from runtime override", {
+        value: context.runtimeTimeout,
+        source: "runtime"
+      });
+      return this.buildResolved(context.runtimeTimeout, "runtime");
+    }
+    const agentTimeout = this.config.agents?.[context.agentName];
+    if (agentTimeout !== void 0) {
+      logger.debug("Timeout resolved from agent config", {
+        agent: context.agentName,
+        value: agentTimeout,
+        source: "agent"
+      });
+      return this.buildResolved(agentTimeout, "agent");
+    }
+    const teamTimeout = this.config.teams?.[context.teamName];
+    if (teamTimeout !== void 0) {
+      logger.debug("Timeout resolved from team config", {
+        team: context.teamName,
+        value: teamTimeout,
+        source: "team"
+      });
+      return this.buildResolved(teamTimeout, "team");
+    }
+    if (this.config.global !== void 0) {
+      logger.debug("Timeout resolved from global config", {
+        value: this.config.global,
+        source: "global"
+      });
+      return this.buildResolved(this.config.global, "global");
+    }
+    logger.debug("Timeout resolved from default", {
+      value: DEFAULT_TIMEOUT,
+      source: "default"
+    });
+    return this.buildResolved(DEFAULT_TIMEOUT, "default");
+  }
+  /**
+   * Build resolved timeout configuration
+   *
+   * Constructs a resolved timeout configuration object with warning threshold.
+   *
+   * @param value - Timeout value in milliseconds
+   * @param source - Configuration source
+   * @returns Resolved timeout configuration
+   * @private
+   */
+  buildResolved(value, source) {
+    const threshold = this.config.warningThreshold ?? DEFAULT_WARNING_THRESHOLD;
+    return {
+      value,
+      source,
+      warningAt: Math.floor(value * threshold),
+      warningsEnabled: true
+    };
+  }
+  /**
+   * Start timeout monitoring
+   *
+   * Starts monitoring an execution with the resolved timeout configuration.
+   * Emits a warning event when the threshold is reached.
+   *
+   * @param resolved - Resolved timeout configuration
+   * @param context - Execution context
+   * @returns Timeout monitor handle
+   *
+   * @example
+   * ```typescript
+   * const monitor = manager.startMonitoring(resolved, {
+   *   agentName: 'backend',
+   *   taskDescription: 'Implement feature X'
+   * });
+   *
+   * // Later, stop monitoring
+   * monitor.stop();
+   * ```
+   */
+  startMonitoring(resolved, context) {
+    const startTime = Date.now();
+    let warningTimer;
+    if (resolved.warningsEnabled) {
+      warningTimer = setTimeout(() => {
+        const event = {
+          agentName: context.agentName,
+          taskDescription: context.taskDescription,
+          elapsedMs: resolved.warningAt,
+          remainingMs: resolved.value - resolved.warningAt,
+          timeoutMs: resolved.value
+        };
+        this.warningEmitter.emitWarning(event);
+      }, resolved.warningAt);
+    }
+    return {
+      resolved,
+      warningTimer,
+      startTime,
+      stop: () => {
+        if (warningTimer) {
+          clearTimeout(warningTimer);
+        }
+      }
+    };
+  }
+  /**
+   * Get warning emitter
+   *
+   * Returns the warning emitter instance for custom event handling.
+   *
+   * @returns Warning emitter instance
+   */
+  getWarningEmitter() {
+    return this.warningEmitter;
+  }
+  /**
+   * Get configuration
+   *
+   * Returns the current timeout configuration.
+   *
+   * @returns Timeout configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/utils/timeout-validator.ts
+init_esm_shims();
+var MIN_WARNING_THRESHOLD2 = 0.5;
+var MAX_WARNING_THRESHOLD2 = 0.95;
+function validateTimeoutConfig(config) {
+  if (config.warningThreshold !== void 0) {
+    if (config.warningThreshold < MIN_WARNING_THRESHOLD2 || config.warningThreshold > MAX_WARNING_THRESHOLD2) {
+      throw new ConfigError(
+        `Timeout warning threshold must be between ${MIN_WARNING_THRESHOLD2} and ${MAX_WARNING_THRESHOLD2}`,
+        "E1003" /* CONFIG_VALIDATION_ERROR */,
+        [],
+        { warningThreshold: config.warningThreshold }
+      );
+    }
+  }
+  if (config.global !== void 0) {
+    if (!isPositiveInteger2(config.global)) {
+      throw new ConfigError(
+        "Global timeout must be a positive integer",
+        "E1003" /* CONFIG_VALIDATION_ERROR */,
+        [],
+        { global: config.global }
+      );
+    }
+  }
+  if (config.teams) {
+    for (const [team, timeout] of Object.entries(config.teams)) {
+      if (!isPositiveInteger2(timeout)) {
+        throw new ConfigError(
+          `Team timeout for '${team}' must be a positive integer`,
+          "E1003" /* CONFIG_VALIDATION_ERROR */,
+          [],
+          { team, timeout }
+        );
+      }
+    }
+  }
+  if (config.agents) {
+    for (const [agent, timeout] of Object.entries(config.agents)) {
+      if (!isPositiveInteger2(timeout)) {
+        throw new ConfigError(
+          `Agent timeout for '${agent}' must be a positive integer`,
+          "E1003" /* CONFIG_VALIDATION_ERROR */,
+          [],
+          { agent, timeout }
+        );
+      }
+    }
+  }
+}
+function isPositiveInteger2(value) {
+  return Number.isInteger(value) && value > 0;
+}
+function buildTimeoutConfig(executionConfig) {
+  if (executionConfig.timeouts) {
+    return executionConfig.timeouts;
+  }
+  if (executionConfig.defaultTimeout !== void 0) {
+    return {
+      global: executionConfig.defaultTimeout
+    };
+  }
+  return {};
+}
+function validateAndBuildTimeoutConfig(executionConfig) {
+  const config = buildTimeoutConfig(executionConfig);
+  if (Object.keys(config).length > 0) {
+    validateTimeoutConfig(config);
+  }
+  return config;
+}
+
 // src/agents/executor.ts
 init_logger();
 import { randomUUID as randomUUID2 } from "crypto";
@@ -8505,6 +8925,14 @@ var AgentExecutor = class {
    * Default retry configuration (v5.0: from config instead of hardcoded)
    */
   defaultRetryConfig;
+  /**
+   * Timeout manager for layered timeout configuration (v5.4.0+)
+   */
+  timeoutManager;
+  /**
+   * Configuration (v5.4.0+)
+   */
+  config;
   /**
    * Create AgentExecutor with optional delegation support
    *
@@ -8516,6 +8944,7 @@ var AgentExecutor = class {
     this.contextManager = config?.contextManager;
     this.profileLoader = config?.profileLoader;
     this.delegationParser = new DelegationParser(config?.profileLoader);
+    this.config = config?.config;
     this.defaultRetryConfig = config?.defaultRetryConfig ?? {
       maxAttempts: 3,
       initialDelay: 1e3,
@@ -8530,11 +8959,48 @@ var AgentExecutor = class {
         "timeout"
       ]
     };
+    if (this.config?.execution) {
+      try {
+        const timeoutConfig = validateAndBuildTimeoutConfig(this.config.execution);
+        if (Object.keys(timeoutConfig).length > 0) {
+          this.timeoutManager = new TimeoutManager(timeoutConfig);
+          logger.debug("TimeoutManager initialized", { timeoutConfig });
+        }
+      } catch (error) {
+        logger.warn("Failed to initialize TimeoutManager", {
+          error: error.message
+        });
+      }
+    }
   }
   /**
    * Execute an agent with the given context
    */
   async execute(context, options = {}) {
+    if (!options.timeout && this.timeoutManager) {
+      try {
+        const resolved = this.timeoutManager.resolve({
+          agentName: context.agent.name,
+          teamName: context.agent.team || "unknown",
+          runtimeTimeout: options.timeout
+        });
+        options = { ...options, timeout: resolved.value };
+        logger.debug("Timeout resolved", {
+          agent: context.agent.name,
+          team: context.agent.team,
+          timeout: resolved.value,
+          source: resolved.source
+        });
+        this.timeoutManager.startMonitoring(resolved, {
+          agentName: context.agent.name,
+          taskDescription: context.task
+        });
+      } catch (error) {
+        logger.warn("Failed to resolve timeout", {
+          error: error.message
+        });
+      }
+    }
     if (options.retry && options.timeout) {
       return this.executeWithTimeout(context, {
         ...options,
@@ -9026,7 +9492,9 @@ ${context.task}`;
           "cycle"
         );
       }
-      const maxDepth = fromAgentProfile.orchestration?.maxDelegationDepth ?? 2;
+      const initiatorName = delegationChain.length > 0 ? delegationChain[0] ?? request.fromAgent : request.fromAgent;
+      const initiatorProfile = await this.profileLoader.loadProfile(initiatorName);
+      const maxDepth = initiatorProfile.orchestration?.maxDelegationDepth ?? 2;
       if (delegationChain.length >= maxDepth) {
         throw new DelegationError(
           `Max delegation depth (${maxDepth}) exceeded. Chain: ${delegationChain.join(" -> ")} (length ${delegationChain.length})`,
@@ -15162,7 +15630,7 @@ init_gemini_provider();
 init_openai_provider();
 init_logger();
 import chalk16 from "chalk";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readdir as readdir6, stat as stat2 } from "fs/promises";
 import { join as join12 } from "path";
 import { createRequire as createRequire3 } from "module";
@@ -15280,25 +15748,25 @@ var statusCommand2 = {
         project: projectInfo,
         configuration: {
           configFile: join12(detectedProjectDir, "automatosx.config.json"),
-          configExists: existsSync6(join12(detectedProjectDir, "automatosx.config.json")),
+          configExists: existsSync7(join12(detectedProjectDir, "automatosx.config.json")),
           logLevel: config.logging.level,
           memoryMaxEntries: config.memory.maxEntries,
           memoryRetentionDays: config.memory.cleanupDays
         },
         directories: {
-          automatosx: { path: automatosxDir, exists: existsSync6(automatosxDir) },
-          agents: { path: agentsDir, exists: existsSync6(agentsDir), count: agentCount },
-          abilities: { path: abilitiesDir, exists: existsSync6(abilitiesDir), count: abilityCount },
-          memory: { path: memoryDir, exists: existsSync6(memoryDir), ...memoryStats },
+          automatosx: { path: automatosxDir, exists: existsSync7(automatosxDir) },
+          agents: { path: agentsDir, exists: existsSync7(agentsDir), count: agentCount },
+          abilities: { path: abilitiesDir, exists: existsSync7(abilitiesDir), count: abilityCount },
+          memory: { path: memoryDir, exists: existsSync7(memoryDir), ...memoryStats },
           prd: {
             path: prdDir,
-            exists: existsSync6(prdDir),
+            exists: existsSync7(prdDir),
             files: workspaceStats.prdFiles,
             sizeBytes: workspaceStats.prdSizeBytes
           },
           tmp: {
             path: tmpDir,
-            exists: existsSync6(tmpDir),
+            exists: existsSync7(tmpDir),
             files: workspaceStats.tmpFiles,
             sizeBytes: workspaceStats.tmpSizeBytes
           }
@@ -15396,7 +15864,7 @@ var statusCommand2 = {
           const value = process.env[name];
           if (value) {
             hasAnyEnvVar = true;
-            const exists = existsSync6(value);
+            const exists = existsSync7(value);
             const icon = exists ? chalk16.green("\u2713") : chalk16.yellow("\u26A0");
             const statusMsg = exists ? chalk16.green("valid") : chalk16.yellow("path not found");
             console.log(`  ${icon} ${name}: ${statusMsg}`);
@@ -15451,7 +15919,7 @@ var statusCommand2 = {
   }
 };
 async function getMemoryStatistics(memoryDir) {
-  if (!existsSync6(memoryDir)) {
+  if (!existsSync7(memoryDir)) {
     return { files: 0, sizeBytes: 0 };
   }
   try {
@@ -15487,7 +15955,7 @@ async function getDirectoryStats(dirPath) {
   return { size: totalSize, files: totalFiles };
 }
 async function countFiles(dirPath, extensions) {
-  if (!existsSync6(dirPath)) {
+  if (!existsSync7(dirPath)) {
     return 0;
   }
   try {
@@ -15500,7 +15968,7 @@ async function countFiles(dirPath, extensions) {
 }
 async function getProjectInfo(projectDir) {
   const packageJsonPath = join12(projectDir, "package.json");
-  if (!existsSync6(packageJsonPath)) {
+  if (!existsSync7(packageJsonPath)) {
     return {};
   }
   try {
@@ -15823,7 +16291,7 @@ init_esm_shims();
 init_esm_shims();
 import { readdir as readdir7 } from "fs/promises";
 import { join as join13 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import chalk19 from "chalk";
 var TEMPLATE_DESCRIPTIONS = {
   "basic-agent": {
@@ -15859,9 +16327,9 @@ var templatesCommand = {
     try {
       console.log(chalk19.blue.bold("\n\u{1F4CB} Available Agent Templates\n"));
       const projectTemplatesDir = join13(process.cwd(), ".automatosx", "templates");
-      const hasProjectTemplates = existsSync7(projectTemplatesDir);
+      const hasProjectTemplates = existsSync8(projectTemplatesDir);
       const defaultTemplatesDir = join13(__dirname, "../examples/templates");
-      const hasDefaultTemplates = existsSync7(defaultTemplatesDir);
+      const hasDefaultTemplates = existsSync8(defaultTemplatesDir);
       if (!hasProjectTemplates && !hasDefaultTemplates) {
         console.log(chalk19.yellow("\u26A0 No templates found."));
         console.log(chalk19.gray('\nRun "ax init" to set up default templates.\n'));
@@ -15919,7 +16387,7 @@ var templatesCommand = {
 // src/cli/commands/agent/create.ts
 init_esm_shims();
 import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join15 } from "path";
 import { load as loadYaml2 } from "js-yaml";
 import chalk20 from "chalk";
@@ -16060,7 +16528,7 @@ var templateEngine = new TemplateEngine();
 // src/cli/commands/agent/helpers.ts
 init_esm_shims();
 import { readdir as readdir8 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { join as join14, extname as extname5, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 init_logger();
@@ -16069,7 +16537,7 @@ var __dirname5 = dirname9(__filename5);
 async function listAvailableTemplates() {
   const templates = [];
   const projectTemplatesDir = join14(process.cwd(), ".automatosx", "templates");
-  if (existsSync8(projectTemplatesDir)) {
+  if (existsSync9(projectTemplatesDir)) {
     try {
       const files = await readdir8(projectTemplatesDir);
       for (const file of files) {
@@ -16087,7 +16555,7 @@ async function listAvailableTemplates() {
     }
   }
   const builtinTemplatesDir = join14(__dirname5, "../../../../examples/templates");
-  if (existsSync8(builtinTemplatesDir)) {
+  if (existsSync9(builtinTemplatesDir)) {
     try {
       const files = await readdir8(builtinTemplatesDir);
       for (const file of files) {
@@ -16282,7 +16750,7 @@ var createCommand2 = {
         console.log(chalk20.gray("  \u2022 Not contain consecutive hyphens\n"));
         process.exit(1);
       }
-      if (existsSync9(agentFile)) {
+      if (existsSync10(agentFile)) {
         console.log(chalk20.red.bold(`
 \u2717 Agent already exists: ${argv2.agent}
 `));
@@ -16368,11 +16836,11 @@ var createCommand2 = {
 };
 async function findTemplate(name) {
   const projectTemplate = join15(process.cwd(), ".automatosx", "templates", `${name}.yaml`);
-  if (existsSync9(projectTemplate)) {
+  if (existsSync10(projectTemplate)) {
     return projectTemplate;
   }
   const defaultTemplate = join15(__dirname, "../examples/templates", `${name}.yaml`);
-  if (existsSync9(defaultTemplate)) {
+  if (existsSync10(defaultTemplate)) {
     return defaultTemplate;
   }
   throw new Error(`Template not found: ${name}
@@ -16627,7 +17095,7 @@ var showCommand = {
 // src/cli/commands/agent/remove.ts
 init_esm_shims();
 import { unlink as unlink2 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { join as join18 } from "path";
 import chalk23 from "chalk";
 import * as readline3 from "readline";
@@ -16680,7 +17148,7 @@ var removeCommand = {
         process.exit(1);
       }
       const agentFile = join18(agentsDir, `${resolvedName}.yaml`);
-      if (!existsSync10(agentFile)) {
+      if (!existsSync11(agentFile)) {
         console.log(chalk23.red.bold(`
 \u2717 Agent file not found: ${resolvedName}
 `));