@defai.digital/automatosx 11.3.1 → 11.3.2

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) {
@@ -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"() {
@@ -2512,6 +2490,7 @@ var init_base_provider = __esm({
     init_provider_schemas();
     init_streaming_progress_parser();
     init_verbosity_manager();
+    init_error_patterns();
     BaseProvider = class _BaseProvider {
       /**
        * Whitelist of allowed provider names for security
@@ -2544,6 +2523,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;
@@ -2601,7 +2584,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 +2606,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 +2618,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 +2729,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 +2743,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 +2761,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 = "";
@@ -2921,7 +2903,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 +2917,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 +2983,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}
 
@@ -3127,26 +3107,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
@@ -4874,24 +4844,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 +4917,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 +4969,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 +5015,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 +5028,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 +5121,10 @@ ${task.task}` : task.task;
             error: errorMessage,
             latencyMs
           };
+        } finally {
+          if (release) {
+            release();
+          }
         }
       }
       /**
@@ -5142,7 +5147,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 +5177,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 +5194,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 +5313,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 +5328,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 +5383,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 +5430,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,7 +5491,7 @@ var init_checkpoint_adapter = __esm({
             });
           }
         }
-        await this.deleteFromFileSystem(workflowId);
+        await this.withFsLock(() => this.deleteFromFileSystem(workflowId));
         logger.info("Checkpoints deleted", { workflowId });
       }
       /**
@@ -5395,15 +5499,15 @@ var init_checkpoint_adapter = __esm({
        */
       async list(workflowId) {
         try {
-          await fs4.mkdir(this.checkpointDir, { recursive: true });
-          const files = await fs4.readdir(this.checkpointDir);
+          await fs5.mkdir(this.checkpointDir, { recursive: true });
+          const files = await fs5.readdir(this.checkpointDir);
           const matchingFiles = files.filter(
-            (file) => file.startsWith(workflowId) && file.endsWith(".json")
+            (file) => file.startsWith(`${workflowId}-`) && file.endsWith(".json")
           );
           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 +5537,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 +5560,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 +5612,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 {
@@ -5514,10 +5628,10 @@ ${result.content.substring(0, 1e3)}
       }
       async deleteFromFileSystem(workflowId) {
         try {
-          const files = await fs4.readdir(this.checkpointDir);
+          const files = await fs5.readdir(this.checkpointDir);
           for (const file of files) {
-            if (file.startsWith(workflowId) && file.endsWith(".json")) {
-              await fs4.unlink(path4.join(this.checkpointDir, file));
+            if (file.startsWith(`${workflowId}-`) && file.endsWith(".json")) {
+              await fs5.unlink(path4.join(this.checkpointDir, file));
             }
           }
         } catch (error) {
@@ -5535,7 +5649,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 +5673,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 +5688,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 +5703,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 +5712,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 +5734,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 +5803,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 +5843,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,
@@ -5726,7 +5888,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 +5923,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
           });
@@ -5880,8 +6042,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 +6085,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 +6114,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 +6163,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 +6200,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 +6224,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 +6245,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 +6266,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 +6287,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 +6308,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 +6330,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 +6352,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 +6404,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 +6438,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 +6462,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 +6487,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 +6502,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 +6521,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 +6536,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 +6555,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 +6574,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 +6593,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) {
@@ -6420,7 +6628,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 +6639,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 +6668,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 +6684,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 +6713,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 +6727,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 +6770,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 +6784,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 +6812,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 +6826,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,15 +6875,28 @@ 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),
@@ -6728,10 +6980,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 +7046,50 @@ 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.
+       */
+      async ensureAgent(options) {
+        if (this.agent && !this.hasConfigChanged(options)) {
+          return;
+        }
+        if (this.initPromise) {
+          await this.initPromise;
+          if (this.agent && !this.hasConfigChanged(options)) {
+            return;
+          }
+        }
+        this.initPromise = this.initializeAgent(options).finally(() => {
+          this.initPromise = null;
+        });
+        await this.initPromise;
+      }
       /**
        * Set up streaming event handlers (for initialization)
+       *
+       * BUG FIX: Remove existing listeners before adding new ones to prevent
+       * listener accumulation when agent is reinitialized.
        */
       setupEventHandlers() {
         if (!this.agent) return;
         try {
+          this.agent.removeAllListeners("stream");
+          this.agent.removeAllListeners("tool");
+          this.agent.removeAllListeners("error");
           this.agent.on("stream", (chunk) => {
             logger.debug("Stream chunk received", {
               type: chunk.type,
@@ -6831,50 +7112,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 +7135,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"}`, {
@@ -7058,21 +7295,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 +7333,41 @@ 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.
+       */
+      async destroyAgentInstance() {
+        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 +7414,13 @@ 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.cliAdapter) {
+              this.initializeCli();
+            }
             this.activeMode = "cli";
             return await this.executeCli(prompt, options);
           }
@@ -7303,6 +7562,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 +7572,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 +7599,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 +7634,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 +7665,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 +7673,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 +7704,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)
@@ -7499,9 +7790,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 +7813,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);
@@ -8626,11 +8919,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;
   }
@@ -9260,11 +9553,16 @@ var PRECOMPILED_CONFIG = {
   },
   "advanced": {
     "embedding": {
+      "model": "text-embedding-3-small",
       "timeout": 3e4,
       "retryDelay": 1e3,
       "dimensions": 1536,
       "maxRetries": 3
     },
+    "projectContext": {
+      "maxSizeBytes": 102400,
+      "cacheTtlMs": 3e5
+    },
     "security": {
       "enablePathValidation": true,
       "allowedExtensions": [
@@ -9320,7 +9618,23 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.1"
+  "axCliSdk": {
+    "maxToolRounds": 400,
+    "checkpoint": {
+      "maxCheckpoints": 10,
+      "flushTimeoutMs": 5e3
+    },
+    "subagent": {
+      "maxParallel": 4,
+      "timeoutMs": 3e5,
+      "maxToolRounds": 100
+    },
+    "instructions": {
+      "cacheTtlMs": 3e5,
+      "maxContextLength": 32e3
+    }
+  },
+  "version": "11.3.2"
 };
 
 // src/core/config/schemas.ts
@@ -9347,7 +9661,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 +10001,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 +10019,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 +10035,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 +10079,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 +10466,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 +10487,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 +11260,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 +11310,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 +11343,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 +11358,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 +11444,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 +11463,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 +13577,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 {
@@ -13583,9 +13897,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;
@@ -14932,11 +15246,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"
             });
           }
         }
@@ -17930,18 +18244,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 +20025,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 +20373,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: rename5 } = await import('fs/promises');
+      await rename5(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 +20938,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 +21536,7 @@ var SessionManager = class _SessionManager {
    * ```
    */
   async destroy() {
+    this.destroyed = true;
     if (this.saveTimeout) {
       clearTimeout(this.saveTimeout);
       this.saveTimeout = void 0;
@@ -21218,9 +21547,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 +21577,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 +21756,7 @@ var SessionManager = class _SessionManager {
    * @private
    */
   saveToFile() {
-    if (!this.persistencePath) {
+    if (!this.persistencePath || this.destroyed) {
       return;
     }
     if (this.saveTimeout) {
@@ -21427,18 +21769,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 +24101,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 +24118,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 +25851,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 +26599,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 +26636,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,
@@ -26870,7 +27212,18 @@ var McpClient = class extends EventEmitter {
         timeout: timeoutHandle
       });
       const message = JSON.stringify(request) + "\n";
-      this.process.stdin.write(message);
+      try {
+        this.process.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,
@@ -29618,8 +29971,8 @@ var LifecycleLogger = class {
       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);
+        const { rename: rename5 } = await import('fs/promises');
+        await rename5(logPath, archivePath);
         logger.info("LifecycleLogger: Rotated log file", {
           oldPath: logPath,
           newPath: archivePath,
@@ -31402,9 +31755,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 +34758,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 +34808,7 @@ var IterateClassifier = class {
       });
     } catch (error) {
       logger.error("Failed to load pattern library", {
-        path: path7,
+        path: path8,
         error: error.message
       });
       throw error;
@@ -34809,14 +35162,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 +35211,7 @@ var IterateAutoResponder = class {
       });
     } catch (error) {
       logger.error("Failed to load template library", {
-        path: path7,
+        path: path8,
         error: error.message
       });
       throw error;
@@ -38670,11 +39023,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: dirname15, join: join51 } = 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 pkgPath = join51(__dirname4, "../../../package.json");
     const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
@@ -40744,8 +41097,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 +41106,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 +41117,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 +41128,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 +41143,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 +41814,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 +41856,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 +43189,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 +43240,7 @@ var SpecSchemaValidator = class {
       ruleId: `SCHEMA-${keyword.toUpperCase()}`,
       severity: "error",
       message,
-      path: path7 || void 0,
+      path: path8 || void 0,
       suggestion
     };
   }
@@ -45707,8 +46060,8 @@ 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");
+  const { join: join51 } = await import('path');
+  const traceFile = join51(workspacePath, ".automatosx/logs/router.trace.jsonl");
   if (!existsSync26(traceFile)) {
     console.log(chalk5.yellow("\n\u26A0\uFE0F  No trace log found\n"));
     console.log(chalk5.gray(`Expected location: ${traceFile}
@@ -48617,13 +48970,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 +49297,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 +49872,6 @@ var OrchestrationInstructionInjector = class {
   providers = /* @__PURE__ */ new Map();
   budgetManager;
   config;
-  lastInjectionTime = 0;
   constructor(config) {
     this.config = {
       ...DEFAULT_ORCHESTRATION_CONFIG,
@@ -49612,7 +49964,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 +50577,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 +50589,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 +51541,6 @@ var AgentInstructionInjector = class {
 var OrchestrationService = class {
   config;
   injector;
-  tokenBudgetManager;
   workflowModeManager;
   agentInjector;
   todoProvider;
@@ -51204,7 +51554,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 +51730,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 +51778,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();