@defai.digital/automatosx 11.3.0 → 11.3.1

package/dist/index.js

@@ -3013,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",
@@ -3025,7 +3029,7 @@ ${fullPrompt}
               completion: 0,
               total: 0
             },
-            latencyMs: Date.now() - startTime,
+            latencyMs,
             finishReason: "stop",
             cached: false
           };
@@ -3045,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);
         }
       }
@@ -3065,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;
         }
       }
@@ -3072,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
         };
       }
       /**
@@ -3796,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
             });
@@ -3805,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();
@@ -3820,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;
@@ -3847,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) {
@@ -5539,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);
       }
@@ -5555,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");
       }
@@ -7042,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) {
@@ -9273,7 +9320,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.0"
+  "version": "11.3.1"
 };
 
 // src/core/config/schemas.ts
@@ -10127,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) {
@@ -13201,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",
@@ -13396,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"));
@@ -13450,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'));
@@ -13891,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
@@ -13974,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 });
@@ -16156,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")) {
@@ -16173,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")) {
@@ -36212,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}";
@@ -36311,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",
@@ -36446,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;
@@ -38062,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;
@@ -45098,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}
 `));
@@ -45118,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) {
@@ -45128,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);
@@ -45146,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) {
@@ -47306,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));
@@ -47396,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;
@@ -47538,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
     });
@@ -47549,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)}`);
@@ -47601,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
     });
@@ -47616,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;
@@ -47657,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
     });
@@ -47690,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
     });
@@ -47723,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) {
@@ -48534,489 +49167,6 @@ var uninstallCommand = {
 // src/cli/commands/mode.ts
 init_esm_shims();
 init_logger();
-
-// src/core/workflow/index.ts
-init_esm_shims();
-
-// src/core/workflow/workflow-mode.ts
-init_esm_shims();
-var WorkflowModeSchema = z.enum(["default", "plan", "iterate", "review"]);
-z.object({
-  name: WorkflowModeSchema,
-  description: z.string(),
-  displayName: z.string(),
-  allowedTools: z.array(z.string()).optional(),
-  blockedTools: z.array(z.string()).optional(),
-  systemInstructions: z.string(),
-  allowNesting: z.boolean(),
-  maxNestingDepth: z.number().int().positive().optional(),
-  autoExitConditions: z.object({
-    maxTurns: z.number().int().positive().optional(),
-    onToolUse: z.array(z.string()).optional(),
-    onKeywords: z.array(z.string()).optional()
-  }).optional()
-});
-var WRITE_TOOLS = [
-  "Write",
-  "Edit",
-  "NotebookEdit",
-  "Bash"
-];
-var DEFAULT_MODE_CONFIG = {
-  name: "default",
-  displayName: "Default",
-  description: "Standard operation mode with all tools available",
-  systemInstructions: "",
-  allowNesting: true,
-  maxNestingDepth: 3
-};
-var PLAN_MODE_CONFIG = {
-  name: "plan",
-  displayName: "Plan Mode",
-  description: "Planning mode - read-only exploration without code modifications",
-  blockedTools: [...WRITE_TOOLS],
-  systemInstructions: `## Plan Mode Active
-
-You are in **Plan Mode**. This mode is for exploration and planning only.
-
-**Restrictions:**
-- You CANNOT use Write, Edit, or Bash tools that modify files
-- Focus on reading, searching, and understanding the codebase
-- Create a comprehensive plan before implementation
-
-**Your Goals:**
-1. Explore the codebase to understand existing patterns
-2. Identify files that need to be modified
-3. Design an implementation approach
-4. Document your plan clearly
-5. Use ExitPlanMode when ready to implement
-
-**Remember:** No code modifications in this mode. Plan first, implement later.`,
-  allowNesting: false,
-  autoExitConditions: {
-    onToolUse: ["ExitPlanMode"]
-  }
-};
-var ITERATE_MODE_CONFIG = {
-  name: "iterate",
-  displayName: "Iterate Mode",
-  description: "Continuous iteration mode for implementation with automatic continuation",
-  systemInstructions: `## Iterate Mode Active
-
-You are in **Iterate Mode**. This mode enables continuous task execution.
-
-**Behavior:**
-- Continue working until the task is complete
-- After each step, assess progress and continue
-- Don't stop to ask for confirmation unless critical
-- Mark todos as completed as you finish them
-
-**Guidelines:**
-1. Work through tasks systematically
-2. Test changes as you go when possible
-3. Update todo list to track progress
-4. Only pause for critical decisions or blockers
-
-**Remember:** Keep iterating until the task is done or you hit a blocker.`,
-  allowNesting: true,
-  maxNestingDepth: 2
-};
-var REVIEW_MODE_CONFIG = {
-  name: "review",
-  displayName: "Review Mode",
-  description: "Code review mode - analyze code quality, security, and best practices",
-  blockedTools: [...WRITE_TOOLS],
-  systemInstructions: `## Review Mode Active
-
-You are in **Review Mode**. This mode is for code review and analysis.
-
-**Focus Areas:**
-- Code quality and readability
-- Security vulnerabilities (OWASP Top 10)
-- Performance issues
-- Best practices and patterns
-- Test coverage gaps
-
-**Output Format:**
-Provide structured feedback:
-1. **Critical Issues** - Must fix before merge
-2. **Warnings** - Should address
-3. **Suggestions** - Nice to have improvements
-4. **Positive Notes** - Good patterns observed
-
-**Remember:** No code modifications. Provide actionable feedback only.`,
-  allowNesting: false
-};
-var WORKFLOW_MODE_CONFIGS = {
-  default: DEFAULT_MODE_CONFIG,
-  plan: PLAN_MODE_CONFIG,
-  iterate: ITERATE_MODE_CONFIG,
-  review: REVIEW_MODE_CONFIG
-};
-function getWorkflowModeConfig(mode) {
-  return WORKFLOW_MODE_CONFIGS[mode];
-}
-function isToolAllowedInMode(tool, mode) {
-  const config = getWorkflowModeConfig(mode);
-  if (config.allowedTools && config.allowedTools.length > 0) {
-    return config.allowedTools.includes(tool);
-  }
-  if (config.blockedTools && config.blockedTools.length > 0) {
-    return !config.blockedTools.includes(tool);
-  }
-  return true;
-}
-function isValidWorkflowMode(mode) {
-  return mode in WORKFLOW_MODE_CONFIGS;
-}
-var WORKFLOW_MODES = WORKFLOW_MODE_CONFIGS;
-
-// src/core/workflow/workflow-mode-manager.ts
-init_esm_shims();
-init_logger();
-var WorkflowModeManager = class {
-  name = "workflow-mode";
-  modeStack = [];
-  transitionListeners = /* @__PURE__ */ new Set();
-  turnCount = 0;
-  constructor(initialMode = "default") {
-    this.modeStack.push({
-      mode: initialMode,
-      enteredAt: Date.now(),
-      enteredAtTurn: 0,
-      reason: "initial"
-    });
-    logger.debug("WorkflowModeManager initialized", {
-      initialMode
-    });
-  }
-  /**
-   * Get the current active mode
-   */
-  getCurrentMode() {
-    const top = this.modeStack[this.modeStack.length - 1];
-    return top?.mode ?? "default";
-  }
-  /**
-   * Get the current mode configuration
-   */
-  getCurrentModeConfig() {
-    const mode = this.getCurrentMode();
-    const entry = this.modeStack[this.modeStack.length - 1];
-    const baseConfig = getWorkflowModeConfig(mode);
-    if (entry?.customConfig) {
-      return {
-        ...baseConfig,
-        ...entry.customConfig,
-        // Deep merge for nested objects
-        autoExitConditions: {
-          ...baseConfig.autoExitConditions,
-          ...entry.customConfig.autoExitConditions
-        }
-      };
-    }
-    return baseConfig;
-  }
-  /**
-   * Get the full mode stack
-   */
-  getModeStack() {
-    return [...this.modeStack];
-  }
-  /**
-   * Get the current stack depth
-   */
-  getStackDepth() {
-    return this.modeStack.length;
-  }
-  /**
-   * Push a new mode onto the stack
-   */
-  pushMode(mode, options) {
-    const currentConfig = this.getCurrentModeConfig();
-    if (!currentConfig.allowNesting) {
-      logger.warn("Cannot push mode: current mode does not allow nesting", {
-        currentMode: this.getCurrentMode(),
-        attemptedMode: mode
-      });
-      return false;
-    }
-    const maxDepth = currentConfig.maxNestingDepth ?? 3;
-    if (this.modeStack.length >= maxDepth) {
-      logger.warn("Cannot push mode: max nesting depth reached", {
-        currentDepth: this.modeStack.length,
-        maxDepth
-      });
-      return false;
-    }
-    const previousMode = this.getCurrentMode();
-    this.modeStack.push({
-      mode,
-      enteredAt: Date.now(),
-      enteredAtTurn: this.turnCount,
-      customConfig: options?.customConfig,
-      reason: options?.reason
-    });
-    this.emitTransition({
-      from: previousMode,
-      to: mode,
-      type: "push",
-      timestamp: Date.now(),
-      reason: options?.reason
-    });
-    logger.info("Pushed workflow mode", {
-      from: previousMode,
-      to: mode,
-      stackDepth: this.modeStack.length,
-      reason: options?.reason
-    });
-    return true;
-  }
-  /**
-   * Pop the current mode from the stack
-   */
-  popMode(reason) {
-    if (this.modeStack.length <= 1) {
-      logger.warn("Cannot pop mode: at base level");
-      return null;
-    }
-    const popped = this.modeStack.pop();
-    const newMode = this.getCurrentMode();
-    if (popped) {
-      this.emitTransition({
-        from: popped.mode,
-        to: newMode,
-        type: "pop",
-        timestamp: Date.now(),
-        reason
-      });
-      logger.info("Popped workflow mode", {
-        from: popped.mode,
-        to: newMode,
-        stackDepth: this.modeStack.length,
-        reason
-      });
-    }
-    return popped?.mode ?? null;
-  }
-  /**
-   * Replace the current mode (pop then push)
-   */
-  replaceMode(mode, options) {
-    const previousMode = this.getCurrentMode();
-    if (this.modeStack.length === 1) {
-      this.modeStack[0] = {
-        mode,
-        enteredAt: Date.now(),
-        enteredAtTurn: this.turnCount,
-        customConfig: options?.customConfig,
-        reason: options?.reason
-      };
-    } else {
-      this.modeStack.pop();
-      this.modeStack.push({
-        mode,
-        enteredAt: Date.now(),
-        enteredAtTurn: this.turnCount,
-        customConfig: options?.customConfig,
-        reason: options?.reason
-      });
-    }
-    this.emitTransition({
-      from: previousMode,
-      to: mode,
-      type: "replace",
-      timestamp: Date.now(),
-      reason: options?.reason
-    });
-    logger.info("Replaced workflow mode", {
-      from: previousMode,
-      to: mode,
-      reason: options?.reason
-    });
-    return true;
-  }
-  /**
-   * Set mode directly (clears stack and sets new base mode)
-   */
-  setMode(mode, options) {
-    const previousMode = this.getCurrentMode();
-    this.modeStack = [{
-      mode,
-      enteredAt: Date.now(),
-      enteredAtTurn: this.turnCount,
-      customConfig: options?.customConfig,
-      reason: options?.reason
-    }];
-    this.emitTransition({
-      from: previousMode,
-      to: mode,
-      type: "replace",
-      timestamp: Date.now(),
-      reason: options?.reason
-    });
-    logger.info("Set workflow mode", {
-      from: previousMode,
-      to: mode,
-      reason: options?.reason
-    });
-  }
-  /**
-   * Check if a tool is allowed in the current mode
-   */
-  isToolAllowed(tool) {
-    return isToolAllowedInMode(tool, this.getCurrentMode());
-  }
-  /**
-   * Get list of blocked tools in current mode
-   */
-  getBlockedTools() {
-    const config = this.getCurrentModeConfig();
-    return config.blockedTools || [];
-  }
-  /**
-   * Filter a list of tools based on current mode
-   */
-  filterTools(tools) {
-    return tools.filter((tool) => this.isToolAllowed(tool.name));
-  }
-  /**
-   * Update turn count (for auto-exit tracking)
-   */
-  updateTurnCount(turn) {
-    this.turnCount = turn;
-    this.checkAutoExit();
-  }
-  /**
-   * Check and handle auto-exit conditions
-   */
-  checkAutoExit() {
-    const config = this.getCurrentModeConfig();
-    const entry = this.modeStack[this.modeStack.length - 1];
-    if (!config.autoExitConditions || !entry) return;
-    if (config.autoExitConditions.maxTurns) {
-      const turnsInMode = this.turnCount - entry.enteredAtTurn;
-      if (turnsInMode >= config.autoExitConditions.maxTurns) {
-        logger.info("Auto-exiting mode due to max turns", {
-          mode: this.getCurrentMode(),
-          turnsInMode,
-          maxTurns: config.autoExitConditions.maxTurns
-        });
-        this.popMode("max_turns_reached");
-      }
-    }
-  }
-  /**
-   * Notify that a tool was used (for auto-exit on tool use)
-   */
-  notifyToolUsed(tool) {
-    const config = this.getCurrentModeConfig();
-    if (config.autoExitConditions?.onToolUse?.includes(tool)) {
-      logger.info("Auto-exiting mode due to tool use", {
-        mode: this.getCurrentMode(),
-        tool
-      });
-      this.popMode(`tool_used:${tool}`);
-    }
-  }
-  /**
-   * Add a mode transition listener
-   */
-  onTransition(listener) {
-    this.transitionListeners.add(listener);
-    return () => this.transitionListeners.delete(listener);
-  }
-  /**
-   * Emit a transition event to all listeners
-   */
-  emitTransition(event) {
-    for (const listener of this.transitionListeners) {
-      try {
-        listener(event);
-      } catch (error) {
-        logger.error("Mode transition listener error", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  // InstructionProvider implementation
-  /**
-   * Check if mode instructions should be generated
-   */
-  shouldGenerate(context) {
-    return this.getCurrentMode() !== "default";
-  }
-  /**
-   * Get mode-specific instructions
-   */
-  async getInstructions(context) {
-    const config = this.getCurrentModeConfig();
-    const instructions = [];
-    if (config.systemInstructions && config.systemInstructions.length > 0) {
-      instructions.push({
-        type: "mode",
-        priority: "high",
-        content: config.systemInstructions,
-        source: "automatosx",
-        createdAt: Date.now(),
-        id: `mode-${config.name}-${Date.now()}`
-      });
-    }
-    if (config.blockedTools && config.blockedTools.length > 0) {
-      instructions.push({
-        type: "mode",
-        priority: "critical",
-        content: `**Tool Restrictions:** The following tools are NOT available in ${config.displayName}: ${config.blockedTools.join(", ")}`,
-        source: "automatosx",
-        createdAt: Date.now(),
-        id: `mode-blocked-tools-${Date.now()}`
-      });
-    }
-    return instructions;
-  }
-  /**
-   * Reset to default state
-   */
-  reset() {
-    const previousMode = this.getCurrentMode();
-    this.modeStack = [{
-      mode: "default",
-      enteredAt: Date.now(),
-      enteredAtTurn: 0,
-      reason: "reset"
-    }];
-    this.turnCount = 0;
-    if (previousMode !== "default") {
-      this.emitTransition({
-        from: previousMode,
-        to: "default",
-        type: "replace",
-        timestamp: Date.now(),
-        reason: "reset"
-      });
-    }
-    logger.debug("WorkflowModeManager reset");
-  }
-  /**
-   * Get status information for debugging
-   */
-  getStatus() {
-    return {
-      currentMode: this.getCurrentMode(),
-      stackDepth: this.modeStack.length,
-      stack: this.modeStack.map((entry) => ({
-        mode: entry.mode,
-        enteredAt: entry.enteredAt,
-        reason: entry.reason
-      })),
-      blockedTools: this.getBlockedTools(),
-      turnCount: this.turnCount
-    };
-  }
-};
-
-// src/cli/commands/mode.ts
 var modeCommand = {
   command: "mode [mode]",
   describe: "Manage workflow modes for embedded instructions (v11.3.0)",
@@ -49043,7 +49193,7 @@ var modeCommand = {
         return;
       }
       if (argv.status || !argv.mode) {
-        displayModeStatus();
+        await displayModeStatus();
         return;
       }
       const modeName = argv.mode.toLowerCase();
@@ -49059,10 +49209,29 @@ var modeCommand = {
         process.exit(1);
       }
       const modeConfig = WORKFLOW_MODES[modeName];
-      console.log(chalk5.green.bold(`
+      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}`));
+          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) => {
@@ -49076,9 +49245,14 @@ var modeCommand = {
         });
       }
       console.log();
-      console.log(chalk5.gray("Note: Mode setting applies to the current session."));
-      console.log(chalk5.gray("Use with --iterate flag in ax run for persistent mode.\n"));
-      logger.info("Workflow mode set", { mode: modeName });
+      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(`
@@ -49108,15 +49282,30 @@ function displayModeList() {
   console.log(chalk5.gray("\nUsage: ax mode <mode-name>"));
   console.log(chalk5.gray("Example: ax mode plan\n"));
 }
-function displayModeStatus() {
-  const currentMode = "default";
+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.length)}`);
+    console.log(`  Blocked tools: ${chalk5.yellow(modeConfig.blockedTools.join(", "))}`);
   } else {
     console.log(`  Blocked tools: ${chalk5.green("none")}`);
   }
@@ -49134,113 +49323,6 @@ init_logger();
 init_esm_shims();
 init_logger();
 
-// src/core/orchestration/types.ts
-init_esm_shims();
-z.object({
-  type: z.enum(["task", "memory", "session", "delegation", "mode"]),
-  priority: z.enum(["critical", "high", "normal", "low"]),
-  content: z.string().min(1).max(5e3),
-  source: z.literal("automatosx"),
-  expiresAfter: z.number().int().positive().optional(),
-  createdAt: z.number(),
-  id: z.string().optional()
-});
-var TodoItemSchema = z.object({
-  id: z.string(),
-  content: z.string().min(1).max(1e3),
-  status: z.enum(["pending", "in_progress", "completed"]),
-  activeForm: z.string().min(1).max(1e3),
-  createdAt: z.number(),
-  updatedAt: z.number().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-z.object({
-  name: z.enum(["default", "plan", "iterate", "review"]),
-  description: z.string(),
-  allowedTools: z.array(z.string()).optional(),
-  blockedTools: z.array(z.string()).optional(),
-  systemInstructions: z.string(),
-  allowNesting: z.boolean()
-});
-z.object({
-  todos: z.array(TodoItemSchema),
-  currentTask: z.string().optional(),
-  agentName: z.string().optional(),
-  turnCount: z.number().int().nonnegative(),
-  workflowMode: z.enum(["default", "plan", "iterate", "review"]),
-  sessionId: z.string().optional(),
-  parentAgent: z.string().optional(),
-  memories: z.array(z.object({
-    content: z.string(),
-    relevance: z.number().min(0).max(1),
-    agent: z.string().optional(),
-    timestamp: z.number()
-  })).optional()
-});
-var DEFAULT_TOKEN_BUDGET = {
-  maxTotal: 2e3,
-  perType: {
-    task: 500,
-    memory: 600,
-    session: 300,
-    delegation: 200,
-    mode: 400
-  },
-  criticalReserve: 300
-};
-var TokenBudgetConfigSchema = z.object({
-  maxTotal: z.number().int().positive().max(1e4),
-  perType: z.record(
-    z.enum(["task", "memory", "session", "delegation", "mode"]),
-    z.number().int().nonnegative()
-  ),
-  criticalReserve: z.number().int().nonnegative()
-});
-var DEFAULT_ORCHESTRATION_CONFIG = {
-  enabled: true,
-  tokenBudget: DEFAULT_TOKEN_BUDGET,
-  todoIntegration: {
-    enabled: true,
-    reminderFrequency: 3,
-    compactMode: false
-  },
-  memoryIntegration: {
-    enabled: true,
-    maxEntries: 5,
-    minRelevance: 0.5
-  },
-  sessionIntegration: {
-    enabled: true,
-    showCollaboration: true
-  },
-  agentTemplates: {
-    enabled: true,
-    reminderFrequency: 5
-  }
-};
-z.object({
-  enabled: z.boolean(),
-  tokenBudget: TokenBudgetConfigSchema,
-  todoIntegration: z.object({
-    enabled: z.boolean(),
-    reminderFrequency: z.number().int().positive(),
-    compactMode: z.boolean()
-  }),
-  memoryIntegration: z.object({
-    enabled: z.boolean(),
-    maxEntries: z.number().int().nonnegative(),
-    minRelevance: z.number().min(0).max(1)
-  }),
-  sessionIntegration: z.object({
-    enabled: z.boolean(),
-    showCollaboration: z.boolean()
-  }),
-  agentTemplates: z.object({
-    enabled: z.boolean(),
-    reminderFrequency: z.number().int().positive()
-  })
-});
-
 // src/core/orchestration/instruction-injector.ts
 init_esm_shims();
 init_logger();
@@ -49248,10 +49330,28 @@ 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,
@@ -49282,9 +49382,8 @@ var TokenBudgetManager = class _TokenBudgetManager {
    * Estimate tokens for an instruction (including formatting overhead)
    */
   estimateInstructionTokens(instruction) {
-    const overhead = 50;
     const contentTokens = this.estimateTokens(instruction.content).tokens;
-    return contentTokens + overhead;
+    return contentTokens + _TokenBudgetManager.FORMATTING_OVERHEAD_TOKENS;
   }
   /**
    * Allocate budget for instructions
@@ -49298,24 +49397,12 @@ var TokenBudgetManager = class _TokenBudgetManager {
   allocateBudget(instructions) {
     const included = [];
     const excluded = [];
-    const perTypeUsage = {
-      task: 0,
-      memory: 0,
-      session: 0,
-      delegation: 0,
-      mode: 0
-    };
+    const perTypeUsage = createEmptyTypeUsage();
     let tokensUsed = 0;
     const availableBudget = this.config.maxTotal;
-    const priorityOrder = {
-      critical: 0,
-      high: 1,
-      normal: 2,
-      low: 3
-    };
     const sorted = [...instructions].sort((a, b) => {
-      const aPriority = priorityOrder[a.priority] ?? 2;
-      const bPriority = priorityOrder[b.priority] ?? 2;
+      const 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;
@@ -49427,12 +49514,12 @@ var TokenBudgetManager = class _TokenBudgetManager {
 };
 
 // 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;
-  instructionCache = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = {
       ...DEFAULT_ORCHESTRATION_CONFIG,
@@ -49555,8 +49642,7 @@ var OrchestrationInstructionInjector = class {
       grouped.set(instruction.type, existing);
     }
     const parts = [];
-    const typeOrder = ["mode", "task", "memory", "session", "delegation"];
-    for (const type of typeOrder) {
+    for (const type of INSTRUCTION_TYPE_ORDER) {
       const typeInstructions = grouped.get(type);
       if (!typeInstructions || typeInstructions.length === 0) continue;
       for (const instruction of typeInstructions) {
@@ -49581,7 +49667,8 @@ ${instruction.content}
       if (instruction.expiresAfter === void 0) {
         return true;
       }
-      const turnsSinceCreation = currentTurn;
+      const createdAtTurn = instruction.createdAtTurn ?? currentTurn;
+      const turnsSinceCreation = currentTurn - createdAtTurn;
       return turnsSinceCreation < instruction.expiresAfter;
     });
   }
@@ -49589,16 +49676,10 @@ ${instruction.content}
    * Calculate per-type token usage
    */
   calculateTypeUsage(instructions) {
-    const usage = {
-      task: 0,
-      memory: 0,
-      session: 0,
-      delegation: 0,
-      mode: 0
-    };
+    const usage = createEmptyTypeUsage();
     for (const instruction of instructions) {
       const tokens = this.budgetManager.estimateInstructionTokens(instruction);
-      usage[instruction.type] = (usage[instruction.type] || 0) + tokens;
+      usage[instruction.type] += tokens;
     }
     return usage;
   }
@@ -49614,22 +49695,15 @@ ${instruction.content}
         excluded: [],
         tokensUsed: 0,
         remaining: this.budgetManager.getConfig().maxTotal,
-        perTypeUsage: {
-          task: 0,
-          memory: 0,
-          session: 0,
-          delegation: 0,
-          mode: 0
-        }
+        perTypeUsage: createEmptyTypeUsage()
       },
       hasInstructions: false
     };
   }
   /**
-   * Clear instruction cache
+   * Clear instruction cache (placeholder for future caching implementation)
    */
   clearCache() {
-    this.instructionCache.clear();
     logger.debug("Instruction cache cleared");
   }
   /**
@@ -49709,7 +49783,7 @@ var TodoInstructionProvider = class {
     if (!context.todos || context.todos.length === 0) {
       return false;
     }
-    const currentHash = this.computeStateHash(context.todos);
+    const currentHash = computeTodoHash(context.todos);
     const stateChanged = currentHash !== this.lastStateHash;
     const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
     const reminderDue = turnsSinceReminder >= this.config.reminderFrequency;
@@ -49723,14 +49797,24 @@ var TodoInstructionProvider = class {
     if (!context.todos || context.todos.length === 0) {
       return instructions;
     }
-    const currentHash = this.computeStateHash(context.todos);
+    const currentHash = computeTodoHash(context.todos);
     const stateChanged = currentHash !== this.lastStateHash;
-    const activeTodos = context.todos.filter(
-      (todo) => todo.status !== "completed" || this.config.showCompleted
-    );
-    const inProgressTasks = activeTodos.filter((todo) => todo.status === "in_progress");
-    const pendingTasks = activeTodos.filter((todo) => todo.status === "pending");
-    const completedTasks = context.todos.filter((todo) => todo.status === "completed");
+    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) {
@@ -49747,8 +49831,9 @@ var TodoInstructionProvider = class {
       type: "task",
       priority,
       content,
-      source: "automatosx",
+      source: INSTRUCTION_SOURCE,
       createdAt: Date.now(),
+      createdAtTurn: context.turnCount,
       expiresAfter: this.config.reminderFrequency + 1,
       id: `todo-${currentHash.substring(0, 8)}`
     });
@@ -49825,13 +49910,6 @@ var TodoInstructionProvider = class {
     }
     return parts.join(" | ");
   }
-  /**
-   * Compute hash of todo state for change detection
-   */
-  computeStateHash(todos) {
-    const stateString = todos.map((t) => `${t.id}:${t.status}:${t.content}`).sort().join("|");
-    return crypto2.createHash("sha256").update(stateString).digest("hex").substring(0, 16);
-  }
   /**
    * Get current configuration
    */
@@ -49860,10 +49938,15 @@ var TodoInstructionProvider = class {
     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,
@@ -49872,8 +49955,9 @@ var DEFAULT_MEMORY_CONFIG = {
   maxAge: 0,
   // No limit by default
   includeMetadata: true,
-  cacheTTL: 6e4
+  cacheTTL: 6e4,
   // 1 minute
+  contentMaxLength: DEFAULT_CONTENT_MAX_LENGTH
 };
 var MemoryInstructionProvider = class {
   name = "memory";
@@ -49942,8 +50026,9 @@ var MemoryInstructionProvider = class {
         type: "memory",
         priority: "normal",
         content,
-        source: "automatosx",
+        source: INSTRUCTION_SOURCE,
         createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
         expiresAfter: this.config.searchFrequency + 1,
         id: `memory-${Date.now()}`
       });
@@ -49966,9 +50051,12 @@ var MemoryInstructionProvider = class {
     if (context.currentTask) {
       parts.push(context.currentTask);
     }
-    const inProgressTodos = context.todos.filter((t) => t.status === "in_progress");
-    for (const todo of inProgressTodos.slice(0, 2)) {
-      parts.push(todo.content);
+    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);
@@ -50042,8 +50130,7 @@ var MemoryInstructionProvider = class {
       } else {
         lines.push(`### Memory ${i + 1} (${relevancePercent}% relevant)`);
       }
-      const maxLength = 500;
-      const content = memory.content.length > maxLength ? memory.content.substring(0, maxLength) + "..." : memory.content;
+      const content = memory.content.length > this.config.contentMaxLength ? memory.content.substring(0, this.config.contentMaxLength) + "..." : memory.content;
       lines.push(content);
       lines.push("");
     }
@@ -50105,6 +50192,7 @@ var DEFAULT_SESSION_CONFIG = {
   reminderFrequency: 5,
   showHandoffContext: true
 };
+var SESSION_CACHE_TTL_MS = 3e4;
 var SessionInstructionProvider = class {
   name = "session";
   config;
@@ -50112,8 +50200,6 @@ var SessionInstructionProvider = class {
   lastReminderTurn = 0;
   cachedState;
   cacheExpiry = 0;
-  CACHE_TTL = 3e4;
-  // 30 seconds
   constructor(stateProvider, config) {
     this.config = {
       ...DEFAULT_SESSION_CONFIG,
@@ -50161,10 +50247,11 @@ var SessionInstructionProvider = class {
         type: "session",
         priority: "normal",
         content,
-        source: "automatosx",
+        source: INSTRUCTION_SOURCE,
         createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
         expiresAfter: this.config.reminderFrequency,
-        id: `session-${context.sessionId || "default"}-${Date.now()}`
+        id: `session-${context.sessionId ?? "default"}-${Date.now()}`
       });
     }
     this.lastReminderTurn = context.turnCount;
@@ -50191,7 +50278,7 @@ var SessionInstructionProvider = class {
       const state = await this.stateProvider.getSessionState(context.sessionId);
       if (state) {
         this.cachedState = state;
-        this.cacheExpiry = Date.now() + this.CACHE_TTL;
+        this.cacheExpiry = Date.now() + SESSION_CACHE_TTL_MS;
       }
       return state;
     } catch (error) {
@@ -50635,22 +50722,42 @@ var STANDARD_TEMPLATE = {
     "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: { ...BACKEND_TEMPLATE, domain: "fullstack", displayName: "Fullstack Engineer" },
+  fullstack: FULLSTACK_TEMPLATE,
   security: SECURITY_TEMPLATE,
   quality: QUALITY_TEMPLATE,
   architecture: ARCHITECTURE_TEMPLATE,
   devops: DEVOPS_TEMPLATE,
-  data: { ...BACKEND_TEMPLATE, domain: "data", displayName: "Data Engineer" },
-  mobile: { ...FRONTEND_TEMPLATE, domain: "mobile", displayName: "Mobile Engineer" },
+  data: DATA_TEMPLATE,
+  mobile: MOBILE_TEMPLATE,
   writer: WRITER_TEMPLATE,
-  researcher: { ...STANDARD_TEMPLATE, domain: "researcher", displayName: "Researcher" },
+  researcher: RESEARCHER_TEMPLATE,
   standard: STANDARD_TEMPLATE
 };
 function getAgentTemplate(domain) {
-  return AGENT_TEMPLATES[domain] || STANDARD_TEMPLATE;
+  return AGENT_TEMPLATES[domain] ?? STANDARD_TEMPLATE;
 }
 function isValidAgentDomain(domain) {
   return domain in AGENT_TEMPLATES;
@@ -50682,8 +50789,95 @@ var DEFAULT_AGENT_CONFIG = {
   minDelegationKeywords: 1,
   includeQualityChecklist: true,
   qualityChecklistFrequency: 10,
-  includeAntiPatterns: true
+  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;
@@ -50730,11 +50924,12 @@ var AgentInstructionInjector = class {
     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 && this.checkDelegationTriggers(context);
+    const hasDelegationTriggers = this.config.delegationDetection && taskText !== this.recentTaskText && this.checkDelegationTriggers(context, domain, taskText);
     return reminderDue || qualityDue || hasDelegationTriggers;
   }
   /**
@@ -50755,8 +50950,9 @@ var AgentInstructionInjector = class {
         type: "delegation",
         priority: "normal",
         content: reminderContent,
-        source: "automatosx",
+        source: INSTRUCTION_SOURCE,
         createdAt: Date.now(),
+        createdAtTurn: context.turnCount,
         expiresAfter: this.config.reminderFrequency,
         id: `agent-reminder-${domain}-${Date.now()}`
       });
@@ -50768,15 +50964,16 @@ var AgentInstructionInjector = class {
         type: "delegation",
         priority: "normal",
         content: checklistContent,
-        source: "automatosx",
+        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) {
-      const taskText = this.extractTaskText(context);
       if (taskText !== this.recentTaskText) {
         this.recentTaskText = taskText;
         const delegationContent = this.checkAndFormatDelegation(template, taskText);
@@ -50785,14 +50982,34 @@ var AgentInstructionInjector = class {
             type: "delegation",
             priority: "high",
             content: delegationContent,
-            source: "automatosx",
+            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
@@ -50816,20 +51033,22 @@ var AgentInstructionInjector = class {
     if (context.currentTask) {
       parts.push(context.currentTask);
     }
-    for (const todo of context.todos.filter((t) => t.status === "in_progress")) {
-      parts.push(todo.content);
+    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) {
-    const domain = this.resolveDomain(context);
-    if (!domain) return false;
-    const taskText = this.extractTaskText(context);
-    if (!taskText) return false;
-    const suggestions = getDelegationSuggestions(taskText, domain);
+  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);
   }
   /**
@@ -50890,6 +51109,54 @@ var AgentInstructionInjector = class {
     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
    */
@@ -51032,8 +51299,13 @@ var OrchestrationService = class {
   }
   /**
    * 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 });
   }
@@ -51060,6 +51332,7 @@ var OrchestrationService = class {
    */
   incrementTurn() {
     this.turnCount++;
+    this.workflowModeManager.updateTurnCount(this.turnCount);
   }
   /**
    * Get current turn count
@@ -51149,10 +51422,49 @@ ${content}
   updateConfig(updates) {
     this.config = {
       ...this.config,
-      ...updates
+      ...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 = new TokenBudgetManager(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 });
   }
@@ -51271,17 +51583,18 @@ function displayTokenBudget(verbose) {
   console.log(`  Critical reserve: ${chalk5.yellow(config.criticalReserve)} tokens`);
   console.log(`  Available: ${chalk5.green(config.maxTotal - config.criticalReserve)} tokens`);
   console.log(chalk5.cyan("\n  Per-Type Allocations:"));
-  const typeAllocations = [
-    { type: "task", budget: 500, description: "Todo/task reminders" },
-    { type: "memory", budget: 400, description: "Memory context" },
-    { type: "session", budget: 300, description: "Session state" },
-    { type: "delegation", budget: 300, description: "Agent delegation hints" },
-    { type: "mode", budget: 200, description: "Workflow mode instructions" }
-  ];
-  typeAllocations.forEach(({ type, budget, description }) => {
+  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) {
-      console.log(chalk5.gray(`      ${description}`));
+    if (verbose && typeDescriptions[type]) {
+      console.log(chalk5.gray(`      ${typeDescriptions[type]}`));
     }
   });
   console.log(chalk5.cyan("\n  Token Estimation:"));
@@ -51405,6 +51718,228 @@ function displayAgentTemplate(domain, verbose) {
   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();
@@ -51427,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).command(modeCommand).command(debugInstructionsCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
+    }).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");