@defai.digital/automatosx 11.2.9 → 11.3.1

package/dist/index.js

@@ -19,7 +19,7 @@ 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';
@@ -2943,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);
@@ -3003,8 +3013,12 @@ ${fullPrompt}
             logger.debug(`Full prompt saved to ${debugPath}`);
           }
           const result = await this.executeCLI(fullPrompt);
+          const latencyMs = Date.now() - startTime;
           this.health.consecutiveFailures = 0;
           this.health.available = true;
+          this.health.errorRate = 0;
+          this.health.latencyMs = latencyMs;
+          this.health.lastCheck = Date.now();
           const response = {
             content: result,
             model: "default",
@@ -3015,7 +3029,7 @@ ${fullPrompt}
               completion: 0,
               total: 0
             },
-            latencyMs: Date.now() - startTime,
+            latencyMs,
             finishReason: "stop",
             cached: false
           };
@@ -3035,6 +3049,8 @@ ${fullPrompt}
           this.health.consecutiveFailures++;
           this.health.available = false;
           this.health.errorRate = 1;
+          this.health.latencyMs = Date.now() - startTime;
+          this.health.lastCheck = Date.now();
           throw this.handleError(error);
         }
       }
@@ -3055,6 +3071,8 @@ ${fullPrompt}
         } catch (error) {
           this.health.available = false;
           this.health.errorRate = 1;
+          this.health.lastCheck = Date.now();
+          this.health.consecutiveFailures = this.health.consecutiveFailures + 1;
           return false;
         }
       }
@@ -3062,13 +3080,13 @@ ${fullPrompt}
        * Get health status
        */
       async healthCheck() {
-        const isAvailable = await this.isAvailable();
+        await this.isAvailable();
         return {
-          available: isAvailable,
+          available: this.health.available,
           latencyMs: this.health.latencyMs,
-          errorRate: isAvailable ? 0 : 1,
-          consecutiveFailures: isAvailable ? 0 : this.health.consecutiveFailures + 1,
-          lastCheckTime: Date.now()
+          errorRate: this.health.errorRate,
+          consecutiveFailures: this.health.consecutiveFailures,
+          lastCheckTime: this.health.lastCheck
         };
       }
       /**
@@ -3786,8 +3804,9 @@ var init_cli_wrapper = __esm({
             child.stdin.write(prompt);
             child.stdin.end();
           }
+          let rl = null;
           if (child.stdout && renderer) {
-            const rl = readline2__default.createInterface({
+            rl = readline2__default.createInterface({
               input: child.stdout,
               crlfDelay: Infinity
             });
@@ -3795,6 +3814,11 @@ var init_cli_wrapper = __esm({
               stdout += line + "\n";
               renderer.processLine(line);
             });
+            rl.on("error", (error) => {
+              logger.warn("Readline error during streaming", {
+                error: error.message
+              });
+            });
           } else if (child.stdout) {
             child.stdout.on("data", (data) => {
               stdout += data.toString();
@@ -3810,6 +3834,10 @@ var init_cli_wrapper = __esm({
               clearTimeout(timeoutHandle);
               timeoutHandle = null;
             }
+            if (rl) {
+              rl.close();
+              rl = null;
+            }
             this.activeProcesses.delete(child);
             if (hasTimedOut) {
               return;
@@ -3837,6 +3865,10 @@ var init_cli_wrapper = __esm({
               clearTimeout(timeoutHandle);
               timeoutHandle = null;
             }
+            if (rl) {
+              rl.close();
+              rl = null;
+            }
             this.activeProcesses.delete(child);
             if (!hasTimedOut) {
               if (renderer) {
@@ -5529,11 +5561,17 @@ ${result.content.substring(0, 1e3)}
       setupAutoSave() {
         this.autoSaveTimer = setInterval(async () => {
           if (this.pendingCheckpoint) {
-            await this.save(
-              this.pendingCheckpoint.workflowId,
-              this.pendingCheckpoint
-            );
-            this.pendingCheckpoint = null;
+            try {
+              await this.save(
+                this.pendingCheckpoint.workflowId,
+                this.pendingCheckpoint
+              );
+              this.pendingCheckpoint = null;
+            } catch (error) {
+              logger.warn("Auto-save failed", {
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
           }
         }, this.options.autoSaveInterval);
       }
@@ -5545,13 +5583,29 @@ ${result.content.substring(0, 1e3)}
       }
       /**
        * Cleanup resources
+       * BUG FIX: Flush pending checkpoint before destroying to prevent data loss
        */
