@defai.digital/automatosx 11.3.1 → 11.3.3

package/dist/index.js

@@ -2,8 +2,9 @@
 import * as path4 from 'path';
 import path4__default, { dirname, join, isAbsolute, basename, resolve, extname as extname$1, relative, sep, normalize, parse as parse$1, delimiter } from 'path';
 import { fileURLToPath } from 'url';
-import * as fs4 from 'fs/promises';
+import * as fs5 from 'fs/promises';
 import { mkdir, appendFile, access as access$1, readFile, stat, rm, readdir, copyFile, writeFile, rename, unlink, constants as constants$1, realpath as realpath$1 } from 'fs/promises';
+import * as fs3 from 'fs';
 import { access, realpath, existsSync, readFileSync, constants, writeFileSync, mkdirSync, promises, statSync, readdirSync, createWriteStream, unlinkSync } from 'fs';
 import Database2 from 'better-sqlite3';
 import os2, { homedir, cpus } from 'os';
@@ -17,9 +18,9 @@ import * as readline2 from 'readline';
 import readline2__default, { createInterface } from 'readline';
 import { Mutex } from 'async-mutex';
 import { promisify } from 'util';
+import crypto2, { randomUUID, createHash } from 'crypto';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import crypto2, { randomUUID, createHash } from 'crypto';
 import * as yaml4 from 'js-yaml';
 import yaml4__default, { load, dump } from 'js-yaml';
 import Table from 'cli-table3';
@@ -32,9 +33,7 @@ import yaml from 'yaml';
 import { parse } from '@iarna/toml';
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -48,15 +47,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
   }
