@defai.digital/automatosx 11.2.8 → 11.3.0

package/dist/index.js

@@ -15,14 +15,14 @@ import chalk5 from 'chalk';
 import ora8 from 'ora';
 import * as readline2 from 'readline';
 import readline2__default, { createInterface } from 'readline';
+import { Mutex } from 'async-mutex';
 import { promisify } from 'util';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { randomUUID, createHash } from 'crypto';
+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';
-import { Mutex } from 'async-mutex';
 import inquirer from 'inquirer';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
@@ -2535,6 +2535,15 @@ var init_base_provider = __esm({
         "test-provider"
         // For unit tests
       ];
+      /** Environment variables to force non-interactive CLI mode */
+      static NON_INTERACTIVE_ENV = {
+        TERM: "dumb",
+        NO_COLOR: "1",
+        FORCE_COLOR: "0",
+        CI: "true",
+        NO_UPDATE_NOTIFIER: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      };
       config;
       logger = logger;
       health;
@@ -2627,19 +2636,7 @@ var init_base_provider = __esm({
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              // Disable TTY checks for codex and other CLIs
-              FORCE_COLOR: "0",
-              CI: "true",
-              // Many CLIs disable TTY checks in CI mode
-              NO_UPDATE_NOTIFIER: "1",
-              // Disable interactive prompts
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
@@ -2789,22 +2786,14 @@ var init_base_provider = __esm({
           });
           const child = spawn(cliCommand2, commandArgs, {
             timeout: this.config.timeout || 12e4,
-            env: {
-              ...process.env,
-              // Force non-interactive mode for CLIs
-              TERM: "dumb",
-              NO_COLOR: "1",
-              FORCE_COLOR: "0",
-              CI: "true",
-              NO_UPDATE_NOTIFIER: "1",
-              DEBIAN_FRONTEND: "noninteractive"
-            }
+            env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
           let stderr = "";
           let timeoutId = null;
           let forceKillTimer = null;
           let readlineInterface = null;
+          let stderrInterface = null;
           const streamingEnabled = process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true";
           const debugMode = process.env.AUTOMATOSX_DEBUG === "true";
           const verbosity = VerbosityManager.getInstance();
@@ -2849,7 +2838,7 @@ var init_base_provider = __esm({
             });
           }
           if (child.stderr) {
-            const stderrInterface = readline2__default.createInterface({
+            stderrInterface = readline2__default.createInterface({
               input: child.stderr,
               crlfDelay: Infinity
             });
@@ -2865,6 +2854,13 @@ var init_base_provider = __esm({
                 }
               }
             });
+            stderrInterface.on("error", (error) => {
+              if (error.message !== "Readable stream already read") {
+                logger.debug("Stderr readline error (non-fatal)", {
+                  error: error.message
+                });
+              }
+            });
           }
           const cleanup = () => {
             if (timeoutId) {
@@ -2883,22 +2879,35 @@ var init_base_provider = __esm({
                 readlineInterface = null;
               }
             }
+            if (stderrInterface) {
+              try {
+                stderrInterface.close();
+              } catch (error) {
+              } finally {
+                stderrInterface = null;
+              }
+            }
           };
           child.on("close", (code, signal) => {
             cleanup();
             if (stderr) {
               logger.debug(`${cliCommand2} CLI stderr output`, { stderr: stderr.trim() });
             }
-            if (code === 0) {
+            if ((code === 0 || code === null) && !signal) {
               if (progressParser) {
                 progressParser.succeed(`${cliCommand2} completed successfully`);
               }
               resolve13({ stdout, stderr });
+            } else if (signal) {
+              if (progressParser) {
+                progressParser.fail(`${cliCommand2} killed by signal ${signal}`);
+              }
+              reject(new Error(`${cliCommand2} CLI killed by signal ${signal}. stderr: ${stderr || "none"}`));
             } else {
               if (progressParser) {
                 progressParser.fail(`${cliCommand2} failed with code ${code}`);
               }
-              reject(new Error(`${cliCommand2} CLI exited with code ${code}${signal ? ` (signal: ${signal})` : ""}. stderr: ${stderr || "none"}`));
+              reject(new Error(`${cliCommand2} CLI exited with code ${code}. stderr: ${stderr || "none"}`));
             }
           });
           child.on("error", (error) => {
@@ -2934,8 +2943,18 @@ var init_base_provider = __esm({
       /**
        * Check if CLI is available - Template method pattern
        * Uses getCLICommand() to determine which CLI to check
+       *
+       * v11.2.9 Fix: Always return true in mock mode (AX_MOCK_PROVIDERS=true)
+       * This allows integration tests in CI to run without installing actual provider CLIs
        */
       async checkCLIAvailable() {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          logger.debug(`${this.getCLICommand()} CLI availability check (mock mode)`, {
+            available: true,
+            mockMode: true
+          });
+          return true;
+        }
         try {
           const cliCommand2 = this.getCLICommand();
           const result = findOnPath(cliCommand2);
@@ -3854,8 +3873,6 @@ var init_cli_wrapper = __esm({
     };
   }
 });
-
-// src/integrations/openai-codex/sdk-adapter.ts
 var CodexSdkAdapter;
 var init_sdk_adapter = __esm({
   "src/integrations/openai-codex/sdk-adapter.ts"() {
@@ -3868,6 +3885,8 @@ var init_sdk_adapter = __esm({
       sdkModule = null;
       options;
       initialized = false;
+      initMutex = new Mutex();
+      // v11.2.8: Prevent race condition in ensureInitialized
       constructor(options = {}) {
         this.options = {
           streamingEnabled: true,
@@ -3962,18 +3981,20 @@ var init_sdk_adapter = __esm({
         return this.activeThread;
       }
       async ensureInitialized() {
-        if (this.initialized) return;
-        try {
-          this.sdkModule = await import('@openai/codex-sdk');
-          this.codex = new this.sdkModule.Codex();
-          this.initialized = true;
-          logger.info("Codex SDK initialized");
-        } catch (error) {
-          throw new CodexError(
-            "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
-            "Codex SDK not available. Install with: npm install @openai/codex-sdk"
-          );
-        }
+        return this.initMutex.runExclusive(async () => {
+          if (this.initialized) return;
+          try {
+            this.sdkModule = await import('@openai/codex-sdk');
+            this.codex = new this.sdkModule.Codex();
+            this.initialized = true;
+            logger.info("Codex SDK initialized");
+          } catch (error) {
+            throw new CodexError(
+              "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
+              "Codex SDK not available. Install with: npm install @openai/codex-sdk"
+            );
+          }
+        });
       }
       async destroy() {
         this.activeThread = null;
@@ -4379,6 +4400,9 @@ var init_command_builder = __esm({
        * @returns Environment variable object
        */
       buildEnv(options) {
+        if (!options.apiKey && !options.baseUrl && !options.model) {
+          return null;
+        }
         const env = {};
         if (options.apiKey) {
           env.YOUR_API_KEY = options.apiKey;
@@ -4426,6 +4450,27 @@ var init_response_parser = __esm({
     AxCliResponseParser = class _AxCliResponseParser {
       /** Maximum number of assistant messages to prevent memory exhaustion */
       static MAX_ASSISTANT_MESSAGES = 1e3;
+      /** Pre-compiled regex patterns for error detection (avoids recompilation per call) */
+      static ERROR_WITH_COLON_REGEX = /Sorry, I encountered an error: (.+?)$/;
+      static ERROR_WITHOUT_COLON_REGEX = /Sorry, I encountered an error(.*?)$/;
+      /**
+       * Extract error message from content if present
+       * @returns Error message or null if no error
+       */
+      extractErrorFromContent(content) {
+        if (!content.includes("Sorry, I encountered an error")) {
+          return null;
+        }
+        const matchWithColon = content.match(_AxCliResponseParser.ERROR_WITH_COLON_REGEX);
+        if (matchWithColon?.[1]) {
+          return matchWithColon[1];
+        }
+        const matchWithoutColon = content.match(_AxCliResponseParser.ERROR_WITHOUT_COLON_REGEX);
+        if (matchWithoutColon) {
+          return matchWithoutColon[1] ? matchWithoutColon[1].trim() : "API error";
+        }
+        return "API error";
+      }
       /**
        * Parse JSONL output from ax-cli into ProviderResponse
        *
@@ -4450,17 +4495,9 @@ var init_response_parser = __esm({
               const parsed = JSON.parse(line);
               const validated = AxCliMessageSchema.parse(parsed);
               if (validated.role === "assistant") {
-                if (validated.content.includes("Sorry, I encountered an error")) {
-                  const matchWithColon = validated.content.match(/Sorry, I encountered an error: (.+?)$/);
-                  if (matchWithColon) {
-                    throw new Error(`ax-cli error: ${matchWithColon[1]}`);
-                  }
-                  const matchWithoutColon = validated.content.match(/Sorry, I encountered an error(.*?)$/);
-                  if (matchWithoutColon) {
-                    const errorMsg = matchWithoutColon[1] ? matchWithoutColon[1].trim() : "API error";
-                    throw new Error(`ax-cli error: ${errorMsg}`);
-                  }
-                  throw new Error("ax-cli error: API error");
+                const errorMsg = this.extractErrorFromContent(validated.content);
+                if (errorMsg) {
+                  throw new Error(`ax-cli error: ${errorMsg}`);
                 }
                 if (assistantMessages.length >= _AxCliResponseParser.MAX_ASSISTANT_MESSAGES) {
                   throw new Error(
@@ -4538,16 +4575,9 @@ var init_response_parser = __esm({
             try {
               const parsed = JSON.parse(line);
               if (parsed.role === "assistant" && parsed.content) {
-                if (parsed.content.includes("Sorry, I encountered an error")) {
-                  const matchWithColon = parsed.content.match(/Sorry, I encountered an error: (.+?)$/);
-                  if (matchWithColon) {
-                    return matchWithColon[1];
-                  }
-                  const matchWithoutColon = parsed.content.match(/Sorry, I encountered an error(.*?)$/);
-                  if (matchWithoutColon) {
-                    return matchWithoutColon[1] ? matchWithoutColon[1].trim() : "Sorry, I encountered an error";
-                  }
-                  return parsed.content;
+                const errorMsg = this.extractErrorFromContent(parsed.content);
+                if (errorMsg) {
+                  return errorMsg;
                 }
               }
             } catch {
@@ -4605,7 +4635,7 @@ var init_adapter = __esm({
             // 10MB
             env: {
               ...process.env,
-              ...this.commandBuilder.buildEnv(options)
+              ...this.commandBuilder.buildEnv(options) ?? {}
             }
           });
           if (stderr && stderr.trim().length > 0) {
@@ -4824,11 +4854,12 @@ var init_token_estimator = __esm({
 });
 
 // src/integrations/ax-cli-sdk/subagent-adapter.ts
-var SubagentAdapter;
+var TOKEN_SPLIT, 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 };
     SubagentAdapter = class {
       orchestrator = null;
       subagents = /* @__PURE__ */ new Map();
@@ -5033,9 +5064,8 @@ ${task.task}` : task.task;
             success: true,
             latencyMs,
             tokensUsed: totalTokens > 0 ? {
-              prompt: Math.floor(totalTokens * 0.3),
-              // Estimated split
-              completion: Math.floor(totalTokens * 0.7),
+              prompt: Math.floor(totalTokens * TOKEN_SPLIT.PROMPT),
+              completion: Math.floor(totalTokens * TOKEN_SPLIT.COMPLETION),
               total: totalTokens
             } : void 0
           };
@@ -5198,7 +5228,10 @@ ${task.task}` : task.task;
         for (const [key, subagent] of this.subagents) {
           try {
             if (subagent.dispose) {
-              subagent.dispose();
+              const result = subagent.dispose();
+              if (result instanceof Promise) {
+                await result;
+              }
             }
             logger.debug("Subagent disposed", { key });
           } catch (error) {
@@ -6354,7 +6387,7 @@ var init_adapter2 = __esm({
     init_instructions_bridge();
     init_mcp_manager();
     init_mcp_manager();
-    AxCliSdkAdapter = class {
+    AxCliSdkAdapter = class _AxCliSdkAdapter {
       agent = null;
       // Will type as LLMAgent after import
       agentConfig = null;
@@ -6565,7 +6598,7 @@ var init_adapter2 = __esm({
           if (!await this.ensureSDKAvailable()) {
             throw new Error("ax-cli SDK not available. Install with: npm install @defai.digital/ax-cli");
           }
-          if (!this.agent || await this.hasConfigChanged(options)) {
+          if (!this.agent || this.hasConfigChanged(options)) {
             await this.initializeAgent(options);
           }
           logger.debug("Executing via SDK (streaming mode for token tracking)", {
@@ -6712,8 +6745,9 @@ var init_adapter2 = __esm({
        * Check if agent config has changed (requires new agent)
        *
        * Since SDK manages credentials via settings, we only track maxToolRounds
+       * v11.2.8: Removed unnecessary async (no async operations)
        */
-      async hasConfigChanged(options) {
+      hasConfigChanged(options) {
         if (!this.agentConfig) return true;
         const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || 400);
         if (changed) {
@@ -6797,6 +6831,49 @@ var init_adapter2 = __esm({
           });
         }
       }
+      /**
+       * Extract token usage from various sources with priority:
+       * 1. SDK events (token_count emissions) - most accurate
+       * 2. Usage object (ChatEntry.usage or response.usage)
+       * 3. Estimation fallback
+       */
+      extractTokenUsage(prompt, content, totalTokensFromEvents, usageObject, sourceName) {
+        if (totalTokensFromEvents > 0) {
+          const estimated2 = TokenEstimator.estimateUsage(prompt, content);
+          const tokens = {
+            prompt: estimated2.prompt,
+            completion: estimated2.completion,
+            total: totalTokensFromEvents
+          };
+          logger.info(`Using token count from SDK events${sourceName ? ` (${sourceName})` : ""}`, {
+            tokens: TokenEstimator.format(tokens),
+            accuracy: "100% (total), 80-90% (split)",
+            source: "token_count events"
+          });
+          return tokens;
+        }
+        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
+        };
+        if (actualTokens.total > 0) {
+          logger.info(`Using token counts from ${sourceName || "usage object"}`, {
+            tokens: TokenEstimator.format(actualTokens),
+            accuracy: "100%",
+            source: sourceName || "usage"
+          });
+          return actualTokens;
+        }
+        const estimated = TokenEstimator.estimateUsage(prompt, content);
+        logger.warn(`SDK did not provide token counts${sourceName ? ` (${sourceName})` : ""}, using estimation`, {
+          tokens: TokenEstimator.format(estimated, true),
+          accuracy: "80-90% (estimated)",
+          source: "estimation"
+        });
+        return estimated;
+      }
       /**
        * Convert SDK response to ExecutionResponse format
        *
@@ -6827,116 +6904,47 @@ var init_adapter2 = __esm({
           }
           const lastAssistant = assistantMessages[assistantMessages.length - 1];
           const content2 = lastAssistant.content || "";
-          let finalTokens2;
-          if (totalTokensFromEvents > 0) {
-            const estimated = TokenEstimator.estimateUsage(prompt, content2);
-            finalTokens2 = {
-              prompt: estimated.prompt,
-              // Estimated split
-              completion: estimated.completion,
-              // Estimated split
-              total: totalTokensFromEvents
-              // Actual total from events
-            };
-            logger.info("Using token count from SDK events", {
-              tokens: TokenEstimator.format(finalTokens2),
-              accuracy: "100% (total), 80-90% (split)",
-              source: "token_count events"
-            });
-          } else {
-            const usage = lastAssistant.usage || lastAssistant.tokens || {};
-            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
-            };
-            const hasActualTokens = actualTokens.total > 0;
-            if (hasActualTokens) {
-              finalTokens2 = {
-                prompt: actualTokens.prompt,
-                completion: actualTokens.completion,
-                total: actualTokens.total
-              };
-              logger.info("Using token counts from ChatEntry.usage", {
-                tokens: TokenEstimator.format(finalTokens2),
-                accuracy: "100%",
-                source: "ChatEntry.usage"
-              });
-            } else {
-              finalTokens2 = TokenEstimator.estimateUsage(prompt, content2);
-              logger.warn("SDK did not provide token counts, using estimation", {
-                tokens: TokenEstimator.format(finalTokens2, true),
-                accuracy: "80-90% (estimated)",
-                source: "estimation"
-              });
-            }
-          }
-          const model2 = this.agent.getCurrentModel();
-          const finishReason2 = "stop";
+          const tokensUsed2 = this.extractTokenUsage(
+            prompt,
+            content2,
+            totalTokensFromEvents,
+            lastAssistant.usage || lastAssistant.tokens,
+            "ChatEntry.usage"
+          );
           return {
             content: content2,
-            model: model2,
-            tokensUsed: finalTokens2,
+            model: this.agent?.getCurrentModel() ?? "unknown",
+            tokensUsed: tokensUsed2,
             latencyMs,
-            finishReason: finishReason2,
+            finishReason: "stop",
             cached: false
-            // SDK doesn't expose cache status via ChatEntry
           };
         }
         const content = typeof result === "string" ? result : result.content || result.text || "";
-        let finalTokens;
-        if (totalTokensFromEvents > 0) {
-          const estimated = TokenEstimator.estimateUsage(prompt, content);
-          finalTokens = {
-            prompt: estimated.prompt,
-            completion: estimated.completion,
-            total: totalTokensFromEvents
-          };
-          logger.info("Using token count from SDK events (fallback path)", {
-            tokens: TokenEstimator.format(finalTokens),
-            accuracy: "100% (total), 80-90% (split)",
-            source: "token_count events"
-          });
-        } else {
-          const usage = result.usage || result.tokens || {};
-          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
-          };
-          const hasActualTokens = actualTokens.total > 0;
-          if (hasActualTokens) {
-            finalTokens = {
-              prompt: actualTokens.prompt,
-              completion: actualTokens.completion,
-              total: actualTokens.total
-            };
-            logger.info("Using token counts from response.usage (fallback path)", {
-              tokens: TokenEstimator.format(finalTokens),
-              accuracy: "100%",
-              source: "response.usage"
-            });
-          } else {
-            finalTokens = TokenEstimator.estimateUsage(prompt, content);
-            logger.warn("SDK did not provide token counts (fallback path), using estimation", {
-              tokens: TokenEstimator.format(finalTokens, true),
-              accuracy: "80-90% (estimated)",
-              source: "estimation"
-            });
-          }
-        }
-        const model = this.agent.getCurrentModel();
-        const finishReason = "stop";
+        const tokensUsed = this.extractTokenUsage(
+          prompt,
+          content,
+          totalTokensFromEvents,
+          result.usage || result.tokens,
+          "response.usage (fallback path)"
+        );
         return {
           content,
-          model,
-          tokensUsed: finalTokens,
+          model: this.agent?.getCurrentModel() ?? "unknown",
+          tokensUsed,
           latencyMs,
-          finishReason,
+          finishReason: "stop",
           cached: false
-          // SDK doesn't expose cache status
         };
       }
+      /** Error mapping patterns: [patterns, prefix, code] */
+      static ERROR_MAPPINGS = [
+        [["rate limit", "rate_limit"], "Rate limit exceeded", "RATE_LIMIT_EXCEEDED"],
+        [["context length", "max_tokens"], "Context length exceeded", "CONTEXT_LENGTH_EXCEEDED"],
+        [["timeout", "timed out"], "Request timeout", "TIMEOUT"],
+        [["invalid api key", "authentication"], "Authentication failed", "AUTHENTICATION_FAILED"],
+        [["network", "econnrefused"], "Network error", "NETWORK_ERROR"]
+      ];
       /**
        * Map SDK errors to AutomatosX error types
        */
@@ -6945,30 +6953,12 @@ var init_adapter2 = __esm({
           return new Error(`SDK error: ${String(error)}`);
         }
         const message = error.message.toLowerCase();
-        if (message.includes("rate limit") || message.includes("rate_limit")) {
-          const mappedError = new Error(`Rate limit exceeded: ${error.message}`);
-          mappedError.code = "RATE_LIMIT_EXCEEDED";
-          return mappedError;
-        }
-        if (message.includes("context length") || message.includes("max_tokens")) {
-          const mappedError = new Error(`Context length exceeded: ${error.message}`);
-          mappedError.code = "CONTEXT_LENGTH_EXCEEDED";
-          return mappedError;
-        }
-        if (message.includes("timeout") || message.includes("timed out")) {
-          const mappedError = new Error(`Request timeout: ${error.message}`);
-          mappedError.code = "TIMEOUT";
-          return mappedError;
-        }
-        if (message.includes("invalid api key") || message.includes("authentication")) {
-          const mappedError = new Error(`Authentication failed: ${error.message}`);
-          mappedError.code = "AUTHENTICATION_FAILED";
-          return mappedError;
-        }
-        if (message.includes("network") || message.includes("econnrefused")) {
-          const mappedError = new Error(`Network error: ${error.message}`);
-          mappedError.code = "NETWORK_ERROR";
-          return mappedError;
+        for (const [patterns, prefix, code] of _AxCliSdkAdapter.ERROR_MAPPINGS) {
+          if (patterns.some((pattern) => message.includes(pattern))) {
+            const mappedError = new Error(`${prefix}: ${error.message}`);
+            mappedError.code = code;
+            return mappedError;
+          }
         }
         return error;
       }
@@ -7003,15 +6993,10 @@ var init_adapter2 = __esm({
        * Get SDK version
        */
       async getVersion() {
-        try {
-          await import('@defai.digital/ax-cli/sdk');
+        if (await this.ensureSDKAvailable()) {
           return "3.14.5+";
-        } catch (error) {
-          logger.warn("Failed to get SDK version", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-          return "unknown";
         }
+        return "unknown";
       }
       /**
        * Get command name (for compatibility with AxCliAdapter interface)
@@ -7031,7 +7016,10 @@ var init_adapter2 = __esm({
       async destroy() {
         if (this.agent) {
           try {
-            this.agent.dispose();
+            const result = this.agent.dispose();
+            if (result instanceof Promise) {
+              await result;
+            }
             this.agent = null;
             this.agentConfig = null;
             logger.debug("SDK agent destroyed");
@@ -9285,7 +9273,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.8"
+  "version": "11.3.0"
 };
 
 // src/core/config/schemas.ts
@@ -15174,7 +15162,7 @@ function parseAXMD(content) {
     "Useful Links"
   ];
   for (const section of sections) {
-    const sectionName = section.split("\n")[0];
+    const sectionName = section.split("\n")[0] ?? "";
     if (sectionName && !standardSections.includes(sectionName)) {
       result.customSections.push(sectionName);
     }
@@ -16567,6 +16555,8 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   getManualOverride() {
     if (this.manualOverride && this.manualOverride.expiresAtMs) {
       if (Date.now() >= this.manualOverride.expiresAtMs) {
+        this.manualOverride;
+        this.manualOverride = void 0;
         void this.clearManualOverride();
         return void 0;
       }
@@ -16907,19 +16897,33 @@ var ProviderMetricsTracker = class extends EventEmitter {
     const p50 = getPercentile(latencies, 50);
     const p95 = getPercentile(latencies, 95);
     const p99 = getPercentile(latencies, 99);
-    const successful = records.filter((r) => r.success);
-    const failed = records.filter((r) => !r.success);
-    const stopFinishes = successful.filter((r) => r.finishReason === "stop");
-    const lengthFinishes = successful.filter((r) => r.finishReason === "length");
-    const errorFinishes = records.filter((r) => r.finishReason === "error");
-    const successRate = successful.length / records.length;
-    const properStopRate = successful.length > 0 ? stopFinishes.length / successful.length : 0;
+    let successCount = 0;
+    let failCount = 0;
+    let stopFinishCount = 0;
+    let lengthFinishCount = 0;
+    let errorFinishCount = 0;
+    let lastSuccessTimestamp = 0;
+    let lastFailureTimestamp = 0;
+    for (const r of records) {
+      if (r.success) {
+        successCount++;
+        lastSuccessTimestamp = r.timestamp;
+        if (r.finishReason === "stop") stopFinishCount++;
+        else if (r.finishReason === "length") lengthFinishCount++;
+      } else {
+        failCount++;
+        lastFailureTimestamp = r.timestamp;
+      }
+      if (r.finishReason === "error") errorFinishCount++;
+    }
+    const successRate = successCount / records.length;
+    const properStopRate = successCount > 0 ? stopFinishCount / successCount : 0;
     const totalCost = records.reduce((sum, r) => sum + r.costUsd, 0);
     const avgCostPerRequest = totalCost / records.length;
     const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
     const avgCostPer1M = totalTokens > 0 ? totalCost / totalTokens * 1e6 : 0;
-    const lastSuccess = successful.length > 0 ? successful[successful.length - 1].timestamp : 0;
-    const lastFailure = failed.length > 0 ? failed[failed.length - 1].timestamp : 0;
+    const lastSuccess = lastSuccessTimestamp;
+    const lastFailure = lastFailureTimestamp;
     let consecutiveFailures = 0;
     for (let i = records.length - 1; i >= 0; i--) {
       if (!records[i].success) {
@@ -16942,12 +16946,12 @@ var ProviderMetricsTracker = class extends EventEmitter {
       },
       quality: {
         totalRequests: records.length,
-        successfulRequests: successful.length,
-        failedRequests: failed.length,
+        successfulRequests: successCount,
+        failedRequests: failCount,
         successRate,
-        stopFinishes: stopFinishes.length,
-        lengthFinishes: lengthFinishes.length,
-        errorFinishes: errorFinishes.length,
+        stopFinishes: stopFinishCount,
+        lengthFinishes: lengthFinishCount,
+        errorFinishes: errorFinishCount,
         properStopRate
       },
       cost: {
@@ -17056,7 +17060,7 @@ var ProviderMetricsTracker = class extends EventEmitter {
    * v9.0.2: Added score caching to reduce redundant calculations
    */
   async calculateScore(provider, weights, allProviders, healthMultiplier = 1) {
-    const cacheKey = `${provider}-${JSON.stringify(weights)}-${healthMultiplier}`;
+    const cacheKey = `${provider}-${weights.cost}-${weights.latency}-${weights.quality}-${weights.availability}-${healthMultiplier}`;
     const cached = this.scoreCache.get(cacheKey);
     const currentRequestCount = this.getRequestCount(provider);
     if (cached) {
@@ -18221,8 +18225,7 @@ var Router = class {
         }
       }
       if (limitedProviders2.length === allProviders2.length && limitedProviders2.length > 0) {
-        const soonestReset = Math.min(...limitedProviders2.map((p) => p.resetAtMs));
-        throw ProviderError.allProvidersLimited(limitedProviders2, soonestReset);
+        throw ProviderError.allProvidersLimited(limitedProviders2, this.getSoonestLimitReset(limitedProviders2));
       }
       throw ProviderError.noAvailableProviders();
     }
@@ -18628,8 +18631,7 @@ var Router = class {
       }
     }
     if (limitedProviders.length === allProviders.length && limitedProviders.length > 0) {
-      const soonestReset = Math.min(...limitedProviders.map((p) => p.resetAtMs));
-      throw ProviderError.allProvidersLimited(limitedProviders, soonestReset);
+      throw ProviderError.allProvidersLimited(limitedProviders, this.getSoonestLimitReset(limitedProviders));
     }
     const errorDetails = {
       lastError: lastError?.message,
@@ -18863,6 +18865,16 @@ Run 'ax doctor' to diagnose provider setup.` : "";
       })
     };
   }
+  /**
+   * Calculate the soonest reset time from limited providers
+   * v11.2.8: Added guard against empty array (Math.min on empty array returns Infinity)
+   */
+  getSoonestLimitReset(limitedProviders) {
+    if (limitedProviders.length === 0) {
+      return Date.now() + 6e4;
+    }
+    return Math.min(...limitedProviders.map((p) => p.resetAtMs));
+  }
 };
 
 // src/core/memory/lazy-manager.ts
@@ -20698,8 +20710,6 @@ z.object({
   limit: z.number().int().positive().max(1e4).optional(),
   offset: z.number().int().nonnegative().optional()
 }).strict();
-
-// src/core/session/manager.ts
 var SessionManager = class _SessionManager {
   /** Active sessions (in-memory, keyed by session ID) */
   activeSessions = /* @__PURE__ */ new Map();
@@ -20772,8 +20782,9 @@ var SessionManager = class _SessionManager {
       try {
         SessionManagerConfigSchema.parse(config);
       } catch (error) {
+        const message = error instanceof ZodError ? error.message : String(error);
         throw new SessionError(
-          `Invalid session manager config: ${error.message}`,
+          `Invalid session manager config: ${message}`,
           void 0,
           "invalid_configuration"
         );
@@ -22175,8 +22186,8 @@ var ProjectContextLoader = class {
     const projectMatch = markdown.match(/>\s*Project:\s*(.+?)$/im);
     if (projectMatch && projectMatch[1]) {
       const parts = projectMatch[1].trim().split(/\s+v/);
-      metadata.name = parts[0];
-      if (parts[1]) {
+      metadata.name = parts[0] || "";
+      if (parts.length > 1 && parts[1]) {
         metadata.version = parts[1];
       }
     }
@@ -29880,13 +29891,23 @@ var MetricsCollector = class {
    */
   getMetricsSummary(serverMetrics) {
     const totalServers = serverMetrics.length;
-    const healthyServers = serverMetrics.filter((m) => m.memoryUsageMB > 0).length;
-    const totalCpu = serverMetrics.reduce((sum, m) => sum + m.cpuUsagePercent, 0);
-    const totalMemory = serverMetrics.reduce((sum, m) => sum + m.memoryUsageMB, 0);
-    const totalRequests = serverMetrics.reduce((sum, m) => sum + m.totalRequests, 0);
-    const totalFailed = serverMetrics.reduce((sum, m) => sum + m.failedRequests, 0);
-    const totalRestarts = serverMetrics.reduce((sum, m) => sum + m.restartCount, 0);
-    const avgResponseTime = serverMetrics.length > 0 ? serverMetrics.reduce((sum, m) => sum + m.avgResponseTimeMs, 0) / serverMetrics.length : 0;
+    let healthyServers = 0;
+    let totalCpu = 0;
+    let totalMemory = 0;
+    let totalRequests = 0;
+    let totalFailed = 0;
+    let totalRestarts = 0;
+    let totalResponseTime = 0;
+    for (const m of serverMetrics) {
+      if (m.memoryUsageMB > 0) healthyServers++;
+      totalCpu += m.cpuUsagePercent;
+      totalMemory += m.memoryUsageMB;
+      totalRequests += m.totalRequests;
+      totalFailed += m.failedRequests;
+      totalRestarts += m.restartCount;
+      totalResponseTime += m.avgResponseTimeMs;
+    }
+    const avgResponseTime = totalServers > 0 ? totalResponseTime / totalServers : 0;
     const errorRate = totalRequests > 0 ? totalFailed / totalRequests * 100 : 0;
     return {
       totalServers,
@@ -31758,7 +31779,7 @@ var addCommand = {
           throw new Error(`Invalid metadata JSON: ${error.message}`);
         }
       }
-      const embedding = new Array(1536).fill(0);
+      const embedding = Array(1536).fill(0);
       const entry = await manager.add(argv.content, embedding, metadata);
       printSuccess("\nMemory entry added successfully\n");
       console.log(`${chalk5.bold("ID:")} ${chalk5.white(entry.id)}`);
@@ -34106,47 +34127,39 @@ ${action.modifications}`;
    * @param stage - Stage to execute
    * @param context - Stage context
    * @returns Stage task prompt
+   * v11.2.8: Refactored to use array.join() for better string building performance
    */
   buildStageTask(stage, context) {
-    let prompt = `# Stage: ${stage.name}
-
-`;
-    prompt += `## Stage Description
+    const parts = [
+      `# Stage: ${stage.name}
+`,
+      `## Stage Description
 ${stage.description}
-
-`;
-    prompt += `## Original Task
+`,
+      `## Original Task
 ${context.task}
-
-`;
+`
+    ];
     if (context.previousOutputs.length > 0) {
-      prompt += `## Previous Stage Outputs
-
-`;
-      context.previousOutputs.forEach((output, index) => {
-        prompt += `### Stage ${index + 1} Output
+      parts.push(`## Previous Stage Outputs
+`);
+      parts.push(...context.previousOutputs.map(
+        (output, index) => `### Stage ${index + 1} Output
 ${output}
-
-`;
-      });
+`
+      ));
     }
     if (stage.key_questions && stage.key_questions.length > 0) {
-      prompt += `## Key Questions to Address
-`;
-      stage.key_questions.forEach((q) => prompt += `- ${q}
-`);
-      prompt += `
-`;
+      parts.push(`## Key Questions to Address`);
+      parts.push(...stage.key_questions.map((q) => `- ${q}`));
+      parts.push("");
     }
     if (stage.outputs && stage.outputs.length > 0) {
-      prompt += `## Expected Outputs
-`;
-      stage.outputs.forEach((o) => prompt += `- ${o}
-`);
-      prompt += `
-`;
+      parts.push(`## Expected Outputs`);
+      parts.push(...stage.outputs.map((o) => `- ${o}`));
+      parts.push("");
     }
-    return prompt;
+    return parts.join("\n");
   }
   /**
    * Enhance stages with index and defaults
@@ -36222,10 +36235,10 @@ var runCommand = {
     }).positional("task", {
       describe: "Task to execute",
       type: "string"
-    }).option("no-auto-select", {
-      describe: "Disable agent auto-selection (v11.1.0+)",
+    }).option("auto-select", {
+      describe: "Enable agent auto-selection when agent not found (v11.1.0+)",
       type: "boolean",
-      default: false
+      default: true
     }).option("provider", {
       describe: "Override provider (claude, gemini, openai)",
       type: "string"
@@ -36367,7 +36380,7 @@ var runCommand = {
       console.log(chalk5.gray('       ax run backend "implement API"     # uses specified agent'));
       process.exit(1);
     }
-    if (!agentProvided && argv.noAutoSelect) {
+    if (!agentProvided && argv.autoSelect === false) {
       console.log(chalk5.red.bold("\n\u274C Error: Agent name is required when --no-auto-select is used\n"));
       console.log(chalk5.gray("Usage: ax run <agent> <task> --no-auto-select"));
       process.exit(1);
@@ -36502,7 +36515,7 @@ var runCommand = {
             }
           }
         } catch (error) {
-          if (argv.noAutoSelect) {
+          if (argv.autoSelect === false) {
             console.error(chalk5.red.bold(`
 \u274C Agent not found: ${actualAgent}
 `));
@@ -44704,10 +44717,11 @@ function displayPlanSummary(plan) {
   console.log(chalk5.gray(`  Storage: ${plan.resourceRequirements.storage}`));
   console.log(chalk5.gray(`  Network: ${plan.resourceRequirements.network}
 `));
+  const SEVERITY_ICONS = { high: "\u{1F534}", medium: "\u{1F7E1}", low: "\u{1F7E2}" };
   if (plan.risks.length > 0) {
     console.log(chalk5.blue("Identified Risks:"));
     for (const risk of plan.risks) {
-      const icon = risk.severity === "high" ? "\u{1F534}" : risk.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      const icon = SEVERITY_ICONS[risk.severity] ?? "\u{1F7E2}";
       console.log(`  ${icon} ${risk.severity.toUpperCase()}: ${risk.title}`);
       console.log(chalk5.gray(`    ${risk.description}`));
       console.log(chalk5.gray(`    Mitigation: ${risk.mitigation}
@@ -44863,24 +44877,24 @@ async function handleList(config, argv) {
       });
     }
   }
-  let displayProviders = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
+  let displayProviders2 = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
   switch (argv.sort) {
     case "cost":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const costA = a.metadata ? (a.metadata.costPerToken.input + a.metadata.costPerToken.output) / 2 : Infinity;
         const costB = b.metadata ? (b.metadata.costPerToken.input + b.metadata.costPerToken.output) / 2 : Infinity;
         return costA - costB;
       });
       break;
     case "latency":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const latA = a.metadata?.latencyEstimate.p95 || Infinity;
         const latB = b.metadata?.latencyEstimate.p95 || Infinity;
         return latA - latB;
       });
       break;
     case "reliability":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const relA = a.metadata?.reliability.availability || 0;
         const relB = b.metadata?.reliability.availability || 0;
         return relB - relA;
@@ -44888,15 +44902,15 @@ async function handleList(config, argv) {
       break;
     case "priority":
     default:
-      displayProviders.sort((a, b) => a.priority - b.priority);
+      displayProviders2.sort((a, b) => a.priority - b.priority);
       break;
   }
   if (argv.json) {
-    console.log(JSON.stringify({ providers: displayProviders }, null, 2));
+    console.log(JSON.stringify({ providers: displayProviders2 }, null, 2));
     return;
   }
   console.log(chalk5.gray("Provider Status & Metadata:\n"));
-  for (const provider of displayProviders) {
+  for (const provider of displayProviders2) {
     const status = provider.enabled ? provider.limitInfo?.isBlocked ? chalk5.red("\u25CF BLOCKED") : chalk5.green("\u25CF ENABLED") : chalk5.gray("\u25CB DISABLED");
     console.log(`${status} ${chalk5.bold(provider.name)} ${chalk5.gray(`(priority: ${provider.priority})`)}`);
     if (provider.metadata && argv.verbose) {
@@ -46143,9 +46157,11 @@ async function checkDiskSpace(workingDir, verbose) {
       timeout: 5e3
     });
     const parts = dfOutput.trim().split(/\s+/);
-    const availableKB = parseInt(parts[3] || "0", 10);
-    const availableMB = Math.round(availableKB / 1024);
-    const availableGB = (availableKB / (1024 * 1024)).toFixed(2);
+    const rawAvailable = parts.length > 3 ? parts[3] : "0";
+    const availableKB = parseInt(rawAvailable || "0", 10);
+    const safeAvailableKB = isNaN(availableKB) ? 0 : availableKB;
+    const availableMB = Math.round(safeAvailableKB / 1024);
+    const availableGB = (safeAvailableKB / (1024 * 1024)).toFixed(2);
     const hasEnoughSpace = availableMB > 100;
     results.push({
       name: "Available Disk Space",
@@ -46833,37 +46849,38 @@ var TelemetryCollector = class {
       logger.warn("Query called on closed or uninitialized telemetry collector");
       return [];
     }
-    let sql = "SELECT * FROM telemetry_events WHERE 1=1";
+    const conditions = [];
     const params = [];
     if (filters.provider) {
-      sql += " AND provider = ?";
+      conditions.push("provider = ?");
       params.push(filters.provider);
     }
     if (filters.agentName) {
-      sql += " AND agent_name = ?";
+      conditions.push("agent_name = ?");
       params.push(filters.agentName);
     }
     if (filters.sessionId) {
-      sql += " AND session_id = ?";
+      conditions.push("session_id = ?");
       params.push(filters.sessionId);
     }
     if (filters.type) {
-      sql += " AND type = ?";
+      conditions.push("type = ?");
       params.push(filters.type);
     }
     if (filters.startDate) {
-      sql += " AND timestamp >= ?";
+      conditions.push("timestamp >= ?");
       params.push(filters.startDate);
     }
     if (filters.endDate) {
-      sql += " AND timestamp <= ?";
+      conditions.push("timestamp <= ?");
       params.push(filters.endDate);
     }
     if (filters.success !== void 0) {
-      sql += " AND success = ?";
+      conditions.push("success = ?");
       params.push(filters.success ? 1 : 0);
     }
-    sql += " ORDER BY timestamp DESC LIMIT ?";
+    const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+    const sql = `SELECT * FROM telemetry_events ${whereClause} ORDER BY timestamp DESC LIMIT ?`;
     params.push(filters.limit || 1e3);
     const rows = this.db.prepare(sql).all(...params);
     return rows.map((row) => this.mapRowToEvent(row));
@@ -46877,20 +46894,22 @@ var TelemetryCollector = class {
     if (this.closed || !this.db) {
       return 0;
     }
-    let sql = "SELECT COUNT(*) as count FROM telemetry_events WHERE 1=1";
+    const conditions = [];
     const params = [];
     if (filters.provider) {
-      sql += " AND provider = ?";
+      conditions.push("provider = ?");
       params.push(filters.provider);
     }
     if (filters.startDate) {
-      sql += " AND timestamp >= ?";
+      conditions.push("timestamp >= ?");
       params.push(filters.startDate);
     }
     if (filters.endDate) {
-      sql += " AND timestamp <= ?";
+      conditions.push("timestamp <= ?");
       params.push(filters.endDate);
     }
+    const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+    const sql = `SELECT COUNT(*) as count FROM telemetry_events ${whereClause}`;
     const result = this.db.prepare(sql).get(...params);
     return result.count;
   }
@@ -47610,9 +47629,11 @@ async function optimizeHandler(argv) {
       console.log(chalk5.green("\u2705 No optimization opportunities found. You're doing great!\n"));
       return;
     }
+    const TYPE_ICONS = { cost_saving: "\u{1F4B0}", performance: "\u26A1", security: "\u{1F512}" };
+    const SEVERITY_COLORS = { high: chalk5.red, medium: chalk5.yellow, low: chalk5.gray };
     for (const rec of recommendations) {
-      const icon = rec.type === "cost_saving" ? "\u{1F4B0}" : rec.type === "performance" ? "\u26A1" : "\u{1F512}";
-      const severityColor = rec.severity === "high" ? chalk5.red : rec.severity === "medium" ? chalk5.yellow : chalk5.gray;
+      const icon = TYPE_ICONS[rec.type] ?? "\u{1F512}";
+      const severityColor = SEVERITY_COLORS[rec.severity] ?? chalk5.gray;
       console.log(`${icon} ${severityColor(rec.severity.toUpperCase())}: ${chalk5.bold(rec.title)}`);
       console.log(`   ${rec.description}`);
       if (rec.estimatedSavings) {
@@ -48510,6 +48531,2880 @@ var uninstallCommand = {
   }
 };
 
+// src/cli/commands/mode.ts
+init_esm_shims();
+init_logger();
+
+// src/core/workflow/index.ts
+init_esm_shims();
+
+// src/core/workflow/workflow-mode.ts
+init_esm_shims();
+var WorkflowModeSchema = z.enum(["default", "plan", "iterate", "review"]);
+z.object({
+  name: WorkflowModeSchema,
+  description: z.string(),
+  displayName: z.string(),
+  allowedTools: z.array(z.string()).optional(),
+  blockedTools: z.array(z.string()).optional(),
+  systemInstructions: z.string(),
+  allowNesting: z.boolean(),
+  maxNestingDepth: z.number().int().positive().optional(),
+  autoExitConditions: z.object({
+    maxTurns: z.number().int().positive().optional(),
+    onToolUse: z.array(z.string()).optional(),
+    onKeywords: z.array(z.string()).optional()
+  }).optional()
+});
+var WRITE_TOOLS = [
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "Bash"
+];
+var DEFAULT_MODE_CONFIG = {
+  name: "default",
+  displayName: "Default",
+  description: "Standard operation mode with all tools available",
+  systemInstructions: "",
+  allowNesting: true,
+  maxNestingDepth: 3
+};
+var PLAN_MODE_CONFIG = {
+  name: "plan",
+  displayName: "Plan Mode",
+  description: "Planning mode - read-only exploration without code modifications",
+  blockedTools: [...WRITE_TOOLS],
+  systemInstructions: `## Plan Mode Active
+
+You are in **Plan Mode**. This mode is for exploration and planning only.
+
+**Restrictions:**
+- You CANNOT use Write, Edit, or Bash tools that modify files
+- Focus on reading, searching, and understanding the codebase
+- Create a comprehensive plan before implementation
+
+**Your Goals:**
+1. Explore the codebase to understand existing patterns
+2. Identify files that need to be modified
+3. Design an implementation approach
+4. Document your plan clearly
+5. Use ExitPlanMode when ready to implement
+
+**Remember:** No code modifications in this mode. Plan first, implement later.`,
+  allowNesting: false,
+  autoExitConditions: {
+    onToolUse: ["ExitPlanMode"]
+  }
+};
+var ITERATE_MODE_CONFIG = {
+  name: "iterate",
+  displayName: "Iterate Mode",
+  description: "Continuous iteration mode for implementation with automatic continuation",
+  systemInstructions: `## Iterate Mode Active
+
+You are in **Iterate Mode**. This mode enables continuous task execution.
+
+**Behavior:**
+- Continue working until the task is complete
+- After each step, assess progress and continue
+- Don't stop to ask for confirmation unless critical
+- Mark todos as completed as you finish them
+
+**Guidelines:**
+1. Work through tasks systematically
+2. Test changes as you go when possible
+3. Update todo list to track progress
+4. Only pause for critical decisions or blockers
+
+**Remember:** Keep iterating until the task is done or you hit a blocker.`,
+  allowNesting: true,
+  maxNestingDepth: 2
+};
+var REVIEW_MODE_CONFIG = {
+  name: "review",
+  displayName: "Review Mode",
+  description: "Code review mode - analyze code quality, security, and best practices",
+  blockedTools: [...WRITE_TOOLS],
+  systemInstructions: `## Review Mode Active
+
+You are in **Review Mode**. This mode is for code review and analysis.
+
+**Focus Areas:**
+- Code quality and readability
+- Security vulnerabilities (OWASP Top 10)
+- Performance issues
+- Best practices and patterns
+- Test coverage gaps
+
+**Output Format:**
+Provide structured feedback:
+1. **Critical Issues** - Must fix before merge
+2. **Warnings** - Should address
+3. **Suggestions** - Nice to have improvements
+4. **Positive Notes** - Good patterns observed
+
+**Remember:** No code modifications. Provide actionable feedback only.`,
+  allowNesting: false
+};
+var WORKFLOW_MODE_CONFIGS = {
+  default: DEFAULT_MODE_CONFIG,
+  plan: PLAN_MODE_CONFIG,
+  iterate: ITERATE_MODE_CONFIG,
+  review: REVIEW_MODE_CONFIG
+};
+function getWorkflowModeConfig(mode) {
+  return WORKFLOW_MODE_CONFIGS[mode];
+}
+function isToolAllowedInMode(tool, mode) {
+  const config = getWorkflowModeConfig(mode);
+  if (config.allowedTools && config.allowedTools.length > 0) {
+    return config.allowedTools.includes(tool);
+  }
+  if (config.blockedTools && config.blockedTools.length > 0) {
+    return !config.blockedTools.includes(tool);
+  }
+  return true;
+}
+function isValidWorkflowMode(mode) {
+  return mode in WORKFLOW_MODE_CONFIGS;
+}
+var WORKFLOW_MODES = WORKFLOW_MODE_CONFIGS;
+
+// src/core/workflow/workflow-mode-manager.ts
+init_esm_shims();
+init_logger();
+var WorkflowModeManager = class {
+  name = "workflow-mode";
+  modeStack = [];
+  transitionListeners = /* @__PURE__ */ new Set();
+  turnCount = 0;
+  constructor(initialMode = "default") {
+    this.modeStack.push({
+      mode: initialMode,
+      enteredAt: Date.now(),
+      enteredAtTurn: 0,
+      reason: "initial"
+    });
+    logger.debug("WorkflowModeManager initialized", {
+      initialMode
+    });
+  }
+  /**
+   * Get the current active mode
+   */
+  getCurrentMode() {
+    const top = this.modeStack[this.modeStack.length - 1];
+    return top?.mode ?? "default";
+  }
+  /**
+   * Get the current mode configuration
+   */
+  getCurrentModeConfig() {
+    const mode = this.getCurrentMode();
+    const entry = this.modeStack[this.modeStack.length - 1];
+    const baseConfig = getWorkflowModeConfig(mode);
+    if (entry?.customConfig) {
+      return {
+        ...baseConfig,
+        ...entry.customConfig,
+        // Deep merge for nested objects
+        autoExitConditions: {
+          ...baseConfig.autoExitConditions,
+          ...entry.customConfig.autoExitConditions
+        }
+      };
+    }
+    return baseConfig;
+  }
+  /**
+   * Get the full mode stack
+   */
+  getModeStack() {
+    return [...this.modeStack];
+  }
+  /**
+   * Get the current stack depth
+   */
+  getStackDepth() {
+    return this.modeStack.length;
+  }
+  /**
+   * Push a new mode onto the stack
+   */
+  pushMode(mode, options) {
+    const currentConfig = this.getCurrentModeConfig();
+    if (!currentConfig.allowNesting) {
+      logger.warn("Cannot push mode: current mode does not allow nesting", {
+        currentMode: this.getCurrentMode(),
+        attemptedMode: mode
+      });
+      return false;
+    }
+    const maxDepth = currentConfig.maxNestingDepth ?? 3;
+    if (this.modeStack.length >= maxDepth) {
+      logger.warn("Cannot push mode: max nesting depth reached", {
+        currentDepth: this.modeStack.length,
+        maxDepth
+      });
+      return false;
+    }
+    const previousMode = this.getCurrentMode();
+    this.modeStack.push({
+      mode,
+      enteredAt: Date.now(),
+      enteredAtTurn: this.turnCount,
+      customConfig: options?.customConfig,
+      reason: options?.reason
+    });
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "push",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Pushed workflow mode", {
+      from: previousMode,
+      to: mode,
+      stackDepth: this.modeStack.length,
+      reason: options?.reason
+    });
+    return true;
+  }
+  /**
+   * Pop the current mode from the stack
+   */
+  popMode(reason) {
+    if (this.modeStack.length <= 1) {
+      logger.warn("Cannot pop mode: at base level");
+      return null;
+    }
+    const popped = this.modeStack.pop();
+    const newMode = this.getCurrentMode();
+    if (popped) {
+      this.emitTransition({
+        from: popped.mode,
+        to: newMode,
+        type: "pop",
+        timestamp: Date.now(),
+        reason
+      });
+      logger.info("Popped workflow mode", {
+        from: popped.mode,
+        to: newMode,
+        stackDepth: this.modeStack.length,
+        reason
+      });
+    }
+    return popped?.mode ?? null;
+  }
+  /**
+   * Replace the current mode (pop then push)
+   */
+  replaceMode(mode, options) {
+    const previousMode = this.getCurrentMode();
+    if (this.modeStack.length === 1) {
+      this.modeStack[0] = {
+        mode,
+        enteredAt: Date.now(),
+        enteredAtTurn: this.turnCount,
+        customConfig: options?.customConfig,
+        reason: options?.reason
+      };
+    } else {
+      this.modeStack.pop();
+      this.modeStack.push({
+        mode,
+        enteredAt: Date.now(),
+        enteredAtTurn: this.turnCount,
+        customConfig: options?.customConfig,
+        reason: options?.reason
+      });
+    }
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "replace",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Replaced workflow mode", {
+      from: previousMode,
+      to: mode,
+      reason: options?.reason
+    });
+    return true;
+  }
+  /**
+   * Set mode directly (clears stack and sets new base mode)
+   */
+  setMode(mode, options) {
+    const previousMode = this.getCurrentMode();
+    this.modeStack = [{
+      mode,
+      enteredAt: Date.now(),
+      enteredAtTurn: this.turnCount,
+      customConfig: options?.customConfig,
+      reason: options?.reason
+    }];
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "replace",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Set workflow mode", {
+      from: previousMode,
+      to: mode,
+      reason: options?.reason
+    });
+  }
+  /**
+   * Check if a tool is allowed in the current mode
+   */
+  isToolAllowed(tool) {
+    return isToolAllowedInMode(tool, this.getCurrentMode());
+  }
+  /**
+   * Get list of blocked tools in current mode
+   */
+  getBlockedTools() {
+    const config = this.getCurrentModeConfig();
+    return config.blockedTools || [];
+  }
+  /**
+   * Filter a list of tools based on current mode
+   */
+  filterTools(tools) {
+    return tools.filter((tool) => this.isToolAllowed(tool.name));
+  }
+  /**
+   * Update turn count (for auto-exit tracking)
+   */
+  updateTurnCount(turn) {
+    this.turnCount = turn;
+    this.checkAutoExit();
+  }
+  /**
+   * Check and handle auto-exit conditions
+   */
+  checkAutoExit() {
+    const config = this.getCurrentModeConfig();
+    const entry = this.modeStack[this.modeStack.length - 1];
+    if (!config.autoExitConditions || !entry) return;
+    if (config.autoExitConditions.maxTurns) {
+      const turnsInMode = this.turnCount - entry.enteredAtTurn;
+      if (turnsInMode >= config.autoExitConditions.maxTurns) {
+        logger.info("Auto-exiting mode due to max turns", {
+          mode: this.getCurrentMode(),
+          turnsInMode,
+          maxTurns: config.autoExitConditions.maxTurns
+        });
+        this.popMode("max_turns_reached");
+      }
+    }
+  }
+  /**
+   * Notify that a tool was used (for auto-exit on tool use)
+   */
+  notifyToolUsed(tool) {
+    const config = this.getCurrentModeConfig();
+    if (config.autoExitConditions?.onToolUse?.includes(tool)) {
+      logger.info("Auto-exiting mode due to tool use", {
+        mode: this.getCurrentMode(),
+        tool
+      });
+      this.popMode(`tool_used:${tool}`);
+    }
+  }
+  /**
+   * Add a mode transition listener
+   */
+  onTransition(listener) {
+    this.transitionListeners.add(listener);
+    return () => this.transitionListeners.delete(listener);
+  }
+  /**
+   * Emit a transition event to all listeners
+   */
+  emitTransition(event) {
+    for (const listener of this.transitionListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        logger.error("Mode transition listener error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  // InstructionProvider implementation
+  /**
+   * Check if mode instructions should be generated
+   */
+  shouldGenerate(context) {
+    return this.getCurrentMode() !== "default";
+  }
+  /**
+   * Get mode-specific instructions
+   */
+  async getInstructions(context) {
+    const config = this.getCurrentModeConfig();
+    const instructions = [];
+    if (config.systemInstructions && config.systemInstructions.length > 0) {
+      instructions.push({
+        type: "mode",
+        priority: "high",
+        content: config.systemInstructions,
+        source: "automatosx",
+        createdAt: Date.now(),
+        id: `mode-${config.name}-${Date.now()}`
+      });
+    }
+    if (config.blockedTools && config.blockedTools.length > 0) {
+      instructions.push({
+        type: "mode",
+        priority: "critical",
+        content: `**Tool Restrictions:** The following tools are NOT available in ${config.displayName}: ${config.blockedTools.join(", ")}`,
+        source: "automatosx",
+        createdAt: Date.now(),
+        id: `mode-blocked-tools-${Date.now()}`
+      });
+    }
+    return instructions;
+  }
+  /**
+   * Reset to default state
+   */
+  reset() {
+    const previousMode = this.getCurrentMode();
+    this.modeStack = [{
+      mode: "default",
+      enteredAt: Date.now(),
+      enteredAtTurn: 0,
+      reason: "reset"
+    }];
+    this.turnCount = 0;
+    if (previousMode !== "default") {
+      this.emitTransition({
+        from: previousMode,
+        to: "default",
+        type: "replace",
+        timestamp: Date.now(),
+        reason: "reset"
+      });
+    }
+    logger.debug("WorkflowModeManager reset");
+  }
+  /**
+   * Get status information for debugging
+   */
+  getStatus() {
+    return {
+      currentMode: this.getCurrentMode(),
+      stackDepth: this.modeStack.length,
+      stack: this.modeStack.map((entry) => ({
+        mode: entry.mode,
+        enteredAt: entry.enteredAt,
+        reason: entry.reason
+      })),
+      blockedTools: this.getBlockedTools(),
+      turnCount: this.turnCount
+    };
+  }
+};
+
+// src/cli/commands/mode.ts
+var modeCommand = {
+  command: "mode [mode]",
+  describe: "Manage workflow modes for embedded instructions (v11.3.0)",
+  builder: (yargs2) => {
+    return yargs2.positional("mode", {
+      describe: "Workflow mode to set (default, plan, iterate, review)",
+      type: "string"
+    }).option("list", {
+      alias: "l",
+      describe: "List available workflow modes",
+      type: "boolean",
+      default: false
+    }).option("status", {
+      alias: "s",
+      describe: "Show current workflow mode status",
+      type: "boolean",
+      default: false
+    }).example("$0 mode plan", "Enter plan mode (restricts code-modifying tools)").example("$0 mode iterate", "Enter iterate mode (for autonomous execution)").example("$0 mode default", "Return to default mode").example("$0 mode --list", "List all available modes").example("$0 mode --status", "Show current mode status");
+  },
+  handler: async (argv) => {
+    try {
+      if (argv.list) {
+        displayModeList();
+        return;
+      }
+      if (argv.status || !argv.mode) {
+        displayModeStatus();
+        return;
+      }
+      const modeName = argv.mode.toLowerCase();
+      if (!isValidWorkflowMode(modeName)) {
+        console.error(chalk5.red.bold(`
+\u274C Invalid workflow mode: ${argv.mode}
+`));
+        console.log(chalk5.gray("Available modes:"));
+        Object.keys(WORKFLOW_MODES).forEach((mode) => {
+          console.log(chalk5.cyan(`  \u2022 ${mode}`));
+        });
+        console.log();
+        process.exit(1);
+      }
+      const modeConfig = WORKFLOW_MODES[modeName];
+      console.log(chalk5.green.bold(`
+\u2705 Workflow mode set to: ${modeName}
+`));
+      console.log(chalk5.gray(`Description: ${modeConfig.description}`));
+      if (modeConfig.blockedTools && modeConfig.blockedTools.length > 0) {
+        console.log(chalk5.yellow("\nRestricted tools in this mode:"));
+        modeConfig.blockedTools.forEach((tool) => {
+          console.log(chalk5.yellow(`  \u2022 ${tool}`));
+        });
+      }
+      if (modeConfig.allowedTools && modeConfig.allowedTools.length > 0) {
+        console.log(chalk5.cyan("\nAllowed tools in this mode:"));
+        modeConfig.allowedTools.forEach((tool) => {
+          console.log(chalk5.cyan(`  \u2022 ${tool}`));
+        });
+      }
+      console.log();
+      console.log(chalk5.gray("Note: Mode setting applies to the current session."));
+      console.log(chalk5.gray("Use with --iterate flag in ax run for persistent mode.\n"));
+      logger.info("Workflow mode set", { mode: modeName });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      logger.error("Mode command failed", { error: err.message });
+      process.exit(1);
+    }
+  }
+};
+function displayModeList() {
+  console.log(chalk5.blue.bold("\n\u{1F4CB} Available Workflow Modes\n"));
+  console.log(chalk5.dim("\u2500".repeat(60)));
+  for (const [name, config] of Object.entries(WORKFLOW_MODES)) {
+    console.log();
+    console.log(chalk5.cyan.bold(`  ${name}`));
+    console.log(chalk5.gray(`    ${config.description}`));
+    if (config.blockedTools && config.blockedTools.length > 0) {
+      console.log(chalk5.yellow(`    Blocked: ${config.blockedTools.join(", ")}`));
+    }
+    if (config.maxNestingDepth !== void 0) {
+      console.log(chalk5.gray(`    Max nesting depth: ${config.maxNestingDepth}`));
+    }
+  }
+  console.log();
+  console.log(chalk5.dim("\u2500".repeat(60)));
+  console.log(chalk5.gray("\nUsage: ax mode <mode-name>"));
+  console.log(chalk5.gray("Example: ax mode plan\n"));
+}
+function displayModeStatus() {
+  const currentMode = "default";
+  const modeConfig = WORKFLOW_MODES[currentMode];
+  console.log(chalk5.blue.bold("\n\u{1F4CA} Workflow Mode Status\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log(`  Current mode: ${chalk5.cyan.bold(currentMode)}`);
+  console.log(`  Description: ${chalk5.gray(modeConfig.description)}`);
+  if (modeConfig.blockedTools && modeConfig.blockedTools.length > 0) {
+    console.log(`  Blocked tools: ${chalk5.yellow(modeConfig.blockedTools.length)}`);
+  } else {
+    console.log(`  Blocked tools: ${chalk5.green("none")}`);
+  }
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log();
+  console.log(chalk5.gray("To change mode: ax mode <mode-name>"));
+  console.log(chalk5.gray("To list modes: ax mode --list\n"));
+}
+
+// src/cli/commands/debug-instructions.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/orchestration-service.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/types.ts
+init_esm_shims();
+z.object({
+  type: z.enum(["task", "memory", "session", "delegation", "mode"]),
+  priority: z.enum(["critical", "high", "normal", "low"]),
+  content: z.string().min(1).max(5e3),
+  source: z.literal("automatosx"),
+  expiresAfter: z.number().int().positive().optional(),
+  createdAt: z.number(),
+  id: z.string().optional()
+});
+var TodoItemSchema = z.object({
+  id: z.string(),
+  content: z.string().min(1).max(1e3),
+  status: z.enum(["pending", "in_progress", "completed"]),
+  activeForm: z.string().min(1).max(1e3),
+  createdAt: z.number(),
+  updatedAt: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  name: z.enum(["default", "plan", "iterate", "review"]),
+  description: z.string(),
+  allowedTools: z.array(z.string()).optional(),
+  blockedTools: z.array(z.string()).optional(),
+  systemInstructions: z.string(),
+  allowNesting: z.boolean()
+});
+z.object({
+  todos: z.array(TodoItemSchema),
+  currentTask: z.string().optional(),
+  agentName: z.string().optional(),
+  turnCount: z.number().int().nonnegative(),
+  workflowMode: z.enum(["default", "plan", "iterate", "review"]),
+  sessionId: z.string().optional(),
+  parentAgent: z.string().optional(),
+  memories: z.array(z.object({
+    content: z.string(),
+    relevance: z.number().min(0).max(1),
+    agent: z.string().optional(),
+    timestamp: z.number()
+  })).optional()
+});
+var DEFAULT_TOKEN_BUDGET = {
+  maxTotal: 2e3,
+  perType: {
+    task: 500,
+    memory: 600,
+    session: 300,
+    delegation: 200,
+    mode: 400
+  },
+  criticalReserve: 300
+};
+var TokenBudgetConfigSchema = z.object({
+  maxTotal: z.number().int().positive().max(1e4),
+  perType: z.record(
+    z.enum(["task", "memory", "session", "delegation", "mode"]),
+    z.number().int().nonnegative()
+  ),
+  criticalReserve: z.number().int().nonnegative()
+});
+var DEFAULT_ORCHESTRATION_CONFIG = {
+  enabled: true,
+  tokenBudget: DEFAULT_TOKEN_BUDGET,
+  todoIntegration: {
+    enabled: true,
+    reminderFrequency: 3,
+    compactMode: false
+  },
+  memoryIntegration: {
+    enabled: true,
+    maxEntries: 5,
+    minRelevance: 0.5
+  },
+  sessionIntegration: {
+    enabled: true,
+    showCollaboration: true
+  },
+  agentTemplates: {
+    enabled: true,
+    reminderFrequency: 5
+  }
+};
+z.object({
+  enabled: z.boolean(),
+  tokenBudget: TokenBudgetConfigSchema,
+  todoIntegration: z.object({
+    enabled: z.boolean(),
+    reminderFrequency: z.number().int().positive(),
+    compactMode: z.boolean()
+  }),
+  memoryIntegration: z.object({
+    enabled: z.boolean(),
+    maxEntries: z.number().int().nonnegative(),
+    minRelevance: z.number().min(0).max(1)
+  }),
+  sessionIntegration: z.object({
+    enabled: z.boolean(),
+    showCollaboration: z.boolean()
+  }),
+  agentTemplates: z.object({
+    enabled: z.boolean(),
+    reminderFrequency: z.number().int().positive()
+  })
+});
+
+// src/core/orchestration/instruction-injector.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/token-budget.ts
+init_esm_shims();
+init_logger();
+var TokenBudgetManager = class _TokenBudgetManager {
+  config;
+  /** Characters per token estimate (conservative) */
+  static CHARS_PER_TOKEN = 4;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_TOKEN_BUDGET,
+      ...config,
+      perType: {
+        ...DEFAULT_TOKEN_BUDGET.perType,
+        ...config?.perType
+      }
+    };
+    logger.debug("TokenBudgetManager initialized", {
+      maxTotal: this.config.maxTotal,
+      criticalReserve: this.config.criticalReserve
+    });
+  }
+  /**
+   * Estimate tokens for a string
+   */
+  estimateTokens(content) {
+    const characters = content.length;
+    const tokens = Math.ceil(characters / _TokenBudgetManager.CHARS_PER_TOKEN);
+    return {
+      tokens,
+      characters,
+      isEstimate: true
+    };
+  }
+  /**
+   * Estimate tokens for an instruction (including formatting overhead)
+   */
+  estimateInstructionTokens(instruction) {
+    const overhead = 50;
+    const contentTokens = this.estimateTokens(instruction.content).tokens;
+    return contentTokens + overhead;
+  }
+  /**
+   * Allocate budget for instructions
+   *
+   * Priority order:
+   * 1. Critical instructions (always included, use reserve)
+   * 2. High priority (included if budget allows)
+   * 3. Normal priority (included if budget allows)
+   * 4. Low priority (only if significant budget remains)
+   */
+  allocateBudget(instructions) {
+    const included = [];
+    const excluded = [];
+    const perTypeUsage = {
+      task: 0,
+      memory: 0,
+      session: 0,
+      delegation: 0,
+      mode: 0
+    };
+    let tokensUsed = 0;
+    const availableBudget = this.config.maxTotal;
+    const priorityOrder = {
+      critical: 0,
+      high: 1,
+      normal: 2,
+      low: 3
+    };
+    const sorted = [...instructions].sort((a, b) => {
+      const aPriority = priorityOrder[a.priority] ?? 2;
+      const bPriority = priorityOrder[b.priority] ?? 2;
+      const priorityDiff = aPriority - bPriority;
+      if (priorityDiff !== 0) return priorityDiff;
+      return a.createdAt - b.createdAt;
+    });
+    for (const instruction of sorted) {
+      const instructionTokens = this.estimateInstructionTokens(instruction);
+      const typeLimit = this.config.perType[instruction.type] || 0;
+      const currentTypeUsage = perTypeUsage[instruction.type] || 0;
+      const wouldExceedTotal = tokensUsed + instructionTokens > availableBudget;
+      const wouldExceedTypeLimit = currentTypeUsage + instructionTokens > typeLimit;
+      if (instruction.priority === "critical") {
+        const criticalBudget = availableBudget + this.config.criticalReserve;
+        if (tokensUsed + instructionTokens <= criticalBudget) {
+          included.push(instruction);
+          tokensUsed += instructionTokens;
+          perTypeUsage[instruction.type] = currentTypeUsage + instructionTokens;
+          continue;
+        }
+      }
+      if (!wouldExceedTotal && !wouldExceedTypeLimit) {
+        included.push(instruction);
+        tokensUsed += instructionTokens;
+        perTypeUsage[instruction.type] = currentTypeUsage + instructionTokens;
+      } else {
+        excluded.push(instruction);
+        logger.debug("Instruction excluded from budget", {
+          type: instruction.type,
+          priority: instruction.priority,
+          tokens: instructionTokens,
+          reason: wouldExceedTotal ? "total_limit" : "type_limit"
+        });
+      }
+    }
+    const result = {
+      included,
+      excluded,
+      tokensUsed,
+      remaining: availableBudget - tokensUsed,
+      perTypeUsage
+    };
+    logger.debug("Budget allocation complete", {
+      included: included.length,
+      excluded: excluded.length,
+      tokensUsed,
+      remaining: result.remaining
+    });
+    return result;
+  }
+  /**
+   * Check if an instruction fits within budget
+   */
+  fitsInBudget(instruction, currentUsage, typeUsage) {
+    const instructionTokens = this.estimateInstructionTokens(instruction);
+    const typeLimit = this.config.perType[instruction.type] || 0;
+    const currentTypeUsage = typeUsage[instruction.type] || 0;
+    if (instruction.priority === "critical") {
+      return currentUsage + instructionTokens <= this.config.maxTotal + this.config.criticalReserve;
+    }
+    return currentUsage + instructionTokens <= this.config.maxTotal && currentTypeUsage + instructionTokens <= typeLimit;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates,
+      perType: {
+        ...this.config.perType,
+        ...updates.perType
+      }
+    };
+    logger.debug("TokenBudgetManager config updated", {
+      maxTotal: this.config.maxTotal
+    });
+  }
+  /**
+   * Get remaining budget for a specific type
+   */
+  getRemainingTypeBudget(type, currentTypeUsage) {
+    const limit = this.config.perType[type] || 0;
+    const used = currentTypeUsage[type] || 0;
+    return Math.max(0, limit - used);
+  }
+  /**
+   * Format budget status for debugging
+   */
+  formatBudgetStatus(allocation) {
+    const lines = [
+      `Token Budget Status:`,
+      `  Total: ${allocation.tokensUsed}/${this.config.maxTotal} (${allocation.remaining} remaining)`,
+      `  Per-Type Usage:`
+    ];
+    for (const [type, used] of Object.entries(allocation.perTypeUsage)) {
+      const limit = this.config.perType[type] || 0;
+      lines.push(`    ${type}: ${used}/${limit}`);
+    }
+    if (allocation.excluded.length > 0) {
+      lines.push(`  Excluded: ${allocation.excluded.length} instruction(s)`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/core/orchestration/instruction-injector.ts
+var OrchestrationInstructionInjector = class {
+  providers = /* @__PURE__ */ new Map();
+  budgetManager;
+  config;
+  lastInjectionTime = 0;
+  instructionCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_ORCHESTRATION_CONFIG,
+      ...config
+    };
+    this.budgetManager = new TokenBudgetManager(this.config.tokenBudget);
+    logger.debug("OrchestrationInstructionInjector initialized", {
+      enabled: this.config.enabled,
+      providers: this.providers.size
+    });
+  }
+  /**
+   * Register an instruction provider
+   */
+  registerProvider(provider) {
+    if (this.providers.has(provider.name)) {
+      logger.warn("Provider already registered, replacing", {
+        name: provider.name
+      });
+    }
+    this.providers.set(provider.name, provider);
+    logger.debug("Instruction provider registered", {
+      name: provider.name,
+      totalProviders: this.providers.size
+    });
+  }
+  /**
+   * Unregister an instruction provider
+   */
+  unregisterProvider(name) {
+    const removed = this.providers.delete(name);
+    if (removed) {
+      logger.debug("Instruction provider unregistered", { name });
+    }
+    return removed;
+  }
+  /**
+   * Get all registered providers
+   */
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Generate and inject instructions based on context
+   */
+  async inject(context, options = {}) {
+    if (!this.config.enabled) {
+      return this.emptyResult();
+    }
+    const startTime = Date.now();
+    const allInstructions = [];
+    for (const provider of this.providers.values()) {
+      try {
+        if (!provider.shouldGenerate(context)) {
+          continue;
+        }
+        const instructions = await provider.getInstructions(context);
+        let filtered = instructions;
+        if (options.includeTypes) {
+          filtered = filtered.filter((i) => options.includeTypes.includes(i.type));
+        }
+        if (options.excludeTypes) {
+          filtered = filtered.filter((i) => !options.excludeTypes.includes(i.type));
+        }
+        allInstructions.push(...filtered);
+      } catch (error) {
+        logger.error("Provider failed to generate instructions", {
+          provider: provider.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const activeInstructions = this.filterExpiredInstructions(
+      allInstructions,
+      context.turnCount
+    );
+    let allocation;
+    if (options.skipBudget) {
+      allocation = {
+        included: activeInstructions,
+        excluded: [],
+        tokensUsed: activeInstructions.reduce(
+          (sum, i) => sum + this.budgetManager.estimateInstructionTokens(i),
+          0
+        ),
+        remaining: 0,
+        perTypeUsage: this.calculateTypeUsage(activeInstructions)
+      };
+    } else {
+      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,
+      instructionsGenerated: allInstructions.length,
+      instructionsIncluded: allocation.included.length,
+      tokensUsed: allocation.tokensUsed,
+      durationMs: duration
+    });
+    return {
+      formattedText,
+      instructions: allocation.included,
+      allocation,
+      hasInstructions: allocation.included.length > 0
+    };
+  }
+  /**
+   * Format instructions as system reminder tags
+   */
+  formatInstructions(instructions) {
+    if (instructions.length === 0) {
+      return "";
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const instruction of instructions) {
+      const existing = grouped.get(instruction.type) || [];
+      existing.push(instruction);
+      grouped.set(instruction.type, existing);
+    }
+    const parts = [];
+    const typeOrder = ["mode", "task", "memory", "session", "delegation"];
+    for (const type of typeOrder) {
+      const typeInstructions = grouped.get(type);
+      if (!typeInstructions || typeInstructions.length === 0) continue;
+      for (const instruction of typeInstructions) {
+        parts.push(this.formatSingleInstruction(instruction));
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Format a single instruction as a system reminder
+   */
+  formatSingleInstruction(instruction) {
+    return `<system-reminder>
+${instruction.content}
+</system-reminder>`;
+  }
+  /**
+   * Filter out expired instructions
+   */
+  filterExpiredInstructions(instructions, currentTurn) {
+    return instructions.filter((instruction) => {
+      if (instruction.expiresAfter === void 0) {
+        return true;
+      }
+      const turnsSinceCreation = currentTurn;
+      return turnsSinceCreation < instruction.expiresAfter;
+    });
+  }
+  /**
+   * Calculate per-type token usage
+   */
+  calculateTypeUsage(instructions) {
+    const usage = {
+      task: 0,
+      memory: 0,
+      session: 0,
+      delegation: 0,
+      mode: 0
+    };
+    for (const instruction of instructions) {
+      const tokens = this.budgetManager.estimateInstructionTokens(instruction);
+      usage[instruction.type] = (usage[instruction.type] || 0) + tokens;
+    }
+    return usage;
+  }
+  /**
+   * Create an empty result
+   */
+  emptyResult() {
+    return {
+      formattedText: "",
+      instructions: [],
+      allocation: {
+        included: [],
+        excluded: [],
+        tokensUsed: 0,
+        remaining: this.budgetManager.getConfig().maxTotal,
+        perTypeUsage: {
+          task: 0,
+          memory: 0,
+          session: 0,
+          delegation: 0,
+          mode: 0
+        }
+      },
+      hasInstructions: false
+    };
+  }
+  /**
+   * Clear instruction cache
+   */
+  clearCache() {
+    this.instructionCache.clear();
+    logger.debug("Instruction cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.tokenBudget) {
+      this.budgetManager.updateConfig(updates.tokenBudget);
+    }
+    logger.debug("OrchestrationInstructionInjector config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Get budget manager for direct access
+   */
+  getBudgetManager() {
+    return this.budgetManager;
+  }
+  /**
+   * Check if orchestration is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Enable or disable orchestration
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+    logger.debug("Orchestration enabled state changed", { enabled });
+  }
+};
+
+// src/core/orchestration/todo-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_TODO_CONFIG = {
+  enabled: true,
+  reminderFrequency: 3,
+  compactMode: false,
+  maxCompactItems: 5,
+  showCompleted: false
+};
+var TodoInstructionProvider = class {
+  name = "todo";
+  config;
+  lastStateHash = "";
+  lastReminderTurn = 0;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_TODO_CONFIG,
+      ...config
+    };
+    logger.debug("TodoInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      reminderFrequency: this.config.reminderFrequency
+    });
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!context.todos || context.todos.length === 0) {
+      return false;
+    }
+    const currentHash = this.computeStateHash(context.todos);
+    const stateChanged = currentHash !== this.lastStateHash;
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const reminderDue = turnsSinceReminder >= this.config.reminderFrequency;
+    return stateChanged || reminderDue;
+  }
+  /**
+   * Generate instructions based on todo state
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    if (!context.todos || context.todos.length === 0) {
+      return instructions;
+    }
+    const currentHash = this.computeStateHash(context.todos);
+    const stateChanged = currentHash !== this.lastStateHash;
+    const activeTodos = context.todos.filter(
+      (todo) => todo.status !== "completed" || this.config.showCompleted
+    );
+    const inProgressTasks = activeTodos.filter((todo) => todo.status === "in_progress");
+    const pendingTasks = activeTodos.filter((todo) => todo.status === "pending");
+    const completedTasks = context.todos.filter((todo) => todo.status === "completed");
+    let content;
+    let priority;
+    if (stateChanged) {
+      content = this.formatFullTodoList(inProgressTasks, pendingTasks, completedTasks);
+      priority = "high";
+    } else if (this.config.compactMode) {
+      content = this.formatCompactReminder(inProgressTasks, pendingTasks);
+      priority = "normal";
+    } else {
+      content = this.formatStandardReminder(inProgressTasks, pendingTasks);
+      priority = "normal";
+    }
+    instructions.push({
+      type: "task",
+      priority,
+      content,
+      source: "automatosx",
+      createdAt: Date.now(),
+      expiresAfter: this.config.reminderFrequency + 1,
+      id: `todo-${currentHash.substring(0, 8)}`
+    });
+    this.lastStateHash = currentHash;
+    this.lastReminderTurn = context.turnCount;
+    logger.debug("Todo instructions generated", {
+      inProgress: inProgressTasks.length,
+      pending: pendingTasks.length,
+      completed: completedTasks.length,
+      stateChanged
+    });
+    return instructions;
+  }
+  /**
+   * Format full todo list (used when state changes)
+   */
+  formatFullTodoList(inProgress, pending, completed) {
+    const lines = [
+      "## Current Task List"
+    ];
+    if (inProgress.length > 0) {
+      lines.push("");
+      lines.push("### Currently Working On:");
+      for (const task of inProgress) {
+        lines.push(`- **${task.activeForm}**`);
+      }
+    }
+    if (pending.length > 0) {
+      lines.push("");
+      lines.push("### Pending Tasks:");
+      for (const task of pending) {
+        lines.push(`- [ ] ${task.content}`);
+      }
+    }
+    if (this.config.showCompleted && completed.length > 0) {
+      lines.push("");
+      lines.push("### Completed:");
+      for (const task of completed.slice(-3)) {
+        lines.push(`- [x] ${task.content}`);
+      }
+    }
+    lines.push("");
+    lines.push("**Remember:** Complete the current in-progress task before starting new ones.");
+    lines.push("Mark tasks as completed as soon as they are done.");
+    return lines.join("\n");
+  }
+  /**
+   * Format standard reminder
+   */
+  formatStandardReminder(inProgress, pending) {
+    const lines = [];
+    if (inProgress.length > 0) {
+      lines.push(`**Current Task:** ${inProgress[0].activeForm}`);
+    }
+    if (pending.length > 0) {
+      lines.push(`**Next:** ${pending[0].content}`);
+      if (pending.length > 1) {
+        lines.push(`(${pending.length - 1} more tasks pending)`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format compact reminder (minimal tokens)
+   */
+  formatCompactReminder(inProgress, pending) {
+    const parts = [];
+    if (inProgress.length > 0) {
+      parts.push(`Doing: ${inProgress[0].activeForm}`);
+    }
+    if (pending.length > 0) {
+      const count = Math.min(pending.length, this.config.maxCompactItems);
+      parts.push(`Next: ${pending.slice(0, count).map((t) => t.content).join(", ")}`);
+    }
+    return parts.join(" | ");
+  }
+  /**
+   * Compute hash of todo state for change detection
+   */
+  computeStateHash(todos) {
+    const stateString = todos.map((t) => `${t.id}:${t.status}:${t.content}`).sort().join("|");
+    return crypto2.createHash("sha256").update(stateString).digest("hex").substring(0, 16);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("TodoInstructionProvider config updated", {
+      enabled: this.config.enabled,
+      compactMode: this.config.compactMode
+    });
+  }
+  /**
+   * Reset state tracking (useful for testing)
+   */
+  reset() {
+    this.lastStateHash = "";
+    this.lastReminderTurn = 0;
+    logger.debug("TodoInstructionProvider state reset");
+  }
+};
+
+// src/core/orchestration/memory-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: true,
+  maxEntries: 5,
+  minRelevance: 0.5,
+  searchFrequency: 3,
+  maxAge: 0,
+  // No limit by default
+  includeMetadata: true,
+  cacheTTL: 6e4
+  // 1 minute
+};
+var MemoryInstructionProvider = class {
+  name = "memory";
+  config;
+  searchProvider;
+  cache;
+  lastSearchTurn = 0;
+  constructor(searchProvider, config) {
+    this.config = {
+      ...DEFAULT_MEMORY_CONFIG,
+      ...config
+    };
+    this.searchProvider = searchProvider;
+    logger.debug("MemoryInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      maxEntries: this.config.maxEntries,
+      hasSearchProvider: !!searchProvider
+    });
+  }
+  /**
+   * Set the memory search provider
+   */
+  setSearchProvider(provider) {
+    this.searchProvider = provider;
+    this.clearCache();
+    logger.debug("Memory search provider set");
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!this.searchProvider) {
+      return false;
+    }
+    if (!context.currentTask && context.todos.length === 0) {
+      return false;
+    }
+    const turnsSinceSearch = context.turnCount - this.lastSearchTurn;
+    const searchDue = turnsSinceSearch >= this.config.searchFrequency;
+    const cacheValid = this.cache && Date.now() - this.cache.timestamp < this.config.cacheTTL;
+    return searchDue || !cacheValid;
+  }
+  /**
+   * Generate instructions based on relevant memories
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    if (!this.searchProvider) {
+      return instructions;
+    }
+    const searchQuery = this.buildSearchQuery(context);
+    if (!searchQuery) {
+      return instructions;
+    }
+    try {
+      const memories = await this.searchMemories(searchQuery, context);
+      if (memories.length === 0) {
+        return instructions;
+      }
+      this.lastSearchTurn = context.turnCount;
+      const content = this.formatMemories(memories);
+      instructions.push({
+        type: "memory",
+        priority: "normal",
+        content,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.searchFrequency + 1,
+        id: `memory-${Date.now()}`
+      });
+      logger.debug("Memory instructions generated", {
+        memoriesFound: memories.length,
+        query: searchQuery.substring(0, 50)
+      });
+    } catch (error) {
+      logger.error("Failed to search memories", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return instructions;
+  }
+  /**
+   * Build search query from context
+   */
+  buildSearchQuery(context) {
+    const parts = [];
+    if (context.currentTask) {
+      parts.push(context.currentTask);
+    }
+    const inProgressTodos = context.todos.filter((t) => t.status === "in_progress");
+    for (const todo of inProgressTodos.slice(0, 2)) {
+      parts.push(todo.content);
+    }
+    if (context.agentName) {
+      parts.push(context.agentName);
+    }
+    if (parts.length === 0) {
+      return null;
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Search for relevant memories
+   */
+  async searchMemories(query, context) {
+    if (!this.searchProvider) {
+      return [];
+    }
+    if (this.cache && this.cache.query === query) {
+      const age = Date.now() - this.cache.timestamp;
+      if (age < this.config.cacheTTL) {
+        logger.debug("Using cached memory results", {
+          cacheAge: age,
+          resultCount: this.cache.results.length
+        });
+        return this.cache.results;
+      }
+    }
+    const results = await this.searchProvider.search({
+      text: query,
+      limit: this.config.maxEntries * 2,
+      // Get extra in case some are filtered
+      filters: context.agentName ? { agentId: context.agentName } : void 0
+    });
+    const filtered = results.filter((r) => r.score >= this.config.minRelevance).filter((r) => this.isWithinMaxAge(r.createdAt)).slice(0, this.config.maxEntries);
+    const memories = filtered.map((r) => ({
+      content: r.content,
+      relevance: r.score,
+      agent: r.metadata?.agentId,
+      timestamp: r.createdAt.getTime()
+    }));
+    this.cache = {
+      query,
+      results: memories,
+      timestamp: Date.now()
+    };
+    return memories;
+  }
+  /**
+   * Check if memory is within max age limit
+   */
+  isWithinMaxAge(createdAt) {
+    if (this.config.maxAge === 0) {
+      return true;
+    }
+    const age = Date.now() - createdAt.getTime();
+    return age <= this.config.maxAge;
+  }
+  /**
+   * Format memories into instruction content
+   */
+  formatMemories(memories) {
+    const lines = [
+      "## Relevant Context from Memory",
+      ""
+    ];
+    for (let i = 0; i < memories.length; i++) {
+      const memory = memories[i];
+      if (!memory) continue;
+      const relevancePercent = Math.round(memory.relevance * 100);
+      if (this.config.includeMetadata && memory.agent) {
+        lines.push(`### Memory ${i + 1} (${relevancePercent}% relevant, from ${memory.agent})`);
+      } else {
+        lines.push(`### Memory ${i + 1} (${relevancePercent}% relevant)`);
+      }
+      const maxLength = 500;
+      const content = memory.content.length > maxLength ? memory.content.substring(0, maxLength) + "..." : memory.content;
+      lines.push(content);
+      lines.push("");
+    }
+    lines.push("**Note:** Use this context to inform your decisions, but verify current state.");
+    return lines.join("\n");
+  }
+  /**
+   * Clear the memory cache
+   */
+  clearCache() {
+    this.cache = void 0;
+    logger.debug("Memory cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.minRelevance !== void 0 || updates.maxEntries !== void 0) {
+      this.clearCache();
+    }
+    logger.debug("MemoryInstructionProvider config updated", {
+      enabled: this.config.enabled,
+      maxEntries: this.config.maxEntries
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.cache = void 0;
+    this.lastSearchTurn = 0;
+    logger.debug("MemoryInstructionProvider reset");
+  }
+  /**
+   * Check if search provider is configured
+   */
+  hasSearchProvider() {
+    return !!this.searchProvider;
+  }
+};
+
+// src/core/orchestration/session-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_SESSION_CONFIG = {
+  enabled: true,
+  showCollaboration: true,
+  showProgress: true,
+  reminderFrequency: 5,
+  showHandoffContext: true
+};
+var SessionInstructionProvider = class {
+  name = "session";
+  config;
+  stateProvider;
+  lastReminderTurn = 0;
+  cachedState;
+  cacheExpiry = 0;
+  CACHE_TTL = 3e4;
+  // 30 seconds
+  constructor(stateProvider, config) {
+    this.config = {
+      ...DEFAULT_SESSION_CONFIG,
+      ...config
+    };
+    this.stateProvider = stateProvider;
+    logger.debug("SessionInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      hasStateProvider: !!stateProvider
+    });
+  }
+  /**
+   * Set the session state provider
+   */
+  setStateProvider(provider) {
+    this.stateProvider = provider;
+    this.clearCache();
+    logger.debug("Session state provider set");
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!context.sessionId && !this.stateProvider) {
+      return false;
+    }
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    return turnsSinceReminder >= this.config.reminderFrequency;
+  }
+  /**
+   * Generate instructions based on session state
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    const state = await this.getSessionState(context);
+    if (!state && !context.sessionId) {
+      return instructions;
+    }
+    const content = this.formatSessionContext(context, state);
+    if (content) {
+      instructions.push({
+        type: "session",
+        priority: "normal",
+        content,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.reminderFrequency,
+        id: `session-${context.sessionId || "default"}-${Date.now()}`
+      });
+    }
+    this.lastReminderTurn = context.turnCount;
+    logger.debug("Session instructions generated", {
+      sessionId: context.sessionId,
+      hasState: !!state
+    });
+    return instructions;
+  }
+  /**
+   * Get session state from provider or cache
+   */
+  async getSessionState(context) {
+    if (!context.sessionId) {
+      return null;
+    }
+    if (this.cachedState && this.cachedState.id === context.sessionId && Date.now() < this.cacheExpiry) {
+      return this.cachedState;
+    }
+    if (!this.stateProvider) {
+      return null;
+    }
+    try {
+      const state = await this.stateProvider.getSessionState(context.sessionId);
+      if (state) {
+        this.cachedState = state;
+        this.cacheExpiry = Date.now() + this.CACHE_TTL;
+      }
+      return state;
+    } catch (error) {
+      logger.error("Failed to get session state", {
+        sessionId: context.sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Format session context into instruction content
+   */
+  formatSessionContext(context, state) {
+    const lines = [];
+    if (context.sessionId) {
+      lines.push("## Session Context");
+      lines.push("");
+    }
+    if (this.config.showCollaboration && state && state.participants.length > 1) {
+      lines.push("### Multi-Agent Collaboration");
+      lines.push(`- **Session:** ${state.id.substring(0, 8)}...`);
+      lines.push(`- **Participants:** ${state.participants.join(", ")}`);
+      if (state.activeAgent) {
+        lines.push(`- **Currently Active:** ${state.activeAgent}`);
+      }
+      lines.push("");
+    }
+    if (this.config.showProgress && state) {
+      const totalTasks = state.completedTasks + state.remainingTasks;
+      if (totalTasks > 0) {
+        const progress = Math.round(state.completedTasks / totalTasks * 100);
+        lines.push("### Session Progress");
+        lines.push(`- Completed: ${state.completedTasks}/${totalTasks} (${progress}%)`);
+        if (state.remainingTasks > 0) {
+          lines.push(`- Remaining: ${state.remainingTasks} task(s)`);
+        }
+        lines.push("");
+      }
+    }
+    if (this.config.showHandoffContext && context.parentAgent) {
+      lines.push("### Delegation Context");
+      lines.push(`- **Delegated from:** ${context.parentAgent}`);
+      if (context.currentTask) {
+        lines.push(`- **Task:** ${context.currentTask}`);
+      }
+      lines.push("");
+      lines.push("**Note:** Complete this task and return control to the parent agent.");
+      lines.push("");
+    }
+    if (context.agentName && !context.parentAgent) {
+      lines.push(`**Current Agent:** ${context.agentName}`);
+      lines.push("");
+    }
+    if (lines.length <= 2) {
+      return null;
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Clear cached state
+   */
+  clearCache() {
+    this.cachedState = void 0;
+    this.cacheExpiry = 0;
+    logger.debug("Session cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("SessionInstructionProvider config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.lastReminderTurn = 0;
+    this.clearCache();
+    logger.debug("SessionInstructionProvider reset");
+  }
+  /**
+   * Check if state provider is configured
+   */
+  hasStateProvider() {
+    return !!this.stateProvider;
+  }
+};
+
+// src/agents/agent-instruction-injector.ts
+init_esm_shims();
+init_logger();
+
+// src/agents/instruction-templates.ts
+init_esm_shims();
+var BACKEND_TEMPLATE = {
+  domain: "backend",
+  displayName: "Backend Engineer",
+  domainReminders: [
+    "Follow RESTful API design principles",
+    "Use proper HTTP status codes",
+    "Implement input validation at API boundaries",
+    "Consider database query performance",
+    "Handle errors gracefully with meaningful messages"
+  ],
+  qualityChecklist: [
+    "API endpoints follow REST conventions",
+    "Database queries are optimized (no N+1)",
+    "Input is validated before processing",
+    "Errors are logged with context",
+    "Sensitive data is not exposed in responses"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["security", "authentication", "authorization", "OWASP", "vulnerability"],
+      suggestedAgent: "security",
+      reason: "Security-related tasks benefit from specialized security review"
+    },
+    {
+      keywords: ["frontend", "UI", "React", "CSS", "component"],
+      suggestedAgent: "frontend",
+      reason: "Frontend implementation should be handled by frontend specialist"
+    },
+    {
+      keywords: ["test", "testing", "unit test", "integration test"],
+      suggestedAgent: "quality",
+      reason: "Testing strategy benefits from QA expertise"
+    }
+  ],
+  antiPatterns: [
+    "Avoid SQL injection by using parameterized queries",
+    "Don't expose internal error details to clients",
+    "Avoid synchronous blocking operations",
+    "Don't hardcode configuration values"
+  ],
+  bestPractices: [
+    "Use prepared statements for database queries",
+    "Implement proper logging with correlation IDs",
+    "Use dependency injection for testability",
+    "Follow the principle of least privilege"
+  ]
+};
+var FRONTEND_TEMPLATE = {
+  domain: "frontend",
+  displayName: "Frontend Engineer",
+  domainReminders: [
+    "Ensure accessibility (WCAG compliance)",
+    "Optimize for performance (Core Web Vitals)",
+    "Handle loading and error states",
+    "Implement responsive design",
+    "Consider keyboard navigation"
+  ],
+  qualityChecklist: [
+    "Components are accessible (ARIA labels, roles)",
+    "Loading states are handled",
+    "Error boundaries catch failures gracefully",
+    "Forms have proper validation feedback",
+    "Images have alt text"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["API", "endpoint", "database", "backend", "server"],
+      suggestedAgent: "backend",
+      reason: "Backend changes should be handled by backend specialist"
+    },
+    {
+      keywords: ["security", "XSS", "CSRF", "sanitize"],
+      suggestedAgent: "security",
+      reason: "Security concerns require specialized review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid inline styles for reusable components",
+    "Don't mutate state directly",
+    "Avoid excessive re-renders",
+    "Don't ignore accessibility requirements"
+  ],
+  bestPractices: [
+    "Use semantic HTML elements",
+    "Implement proper form validation",
+    "Optimize bundle size",
+    "Use React.memo for expensive components"
+  ]
+};
+var SECURITY_TEMPLATE = {
+  domain: "security",
+  displayName: "Security Engineer",
+  domainReminders: [
+    "Apply OWASP Top 10 security guidelines",
+    "Validate and sanitize ALL user input",
+    "Use parameterized queries to prevent SQL injection",
+    "Implement proper authentication and authorization",
+    "Never expose sensitive data in logs or responses"
+  ],
+  qualityChecklist: [
+    "Input validation is present at all entry points",
+    "Authentication tokens are handled securely",
+    "Sensitive data is encrypted at rest and in transit",
+    "Error messages don't leak implementation details",
+    "Dependencies are checked for known vulnerabilities"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["performance", "optimization", "speed", "latency"],
+      suggestedAgent: "backend",
+      reason: "Performance optimization is a backend concern"
+    }
+  ],
+  antiPatterns: [
+    "Never trust user input without validation",
+    "Don't store passwords in plain text",
+    "Avoid security through obscurity",
+    "Don't disable security features for convenience"
+  ],
+  bestPractices: [
+    "Follow the principle of least privilege",
+    "Implement defense in depth",
+    "Use secure defaults",
+    "Fail securely (deny by default)"
+  ]
+};
+var QUALITY_TEMPLATE = {
+  domain: "quality",
+  displayName: "Quality Assurance Engineer",
+  domainReminders: [
+    "Write tests that verify behavior, not implementation",
+    "Cover edge cases and error scenarios",
+    "Ensure test isolation (no shared state)",
+    "Use meaningful test descriptions",
+    "Follow the Arrange-Act-Assert pattern"
+  ],
+  qualityChecklist: [
+    "Unit tests cover critical paths",
+    "Integration tests verify component interactions",
+    "Edge cases are tested",
+    "Error handling is verified",
+    "Tests are maintainable and readable"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "build", "create", "develop"],
+      suggestedAgent: "backend",
+      reason: "Implementation tasks should go to domain specialists"
+    },
+    {
+      keywords: ["security", "vulnerability", "penetration"],
+      suggestedAgent: "security",
+      reason: "Security testing requires specialized expertise"
+    }
+  ],
+  antiPatterns: [
+    "Avoid testing implementation details",
+    "Don't use flaky tests",
+    "Avoid excessive mocking",
+    "Don't ignore failing tests"
+  ],
+  bestPractices: [
+    "Test behavior, not implementation",
+    "Use descriptive test names",
+    "Keep tests independent",
+    "Follow the testing pyramid"
+  ]
+};
+var ARCHITECTURE_TEMPLATE = {
+  domain: "architecture",
+  displayName: "Software Architect",
+  domainReminders: [
+    "Consider scalability implications",
+    "Document architectural decisions (ADRs)",
+    "Evaluate trade-offs explicitly",
+    "Design for maintainability",
+    "Consider operational concerns"
+  ],
+  qualityChecklist: [
+    "Architecture supports future scaling",
+    "Components have clear boundaries",
+    "Dependencies are managed properly",
+    "System is observable (logging, metrics)",
+    "Failure modes are handled"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "code", "fix", "bug"],
+      suggestedAgent: "backend",
+      reason: "Implementation details should be handled by domain specialists"
+    },
+    {
+      keywords: ["security", "compliance", "audit"],
+      suggestedAgent: "security",
+      reason: "Security architecture needs specialized review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid premature optimization",
+    "Don't over-engineer solutions",
+    "Avoid tight coupling between components",
+    "Don't ignore non-functional requirements"
+  ],
+  bestPractices: [
+    "Design for change",
+    "Use well-known patterns",
+    "Document decisions and rationale",
+    "Consider operational requirements"
+  ]
+};
+var DEVOPS_TEMPLATE = {
+  domain: "devops",
+  displayName: "DevOps Engineer",
+  domainReminders: [
+    "Automate repetitive tasks",
+    "Implement proper monitoring and alerting",
+    "Follow infrastructure as code principles",
+    "Consider disaster recovery",
+    "Optimize for reliability and cost"
+  ],
+  qualityChecklist: [
+    "Deployments are automated and repeatable",
+    "Monitoring covers key metrics",
+    "Alerts are actionable",
+    "Backups are tested",
+    "Security is integrated into CI/CD"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["code", "feature", "bug", "implement"],
+      suggestedAgent: "backend",
+      reason: "Application code changes should go to developers"
+    },
+    {
+      keywords: ["security", "credentials", "secrets"],
+      suggestedAgent: "security",
+      reason: "Security-sensitive changes need security review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid manual deployments",
+    "Don't store secrets in code",
+    "Avoid single points of failure",
+    "Don't ignore monitoring gaps"
+  ],
+  bestPractices: [
+    "Use infrastructure as code",
+    "Implement CI/CD pipelines",
+    "Follow GitOps practices",
+    "Use immutable infrastructure"
+  ]
+};
+var WRITER_TEMPLATE = {
+  domain: "writer",
+  displayName: "Technical Writer",
+  domainReminders: [
+    "Write for the target audience",
+    "Use clear, concise language",
+    "Include practical examples",
+    "Structure content logically",
+    "Keep documentation up to date"
+  ],
+  qualityChecklist: [
+    "Documentation matches current code",
+    "Examples are working and tested",
+    "Content is well-organized",
+    "Technical terms are explained",
+    "Links and references are valid"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "code", "fix", "develop"],
+      suggestedAgent: "backend",
+      reason: "Code changes should be handled by developers"
+    }
+  ],
+  antiPatterns: [
+    "Avoid jargon without explanation",
+    "Don't assume reader knowledge",
+    "Avoid outdated examples",
+    "Don't ignore code comments"
+  ],
+  bestPractices: [
+    "Use consistent terminology",
+    "Include code examples",
+    "Keep documentation near code",
+    "Update docs with code changes"
+  ]
+};
+var STANDARD_TEMPLATE = {
+  domain: "standard",
+  displayName: "General Assistant",
+  domainReminders: [
+    "Understand the task before starting",
+    "Ask clarifying questions when needed",
+    "Break complex tasks into smaller steps",
+    "Verify your work before completing",
+    "Document your changes"
+  ],
+  qualityChecklist: [
+    "Task requirements are understood",
+    "Changes are tested",
+    "Code follows project conventions",
+    "Documentation is updated",
+    "No regressions introduced"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["security", "vulnerability", "authentication"],
+      suggestedAgent: "security",
+      reason: "Security tasks need specialized attention"
+    },
+    {
+      keywords: ["test", "testing", "QA", "quality"],
+      suggestedAgent: "quality",
+      reason: "Testing benefits from QA expertise"
+    },
+    {
+      keywords: ["architecture", "design", "scalability"],
+      suggestedAgent: "architecture",
+      reason: "Architectural decisions need careful consideration"
+    }
+  ],
+  antiPatterns: [
+    "Avoid making changes without understanding context",
+    "Don't skip testing",
+    "Avoid large, monolithic changes",
+    "Don't ignore existing patterns"
+  ],
+  bestPractices: [
+    "Follow existing code conventions",
+    "Write self-documenting code",
+    "Test your changes",
+    "Keep changes focused"
+  ]
+};
+var AGENT_TEMPLATES = {
+  backend: BACKEND_TEMPLATE,
+  frontend: FRONTEND_TEMPLATE,
+  fullstack: { ...BACKEND_TEMPLATE, domain: "fullstack", displayName: "Fullstack Engineer" },
+  security: SECURITY_TEMPLATE,
+  quality: QUALITY_TEMPLATE,
+  architecture: ARCHITECTURE_TEMPLATE,
+  devops: DEVOPS_TEMPLATE,
+  data: { ...BACKEND_TEMPLATE, domain: "data", displayName: "Data Engineer" },
+  mobile: { ...FRONTEND_TEMPLATE, domain: "mobile", displayName: "Mobile Engineer" },
+  writer: WRITER_TEMPLATE,
+  researcher: { ...STANDARD_TEMPLATE, domain: "researcher", displayName: "Researcher" },
+  standard: STANDARD_TEMPLATE
+};
+function getAgentTemplate(domain) {
+  return AGENT_TEMPLATES[domain] || STANDARD_TEMPLATE;
+}
+function isValidAgentDomain(domain) {
+  return domain in AGENT_TEMPLATES;
+}
+function getDelegationSuggestions(text, currentDomain) {
+  const template = getAgentTemplate(currentDomain);
+  const suggestions = [];
+  const textLower = text.toLowerCase();
+  for (const trigger of template.delegationTriggers) {
+    const matchedKeywords = trigger.keywords.filter(
+      (kw) => textLower.includes(kw.toLowerCase())
+    );
+    if (matchedKeywords.length > 0) {
+      suggestions.push({
+        agent: trigger.suggestedAgent,
+        reason: trigger.reason,
+        keywords: matchedKeywords
+      });
+    }
+  }
+  return suggestions;
+}
+
+// src/agents/agent-instruction-injector.ts
+var DEFAULT_AGENT_CONFIG = {
+  enabled: true,
+  reminderFrequency: 5,
+  delegationDetection: true,
+  minDelegationKeywords: 1,
+  includeQualityChecklist: true,
+  qualityChecklistFrequency: 10,
+  includeAntiPatterns: true
+};
+var AgentInstructionInjector = class {
+  name = "agent-template";
+  config;
+  lastReminderTurn = 0;
+  lastQualityCheckTurn = 0;
+  currentDomain;
+  recentTaskText = "";
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_AGENT_CONFIG,
+      ...config
+    };
+    logger.debug("AgentInstructionInjector initialized", {
+      enabled: this.config.enabled,
+      reminderFrequency: this.config.reminderFrequency
+    });
+  }
+  /**
+   * Set the current agent domain
+   */
+  setDomain(domain) {
+    if (isValidAgentDomain(domain)) {
+      this.currentDomain = domain;
+      logger.debug("Agent domain set", { domain });
+    } else {
+      this.currentDomain = "standard";
+      logger.debug("Unknown domain, using standard", { domain });
+    }
+  }
+  /**
+   * Get the current domain
+   */
+  getDomain() {
+    return this.currentDomain;
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    const domain = this.resolveDomain(context);
+    if (!domain) {
+      return false;
+    }
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const reminderDue = turnsSinceReminder >= this.config.reminderFrequency;
+    const turnsSinceQuality = context.turnCount - this.lastQualityCheckTurn;
+    const qualityDue = this.config.includeQualityChecklist && turnsSinceQuality >= this.config.qualityChecklistFrequency;
+    const hasDelegationTriggers = this.config.delegationDetection && this.checkDelegationTriggers(context);
+    return reminderDue || qualityDue || hasDelegationTriggers;
+  }
+  /**
+   * Generate instructions based on agent domain
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    const domain = this.resolveDomain(context);
+    if (!domain) {
+      return instructions;
+    }
+    const template = getAgentTemplate(domain);
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const turnsSinceQuality = context.turnCount - this.lastQualityCheckTurn;
+    if (turnsSinceReminder >= this.config.reminderFrequency) {
+      const reminderContent = this.formatDomainReminders(template);
+      instructions.push({
+        type: "delegation",
+        priority: "normal",
+        content: reminderContent,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.reminderFrequency,
+        id: `agent-reminder-${domain}-${Date.now()}`
+      });
+      this.lastReminderTurn = context.turnCount;
+    }
+    if (this.config.includeQualityChecklist && turnsSinceQuality >= this.config.qualityChecklistFrequency) {
+      const checklistContent = this.formatQualityChecklist(template);
+      instructions.push({
+        type: "delegation",
+        priority: "normal",
+        content: checklistContent,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.qualityChecklistFrequency,
+        id: `agent-quality-${domain}-${Date.now()}`
+      });
+      this.lastQualityCheckTurn = context.turnCount;
+    }
+    if (this.config.delegationDetection) {
+      const taskText = this.extractTaskText(context);
+      if (taskText !== this.recentTaskText) {
+        this.recentTaskText = taskText;
+        const delegationContent = this.checkAndFormatDelegation(template, taskText);
+        if (delegationContent) {
+          instructions.push({
+            type: "delegation",
+            priority: "high",
+            content: delegationContent,
+            source: "automatosx",
+            createdAt: Date.now(),
+            expiresAfter: 3,
+            id: `agent-delegation-${Date.now()}`
+          });
+        }
+      }
+    }
+    logger.debug("Agent instructions generated", {
+      domain,
+      instructionCount: instructions.length
+    });
+    return instructions;
+  }
+  /**
+   * Resolve domain from context or current setting
+   */
+  resolveDomain(context) {
+    if (context.agentName && isValidAgentDomain(context.agentName)) {
+      return context.agentName;
+    }
+    return this.currentDomain;
+  }
+  /**
+   * Extract task text from context for delegation detection
+   */
+  extractTaskText(context) {
+    const parts = [];
+    if (context.currentTask) {
+      parts.push(context.currentTask);
+    }
+    for (const todo of context.todos.filter((t) => t.status === "in_progress")) {
+      parts.push(todo.content);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Check if delegation triggers are present
+   */
+  checkDelegationTriggers(context) {
+    const domain = this.resolveDomain(context);
+    if (!domain) return false;
+    const taskText = this.extractTaskText(context);
+    if (!taskText) return false;
+    const suggestions = getDelegationSuggestions(taskText, domain);
+    return suggestions.some((s) => s.keywords.length >= this.config.minDelegationKeywords);
+  }
+  /**
+   * Format domain reminders
+   */
+  formatDomainReminders(template) {
+    const lines = [
+      `## ${template.displayName} Reminders`,
+      ""
+    ];
+    for (const reminder of template.domainReminders) {
+      lines.push(`- ${reminder}`);
+    }
+    if (this.config.includeAntiPatterns && template.antiPatterns.length > 0) {
+      lines.push("");
+      lines.push("**Avoid:**");
+      for (const antiPattern of template.antiPatterns.slice(0, 3)) {
+        lines.push(`- ${antiPattern}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format quality checklist
+   */
+  formatQualityChecklist(template) {
+    const lines = [
+      `## Quality Checklist (${template.displayName})`,
+      "",
+      "Before completing, verify:"
+    ];
+    for (const item of template.qualityChecklist) {
+      lines.push(`- [ ] ${item}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Check for delegation triggers and format suggestion
+   */
+  checkAndFormatDelegation(template, taskText) {
+    const suggestions = getDelegationSuggestions(taskText, template.domain);
+    const relevantSuggestions = suggestions.filter(
+      (s) => s.keywords.length >= this.config.minDelegationKeywords
+    );
+    if (relevantSuggestions.length === 0) {
+      return null;
+    }
+    const lines = [
+      "## Delegation Suggestion",
+      ""
+    ];
+    for (const suggestion of relevantSuggestions) {
+      lines.push(`**Consider delegating to @${suggestion.agent}**`);
+      lines.push(`- Reason: ${suggestion.reason}`);
+      lines.push(`- Triggered by: ${suggestion.keywords.join(", ")}`);
+      lines.push("");
+    }
+    lines.push("Use `DELEGATE TO @agent: task` or `@agent task` syntax to delegate.");
+    return lines.join("\n");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("AgentInstructionInjector config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.lastReminderTurn = 0;
+    this.lastQualityCheckTurn = 0;
+    this.recentTaskText = "";
+    logger.debug("AgentInstructionInjector reset");
+  }
+};
+
+// src/core/orchestration/orchestration-service.ts
+var OrchestrationService = class {
+  config;
+  injector;
+  tokenBudgetManager;
+  workflowModeManager;
+  agentInjector;
+  todoProvider;
+  memoryProvider;
+  sessionProvider;
+  turnCount = 0;
+  currentTodos = [];
+  constructor(serviceConfig = {}) {
+    this.config = {
+      ...DEFAULT_ORCHESTRATION_CONFIG,
+      ...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,
+      reminderFrequency: this.config.agentTemplates?.reminderFrequency ?? 5
+    });
+    this.initializeProviders(serviceConfig);
+    logger.debug("OrchestrationService initialized", {
+      todoEnabled: this.config.todoIntegration?.enabled,
+      memoryEnabled: this.config.memoryIntegration?.enabled,
+      sessionEnabled: this.config.sessionIntegration?.enabled,
+      agentTemplatesEnabled: this.config.agentTemplates?.enabled
+    });
+  }
+  /**
+   * Initialize instruction providers
+   */
+  initializeProviders(serviceConfig) {
+    if (this.config.todoIntegration?.enabled !== false) {
+      this.todoProvider = new TodoInstructionProvider({
+        enabled: true,
+        reminderFrequency: this.config.todoIntegration?.reminderFrequency ?? 3,
+        compactMode: this.config.todoIntegration?.compactMode ?? false
+      });
+      this.injector.registerProvider(this.todoProvider);
+    }
+    if (this.config.memoryIntegration?.enabled !== false && serviceConfig.memorySearchProvider) {
+      this.memoryProvider = new MemoryInstructionProvider(
+        serviceConfig.memorySearchProvider,
+        {
+          enabled: true,
+          maxEntries: this.config.memoryIntegration?.maxEntries ?? 5,
+          minRelevance: this.config.memoryIntegration?.minRelevance ?? 0.5
+        }
+      );
+      this.injector.registerProvider(this.memoryProvider);
+    }
+    if (this.config.sessionIntegration?.enabled !== false) {
+      this.sessionProvider = new SessionInstructionProvider(
+        serviceConfig.sessionStateProvider,
+        {
+          enabled: true,
+          showCollaboration: this.config.sessionIntegration?.showCollaboration ?? true,
+          showProgress: true,
+          reminderFrequency: 5,
+          showHandoffContext: true
+        }
+      );
+      this.injector.registerProvider(this.sessionProvider);
+    }
+    if (this.config.agentTemplates?.enabled !== false) {
+      if (serviceConfig.agentDomain) {
+        this.agentInjector.setDomain(serviceConfig.agentDomain);
+      }
+      this.injector.registerProvider(this.agentInjector);
+    }
+  }
+  /**
+   * Set the current agent domain for agent-specific instructions
+   */
+  setAgentDomain(domain) {
+    this.agentInjector.setDomain(domain);
+    logger.debug("Agent domain set", { domain });
+  }
+  /**
+   * Set the memory search provider
+   */
+  setMemoryProvider(provider) {
+    if (this.memoryProvider) {
+      this.memoryProvider.setSearchProvider(provider);
+    } else if (this.config.memoryIntegration?.enabled !== false) {
+      this.memoryProvider = new MemoryInstructionProvider(provider, {
+        enabled: true,
+        maxEntries: this.config.memoryIntegration?.maxEntries ?? 5,
+        minRelevance: this.config.memoryIntegration?.minRelevance ?? 0.5
+      });
+      this.injector.registerProvider(this.memoryProvider);
+    }
+  }
+  /**
+   * Set the session state provider
+   */
+  setSessionProvider(provider) {
+    if (this.sessionProvider) {
+      this.sessionProvider.setStateProvider(provider);
+    }
+  }
+  /**
+   * Update the current todo list
+   */
+  updateTodos(todos) {
+    this.currentTodos = todos;
+  }
+  /**
+   * Set the workflow mode
+   */
+  setWorkflowMode(mode) {
+    this.workflowModeManager.setMode(mode);
+    logger.debug("Workflow mode set", { mode });
+  }
+  /**
+   * Get current workflow mode
+   */
+  getWorkflowMode() {
+    return this.workflowModeManager.getCurrentMode();
+  }
+  /**
+   * Check if a tool is allowed in current workflow mode
+   */
+  isToolAllowed(toolName) {
+    return this.workflowModeManager.isToolAllowed(toolName);
+  }
+  /**
+   * Filter tools based on current workflow mode
+   */
+  filterTools(tools) {
+    return this.workflowModeManager.filterTools(tools);
+  }
+  /**
+   * Increment turn count (called after each agent response)
+   */
+  incrementTurn() {
+    this.turnCount++;
+  }
+  /**
+   * Get current turn count
+   */
+  getTurnCount() {
+    return this.turnCount;
+  }
+  /**
+   * Generate and inject instructions for the current context
+   */
+  async injectInstructions(options = {}) {
+    const context = {
+      todos: this.currentTodos,
+      turnCount: this.turnCount,
+      workflowMode: this.workflowModeManager.getCurrentMode(),
+      currentTask: options.task,
+      agentName: options.agentName,
+      sessionId: options.sessionId,
+      parentAgent: options.parentAgent
+    };
+    const result = await this.injector.inject(context);
+    logger.debug("Instructions injected", {
+      instructionCount: result.instructions.length,
+      tokensUsed: result.allocation.tokensUsed,
+      hasInstructions: result.hasInstructions
+    });
+    return {
+      content: result.formattedText,
+      instructions: result.instructions,
+      tokenCount: result.allocation.tokensUsed,
+      applied: result.hasInstructions
+    };
+  }
+  /**
+   * Format instructions as system reminder tags
+   */
+  formatAsSystemReminder(content) {
+    if (!content || content.trim().length === 0) {
+      return "";
+    }
+    return `<system-reminder>
+${content}
+</system-reminder>`;
+  }
+  /**
+   * Get debug information about current orchestration state
+   */
+  getDebugInfo() {
+    const budgetConfig = this.tokenBudgetManager.getConfig();
+    const providers = this.injector.getProviders().map((p) => p.name);
+    return {
+      turnCount: this.turnCount,
+      workflowMode: this.workflowModeManager.getCurrentMode(),
+      todoCount: this.currentTodos.length,
+      providers,
+      tokenBudget: {
+        used: 0,
+        // Would need to track this
+        total: budgetConfig.maxTotal,
+        remaining: budgetConfig.maxTotal
+      }
+    };
+  }
+  /**
+   * Reset all state (for new conversations)
+   */
+  reset() {
+    this.turnCount = 0;
+    this.currentTodos = [];
+    this.workflowModeManager.reset();
+    this.agentInjector.reset();
+    this.injector.clearCache();
+    if (this.todoProvider) {
+      this.todoProvider.reset();
+    }
+    if (this.memoryProvider) {
+      this.memoryProvider.clearCache();
+    }
+    if (this.sessionProvider) {
+      this.sessionProvider.reset();
+    }
+    logger.debug("OrchestrationService reset");
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.tokenBudget) {
+      this.tokenBudgetManager = new TokenBudgetManager(updates.tokenBudget);
+    }
+    logger.debug("OrchestrationService config updated", { updates });
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/cli/commands/debug-instructions.ts
+var debugInstructionsCommand = {
+  command: "debug:instructions",
+  describe: "Show current embedded instructions state (v11.3.0)",
+  builder: (yargs2) => {
+    return yargs2.option("tokens", {
+      alias: "t",
+      describe: "Show token budget details",
+      type: "boolean",
+      default: false
+    }).option("providers", {
+      alias: "p",
+      describe: "Show registered instruction providers",
+      type: "boolean",
+      default: false
+    }).option("templates", {
+      describe: "Show available agent templates",
+      type: "boolean",
+      default: false
+    }).option("agent", {
+      alias: "a",
+      describe: "Show template for specific agent domain",
+      type: "string"
+    }).option("verbose", {
+      alias: "v",
+      describe: "Show verbose output",
+      type: "boolean",
+      default: false
+    }).example("$0 debug:instructions", "Show overall instruction state").example("$0 debug:instructions --tokens", "Show token budget details").example("$0 debug:instructions --providers", "List instruction providers").example("$0 debug:instructions --templates", "List agent templates").example("$0 debug:instructions --agent backend", "Show backend agent template");
+  },
+  handler: async (argv) => {
+    try {
+      if (argv.tokens) {
+        displayTokenBudget(argv.verbose);
+        return;
+      }
+      if (argv.providers) {
+        displayProviders(argv.verbose);
+        return;
+      }
+      if (argv.templates) {
+        displayAgentTemplates(argv.verbose);
+        return;
+      }
+      if (argv.agent) {
+        displayAgentTemplate(argv.agent, argv.verbose);
+        return;
+      }
+      displayOverallState(argv.verbose);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      logger.error("Debug instructions command failed", { error: err.message });
+      process.exit(1);
+    }
+  }
+};
+function displayOverallState(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F50D} Embedded Instructions Debug Info\n"));
+  console.log(chalk5.dim("\u2550".repeat(60)));
+  const service = new OrchestrationService();
+  const debugInfo = service.getDebugInfo();
+  console.log(chalk5.cyan("\n\u{1F4CA} Current State"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  console.log(`  Turn count: ${chalk5.yellow(debugInfo.turnCount)}`);
+  console.log(`  Workflow mode: ${chalk5.cyan(debugInfo.workflowMode)}`);
+  console.log(`  Active todos: ${chalk5.yellow(debugInfo.todoCount)}`);
+  console.log(`  Registered providers: ${chalk5.green(debugInfo.providers.length)}`);
+  console.log(chalk5.cyan("\n\u{1F4B0} Token Budget"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  console.log(`  Used: ${chalk5.yellow(debugInfo.tokenBudget.used)} / ${debugInfo.tokenBudget.total}`);
+  const usagePercent = Math.round(debugInfo.tokenBudget.used / debugInfo.tokenBudget.total * 100);
+  const barLength = 30;
+  const filledLength = Math.round(usagePercent / 100 * barLength);
+  const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
+  const barColor = usagePercent > 80 ? chalk5.red : usagePercent > 50 ? chalk5.yellow : chalk5.green;
+  console.log(`  ${barColor(bar)} ${usagePercent}%`);
+  if (debugInfo.providers.length > 0) {
+    console.log(chalk5.cyan("\n\u{1F50C} Active Providers"));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    debugInfo.providers.forEach((provider, index) => {
+      console.log(`  ${index + 1}. ${chalk5.green(provider)}`);
+    });
+  }
+  console.log(chalk5.cyan("\n\u{1F504} Workflow Modes"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  Object.keys(WORKFLOW_MODES).forEach((mode) => {
+    const isCurrent = mode === debugInfo.workflowMode;
+    const prefix = isCurrent ? chalk5.green("\u25BA") : " ";
+    const modeText = isCurrent ? chalk5.green.bold(mode) : chalk5.gray(mode);
+    console.log(`  ${prefix} ${modeText}`);
+  });
+  console.log(chalk5.dim("\n" + "\u2550".repeat(60)));
+  console.log(chalk5.gray("\nUse --tokens, --providers, or --templates for detailed info.\n"));
+}
+function displayTokenBudget(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F4B0} Token Budget Details\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  const budgetManager = new TokenBudgetManager();
+  const config = budgetManager.getConfig();
+  console.log(`
+  Total budget: ${chalk5.cyan(config.maxTotal)} tokens`);
+  console.log(`  Critical reserve: ${chalk5.yellow(config.criticalReserve)} tokens`);
+  console.log(`  Available: ${chalk5.green(config.maxTotal - config.criticalReserve)} tokens`);
+  console.log(chalk5.cyan("\n  Per-Type Allocations:"));
+  const typeAllocations = [
+    { type: "task", budget: 500, description: "Todo/task reminders" },
+    { type: "memory", budget: 400, description: "Memory context" },
+    { type: "session", budget: 300, description: "Session state" },
+    { type: "delegation", budget: 300, description: "Agent delegation hints" },
+    { type: "mode", budget: 200, description: "Workflow mode instructions" }
+  ];
+  typeAllocations.forEach(({ type, budget, description }) => {
+    console.log(`    \u2022 ${chalk5.cyan(type)}: ${budget} tokens`);
+    if (verbose) {
+      console.log(chalk5.gray(`      ${description}`));
+    }
+  });
+  console.log(chalk5.cyan("\n  Token Estimation:"));
+  console.log(chalk5.gray("    ~4 characters = 1 token (approximation)"));
+  console.log(chalk5.gray("    Actual usage may vary by content"));
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log();
+}
+function displayProviders(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F50C} Instruction Providers\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  const providers = [
+    {
+      name: "TodoInstructionProvider",
+      description: "Generates task reminders from todo list",
+      triggers: "Todo state changes, periodic reminders",
+      priority: "high"
+    },
+    {
+      name: "MemoryInstructionProvider",
+      description: "Injects relevant context from memory",
+      triggers: "Task keywords, memory relevance",
+      priority: "normal"
+    },
+    {
+      name: "SessionInstructionProvider",
+      description: "Shows multi-agent collaboration state",
+      triggers: "Session changes, periodic reminders",
+      priority: "normal"
+    },
+    {
+      name: "AgentInstructionInjector",
+      description: "Domain-specific reminders and delegation hints",
+      triggers: "Agent domain, task keywords",
+      priority: "normal"
+    },
+    {
+      name: "WorkflowModeManager",
+      description: "Mode-specific instructions and tool filtering",
+      triggers: "Mode changes",
+      priority: "high"
+    }
+  ];
+  providers.forEach((provider, index) => {
+    console.log(`
+  ${index + 1}. ${chalk5.cyan.bold(provider.name)}`);
+    console.log(chalk5.gray(`     ${provider.description}`));
+    if (verbose) {
+      console.log(`     Triggers: ${chalk5.yellow(provider.triggers)}`);
+      console.log(`     Priority: ${chalk5.green(provider.priority)}`);
+    }
+  });
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log();
+}
+function displayAgentTemplates(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F4CB} Agent Instruction Templates\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  for (const [domain, template] of Object.entries(AGENT_TEMPLATES)) {
+    console.log(`
+  ${chalk5.cyan.bold(template.displayName)} (${domain})`);
+    if (verbose) {
+      console.log(chalk5.gray(`    Reminders: ${template.domainReminders.length}`));
+      console.log(chalk5.gray(`    Checklist items: ${template.qualityChecklist.length}`));
+      console.log(chalk5.gray(`    Delegation triggers: ${template.delegationTriggers.length}`));
+      console.log(chalk5.gray(`    Anti-patterns: ${template.antiPatterns.length}`));
+      console.log(chalk5.gray(`    Best practices: ${template.bestPractices.length}`));
+    }
+  }
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log(chalk5.gray("\nUse --agent <domain> to see template details.\n"));
+}
+function displayAgentTemplate(domain, verbose) {
+  const template = AGENT_TEMPLATES[domain];
+  if (!template) {
+    console.error(chalk5.red.bold(`
+\u274C Unknown agent domain: ${domain}
+`));
+    console.log(chalk5.gray("Available domains:"));
+    Object.keys(AGENT_TEMPLATES).forEach((d) => {
+      console.log(chalk5.cyan(`  \u2022 ${d}`));
+    });
+    console.log();
+    process.exit(1);
+  }
+  console.log(chalk5.blue.bold(`
+\u{1F4CB} ${template.displayName} Agent Template
+`));
+  console.log(chalk5.dim("\u2550".repeat(60)));
+  console.log(chalk5.cyan("\n\u{1F514} Domain Reminders:"));
+  template.domainReminders.forEach((reminder, i) => {
+    console.log(`  ${i + 1}. ${reminder}`);
+  });
+  console.log(chalk5.cyan("\n\u2705 Quality Checklist:"));
+  template.qualityChecklist.forEach((item, i) => {
+    console.log(`  ${i + 1}. ${item}`);
+  });
+  if (template.delegationTriggers.length > 0) {
+    console.log(chalk5.cyan("\n\u{1F500} Delegation Triggers:"));
+    template.delegationTriggers.forEach((trigger, i) => {
+      console.log(`  ${i + 1}. \u2192 ${chalk5.yellow(trigger.suggestedAgent)}`);
+      console.log(chalk5.gray(`     Keywords: ${trigger.keywords.join(", ")}`));
+      if (verbose) {
+        console.log(chalk5.gray(`     Reason: ${trigger.reason}`));
+      }
+    });
+  }
+  if (verbose && template.antiPatterns.length > 0) {
+    console.log(chalk5.red("\n\u26A0\uFE0F  Anti-Patterns to Avoid:"));
+    template.antiPatterns.forEach((pattern, i) => {
+      console.log(`  ${i + 1}. ${pattern}`);
+    });
+  }
+  if (verbose && template.bestPractices.length > 0) {
+    console.log(chalk5.green("\n\u2728 Best Practices:"));
+    template.bestPractices.forEach((practice, i) => {
+      console.log(`  ${i + 1}. ${practice}`);
+    });
+  }
+  console.log(chalk5.dim("\n\u2550".repeat(60)));
+  console.log();
+}
+
 // src/cli/index.ts
 installExitHandlers();
 var VERSION2 = getVersion();
@@ -48532,7 +51427,7 @@ globalTracker.mark("cli_start");
       type: "string",
       description: "Path to custom config file",
       global: true
-    }).command(setupCommand).command(initCommand).command(configureCommand).command(cliCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
+    }).command(setupCommand).command(initCommand).command(configureCommand).command(cliCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).command(modeCommand).command(debugInstructionsCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
     globalTracker.mark("yargs_parse_end");
     globalTracker.measure("yargs_parsing", "yargs_parse_start", "yargs_parse_end");
     globalTracker.mark("options_setup_start");