-      destroy() {
+      async destroy() {
         if (this.autoSaveTimer) {
           clearInterval(this.autoSaveTimer);
           this.autoSaveTimer = null;
         }
-        this.pendingCheckpoint = null;
+        if (this.pendingCheckpoint) {
+          try {
+            await this.save(
+              this.pendingCheckpoint.workflowId,
+              this.pendingCheckpoint
+            );
+            logger.debug("Pending checkpoint flushed on destroy", {
+              workflowId: this.pendingCheckpoint.workflowId
+            });
+          } catch (error) {
+            logger.warn("Failed to flush pending checkpoint on destroy", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          this.pendingCheckpoint = null;
+        }
         this.sdkCheckpointManager = null;
         logger.debug("CheckpointAdapter destroyed");
       }
@@ -7032,7 +7086,10 @@ var init_adapter2 = __esm({
         }
         if (this.checkpointAdapter) {
           try {
-            this.checkpointAdapter.destroy();
+            const result = this.checkpointAdapter.destroy();
+            if (result instanceof Promise) {
+              await result;
+            }
             this.checkpointAdapter = null;
             logger.debug("CheckpointAdapter destroyed");
           } catch (error) {
@@ -9263,7 +9320,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.9"
+  "version": "11.3.1"
 };
 
 // src/core/config/schemas.ts
@@ -10117,6 +10174,7 @@ async function saveConfigFile(path7, config) {
       content = JSON.stringify(config, null, 2);
     }
     await writeFile(path7, content, "utf-8");
+    configCache.clear();
     logger.info("Config saved successfully", { path: normalizePath(path7), format: ext });
   } catch (error) {
     if (error instanceof ConfigError) {
@@ -13191,12 +13249,6 @@ var setupCommand = {
       describe: "Force setup even if .automatosx already exists",
       type: "boolean",
       default: false
-    }).option("spec-kit", {
-      describe: "Automatically initialize GitHub Spec-Kit for spec-driven development",
-      type: "boolean"
-    }).option("skip-spec-kit", {
-      describe: "Skip Spec-Kit initialization (useful for CI/CD)",
-      type: "boolean"
     }).option("claude-code", {
       describe: "Setup Claude Code integration (generates manifests and registers MCP server)",
       type: "boolean",
@@ -13386,7 +13438,6 @@ var setupCommand = {
       console.log(chalk5.cyan("\u{1F4DD} Updating .gitignore..."));
       await updateGitignore(projectDir);
       console.log(chalk5.green("   \u2713 .gitignore updated"));
-      const specKitInitialized = await maybeInitializeSpecKit(projectDir, argv);
       let claudeCodeSetupSucceeded = false;
       if (argv.claudeCode) {
         console.log(chalk5.blue("\n\u{1F527} Setting up Claude Code integration...\n"));
@@ -13440,13 +13491,6 @@ var setupCommand = {
       console.log(chalk5.gray('    ax run backend "implement auth" --workflow auth-flow'));
       console.log(chalk5.gray('    ax run backend "create API" --workflow api-flow'));
       console.log(chalk5.gray("  \u2022 Available: auth-flow, feature-flow, api-flow, refactor-flow\n"));
-      if (specKitInitialized) {
-        console.log(chalk5.cyan("Spec Files (.specify/):"));
-        console.log(chalk5.gray("  \u2022 Spec files created for documentation"));
-        console.log(chalk5.gray("  \u2022 Use agents to work with specs:"));
-        console.log(chalk5.gray('    ax run product "Write spec for feature X"'));
-        console.log(chalk5.gray("  \u2022 Note: ax spec run removed in v11.0.0, use --workflow instead\n"));
-      }
       console.log(chalk5.cyan("Iterate Mode (Autonomous Multi-Iteration):"));
       console.log(chalk5.gray("  \u2022 Enable with --iterate flag for autonomous task loops"));
       console.log(chalk5.gray('  \u2022 Example: ax run quality "find bugs" --iterate --iterate-max-iterations 5'));
@@ -13881,9 +13925,9 @@ async function initializeGitRepository(projectDir) {
       logger.info("Git repository already exists, skipping initialization");
       return true;
     }
-    const { spawn: spawn9 } = await import('child_process');
+    const { spawn: spawn10 } = await import('child_process');
     await new Promise((resolve13, reject) => {
-      const child = spawn9("git", ["init"], {
+      const child = spawn10("git", ["init"], {
         cwd: projectDir,
         stdio: "pipe",
         shell: false
@@ -13964,155 +14008,6 @@ async function updateGitignore(projectDir) {
     logger.warn("Failed to update .gitignore", { error: error.message });
   }
 }
-async function maybeInitializeSpecKit(projectDir, argv) {
-  const specifyDir = join(projectDir, ".specify");
-  const specifyExists = await checkExists2(specifyDir);
-  if (specifyExists) {
-    logger.info("Spec-Kit directory already exists, skipping initialization", {
-      path: specifyDir
-    });
-    return true;
-  }
-  if (argv.skipSpecKit) {
-    logger.info("Skipping Spec-Kit initialization (--skip-spec-kit flag)");
-    return false;
-  }
-  if (argv.specKit) {
-    console.log(chalk5.cyan("\n\u{1F4CB} Initializing GitHub Spec-Kit..."));
-    return await initializeSpecKit(projectDir);
-  }
-  if (process.stdout.isTTY && process.stdin.isTTY) {
-    console.log(chalk5.cyan("\n\u{1F4CB} GitHub Spec-Kit Integration"));
-    console.log(chalk5.gray("   Spec-Kit enables spec-driven development workflows."));
-    console.log(chalk5.gray("   It creates .specify/ directory with spec.md, plan.md, and tasks.md"));
-    console.log(chalk5.gray("   for structured planning and task management.\n"));
-    try {
-      const prompt = new PromptHelper();
-      try {
-        const answer = await prompt.question(
-          chalk5.cyan("   Initialize Spec-Kit now? (y/N): ")
-        );
-        const shouldInit = answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
-        if (shouldInit) {
-          console.log(chalk5.cyan("\n   Initializing Spec-Kit..."));
-          return await initializeSpecKit(projectDir);
-        } else {
-          logger.info("User declined Spec-Kit initialization");
-          return false;
-        }
-      } finally {
-        prompt.close();
-      }
-    } catch (error) {
-      logger.warn("Failed to prompt for Spec-Kit initialization", {
-        error: error.message
-      });
-      return false;
-    }
-  }
-  logger.info("Non-interactive mode, skipping Spec-Kit initialization");
-  return false;
-}
-async function initializeSpecKit(projectDir) {
-  try {
-    const specifyDir = join(projectDir, ".specify");
-    await mkdir(specifyDir, { recursive: true });
-    const specTemplate = `# Project Specification
-
-## Overview
-<!-- Brief description of what this project does -->
-
-## Goals
-<!-- List the main goals and objectives -->
-
-## Requirements
-<!-- Detailed requirements -->
-
-### Functional Requirements
-<!-- What the system should do -->
-
-### Non-Functional Requirements
-<!-- Performance, security, scalability, etc. -->
-
-## Success Criteria
-<!-- How do we measure success? -->
-
-## Out of Scope
-<!-- What this project explicitly does NOT include -->
-`;
-    const planTemplate = `# Technical Plan
-
-## Architecture
-<!-- High-level architecture diagram or description -->
-
-## Technology Stack
-<!-- Languages, frameworks, libraries, tools -->
-
-## Implementation Approach
-<!-- Step-by-step approach to implementation -->
-
-## Data Model
-<!-- Database schema, data structures -->
-
-## API Design
-<!-- API endpoints, interfaces -->
-
-## Security Considerations
-<!-- Authentication, authorization, data protection -->
-
-## Testing Strategy
-<!-- Unit tests, integration tests, E2E tests -->
-
-## Deployment Plan
-<!-- How will this be deployed? -->
-
-## Risks and Mitigations
-<!-- Potential risks and how to handle them -->
-`;
-    const tasksTemplate = `# Tasks
-
-<!-- Task format: - [ ] id:task-id ops:"command" dep:dependency-id -->
-<!-- Example: -->
-<!-- - [ ] id:setup:env ops:"ax run devops 'Setup development environment'" -->
-<!-- - [ ] id:impl:api ops:"ax run backend 'Implement REST API'" dep:setup:env -->
-<!-- - [ ] id:test:api ops:"ax run quality 'Write API tests'" dep:impl:api -->
-
-## Phase 1: Setup
-- [ ] id:setup:env ops:"ax run devops 'Setup development environment'"
-- [ ] id:setup:db ops:"ax run backend 'Setup database schema'" dep:setup:env
-
-## Phase 2: Implementation
-- [ ] id:impl:core ops:"ax run backend 'Implement core functionality'" dep:setup:db
-
-## Phase 3: Testing
-- [ ] id:test:unit ops:"ax run quality 'Write unit tests'" dep:impl:core
-- [ ] id:test:integration ops:"ax run quality 'Write integration tests'" dep:impl:core
-
-## Phase 4: Documentation
-- [ ] id:docs:api ops:"ax run writer 'Write API documentation'" dep:impl:core
-`;
-    await writeFile(join(specifyDir, "spec.md"), specTemplate, "utf8");
-    await writeFile(join(specifyDir, "plan.md"), planTemplate, "utf8");
-    await writeFile(join(specifyDir, "tasks.md"), tasksTemplate, "utf8");
-    console.log(chalk5.green("   \u2713 Spec-Kit set up successfully"));
-    console.log(chalk5.gray("      Files created: .specify/spec.md, plan.md, tasks.md"));
-    logger.info("Spec-Kit set up successfully", {
-      projectDir,
-      specifyDir
-    });
-    return true;
-  } catch (error) {
-    const errorMessage = error.message;
-    console.log(chalk5.yellow("   \u26A0\uFE0F  Failed to initialize Spec-Kit"));
-    console.log(chalk5.gray(`      ${errorMessage}
-`));
-    logger.warn("Spec-Kit initialization failed (non-critical)", {
-      error: errorMessage,
-      projectDir
-    });
-    return false;
-  }
-}
 async function setupGeminiIntegration(projectDir, packageRoot) {
   const geminiDir = join(projectDir, ".gemini");
   await mkdir(geminiDir, { recursive: true });
@@ -16146,12 +16041,12 @@ var listCommand = {
 };
 async function listAgents(pathResolver, format) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync25 } = await import('fs');
+  const { existsSync: existsSync26 } = await import('fs');
   const projectDir = await detectProjectRoot();
   const examplesDir = join(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync25(agentsDir)) {
+    if (existsSync26(agentsDir)) {
       const files = await readdir(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -16163,7 +16058,7 @@ async function listAgents(pathResolver, format) {
         }
       }
     }
-    if (existsSync25(examplesDir)) {
+    if (existsSync26(examplesDir)) {
       const files = await readdir(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -22176,8 +22071,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];
       }
     }
@@ -36202,6 +36097,707 @@ function formatForSave(result, format, metadata) {
   }
   return formatOutput(result, format, true);
 }
+
+// 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 Object.prototype.hasOwnProperty.call(WORKFLOW_MODE_CONFIGS, mode);
+}
+var WORKFLOW_MODES = WORKFLOW_MODE_CONFIGS;
+
+// src/core/workflow/workflow-mode-manager.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/types.ts
+init_esm_shims();
+var INSTRUCTION_SOURCE = "automatosx";
+z.object({
+  type: z.enum(["task", "memory", "session", "delegation", "mode", "context"]),
+  priority: z.enum(["critical", "high", "normal", "low"]),
+  content: z.string().min(1).max(5e3),
+  source: z.literal(INSTRUCTION_SOURCE),
+  expiresAfter: z.number().int().positive().optional(),
+  createdAt: z.number(),
+  createdAtTurn: z.number().int().nonnegative().optional(),
+  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(),
+  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()
+});
+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,
+    context: 300
+  },
+  criticalReserve: 300
+};
+var TokenBudgetConfigSchema = z.object({
+  maxTotal: z.number().int().positive().max(1e4),
+  perType: z.record(
+    z.enum(["task", "memory", "session", "delegation", "mode", "context"]),
+    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/workflow/workflow-mode-manager.ts
+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 top entry from the mode stack (private helper to reduce repetition)
+   */
+  getTopEntry() {
+    return this.modeStack[this.modeStack.length - 1];
+  }
+  /**
+   * Get the current active mode
+   */
+  getCurrentMode() {
+    return this.getTopEntry()?.mode ?? "default";
+  }
+  /**
+   * Get the current mode configuration
+   */
+  getCurrentModeConfig() {
+    const mode = this.getCurrentMode();
+    const entry = this.getTopEntry();
+    const baseConfig = getWorkflowModeConfig(mode);
+    if (entry?.customConfig) {
+      const mergedAutoExit = entry.customConfig.autoExitConditions || baseConfig.autoExitConditions ? {
+        ...baseConfig.autoExitConditions ?? {},
+        ...entry.customConfig.autoExitConditions ?? {}
+      } : void 0;
+      return {
+        ...baseConfig,
+        ...entry.customConfig,
+        // Deep merge for nested objects
+        autoExitConditions: mergedAutoExit
+      };
+    }
+    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.getTopEntry();
+    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: INSTRUCTION_SOURCE,
+        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: INSTRUCTION_SOURCE,
+        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/core/workflow/mode-state-manager.ts
+init_esm_shims();
+init_logger();
+init_path_resolver();
+var ModeStateSchema = z.object({
+  mode: z.enum(["default", "plan", "iterate", "review"]),
+  setAt: z.number(),
+  setBy: z.string().optional(),
+  reason: z.string().optional(),
+  expiresAt: z.number().optional()
+});
+var STATE_FILE_PATH = ".automatosx/state/mode.json";
+var DEFAULT_EXPIRATION_MS = 4 * 60 * 60 * 1e3;
+async function getStateFilePath() {
+  const projectRoot = await detectProjectRoot(process.cwd());
+  return join(projectRoot, STATE_FILE_PATH);
+}
+async function loadModeState() {
+  try {
+    const statePath = await getStateFilePath();
+    if (!existsSync(statePath)) {
+      logger.debug("No mode state file found", { path: statePath });
+      return null;
+    }
+    const content = readFileSync(statePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = ModeStateSchema.safeParse(parsed);
+    if (!result.success) {
+      logger.warn("Invalid mode state file", {
+        path: statePath,
+        error: result.error.message
+      });
+      return null;
+    }
+    const state = result.data;
+    if (state.expiresAt && Date.now() > state.expiresAt) {
+      logger.debug("Mode state expired", {
+        mode: state.mode,
+        expiredAt: new Date(state.expiresAt).toISOString()
+      });
+      return null;
+    }
+    logger.debug("Loaded mode state", {
+      mode: state.mode,
+      setAt: new Date(state.setAt).toISOString()
+    });
+    return state;
+  } catch (error) {
+    logger.error("Failed to load mode state", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function saveModeState(mode, options) {
+  try {
+    const statePath = await getStateFilePath();
+    const stateDir = dirname(statePath);
+    if (!existsSync(stateDir)) {
+      mkdirSync(stateDir, { recursive: true });
+    }
+    const state = {
+      mode,
+      setAt: Date.now(),
+      setBy: options?.setBy ?? "cli",
+      reason: options?.reason,
+      expiresAt: Date.now() + (options?.expiresIn ?? DEFAULT_EXPIRATION_MS)
+    };
+    writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+    logger.debug("Saved mode state", {
+      mode,
+      expiresAt: new Date(state.expiresAt).toISOString()
+    });
+    return true;
+  } catch (error) {
+    logger.error("Failed to save mode state", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+async function getCurrentPersistedMode() {
+  const state = await loadModeState();
+  return state?.mode ?? "default";
+}
+function isModePersistenceEnabled() {
+  return process.env.AX_DISABLE_MODE_PERSISTENCE !== "true";
+}
+
+// src/core/workflow/workflow-progress-provider.ts
+init_esm_shims();
+init_logger();
+
+// src/cli/commands/run.ts
 function displayAutoSelectionResult(selection, verbosity, showBanner = true) {
   if (!showBanner || !verbosity.shouldShow("showBanner")) return;
   const confidenceEmoji = selection.confidence === "high" ? "\u2705" : selection.confidence === "medium" ? "\u26A1" : "\u{1F4A1}";
@@ -36225,10 +36821,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"
@@ -36301,10 +36897,6 @@ var runCommand = {
       describe: "Show execution timeline after completion (requires --parallel)",
       type: "boolean",
       default: true
-    }).option("no-spec", {
-      describe: "Bypass spec-kit suggestion for complex tasks (v5.8.3+)",
-      type: "boolean",
-      default: false
     }).option("sandbox", {
       describe: "Sandbox mode for code execution (v6.0.7 Phase 3)",
       type: "string",
@@ -36370,7 +36962,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);
@@ -36436,6 +37028,32 @@ var runCommand = {
         process.exit(1);
       }
     }
+    if (!argv.workflow && !argv.iterate && isModePersistenceEnabled()) {
+      const persistedMode = await getCurrentPersistedMode();
+      if (persistedMode === "iterate") {
+        argv.iterate = true;
+        if (verbosity.shouldShow("showBanner")) {
+          console.log(chalk5.cyan(`\u{1F4CB} Using persisted mode: iterate`));
+          console.log(chalk5.gray(`   (set via \`ax mode iterate\`, use \`ax mode default\` to clear)
+`));
+        }
+        logger.info("Applied persisted iterate mode");
+      } else if (persistedMode === "plan") {
+        if (verbosity.shouldShow("showBanner")) {
+          console.log(chalk5.cyan(`\u{1F4CB} Using persisted mode: plan`));
+          console.log(chalk5.gray(`   (read-only exploration mode)
+`));
+        }
+        logger.info("Applied persisted plan mode");
+      } else if (persistedMode === "review") {
+        if (verbosity.shouldShow("showBanner")) {
+          console.log(chalk5.cyan(`\u{1F4CB} Using persisted mode: review`));
+          console.log(chalk5.gray(`   (code review mode)
+`));
+        }
+        logger.info("Applied persisted review mode");
+      }
+    }
     if (verbosity.isQuiet()) {
       argv.showDependencyGraph = false;
       argv.showTimeline = false;
@@ -36505,7 +37123,7 @@ var runCommand = {
             }
           }
         } catch (error) {
-          if (argv.noAutoSelect) {
+          if (argv.autoSelect === false) {
             console.error(chalk5.red.bold(`
 \u274C Agent not found: ${actualAgent}
 `));
@@ -38052,11 +38670,11 @@ async function getCurrentVersion() {
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
     const { readFile: readFile24 } = await import('fs/promises');
-    const { dirname: dirname14, join: join49 } = await import('path');
+    const { dirname: dirname15, join: join50 } = await import('path');
     const { fileURLToPath: fileURLToPath5 } = await import('url');
     const __filename3 = fileURLToPath5(import.meta.url);
-    const __dirname4 = dirname14(__filename3);
-    const pkgPath = join49(__dirname4, "../../../package.json");
+    const __dirname4 = dirname15(__filename3);
+    const pkgPath = join50(__dirname4, "../../../package.json");
     const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version;
@@ -44867,24 +45485,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;
@@ -44892,15 +45510,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) {
@@ -45088,10 +45706,10 @@ async function handleReset() {
 `));
 }
 async function handleTrace(workspacePath, argv) {
-  const { existsSync: existsSync25, readFileSync: readFileSync8, watchFile } = await import('fs');
-  const { join: join49 } = await import('path');
-  const traceFile = join49(workspacePath, ".automatosx/logs/router.trace.jsonl");
-  if (!existsSync25(traceFile)) {
+  const { existsSync: existsSync26, readFileSync: readFileSync9, watchFile } = await import('fs');
+  const { join: join50 } = await import('path');
+  const traceFile = join50(workspacePath, ".automatosx/logs/router.trace.jsonl");
+  if (!existsSync26(traceFile)) {
     console.log(chalk5.yellow("\n\u26A0\uFE0F  No trace log found\n"));
     console.log(chalk5.gray(`Expected location: ${traceFile}
 `));
@@ -45108,7 +45726,7 @@ async function handleTrace(workspacePath, argv) {
 `));
   if (argv.follow) {
     console.log(chalk5.gray("Following trace log (Ctrl+C to exit)...\n"));
-    const content = readFileSync8(traceFile, "utf-8");
+    const content = readFileSync9(traceFile, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const recentLines = lines.slice(-(argv.lines || 20));
     for (const line of recentLines) {
@@ -45118,7 +45736,7 @@ async function handleTrace(workspacePath, argv) {
     const { unwatchFile } = await import('fs');
     watchFile(traceFile, { interval: 500 }, (curr, prev) => {
       if (curr.size > lastSize) {
-        const newContent = readFileSync8(traceFile, "utf-8");
+        const newContent = readFileSync9(traceFile, "utf-8");
         const newLines = newContent.slice(lastSize).split("\n").filter((l) => l.trim());
         for (const line of newLines) {
           displayTraceEvent(line);
@@ -45136,7 +45754,7 @@ async function handleTrace(workspacePath, argv) {
     await new Promise(() => {
     });
   } else {
-    const content = readFileSync8(traceFile, "utf-8");
+    const content = readFileSync9(traceFile, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const recentLines = lines.slice(-(argv.lines || 20));
     if (recentLines.length === 0) {
@@ -46147,9 +46765,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",
@@ -47294,10 +47914,14 @@ var OptimizationAnalyzer = class {
    * Analyze usage and generate recommendations
    */
   async analyze(timeRange) {
-    logger.debug("Analyzing for optimization opportunities", { timeRange });
+    logger.debug("Analyzing for optimization opportunities", {
+      timeRange,
+      provider: timeRange.provider
+    });
     const summary = await this.analytics.generateSummary({
       startDate: timeRange.start,
-      endDate: timeRange.end
+      endDate: timeRange.end,
+      provider: timeRange.provider
     });
     const recommendations = [];
     recommendations.push(...this.findModelDowngradeOpportunities(summary));
@@ -47384,6 +48008,7 @@ var OptimizationAnalyzer = class {
       type: "cache_hit",
       startDate: timeRange.start,
       endDate: timeRange.end,
+      provider: timeRange.provider,
       limit: 1e4
     });
     const totalExecutions = summary.executions.total;
@@ -47526,10 +48151,11 @@ var analyticsCommand = {
   }
 };
 async function summaryHandler(argv) {
+  let telemetry;
   try {
     const config = await loadConfig(process.cwd());
     const telemetryConfig = config.telemetry || { enabled: false };
-    const telemetry = getTelemetryCollector({
+    telemetry = getTelemetryCollector({
       ...telemetryConfig,
       enabled: true
     });
@@ -47537,15 +48163,19 @@ async function summaryHandler(argv) {
     const timeRange = parseTimePeriod(argv.period || "7d");
     const summary = await analytics.generateSummary({
       startDate: timeRange.startDate,
-      endDate: timeRange.endDate
+      endDate: timeRange.endDate,
+      provider: argv.provider
     });
     if (argv.format === "json") {
       console.log(JSON.stringify(summary, null, 2));
       return;
     }
     console.log(chalk5.bold.cyan("\n\u{1F4CA} AutomatosX Analytics Summary\n"));
-    console.log(chalk5.dim(`Period: ${formatPeriod(argv.period || "7d")}
-`));
+    console.log(chalk5.dim(`Period: ${formatPeriod(argv.period || "7d")}`));
+    if (argv.provider) {
+      console.log(chalk5.dim(`Provider filter: ${argv.provider}`));
+    }
+    console.log();
     console.log(chalk5.bold("Executions"));
     console.log(`  Total: ${summary.executions.total}`);
     console.log(`  Successful: ${chalk5.green(summary.executions.successful)}`);
@@ -47589,13 +48219,16 @@ async function summaryHandler(argv) {
     });
     logger.error("Analytics summary failed", { error: error.message });
     process.exit(1);
+  } finally {
+    await telemetry?.close();
   }
 }
 async function optimizeHandler(argv) {
+  let telemetry;
   try {
     const config = await loadConfig(process.cwd());
     const telemetryConfig = config.telemetry || { enabled: false };
-    const telemetry = getTelemetryCollector({
+    telemetry = getTelemetryCollector({
       ...telemetryConfig,
       enabled: true
     });
@@ -47604,15 +48237,19 @@ async function optimizeHandler(argv) {
     const timeRange = parseTimePeriod(argv.period || "7d");
     const recommendations = await optimizer.analyze({
       start: timeRange.startDate,
-      end: timeRange.endDate
+      end: timeRange.endDate,
+      provider: argv.provider
     });
     if (argv.format === "json") {
       console.log(JSON.stringify(recommendations, null, 2));
       return;
     }
     console.log(chalk5.bold.cyan("\n\u{1F4A1} Optimization Recommendations\n"));
-    console.log(chalk5.dim(`Period: ${formatPeriod(argv.period || "7d")}
-`));
+    console.log(chalk5.dim(`Period: ${formatPeriod(argv.period || "7d")}`));
+    if (argv.provider) {
+      console.log(chalk5.dim(`Provider filter: ${argv.provider}`));
+    }
+    console.log();
     if (recommendations.length === 0) {
       console.log(chalk5.green("\u2705 No optimization opportunities found. You're doing great!\n"));
       return;
@@ -47645,13 +48282,16 @@ async function optimizeHandler(argv) {
     });
     logger.error("Optimization analysis failed", { error: error.message });
     process.exit(1);
+  } finally {
+    await telemetry?.close();
   }
 }
 async function clearHandler(argv) {
+  let telemetry;
   try {
     const config = await loadConfig(process.cwd());
     const telemetryConfig = config.telemetry || { enabled: false };
-    const telemetry = getTelemetryCollector({
+    telemetry = getTelemetryCollector({
       ...telemetryConfig,
       enabled: true
     });
@@ -47678,13 +48318,16 @@ async function clearHandler(argv) {
     });
     logger.error("Clear telemetry failed", { error: error.message });
     process.exit(1);
+  } finally {
+    await telemetry?.close();
   }
 }
 async function statusHandler(argv) {
+  let telemetry;
   try {
     const config = await loadConfig(process.cwd());
     const telemetryConfig = config.telemetry || { enabled: false };
-    const telemetry = getTelemetryCollector({
+    telemetry = getTelemetryCollector({
       ...telemetryConfig,
       enabled: true
     });
@@ -47711,6 +48354,8 @@ async function statusHandler(argv) {
     });
     logger.error("Telemetry status failed", { error: error.message });
     process.exit(1);
+  } finally {
+    await telemetry?.close();
   }
 }
 function parseTimePeriod(period) {
@@ -48519,6 +49164,2782 @@ var uninstallCommand = {
   }
 };
 
+// src/cli/commands/mode.ts
+init_esm_shims();
+init_logger();
+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) {
+        await 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];
+      if (isModePersistenceEnabled()) {
+        const saved = await saveModeState(modeName, {
+          setBy: "cli",
+          reason: `ax mode ${modeName}`
+        });
+        if (saved) {
+          console.log(chalk5.green.bold(`
+\u2705 Workflow mode set to: ${modeName}
+`));
+          console.log(chalk5.gray(`Description: ${modeConfig.description}`));
+        } else {
+          console.log(chalk5.yellow.bold(`
+\u26A0\uFE0F  Mode set to: ${modeName} (not persisted)
+`));
+          console.log(chalk5.gray(`Description: ${modeConfig.description}`));
+        }
+      } else {
+        console.log(chalk5.green.bold(`
+\u2705 Workflow mode set to: ${modeName}
+`));
+        console.log(chalk5.gray(`Description: ${modeConfig.description}`));
+        console.log(chalk5.gray("(Mode persistence disabled via AX_DISABLE_MODE_PERSISTENCE)"));
+      }
+      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();
+      if (modeName === "iterate") {
+        console.log(chalk5.cyan('\u{1F4A1} Tip: Use `ax run <agent> "task"` and it will auto-use iterate mode'));
+      } else if (modeName === "plan") {
+        console.log(chalk5.cyan('\u{1F4A1} Tip: Use `ax run <agent> "task"` and it will auto-use plan mode'));
+        console.log(chalk5.gray("   The mode will persist until you run `ax mode default`"));
+      }
+      console.log();
+      logger.info("Workflow mode set", { mode: modeName, persisted: isModePersistenceEnabled() });
+    } 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"));
+}
+async function displayModeStatus() {
+  const modeState = await loadModeState();
+  const currentMode = modeState?.mode ?? "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 (modeState) {
+    const setAt = new Date(modeState.setAt);
+    const expiresAt = modeState.expiresAt ? new Date(modeState.expiresAt) : null;
+    console.log(`  Set at: ${chalk5.gray(setAt.toLocaleString())}`);
+    if (expiresAt) {
+      const remainingMs = expiresAt.getTime() - Date.now();
+      const remainingMins = Math.round(remainingMs / 6e4);
+      if (remainingMs > 0) {
+        console.log(`  Expires in: ${chalk5.gray(`${remainingMins} minutes`)}`);
+      } else {
+        console.log(`  Status: ${chalk5.yellow("expired (will use default)")}`);
+      }
+    }
+  }
+  if (modeConfig.blockedTools && modeConfig.blockedTools.length > 0) {
+    console.log(`  Blocked tools: ${chalk5.yellow(modeConfig.blockedTools.join(", "))}`);
+  } 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/instruction-injector.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/token-budget.ts
+init_esm_shims();
+init_logger();
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  normal: 2,
+  low: 3
+};
+function createEmptyTypeUsage() {
+  return {
+    task: 0,
+    memory: 0,
+    session: 0,
+    delegation: 0,
+    mode: 0,
+    context: 0
+  };
+}
+var TokenBudgetManager = class _TokenBudgetManager {
+  config;
+  /** Characters per token estimate (conservative) */
+  static CHARS_PER_TOKEN = 4;
+  /** Overhead tokens for system-reminder XML tags and formatting */
+  static FORMATTING_OVERHEAD_TOKENS = 50;
+  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 contentTokens = this.estimateTokens(instruction.content).tokens;
+    return contentTokens + _TokenBudgetManager.FORMATTING_OVERHEAD_TOKENS;
+  }
+  /**
+   * 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 = createEmptyTypeUsage();
+    let tokensUsed = 0;
+    const availableBudget = this.config.maxTotal;
+    const sorted = [...instructions].sort((a, b) => {
+      const aPriority = PRIORITY_ORDER[a.priority];
+      const bPriority = PRIORITY_ORDER[b.priority];
+      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 INSTRUCTION_TYPE_ORDER = ["mode", "task", "context", "memory", "session", "delegation"];
+var OrchestrationInstructionInjector = class {
+  providers = /* @__PURE__ */ new Map();
+  budgetManager;
+  config;
+  lastInjectionTime = 0;
+  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 = [];
+    for (const type of INSTRUCTION_TYPE_ORDER) {
+      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 createdAtTurn = instruction.createdAtTurn ?? currentTurn;
+      const turnsSinceCreation = currentTurn - createdAtTurn;
+      return turnsSinceCreation < instruction.expiresAfter;
+    });
+  }
+  /**
+   * Calculate per-type token usage
+   */
+  calculateTypeUsage(instructions) {
+    const usage = createEmptyTypeUsage();
+    for (const instruction of instructions) {
+      const tokens = this.budgetManager.estimateInstructionTokens(instruction);
+      usage[instruction.type] += tokens;
+    }
+    return usage;
+  }
+  /**
+   * Create an empty result
+   */
+  emptyResult() {
+    return {
+      formattedText: "",
+      instructions: [],
+      allocation: {
+        included: [],
+        excluded: [],
+        tokensUsed: 0,
+        remaining: this.budgetManager.getConfig().maxTotal,
+        perTypeUsage: createEmptyTypeUsage()
+      },
+      hasInstructions: false
+    };
+  }
+  /**
+   * Clear instruction cache (placeholder for future caching implementation)
+   */
+  clearCache() {
+    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 = computeTodoHash(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 = computeTodoHash(context.todos);
+    const stateChanged = currentHash !== this.lastStateHash;
+    const inProgressTasks = [];
+    const pendingTasks = [];
+    const completedTasks = [];
+    for (const todo of context.todos) {
+      switch (todo.status) {
+        case "in_progress":
+          inProgressTasks.push(todo);
+          break;
+        case "pending":
+          pendingTasks.push(todo);
+          break;
+        case "completed":
+          completedTasks.push(todo);
+          break;
+      }
+    }
+    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: INSTRUCTION_SOURCE,
+      createdAt: Date.now(),
+      createdAtTurn: context.turnCount,
+      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(" | ");
+  }
+  /**
+   * 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");
+  }
+};
+function computeTodoHash(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);
+}
+
+// src/core/orchestration/memory-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_CONTENT_MAX_LENGTH = 500;
+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
+  contentMaxLength: DEFAULT_CONTENT_MAX_LENGTH
+};
+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: INSTRUCTION_SOURCE,
+        createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
+        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);
+    }
+    let inProgressCount = 0;
+    for (const todo of context.todos) {
+      if (todo.status === "in_progress") {
+        parts.push(todo.content);
+        if (++inProgressCount >= 2) break;
+      }
+    }
+    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 content = memory.content.length > this.config.contentMaxLength ? memory.content.substring(0, this.config.contentMaxLength) + "..." : 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 SESSION_CACHE_TTL_MS = 3e4;
+var SessionInstructionProvider = class {
+  name = "session";
+  config;
+  stateProvider;
+  lastReminderTurn = 0;
+  cachedState;
+  cacheExpiry = 0;
+  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: INSTRUCTION_SOURCE,
+        createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
+        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() + SESSION_CACHE_TTL_MS;
+      }
+      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 FULLSTACK_TEMPLATE = {
+  ...BACKEND_TEMPLATE,
+  domain: "fullstack",
+  displayName: "Fullstack Engineer"
+};
+var DATA_TEMPLATE = {
+  ...BACKEND_TEMPLATE,
+  domain: "data",
+  displayName: "Data Engineer"
+};
+var MOBILE_TEMPLATE = {
+  ...FRONTEND_TEMPLATE,
+  domain: "mobile",
+  displayName: "Mobile Engineer"
+};
+var RESEARCHER_TEMPLATE = {
+  ...STANDARD_TEMPLATE,
+  domain: "researcher",
+  displayName: "Researcher"
+};
+var AGENT_TEMPLATES = {
+  backend: BACKEND_TEMPLATE,
+  frontend: FRONTEND_TEMPLATE,
+  fullstack: FULLSTACK_TEMPLATE,
+  security: SECURITY_TEMPLATE,
+  quality: QUALITY_TEMPLATE,
+  architecture: ARCHITECTURE_TEMPLATE,
+  devops: DEVOPS_TEMPLATE,
+  data: DATA_TEMPLATE,
+  mobile: MOBILE_TEMPLATE,
+  writer: WRITER_TEMPLATE,
+  researcher: RESEARCHER_TEMPLATE,
+  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,
+  contextAwareBoosting: true
+};
+var CONTEXT_KEYWORD_CATEGORIES = [
+  {
+    name: "security",
+    keywords: ["auth", "authentication", "authorization", "login", "password", "token", "jwt", "oauth", "session", "credential", "encrypt", "decrypt", "hash", "secret", "permission", "role", "access control", "csrf", "xss", "injection", "sanitize", "validate input"],
+    boostDomains: ["security"],
+    additionalChecklist: [
+      "Validate all user input before processing",
+      "Use parameterized queries to prevent injection",
+      "Ensure sensitive data is not logged or exposed",
+      "Implement proper session management",
+      "Follow OWASP Top 10 guidelines"
+    ]
+  },
+  {
+    name: "database",
+    keywords: ["database", "db", "sql", "query", "migration", "schema", "table", "index", "transaction", "orm", "prisma", "mongoose", "postgresql", "mysql", "sqlite", "redis", "cache"],
+    boostDomains: ["backend"],
+    additionalChecklist: [
+      "Use transactions for multi-step operations",
+      "Add appropriate indexes for query performance",
+      "Handle connection pooling properly",
+      "Avoid N+1 query patterns",
+      "Use prepared statements for security"
+    ]
+  },
+  {
+    name: "api",
+    keywords: ["api", "endpoint", "rest", "graphql", "request", "response", "http", "status code", "route", "middleware", "cors", "rate limit"],
+    boostDomains: ["backend"],
+    additionalChecklist: [
+      "Use appropriate HTTP status codes",
+      "Validate request body and parameters",
+      "Document API with clear examples",
+      "Implement proper error responses",
+      "Consider rate limiting for public endpoints"
+    ]
+  },
+  {
+    name: "testing",
+    keywords: ["test", "testing", "unit test", "integration test", "e2e", "mock", "stub", "fixture", "coverage", "assert", "expect", "vitest", "jest", "cypress"],
+    boostDomains: ["quality"],
+    additionalChecklist: [
+      "Test behavior, not implementation details",
+      "Include edge cases and error scenarios",
+      "Keep tests isolated and independent",
+      "Use meaningful test descriptions",
+      "Aim for high coverage on critical paths"
+    ]
+  },
+  {
+    name: "performance",
+    keywords: ["performance", "optimize", "slow", "fast", "latency", "memory", "cpu", "bottleneck", "profiling", "benchmark", "cache", "lazy load", "debounce", "throttle"],
+    boostDomains: ["backend", "devops"],
+    additionalChecklist: [
+      "Profile before optimizing",
+      "Consider caching for expensive operations",
+      "Avoid premature optimization",
+      "Measure impact of changes",
+      "Watch for memory leaks"
+    ]
+  },
+  {
+    name: "deployment",
+    keywords: ["deploy", "deployment", "ci", "cd", "pipeline", "docker", "kubernetes", "container", "production", "staging", "environment", "config", "secret", "infrastructure"],
+    boostDomains: ["devops"],
+    additionalChecklist: [
+      "Never hardcode secrets or credentials",
+      "Use environment variables for configuration",
+      "Ensure rollback strategy exists",
+      "Test in staging before production",
+      "Monitor deployment health"
+    ]
+  },
+  {
+    name: "frontend",
+    keywords: ["ui", "ux", "component", "react", "vue", "angular", "css", "style", "responsive", "accessibility", "a11y", "wcag", "form", "validation", "state", "render"],
+    boostDomains: ["frontend"],
+    additionalChecklist: [
+      "Ensure accessibility (ARIA labels, keyboard nav)",
+      "Handle loading and error states",
+      "Optimize for performance (memo, lazy loading)",
+      "Test across different screen sizes",
+      "Validate forms with clear error messages"
+    ]
+  }
+];
+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 taskText = this.extractTaskText(context);
+    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 && taskText !== this.recentTaskText && this.checkDelegationTriggers(context, domain, taskText);
+    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: INSTRUCTION_SOURCE,
+        createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
+        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: INSTRUCTION_SOURCE,
+        createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
+        expiresAfter: this.config.qualityChecklistFrequency,
+        id: `agent-quality-${domain}-${Date.now()}`
+      });
+      this.lastQualityCheckTurn = context.turnCount;
+    }
+    const taskText = this.extractTaskText(context);
+    if (this.config.delegationDetection) {
+      if (taskText !== this.recentTaskText) {
+        this.recentTaskText = taskText;
+        const delegationContent = this.checkAndFormatDelegation(template, taskText);
+        if (delegationContent) {
+          instructions.push({
+            type: "delegation",
+            priority: "high",
+            content: delegationContent,
+            source: INSTRUCTION_SOURCE,
+            createdAt: Date.now(),
+            createdAtTurn: context.turnCount,
+            expiresAfter: 3,
+            id: `agent-delegation-${Date.now()}`
+          });
+        }
+      }
+    }
+    if (this.config.contextAwareBoosting && taskText) {
+      const detectedCategories = this.detectContextCategories(taskText);
+      const contextBoostContent = this.formatContextBoost(detectedCategories);
+      if (contextBoostContent) {
+        instructions.push({
+          type: "context",
+          priority: "normal",
+          content: contextBoostContent,
+          source: INSTRUCTION_SOURCE,
+          createdAt: Date.now(),
+          createdAtTurn: context.turnCount,
+          expiresAfter: 5,
+          id: `agent-context-boost-${Date.now()}`
+        });
+        logger.debug("Context-aware boost applied", {
+          categories: detectedCategories.map((c) => c.name)
+        });
+      }
+    }
+    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) {
+      if (todo.status === "in_progress") {
+        parts.push(todo.content);
+      }
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Check if delegation triggers are present
+   */
+  checkDelegationTriggers(context, domain, taskText) {
+    const resolvedDomain = domain ?? this.resolveDomain(context);
+    if (!resolvedDomain) return false;
+    const text = taskText ?? this.extractTaskText(context);
+    if (!text) return false;
+    const suggestions = getDelegationSuggestions(text, resolvedDomain);
+    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");
+  }
+  /**
+   * Detect context categories from task text
+   * @since v11.3.1
+   */
+  detectContextCategories(taskText) {
+    if (!taskText || !this.config.contextAwareBoosting) {
+      return [];
+    }
+    const textLower = taskText.toLowerCase();
+    const matchedCategories = [];
+    for (const category of CONTEXT_KEYWORD_CATEGORIES) {
+      const matchCount = category.keywords.filter(
+        (kw) => textLower.includes(kw.toLowerCase())
+      ).length;
+      if (matchCount > 0) {
+        matchedCategories.push(category);
+      }
+    }
+    return matchedCategories;
+  }
+  /**
+   * Format context-aware boosted instructions
+   * @since v11.3.1
+   */
+  formatContextBoost(categories) {
+    if (categories.length === 0) {
+      return null;
+    }
+    const lines = [];
+    const allChecklistItems = /* @__PURE__ */ new Set();
+    const categoryNames = [];
+    for (const category of categories) {
+      categoryNames.push(category.name);
+      for (const item of category.additionalChecklist.slice(0, 3)) {
+        allChecklistItems.add(item);
+      }
+    }
+    if (allChecklistItems.size === 0) {
+      return null;
+    }
+    lines.push(`## Context-Aware Reminders (${categoryNames.join(", ")})`);
+    lines.push("");
+    lines.push("Based on task keywords, ensure you:");
+    for (const item of Array.from(allChecklistItems).slice(0, 5)) {
+      lines.push(`- ${item}`);
+    }
+    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
+   *
+   * @throws Error if mode is not a valid WorkflowMode
+   */
+  setWorkflowMode(mode) {
+    if (!isValidWorkflowMode(mode)) {
+      throw new Error(`Invalid workflow mode: ${mode}. Valid modes: default, plan, iterate, review`);
+    }
+    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++;
+    this.workflowModeManager.updateTurnCount(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,
+      tokenBudget: updates.tokenBudget ? { ...this.config.tokenBudget, ...updates.tokenBudget } : this.config.tokenBudget,
+      todoIntegration: updates.todoIntegration ? { ...this.config.todoIntegration, ...updates.todoIntegration } : this.config.todoIntegration,
+      memoryIntegration: updates.memoryIntegration ? { ...this.config.memoryIntegration, ...updates.memoryIntegration } : this.config.memoryIntegration,
+      sessionIntegration: updates.sessionIntegration ? { ...this.config.sessionIntegration, ...updates.sessionIntegration } : this.config.sessionIntegration,
+      agentTemplates: updates.agentTemplates ? { ...this.config.agentTemplates, ...updates.agentTemplates } : this.config.agentTemplates
+    };
+    if (updates.tokenBudget) {
+      this.tokenBudgetManager.updateConfig(this.config.tokenBudget);
+    }
+    this.injector.updateConfig(updates);
+    if (updates.todoIntegration && this.todoProvider) {
+      const current = this.todoProvider.getConfig();
+      this.todoProvider.updateConfig({
+        enabled: updates.todoIntegration.enabled ?? current.enabled,
+        reminderFrequency: updates.todoIntegration.reminderFrequency ?? current.reminderFrequency,
+        compactMode: updates.todoIntegration.compactMode ?? current.compactMode
+      });
+    }
+    if (updates.memoryIntegration && this.memoryProvider) {
+      const current = this.memoryProvider.getConfig();
+      this.memoryProvider.updateConfig({
+        enabled: updates.memoryIntegration.enabled ?? current.enabled,
+        maxEntries: updates.memoryIntegration.maxEntries ?? current.maxEntries,
+        minRelevance: updates.memoryIntegration.minRelevance ?? current.minRelevance
+      });
+    }
+    if (updates.sessionIntegration && this.sessionProvider) {
+      const current = this.sessionProvider.getConfig();
+      this.sessionProvider.updateConfig({
+        enabled: updates.sessionIntegration.enabled ?? current.enabled,
+        showCollaboration: updates.sessionIntegration.showCollaboration ?? current.showCollaboration
+      });
+    }
+    if (updates.agentTemplates) {
+      const agentUpdates = {};
+      if (updates.agentTemplates.enabled !== void 0) {
+        agentUpdates.enabled = updates.agentTemplates.enabled;
+      }
+      if (updates.agentTemplates.reminderFrequency !== void 0) {
+        agentUpdates.reminderFrequency = updates.agentTemplates.reminderFrequency;
+      }
+      this.agentInjector.updateConfig(agentUpdates);
+    }
+    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 typeDescriptions = {
+    task: "Todo/task reminders",
+    memory: "Memory context",
+    session: "Session state",
+    delegation: "Agent delegation hints",
+    mode: "Workflow mode instructions",
+    context: "Context-aware boosted reminders"
+  };
+  Object.entries(config.perType).forEach(([type, budget]) => {
+    console.log(`    \u2022 ${chalk5.cyan(type)}: ${budget} tokens`);
+    if (verbose && typeDescriptions[type]) {
+      console.log(chalk5.gray(`      ${typeDescriptions[type]}`));
+    }
+  });
+  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/commands/shortcuts.ts
+init_esm_shims();
+init_logger();
+async function runAxCommand(args) {
+  return new Promise((resolve13, reject) => {
+    const nodeExe = process.argv[0];
+    const cliScript = process.argv[1];
+    if (!nodeExe || !cliScript) {
+      reject(new Error("Cannot determine CLI path"));
+      return;
+    }
+    const child = spawn(nodeExe, [cliScript, ...args], {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve13();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+var planCommand = {
+  command: "plan [task]",
+  describe: "Enter plan mode and explore/plan a task (shortcut for ax mode plan + ax run)",
+  builder: (yargs2) => {
+    return yargs2.positional("task", {
+      describe: "Task to plan (optional - if not provided, just sets mode)",
+      type: "string"
+    }).option("agent", {
+      alias: "a",
+      describe: "Agent to use (auto-selects if not specified)",
+      type: "string"
+    }).option("provider", {
+      alias: "p",
+      describe: "Override provider",
+      type: "string"
+    }).option("verbose", {
+      alias: "v",
+      describe: "Verbose output",
+      type: "boolean",
+      default: false
+    }).option("quiet", {
+      alias: "q",
+      describe: "Quiet output",
+      type: "boolean",
+      default: false
+    }).example("$0 plan", "Enter plan mode").example('$0 plan "design auth system"', "Plan a task with auto-selected agent").example('$0 plan "design API" --agent architecture', "Plan with specific agent");
+  },
+  handler: async (argv) => {
+    try {
+      const saved = await saveModeState("plan", {
+        setBy: "shortcut",
+        reason: "ax plan command"
+      });
+      if (!saved) {
+        logger.warn("Failed to persist mode state, continuing anyway");
+      }
+      if (!argv.quiet) {
+        console.log(chalk5.cyan.bold("\n\u{1F4CB} Plan Mode Activated\n"));
+        console.log(chalk5.gray("Read-only exploration mode - no file modifications allowed"));
+        console.log(chalk5.gray("Use `ax mode default` to exit plan mode\n"));
+      }
+      if (argv.task) {
+        const runArgs = ["run"];
+        if (argv.agent) runArgs.push(argv.agent);
+        runArgs.push(argv.task);
+        if (argv.provider) runArgs.push("--provider", argv.provider);
+        if (argv.verbose) runArgs.push("--verbose");
+        if (argv.quiet) runArgs.push("--quiet");
+        await runAxCommand(runArgs);
+      } else {
+        console.log(chalk5.gray('No task specified. Use `ax run <agent> "task"` to run in plan mode.'));
+      }
+      logger.info("Plan shortcut executed", { task: argv.task, agent: argv.agent });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      process.exit(1);
+    }
+  }
+};
+var iterateCommand = {
+  command: "iterate [task]",
+  describe: "Enter iterate mode and run a task autonomously (shortcut for ax mode iterate + ax run --iterate)",
+  builder: (yargs2) => {
+    return yargs2.positional("task", {
+      describe: "Task to execute (optional - if not provided, just sets mode)",
+      type: "string"
+    }).option("agent", {
+      alias: "a",
+      describe: "Agent to use (auto-selects if not specified)",
+      type: "string"
+    }).option("timeout", {
+      alias: "t",
+      describe: "Max duration in minutes",
+      type: "number"
+    }).option("max-tokens", {
+      describe: "Max total tokens",
+      type: "number"
+    }).option("provider", {
+      alias: "p",
+      describe: "Override provider",
+      type: "string"
+    }).option("verbose", {
+      alias: "v",
+      describe: "Verbose output",
+      type: "boolean",
+      default: false
+    }).option("quiet", {
+      alias: "q",
+      describe: "Quiet output",
+      type: "boolean",
+      default: false
+    }).example("$0 iterate", "Enter iterate mode").example('$0 iterate "implement auth"', "Run task in iterate mode").example('$0 iterate "fix bug" --agent backend', "Iterate with specific agent");
+  },
+  handler: async (argv) => {
+    try {
+      const saved = await saveModeState("iterate", {
+        setBy: "shortcut",
+        reason: "ax iterate command"
+      });
+      if (!saved) {
+        logger.warn("Failed to persist mode state, continuing anyway");
+      }
+      if (!argv.quiet) {
+        console.log(chalk5.cyan.bold("\n\u{1F504} Iterate Mode Activated\n"));
+        console.log(chalk5.gray("Autonomous execution mode - agent will work continuously"));
+        console.log(chalk5.gray("Use `ax mode default` to exit iterate mode\n"));
+      }
+      if (argv.task) {
+        const runArgs = ["run"];
+        if (argv.agent) runArgs.push(argv.agent);
+        runArgs.push(argv.task);
+        runArgs.push("--iterate");
+        if (argv.timeout) runArgs.push("--iterate-timeout", String(argv.timeout));
+        if (argv.maxTokens) runArgs.push("--iterate-max-tokens", String(argv.maxTokens));
+        if (argv.provider) runArgs.push("--provider", argv.provider);
+        if (argv.verbose) runArgs.push("--verbose");
+        if (argv.quiet) runArgs.push("--quiet");
+        await runAxCommand(runArgs);
+      } else {
+        console.log(chalk5.gray('No task specified. Use `ax run <agent> "task"` to run in iterate mode.'));
+      }
+      logger.info("Iterate shortcut executed", { task: argv.task, agent: argv.agent });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      process.exit(1);
+    }
+  }
+};
+var reviewCommand = {
+  command: "review [path]",
+  describe: "Enter review mode and analyze code (shortcut for ax mode review + ax run quality)",
+  builder: (yargs2) => {
+    return yargs2.positional("path", {
+      describe: "Path to review (file or directory)",
+      type: "string"
+    }).option("agent", {
+      alias: "a",
+      describe: "Agent to use (defaults to quality)",
+      type: "string",
+      default: "quality"
+    }).option("provider", {
+      alias: "p",
+      describe: "Override provider",
+      type: "string"
+    }).option("verbose", {
+      alias: "v",
+      describe: "Verbose output",
+      type: "boolean",
+      default: false
+    }).option("quiet", {
+      alias: "q",
+      describe: "Quiet output",
+      type: "boolean",
+      default: false
+    }).example("$0 review", "Enter review mode").example("$0 review src/core/", "Review a directory").example("$0 review src/api.ts", "Review a specific file");
+  },
+  handler: async (argv) => {
+    try {
+      const saved = await saveModeState("review", {
+        setBy: "shortcut",
+        reason: "ax review command"
+      });
+      if (!saved) {
+        logger.warn("Failed to persist mode state, continuing anyway");
+      }
+      if (!argv.quiet) {
+        console.log(chalk5.cyan.bold("\n\u{1F50D} Review Mode Activated\n"));
+        console.log(chalk5.gray("Code review mode - analyzing for quality, security, and best practices"));
+        console.log(chalk5.gray("Use `ax mode default` to exit review mode\n"));
+      }
+      if (argv.path) {
+        const task = `Review the code at ${argv.path} for quality, security, and best practices`;
+        const runArgs = ["run", argv.agent || "quality", task];
+        if (argv.provider) runArgs.push("--provider", argv.provider);
+        if (argv.verbose) runArgs.push("--verbose");
+        if (argv.quiet) runArgs.push("--quiet");
+        await runAxCommand(runArgs);
+      } else {
+        console.log(chalk5.gray('No path specified. Use `ax run quality "Review <path>"` to review code.'));
+      }
+      logger.info("Review shortcut executed", { path: argv.path, agent: argv.agent });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      process.exit(1);
+    }
+  }
+};
+
 // src/cli/index.ts
 installExitHandlers();
 var VERSION2 = getVersion();
@@ -48541,7 +51962,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).command(planCommand).command(iterateCommand).command(reviewCommand).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");