@@ -753,16 +743,16 @@ var init_errors = __esm({
       constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
         super(message, code, suggestions, context);
       }
-      static notFound(path7) {
+      static notFound(path8) {
         return new _ConfigError(
-          `Configuration file not found: ${path7}`,
+          `Configuration file not found: ${path8}`,
           "E1000" /* CONFIG_NOT_FOUND */,
           [
             'Run "automatosx setup" to create a new configuration',
             "Specify a custom config path with --config option",
             "Check that you are in a valid AutomatosX project directory"
           ],
-          { path: path7 }
+          { path: path8 }
         );
       }
       static invalid(reason, context) {
@@ -777,7 +767,7 @@ var init_errors = __esm({
           context
         );
       }
-      static parseError(error, path7) {
+      static parseError(error, path8) {
         return new _ConfigError(
           `Failed to parse configuration: ${error.message}`,
           "E1002" /* CONFIG_PARSE_ERROR */,
@@ -786,7 +776,7 @@ var init_errors = __esm({
             "Use a JSON validator to find syntax errors",
             'Reset to default with "automatosx setup --force"'
           ],
-          { path: path7, originalError: error.message }
+          { path: path8, originalError: error.message }
         );
       }
     };
@@ -1014,8 +1004,8 @@ __export(path_resolver_exports, {
   PathResolver: () => PathResolver,
   detectProjectRoot: () => detectProjectRoot
 });
-function isWindowsPath(path7) {
-  return /^[a-zA-Z]:[/\\]/.test(path7);
+function isWindowsPath(path8) {
+  return /^[a-zA-Z]:[/\\]/.test(path8);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   if (process.env.AUTOMATOSX_PROJECT_ROOT) {
@@ -1121,8 +1111,8 @@ var init_path_resolver = __esm({
       /**
        * Validate path is within allowed base directory
        */
-      validatePath(path7, baseDir) {
-        const normalized = normalizePath(resolvePath(path7));
+      validatePath(path8, baseDir) {
+        const normalized = normalizePath(resolvePath(path8));
         const base = normalizePath(resolvePath(baseDir));
         const separator = "/";
         const pathWithSep = normalized + separator;
@@ -1132,15 +1122,15 @@ var init_path_resolver = __esm({
       /**
        * Check if path is within allowed boundaries
        */
-      isPathAllowed(path7) {
-        const boundary = this.checkBoundaries(path7);
+      isPathAllowed(path8) {
+        const boundary = this.checkBoundaries(path8);
         return boundary === "agent_workspace" || boundary === "user_project";
       }
       /**
        * Check which boundary a path belongs to
        */
-      checkBoundaries(path7) {
-        const normalized = resolvePath(path7);
+      checkBoundaries(path8) {
+        const normalized = resolvePath(path8);
         if (this.validatePath(normalized, this.config.agentWorkspace)) {
           return "agent_workspace";
         }
@@ -1158,15 +1148,15 @@ var init_path_resolver = __esm({
       /**
        * Get relative path from project root
        */
-      getRelativeToProject(path7) {
-        const normalized = resolvePath(path7);
+      getRelativeToProject(path8) {
+        const normalized = resolvePath(path8);
         return normalizePath(getRelativePath(this.config.projectDir, normalized));
       }
       /**
        * Get relative path from working directory
        */
-      getRelativeToWorking(path7) {
-        const normalized = resolvePath(path7);
+      getRelativeToWorking(path8) {
+        const normalized = resolvePath(path8);
         return normalizePath(getRelativePath(this.config.workingDir, normalized));
       }
       /**
@@ -1185,11 +1175,11 @@ var init_path_resolver = __esm({
        * Validate path is within project boundaries
        * @throws PathError if outside project
        */
-      validateInProject(path7) {
-        const boundary = this.checkBoundaries(path7);
+      validateInProject(path8) {
+        const boundary = this.checkBoundaries(path8);
         if (boundary === "outside_boundaries" || boundary === "system_restricted") {
           throw new PathError("Path outside project directory", {
-            path: path7,
+            path: path8,
             projectDir: this.config.projectDir,
             boundary
           });
@@ -1432,11 +1422,11 @@ var init_workspace_indexer = __esm({
       /**
        * Detect file type and language
        */
-      detectTypeAndLanguage(path7, ext) {
-        if (path7.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
+      detectTypeAndLanguage(path8, ext) {
+        if (path8.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
           return { type: "config", language: "json" };
         }
-        if (path7.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path7.includes("__tests__")) {
+        if (path8.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path8.includes("__tests__")) {
           const lang = LANGUAGE_MAP[ext];
           return { type: "test", language: lang };
         }
@@ -1453,15 +1443,15 @@ var init_workspace_indexer = __esm({
        *
        * Higher score = more likely to be relevant
        */
-      calculateImportance(path7, type, size) {
+      calculateImportance(path8, type, size) {
         let score = 0.5;
-        if (path7.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
-        if (path7.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
-        if (path7.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
+        if (path8.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
+        if (path8.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
+        if (path8.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
         if (type === "config") score = 0.85;
-        if (path7.includes("/core/")) score += 0.15;
-        if (path7.includes("/types/")) score += 0.1;
-        if (path7.includes("/utils/")) score += 0.05;
+        if (path8.includes("/core/")) score += 0.15;
+        if (path8.includes("/types/")) score += 0.1;
+        if (path8.includes("/utils/")) score += 0.05;
         if (type === "test") score = Math.max(0.3, score - 0.3);
         if (type === "doc") score = Math.max(0.4, score - 0.2);
         if (size > 1e4) score += 0.05;
@@ -1937,10 +1927,10 @@ function findOnPathUnix(cmdBase) {
   try {
     const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
     if (which.status === 0) {
-      const path7 = which.stdout.toString().trim();
-      if (path7) {
-        logger.debug("Found via which", { cmdBase, path: path7 });
-        return { found: true, path: path7 };
+      const path8 = which.stdout.toString().trim();
+      if (path8) {
+        logger.debug("Found via which", { cmdBase, path: path8 });
+        return { found: true, path: path8 };
       }
     }
   } catch (error) {
@@ -1981,8 +1971,8 @@ var init_provider_schemas = __esm({
       completion: z.number().int().nonnegative(),
       total: z.number().int().nonnegative()
     }).refine(
-      (data) => data.total === data.prompt + data.completion,
-      "Total tokens must equal prompt + completion"
+      (data) => data.total >= data.prompt + data.completion,
+      "Total tokens must be greater than or equal to prompt + completion"
     ).describe("Token usage information");
     finishReasonSchema = z.enum([
       "stop",
@@ -2239,15 +2229,6 @@ var init_streaming_progress_parser = __esm({
 });
 
 // src/providers/error-patterns.ts
-var error_patterns_exports = {};
-__export(error_patterns_exports, {
-  GENERIC_ERROR_PATTERNS: () => GENERIC_ERROR_PATTERNS,
-  PROVIDER_ERROR_PATTERNS: () => PROVIDER_ERROR_PATTERNS,
-  getProviderErrorPatterns: () => getProviderErrorPatterns,
-  isLimitError: () => isLimitError,
-  isQuotaError: () => isQuotaError,
-  isRateLimitError: () => isRateLimitError
-});
 function isQuotaError(error, providerName) {
   const patterns = PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
   const message = (error?.message || "").toLowerCase();
@@ -2289,9 +2270,6 @@ function isRateLimitError(error, providerName) {
 function isLimitError(error, providerName) {
   return isQuotaError(error, providerName) || isRateLimitError(error, providerName);
 }
-function getProviderErrorPatterns(providerName) {
-  return PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
-}
 var PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
 var init_error_patterns = __esm({
   "src/providers/error-patterns.ts"() {
@@ -2480,6 +2458,62 @@ var init_error_patterns = __esm({
           "quota_exceeded",
           "billing_hard_limit_reached"
         ]
+      },
+      /**
+       * ax-cli Provider Error Patterns (v9.2.0)
+       *
+       * ax-cli is a multi-model provider supporting GLM, xAI, OpenAI, Anthropic, Ollama, etc.
+       * BUG FIX: Added missing patterns - previously fell back to generic patterns which
+       * may miss provider-specific errors from the underlying model providers.
+       *
+       * Combines patterns from all supported backends since ax-cli proxies to them.
+       */
+      "ax-cli": {
+        quota: [
+          // GLM patterns
+          "quota exceeded",
+          "quota limit reached",
+          "insufficient quota",
+          // OpenAI patterns (via ax-cli)
+          "insufficient_quota",
+          "quota_exceeded",
+          "billing hard limit reached",
+          "usage limit exceeded",
+          "monthly quota exceeded",
+          "credit limit reached",
+          // Anthropic patterns (via ax-cli)
+          "credit limit reached",
+          // Generic patterns
+          "daily quota exceeded",
+          "api quota exceeded"
+        ],
+        rateLimit: [
+          // Common patterns
+          "rate_limit_exceeded",
+          "rate limit exceeded",
+          "too_many_requests",
+          "too many requests",
+          "requests per minute exceeded",
+          "tokens per minute exceeded",
+          "rate limit reached",
+          // Anthropic patterns (via ax-cli)
+          "rate_limit_error",
+          "overloaded_error",
+          "overloaded",
+          // xAI/Grok patterns
+          "throttled",
+          "request throttled"
+        ],
+        statusCodes: [429, 529],
+        errorCodes: [
+          "insufficient_quota",
+          "rate_limit_exceeded",
+          "quota_exceeded",
+          "rate_limit_error",
+          "overloaded_error",
+          "RATE_LIMIT_EXCEEDED",
+          "QUOTA_EXCEEDED"
+        ]
       }
     };
     GENERIC_ERROR_PATTERNS = {
@@ -2502,6 +2536,105 @@ var init_error_patterns = __esm({
     };
   }
 });
+
+// src/providers/retry-errors.ts
+function containsErrorPattern(message, patterns) {
+  const lowerMessage = message.toLowerCase();
+  return patterns.some((pattern) => lowerMessage.includes(pattern.toLowerCase()));
+}
+function getRetryableErrors(provider) {
+  const baseErrors = [
+    ...COMMON_NETWORK_ERRORS,
+    ...COMMON_RATE_LIMIT_ERRORS,
+    ...COMMON_SERVER_ERRORS
+  ];
+  switch (provider) {
+    case "claude":
+      return [...baseErrors, ...CLAUDE_RETRYABLE_ERRORS];
+    case "gemini":
+      return [...baseErrors, ...GEMINI_RETRYABLE_ERRORS];
+    case "openai":
+      return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
+    case "ax-cli":
+      return [...baseErrors, ...AX_CLI_RETRYABLE_ERRORS];
+    case "codex":
+      return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
+    case "base":
+    default:
+      return baseErrors;
+  }
+}
+function shouldRetryError(error, provider) {
+  const message = error.message;
+  if (containsErrorPattern(message, NON_RETRYABLE_ERRORS)) {
+    return false;
+  }
+  const retryableErrors = getRetryableErrors(provider);
+  return containsErrorPattern(message, retryableErrors);
+}
+var COMMON_NETWORK_ERRORS, COMMON_RATE_LIMIT_ERRORS, COMMON_SERVER_ERRORS, CLAUDE_RETRYABLE_ERRORS, GEMINI_RETRYABLE_ERRORS, OPENAI_RETRYABLE_ERRORS, AX_CLI_RETRYABLE_ERRORS, CODEX_RETRYABLE_ERRORS, NON_RETRYABLE_ERRORS;
+var init_retry_errors = __esm({
+  "src/providers/retry-errors.ts"() {
+    init_esm_shims();
+    COMMON_NETWORK_ERRORS = [
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "ECONNREFUSED",
+      "connection_error",
+      "network connection error",
+      "timeout"
+    ];
+    COMMON_RATE_LIMIT_ERRORS = [
+      "rate_limit",
+      "rate_limit_error",
+      "too many requests"
+    ];
+    COMMON_SERVER_ERRORS = [
+      "internal_server_error",
+      "server_error",
+      "service_unavailable",
+      "unavailable"
+    ];
+    CLAUDE_RETRYABLE_ERRORS = [
+      "overloaded_error",
+      "internal_server_error"
+    ];
+    GEMINI_RETRYABLE_ERRORS = [
+      "resource_exhausted",
+      "deadline_exceeded",
+      "internal"
+    ];
+    OPENAI_RETRYABLE_ERRORS = [
+      "internal_error"
+    ];
+    AX_CLI_RETRYABLE_ERRORS = [
+      // Inherited from Anthropic (via ax-cli)
+      "overloaded_error",
+      // Inherited from OpenAI (via ax-cli)
+      "internal_error",
+      // ax-cli specific
+      "agent_error",
+      "tool_execution_error",
+      // xAI/Grok specific
+      "service_overloaded"
+    ];
+    CODEX_RETRYABLE_ERRORS = [
+      ...OPENAI_RETRYABLE_ERRORS,
+      "sandbox_error"
+      // Codex-specific sandbox issues are often transient
+    ];
+    NON_RETRYABLE_ERRORS = [
+      "authentication",
+      "unauthorized",
+      "api key",
+      "not found",
+      "permission denied",
+      "invalid_api_key",
+      "invalid_request"
+    ];
+  }
+});
 var BaseProvider;
 var init_base_provider = __esm({
   "src/providers/base-provider.ts"() {
@@ -2512,6 +2645,8 @@ var init_base_provider = __esm({
     init_provider_schemas();
     init_streaming_progress_parser();
     init_verbosity_manager();
+    init_error_patterns();
+    init_retry_errors();
     BaseProvider = class _BaseProvider {
       /**
        * Whitelist of allowed provider names for security
@@ -2544,6 +2679,10 @@ var init_base_provider = __esm({
         NO_UPDATE_NOTIFIER: "1",
         DEBIAN_FRONTEND: "noninteractive"
       };
+      /** Default CLI execution timeout in milliseconds */
+      static DEFAULT_TIMEOUT_MS = 12e4;
+      /** Time to wait after SIGTERM before escalating to SIGKILL */
+      static SIGKILL_ESCALATION_MS = 5e3;
       config;
       logger = logger;
       health;
@@ -2561,6 +2700,8 @@ var init_base_provider = __esm({
           latencyMs: 0,
           errorRate: 0,
           consecutiveFailures: 0,
+          consecutiveSuccesses: 0,
+          // BUG FIX: Track consecutive successes
           lastCheck: Date.now()
         };
       }
@@ -2601,7 +2742,7 @@ var init_base_provider = __esm({
             useStdin,
             streaming: process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true"
           });
-          const result = useStdin ? await this.executeWithStdin(cliCommand2, argsString.trim(), prompt) : await this.executeWithSpawn(fullCommand, cliCommand2);
+          const result = useStdin ? await this.executeWithStdin(cliCommand2, cliArgs, prompt) : await this.executeWithSpawn(fullCommand, cliCommand2);
           if (!result.stdout) {
             throw new Error(`${cliCommand2} CLI returned empty output. stderr: ${result.stderr || "none"}`);
           }
@@ -2623,8 +2764,8 @@ var init_base_provider = __esm({
       /**
        * Execute command using spawn() with streaming support (v8.4.18)
        *
-       * Replaces execWithCleanup to support real-time line-by-line output streaming.
-       * Maintains all timeout and cleanup behaviors from execWithCleanup.
+       * Supports real-time line-by-line output streaming with proper timeout
+       * and cleanup behaviors (SIGTERM → SIGKILL escalation pattern).
        *
        * @param command - Full command string to execute
        * @param cliCommand - CLI command name (for logging)
@@ -2635,7 +2776,7 @@ var init_base_provider = __esm({
           const child = spawn(command, [], {
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
-            timeout: this.config.timeout || 12e4,
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2746,7 +2887,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand2} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2760,7 +2901,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -2778,14 +2919,13 @@ var init_base_provider = __esm({
        */
       async executeWithStdin(cliCommand2, cliArgs, prompt) {
         return new Promise((resolve13, reject) => {
-          const commandArgs = cliArgs ? cliArgs.split(" ").filter(Boolean) : [];
           logger.debug(`Executing ${cliCommand2} CLI with stdin`, {
             command: cliCommand2,
-            args: commandArgs,
+            args: cliArgs,
             promptLength: prompt.length
           });
-          const child = spawn(cliCommand2, commandArgs, {
-            timeout: this.config.timeout || 12e4,
+          const child = spawn(cliCommand2, cliArgs, {
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2808,11 +2948,20 @@ var init_base_provider = __esm({
               child.stdin.write(prompt);
               child.stdin.end();
             } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
               logger.error("Failed to write to stdin", {
                 command: cliCommand2,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
               });
+              child.kill("SIGTERM");
+              reject(new Error(`Failed to write prompt to ${cliCommand2} stdin: ${errorMessage}`));
+              return;
             }
+          } else {
+            logger.error("stdin not available for child process", { command: cliCommand2 });
+            child.kill("SIGTERM");
+            reject(new Error(`${cliCommand2} stdin not available - cannot send prompt`));
+            return;
           }
           if (child.stdout) {
             readlineInterface = readline2__default.createInterface({
@@ -2921,7 +3070,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand2} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2935,7 +3084,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -3001,10 +3150,8 @@ var init_base_provider = __esm({
 ${request.prompt}`;
           }
           if (process.env.AUTOMATOSX_DEBUG_PROMPT === "true") {
-            const fs7 = await import('fs');
-            const path7 = await import('path');
-            const debugPath = path7.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
-            fs7.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
+            const debugPath = path4.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
+            fs3.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
 
 ${fullPrompt}
 
@@ -3015,6 +3162,7 @@ ${fullPrompt}
           const result = await this.executeCLI(fullPrompt);
           const latencyMs = Date.now() - startTime;
           this.health.consecutiveFailures = 0;
+          this.health.consecutiveSuccesses++;
           this.health.available = true;
           this.health.errorRate = 0;
           this.health.latencyMs = latencyMs;
@@ -3047,6 +3195,7 @@ ${fullPrompt}
           return response;
         } catch (error) {
           this.health.consecutiveFailures++;
+          this.health.consecutiveSuccesses = 0;
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.latencyMs = Date.now() - startTime;
@@ -3060,19 +3209,23 @@ ${fullPrompt}
       async isAvailable() {
         try {
           const available = await this.checkCLIAvailable();
-          this.health = {
-            available,
-            latencyMs: 0,
-            errorRate: available ? 0 : 1,
-            lastCheck: Date.now(),
-            consecutiveFailures: available ? 0 : this.health.consecutiveFailures + 1
-          };
+          this.health.available = available;
+          this.health.errorRate = available ? 0 : 1;
+          this.health.lastCheck = Date.now();
+          if (available) {
+            this.health.consecutiveFailures = 0;
+            this.health.consecutiveSuccesses++;
+          } else {
+            this.health.consecutiveFailures++;
+            this.health.consecutiveSuccesses = 0;
+          }
           return available;
         } catch (error) {
           this.health.available = false;
           this.health.errorRate = 1;
           this.health.lastCheck = Date.now();
-          this.health.consecutiveFailures = this.health.consecutiveFailures + 1;
+          this.health.consecutiveFailures++;
+          this.health.consecutiveSuccesses = 0;
           return false;
         }
       }
@@ -3127,26 +3280,16 @@ ${fullPrompt}
        * @returns true if this is a rate limit or quota error
        */
       detectRateLimitError(error) {
-        const { isLimitError: isLimitError2 } = (init_error_patterns(), __toCommonJS(error_patterns_exports));
-        try {
-          const isLimited = isLimitError2(error, this.config.name);
-          if (isLimited) {
-            this.logger.debug("Rate limit error detected", {
-              provider: this.config.name,
-              message: error?.message,
-              code: error?.code,
-              status: error?.status || error?.statusCode
-            });
-          }
-          return isLimited;
-        } catch (detectionError) {
-          this.logger.warn("Rate limit detection failed, using fallback", {
+        const isLimited = isLimitError(error, this.config.name);
+        if (isLimited) {
+          this.logger.debug("Rate limit error detected", {
             provider: this.config.name,
-            error: detectionError
+            message: error?.message,
+            code: error?.code,
+            status: error?.status || error?.statusCode
           });
-          const message = (error?.message || "").toLowerCase();
-          return message.includes("rate limit") || message.includes("quota") || message.includes("resource_exhausted") || message.includes("too many requests");
         }
+        return isLimited;
       }
       /**
        * Escape shell command arguments to prevent injection
@@ -3239,8 +3382,20 @@ ${fullPrompt}
         };
       }
       shouldRetry(error) {
-        const message = error.message.toLowerCase();
-        return message.includes("timeout") || message.includes("rate limit") || message.includes("temporarily unavailable") || message.includes("503") || message.includes("502");
+        const providerName = this.config.name.toLowerCase();
+        let retryableProvider = "base";
+        if (providerName === "claude" || providerName === "claude-code") {
+          retryableProvider = "claude";
+        } else if (providerName === "gemini" || providerName === "gemini-cli") {
+          retryableProvider = "gemini";
+        } else if (providerName === "openai") {
+          retryableProvider = "openai";
+        } else if (providerName === "codex") {
+          retryableProvider = "codex";
+        } else if (providerName === "ax-cli" || providerName === "glm") {
+          retryableProvider = "ax-cli";
+        }
+        return shouldRetryError(error, retryableProvider);
       }
       getRetryDelay(attempt) {
         return Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
@@ -3264,7 +3419,9 @@ ${fullPrompt}
           },
           health: {
             consecutiveFailures: this.health.consecutiveFailures,
-            consecutiveSuccesses: this.health.consecutiveFailures === 0 ? 1 : 0,
+            // BUG FIX: Use actual tracked value instead of incorrect derivation
+            // Previously: `consecutiveFailures === 0 ? 1 : 0` which was wrong
+            consecutiveSuccesses: this.health.consecutiveSuccesses,
             lastCheckTime: this.health.lastCheck,
             lastCheckDuration: 0,
             uptime: this.health.lastCheck > 0 ? Date.now() - this.health.lastCheck : 0
@@ -3964,7 +4121,20 @@ var init_sdk_adapter = __esm({
             }
           }
           const tokenCount = result.usage ? (result.usage.input_tokens || 0) + (result.usage.output_tokens || 0) : void 0;
-          if (!this.options.reuseThreads) {
+          if (!this.options.reuseThreads && this.activeThread) {
+            try {
+              const threadWithDispose = this.activeThread;
+              if (typeof threadWithDispose.dispose === "function") {
+                const disposeResult = threadWithDispose.dispose();
+                if (disposeResult instanceof Promise) {
+                  await disposeResult;
+                }
+              }
+            } catch (disposeError) {
+              logger.warn("Error disposing thread", {
+                error: disposeError instanceof Error ? disposeError.message : String(disposeError)
+              });
+            }
             this.activeThread = null;
           }
           return {
@@ -4143,12 +4313,38 @@ var init_hybrid_adapter = __esm({
         }
         this.activeMode = "cli";
       }
+      /**
+       * Cleanup resources
+       *
+       * BUG FIX: Use Promise.allSettled to ensure cleanup continues even if one
+       * adapter fails, and properly log any cleanup errors. Previously, a failure
+       * in SDK destroy would prevent CLI cleanup from running.
+       */
       async destroy() {
-        if (this.sdkAdapter) await this.sdkAdapter.destroy();
-        if (this.cliAdapter) await this.cliAdapter.cleanup();
+        const cleanupPromises = [];
+        if (this.sdkAdapter) {
+          cleanupPromises.push(
+            this.sdkAdapter.destroy().catch((err) => {
+              logger.warn("Error destroying SDK adapter", {
+                error: err instanceof Error ? err.message : String(err)
+              });
+            })
+          );
+        }
+        if (this.cliAdapter) {
+          cleanupPromises.push(
+            this.cliAdapter.cleanup().catch((err) => {
+              logger.warn("Error cleaning up CLI adapter", {
+                error: err instanceof Error ? err.message : String(err)
+              });
+            })
+          );
+        }
+        await Promise.allSettled(cleanupPromises);
         this.sdkAdapter = null;
         this.cliAdapter = null;
         this.activeMode = null;
+        logger.debug("HybridCodexAdapter destroyed");
       }
     };
   }
@@ -4205,7 +4401,7 @@ var init_openai_provider = __esm({
             error: error instanceof Error ? error.message : String(error),
             mode: this.hybridAdapter?.getActiveMode() || "unknown"
           });
-          throw error;
+          throw this.handleError(error);
         }
       }
       initializeHybridAdapter() {
@@ -4398,17 +4594,25 @@ var init_command_builder = __esm({
       /**
        * Escape string for shell execution
        *
-       * Wraps in double quotes and escapes:
-       * - Double quotes: " → \"
+       * Uses $'...' ANSI-C quoting for reliable cross-platform escaping.
+       * This handles all special characters including newlines, tabs, and unicode.
+       *
+       * Escapes:
+       * - Single quotes: ' → \'
        * - Backslashes: \ → \\
-       * - Dollar signs: $ → \$
-       * - Backticks: ` → \`
+       * - Newlines: \n → \n (literal escape sequence)
+       * - Carriage returns: \r → \r
+       * - Tabs: \t → \t
+       *
+       * BUG FIX (v11.3.3): Previous implementation using double quotes didn't handle
+       * newlines properly, which could break shell commands or cause unexpected behavior.
        *
        * @param input - String to escape
-       * @returns Shell-safe escaped string
+       * @returns Shell-safe escaped string using ANSI-C quoting
        */
       escape(input) {
-        return `"${input.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`")}"`;
+        const escaped = input.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+        return `$'${escaped}'`;
       }
       /**
        * Build environment variables for CLI execution
@@ -4874,24 +5078,25 @@ var init_token_estimator = __esm({
     };
   }
 });
-
-// src/integrations/ax-cli-sdk/subagent-adapter.ts
-var TOKEN_SPLIT, SubagentAdapter;
+var TOKEN_SPLIT, DEFAULT_MAX_PARALLEL, DEFAULT_TIMEOUT_MS, DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS, SubagentAdapter;
 var init_subagent_adapter = __esm({
   "src/integrations/ax-cli-sdk/subagent-adapter.ts"() {
     init_esm_shims();
     init_logger();
     TOKEN_SPLIT = { PROMPT: 0.3, COMPLETION: 0.7 };
+    DEFAULT_MAX_PARALLEL = 4;
+    DEFAULT_TIMEOUT_MS = 3e5;
+    DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS = 100;
     SubagentAdapter = class {
       orchestrator = null;
       subagents = /* @__PURE__ */ new Map();
+      busySubagents = /* @__PURE__ */ new Set();
       sdkAvailable = null;
       options;
       constructor(options = {}) {
         this.options = {
-          maxParallel: options.maxParallel ?? 4,
-          timeout: options.timeout ?? 3e5,
-          // 5 minutes
+          maxParallel: options.maxParallel ?? DEFAULT_MAX_PARALLEL,
+          timeout: options.timeout ?? DEFAULT_TIMEOUT_MS,
           sharedContext: options.sharedContext ?? true,
           continueOnError: options.continueOnError ?? true,
           events: options.events,
@@ -4946,23 +5151,41 @@ var init_subagent_adapter = __esm({
           taskCount: tasks.length,
           maxParallel: this.options.maxParallel
         });
-        const sortedTasks = [...tasks].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-        const results = [];
+        const tasksWithIndex = tasks.map((task, index) => ({ task, index }));
+        const sortedTasks = [...tasksWithIndex].sort(
+          (a, b) => (a.task.priority ?? 0) - (b.task.priority ?? 0)
+        );
+        const results = new Array(tasks.length);
         const batchSize = this.options.maxParallel;
         for (let i = 0; i < sortedTasks.length; i += batchSize) {
           const batch = sortedTasks.slice(i, i + batchSize);
-          const batchResults = await this.executeBatch(batch);
-          results.push(...batchResults);
+          const batchResults = await this.executeBatch(batch.map((item) => item.task));
+          batch.forEach((item, idx) => {
+            results[item.index] = batchResults[idx];
+          });
           if (this.options.sharedContext && i + batchSize < sortedTasks.length) {
             await this.propagateContext(batchResults);
           }
         }
+        const finalResults = results.map((result, index) => {
+          if (result) {
+            return result;
+          }
+          return {
+            task: tasks[index]?.task ?? "unknown",
+            role: tasks[index]?.config.role ?? "custom",
+            content: "",
+            success: false,
+            error: "Subagent result missing",
+            latencyMs: 0
+          };
+        });
         logger.info("Parallel execution complete", {
           taskCount: tasks.length,
-          successCount: results.filter((r) => r.success).length,
+          successCount: finalResults.filter((r) => r.success).length,
           totalLatencyMs: Date.now() - startTime
         });
-        return results;
+        return finalResults;
       }
       /**
        * Execute tasks sequentially with context propagation
@@ -4980,18 +5203,27 @@ var init_subagent_adapter = __esm({
         const results = [];
         let accumulatedContext = "";
         for (const task of tasks) {
-          const taskWithContext = {
-            ...task,
-            context: task.context ? `${task.context}
+          let combinedContext;
+          if (task.context && accumulatedContext) {
+            combinedContext = `${task.context}
 
 Previous results:
-${accumulatedContext}` : accumulatedContext || void 0
+${accumulatedContext}`;
+          } else if (task.context) {
+            combinedContext = task.context;
+          } else if (accumulatedContext) {
+            combinedContext = accumulatedContext;
+          }
+          const taskWithContext = {
+            ...task,
+            context: combinedContext
           };
           const result = await this.executeTask(taskWithContext);
           results.push(result);
           if (result.success && this.options.sharedContext) {
+            const truncated = result.content.length > 500;
             accumulatedContext += `
-[${result.role}]: ${result.content.substring(0, 500)}...
+[${result.role}]: ${result.content.substring(0, 500)}${truncated ? "..." : ""}
 `;
           }
           if (!result.success && !this.options.continueOnError) {
@@ -5017,6 +5249,7 @@ ${accumulatedContext}` : accumulatedContext || void 0
         const startTime = Date.now();
         const subagentKey = this.getSubagentKey(task.config);
         const taskId = `${subagentKey}:${Date.now()}`;
+        let release = null;
         this.emitEvent("task_start", task.task);
         this.emitEvent("state_change", {
           previousState: "idle",
@@ -5029,7 +5262,9 @@ ${accumulatedContext}` : accumulatedContext || void 0
           message: `Starting ${task.config.role} task`
         });
         try {
-          const subagent = await this.getOrCreateSubagent(task.config);
+          const acquired = await this.acquireSubagent(task.config);
+          const subagent = acquired.subagent;
+          release = acquired.release;
           const prompt = task.context ? `Context:
 ${task.context}
 
@@ -5120,6 +5355,10 @@ ${task.task}` : task.task;
             error: errorMessage,
             latencyMs
           };
+        } finally {
+          if (release) {
+            release();
+          }
         }
       }
       /**
@@ -5142,7 +5381,11 @@ ${task.task}` : task.task;
        * Propagate context from completed tasks
        */
       async propagateContext(results) {
-        const contextSummary = results.filter((r) => r.success).map((r) => `[${r.role}]: ${r.content.substring(0, 200)}...`).join("\n");
+        const contextSummary = results.filter((r) => r.success).map((r) => {
+          const truncated = r.content.length > 200;
+          const summary = r.content.substring(0, 200);
+          return `[${r.role}]: ${summary}${truncated ? "..." : ""}`;
+        }).join("\n");
         if (contextSummary && this.orchestrator?.setSharedContext) {
           try {
             await this.orchestrator.setSharedContext(contextSummary);
@@ -5168,7 +5411,7 @@ ${task.task}` : task.task;
           const { createSubagent } = await import('@defai.digital/ax-cli/sdk');
           const subagent = createSubagent(config.role, {
             systemPrompt: config.instructions,
-            maxToolRounds: config.maxToolRounds ?? 100
+            maxToolRounds: config.maxToolRounds ?? DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS
           });
           this.subagents.set(key, subagent);
           logger.debug("Created new subagent", {
@@ -5185,11 +5428,70 @@ ${task.task}` : task.task;
           throw error;
         }
       }
+      /**
+       * Create a temporary subagent instance. Used when the cached subagent is busy.
+       */
+      async createEphemeralSubagent(config) {
+        const { createSubagent } = await import('@defai.digital/ax-cli/sdk');
+        return createSubagent(config.role, {
+          systemPrompt: config.instructions,
+          maxToolRounds: config.maxToolRounds ?? DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS
+        });
+      }
+      /**
+       * Acquire a subagent instance for a task. If a cached instance is already
+       * running another task, create a short-lived one to avoid interleaved
+       * streams from concurrent executions.
+       */
+      async acquireSubagent(config) {
+        const key = this.getSubagentKey(config);
+        if (!this.busySubagents.has(key)) {
+          this.busySubagents.add(key);
+          let subagent;
+          try {
+            subagent = await this.getOrCreateSubagent(config);
+          } catch (error) {
+            this.busySubagents.delete(key);
+            throw error;
+          }
+          return {
+            subagent,
+            release: () => this.releaseSubagent(key)
+          };
+        }
+        logger.debug("Cached subagent busy, creating ephemeral instance", { key });
+        const ephemeral = await this.createEphemeralSubagent(config);
+        return {
+          subagent: ephemeral,
+          release: () => {
+            try {
+              if (ephemeral.dispose) {
+                const result = ephemeral.dispose();
+                if (result instanceof Promise) {
+                  result.catch((err) => logger.warn("Error disposing ephemeral subagent", { error: err instanceof Error ? err.message : String(err) }));
+                }
+              }
+            } catch (error) {
+              logger.warn("Error disposing ephemeral subagent", {
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+        };
+      }
+      /**
+       * Release a cached subagent so it can be reused.
+       */
+      releaseSubagent(key) {
+        this.busySubagents.delete(key);
+      }
       /**
        * Generate unique key for subagent config
        */
       getSubagentKey(config) {
-        return `${config.role}:${config.specialization || "default"}`;
+        const instructionsHash = config.instructions ? createHash("sha256").update(config.instructions).digest("hex").slice(0, 12) : "noinstr";
+        const maxToolRounds = config.maxToolRounds ?? DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS;
+        return `${config.role}:${config.specialization || "default"}:${maxToolRounds}:${instructionsHash}`;
       }
       /**
        * Ensure orchestrator is initialized
@@ -5245,8 +5547,11 @@ ${task.task}` : task.task;
       }
       /**
        * Cleanup all subagents
+       * BUG FIX: Continue cleanup even if individual subagent disposal fails,
+       * and report all errors at the end to ensure no resources are leaked.
        */
       async destroy() {
+        const errors = [];
         for (const [key, subagent] of this.subagents) {
           try {
             if (subagent.dispose) {
@@ -5257,24 +5562,54 @@ ${task.task}` : task.task;
             }
             logger.debug("Subagent disposed", { key });
           } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
             logger.warn("Error disposing subagent", {
               key,
-              error: error instanceof Error ? error.message : String(error)
+              error: errorMsg
             });
+            errors.push({ key, error: errorMsg });
           }
         }
+        const orchestrator = this.orchestrator;
         this.subagents.clear();
+        this.busySubagents.clear();
+        if (orchestrator && typeof orchestrator.dispose === "function") {
+          try {
+            await orchestrator.dispose();
+          } catch (error) {
+            logger.warn("Error disposing subagent orchestrator", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        } else if (orchestrator && typeof orchestrator.shutdown === "function") {
+          try {
+            await orchestrator.shutdown();
+          } catch (error) {
+            logger.warn("Error shutting down subagent orchestrator", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
         this.orchestrator = null;
+        if (errors.length > 0) {
+          logger.error("SubagentAdapter cleanup had errors", {
+            errorCount: errors.length,
+            errors
+          });
+        }
         logger.debug("SubagentAdapter destroyed");
       }
     };
   }
 });
-var CheckpointAdapter;
+var DEFAULT_CHECKPOINT_DIR, DEFAULT_MAX_CHECKPOINTS, FLUSH_TIMEOUT_MS, CheckpointAdapter;
 var init_checkpoint_adapter = __esm({
   "src/integrations/ax-cli-sdk/checkpoint-adapter.ts"() {
     init_esm_shims();
     init_logger();
+    DEFAULT_CHECKPOINT_DIR = ".automatosx/checkpoints";
+    DEFAULT_MAX_CHECKPOINTS = 10;
+    FLUSH_TIMEOUT_MS = 5e3;
     CheckpointAdapter = class {
       checkpointDir;
       sdkCheckpointManager = null;
@@ -5282,11 +5617,12 @@ var init_checkpoint_adapter = __esm({
       options;
       autoSaveTimer = null;
       pendingCheckpoint = null;
+      fsLock = Promise.resolve();
       constructor(options = {}) {
         this.options = {
-          checkpointDir: options.checkpointDir ?? ".automatosx/checkpoints",
+          checkpointDir: options.checkpointDir ?? DEFAULT_CHECKPOINT_DIR,
           autoSaveInterval: options.autoSaveInterval ?? 0,
-          maxCheckpoints: options.maxCheckpoints ?? 10,
+          maxCheckpoints: options.maxCheckpoints ?? DEFAULT_MAX_CHECKPOINTS,
           compress: options.compress ?? false
         };
         this.checkpointDir = this.options.checkpointDir;
@@ -5328,8 +5664,10 @@ var init_checkpoint_adapter = __esm({
             });
           }
         }
-        await this.saveToFileSystem(checkpoint);
-        await this.cleanupOldCheckpoints(workflowId);
+        await this.withFsLock(async () => {
+          await this.saveToFileSystem(checkpoint);
+          await this.cleanupOldCheckpoints(workflowId);
+        });
         logger.info("Checkpoint saved", {
           workflowId,
           phase: checkpoint.phase,
@@ -5387,23 +5725,32 @@ var init_checkpoint_adapter = __esm({
             });
           }
         }
-        await this.deleteFromFileSystem(workflowId);
+        await this.withFsLock(() => this.deleteFromFileSystem(workflowId));
         logger.info("Checkpoints deleted", { workflowId });
       }
       /**
        * List all checkpoints for a workflow
+       *
+       * BUG FIX (v11.3.3): The previous pattern `startsWith(workflowId-)` would match
+       * similar workflow IDs. For example, "auth" would match "auth-v2-1.json".
+       * Now we verify that the suffix after the workflowId is a numeric phase.
        */
       async list(workflowId) {
         try {
-          await fs4.mkdir(this.checkpointDir, { recursive: true });
-          const files = await fs4.readdir(this.checkpointDir);
-          const matchingFiles = files.filter(
-            (file) => file.startsWith(workflowId) && file.endsWith(".json")
-          );
+          await fs5.mkdir(this.checkpointDir, { recursive: true });
+          const files = await fs5.readdir(this.checkpointDir);
+          const prefix = `${workflowId}-`;
+          const matchingFiles = files.filter((file) => {
+            if (!file.startsWith(prefix) || !file.endsWith(".json")) {
+              return false;
+            }
+            const middle = file.slice(prefix.length, -5);
+            return /^\d+$/.test(middle);
+          });
           const results = await Promise.all(
             matchingFiles.map(async (file) => {
               try {
-                const content = await fs4.readFile(
+                const content = await fs5.readFile(
                   path4.join(this.checkpointDir, file),
                   "utf-8"
                 );
@@ -5433,6 +5780,13 @@ var init_checkpoint_adapter = __esm({
       async savePhase(workflowId, phaseId, result, workflow) {
         let checkpoint = await this.load(workflowId);
         const phaseIndex = workflow.phases.findIndex((p) => p.id === phaseId);
+        if (phaseIndex === -1) {
+          logger.warn("Phase not found in workflow", {
+            workflowId,
+            phaseId,
+            availablePhases: workflow.phases.map((p) => p.id)
+          });
+        }
         if (!checkpoint) {
           checkpoint = {
             id: `${workflowId}-${Date.now()}`,
@@ -5449,9 +5803,12 @@ var init_checkpoint_adapter = __esm({
         }
         if (result.success) {
           checkpoint.completedTasks.push(phaseId);
-          checkpoint.phase = phaseIndex + 1;
+          if (phaseIndex >= 0) {
+            checkpoint.phase = phaseIndex + 1;
+          }
+          const phaseLabel = phaseIndex >= 0 ? `Phase ${phaseIndex + 1}` : "Unknown Phase";
           checkpoint.context += `
-[Phase ${phaseIndex + 1}: ${phaseId}]
+[${phaseLabel}: ${phaseId}]
 ${result.content.substring(0, 1e3)}
 `;
           if (result.tokensUsed && checkpoint.tokensUsed) {
@@ -5498,11 +5855,11 @@ ${result.content.substring(0, 1e3)}
         await this.sdkCheckpointManager.delete(workflowId);
       }
       async saveToFileSystem(checkpoint) {
-        await fs4.mkdir(this.checkpointDir, { recursive: true });
+        await fs5.mkdir(this.checkpointDir, { recursive: true });
         const filename = `${checkpoint.workflowId}-${checkpoint.phase}.json`;
         const filepath = path4.join(this.checkpointDir, filename);
         const content = JSON.stringify(checkpoint, null, 2);
-        await fs4.writeFile(filepath, content, "utf-8");
+        await this.atomicWrite(filepath, content);
       }
       async loadFromFileSystem(workflowId) {
         try {
@@ -5512,12 +5869,21 @@ ${result.content.substring(0, 1e3)}
           return null;
         }
       }
+      /**
+       * BUG FIX (v11.3.3): Use same precise matching as list() to avoid
+       * deleting checkpoints for workflows with similar IDs.
+       */
       async deleteFromFileSystem(workflowId) {
         try {
-          const files = await fs4.readdir(this.checkpointDir);
+          const files = await fs5.readdir(this.checkpointDir);
+          const prefix = `${workflowId}-`;
           for (const file of files) {
-            if (file.startsWith(workflowId) && file.endsWith(".json")) {
-              await fs4.unlink(path4.join(this.checkpointDir, file));
+            if (!file.startsWith(prefix) || !file.endsWith(".json")) {
+              continue;
+            }
+            const middle = file.slice(prefix.length, -5);
+            if (/^\d+$/.test(middle)) {
+              await fs5.unlink(path4.join(this.checkpointDir, file));
             }
           }
         } catch (error) {
@@ -5535,7 +5901,7 @@ ${result.content.substring(0, 1e3)}
           for (const checkpoint of toDelete) {
             try {
               const filename = `${checkpoint.workflowId}-${checkpoint.phase}.json`;
-              await fs4.unlink(path4.join(this.checkpointDir, filename));
+              await fs5.unlink(path4.join(this.checkpointDir, filename));
             } catch {
             }
           }
@@ -5559,8 +5925,11 @@ ${result.content.substring(0, 1e3)}
         }
       }
       setupAutoSave() {
+        let autoSaveRunning = false;
         this.autoSaveTimer = setInterval(async () => {
+          if (autoSaveRunning) return;
           if (this.pendingCheckpoint) {
+            autoSaveRunning = true;
             try {
               await this.save(
                 this.pendingCheckpoint.workflowId,
@@ -5571,6 +5940,8 @@ ${result.content.substring(0, 1e3)}
               logger.warn("Auto-save failed", {
                 error: error instanceof Error ? error.message : String(error)
               });
+            } finally {
+              autoSaveRunning = false;
             }
           }
         }, this.options.autoSaveInterval);
@@ -5584,6 +5955,7 @@ ${result.content.substring(0, 1e3)}
       /**
        * Cleanup resources
        * BUG FIX: Flush pending checkpoint before destroying to prevent data loss
+       * BUG FIX: Add timeout to prevent hanging during cleanup
        */
       async destroy() {
         if (this.autoSaveTimer) {
@@ -5592,10 +5964,15 @@ ${result.content.substring(0, 1e3)}
         }
         if (this.pendingCheckpoint) {
           try {
-            await this.save(
-              this.pendingCheckpoint.workflowId,
-              this.pendingCheckpoint
-            );
+            await Promise.race([
+              this.save(
+                this.pendingCheckpoint.workflowId,
+                this.pendingCheckpoint
+              ),
+              new Promise(
+                (_, reject) => setTimeout(() => reject(new Error("Checkpoint flush timed out")), FLUSH_TIMEOUT_MS)
+              )
+            ]);
             logger.debug("Pending checkpoint flushed on destroy", {
               workflowId: this.pendingCheckpoint.workflowId
             });
@@ -5609,12 +5986,44 @@ ${result.content.substring(0, 1e3)}
         this.sdkCheckpointManager = null;
         logger.debug("CheckpointAdapter destroyed");
       }
+      /**
+       * Serialize filesystem operations to avoid race conditions between auto-save and manual saves.
+       */
+      async withFsLock(fn) {
+        const resultPromise = this.fsLock.then(fn, fn);
+        this.fsLock = resultPromise.then(
+          () => Promise.resolve(),
+          () => Promise.resolve()
+        );
+        return resultPromise;
+      }
+      /**
+       * Write checkpoint atomically to avoid partial files being read by list/load.
+       * BUG FIX: Clean up temp file on rename failure to prevent resource leak.
+       */
+      async atomicWrite(filepath, content) {
+        const tempFile = `${filepath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        await fs5.writeFile(tempFile, content, "utf-8");
+        try {
+          await fs5.rename(tempFile, filepath);
+        } catch (renameError) {
+          try {
+            await fs5.unlink(tempFile);
+          } catch {
+          }
+          throw renameError;
+        }
+      }
     };
   }
 });
 function getInstructionsBridge(options) {
   if (!defaultBridge) {
     defaultBridge = new InstructionsBridge(options);
+  } else if (options) {
+    logger.warn("InstructionsBridge already initialized, ignoring new options", {
+      hint: "Use resetInstructionsBridge() to recreate with new options"
+    });
   }
   return defaultBridge;
 }
@@ -5646,8 +6055,9 @@ var init_instructions_bridge = __esm({
        * @returns Combined instructions from all sources
        */
       async getInstructions(agentName, additionalContext) {
+        const cacheSignature = await this.buildCacheSignature(agentName);
         const cached = this.cache.get(agentName);
-        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+        if (cached && cached.signature === cacheSignature && Date.now() - cached.timestamp < this.CACHE_TTL) {
           logger.debug("Using cached instructions", { agentName });
           if (additionalContext) {
             return {
@@ -5685,7 +6095,11 @@ var init_instructions_bridge = __esm({
             projectMemory: !!projectContext
           }
         };
-        this.cache.set(agentName, { instructions: combined, timestamp: Date.now() });
+        this.cache.set(agentName, {
+          instructions: combined,
+          timestamp: Date.now(),
+          signature: cacheSignature
+        });
         logger.info("Instructions combined", {
           agentName,
           sources: combined.sources,
@@ -5710,13 +6124,13 @@ var init_instructions_bridge = __esm({
         if (additionalContext) {
           parts.push("## Additional Context\n\n" + additionalContext);
         }
-        let combined = parts.join("\n\n---\n\n");
+        const combined = parts.join("\n\n---\n\n");
         if (combined.length > this.options.maxContextLength) {
-          combined = combined.substring(0, this.options.maxContextLength - 100) + "\n\n[Context truncated due to length limit]";
           logger.warn("Instructions truncated", {
-            originalLength: parts.join("\n\n---\n\n").length,
+            originalLength: combined.length,
             truncatedTo: this.options.maxContextLength
           });
+          return combined.substring(0, this.options.maxContextLength - 100) + "\n\n[Context truncated due to length limit]";
         }
         return combined;
       }
@@ -5726,7 +6140,7 @@ var init_instructions_bridge = __esm({
       async loadAgentProfile(agentName) {
         const profilePath = path4.join(this.options.agentsDir, `${agentName}.ax.yaml`);
         try {
-          const content = await fs4.readFile(profilePath, "utf-8");
+          const content = await fs5.readFile(profilePath, "utf-8");
           const profile = this.parseYamlProfile(content);
           logger.debug("Agent profile loaded", { agentName, profilePath });
           return profile;
@@ -5761,7 +6175,7 @@ var init_instructions_bridge = __esm({
           }
         }
         try {
-          const content = await fs4.readFile(this.options.axCliCustomPath, "utf-8");
+          const content = await fs5.readFile(this.options.axCliCustomPath, "utf-8");
           logger.debug("Custom instructions loaded from file", {
             path: this.options.axCliCustomPath
           });
@@ -5805,6 +6219,11 @@ var init_instructions_bridge = __esm({
       }
       /**
        * Parse YAML profile content (simple parser)
+       *
+       * BUG FIX (v11.3.3):
+       * - Support keys with hyphens/underscores (e.g., display_name, my-key)
+       * - Strip quotes from string values
+       * - Handle empty values correctly
        */
       parseYamlProfile(content) {
         const lines = content.split("\n");
@@ -5813,27 +6232,33 @@ var init_instructions_bridge = __esm({
         let instructionsBuffer = [];
         let inInstructions = false;
         for (const line of lines) {
-          const match = line.match(/^(\w+):\s*(.*)$/);
+          const match = line.match(/^([\w-]+):\s*(.*)$/);
           if (match) {
-            const [, key, value] = match;
-            if (inInstructions && key !== "instructions") {
+            const [, rawKey, rawValue] = match;
+            const key = rawKey ?? "";
+            let value = rawValue ?? "";
+            if (value && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+              value = value.slice(1, -1);
+            }
+            const normalizedKey = key.replace(/-/g, "_");
+            if (inInstructions && normalizedKey !== "instructions") {
               profile.instructions = instructionsBuffer.join("\n").trim();
               instructionsBuffer = [];
               inInstructions = false;
             }
-            if (key === "instructions") {
+            if (normalizedKey === "instructions") {
               inInstructions = true;
-              currentKey = key;
+              currentKey = normalizedKey;
               if (value && value.startsWith("|")) ; else if (value) {
                 profile.instructions = value;
                 inInstructions = false;
               }
-            } else if (key === "expertise") {
+            } else if (normalizedKey === "expertise") {
               profile.expertise = [];
-              currentKey = key;
-            } else if (key && value !== void 0) {
-              profile[key] = value;
-              currentKey = key;
+              currentKey = normalizedKey;
+            } else if (normalizedKey && value !== void 0) {
+              profile[normalizedKey] = value;
+              currentKey = normalizedKey;
             }
           } else if (inInstructions) {
             instructionsBuffer.push(line.replace(/^  /, ""));
@@ -5880,8 +6305,8 @@ ${profile.expertise.map((e) => `- ${e}`).join("\n")}
 ${profile.instructions}
 `;
         try {
-          await fs4.mkdir(path4.dirname(this.options.axCliCustomPath), { recursive: true });
-          await fs4.writeFile(this.options.axCliCustomPath, customContent, "utf-8");
+          await fs5.mkdir(path4.dirname(this.options.axCliCustomPath), { recursive: true });
+          await fs5.writeFile(this.options.axCliCustomPath, customContent, "utf-8");
           logger.info("Agent synced to ax-cli custom instructions", {
             agentName,
             path: this.options.axCliCustomPath
@@ -5923,6 +6348,26 @@ ${profile.instructions}
         this.cache.delete(agentName);
         logger.debug("Agent cache cleared", { agentName });
       }
+      /**
+       * Build a cache signature from underlying file mtimes to invalidate cache when
+       * agent profiles or custom instructions change on disk.
+       */
+      async buildCacheSignature(agentName) {
+        const profilePath = path4.join(this.options.agentsDir, `${agentName}.ax.yaml`);
+        const [profileSig, customSig] = await Promise.all([
+          this.getFileSignature(profilePath),
+          this.getFileSignature(this.options.axCliCustomPath)
+        ]);
+        return [profileSig, customSig, this.options.includeProjectMemory ? "mem" : "nomem"].join("|");
+      }
+      async getFileSignature(filePath) {
+        try {
+          const stats = await fs5.stat(filePath);
+          return `${stats.mtimeMs}:${stats.size}`;
+        } catch {
+          return "missing";
+        }
+      }
     };
     defaultBridge = null;
   }
@@ -5932,14 +6377,19 @@ ${profile.instructions}
 function getAxCliMCPManager(options) {
   if (!defaultManager2) {
     defaultManager2 = new AxCliMCPManager(options);
+  } else if (options) {
+    logger.warn("AxCliMCPManager already initialized, ignoring new options", {
+      hint: "Use resetAxCliMCPManager() to recreate with new options"
+    });
   }
   return defaultManager2;
 }
-var AxCliMCPManager, defaultManager2;
+var SDK_NOT_AVAILABLE_ERROR, AxCliMCPManager, defaultManager2;
 var init_mcp_manager = __esm({
   "src/integrations/ax-cli-sdk/mcp-manager.ts"() {
     init_esm_shims();
     init_logger();
+    SDK_NOT_AVAILABLE_ERROR = "ax-cli SDK not available";
     AxCliMCPManager = class {
       sdkAvailable = null;
       mcpModule = null;
@@ -5976,7 +6426,7 @@ var init_mcp_manager = __esm({
       async getTemplateNames() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.getTemplateNames) {
@@ -6013,7 +6463,7 @@ var init_mcp_manager = __esm({
       async getTemplate(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.getTemplate) {
@@ -6037,7 +6487,7 @@ var init_mcp_manager = __esm({
       async getTemplatesByCategory(category) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.getTemplatesByCategory) {
@@ -6058,7 +6508,7 @@ var init_mcp_manager = __esm({
       async searchTemplates(keyword) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.searchTemplates) {
@@ -6079,7 +6529,7 @@ var init_mcp_manager = __esm({
       async generateConfigFromTemplate(templateName, env) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.generateConfigFromTemplate) {
@@ -6100,7 +6550,7 @@ var init_mcp_manager = __esm({
       async loadConfig() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.loadMCPConfig) {
@@ -6121,7 +6571,7 @@ var init_mcp_manager = __esm({
       async addServer(name, config) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.addMCPServer) {
@@ -6143,7 +6593,7 @@ var init_mcp_manager = __esm({
       async removeServer(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.removeMCPServer) {
@@ -6165,7 +6615,7 @@ var init_mcp_manager = __esm({
       async getPredefinedServers() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.PREDEFINED_SERVERS) {
@@ -6217,7 +6667,7 @@ var init_mcp_manager = __esm({
       async getServerStatus(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.getServerStatus) {
@@ -6251,7 +6701,7 @@ var init_mcp_manager = __esm({
       async getAllServerStatuses() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.getAllServerStatuses) {
@@ -6275,7 +6725,7 @@ var init_mcp_manager = __esm({
       async healthCheck() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.healthCheck) {
@@ -6300,7 +6750,7 @@ var init_mcp_manager = __esm({
       async startServer(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.startServer) {
@@ -6315,9 +6765,16 @@ var init_mcp_manager = __esm({
           }
           return { ok: false, error: new Error("startServer not available in SDK") };
         } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.serverStatuses.set(name, {
+            name,
+            status: "error",
+            lastHealthCheck: /* @__PURE__ */ new Date(),
+            error: errorMessage
+          });
           return {
             ok: false,
-            error: error instanceof Error ? error : new Error(String(error))
+            error: error instanceof Error ? error : new Error(errorMessage)
           };
         }
       }
@@ -6327,7 +6784,7 @@ var init_mcp_manager = __esm({
       async stopServer(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.stopServer) {
@@ -6342,9 +6799,16 @@ var init_mcp_manager = __esm({
           }
           return { ok: false, error: new Error("stopServer not available in SDK") };
         } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.serverStatuses.set(name, {
+            name,
+            status: "error",
+            lastHealthCheck: /* @__PURE__ */ new Date(),
+            error: errorMessage
+          });
           return {
             ok: false,
-            error: error instanceof Error ? error : new Error(String(error))
+            error: error instanceof Error ? error : new Error(errorMessage)
           };
         }
       }
@@ -6354,7 +6818,7 @@ var init_mcp_manager = __esm({
       async restartServer(name) {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.restartServer) {
@@ -6373,9 +6837,16 @@ var init_mcp_manager = __esm({
           }
           return this.startServer(name);
         } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.serverStatuses.set(name, {
+            name,
+            status: "error",
+            lastHealthCheck: /* @__PURE__ */ new Date(),
+            error: errorMessage
+          });
           return {
             ok: false,
-            error: error instanceof Error ? error : new Error(String(error))
+            error: error instanceof Error ? error : new Error(errorMessage)
           };
         }
       }
@@ -6385,7 +6856,7 @@ var init_mcp_manager = __esm({
       async shutdown() {
         try {
           if (!await this.isAvailable()) {
-            return { ok: false, error: new Error("ax-cli SDK not available") };
+            return { ok: false, error: new Error(SDK_NOT_AVAILABLE_ERROR) };
           }
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.shutdown) {
@@ -6401,11 +6872,27 @@ var init_mcp_manager = __esm({
             return { ok: true, value: void 0 };
           }
           const serversResult = await this.listServers();
-          if (serversResult.ok) {
-            for (const name of serversResult.value) {
-              await this.stopServer(name);
+          if (!serversResult.ok) {
+            logger.warn("Cannot enumerate servers for shutdown", {
+              error: serversResult.error.message
+            });
+            return serversResult;
+          }
+          const errors = [];
+          for (const name of serversResult.value) {
+            const stopResult = await this.stopServer(name);
+            if (!stopResult.ok) {
+              errors.push({
+                name,
+                error: stopResult.error.message
+              });
             }
           }
+          if (errors.length > 0) {
+            const errorMessage = `Failed to stop ${errors.length} server(s): ${errors.map((e) => `${e.name} (${e.error})`).join(", ")}`;
+            logger.warn("Partial MCP shutdown failure", { errors });
+            return { ok: false, error: new Error(errorMessage) };
+          }
           return { ok: true, value: void 0 };
         } catch (error) {
           return {
@@ -6420,7 +6907,7 @@ var init_mcp_manager = __esm({
 });
 
 // src/integrations/ax-cli-sdk/adapter.ts
-var AxCliSdkAdapter;
+var DEFAULT_MAX_TOOL_ROUNDS, AxCliSdkAdapter;
 var init_adapter2 = __esm({
   "src/integrations/ax-cli-sdk/adapter.ts"() {
     init_esm_shims();
@@ -6431,10 +6918,13 @@ var init_adapter2 = __esm({
     init_instructions_bridge();
     init_mcp_manager();
     init_mcp_manager();
+    DEFAULT_MAX_TOOL_ROUNDS = 400;
     AxCliSdkAdapter = class _AxCliSdkAdapter {
       agent = null;
       // Will type as LLMAgent after import
       agentConfig = null;
+      initPromise = null;
+      executionLock = Promise.resolve();
       reuseEnabled;
       streamingEnabled;
       sdkAvailable = null;
@@ -6457,6 +6947,9 @@ var init_adapter2 = __esm({
       /**
        * Get or create SubagentAdapter for parallel multi-agent execution
        *
+       * BUG FIX: Log warning when options are provided but adapter already exists,
+       * as the options will be ignored.
+       *
        * @example
        * ```typescript
        * const subagents = adapter.getSubagentAdapter();
@@ -6470,6 +6963,10 @@ var init_adapter2 = __esm({
         if (!this.subagentAdapter) {
           this.subagentAdapter = new SubagentAdapter(options);
           logger.debug("SubagentAdapter created");
+        } else if (options) {
+          logger.warn("SubagentAdapter already exists, ignoring new options", {
+            hint: "Call destroy() first to recreate with new options"
+          });
         }
         return this.subagentAdapter;
       }
@@ -6495,6 +6992,9 @@ var init_adapter2 = __esm({
       /**
        * Get or create CheckpointAdapter for resumable workflows
        *
+       * BUG FIX: Log warning when options are provided but adapter already exists,
+       * as the options will be ignored.
+       *
        * @example
        * ```typescript
        * const checkpoints = adapter.getCheckpointAdapter();
@@ -6506,6 +7006,10 @@ var init_adapter2 = __esm({
         if (!this.checkpointAdapter) {
           this.checkpointAdapter = new CheckpointAdapter(options);
           logger.debug("CheckpointAdapter created");
+        } else if (options) {
+          logger.warn("CheckpointAdapter already exists, ignoring new options", {
+            hint: "Call destroy() first to recreate with new options"
+          });
         }
         return this.checkpointAdapter;
       }
@@ -6545,6 +7049,9 @@ var init_adapter2 = __esm({
       /**
        * Get or create InstructionsBridge for unified agent instructions
        *
+       * BUG FIX: Log warning when options are provided but bridge already exists,
+       * as the options will be ignored.
+       *
        * @example
        * ```typescript
        * const bridge = adapter.getInstructionsBridge();
@@ -6556,6 +7063,10 @@ var init_adapter2 = __esm({
         if (!this.instructionsBridge) {
           this.instructionsBridge = getInstructionsBridge(options);
           logger.debug("InstructionsBridge created");
+        } else if (options) {
+          logger.warn("InstructionsBridge already exists, ignoring new options", {
+            hint: "Call destroy() first to recreate with new options"
+          });
         }
         return this.instructionsBridge;
       }
@@ -6580,6 +7091,9 @@ var init_adapter2 = __esm({
       /**
        * Get or create MCP Manager for ax-cli MCP server management
        *
+       * BUG FIX: Log warning when options are provided but manager already exists,
+       * as the options will be ignored.
+       *
        * @example
        * ```typescript
        * const mcp = adapter.getMCPManager();
@@ -6591,6 +7105,10 @@ var init_adapter2 = __esm({
         if (!this.mcpManager) {
           this.mcpManager = getAxCliMCPManager(options);
           logger.debug("AxCliMCPManager created");
+        } else if (options) {
+          logger.warn("AxCliMCPManager already exists, ignoring new options", {
+            hint: "Call destroy() first to recreate with new options"
+          });
         }
         return this.mcpManager;
       }
@@ -6636,21 +7154,35 @@ var init_adapter2 = __esm({
        * Performance: ~5ms overhead vs ~50-200ms for CLI spawning
        */
       async execute(prompt, options) {
+        return this.runExclusive(() => this.executeInternal(prompt, options));
+      }
+      /**
+       * Serialize executions to avoid chat history corruption and token mis-tracking
+       * when the same adapter instance is used concurrently.
+       */
+      async runExclusive(fn) {
+        const resultPromise = this.executionLock.then(fn, fn);
+        this.executionLock = resultPromise.then(
+          () => Promise.resolve(),
+          () => Promise.resolve()
+        );
+        return resultPromise;
+      }
+      async executeInternal(prompt, options) {
         const startTime = Date.now();
         let totalTokens = 0;
         try {
           if (!await this.ensureSDKAvailable()) {
             throw new Error("ax-cli SDK not available. Install with: npm install @defai.digital/ax-cli");
           }
-          if (!this.agent || this.hasConfigChanged(options)) {
-            await this.initializeAgent(options);
-          }
+          await this.ensureAgent(options);
           logger.debug("Executing via SDK (streaming mode for token tracking)", {
             promptLength: prompt.length,
             userWantsCallbacks: !!(options.onStream || options.onTool),
             note: "SDK handles custom instructions and project memory"
           });
-          const historyLengthBefore = this.agent.getChatHistory().length;
+          const chatHistory = typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : null;
+          const historyLengthBefore = Array.isArray(chatHistory) ? chatHistory.length : 0;
           for await (const chunk of this.agent.processUserMessageStream(prompt)) {
             if (chunk.type === "token_count" && chunk.tokenCount) {
               totalTokens += chunk.tokenCount;
@@ -6687,8 +7219,8 @@ var init_adapter2 = __esm({
               }
             }
           }
-          const fullHistory = this.agent.getChatHistory();
-          const result = fullHistory.slice(historyLengthBefore);
+          const fullHistory = typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : [];
+          const result = Array.isArray(fullHistory) ? fullHistory.slice(historyLengthBefore) : [];
           logger.debug("Chat history extraction", {
             historyLengthBefore,
             historyLengthAfter: fullHistory.length,
@@ -6728,10 +7260,11 @@ var init_adapter2 = __esm({
        * We do NOT pass credentials to the SDK - it manages its own configuration.
        */
       async initializeAgent(options) {
+        await this.destroyAgentInstance();
         const { createAgent } = await import('@defai.digital/ax-cli/sdk');
         try {
           const config = {
-            maxToolRounds: options.maxToolRounds || 400
+            maxToolRounds: options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS
           };
           logger.debug("Creating SDK agent (credentials from ax-cli settings)", {
             maxToolRounds: config.maxToolRounds,
@@ -6793,22 +7326,75 @@ var init_adapter2 = __esm({
        */
       hasConfigChanged(options) {
         if (!this.agentConfig) return true;
-        const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || 400);
+        const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS);
         if (changed) {
           logger.debug("Agent config changed, will reinitialize", {
             oldMaxToolRounds: this.agentConfig.maxToolRounds,
-            newMaxToolRounds: options.maxToolRounds || 400,
+            newMaxToolRounds: options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS,
             note: "SDK credentials managed by ax-cli setup"
           });
         }
         return changed;
       }
+      /**
+       * Ensure agent is initialized exactly once even if execute() is called
+       * concurrently. Reinitializes when config changes.
+       *
+       * BUG FIX: If config changes while initialization is in progress, we need to
+       * wait for current init to complete, then reinitialize with new config.
+       *
+       * BUG FIX (v11.3.3): Track initialization errors to prevent repeated init
+       * attempts from creating a retry storm. If init fails, remember the error
+       * and rethrow it for subsequent callers until reset.
+       */
+      initError = null;
+      async ensureAgent(options) {
+        if (this.agent && !this.hasConfigChanged(options)) {
+          return;
+        }
+        if (this.initError && !this.agent) {
+          throw this.initError;
+        }
+        if (this.initPromise) {
+          await this.initPromise;
+          if (this.agent && !this.hasConfigChanged(options)) {
+            return;
+          }
+          if (this.initError) {
+            throw this.initError;
+          }
+        }
+        this.initError = null;
+        this.initPromise = this.initializeAgent(options).catch((error) => {
+          this.initError = error instanceof Error ? error : new Error(String(error));
+          throw error;
+        }).finally(() => {
+          this.initPromise = null;
+        });
+        await this.initPromise;
+      }
       /**
        * Set up streaming event handlers (for initialization)
+       *
+       * BUG FIX (v11.3.3): Check if removeAllListeners exists before calling it.
+       * Not all SDK agent implementations extend EventEmitter, and calling
+       * a non-existent method would cause an error. Use optional chaining and
+       * type guards to safely handle this.
        */
       setupEventHandlers() {
         if (!this.agent) return;
         try {
+          if (typeof this.agent.removeAllListeners === "function") {
+            this.agent.removeAllListeners("stream");
+            this.agent.removeAllListeners("tool");
+            this.agent.removeAllListeners("error");
+          } else if (typeof this.agent.off === "function") {
+            logger.debug("Agent uses off() instead of removeAllListeners(), skipping listener cleanup");
+          }
+          if (typeof this.agent.on !== "function") {
+            logger.debug("Agent does not support event subscription, skipping event handlers");
+            return;
+          }
           this.agent.on("stream", (chunk) => {
             logger.debug("Stream chunk received", {
               type: chunk.type,
@@ -6831,50 +7417,6 @@ var init_adapter2 = __esm({
           });
         }
       }
-      /**
-       * Set up streaming callbacks for execution
-       */
-      setupStreamingCallbacks(options) {
-        if (!this.agent) return;
-        try {
-          this.agent.removeAllListeners("stream");
-          this.agent.removeAllListeners("tool");
-          if (options.onStream) {
-            this.agent.on("stream", (chunk) => {
-              try {
-                options.onStream({
-                  type: chunk.type || "content",
-                  content: chunk.content,
-                  tool: chunk.tool,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              } catch (error) {
-                logger.warn("Stream callback error", {
-                  error: error instanceof Error ? error.message : String(error)
-                });
-              }
-            });
-          }
-          if (options.onTool) {
-            this.agent.on("tool", (data) => {
-              try {
-                options.onTool({
-                  name: data.name,
-                  args: data.args
-                });
-              } catch (error) {
-                logger.warn("Tool callback error", {
-                  error: error instanceof Error ? error.message : String(error)
-                });
-              }
-            });
-          }
-        } catch (error) {
-          logger.warn("Failed to setup streaming callbacks", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
       /**
        * Extract token usage from various sources with priority:
        * 1. SDK events (token_count emissions) - most accurate
@@ -6898,9 +7440,9 @@ var init_adapter2 = __esm({
         }
         const usage = usageObject || {};
         const actualTokens = {
-          prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
-          completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
-          total: usage.total_tokens || usage.total || usage.totalTokens || 0
+          prompt: usage.prompt_tokens ?? usage.prompt ?? usage.input ?? usage.promptTokens ?? 0,
+          completion: usage.completion_tokens ?? usage.completion ?? usage.output ?? usage.completionTokens ?? 0,
+          total: usage.total_tokens ?? usage.total ?? usage.totalTokens ?? 0
         };
         if (actualTokens.total > 0) {
           logger.info(`Using token counts from ${sourceName || "usage object"}`, {
@@ -6964,12 +7506,12 @@ var init_adapter2 = __esm({
             cached: false
           };
         }
-        const content = typeof result === "string" ? result : result.content || result.text || "";
+        const content = typeof result === "string" ? result : result?.content || result?.text || "";
         const tokensUsed = this.extractTokenUsage(
           prompt,
           content,
           totalTokensFromEvents,
-          result.usage || result.tokens,
+          result?.usage || result?.tokens,
           "response.usage (fallback path)"
         );
         return {
@@ -7058,21 +7600,7 @@ var init_adapter2 = __esm({
        * Cleanup resources
        */
       async destroy() {
-        if (this.agent) {
-          try {
-            const result = this.agent.dispose();
-            if (result instanceof Promise) {
-              await result;
-            }
-            this.agent = null;
-            this.agentConfig = null;
-            logger.debug("SDK agent destroyed");
-          } catch (error) {
-            logger.warn("Error during agent cleanup", {
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        }
+        await this.destroyAgentInstance();
         if (this.subagentAdapter) {
           try {
             await this.subagentAdapter.destroy();
@@ -7110,8 +7638,43 @@ var init_adapter2 = __esm({
           }
         }
         if (this.mcpManager) {
-          this.mcpManager = null;
-          logger.debug("MCP Manager cleared");
+          try {
+            const shutdownResult = await this.mcpManager.shutdown();
+            if (!shutdownResult.ok) {
+              logger.warn("Error while shutting down MCP servers", {
+                error: shutdownResult.error instanceof Error ? shutdownResult.error.message : String(shutdownResult.error)
+              });
+            }
+          } catch (error) {
+            logger.warn("Error during MCP Manager cleanup", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          } finally {
+            this.mcpManager = null;
+            logger.debug("MCP Manager cleared");
+          }
+        }
+      }
+      /**
+       * Dispose the primary agent without touching ancillary adapters.
+       * BUG FIX (v11.3.3): Also clear initError to allow retry after destroy.
+       */
+      async destroyAgentInstance() {
+        this.initError = null;
+        if (!this.agent) return;
+        try {
+          const result = this.agent.dispose();
+          if (result instanceof Promise) {
+            await result;
+          }
+        } catch (error) {
+          logger.warn("Error during agent cleanup", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        } finally {
+          this.agent = null;
+          this.agentConfig = null;
+          logger.debug("SDK agent destroyed");
         }
       }
     };
@@ -7158,10 +7721,22 @@ var init_hybrid_adapter2 = __esm({
           }
           throw new Error(`No adapter available for mode: ${this.mode}`);
         } catch (error) {
-          if (this.mode === "auto" && this.activeMode === "sdk" && this.cliAdapter) {
+          if (this.mode === "auto" && this.activeMode === "sdk") {
             logger.warn("SDK execution failed, falling back to CLI", {
               error: error instanceof Error ? error.message : String(error)
             });
+            if (this.sdkAdapter) {
+              const sdkAdapterToClean = this.sdkAdapter;
+              this.sdkAdapter = null;
+              sdkAdapterToClean.destroy().catch((cleanupError) => {
+                logger.warn("Error during SDK adapter cleanup on fallback", {
+                  error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+                });
+              });
+            }
+            if (!this.cliAdapter) {
+              this.initializeCli();
+            }
             this.activeMode = "cli";
             return await this.executeCli(prompt, options);
           }
@@ -7230,15 +7805,25 @@ var init_hybrid_adapter2 = __esm({
        *
        * @param required - If true, throws if SDK unavailable
        * @returns true if SDK is available, false otherwise
+       *
+       * BUG FIX (v11.3.3): Clean up SDK adapter if isAvailable() returns false.
+       * Previously the adapter was just set to null without calling destroy(),
+       * which could leak resources initialized in the constructor.
        */
       async initializeSdk(required) {
         if (this.sdkAdapter) {
           return true;
         }
+        let adapter = null;
         try {
-          this.sdkAdapter = new AxCliSdkAdapter(this.sdkOptions);
-          const available = await this.sdkAdapter.isAvailable();
+          adapter = new AxCliSdkAdapter(this.sdkOptions);
+          const available = await adapter.isAvailable();
           if (!available) {
+            await adapter.destroy().catch((cleanupError) => {
+              logger.warn("Error cleaning up unavailable SDK adapter", {
+                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+              });
+            });
             if (required) {
               throw new Error(
                 "ax-cli SDK not available. Install with: npm install @defai.digital/ax-cli"
@@ -7247,14 +7832,21 @@ var init_hybrid_adapter2 = __esm({
             logger.warn("SDK not available", {
               hint: "Install with: npm install @defai.digital/ax-cli"
             });
-            this.sdkAdapter = null;
             return false;
           }
+          this.sdkAdapter = adapter;
           logger.info("SDK adapter initialized", {
             version: await this.sdkAdapter.getVersion()
           });
           return true;
         } catch (error) {
+          if (adapter) {
+            await adapter.destroy().catch((cleanupError) => {
+              logger.warn("Error cleaning up SDK adapter after error", {
+                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+              });
+            });
+          }
           logger.error("Failed to initialize SDK adapter", {
             error: error instanceof Error ? error.message : String(error)
           });
@@ -7303,6 +7895,9 @@ var init_hybrid_adapter2 = __esm({
       }
       /**
        * Get command name
+       *
+       * BUG FIX: Handle 'auto' mode correctly - return 'ax-cli-auto' to indicate
+       * the actual command hasn't been determined yet (will be sdk or cli after initialization)
        */
       getCommand() {
         if (this.activeMode === "sdk") {
@@ -7310,7 +7905,13 @@ var init_hybrid_adapter2 = __esm({
         } else if (this.activeMode === "cli") {
           return "ax-cli";
         }
-        return this.mode === "sdk" ? "ax-cli-sdk" : "ax-cli";
+        if (this.mode === "sdk") {
+          return "ax-cli-sdk";
+        } else if (this.mode === "cli") {
+          return "ax-cli";
+        } else {
+          return "ax-cli-auto";
+        }
       }
       /**
        * Get display name
@@ -7331,9 +7932,22 @@ var init_hybrid_adapter2 = __esm({
       }
       /**
        * Force switch to CLI mode (for debugging or fallback)
+       *
+       * BUG FIX: Destroy SDK adapter when switching to CLI to prevent resource leaks
+       * (memory, event listeners) from the unused SDK adapter.
        */
-      switchToCliMode() {
+      async switchToCliMode() {
         logger.info("Forcing switch to CLI mode");
+        if (this.sdkAdapter) {
+          try {
+            await this.sdkAdapter.destroy();
+          } catch (error) {
+            logger.warn("Error destroying SDK adapter during mode switch", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          this.sdkAdapter = null;
+        }
         this.initializeCli();
         this.activeMode = "cli";
       }
@@ -7353,13 +7967,22 @@ var init_hybrid_adapter2 = __esm({
       }
       /**
        * Cleanup resources
+       * BUG FIX: Use Promise.allSettled to ensure cleanup completes even if SDK destroy fails
        */
       async destroy() {
         const destroyPromises = [];
         if (this.sdkAdapter) {
           destroyPromises.push(this.sdkAdapter.destroy());
         }
-        await Promise.all(destroyPromises);
+        const results = await Promise.allSettled(destroyPromises);
+        results.forEach((result, index) => {
+          if (result.status === "rejected") {
+            logger.warn("Adapter cleanup failed", {
+              index,
+              error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+            });
+          }
+        });
         this.sdkAdapter = null;
         this.cliAdapter = null;
         this.activeMode = null;
@@ -7375,7 +7998,7 @@ __export(ax_cli_provider_exports, {
   AxCliProvider: () => AxCliProvider,
   GlmProvider: () => GlmProvider
 });
-var SDK_ADAPTER_UNAVAILABLE_ERROR, AxCliProvider, GlmProvider;
+var SDK_ADAPTER_UNAVAILABLE_ERROR, DEFAULT_MAX_TOOL_ROUNDS2, AxCliProvider, GlmProvider;
 var init_ax_cli_provider = __esm({
   "src/providers/ax-cli-provider.ts"() {
     init_esm_shims();
@@ -7383,6 +8006,7 @@ var init_ax_cli_provider = __esm({
     init_hybrid_adapter2();
     init_logger();
     SDK_ADAPTER_UNAVAILABLE_ERROR = 'SDK adapter not available. Ensure mode="sdk" or "auto" with SDK installed.';
+    DEFAULT_MAX_TOOL_ROUNDS2 = 400;
     AxCliProvider = class extends BaseProvider {
       adapter;
       config;
@@ -7413,7 +8037,7 @@ var init_ax_cli_provider = __esm({
         const options = {
           model: request.model || axCliConfig.model,
           // Optional model override
-          maxToolRounds: axCliConfig.maxToolRounds || 400,
+          maxToolRounds: axCliConfig.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS2,
           timeout: this.config.timeout,
           // Note: apiKey and baseUrl are ignored by SDK adapter (v3.7.0+)
           // SDK loads credentials from ax-cli setup (~/.ax-cli/config.json)
@@ -7441,18 +8065,31 @@ var init_ax_cli_provider = __esm({
             error: error instanceof Error ? error.message : String(error),
             model: options.model || "(from ax-cli setup)"
           });
-          throw error;
+          throw this.handleError(error);
         }
       }
       /**
        * Check if ax-cli is available
        *
+       * BUG FIX: Update health status like BaseProvider.isAvailable() does.
+       * Previously only returned the availability boolean without updating
+       * the provider's health state, which meant consecutiveFailures,
+       * consecutiveSuccesses, and errorRate weren't tracked for this provider.
+       *
        * @returns True if ax-cli is installed and accessible
        */
       async isAvailable() {
         try {
           const available = await this.adapter.isAvailable();
-          if (!available) {
+          this.health.available = available;
+          this.health.errorRate = available ? 0 : 1;
+          this.health.lastCheck = Date.now();
+          if (available) {
+            this.health.consecutiveFailures = 0;
+            this.health.consecutiveSuccesses++;
+          } else {
+            this.health.consecutiveFailures++;
+            this.health.consecutiveSuccesses = 0;
             logger.warn("ax-cli is not available", {
               provider: this.name,
               command: this.adapter.getCommand()
@@ -7460,6 +8097,11 @@ var init_ax_cli_provider = __esm({
           }
           return available;
         } catch (error) {
+          this.health.available = false;
+          this.health.errorRate = 1;
+          this.health.lastCheck = Date.now();
+          this.health.consecutiveFailures++;
+          this.health.consecutiveSuccesses = 0;
           logger.error("Failed to check ax-cli availability", {
             error: error instanceof Error ? error.message : String(error)
           });
@@ -7499,9 +8141,11 @@ var init_ax_cli_provider = __esm({
       }
       /**
        * Force switch to CLI mode (for debugging or fallback)
+       *
+       * This method is async because it needs to clean up SDK adapter resources.
        */
-      switchToCliMode() {
-        this.adapter.switchToCliMode();
+      async switchToCliMode() {
+        await this.adapter.switchToCliMode();
       }
       // ==========================================
       // SDK Advanced Features (v10.4.0)
@@ -7520,7 +8164,7 @@ var init_ax_cli_provider = __esm({
        * ]);
        * ```
        */
-      async executeParallelTasks(tasks, options) {
+      async executeParallelTasks(tasks) {
         const sdkAdapter = this.adapter.getSdkAdapter();
         if (!sdkAdapter) {
           throw new Error(SDK_ADAPTER_UNAVAILABLE_ERROR);
@@ -7649,6 +8293,28 @@ var init_ax_cli_provider = __esm({
       getMockResponse() {
         return "Mock ax-cli response for testing";
       }
+      /**
+       * Cleanup provider resources
+       *
+       * BUG FIX (v11.3.3): AxCliProvider was missing a destroy() method, which meant
+       * the underlying HybridAxCliAdapter (and its SDK adapter, subagent adapter,
+       * checkpoint adapter, etc.) would never be cleaned up. This could cause:
+       * - Memory leaks from cached SDK agents
+       * - Unflushed checkpoint data
+       * - Orphaned MCP server connections
+       *
+       * Call this method when the provider is no longer needed.
+       */
+      async destroy() {
+        try {
+          await this.adapter.destroy();
+          logger.info("AxCliProvider destroyed");
+        } catch (error) {
+          logger.warn("Error during AxCliProvider cleanup", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
     };
     GlmProvider = AxCliProvider;
   }
@@ -8626,11 +9292,11 @@ var VALIDATION_LIMITS = {
   MAX_PORT: 65535
   // Maximum port number
 };
-function isValidRelativePath(path7) {
-  if (!path7 || typeof path7 !== "string") {
+function isValidRelativePath(path8) {
+  if (!path8 || typeof path8 !== "string") {
     return false;
   }
-  const normalizedPath = path7.replace(/\\/g, "/");
+  const normalizedPath = path8.replace(/\\/g, "/");
   if (normalizedPath.startsWith("/")) {
     return false;
   }
@@ -9022,7 +9688,7 @@ var PRECOMPILED_CONFIG = {
   "providers": {
     "claude-code": {
       "enabled": true,
-      "priority": 1,
+      "priority": 3,
       "timeout": 27e5,
       "command": "claude",
       "healthCheck": {
@@ -9082,7 +9748,7 @@ var PRECOMPILED_CONFIG = {
     },
     "openai": {
       "enabled": true,
-      "priority": 3,
+      "priority": 1,
       "timeout": 27e5,
       "command": "codex",
       "healthCheck": {
@@ -9320,7 +9986,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.1"
+  "version": "11.3.3"
 };
 
 // src/core/config/schemas.ts
@@ -9347,7 +10013,7 @@ var safeNameSchema = z.string().min(1).max(VALIDATION_LIMITS.MAX_NAME_LENGTH).re
   "Name must be alphanumeric with dash/underscore only"
 ).describe("Safe identifier name");
 var relativePathSchema = z.string().min(1).refine(
-  (path7) => !path7.includes("..") && !path7.startsWith("/"),
+  (path8) => !path8.includes("..") && !path8.startsWith("/"),
   "Path must be relative (no ../, no absolute paths)"
 ).describe("Relative path within project");
 var fileExtensionSchema = z.string().regex(
@@ -9687,16 +10353,16 @@ async function loadConfigUncached(projectDir) {
   });
   return config;
 }
-async function loadConfigFile(path7) {
+async function loadConfigFile(path8) {
   try {
-    const content = await readFile(path7, "utf-8");
+    const content = await readFile(path8, "utf-8");
     if (content.length > VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE) {
       throw ConfigError.parseError(
         new Error(`Config file too large (max ${VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE / 1024}KB, got ${Math.ceil(content.length / 1024)}KB)`),
-        path7
+        path8
       );
     }
-    const ext = extname(path7).toLowerCase();
+    const ext = extname(path8).toLowerCase();
     let userConfig;
     try {
       if (ext === ".yaml" || ext === ".yml") {
@@ -9705,7 +10371,7 @@ async function loadConfigFile(path7) {
         userConfig = JSON.parse(content);
       }
     } catch (parseError) {
-      throw ConfigError.parseError(parseError, path7);
+      throw ConfigError.parseError(parseError, path8);
     }
     const config = mergeConfig(DEFAULT_CONFIG, userConfig);
     if (config.execution && userConfig.execution?.maxConcurrentAgents === void 0) {
@@ -9721,35 +10387,35 @@ async function loadConfigFile(path7) {
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path7, errors: validationErrors }
+        { path: path8, errors: validationErrors }
       );
     }
-    logger.info("Config loaded successfully", { path: normalizePath(path7), format: ext });
+    logger.info("Config loaded successfully", { path: normalizePath(path8), format: ext });
     return config;
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "ENOENT") {
-      throw ConfigError.notFound(path7);
+      throw ConfigError.notFound(path8);
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied reading config: ${path7}`,
+        `Permission denied reading config: ${path8}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the file is accessible"
         ],
-        { path: path7, error: error.message }
+        { path: path8, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to load config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file format and permissions"],
-      { path: path7, originalError: error.message }
+      { path: path8, originalError: error.message }
     );
   }
 }
@@ -9765,8 +10431,8 @@ function validateConfigWithZod(config) {
     return ["Configuration validation failed with unknown error structure"];
   }
   return result.error.issues.map((err) => {
-    const path7 = err.path.join(".");
-    return `${path7}: ${err.message}`;
+    const path8 = err.path.join(".");
+    return `${path8}: ${err.message}`;
   });
 }
 function validateConfig(config) {
@@ -10152,16 +10818,16 @@ function validateConfig(config) {
   }
   return errors;
 }
-async function saveConfigFile(path7, config) {
+async function saveConfigFile(path8, config) {
   try {
     const validationErrors = validateConfig(config);
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path7, errors: validationErrors }
+        { path: path8, errors: validationErrors }
       );
     }
-    const ext = extname(path7).toLowerCase();
+    const ext = extname(path8).toLowerCase();
     let content;
     if (ext === ".yaml" || ext === ".yml") {
       content = dump(config, {
@@ -10173,30 +10839,30 @@ async function saveConfigFile(path7, config) {
     } else {
       content = JSON.stringify(config, null, 2);
     }
-    await writeFile(path7, content, "utf-8");
+    await writeFile(path8, content, "utf-8");
     configCache.clear();
-    logger.info("Config saved successfully", { path: normalizePath(path7), format: ext });
+    logger.info("Config saved successfully", { path: normalizePath(path8), format: ext });
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied writing config: ${path7}`,
+        `Permission denied writing config: ${path8}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the directory is writable"
         ],
-        { path: path7, error: error.message }
+        { path: path8, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to save config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file path and permissions"],
-      { path: path7, originalError: error.message }
+      { path: path8, originalError: error.message }
     );
   }
 }
@@ -10946,10 +11612,10 @@ var configCommand = {
       } else {
         const projectConfig = resolve(process.cwd(), "ax.config.json");
         const hiddenConfig = resolve(process.cwd(), ".automatosx", "config.json");
-        const fs7 = await import('fs');
-        if (fs7.existsSync(projectConfig)) {
+        const fs8 = await import('fs');
+        if (fs8.existsSync(projectConfig)) {
           configPath = projectConfig;
-        } else if (fs7.existsSync(hiddenConfig)) {
+        } else if (fs8.existsSync(hiddenConfig)) {
           configPath = hiddenConfig;
         } else {
           configPath = projectConfig;
@@ -10996,9 +11662,9 @@ var configCommand = {
     }
   }
 };
-async function checkExists(path7) {
+async function checkExists(path8) {
   try {
-    await access$1(path7, constants.F_OK);
+    await access$1(path8, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -11029,7 +11695,7 @@ async function validateConfigFile(config, verbose) {
   }
   console.log();
 }
-async function resetConfig(path7, verbose) {
+async function resetConfig(path8, verbose) {
   const { createRequire } = await import('module');
   const require2 = createRequire(import.meta.url);
   let version = "11.2.6";
@@ -11044,14 +11710,14 @@ async function resetConfig(path7, verbose) {
     // Users should rely on IDE JSON Schema plugins that fetch from npm package
     version
   };
-  await saveConfigFile(path7, config);
+  await saveConfigFile(path8, config);
   printSuccess("Configuration reset to defaults");
   if (verbose) {
     console.log(chalk5.gray(`
-Config file: ${path7}
+Config file: ${path8}
 `));
   }
-  logger.info("Configuration reset", { path: path7 });
+  logger.info("Configuration reset", { path: path8 });
 }
 async function listConfig(config, verbose) {
   console.log(chalk5.bold.cyan("\n\u{1F4CB} AutomatosX Configuration\n"));
@@ -11130,7 +11796,7 @@ async function getConfig(config, key, verbose) {
     }
   }
 }
-async function setConfig(path7, config, key, value, verbose) {
+async function setConfig(path8, config, key, value, verbose) {
   let parsedValue = value;
   try {
     parsedValue = JSON.parse(value);
@@ -11149,21 +11815,21 @@ async function setConfig(path7, config, key, value, verbose) {
     console.log();
     process.exit(1);
   }
-  await saveConfigFile(path7, config);
+  await saveConfigFile(path8, config);
   printSuccess(`Configuration updated: ${key} = ${value}`);
   if (verbose) {
     console.log(chalk5.gray(`
-Config file: ${path7}`));
+Config file: ${path8}`));
     console.log(chalk5.gray("Configuration validated successfully\n"));
   }
   logger.info("Configuration updated", { key, value });
 }
-function getNestedValue(obj, path7) {
-  if (!path7 || !path7.trim()) return void 0;
-  return path7.split(".").filter(Boolean).reduce((current, key) => current?.[key], obj);
+function getNestedValue(obj, path8) {
+  if (!path8 || !path8.trim()) return void 0;
+  return path8.split(".").filter(Boolean).reduce((current, key) => current?.[key], obj);
 }
-function setNestedValue(obj, path7, value) {
-  const keys = path7.split(".");
+function setNestedValue(obj, path8, value) {
+  const keys = path8.split(".");
   const lastKey = keys.pop();
   if (!lastKey) return false;
   const target = keys.reduce((current, key) => {
@@ -13263,7 +13929,7 @@ var setupCommand = {
     let version = "11.2.6";
     try {
       const packageJson = JSON.parse(
-        await import('fs/promises').then((fs7) => fs7.readFile(join(packageRoot, "package.json"), "utf-8"))
+        await import('fs/promises').then((fs8) => fs8.readFile(join(packageRoot, "package.json"), "utf-8"))
       );
       version = packageJson.version;
     } catch {
@@ -13375,6 +14041,9 @@ var setupCommand = {
       console.log(chalk5.cyan("\u{1F504} Installing workflow templates..."));
       const workflowCount = await copyWorkflowTemplates(automatosxDir, packageRoot);
       console.log(chalk5.green(`   \u2713 ${workflowCount} workflow templates installed`));
+      console.log(chalk5.cyan("\u{1F501} Installing iterate mode configuration..."));
+      await copyIterateConfig(automatosxDir, packageRoot);
+      console.log(chalk5.green("   \u2713 Iterate mode patterns and templates installed"));
       console.log(chalk5.cyan("\u2699\uFE0F  Generating configuration..."));
       await createDefaultConfig(configPath, argv.force ?? false, version);
       createdResources.push(configPath);
@@ -13583,9 +14252,9 @@ var setupCommand = {
     }
   }
 };
-async function checkExists2(path7) {
+async function checkExists2(path8) {
   try {
-    await access$1(path7, constants.F_OK);
+    await access$1(path8, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -13606,8 +14275,12 @@ async function createDirectoryStructure(baseDir) {
     // v5.1: Session persistence
     // v5.2: Removed 'workspaces' - automatosx/PRD and automatosx/tmp created on-demand
     join(baseDir, "logs"),
-    join(baseDir, "workflows")
+    join(baseDir, "workflows"),
     // v11.0.0: Workflow templates directory
+    join(baseDir, "iterate"),
+    // v11.4.0: Iterate mode patterns and templates
+    join(baseDir, "state")
+    // v11.3.0: Mode state persistence
   ];
   for (const dir of dirs) {
     await mkdir(dir, { recursive: true, mode: 493 });
@@ -13723,6 +14396,167 @@ async function copyWorkflowTemplates(baseDir, packageRoot) {
     return 4;
   }
 }
+async function copyIterateConfig(baseDir, packageRoot) {
+  const iterateDir = join(baseDir, "iterate");
+  const examplesIterateDir = join(packageRoot, "examples/iterate");
+  try {
+    if (await checkExists2(examplesIterateDir)) {
+      const files = await readdir(examplesIterateDir);
+      for (const file of files) {
+        if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+          await copyFile(join(examplesIterateDir, file), join(iterateDir, file));
+        }
+      }
+      return;
+    }
+  } catch {
+  }
+  await createDefaultIterateConfig(iterateDir);
+}
+async function createDefaultIterateConfig(iterateDir) {
+  const patternsYaml = `# AutomatosX Iterate Mode - Pattern Library
+# Production patterns for response classification
+#
+# Classification Types:
+# - confirmation_prompt: AI asking for permission to proceed (auto-respond YES)
+# - genuine_question: AI asking for user input/decision (PAUSE)
+# - status_update: AI reporting progress (NO-OP)
+# - completion_signal: AI indicating task complete (acknowledge)
+# - blocking_request: AI needs external input (PAUSE)
+# - error_signal: AI encountered error (PAUSE for recovery)
+# - rate_limit_or_context: Provider limits hit (RETRY with different provider)
+
+version: "1.0.0"
+updatedAt: "${(/* @__PURE__ */ new Date()).toISOString()}"
+description: "Production pattern library for iterate mode classifier"
+
+patterns:
+  confirmation_prompt:
+    - pattern: "\\\\b(should I|shall I|do you want me to|would you like me to)\\\\b.*(proceed|continue|start|begin|go ahead)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\b(ready to|prepared to)\\\\b.*(proceed|continue|start|begin|implement)"
+      priority: 9
+      confidence: 0.9
+    - pattern: "\\\\b(continue|proceed|go ahead)\\\\s*\\\\?"
+      priority: 8
+      confidence: 0.85
+    - pattern: "\\\\b(is that|does that|sound)\\\\s+(okay|ok|good|correct|right)\\\\s*\\\\?"
+      priority: 7
+      confidence: 0.8
+
+  genuine_question:
+    - pattern: "\\\\b(which|what)\\\\b.*(approach|method|option|implementation|strategy|framework|library)\\\\b.*(should|would|prefer|recommend)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\b(option [A-Z]|choice \\\\d|alternative \\\\d)\\\\b"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\bwould you prefer\\\\b"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\bcould you (clarify|explain|specify|provide)\\\\b"
+      priority: 8
+      confidence: 0.85
+
+  status_update:
+    - pattern: "\\\\b(working on|implementing|creating|building|setting up|configuring)\\\\b"
+      priority: 10
+      confidence: 0.9
+    - pattern: "\\\\b(analyzing|reviewing|examining|checking|looking at)\\\\b"
+      priority: 9
+      confidence: 0.85
+    - pattern: "\\\\bI('ll| will| am going to)\\\\b.*(now|first|next|then)\\\\b"
+      priority: 8
+      confidence: 0.8
+
+  completion_signal:
+    - pattern: "\\\\b(all (tasks|items|changes|updates)|everything)\\\\s+(completed|done|finished|implemented)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\bsuccessfully (completed|implemented|created|fixed|resolved)"
+      priority: 9
+      confidence: 0.9
+    - pattern: "\\\\blet me know if (you need|there('s| is)) anything else"
+      priority: 7
+      confidence: 0.8
+
+  blocking_request:
+    - pattern: "\\\\b(API key|credentials|password|token|secret)\\\\s+(needed|required|missing)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\bplease (provide|enter|specify|supply)\\\\b.*(key|password|token|credential)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\b(need|require|waiting for)\\\\s+(your|user)\\\\s+(input|approval|confirmation|decision)"
+      priority: 10
+      confidence: 0.95
+
+  error_signal:
+    - pattern: "\\\\b(error|failed|failure|exception)\\\\s*:"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\b(cannot|can't|couldn't|unable to)\\\\s+(find|locate|access|connect|read|write)"
+      priority: 9
+      confidence: 0.9
+    - pattern: "\\\\b(test|build|compilation)\\\\s+(failed|error)"
+      priority: 9
+      confidence: 0.9
+
+  rate_limit_or_context:
+    - pattern: "\\\\brate limit\\\\s*(exceeded|reached|hit)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\bcontext (window|limit)\\\\s*(exceeded|full|reached)"
+      priority: 10
+      confidence: 0.95
+    - pattern: "\\\\btoo many requests"
+      priority: 10
+      confidence: 0.95
+`;
+  const templatesYaml = `# AutomatosX Iterate Mode - Template Library
+# Production templates for auto-response generation
+
+version: "1.0.0"
+updatedAt: "${(/* @__PURE__ */ new Date()).toISOString()}"
+description: "Production template library for iterate mode auto-responder"
+
+templates:
+  confirmation_prompt:
+    - template: "Yes, please proceed."
+      priority: 10
+      provider: null
+    - template: "Yes, continue with that approach."
+      priority: 9
+      provider: null
+    - template: "Sounds good, go ahead."
+      priority: 8
+      provider: null
+    - template: "Proceed."
+      priority: 7
+      provider: null
+    - template: "Continue."
+      priority: 7
+      provider: null
+
+  completion_signal:
+    - template: "Thank you."
+      priority: 10
+      provider: null
+    - template: "Great work."
+      priority: 9
+      provider: null
+
+  status_update: []
+  genuine_question: []
+  blocking_request: []
+  error_signal: []
+  rate_limit_or_context: []
+`;
+  await writeFile(join(iterateDir, "patterns.yaml"), patternsYaml, "utf-8");
+  await writeFile(join(iterateDir, "templates.yaml"), templatesYaml, "utf-8");
+  logger.info("Created default iterate mode configuration", { iterateDir });
+}
 async function createDefaultWorkflowTemplates(targetDir) {
   const authFlow = `# Authentication Implementation Workflow
 # Usage: ax run backend "implement user login" --workflow auth-flow
@@ -14932,11 +15766,11 @@ async function detectExpressRoutes(projectDir) {
         while ((match = routeRegex.exec(content)) !== null) {
           if (match[1] && match[2]) {
             const method = match[1].toUpperCase();
-            const path7 = match[2];
+            const path8 = match[2];
             endpoints.push({
               method,
-              path: path7,
-              group: path7.split("/")[1] || "api"
+              path: path8,
+              group: path8.split("/")[1] || "api"
             });
           }
         }
@@ -16041,12 +16875,12 @@ var listCommand = {
 };
 async function listAgents(pathResolver, format) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync26 } = await import('fs');
+  const { existsSync: existsSync27 } = await import('fs');
   const projectDir = await detectProjectRoot();
   const examplesDir = join(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync26(agentsDir)) {
+    if (existsSync27(agentsDir)) {
       const files = await readdir(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -16058,7 +16892,7 @@ async function listAgents(pathResolver, format) {
         }
       }
     }
-    if (existsSync26(examplesDir)) {
+    if (existsSync27(examplesDir)) {
       const files = await readdir(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -17930,18 +18764,18 @@ var ProviderSessionManager = class {
 };
 var providerSessionInstances = /* @__PURE__ */ new Map();
 async function getProviderSession(workspacePath) {
-  let path7;
+  let path8;
   {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      path7 = process.cwd();
+      path8 = process.cwd();
     } else {
-      path7 = await detectProjectRoot();
+      path8 = await detectProjectRoot();
     }
   }
-  if (!providerSessionInstances.has(path7)) {
-    providerSessionInstances.set(path7, new ProviderSessionManager(path7));
+  if (!providerSessionInstances.has(path8)) {
+    providerSessionInstances.set(path8, new ProviderSessionManager(path8));
   }
-  return providerSessionInstances.get(path7);
+  return providerSessionInstances.get(path8);
 }
 
 // src/core/router/router.ts
@@ -19711,6 +20545,9 @@ var MemoryManager = class _MemoryManager {
         if (!Number.isInteger(offsetValue) || offsetValue < 0) {
           throw new Error(`Invalid offset value: ${options.offset}. Must be a non-negative integer.`);
         }
+        if (!limitClause) {
+          limitClause = "LIMIT -1";
+        }
         offsetClause = `OFFSET ${offsetValue}`;
       }
       const sql = `
@@ -20056,14 +20893,21 @@ var MemoryManager = class _MemoryManager {
       this.initialized = false;
       this.entryCount = 0;
       this.statements = {};
-      const { rename: rename4 } = await import('fs/promises');
-      await rename4(tempPath, this.config.dbPath);
+      const { rename: rename6 } = await import('fs/promises');
+      await rename6(tempPath, this.config.dbPath);
       this.db = new Database2(this.config.dbPath);
       this.db.pragma("journal_mode = WAL");
       this.db.pragma(`busy_timeout = ${this.config.busyTimeout}`);
       await this.initialize();
       logger.info("Database restored successfully (atomic operation)", { srcPath: normalizePath(srcPath) });
     } catch (error) {
+      try {
+        DatabaseFactory.close(this.db);
+      } finally {
+        this.initialized = false;
+        this.entryCount = 0;
+        this.statements = {};
+      }
       throw new MemoryError(
         `Failed to restore database: ${error.message}`,
         "DATABASE_ERROR",
@@ -20614,6 +21458,10 @@ var SessionManager = class _SessionManager {
   MAX_TASKS_PER_SESSION = 1e3;
   /** UUID v4 validation regex (static for performance) */
   static UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  /** Tracks whether manager has been destroyed to prevent late saves */
+  destroyed = false;
+  /** Last persistence error (reported during flush) */
+  lastSaveError;
   /**
    * Validate session ID format (must be valid UUID v4)
    *
@@ -21208,6 +22056,7 @@ var SessionManager = class _SessionManager {
    * ```
    */
   async destroy() {
+    this.destroyed = true;
     if (this.saveTimeout) {
       clearTimeout(this.saveTimeout);
       this.saveTimeout = void 0;
@@ -21218,9 +22067,12 @@ var SessionManager = class _SessionManager {
       logger.error("Error flushing save during destroy", {
         error: error.message
       });
+      this.lastSaveError = void 0;
     }
+    const sessionCount = this.activeSessions.size;
+    this.activeSessions.clear();
     logger.debug("SessionManager destroyed", {
-      sessions: this.activeSessions.size
+      sessions: sessionCount
     });
   }
   /**
@@ -21245,11 +22097,21 @@ var SessionManager = class _SessionManager {
         this.pendingSave = void 0;
       });
       await this.pendingSave;
+      if (this.lastSaveError) {
+        const err = this.lastSaveError;
+        this.lastSaveError = void 0;
+        throw err;
+      }
       return;
     }
     if (this.pendingSave) {
       try {
         await this.pendingSave;
+        if (this.lastSaveError) {
+          const err = this.lastSaveError;
+          this.lastSaveError = void 0;
+          throw err;
+        }
       } catch (err) {
         throw err;
       }
@@ -21414,7 +22276,7 @@ var SessionManager = class _SessionManager {
    * @private
    */
   saveToFile() {
-    if (!this.persistencePath) {
+    if (!this.persistencePath || this.destroyed) {
       return;
     }
     if (this.saveTimeout) {
@@ -21427,18 +22289,18 @@ var SessionManager = class _SessionManager {
       }
       this.saveNeeded = false;
       const executeNextSave = async () => {
-        await this.doSave();
+        try {
+          await this.doSave();
+          this.lastSaveError = void 0;
+        } catch (err) {
+          this.lastSaveError = err;
+        }
         if (this.saveNeeded) {
           this.saveNeeded = false;
           return executeNextSave();
         }
       };
-      this.pendingSave = executeNextSave().catch((err) => {
-        logger.error("Debounced save failed", {
-          error: err.message
-        });
-        throw err;
-      }).finally(() => {
+      this.pendingSave = executeNextSave().finally(() => {
         this.pendingSave = void 0;
       });
     }, 100);
@@ -23759,9 +24621,9 @@ var DependencyGraphBuilder = class {
   detectCycles(graph) {
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const visit = (nodeName, path7) => {
+    const visit = (nodeName, path8) => {
       if (visiting.has(nodeName)) {
-        throw new Error(`Circular dependency detected: ${[...path7, nodeName].join(" \u2192 ")}`);
+        throw new Error(`Circular dependency detected: ${[...path8, nodeName].join(" \u2192 ")}`);
       }
       if (visited.has(nodeName)) {
         return;
@@ -23776,7 +24638,7 @@ var DependencyGraphBuilder = class {
       }
       visiting.add(nodeName);
       for (const dependency of node.dependencies) {
-        visit(dependency, [...path7, nodeName]);
+        visit(dependency, [...path8, nodeName]);
       }
       visiting.delete(nodeName);
       visited.add(nodeName);
@@ -25509,59 +26371,59 @@ var DANGEROUS_PATH_PATTERNS = [
   // Common data drive (Windows, alt format)
 ];
 var SUSPICIOUS_PATH_CHARS = /[<>:|"]/;
-function validatePathParameter(path7, paramName, projectRoot = process.cwd()) {
-  if (!path7 || path7.trim() === "") {
+function validatePathParameter(path8, paramName, projectRoot = process.cwd()) {
+  if (!path8 || path8.trim() === "") {
     throw new ValidationError(
       `Invalid ${paramName}: path cannot be empty`,
       -32602 /* InvalidParams */,
-      { path: path7, paramName }
+      { path: path8, paramName }
     );
   }
   for (const pattern of DANGEROUS_PATH_PATTERNS) {
-    if (path7.includes(pattern)) {
+    if (path8.includes(pattern)) {
       throw new ValidationError(
         `Invalid ${paramName}: path contains dangerous pattern "${pattern}"`,
         -32602 /* InvalidParams */,
-        { path: path7, paramName, pattern }
+        { path: path8, paramName, pattern }
       );
     }
   }
-  if (isAbsolute(path7)) {
+  if (isAbsolute(path8)) {
     throw new ValidationError(
       `Invalid ${paramName}: absolute paths are not allowed`,
       -32602 /* InvalidParams */,
-      { path: path7, paramName }
+      { path: path8, paramName }
     );
   }
   try {
-    const resolvedPath = resolve(projectRoot, path7);
+    const resolvedPath = resolve(projectRoot, path8);
     const normalizedRoot = resolve(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
         -32602 /* InvalidParams */,
-        { path: path7, paramName, projectRoot, resolvedPath }
+        { path: path8, paramName, projectRoot, resolvedPath }
       );
     }
   } catch (error) {
     throw new ValidationError(
       `Invalid ${paramName}: path resolution failed`,
       -32602 /* InvalidParams */,
-      { path: path7, paramName, error: String(error) }
+      { path: path8, paramName, error: String(error) }
     );
   }
-  if (path7.includes("\0")) {
+  if (path8.includes("\0")) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains null byte`,
       -32602 /* InvalidParams */,
-      { path: path7, paramName }
+      { path: path8, paramName }
     );
   }
-  if (SUSPICIOUS_PATH_CHARS.test(path7)) {
+  if (SUSPICIOUS_PATH_CHARS.test(path8)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path7, paramName }
+      { path: path8, paramName }
     );
   }
 }
@@ -26257,8 +27119,8 @@ function createMemoryExportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_export called", { input });
     try {
-      const { path: path7 } = input;
-      const absolutePath = resolveExportPath(deps.pathResolver, path7);
+      const { path: path8 } = input;
+      const absolutePath = resolveExportPath(deps.pathResolver, path8);
       const exported = await deps.memoryManager.exportToJSON(absolutePath);
       const result = {
         success: true,
@@ -26294,8 +27156,8 @@ function createMemoryImportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_import called", { input });
     try {
-      const { path: path7 } = input;
-      const absolutePath = resolveImportPath(deps.pathResolver, path7);
+      const { path: path8 } = input;
+      const absolutePath = resolveImportPath(deps.pathResolver, path8);
       const imported = await deps.memoryManager.importFromJSON(absolutePath);
       const result = {
         success: true,
@@ -26848,7 +27710,8 @@ var McpClient = class extends EventEmitter {
    * Send JSON-RPC request and wait for response
    */
   async sendRequest(method, params, timeout) {
-    if (!this.process?.stdin) {
+    const stdin = this.process?.stdin;
+    if (!stdin) {
       throw new Error("MCP client not connected");
     }
     const id = this.nextRequestId++;
@@ -26870,7 +27733,18 @@ var McpClient = class extends EventEmitter {
         timeout: timeoutHandle
       });
       const message = JSON.stringify(request) + "\n";
-      this.process.stdin.write(message);
+      try {
+        stdin.write(message);
+      } catch (error) {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(id);
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        reject(err);
+        return;
+      }
       logger.debug("[MCP Client] Sent request", {
         id,
         method,
@@ -26880,6 +27754,10 @@ var McpClient = class extends EventEmitter {
   }
   /**
    * Send JSON-RPC notification (no response expected)
+   *
+   * BUG FIX: Handle write errors gracefully. If the process has exited or the
+   * pipe is broken, write() could throw an uncaught exception that would crash
+   * the application.
    */
   sendNotification(method, params) {
     if (!this.process?.stdin) {
@@ -26891,7 +27769,14 @@ var McpClient = class extends EventEmitter {
       params
     };
     const message = JSON.stringify(notification) + "\n";
-    this.process.stdin.write(message);
+    try {
+      this.process.stdin.write(message);
+    } catch (error) {
+      logger.debug("[MCP Client] Failed to send notification (pipe may be closed)", {
+        method,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   /**
    * Handle incoming JSON-RPC message
@@ -27242,6 +28127,11 @@ var McpClientPool = class extends EventEmitter {
   }
   /**
    * Check if pool has available capacity for provider
+   *
+   * BUG FIX: Account for pendingConnections to avoid reporting capacity
+   * when concurrent connection creations are in progress. Previously,
+   * hasCapacity() could return true even when all slots were about to be
+   * filled by in-flight createConnection() calls, causing over-allocation.
    */
   hasCapacity(provider) {
     const pool = this.pools.get(provider);
@@ -27255,7 +28145,8 @@ var McpClientPool = class extends EventEmitter {
         connectedCount++;
       }
     }
-    return connectedCount < this.config.maxConnectionsPerProvider;
+    const totalAllocated = connectedCount + pool.pendingConnections;
+    return totalAllocated < this.config.maxConnectionsPerProvider;
   }
   // ============================================
   // Private Methods
@@ -27378,6 +28269,10 @@ var McpClientPool = class extends EventEmitter {
           }
         }
         for (const pooledClient of toRemove) {
+          if (pooledClient.inUse) {
+            logger.debug("[MCP Pool] Skipping idle client removal - now in use", { provider });
+            continue;
+          }
           logger.debug("[MCP Pool] Closing idle connection", {
             provider,
             idleTimeMs: now - pooledClient.lastUsed
@@ -29606,20 +30501,20 @@ var LifecycleLogger = class {
   }
   /**
    * Rotate log file if it exceeds size limit
+   *
+   * BUG FIX: Previously used dynamic imports for fs/fs.promises which are already
+   * imported at module level, causing unnecessary overhead. Also had a TOCTOU race
+   * between existsSync and statSync - now uses async stat() which handles ENOENT
+   * gracefully without the race condition.
    */
   async rotateLogIfNeeded(logPath) {
-    if (!existsSync(logPath)) {
-      return;
-    }
     try {
-      const { statSync: statSync5 } = await import('fs');
-      const stats = statSync5(logPath);
+      const stats = await stat(logPath);
       const sizeMB = stats.size / (1024 * 1024);
       if (sizeMB > this.maxLogSizeMB) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         const archivePath = logPath.replace(".jsonl", `-${timestamp}.jsonl`);
-        const { rename: rename4 } = await import('fs/promises');
-        await rename4(logPath, archivePath);
+        await rename(logPath, archivePath);
         logger.info("LifecycleLogger: Rotated log file", {
           oldPath: logPath,
           newPath: archivePath,
@@ -29627,6 +30522,9 @@ var LifecycleLogger = class {
         });
       }
     } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
       logger.error("LifecycleLogger: Failed to rotate log file", { error });
     }
   }
@@ -29655,6 +30553,8 @@ var MetricsCollector = class {
   failedRequestCounts = /* @__PURE__ */ new Map();
   responseTimes = /* @__PURE__ */ new Map();
   restartCounts = /* @__PURE__ */ new Map();
+  /** Track which servers have had their first start recorded */
+  serverStarted = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     this.enabled = options.enabled ?? true;
     this.collectionIntervalMs = options.collectionIntervalMs ?? 1e4;
@@ -29693,15 +30593,27 @@ var MetricsCollector = class {
   }
   /**
    * Record server start
+   *
+   * BUG FIX: Previously incremented restartCount on every start including the first one,
+   * so a server that never restarted would show restartCount: 1. Now correctly tracks
+   * only actual restarts (starts after the first one).
    */
   recordServerStart(serverName) {
     if (!this.enabled) return;
-    const currentRestarts = this.restartCounts.get(serverName) || 0;
-    this.restartCounts.set(serverName, currentRestarts + 1);
-    logger.debug("MetricsCollector: Recorded server start", {
-      serverName,
-      restartCount: currentRestarts + 1
-    });
+    if (this.serverStarted.has(serverName)) {
+      const currentRestarts = this.restartCounts.get(serverName) || 0;
+      this.restartCounts.set(serverName, currentRestarts + 1);
+      logger.debug("MetricsCollector: Recorded server restart", {
+        serverName,
+        restartCount: currentRestarts + 1
+      });
+    } else {
+      this.serverStarted.add(serverName);
+      this.restartCounts.set(serverName, 0);
+      logger.debug("MetricsCollector: Recorded server first start", {
+        serverName
+      });
+    }
   }
   /**
    * Record request
@@ -29834,6 +30746,7 @@ var MetricsCollector = class {
       this.failedRequestCounts.delete(serverName);
       this.responseTimes.delete(serverName);
       this.restartCounts.delete(serverName);
+      this.serverStarted.delete(serverName);
       logger.info("MetricsCollector: Cleared history for server", { serverName });
     } else {
       this.metricsHistory.clear();
@@ -29841,6 +30754,7 @@ var MetricsCollector = class {
       this.failedRequestCounts.clear();
       this.responseTimes.clear();
       this.restartCounts.clear();
+      this.serverStarted.clear();
       logger.info("MetricsCollector: Cleared all history");
     }
   }
@@ -29926,6 +30840,8 @@ var ResourceEnforcer = class {
   violationHandlers = [];
   violationTimestamps = /* @__PURE__ */ new Map();
   monitoredServers = /* @__PURE__ */ new Map();
+  /** Track throttle resume timers to prevent leaks on stop() */
+  throttleTimers = /* @__PURE__ */ new Map();
   constructor(options) {
     this.defaultLimits = options.defaultLimits;
     this.serverLimits = options.serverLimits || /* @__PURE__ */ new Map();
@@ -29952,13 +30868,20 @@ var ResourceEnforcer = class {
   }
   /**
    * Stop enforcing resource limits
+   *
+   * BUG FIX: Now also clears all pending throttle resume timers to prevent
+   * them from executing after stop() is called.
    */
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = void 0;
-      logger.info("ResourceEnforcer: Stopped enforcement");
     }
+    for (const timer of this.throttleTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.throttleTimers.clear();
+    logger.info("ResourceEnforcer: Stopped enforcement");
   }
   /**
    * Register server for monitoring
@@ -30108,19 +31031,34 @@ var ResourceEnforcer = class {
   }
   /**
    * Throttle process temporarily
+   *
+   * BUG FIX: Now tracks the resume timer so it can be cleaned up on stop().
+   * Also checks if process is still running before attempting to resume.
    */
   async throttleProcess(serverProcess) {
+    const serverName = serverProcess.config.name;
     try {
       logger.info("ResourceEnforcer: Throttling process", {
-        serverName: serverProcess.config.name,
+        serverName,
         pid: serverProcess.process.pid
       });
       serverProcess.process.kill("SIGSTOP");
-      setTimeout(() => {
+      const existingTimer = this.throttleTimers.get(serverName);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const resumeTimer = setTimeout(() => {
+        this.throttleTimers.delete(serverName);
+        if (!serverProcess.running || serverProcess.process.killed) {
+          logger.debug("ResourceEnforcer: Skipping resume - process no longer running", {
+            serverName
+          });
+          return;
+        }
         try {
           serverProcess.process.kill("SIGCONT");
           logger.info("ResourceEnforcer: Resumed process", {
-            serverName: serverProcess.config.name
+            serverName
           });
         } catch (error) {
           logger.error("ResourceEnforcer: Failed to resume process", {
@@ -30128,6 +31066,7 @@ var ResourceEnforcer = class {
           });
         }
       }, 1e3);
+      this.throttleTimers.set(serverName, resumeTimer);
     } catch (error) {
       logger.error("ResourceEnforcer: Failed to throttle process", {
         error: error.message
@@ -30890,7 +31829,7 @@ var GeminiMCPManager = class {
 };
 var defaultManager = null;
 function getDefaultGeminiMCPManager(config) {
-  if (!defaultManager || config) {
+  if (!defaultManager) {
     defaultManager = new GeminiMCPManager(
       {
         // Default empty config
@@ -31402,9 +32341,9 @@ var ProgressIndicator = class {
 // src/cli/commands/memory.ts
 var DEFAULT_DB_PATH = ".automatosx/memory/memory.db";
 function getMemoryManager(dbPath) {
-  const path7 = dbPath || DEFAULT_DB_PATH;
+  const path8 = dbPath || DEFAULT_DB_PATH;
   return new LazyMemoryManager({
-    dbPath: resolve(path7),
+    dbPath: resolve(path8),
     maxEntries: 1e5,
     autoCleanup: false,
     trackAccess: true
@@ -34405,14 +35344,14 @@ var IterateClassifier = class {
    * **Phase 1 (Week 1)**: Skeleton only (no-op)
    * **Phase 2 (Week 2)**: Full implementation with YAML loading and validation
    */
-  async loadPatterns(path7) {
-    logger.debug("Loading pattern library", { path: path7 });
-    if (!existsSync(path7)) {
-      logger.warn("Pattern library file not found", { path: path7 });
+  async loadPatterns(path8) {
+    logger.debug("Loading pattern library", { path: path8 });
+    if (!existsSync(path8)) {
+      logger.warn("Pattern library file not found", { path: path8 });
       return;
     }
     try {
-      const fileContent = await readFile(path7, "utf-8");
+      const fileContent = await readFile(path8, "utf-8");
       const parsed = load(fileContent);
       if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid pattern library format: not an object");
@@ -34455,7 +35394,7 @@ var IterateClassifier = class {
       });
     } catch (error) {
       logger.error("Failed to load pattern library", {
-        path: path7,
+        path: path8,
         error: error.message
       });
       throw error;
@@ -34612,7 +35551,8 @@ var IterateClassifier = class {
   checkProviderMarkers(message, provider) {
     const providerLower = provider.toLowerCase();
     if (providerLower.includes("claude")) {
-      if (message.includes("<THOUGHT>") || message.includes("<thinking>")) {
+      const lowerMessage = message.toLowerCase();
+      if (lowerMessage.includes("<thinking>") || lowerMessage.includes("</thinking>") || lowerMessage.includes("<thought>") || lowerMessage.includes("</thought>")) {
         return { type: "status_update", confidence: 0.85 };
       }
       if (message.includes("Let me break this") || message.includes("I'll break this")) {
@@ -34809,14 +35749,14 @@ var IterateAutoResponder = class {
    * **Phase 1 (Week 1)**: Skeleton only (no-op)
    * **Phase 3 (Week 3)**: Full implementation with YAML loading and validation
    */
-  async loadTemplates(path7) {
-    logger.debug("Loading template library", { path: path7 });
-    if (!existsSync(path7)) {
-      logger.warn("Template library file not found", { path: path7 });
+  async loadTemplates(path8) {
+    logger.debug("Loading template library", { path: path8 });
+    if (!existsSync(path8)) {
+      logger.warn("Template library file not found", { path: path8 });
       return;
     }
     try {
-      const fileContent = await readFile(path7, "utf-8");
+      const fileContent = await readFile(path8, "utf-8");
       const parsed = load(fileContent);
       if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid template library format: not an object");
@@ -34858,7 +35798,7 @@ var IterateAutoResponder = class {
       });
     } catch (error) {
       logger.error("Failed to load template library", {
-        path: path7,
+        path: path8,
         error: error.message
       });
       throw error;
@@ -35022,6 +35962,16 @@ var IterateModeController = class {
    * @param config - Iterate mode configuration
    * @param sessionManager - Session manager for state persistence (optional)
    */
+  /**
+   * Flag indicating if patterns/templates have been loaded
+   * @private
+   */
+  initialized = false;
+  /**
+   * Promise for initialization (to avoid race conditions)
+   * @private
+   */
+  initPromise;
   constructor(config, sessionManager, statusRenderer) {
     this.config = config;
     this.sessionManager = sessionManager;
@@ -35039,6 +35989,58 @@ var IterateModeController = class {
       strictness: config.classifier.strictness,
       hasStatusRenderer: !!statusRenderer
     });
+    this.initPromise = this.loadPatternsAndTemplates();
+  }
+  /**
+   * Load pattern and template libraries
+   *
+   * Automatically loads patterns.yaml and templates.yaml from the configured paths.
+   * If files don't exist, uses fallback patterns.
+   *
+   * @private
+   */
+  async loadPatternsAndTemplates() {
+    if (this.initialized) {
+      return;
+    }
+    const patternsPath = this.config.classifier.patternLibraryPath;
+    const templatesPath = patternsPath.replace("patterns.yaml", "templates.yaml");
+    if (existsSync(patternsPath)) {
+      try {
+        await this.classifier.loadPatterns(patternsPath);
+        logger.info("Loaded iterate patterns", { path: patternsPath });
+      } catch (error) {
+        logger.warn("Failed to load iterate patterns, using defaults", {
+          path: patternsPath,
+          error: error.message
+        });
+      }
+    } else {
+      logger.warn("Iterate patterns file not found, using defaults", { path: patternsPath });
+    }
+    if (existsSync(templatesPath)) {
+      try {
+        await this.responder.loadTemplates(templatesPath);
+        logger.info("Loaded iterate templates", { path: templatesPath });
+      } catch (error) {
+        logger.warn("Failed to load iterate templates, using defaults", {
+          path: templatesPath,
+          error: error.message
+        });
+      }
+    } else {
+      logger.warn("Iterate templates file not found, using defaults", { path: templatesPath });
+    }
+    this.initialized = true;
+  }
+  /**
+   * Ensure patterns and templates are loaded before use
+   * @private
+   */
+  async ensureInitialized() {
+    if (!this.initialized && this.initPromise) {
+      await this.initPromise;
+    }
   }
   /**
    * Execute agent with iterate mode enabled
@@ -35057,6 +36059,7 @@ var IterateModeController = class {
    * **Phase 3 (Week 3)**: Full implementation with orchestration loop
    */
   async executeWithIterate(context, options) {
+    await this.ensureInitialized();
     const sessionId = this.sessionManager ? (await this.sessionManager.createSession(context.task, context.agent.name)).id : randomUUID();
     this.initializeState(sessionId);
     logger.info("Iterate mode execution started", {
@@ -35159,17 +36162,16 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
    */
   async handleResponse(response) {
     const startTime = Date.now();
+    await this.ensureInitialized();
     if (!this.state) {
-      logger.warn("handleResponse called without initialized state - returning skeleton response");
-      return {
-        type: "continue",
-        reason: "Skeleton implementation - state not initialized"
-      };
+      logger.warn("handleResponse called without initialized state - initializing now");
+      this.initializeState(randomUUID());
     }
+    const state = this.state;
     logger.debug("Handling response", {
       hasContent: !!response.content,
       contentLength: response.content?.length || 0,
-      iterations: this.state.totalIterations
+      iterations: state.totalIterations
     });
     const classification = await this.classifier.classify(
       response.content || "",
@@ -35180,12 +36182,12 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
         tokenCount: response.tokensUsed?.total
       }
     );
-    this.state.classificationHistory.push(classification);
+    state.classificationHistory.push(classification);
     const maxHistorySize = this.config.classifier.contextWindowMessages * 2;
-    if (this.state.classificationHistory.length > maxHistorySize) {
-      this.state.classificationHistory = this.state.classificationHistory.slice(-maxHistorySize);
+    if (state.classificationHistory.length > maxHistorySize) {
+      state.classificationHistory = state.classificationHistory.slice(-maxHistorySize);
       logger.debug("Trimmed classification history to prevent memory leak", {
-        newSize: this.state.classificationHistory.length,
+        newSize: state.classificationHistory.length,
         maxSize: maxHistorySize
       });
     }
@@ -35229,8 +36231,18 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
         context: `Maximum iterations reached`
       };
     }
+    const safetyCheck = this.checkSafetyGuards(response.content || "");
+    if (!safetyCheck.safe && this.config.notifications.pauseOnHighRiskOperation) {
+      const dangerousOps = safetyCheck.detectedOperations.map((op) => `${op.type}: ${op.match}`).join(", ");
+      return {
+        type: "pause",
+        reason: "Dangerous operation detected",
+        pauseReason: "high_risk_operation",
+        context: `Detected: ${dangerousOps}`
+      };
+    }
     const action = this.determineAction(classification, response);
-    if (action.type === "continue" && action.response === void 0) {
+    if ((action.type === "continue" || action.type === "stop") && action.response === void 0) {
       const autoResponse = await this.responder.generateResponse(
         classification,
         {
@@ -35258,7 +36270,7 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
     this.emitEvent({
       type: "iterate.classification",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionId: this.state.sessionId,
+      sessionId: state.sessionId,
       payload: {
         classification,
         action: action.type,
@@ -35317,8 +36329,8 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
     }
     if (type === "completion_signal") {
       return {
-        type: "continue",
-        reason: "Completion signal - acknowledging",
+        type: "stop",
+        reason: "Completion signal - task finished",
         metadata: { confidence }
       };
     }
@@ -35538,9 +36550,8 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       // v8.5.8 - Deprecated, always 0 (cost tracking removed)
       classificationBreakdown: breakdown,
       avgClassificationLatencyMs: Math.round(avgLatency),
-      safetyChecks: {
+      safetyChecks: this.state.metadata.safetyChecks || {
         total: 0,
-        // TODO: Track safety checks
         allowed: 0,
         paused: 0,
         blocked: 0
@@ -35552,19 +36563,42 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
   /**
    * Emit telemetry event
    *
+   * Writes events to JSONL telemetry file for observability.
+   *
    * @param event - Telemetry event to emit
    * @private
-   *
-   * **Phase 1 (Week 1)**: Logs only
-   * **Phase 4 (Week 4)**: Full telemetry with file logging
    */
   emitEvent(event) {
-    if (this.config.telemetry.emitMetrics) {
-      logger.debug("Iterate event (skeleton)", {
-        type: event.type,
-        sessionId: event.sessionId
-      });
+    if (!this.config.telemetry.emitMetrics) {
+      return;
+    }
+    logger.debug("Iterate event", {
+      type: event.type,
+      sessionId: event.sessionId
+    });
+    const patternsPath = this.config.classifier.patternLibraryPath;
+    const iterateDir = dirname(patternsPath);
+    const baseDir = dirname(iterateDir);
+    const logDir = join(baseDir, "logs");
+    const logPath = join(logDir, `iterate-trace-${event.sessionId}.jsonl`);
+    const line = JSON.stringify(event) + "\n";
+    if (!existsSync(logDir)) {
+      try {
+        mkdirSync(logDir, { recursive: true });
+      } catch {
+      }
     }
+    appendFile(logPath, line).catch((error) => {
+      if (!this.state?.metadata.telemetryErrorLogged) {
+        logger.warn("Failed to write iterate telemetry", {
+          path: logPath,
+          error: error.message
+        });
+        if (this.state) {
+          this.state.metadata.telemetryErrorLogged = true;
+        }
+      }
+    });
   }
   /**
    * Check if time budget exceeded
@@ -35771,6 +36805,175 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       timestamp: c.timestamp
     }));
   }
+  /**
+   * Check for dangerous operations in response content
+   *
+   * Detects potentially destructive commands and operations that should
+   * pause execution for user confirmation.
+   *
+   * @param content - Response content to check
+   * @returns Safety check result with detected operations
+   */
+  checkSafetyGuards(content) {
+    if (!this.config.safety.enableDangerousOperationGuard) {
+      return { safe: true, detectedOperations: [] };
+    }
+    const detectedOperations = [];
+    const dangerousPatterns = [
+      // File deletion (HIGH risk)
+      {
+        pattern: /\brm\s+-rf\s+[\/~]/i,
+        type: "fileDelete",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\brm\s+-rf\s+\./i,
+        type: "fileDelete",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\brmdir\s+.*--ignore-fail-on-non-empty/i,
+        type: "fileDelete",
+        risk: "MEDIUM"
+      },
+      // Git force operations (HIGH risk)
+      {
+        pattern: /\bgit\s+push\s+.*--force/i,
+        type: "gitForce",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bgit\s+push\s+-f\b/i,
+        type: "gitForce",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bgit\s+reset\s+--hard/i,
+        type: "gitForce",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bgit\s+clean\s+-fd/i,
+        type: "gitForce",
+        risk: "MEDIUM"
+      },
+      // Database operations (HIGH risk)
+      {
+        pattern: /\bDROP\s+(TABLE|DATABASE|SCHEMA)\b/i,
+        type: "databaseDrop",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bTRUNCATE\s+TABLE\b/i,
+        type: "databaseTruncate",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bDELETE\s+FROM\s+\w+\s*(;|$|WHERE\s+1\s*=\s*1)/i,
+        type: "databaseDelete",
+        risk: "HIGH"
+      },
+      // Secrets/credentials in code (HIGH risk)
+      {
+        pattern: /\b(password|secret|api_key|apikey|api-key|token)\s*[=:]\s*["'][^"']{8,}["']/i,
+        type: "secretsInCode",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\b(AWS_SECRET|PRIVATE_KEY|AUTH_TOKEN)\s*[=:]/i,
+        type: "secretsInCode",
+        risk: "HIGH"
+      },
+      // Shell commands (MEDIUM risk based on config)
+      {
+        pattern: /\bsudo\s+/i,
+        type: "shellCommands",
+        risk: "MEDIUM"
+      },
+      {
+        pattern: /\bchmod\s+777\b/i,
+        type: "shellCommands",
+        risk: "MEDIUM"
+      },
+      {
+        pattern: /\bcurl\s+.*\|\s*(bash|sh)\b/i,
+        type: "shellCommands",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\bwget\s+.*\|\s*(bash|sh)\b/i,
+        type: "shellCommands",
+        risk: "HIGH"
+      },
+      // Package installation (MEDIUM risk)
+      {
+        pattern: /\bnpm\s+install\s+--global\b/i,
+        type: "packageInstall",
+        risk: "MEDIUM"
+      },
+      {
+        pattern: /\bpip\s+install\s+--user\b/i,
+        type: "packageInstall",
+        risk: "LOW"
+      },
+      // Writing outside workspace (HIGH risk)
+      {
+        pattern: /\b(write|create|save)\s+.*[\/~](etc|usr|bin|lib|opt)\//i,
+        type: "writeOutsideWorkspace",
+        risk: "HIGH"
+      },
+      {
+        pattern: /\becho\s+.*>\s*[\/~](etc|usr|bin)/i,
+        type: "writeOutsideWorkspace",
+        risk: "HIGH"
+      }
+    ];
+    for (const { pattern, type, risk } of dangerousPatterns) {
+      const match = content.match(pattern);
+      if (match) {
+        const configuredRisk = this.config.safety.dangerousOperations[type];
+        if (configuredRisk) {
+          detectedOperations.push({
+            type,
+            risk,
+            match: match[0].substring(0, 100)
+            // Truncate long matches
+          });
+        }
+      }
+    }
+    const riskTolerance = this.config.safety.riskTolerance;
+    const isSafe = detectedOperations.every((op) => {
+      if (riskTolerance === "permissive") {
+        return op.risk !== "HIGH";
+      } else if (riskTolerance === "balanced") {
+        return op.risk === "LOW";
+      } else {
+        return false;
+      }
+    });
+    if (detectedOperations.length > 0) {
+      logger.warn("Dangerous operations detected", {
+        count: detectedOperations.length,
+        operations: detectedOperations,
+        safe: isSafe,
+        riskTolerance
+      });
+      if (this.state) {
+        this.state.metadata.safetyChecks = this.state.metadata.safetyChecks || { total: 0, allowed: 0, paused: 0, blocked: 0 };
+        this.state.metadata.safetyChecks.total++;
+        if (isSafe) {
+          this.state.metadata.safetyChecks.allowed++;
+        } else {
+          this.state.metadata.safetyChecks.paused++;
+        }
+      }
+    }
+    return {
+      safe: isSafe || detectedOperations.length === 0,
+      detectedOperations
+    };
+  }
 };
 
 // src/cli/renderers/iterate-status-renderer.ts
@@ -37538,7 +38741,10 @@ Result: ${result.stages.map((s) => s.output).join("\n\n")}`;
                   writeOutsideWorkspace: "HIGH",
                   secretsInCode: "HIGH",
                   shellCommands: "MEDIUM",
-                  packageInstall: "MEDIUM"
+                  packageInstall: "MEDIUM",
+                  databaseDrop: "HIGH",
+                  databaseTruncate: "HIGH",
+                  databaseDelete: "HIGH"
                 },
                 enableTimeTracking: true,
                 enableIterationTracking: true
@@ -38670,11 +39876,11 @@ async function getCurrentVersion() {
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
     const { readFile: readFile24 } = await import('fs/promises');
-    const { dirname: dirname15, join: join50 } = await import('path');
+    const { dirname: dirname16, join: join52 } = await import('path');
     const { fileURLToPath: fileURLToPath5 } = await import('url');
     const __filename3 = fileURLToPath5(import.meta.url);
-    const __dirname4 = dirname15(__filename3);
-    const pkgPath = join50(__dirname4, "../../../package.json");
+    const __dirname4 = dirname16(__filename3);
+    const pkgPath = join52(__dirname4, "../../../package.json");
     const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
@@ -40744,8 +41950,8 @@ var ConfigManager = class {
    * @returns User configuration or empty object if not found
    */
   async readUserConfig() {
-    const path7 = getUserConfigPath();
-    return this.readConfig(path7, "user");
+    const path8 = getUserConfigPath();
+    return this.readConfig(path8, "user");
   }
   /**
    * Read project-level Gemini CLI configuration
@@ -40753,8 +41959,8 @@ var ConfigManager = class {
    * @returns Project configuration or empty object if not found
    */
   async readProjectConfig() {
-    const path7 = getProjectConfigPath();
-    return this.readConfig(path7, "project");
+    const path8 = getProjectConfigPath();
+    return this.readConfig(path8, "project");
   }
   /**
    * Read configuration from a specific path with caching
@@ -40764,7 +41970,7 @@ var ConfigManager = class {
    * @returns Configuration object
    * @private
    */
-  async readConfig(path7, scope) {
+  async readConfig(path8, scope) {
     const cached = this.cache.get(scope);
     if (cached && Date.now() - cached.timestamp < this.ttl) {
       return cached.data;
@@ -40775,13 +41981,13 @@ var ConfigManager = class {
     }
     const readOperation = (async () => {
       try {
-        const exists = await fileExists(path7);
+        const exists = await fileExists(path8);
         if (!exists) {
           const emptyConfig = {};
           this.cache.set(scope, { data: emptyConfig, timestamp: Date.now() });
           return emptyConfig;
         }
-        const config = await readJsonFile(path7);
+        const config = await readJsonFile(path8);
         this.cache.set(scope, { data: config, timestamp: Date.now() });
         return config;
       } catch (error) {
@@ -40790,8 +41996,8 @@ var ConfigManager = class {
         }
         throw new GeminiCLIError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          `Failed to read configuration from ${path7}`,
-          { path: path7, originalError: error }
+          `Failed to read configuration from ${path8}`,
+          { path: path8, originalError: error }
         );
       } finally {
         this.pendingReads.delete(scope);
@@ -41461,8 +42667,8 @@ var CommandTranslator = class {
         paths.push(getProjectCommandsPath());
       }
     }
-    for (const path7 of paths) {
-      const discovered = await this.scanDirectory(path7);
+    for (const path8 of paths) {
+      const discovered = await this.scanDirectory(path8);
       commands.push(...discovered);
     }
     return commands;
@@ -41503,8 +42709,8 @@ var CommandTranslator = class {
     const results = [];
     for (const name of commandNames) {
       try {
-        const path7 = await this.importCommand(name, outputDir, options);
-        results.push(path7);
+        const path8 = await this.importCommand(name, outputDir, options);
+        results.push(path8);
       } catch (error) {
         if (error instanceof GeminiCLIError) {
           console.error(`Failed to import ${name}: ${error.message}`);
@@ -42836,7 +44042,7 @@ var SpecSchemaValidator = class {
    * Convert Ajv error to ValidationIssue
    */
   convertAjvError(error) {
-    const path7 = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    const path8 = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
     const keyword = error.keyword;
     let message = error.message || "Validation error";
     let suggestion;
@@ -42887,7 +44093,7 @@ var SpecSchemaValidator = class {
       ruleId: `SCHEMA-${keyword.toUpperCase()}`,
       severity: "error",
       message,
-      path: path7 || void 0,
+      path: path8 || void 0,
       suggestion
     };
   }
@@ -45706,10 +46912,10 @@ async function handleReset() {
 `));
 }
 async function handleTrace(workspacePath, argv) {
-  const { existsSync: existsSync26, readFileSync: readFileSync9, watchFile } = await import('fs');
-  const { join: join50 } = await import('path');
-  const traceFile = join50(workspacePath, ".automatosx/logs/router.trace.jsonl");
-  if (!existsSync26(traceFile)) {
+  const { existsSync: existsSync27, readFileSync: readFileSync9, watchFile } = await import('fs');
+  const { join: join52 } = await import('path');
+  const traceFile = join52(workspacePath, ".automatosx/logs/router.trace.jsonl");
+  if (!existsSync27(traceFile)) {
     console.log(chalk5.yellow("\n\u26A0\uFE0F  No trace log found\n"));
     console.log(chalk5.gray(`Expected location: ${traceFile}
 `));
@@ -48617,13 +49823,13 @@ Time since last change: ${timeSinceLastChange}ms`
 init_logger();
 var flagManagerInstances = /* @__PURE__ */ new Map();
 function getFlagManager(workspacePath) {
-  const path7 = process.cwd();
-  if (!flagManagerInstances.has(path7)) {
-    const manager = new FeatureFlagManager(path7);
+  const path8 = process.cwd();
+  if (!flagManagerInstances.has(path8)) {
+    const manager = new FeatureFlagManager(path8);
     initializeFlags(manager);
-    flagManagerInstances.set(path7, manager);
+    flagManagerInstances.set(path8, manager);
   }
-  return flagManagerInstances.get(path7);
+  return flagManagerInstances.get(path8);
 }
 function initializeFlags(manager) {
   if (!manager.hasStorage()) {
@@ -48944,9 +50150,9 @@ var cliCommand = {
 // src/cli/commands/uninstall.ts
 init_esm_shims();
 init_logger();
-async function fileExists2(path7) {
+async function fileExists2(path8) {
   try {
-    await access$1(path7);
+    await access$1(path8);
     return true;
   } catch {
     return false;
@@ -49519,7 +50725,6 @@ var OrchestrationInstructionInjector = class {
   providers = /* @__PURE__ */ new Map();
   budgetManager;
   config;
-  lastInjectionTime = 0;
   constructor(config) {
     this.config = {
       ...DEFAULT_ORCHESTRATION_CONFIG,
@@ -49612,7 +50817,6 @@ var OrchestrationInstructionInjector = class {
       allocation = this.budgetManager.allocateBudget(activeInstructions);
     }
     const formattedText = this.formatInstructions(allocation.included);
-    this.lastInjectionTime = Date.now();
     const duration = Date.now() - startTime;
     logger.debug("Instruction injection complete", {
       providers: this.providers.size,
@@ -50226,7 +51430,7 @@ var SessionInstructionProvider = class {
     if (!this.config.enabled) {
       return false;
     }
-    if (!context.sessionId && !this.stateProvider) {
+    if (!context.sessionId && !this.stateProvider && !context.parentAgent) {
       return false;
     }
     const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
@@ -50238,7 +51442,7 @@ var SessionInstructionProvider = class {
   async getInstructions(context) {
     const instructions = [];
     const state = await this.getSessionState(context);
-    if (!state && !context.sessionId) {
+    if (!state && !context.sessionId && !context.parentAgent) {
       return instructions;
     }
     const content = this.formatSessionContext(context, state);
@@ -51190,7 +52394,6 @@ var AgentInstructionInjector = class {
 var OrchestrationService = class {
   config;
   injector;
-  tokenBudgetManager;
   workflowModeManager;
   agentInjector;
   todoProvider;
@@ -51204,7 +52407,6 @@ var OrchestrationService = class {
       ...serviceConfig
     };
     this.injector = new OrchestrationInstructionInjector(this.config);
-    this.tokenBudgetManager = new TokenBudgetManager(this.config.tokenBudget);
     this.workflowModeManager = new WorkflowModeManager();
     this.agentInjector = new AgentInstructionInjector({
       enabled: this.config.agentTemplates?.enabled ?? true,
@@ -51381,7 +52583,7 @@ ${content}
    * Get debug information about current orchestration state
    */
   getDebugInfo() {
-    const budgetConfig = this.tokenBudgetManager.getConfig();
+    const budgetConfig = this.injector.getBudgetManager().getConfig();
     const providers = this.injector.getProviders().map((p) => p.name);
     return {
       turnCount: this.turnCount,
@@ -51429,9 +52631,6 @@ ${content}
       sessionIntegration: updates.sessionIntegration ? { ...this.config.sessionIntegration, ...updates.sessionIntegration } : this.config.sessionIntegration,
       agentTemplates: updates.agentTemplates ? { ...this.config.agentTemplates, ...updates.agentTemplates } : this.config.agentTemplates
     };
-    if (updates.tokenBudget) {
-      this.tokenBudgetManager.updateConfig(this.config.tokenBudget);
-    }
     this.injector.updateConfig(updates);
     if (updates.todoIntegration && this.todoProvider) {
       const current = this.todoProvider.getConfig();