@defai.digital/automatosx 11.3.3 → 11.3.4

package/dist/index.js

@@ -2270,251 +2270,148 @@ function isRateLimitError(error, providerName) {
 function isLimitError(error, providerName) {
   return isQuotaError(error, providerName) || isRateLimitError(error, providerName);
 }
-var PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
+var GEMINI_PATTERNS, CLAUDE_PATTERNS, OPENAI_PATTERNS, AX_CLI_PATTERNS, PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
 var init_error_patterns = __esm({
   "src/providers/error-patterns.ts"() {
     init_esm_shims();
+    GEMINI_PATTERNS = {
+      quota: [
+        "RESOURCE_EXHAUSTED",
+        "resource_exhausted",
+        "quotaExceeded",
+        "quota exceeded",
+        "quota limit reached",
+        "daily quota exceeded",
+        "monthly quota exceeded",
+        "insufficient quota"
+      ],
+      rateLimit: [
+        "RATE_LIMIT_EXCEEDED",
+        "rate_limit_exceeded",
+        "rate limit exceeded",
+        "too many requests",
+        "requests per minute exceeded",
+        "requests per day exceeded"
+      ],
+      statusCodes: [429],
+      // Too Many Requests
+      errorCodes: [
+        "RESOURCE_EXHAUSTED",
+        "RATE_LIMIT_EXCEEDED",
+        "QUOTA_EXCEEDED"
+      ]
+    };
+    CLAUDE_PATTERNS = {
+      quota: [
+        "insufficient_quota",
+        "quota_exceeded",
+        "quota exceeded",
+        "credit limit reached",
+        "usage limit exceeded",
+        "monthly quota exceeded"
+      ],
+      rateLimit: [
+        "rate_limit_error",
+        "rate limit exceeded",
+        "overloaded_error",
+        "overloaded",
+        "too many requests",
+        "requests per minute exceeded"
+      ],
+      statusCodes: [429, 529],
+      // Too Many Requests, Overloaded
+      errorCodes: [
+        "rate_limit_error",
+        "overloaded_error",
+        "insufficient_quota"
+      ]
+    };
+    OPENAI_PATTERNS = {
+      quota: [
+        "insufficient_quota",
+        "quota_exceeded",
+        "quota exceeded",
+        "billing hard limit reached",
+        "usage limit exceeded",
+        "monthly quota exceeded",
+        "credit limit reached"
+      ],
+      rateLimit: [
+        "rate_limit_exceeded",
+        "rate limit exceeded",
+        "too_many_requests",
+        "too many requests",
+        "requests per minute exceeded",
+        "tokens per minute exceeded",
+        "rate limit reached"
+      ],
+      statusCodes: [429],
+      // Too Many Requests
+      errorCodes: [
+        "insufficient_quota",
+        "rate_limit_exceeded",
+        "quota_exceeded",
+        "billing_hard_limit_reached"
+      ]
+    };
+    AX_CLI_PATTERNS = {
+      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",
+        // 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"
+      ]
+    };
     PROVIDER_ERROR_PATTERNS = {
-      /**
-       * Google Gemini Error Patterns
-       *
-       * Gemini uses gRPC-style error codes and returns structured errors.
-       * Common quota errors include RESOURCE_EXHAUSTED and quotaExceeded.
-       */
-      gemini: {
-        quota: [
-          "RESOURCE_EXHAUSTED",
-          "resource_exhausted",
-          "quotaExceeded",
-          "quota exceeded",
-          "quota limit reached",
-          "daily quota exceeded",
-          "monthly quota exceeded",
-          "insufficient quota"
-        ],
-        rateLimit: [
-          "RATE_LIMIT_EXCEEDED",
-          "rate_limit_exceeded",
-          "rate limit exceeded",
-          "too many requests",
-          "requests per minute exceeded",
-          "requests per day exceeded"
-        ],
-        statusCodes: [429],
-        // Too Many Requests
-        errorCodes: [
-          "RESOURCE_EXHAUSTED",
-          "RATE_LIMIT_EXCEEDED",
-          "QUOTA_EXCEEDED"
-        ]
-      },
-      /**
-       * Anthropic Claude Error Patterns
-       *
-       * Claude returns different error types for rate limiting vs overload.
-       * Status 529 indicates temporary overload, 429 indicates rate limiting.
-       */
-      claude: {
-        quota: [
-          "insufficient_quota",
-          "quota_exceeded",
-          "quota exceeded",
-          "credit limit reached",
-          "usage limit exceeded",
-          "monthly quota exceeded"
-        ],
-        rateLimit: [
-          "rate_limit_error",
-          "rate limit exceeded",
-          "overloaded_error",
-          "overloaded",
-          "too many requests",
-          "requests per minute exceeded"
-        ],
-        statusCodes: [429, 529],
-        // Too Many Requests, Overloaded
-        errorCodes: [
-          "rate_limit_error",
-          "overloaded_error",
-          "insufficient_quota"
-        ]
-      },
-      /**
-       * OpenAI Error Patterns
-       *
-       * OpenAI provides detailed error messages for different types of limits.
-       * Distinguishes between quota exhaustion and rate limiting.
-       */
-      openai: {
-        quota: [
-          "insufficient_quota",
-          "quota_exceeded",
-          "quota exceeded",
-          "billing hard limit reached",
-          "usage limit exceeded",
-          "monthly quota exceeded",
-          "credit limit reached"
-        ],
-        rateLimit: [
-          "rate_limit_exceeded",
-          "rate limit exceeded",
-          "too_many_requests",
-          "too many requests",
-          "requests per minute exceeded",
-          "tokens per minute exceeded",
-          "rate limit reached"
-        ],
-        statusCodes: [429],
-        // Too Many Requests
-        errorCodes: [
-          "insufficient_quota",
-          "rate_limit_exceeded",
-          "quota_exceeded",
-          "billing_hard_limit_reached"
-        ]
-      },
-      /**
-       * Claude Code Provider (extension of Claude patterns)
-       */
-      "claude-code": {
-        quota: [
-          "insufficient_quota",
-          "quota_exceeded",
-          "quota exceeded",
-          "credit limit reached",
-          "usage limit exceeded",
-          "monthly quota exceeded"
-        ],
-        rateLimit: [
-          "rate_limit_error",
-          "rate limit exceeded",
-          "overloaded_error",
-          "overloaded",
-          "too many requests",
-          "requests per minute exceeded"
-        ],
-        statusCodes: [429, 529],
-        errorCodes: [
-          "rate_limit_error",
-          "overloaded_error",
-          "insufficient_quota"
-        ]
-      },
-      /**
-       * Gemini CLI Provider (same patterns as Gemini)
-       */
-      "gemini-cli": {
-        quota: [
-          "RESOURCE_EXHAUSTED",
-          "resource_exhausted",
-          "quotaExceeded",
-          "quota exceeded",
-          "quota limit reached",
-          "daily quota exceeded",
-          "monthly quota exceeded",
-          "insufficient quota"
-        ],
-        rateLimit: [
-          "RATE_LIMIT_EXCEEDED",
-          "rate_limit_exceeded",
-          "rate limit exceeded",
-          "too many requests",
-          "requests per minute exceeded",
-          "requests per day exceeded"
-        ],
-        statusCodes: [429],
-        errorCodes: [
-          "RESOURCE_EXHAUSTED",
-          "RATE_LIMIT_EXCEEDED",
-          "QUOTA_EXCEEDED"
-        ]
-      },
-      /**
-       * Codex CLI Provider (same patterns as OpenAI)
-       */
-      codex: {
-        quota: [
-          "insufficient_quota",
-          "quota_exceeded",
-          "quota exceeded",
-          "billing hard limit reached",
-          "usage limit exceeded",
-          "monthly quota exceeded",
-          "credit limit reached"
-        ],
-        rateLimit: [
-          "rate_limit_exceeded",
-          "rate limit exceeded",
-          "too_many_requests",
-          "too many requests",
-          "requests per minute exceeded",
-          "tokens per minute exceeded",
-          "rate limit reached"
-        ],
-        statusCodes: [429],
-        errorCodes: [
-          "insufficient_quota",
-          "rate_limit_exceeded",
-          "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"
-        ]
-      }
+      // Primary providers
+      gemini: GEMINI_PATTERNS,
+      claude: CLAUDE_PATTERNS,
+      codex: OPENAI_PATTERNS,
+      "ax-cli": AX_CLI_PATTERNS,
+      // Aliases - reference same patterns to avoid duplication
+      "gemini-cli": GEMINI_PATTERNS,
+      // Alias for gemini
+      "claude-code": CLAUDE_PATTERNS,
+      // Alias for claude
+      "openai": OPENAI_PATTERNS
+      // Alias for codex (same underlying API)
     };
     GENERIC_ERROR_PATTERNS = {
       quota: [
@@ -2897,9 +2794,14 @@ var init_base_provider = __esm({
               });
               child.kill("SIGTERM");
               forceKillTimer = setTimeout(() => {
-                if (child.pid && !child.killed) {
-                  logger.warn("Force killing child process", { pid: child.pid });
-                  child.kill("SIGKILL");
+                if (child.pid) {
+                  try {
+                    process.kill(child.pid, 0);
+                    logger.warn("Force killing child process", { pid: child.pid });
+                    child.kill("SIGKILL");
+                  } catch {
+                    logger.debug("Process already exited before SIGKILL", { pid: child.pid });
+                  }
                 }
               }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
@@ -3080,9 +2982,14 @@ var init_base_provider = __esm({
               });
               child.kill("SIGTERM");
               forceKillTimer = setTimeout(() => {
-                if (child.pid && !child.killed) {
-                  logger.warn("Force killing child process", { pid: child.pid });
-                  child.kill("SIGKILL");
+                if (child.pid) {
+                  try {
+                    process.kill(child.pid, 0);
+                    logger.warn("Force killing child process", { pid: child.pid });
+                    child.kill("SIGKILL");
+                  } catch {
+                    logger.debug("Process already exited before SIGKILL", { pid: child.pid });
+                  }
                 }
               }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
@@ -4361,12 +4268,20 @@ var init_openai_provider = __esm({
     OpenAIProvider = class extends BaseProvider {
       hybridAdapter = null;
       providerConfig;
+      /** BUG FIX: Track pending initialization to prevent race condition where
+       * concurrent execute() calls could each trigger initializeHybridAdapter() */
+      initializationPromise = null;
+      /** BUG FIX: Track destroyed state to prevent use-after-destroy race condition */
+      isDestroyed = false;
       constructor(config) {
         super(config);
         this.providerConfig = config;
         logger.debug("[OpenAI/Codex] Initialized", { mode: config.mode || "auto" });
       }
       async execute(request) {
+        if (this.isDestroyed) {
+          throw new Error("OpenAIProvider has been destroyed and cannot execute requests");
+        }
         if (process.env.AX_MOCK_PROVIDERS === "true") {
           return {
             content: this.getMockResponse(),
@@ -4377,9 +4292,7 @@ var init_openai_provider = __esm({
           };
         }
         const startTime = Date.now();
-        if (!this.hybridAdapter) {
-          this.initializeHybridAdapter();
-        }
+        await this.ensureInitialized();
         try {
           const result = await this.hybridAdapter.execute(
             request.prompt,
@@ -4404,7 +4317,30 @@ var init_openai_provider = __esm({
           throw this.handleError(error);
         }
       }
-      initializeHybridAdapter() {
+      /**
+       * BUG FIX: Ensure adapter is initialized exactly once, even with concurrent calls.
+       * Uses a promise-based lock pattern to prevent race conditions where multiple
+       * execute() calls could each trigger initializeHybridAdapter().
+       */
+      async ensureInitialized() {
+        if (this.hybridAdapter) {
+          return;
+        }
+        if (this.initializationPromise) {
+          await this.initializationPromise;
+          return;
+        }
+        this.initializationPromise = this.initializeHybridAdapter();
+        try {
+          await this.initializationPromise;
+        } finally {
+          this.initializationPromise = null;
+        }
+      }
+      async initializeHybridAdapter() {
+        if (this.hybridAdapter) {
+          return;
+        }
         const options = {
           mode: this.providerConfig.mode || "auto",
           cli: {
@@ -4442,6 +4378,7 @@ var init_openai_provider = __esm({
         this.hybridAdapter?.switchToCliMode();
       }
       async destroy() {
+        this.isDestroyed = true;
         if (this.hybridAdapter) {
           await this.hybridAdapter.destroy();
           this.hybridAdapter = null;
@@ -5088,6 +5025,8 @@ var init_subagent_adapter = __esm({
     DEFAULT_TIMEOUT_MS = 3e5;
     DEFAULT_SUBAGENT_MAX_TOOL_ROUNDS = 100;
     SubagentAdapter = class {
+      // PRODUCTION FIX: Use typed interfaces instead of 'any'
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       orchestrator = null;
       subagents = /* @__PURE__ */ new Map();
       busySubagents = /* @__PURE__ */ new Set();
@@ -5283,12 +5222,29 @@ ${task.task}` : task.task;
           });
           let content = "";
           let totalTokens = 0;
-          for await (const chunk of subagent.processUserMessageStream(prompt)) {
-            if (chunk.type === "content") {
-              content += chunk.content || "";
-            }
-            if (chunk.type === "token_count" && chunk.tokenCount) {
-              totalTokens += chunk.tokenCount;
+          const timeoutMs = this.options.timeout;
+          let timeoutTimer = null;
+          try {
+            const timeoutPromise = new Promise((_, reject) => {
+              timeoutTimer = setTimeout(() => {
+                reject(new Error(`Subagent task timed out after ${timeoutMs}ms`));
+              }, timeoutMs);
+            });
+            const streamPromise = (async () => {
+              for await (const chunk of subagent.processUserMessageStream(prompt)) {
+                if (chunk.type === "content") {
+                  content += chunk.content || "";
+                }
+                if (chunk.type === "token_count" && chunk.tokenCount) {
+                  totalTokens += chunk.tokenCount;
+                }
+              }
+            })();
+            await Promise.race([streamPromise, timeoutPromise]);
+          } finally {
+            if (timeoutTimer !== null) {
+              clearTimeout(timeoutTimer);
+              timeoutTimer = null;
             }
           }
           const latencyMs = Date.now() - startTime;
@@ -5357,7 +5313,7 @@ ${task.task}` : task.task;
           };
         } finally {
           if (release) {
-            release();
+            await release();
           }
         }
       }
@@ -5401,11 +5357,16 @@ ${task.task}` : task.task;
       }
       /**
        * Get or create a subagent for the given config
+       *
+       * PRODUCTION FIX: Return typed SDKSubagent instead of 'any'
+       * Note: We still need 'as unknown as SDKSubagent' cast since SDK types may differ,
+       * but this is safer than raw 'any' as it enforces interface compliance.
        */
       async getOrCreateSubagent(config) {
         const key = this.getSubagentKey(config);
-        if (this.subagents.has(key)) {
-          return this.subagents.get(key);
+        const cached = this.subagents.get(key);
+        if (cached) {
+          return cached;
         }
         try {
           const { createSubagent } = await import('@defai.digital/ax-cli/sdk');
@@ -5430,6 +5391,8 @@ ${task.task}` : task.task;
       }
       /**
        * Create a temporary subagent instance. Used when the cached subagent is busy.
+       *
+       * PRODUCTION FIX: Return typed SDKSubagent instead of 'any'
        */
       async createEphemeralSubagent(config) {
         const { createSubagent } = await import('@defai.digital/ax-cli/sdk');
@@ -5442,6 +5405,9 @@ ${task.task}` : task.task;
        * 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.
+       *
+       * PRODUCTION FIX (v11.3.4): Changed release() to return Promise for proper
+       * async cleanup of ephemeral subagents. Callers must await release().
        */
       async acquireSubagent(config) {
         const key = this.getSubagentKey(config);
@@ -5456,23 +5422,27 @@ ${task.task}` : task.task;
           }
           return {
             subagent,
-            release: () => this.releaseSubagent(key)
+            release: async () => this.releaseSubagent(key)
           };
         }
         logger.debug("Cached subagent busy, creating ephemeral instance", { key });
         const ephemeral = await this.createEphemeralSubagent(config);
         return {
           subagent: ephemeral,
-          release: () => {
+          // PRODUCTION FIX: Properly await async dispose to ensure cleanup completes
+          // before next task starts, preventing resource accumulation
+          release: async () => {
             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) }));
+                  await result;
                 }
               }
+              logger.debug("Ephemeral subagent disposed successfully", { key });
             } catch (error) {
               logger.warn("Error disposing ephemeral subagent", {
+                key,
                 error: error instanceof Error ? error.message : String(error)
               });
             }
@@ -5602,7 +5572,7 @@ ${task.task}` : task.task;
     };
   }
 });
-var DEFAULT_CHECKPOINT_DIR, DEFAULT_MAX_CHECKPOINTS, FLUSH_TIMEOUT_MS, CheckpointAdapter;
+var DEFAULT_CHECKPOINT_DIR, DEFAULT_MAX_CHECKPOINTS, FLUSH_TIMEOUT_MS, FLUSH_MAX_RETRIES, FLUSH_RETRY_DELAY_MS, CheckpointAdapter;
 var init_checkpoint_adapter = __esm({
   "src/integrations/ax-cli-sdk/checkpoint-adapter.ts"() {
     init_esm_shims();
@@ -5610,6 +5580,8 @@ var init_checkpoint_adapter = __esm({
     DEFAULT_CHECKPOINT_DIR = ".automatosx/checkpoints";
     DEFAULT_MAX_CHECKPOINTS = 10;
     FLUSH_TIMEOUT_MS = 5e3;
+    FLUSH_MAX_RETRIES = 3;
+    FLUSH_RETRY_DELAY_MS = 500;
     CheckpointAdapter = class {
       checkpointDir;
       sdkCheckpointManager = null;
@@ -5781,11 +5753,15 @@ var init_checkpoint_adapter = __esm({
         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", {
+          const availablePhases = workflow.phases.map((p) => p.id);
+          logger.error("Phase not found in workflow - cannot save checkpoint", {
             workflowId,
             phaseId,
-            availablePhases: workflow.phases.map((p) => p.id)
+            availablePhases
           });
+          throw new Error(
+            `Invalid phase ID '${phaseId}' for workflow '${workflowId}'. Available phases: ${availablePhases.join(", ")}`
+          );
         }
         if (!checkpoint) {
           checkpoint = {
@@ -5802,13 +5778,12 @@ var init_checkpoint_adapter = __esm({
           };
         }
         if (result.success) {
-          checkpoint.completedTasks.push(phaseId);
-          if (phaseIndex >= 0) {
-            checkpoint.phase = phaseIndex + 1;
+          if (!checkpoint.completedTasks.includes(phaseId)) {
+            checkpoint.completedTasks.push(phaseId);
           }
-          const phaseLabel = phaseIndex >= 0 ? `Phase ${phaseIndex + 1}` : "Unknown Phase";
+          checkpoint.phase = phaseIndex + 1;
           checkpoint.context += `
-[${phaseLabel}: ${phaseId}]
+[Phase ${phaseIndex + 1}: ${phaseId}]
 ${result.content.substring(0, 1e3)}
 `;
           if (result.tokensUsed && checkpoint.tokensUsed) {
@@ -5956,6 +5931,8 @@ ${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
+       * PRODUCTION FIX (v11.3.4): Add retry logic for checkpoint flush to handle
+       * transient filesystem errors (e.g., disk briefly unavailable)
        */
       async destroy() {
         if (this.autoSaveTimer) {
@@ -5963,22 +5940,44 @@ ${result.content.substring(0, 1e3)}
           this.autoSaveTimer = null;
         }
         if (this.pendingCheckpoint) {
-          try {
-            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
-            });
-          } catch (error) {
-            logger.warn("Failed to flush pending checkpoint on destroy", {
-              error: error instanceof Error ? error.message : String(error)
+          const checkpoint = this.pendingCheckpoint;
+          let lastError = null;
+          let success = false;
+          for (let attempt = 1; attempt <= FLUSH_MAX_RETRIES; attempt++) {
+            try {
+              await Promise.race([
+                this.save(checkpoint.workflowId, checkpoint),
+                new Promise(
+                  (_, reject) => setTimeout(() => reject(new Error("Checkpoint flush timed out")), FLUSH_TIMEOUT_MS)
+                )
+              ]);
+              logger.debug("Pending checkpoint flushed on destroy", {
+                workflowId: checkpoint.workflowId,
+                attempt
+              });
+              success = true;
+              break;
+            } catch (error) {
+              lastError = error instanceof Error ? error : new Error(String(error));
+              logger.warn("Checkpoint flush attempt failed", {
+                workflowId: checkpoint.workflowId,
+                attempt,
+                maxAttempts: FLUSH_MAX_RETRIES,
+                error: lastError.message
+              });
+              if (attempt < FLUSH_MAX_RETRIES) {
+                await new Promise((resolve13) => setTimeout(resolve13, FLUSH_RETRY_DELAY_MS));
+              }
+            }
+          }
+          if (!success && lastError) {
+            logger.error("Failed to flush checkpoint after all retries", {
+              workflowId: checkpoint.workflowId,
+              phase: checkpoint.phase,
+              totalPhases: checkpoint.totalPhases,
+              completedTasks: checkpoint.completedTasks.length,
+              error: lastError.message,
+              hint: "Checkpoint data may need manual recovery"
             });
           }
           this.pendingCheckpoint = null;
@@ -6225,20 +6224,39 @@ var init_instructions_bridge = __esm({
        * - Strip quotes from string values
        * - Handle empty values correctly
        */
+      /**
+       * PRODUCTION FIX (v11.3.4): Enhanced YAML parser with better edge case handling:
+       * - Handle values containing colons (e.g., "description: Function: does X")
+       * - Strip YAML comments (lines starting with # or inline # comments)
+       * - Preserve escaped quotes within values
+       * - Handle empty/null values correctly
+       */
       parseYamlProfile(content) {
         const lines = content.split("\n");
         const profile = {};
         let currentKey = "";
         let instructionsBuffer = [];
         let inInstructions = false;
-        for (const line of lines) {
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line === void 0) continue;
+          if (line.trim().startsWith("#")) {
+            continue;
+          }
           const match = line.match(/^([\w-]+):\s*(.*)$/);
           if (match) {
             const [, rawKey, rawValue] = match;
             const key = rawKey ?? "";
             let value = rawValue ?? "";
+            if (!value.startsWith('"') && !value.startsWith("'")) {
+              const commentIndex = value.search(/\s+#/);
+              if (commentIndex > 0) {
+                value = value.substring(0, commentIndex).trim();
+              }
+            }
             if (value && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
               value = value.slice(1, -1);
+              value = value.replace(/\\"/g, '"').replace(/\\'/g, "'");
             }
             const normalizedKey = key.replace(/-/g, "_");
             if (inInstructions && normalizedKey !== "instructions") {
@@ -6249,7 +6267,7 @@ var init_instructions_bridge = __esm({
             if (normalizedKey === "instructions") {
               inInstructions = true;
               currentKey = normalizedKey;
-              if (value && value.startsWith("|")) ; else if (value) {
+              if (value && (value.startsWith("|") || value.startsWith(">"))) ; else if (value) {
                 profile.instructions = value;
                 inInstructions = false;
               }
@@ -6257,14 +6275,23 @@ var init_instructions_bridge = __esm({
               profile.expertise = [];
               currentKey = normalizedKey;
             } else if (normalizedKey && value !== void 0) {
-              profile[normalizedKey] = value;
+              if (value === "null" || value === "~" || value === "") {
+                profile[normalizedKey] = "";
+              } else {
+                profile[normalizedKey] = value;
+              }
               currentKey = normalizedKey;
             }
           } else if (inInstructions) {
-            instructionsBuffer.push(line.replace(/^  /, ""));
+            const trimmedLine = line.replace(/^  /, "");
+            instructionsBuffer.push(trimmedLine);
           } else if (currentKey === "expertise" && line.trim().startsWith("- ")) {
+            let listValue = line.trim().substring(2);
+            if (listValue.startsWith('"') && listValue.endsWith('"') || listValue.startsWith("'") && listValue.endsWith("'")) {
+              listValue = listValue.slice(1, -1);
+            }
             profile.expertise = profile.expertise ?? [];
-            profile.expertise.push(line.trim().substring(2));
+            profile.expertise.push(listValue);
           }
         }
         if (inInstructions && instructionsBuffer.length > 0) {
@@ -6643,7 +6670,7 @@ var init_mcp_manager = __esm({
       async addFromTemplate(templateName, env) {
         const configResult = await this.generateConfigFromTemplate(templateName, env);
         if (!configResult.ok) {
-          return configResult;
+          return { ok: false, error: configResult.error };
         }
         return this.addServer(templateName, configResult.value);
       }
@@ -6653,7 +6680,7 @@ var init_mcp_manager = __esm({
       async listServers() {
         const configResult = await this.loadConfig();
         if (!configResult.ok) {
-          return configResult;
+          return { ok: false, error: configResult.error };
         }
         return { ok: true, value: Object.keys(configResult.value) };
       }
@@ -6706,10 +6733,13 @@ var init_mcp_manager = __esm({
           const { MCPManagerV2 } = this.mcpModule;
           if (MCPManagerV2?.getAllServerStatuses) {
             const statuses = MCPManagerV2.getAllServerStatuses();
-            for (const status of statuses) {
-              this.serverStatuses.set(status.name, status);
+            if (statuses && Array.isArray(statuses)) {
+              for (const status of statuses) {
+                this.serverStatuses.set(status.name, status);
+              }
+              return { ok: true, value: statuses };
             }
-            return { ok: true, value: statuses };
+            return { ok: true, value: [] };
           }
           return { ok: true, value: Array.from(this.serverStatuses.values()) };
         } catch (error) {
@@ -6876,7 +6906,7 @@ var init_mcp_manager = __esm({
             logger.warn("Cannot enumerate servers for shutdown", {
               error: serversResult.error.message
             });
-            return serversResult;
+            return { ok: false, error: serversResult.error };
           }
           const errors = [];
           for (const name of serversResult.value) {
@@ -6920,8 +6950,8 @@ var init_adapter2 = __esm({
     init_mcp_manager();
     DEFAULT_MAX_TOOL_ROUNDS = 400;
     AxCliSdkAdapter = class _AxCliSdkAdapter {
+      // PRODUCTION FIX: Use typed SDKAgent interface instead of 'any'
       agent = null;
-      // Will type as LLMAgent after import
       agentConfig = null;
       initPromise = null;
       executionLock = Promise.resolve();
@@ -7181,8 +7211,11 @@ var init_adapter2 = __esm({
             userWantsCallbacks: !!(options.onStream || options.onTool),
             note: "SDK handles custom instructions and project memory"
           });
-          const chatHistory = typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : null;
+          const chatHistory = this.agent && typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : null;
           const historyLengthBefore = Array.isArray(chatHistory) ? chatHistory.length : 0;
+          if (!this.agent) {
+            throw new Error("Agent not initialized");
+          }
           for await (const chunk of this.agent.processUserMessageStream(prompt)) {
             if (chunk.type === "token_count" && chunk.tokenCount) {
               totalTokens += chunk.tokenCount;
@@ -7219,7 +7252,7 @@ var init_adapter2 = __esm({
               }
             }
           }
-          const fullHistory = typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : [];
+          const fullHistory = this.agent && typeof this.agent.getChatHistory === "function" ? this.agent.getChatHistory() : [];
           const result = Array.isArray(fullHistory) ? fullHistory.slice(historyLengthBefore) : [];
           logger.debug("Chat history extraction", {
             historyLengthBefore,
@@ -7408,7 +7441,7 @@ var init_adapter2 = __esm({
           });
           this.agent.on("error", (error) => {
             logger.error("Agent error event", {
-              error: error.message
+              error: error instanceof Error ? error.message : String(error)
             });
           });
         } catch (error) {
@@ -7499,7 +7532,7 @@ var init_adapter2 = __esm({
           );
           return {
             content: content2,
-            model: this.agent?.getCurrentModel() ?? "unknown",
+            model: this.agent?.getCurrentModel?.() ?? "unknown",
             tokensUsed: tokensUsed2,
             latencyMs,
             finishReason: "stop",
@@ -7516,7 +7549,7 @@ var init_adapter2 = __esm({
         );
         return {
           content,
-          model: this.agent?.getCurrentModel() ?? "unknown",
+          model: this.agent?.getCurrentModel?.() ?? "unknown",
           tokensUsed,
           latencyMs,
           finishReason: "stop",
@@ -7663,9 +7696,11 @@ var init_adapter2 = __esm({
         this.initError = null;
         if (!this.agent) return;
         try {
-          const result = this.agent.dispose();
-          if (result instanceof Promise) {
-            await result;
+          if (this.agent.dispose) {
+            const result = this.agent.dispose();
+            if (result instanceof Promise) {
+              await result;
+            }
           }
         } catch (error) {
           logger.warn("Error during agent cleanup", {
@@ -7695,6 +7730,9 @@ var init_hybrid_adapter2 = __esm({
       sdkAdapter = null;
       cliAdapter = null;
       sdkOptions;
+      // BUG FIX (v11.3.4): Track pending initialization to prevent race condition
+      // where concurrent execute() calls could both try to initialize adapters
+      initPromise = null;
       constructor(options = {}) {
         this.mode = options.mode || "auto";
         this.sdkOptions = options.sdk;
@@ -7771,11 +7809,30 @@ var init_hybrid_adapter2 = __esm({
       }
       /**
        * Ensure adapters are initialized based on mode
+       *
+       * BUG FIX (v11.3.4): Use initPromise to prevent race condition where
+       * concurrent execute() calls could both attempt initialization before
+       * activeMode is set. Now subsequent callers wait for the first init.
        */
       async ensureAdapters() {
         if (this.activeMode !== null) {
           return;
         }
+        if (this.initPromise) {
+          await this.initPromise;
+          return;
+        }
+        this.initPromise = this.doInitializeAdapters();
+        try {
+          await this.initPromise;
+        } finally {
+          this.initPromise = null;
+        }
+      }
+      /**
+       * Perform actual adapter initialization (called only once via ensureAdapters)
+       */
+      async doInitializeAdapters() {
         if (this.mode === "sdk") {
           await this.initializeSdk(true);
           this.activeMode = "sdk";
@@ -27519,13 +27576,17 @@ init_logger();
 // src/providers/mcp/mcp-client.ts
 init_esm_shims();
 init_logger();
-var McpClient = class extends EventEmitter {
+var McpClient = class _McpClient extends EventEmitter {
   config;
   process = null;
   readline = null;
   state;
   pendingRequests = /* @__PURE__ */ new Map();
   nextRequestId = 1;
+  /** BUG FIX: Maximum request ID before wraparound to prevent Number precision loss.
+   * JavaScript loses integer precision after Number.MAX_SAFE_INTEGER (2^53 - 1).
+   * Using 1 billion as a safe wraparound point - still unique within any realistic session. */
+  static MAX_REQUEST_ID = 1e9;
   serverInfo = null;
   constructor(config) {
     super();
@@ -27715,6 +27776,9 @@ var McpClient = class extends EventEmitter {
       throw new Error("MCP client not connected");
     }
     const id = this.nextRequestId++;
+    if (this.nextRequestId > _McpClient.MAX_REQUEST_ID) {
+      this.nextRequestId = 1;
+    }
     const request = {
       jsonrpc: "2.0",
       id,
@@ -28045,10 +28109,13 @@ var McpClientPool = class extends EventEmitter {
       } else {
         this.removeFromPool(pool, pooledClient);
         this.emitEvent("connection_closed", provider, { reason: "connection_died" });
+        pool.pendingConnections++;
         this.createConnection(provider).then((newClient) => {
           pool.clients.push(this.createPooledClient(newClient));
           waiter.resolve(newClient);
-        }).catch(waiter.reject);
+        }).catch(waiter.reject).finally(() => {
+          pool.pendingConnections--;
+        });
       }
     }
   }
@@ -35226,7 +35293,7 @@ var IterateError = class extends Error {
 // src/core/iterate/iterate-classifier.ts
 init_esm_shims();
 init_logger();
-var IterateClassifier = class {
+var IterateClassifier = class _IterateClassifier {
   config;
   patterns;
   /**
@@ -35307,7 +35374,7 @@ var IterateClassifier = class {
               reason = "Semantic similarity";
             } else {
               result = { type: "status_update", confidence: 0.3 };
-              method = "semantic_scoring";
+              method = "fallback";
               reason = "No matches found, using default";
             }
           }
@@ -35322,7 +35389,10 @@ var IterateClassifier = class {
       reason,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       context: {
-        latencyMs: latency
+        latencyMs: latency,
+        // Store the original message for context window lookups
+        // This is used by getRecentMessages() in the controller
+        message
       }
     };
     logger.info("Classification complete", {
@@ -35453,19 +35523,25 @@ var IterateClassifier = class {
    * **Phase 1 (Week 1)**: Skeleton only
    * **Phase 2 (Week 2)**: Full pattern matching implementation
    */
+  /**
+   * Default priority order for classification types
+   * genuine_question has highest priority to avoid false auto-responses
+   * @private
+   */
+  static DEFAULT_PRIORITY_ORDER = [
+    "genuine_question",
+    "blocking_request",
+    "rate_limit_or_context",
+    "error_signal",
+    "completion_signal",
+    "confirmation_prompt",
+    "status_update"
+  ];
   classifyWithPatterns(message) {
     if (!this.patterns || this.compiledPatterns.size === 0) {
       return null;
     }
-    const priorityOrder = [
-      "genuine_question",
-      "blocking_request",
-      "rate_limit_or_context",
-      "error_signal",
-      "completion_signal",
-      "confirmation_prompt",
-      "status_update"
-    ];
+    const priorityOrder = this.config.classificationPriorityOrder ?? _IterateClassifier.DEFAULT_PRIORITY_ORDER;
     for (const type of priorityOrder) {
       const patterns = this.compiledPatterns.get(type);
       if (!patterns || patterns.length === 0) {
@@ -35595,28 +35671,71 @@ var IterateClassifier = class {
     };
   }
   /**
-   * Compile regex pattern from string
+   * Pattern validation errors collected during loading
+   * @private
+   */
+  patternValidationErrors = [];
+  /**
+   * Compile regex pattern from string with validation
    *
    * @param patternStr - Pattern string
-   * @returns Compiled RegExp
+   * @param classificationType - Type this pattern belongs to (for error reporting)
+   * @returns Compiled RegExp, or null if invalid
    * @private
    */
-  compilePattern(patternStr) {
+  compilePattern(patternStr, classificationType) {
+    if (!patternStr || patternStr.trim() === "") {
+      const errorMsg = "Pattern is empty or whitespace-only";
+      logger.warn("Invalid pattern: empty", {
+        type: classificationType,
+        error: errorMsg
+      });
+      this.patternValidationErrors.push({
+        pattern: patternStr || "(empty)",
+        type: classificationType || "unknown",
+        error: errorMsg
+      });
+      return null;
+    }
     try {
       return new RegExp(patternStr, "i");
     } catch (error) {
-      logger.warn("Failed to compile pattern", {
-        pattern: patternStr,
-        error: error.message
+      const errorMsg = error.message;
+      logger.warn("Failed to compile pattern - invalid regex syntax", {
+        pattern: patternStr.substring(0, 100),
+        type: classificationType,
+        error: errorMsg
       });
-      return /(?!)/;
+      this.patternValidationErrors.push({
+        pattern: patternStr.substring(0, 100),
+        type: classificationType || "unknown",
+        error: errorMsg
+      });
+      return null;
     }
   }
+  /**
+   * Get pattern validation errors from last load operation
+   *
+   * @returns Array of validation errors with pattern, type, and error message
+   */
+  getPatternValidationErrors() {
+    return [...this.patternValidationErrors];
+  }
+  /**
+   * Check if there are any pattern validation errors
+   *
+   * @returns True if there are validation errors
+   */
+  hasPatternValidationErrors() {
+    return this.patternValidationErrors.length > 0;
+  }
   /**
    * Compile all patterns from pattern library
    *
    * Compiles regex patterns and caches them for fast matching.
    * Patterns are sorted by priority (higher priority first).
+   * Invalid patterns are tracked in patternValidationErrors for reporting.
    *
    * @private
    */
@@ -35625,22 +35744,45 @@ var IterateClassifier = class {
       return;
     }
     this.compiledPatterns.clear();
+    this.patternValidationErrors = [];
     let totalCompiled = 0;
+    let totalFailed = 0;
     for (const [type, patterns] of Object.entries(this.patterns.patterns)) {
       const classificationType = type;
       if (!Array.isArray(patterns) || patterns.length === 0) {
         continue;
       }
-      const compiled = patterns.map((p) => this.compilePattern(p.pattern)).filter((regex) => regex.source !== "(?!)");
+      const compiled = [];
+      for (const p of patterns) {
+        const regex = this.compilePattern(p.pattern, classificationType);
+        if (regex !== null) {
+          compiled.push(regex);
+          totalCompiled++;
+        } else {
+          totalFailed++;
+        }
+      }
       if (compiled.length > 0) {
         this.compiledPatterns.set(classificationType, compiled);
-        totalCompiled += compiled.length;
       }
     }
-    logger.debug("Patterns compiled", {
-      types: this.compiledPatterns.size,
-      totalPatterns: totalCompiled
-    });
+    if (totalFailed > 0) {
+      logger.warn("Pattern compilation completed with errors", {
+        types: this.compiledPatterns.size,
+        totalCompiled,
+        totalFailed,
+        errors: this.patternValidationErrors.map((e) => ({
+          type: e.type,
+          pattern: e.pattern.substring(0, 50),
+          error: e.error
+        }))
+      });
+    } else {
+      logger.debug("Patterns compiled successfully", {
+        types: this.compiledPatterns.size,
+        totalPatterns: totalCompiled
+      });
+    }
   }
 };
 
@@ -36051,14 +36193,22 @@ var IterateModeController = class {
    * - Safety checks
    * - Budget monitoring
    *
+   * **Orchestration Flow**:
+   * 1. Initialize state and check initial budgets
+   * 2. Execute agent via provider with hooks installed
+   * 3. When response received, classify and determine action
+   * 4. If 'continue': send auto-response and loop
+   * 5. If 'pause'/'stop': return control to caller
+   *
    * @param context - Execution context
    * @param options - Execution options
+   * @param executor - Optional agent executor for actual execution (injected for testability)
    * @returns Execution result with iterate stats
    *
-   * **Phase 1 (Week 1)**: Skeleton implementation (no-op, falls back to standard execution)
-   * **Phase 3 (Week 3)**: Full implementation with orchestration loop
+   * @since v6.4.0 - Initial skeleton
+   * @since v11.3.4 - Full implementation with orchestration loop
    */
-  async executeWithIterate(context, options) {
+  async executeWithIterate(context, options, executor) {
     await this.ensureInitialized();
     const sessionId = this.sessionManager ? (await this.sessionManager.createSession(context.task, context.agent.name)).id : randomUUID();
     this.initializeState(sessionId);
@@ -36083,29 +36233,125 @@ var IterateModeController = class {
         }
       }
     });
+    const responseContents = [];
+    let totalTokensUsed = { prompt: 0, completion: 0, total: 0 };
+    let lastResponse;
     try {
       if (this.checkTimeBudget()) {
         throw new IterateError("Time budget exceeded before execution", "budget_exceeded");
       }
-      if (this.checkTokenBudget()) {
-        throw new IterateError("Token budget exceeded before execution", "budget_exceeded");
+      let currentTask = context.task;
+      let shouldContinue = true;
+      while (shouldContinue) {
+        const iterationContext = {
+          ...context,
+          task: currentTask
+        };
+        let result2;
+        let action;
+        if (executor) {
+          let capturedAction;
+          const iterateOptions = {
+            ...options,
+            iterateMode: true,
+            hooks: {
+              ...options.hooks,
+              onPostResponse: async (response) => {
+                const responseAction = await this.handleResponse(response);
+                capturedAction = responseAction;
+                return responseAction;
+              }
+            }
+          };
+          result2 = await executor.execute(iterationContext, iterateOptions);
+          action = capturedAction || { type: "stop", reason: "No action from executor" };
+        } else {
+          const startTime = Date.now();
+          const response = await context.provider.execute({
+            prompt: currentTask,
+            systemPrompt: context.agent.systemPrompt,
+            model: context.agent.model,
+            temperature: context.agent.temperature,
+            maxTokens: context.agent.maxTokens,
+            signal: options.signal
+          });
+          action = await this.handleResponse(response);
+          result2 = {
+            response,
+            duration: Date.now() - startTime,
+            context: iterationContext
+          };
+        }
+        lastResponse = result2.response;
+        if (result2.response.content) {
+          responseContents.push(result2.response.content);
+        }
+        if (result2.response.tokensUsed) {
+          totalTokensUsed.prompt += result2.response.tokensUsed.prompt || 0;
+          totalTokensUsed.completion += result2.response.tokensUsed.completion || 0;
+          totalTokensUsed.total += result2.response.tokensUsed.total || 0;
+        }
+        logger.debug("Iterate loop action", {
+          actionType: action.type,
+          reason: action.reason,
+          hasAutoResponse: !!action.response
+        });
+        switch (action.type) {
+          case "continue":
+            if (action.response) {
+              currentTask = action.response;
+              this.emitEvent({
+                type: "iterate.auto_response",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                sessionId,
+                payload: {
+                  response: action.response,
+                  iteration: this.state?.totalIterations || 0
+                }
+              });
+            } else {
+              shouldContinue = false;
+            }
+            break;
+          case "stop":
+            shouldContinue = false;
+            this.emitEvent({
+              type: "iterate.stop",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              sessionId,
+              payload: {
+                reason: action.reason,
+                stats: this.getStats()
+              }
+            });
+            break;
+          case "pause":
+            shouldContinue = false;
+            await this.pause(action.pauseReason || "user_interrupt", action.context);
+            break;
+          case "retry":
+            logger.info("Retry requested, continuing with same task");
+            break;
+          case "no_op":
+            shouldContinue = false;
+            break;
+          default:
+            logger.warn("Unknown action type, stopping iterate loop", { actionType: action.type });
+            shouldContinue = false;
+        }
       }
       const duration = Date.now() - new Date(this.state.startedAt).getTime();
+      const stats = this.getStats();
+      if (this.statusRenderer) {
+        this.statusRenderer.renderSummary(stats);
+      }
       const result = {
         response: {
-          content: `Iterate mode framework initialized for: ${context.task}
-
-Session ID: ${sessionId}
-State: ${JSON.stringify(this.getStats(), null, 2)}
-
-Note: Full execution loop will be implemented in future phases`,
-          tokensUsed: {
-            prompt: 0,
-            completion: 0,
-            total: 0
-          },
+          content: responseContents.join("\n\n---\n\n") || "Iterate mode completed with no output",
+          tokensUsed: totalTokensUsed,
           latencyMs: duration,
-          model: context.agent.name,
+          model: lastResponse?.model || context.agent.model || "unknown",
+          // 'stop' is standard LLM finish reason for both normal completion and pauses
           finishReason: "stop"
         },
         duration,
@@ -36114,30 +36360,40 @@ Note: Full execution loop will be implemented in future phases`,
       logger.info("Iterate mode execution completed", {
         sessionId,
         duration: result.duration,
-        stats: this.getStats()
+        iterations: stats.totalIterations,
+        autoResponses: stats.totalAutoResponses,
+        tokens: stats.totalTokens,
+        stopReason: stats.stopReason
       });
       return result;
     } catch (error) {
       const duration = this.state ? Date.now() - new Date(this.state.startedAt).getTime() : 0;
+      const stats = this.getStats();
       logger.error("Iterate mode execution failed", {
         sessionId,
         error: error.message,
-        duration
+        duration,
+        stats
+      });
+      this.emitEvent({
+        type: "iterate.error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        payload: {
+          error: error.message,
+          stats
+        }
       });
       return {
         response: {
-          content: `Iterate mode execution failed: ${error.message}
-
-Session ID: ${sessionId}
-Error: ${error.message}${this.state ? `
-State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
-          tokensUsed: {
-            prompt: 0,
-            completion: 0,
-            total: 0
-          },
+          content: responseContents.length > 0 ? responseContents.join("\n\n---\n\n") + `
+
+---
+
+Iterate mode error: ${error.message}` : `Iterate mode execution failed: ${error.message}`,
+          tokensUsed: totalTokensUsed,
           latencyMs: duration,
-          model: context.agent.name,
+          model: lastResponse?.model || context.agent.model || "unknown",
           finishReason: "error"
         },
         duration,
@@ -36203,16 +36459,12 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
         response
       });
     }
-    if (response.tokensUsed && response.tokensUsed.total) {
-      this.updateTokens(response.tokensUsed.total);
-    }
-    this.incrementIterations();
-    if (this.checkTokenBudget()) {
+    if (this.checkIterationLimit()) {
       return {
         type: "pause",
-        reason: "Token budget exceeded",
-        pauseReason: "token_limit_exceeded",
-        context: `Maximum token limit of ${this.config.defaults.maxTotalTokens} reached`
+        reason: "Iteration limit exceeded",
+        pauseReason: "iteration_limit_exceeded",
+        context: `Maximum iterations reached`
       };
     }
     if (this.checkTimeBudget()) {
@@ -36223,14 +36475,19 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
         context: `Maximum duration of ${this.config.defaults.maxDurationMinutes} minutes reached`
       };
     }
-    if (this.checkIterationLimit()) {
+    const newTokens = response.tokensUsed?.total || 0;
+    if (this.wouldExceedTokenBudget(newTokens)) {
       return {
         type: "pause",
-        reason: "Iteration limit exceeded",
-        pauseReason: "iteration_limit_exceeded",
-        context: `Maximum iterations reached`
+        reason: "Token budget exceeded",
+        pauseReason: "token_limit_exceeded",
+        context: `Maximum token limit of ${this.config.defaults.maxTotalTokens} reached`
       };
     }
+    if (newTokens > 0) {
+      this.updateTokens(newTokens);
+    }
+    this.incrementIterations();
     const safetyCheck = this.checkSafetyGuards(response.content || "");
     if (!safetyCheck.safe && this.config.notifications.pauseOnHighRiskOperation) {
       const dangerousOps = safetyCheck.detectedOperations.map((op) => `${op.type}: ${op.match}`).join(", ");
@@ -36243,6 +36500,18 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
     }
     const action = this.determineAction(classification, response);
     if ((action.type === "continue" || action.type === "stop") && action.response === void 0) {
+      if (this.state && this.state.currentStageAutoResponses >= this.config.defaults.maxAutoResponsesPerStage) {
+        logger.warn("Auto-response limit reached, pausing instead of auto-responding", {
+          currentStageAutoResponses: this.state.currentStageAutoResponses,
+          limit: this.config.defaults.maxAutoResponsesPerStage
+        });
+        return {
+          type: "pause",
+          reason: "Auto-response limit exceeded",
+          pauseReason: "auto_response_limit_exceeded",
+          context: `Maximum auto-responses per stage (${this.config.defaults.maxAutoResponsesPerStage}) reached`
+        };
+      }
       const autoResponse = await this.responder.generateResponse(
         classification,
         {
@@ -36524,14 +36793,31 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
     const userInterventions = breakdown.genuine_question + breakdown.blocking_request;
     let stopReason = "completion";
     if (this.state.pauseReason) {
-      if (this.state.pauseReason === "time_limit_exceeded") {
-        stopReason = "timeout";
-      } else if (this.state.pauseReason === "token_limit_exceeded") {
-        stopReason = "token_limit";
-      } else if (this.state.pauseReason === "user_interrupt") {
-        stopReason = "user_interrupt";
-      } else if (this.state.pauseReason === "error_recovery_needed") {
-        stopReason = "error";
+      switch (this.state.pauseReason) {
+        case "time_limit_exceeded":
+          stopReason = "timeout";
+          break;
+        case "token_limit_exceeded":
+          stopReason = "token_limit";
+          break;
+        case "iteration_limit_exceeded":
+        case "auto_response_limit_exceeded":
+          stopReason = "iteration_limit";
+          break;
+        case "user_interrupt":
+        case "genuine_question":
+        case "blocking_request":
+          stopReason = "user_interrupt";
+          break;
+        case "high_risk_operation":
+          stopReason = "safety_paused";
+          break;
+        case "error_recovery_needed":
+          stopReason = "error";
+          break;
+        default:
+          logger.warn("Unknown pauseReason in getStats", { pauseReason: this.state.pauseReason });
+          stopReason = "completion";
       }
     }
     const errorCount = breakdown.error_signal;
@@ -36625,50 +36911,86 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       return true;
     }
     const percentElapsed = elapsedMinutes / maxMinutes * 100;
+    if (!this.state.metadata.emittedTimeWarnings) {
+      this.state.metadata.emittedTimeWarnings = [];
+    }
+    const emittedTimeWarnings = this.state.metadata.emittedTimeWarnings;
     for (const threshold of this.config.notifications.warnAtTimePercent) {
-      if (percentElapsed >= threshold && percentElapsed < threshold + 1) {
+      if (percentElapsed >= threshold && !emittedTimeWarnings.includes(threshold)) {
         logger.warn(`Time budget at ${threshold}% of limit`, {
           elapsedMinutes: Math.round(elapsedMinutes),
           maxMinutes,
           percentUsed: Math.round(percentElapsed)
         });
+        emittedTimeWarnings.push(threshold);
+        this.state.lastWarningThreshold = {
+          type: "time",
+          percent: threshold,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
       }
     }
     return false;
   }
   /**
-   * Check if token budget exceeded
+   * Check if adding new tokens would exceed the token budget
    *
-   * @returns True if token budget exceeded
+   * @param newTokens - Number of new tokens to add
+   * @returns True if adding these tokens would exceed the budget
    * @private
-   * @since v8.6.0
+   * @since v11.3.4
    *
-   * More reliable than cost checking as token counts don't change
+   * This is a pre-check to prevent exceeding the budget (check BEFORE adding)
    */
-  checkTokenBudget() {
+  wouldExceedTokenBudget(newTokens) {
     if (!this.state) return false;
     const maxTotalTokens = this.config.defaults.maxTotalTokens;
     if (!maxTotalTokens) {
       return false;
     }
     const currentTokens = this.state.totalTokens;
-    if (currentTokens >= maxTotalTokens) {
-      logger.warn("Token budget exceeded", {
+    const projectedTokens = currentTokens + newTokens;
+    if (projectedTokens > maxTotalTokens) {
+      logger.warn("Token budget would be exceeded", {
         currentTokens,
+        newTokens,
+        projectedTokens,
         maxTotalTokens,
         sessionId: this.state.sessionId
       });
       return true;
     }
+    return false;
+  }
+  /**
+   * Check token budget warnings (called after tokens are added)
+   *
+   * @private
+   * @since v8.6.0
+   *
+   * Emits warnings at configured thresholds (default: 75%, 90%)
+   */
+  checkTokenBudgetWarnings() {
+    if (!this.state) return;
+    const maxTotalTokens = this.config.defaults.maxTotalTokens;
+    if (!maxTotalTokens) {
+      return;
+    }
+    const currentTokens = this.state.totalTokens;
     const percentUsed = currentTokens / maxTotalTokens * 100;
     const warnThresholds = this.config.defaults.warnAtTokenPercent || [75, 90];
+    if (!this.state.metadata.emittedTokenWarnings) {
+      this.state.metadata.emittedTokenWarnings = [];
+    }
+    const emittedTokenWarnings = this.state.metadata.emittedTokenWarnings;
     for (const threshold of warnThresholds) {
-      if (percentUsed >= threshold && percentUsed < threshold + 1) {
+      if (percentUsed >= threshold && !emittedTokenWarnings.includes(threshold)) {
         logger.warn(`Token budget at ${threshold}% of limit`, {
           currentTokens,
           maxTotalTokens,
           percentUsed: percentUsed.toFixed(1)
         });
+        emittedTokenWarnings.push(threshold);
         this.state.lastWarningThreshold = {
           type: "tokens",
           percent: threshold,
@@ -36676,7 +36998,6 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
         };
       }
     }
-    return false;
   }
   /**
    * Check if iteration limit exceeded
@@ -36705,13 +37026,6 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       });
       return true;
     }
-    if (this.state.currentStageAutoResponses >= this.config.defaults.maxAutoResponsesPerStage) {
-      logger.warn("Auto-response limit exceeded", {
-        currentStageAutoResponses: this.state.currentStageAutoResponses,
-        limit: this.config.defaults.maxAutoResponsesPerStage
-      });
-      return true;
-    }
     return false;
   }
   /**
@@ -36787,6 +37101,7 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       currentStageTokens: this.state.currentStageTokens,
       maxTotalTokens: this.config.defaults.maxTotalTokens
     });
+    this.checkTokenBudgetWarnings();
   }
   /**
    * Get recent messages from classification history
@@ -36947,9 +37262,9 @@ State: ${JSON.stringify(this.getStats(), null, 2)}` : ""}`,
       if (riskTolerance === "permissive") {
         return op.risk !== "HIGH";
       } else if (riskTolerance === "balanced") {
-        return op.risk === "LOW";
+        return op.risk !== "HIGH";
       } else {
-        return false;
+        return op.risk === "LOW";
       }
     });
     if (detectedOperations.length > 0) {