@defai.digital/automatosx 11.2.9 → 11.3.0

package/dist/index.js

@@ -19,7 +19,7 @@ import { Mutex } from 'async-mutex';
 import { promisify } from 'util';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { randomUUID, createHash } from 'crypto';
+import crypto2, { randomUUID, createHash } from 'crypto';
 import * as yaml4 from 'js-yaml';
 import yaml4__default, { load, dump } from 'js-yaml';
 import Table from 'cli-table3';
@@ -2943,8 +2943,18 @@ var init_base_provider = __esm({
       /**
        * Check if CLI is available - Template method pattern
        * Uses getCLICommand() to determine which CLI to check
+       *
+       * v11.2.9 Fix: Always return true in mock mode (AX_MOCK_PROVIDERS=true)
+       * This allows integration tests in CI to run without installing actual provider CLIs
        */
       async checkCLIAvailable() {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          logger.debug(`${this.getCLICommand()} CLI availability check (mock mode)`, {
+            available: true,
+            mockMode: true
+          });
+          return true;
+        }
         try {
           const cliCommand2 = this.getCLICommand();
           const result = findOnPath(cliCommand2);
@@ -9263,7 +9273,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.2.9"
+  "version": "11.3.0"
 };
 
 // src/core/config/schemas.ts
@@ -22176,8 +22186,8 @@ var ProjectContextLoader = class {
     const projectMatch = markdown.match(/>\s*Project:\s*(.+?)$/im);
     if (projectMatch && projectMatch[1]) {
       const parts = projectMatch[1].trim().split(/\s+v/);
-      metadata.name = parts[0];
-      if (parts[1]) {
+      metadata.name = parts[0] || "";
+      if (parts.length > 1 && parts[1]) {
         metadata.version = parts[1];
       }
     }
@@ -36225,10 +36235,10 @@ var runCommand = {
     }).positional("task", {
       describe: "Task to execute",
       type: "string"
-    }).option("no-auto-select", {
-      describe: "Disable agent auto-selection (v11.1.0+)",
+    }).option("auto-select", {
+      describe: "Enable agent auto-selection when agent not found (v11.1.0+)",
       type: "boolean",
-      default: false
+      default: true
     }).option("provider", {
       describe: "Override provider (claude, gemini, openai)",
       type: "string"
@@ -36370,7 +36380,7 @@ var runCommand = {
       console.log(chalk5.gray('       ax run backend "implement API"     # uses specified agent'));
       process.exit(1);
     }
-    if (!agentProvided && argv.noAutoSelect) {
+    if (!agentProvided && argv.autoSelect === false) {
       console.log(chalk5.red.bold("\n\u274C Error: Agent name is required when --no-auto-select is used\n"));
       console.log(chalk5.gray("Usage: ax run <agent> <task> --no-auto-select"));
       process.exit(1);
@@ -36505,7 +36515,7 @@ var runCommand = {
             }
           }
         } catch (error) {
-          if (argv.noAutoSelect) {
+          if (argv.autoSelect === false) {
             console.error(chalk5.red.bold(`
 \u274C Agent not found: ${actualAgent}
 `));
@@ -44867,24 +44877,24 @@ async function handleList(config, argv) {
       });
     }
   }
-  let displayProviders = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
+  let displayProviders2 = argv.available ? providers.filter((p) => p.enabled && !p.limitInfo?.isBlocked) : providers;
   switch (argv.sort) {
     case "cost":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const costA = a.metadata ? (a.metadata.costPerToken.input + a.metadata.costPerToken.output) / 2 : Infinity;
         const costB = b.metadata ? (b.metadata.costPerToken.input + b.metadata.costPerToken.output) / 2 : Infinity;
         return costA - costB;
       });
       break;
     case "latency":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const latA = a.metadata?.latencyEstimate.p95 || Infinity;
         const latB = b.metadata?.latencyEstimate.p95 || Infinity;
         return latA - latB;
       });
       break;
     case "reliability":
-      displayProviders.sort((a, b) => {
+      displayProviders2.sort((a, b) => {
         const relA = a.metadata?.reliability.availability || 0;
         const relB = b.metadata?.reliability.availability || 0;
         return relB - relA;
@@ -44892,15 +44902,15 @@ async function handleList(config, argv) {
       break;
     case "priority":
     default:
-      displayProviders.sort((a, b) => a.priority - b.priority);
+      displayProviders2.sort((a, b) => a.priority - b.priority);
       break;
   }
   if (argv.json) {
-    console.log(JSON.stringify({ providers: displayProviders }, null, 2));
+    console.log(JSON.stringify({ providers: displayProviders2 }, null, 2));
     return;
   }
   console.log(chalk5.gray("Provider Status & Metadata:\n"));
-  for (const provider of displayProviders) {
+  for (const provider of displayProviders2) {
     const status = provider.enabled ? provider.limitInfo?.isBlocked ? chalk5.red("\u25CF BLOCKED") : chalk5.green("\u25CF ENABLED") : chalk5.gray("\u25CB DISABLED");
     console.log(`${status} ${chalk5.bold(provider.name)} ${chalk5.gray(`(priority: ${provider.priority})`)}`);
     if (provider.metadata && argv.verbose) {
@@ -46147,9 +46157,11 @@ async function checkDiskSpace(workingDir, verbose) {
       timeout: 5e3
     });
     const parts = dfOutput.trim().split(/\s+/);
-    const availableKB = parseInt(parts[3] || "0", 10);
-    const availableMB = Math.round(availableKB / 1024);
-    const availableGB = (availableKB / (1024 * 1024)).toFixed(2);
+    const rawAvailable = parts.length > 3 ? parts[3] : "0";
+    const availableKB = parseInt(rawAvailable || "0", 10);
+    const safeAvailableKB = isNaN(availableKB) ? 0 : availableKB;
+    const availableMB = Math.round(safeAvailableKB / 1024);
+    const availableGB = (safeAvailableKB / (1024 * 1024)).toFixed(2);
     const hasEnoughSpace = availableMB > 100;
     results.push({
       name: "Available Disk Space",
@@ -48519,6 +48531,2880 @@ var uninstallCommand = {
   }
 };
 
+// src/cli/commands/mode.ts
+init_esm_shims();
+init_logger();
+
+// src/core/workflow/index.ts
+init_esm_shims();
+
+// src/core/workflow/workflow-mode.ts
+init_esm_shims();
+var WorkflowModeSchema = z.enum(["default", "plan", "iterate", "review"]);
+z.object({
+  name: WorkflowModeSchema,
+  description: z.string(),
+  displayName: z.string(),
+  allowedTools: z.array(z.string()).optional(),
+  blockedTools: z.array(z.string()).optional(),
+  systemInstructions: z.string(),
+  allowNesting: z.boolean(),
+  maxNestingDepth: z.number().int().positive().optional(),
+  autoExitConditions: z.object({
+    maxTurns: z.number().int().positive().optional(),
+    onToolUse: z.array(z.string()).optional(),
+    onKeywords: z.array(z.string()).optional()
+  }).optional()
+});
+var WRITE_TOOLS = [
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "Bash"
+];
+var DEFAULT_MODE_CONFIG = {
+  name: "default",
+  displayName: "Default",
+  description: "Standard operation mode with all tools available",
+  systemInstructions: "",
+  allowNesting: true,
+  maxNestingDepth: 3
+};
+var PLAN_MODE_CONFIG = {
+  name: "plan",
+  displayName: "Plan Mode",
+  description: "Planning mode - read-only exploration without code modifications",
+  blockedTools: [...WRITE_TOOLS],
+  systemInstructions: `## Plan Mode Active
+
+You are in **Plan Mode**. This mode is for exploration and planning only.
+
+**Restrictions:**
+- You CANNOT use Write, Edit, or Bash tools that modify files
+- Focus on reading, searching, and understanding the codebase
+- Create a comprehensive plan before implementation
+
+**Your Goals:**
+1. Explore the codebase to understand existing patterns
+2. Identify files that need to be modified
+3. Design an implementation approach
+4. Document your plan clearly
+5. Use ExitPlanMode when ready to implement
+
+**Remember:** No code modifications in this mode. Plan first, implement later.`,
+  allowNesting: false,
+  autoExitConditions: {
+    onToolUse: ["ExitPlanMode"]
+  }
+};
+var ITERATE_MODE_CONFIG = {
+  name: "iterate",
+  displayName: "Iterate Mode",
+  description: "Continuous iteration mode for implementation with automatic continuation",
+  systemInstructions: `## Iterate Mode Active
+
+You are in **Iterate Mode**. This mode enables continuous task execution.
+
+**Behavior:**
+- Continue working until the task is complete
+- After each step, assess progress and continue
+- Don't stop to ask for confirmation unless critical
+- Mark todos as completed as you finish them
+
+**Guidelines:**
+1. Work through tasks systematically
+2. Test changes as you go when possible
+3. Update todo list to track progress
+4. Only pause for critical decisions or blockers
+
+**Remember:** Keep iterating until the task is done or you hit a blocker.`,
+  allowNesting: true,
+  maxNestingDepth: 2
+};
+var REVIEW_MODE_CONFIG = {
+  name: "review",
+  displayName: "Review Mode",
+  description: "Code review mode - analyze code quality, security, and best practices",
+  blockedTools: [...WRITE_TOOLS],
+  systemInstructions: `## Review Mode Active
+
+You are in **Review Mode**. This mode is for code review and analysis.
+
+**Focus Areas:**
+- Code quality and readability
+- Security vulnerabilities (OWASP Top 10)
+- Performance issues
+- Best practices and patterns
+- Test coverage gaps
+
+**Output Format:**
+Provide structured feedback:
+1. **Critical Issues** - Must fix before merge
+2. **Warnings** - Should address
+3. **Suggestions** - Nice to have improvements
+4. **Positive Notes** - Good patterns observed
+
+**Remember:** No code modifications. Provide actionable feedback only.`,
+  allowNesting: false
+};
+var WORKFLOW_MODE_CONFIGS = {
+  default: DEFAULT_MODE_CONFIG,
+  plan: PLAN_MODE_CONFIG,
+  iterate: ITERATE_MODE_CONFIG,
+  review: REVIEW_MODE_CONFIG
+};
+function getWorkflowModeConfig(mode) {
+  return WORKFLOW_MODE_CONFIGS[mode];
+}
+function isToolAllowedInMode(tool, mode) {
+  const config = getWorkflowModeConfig(mode);
+  if (config.allowedTools && config.allowedTools.length > 0) {
+    return config.allowedTools.includes(tool);
+  }
+  if (config.blockedTools && config.blockedTools.length > 0) {
+    return !config.blockedTools.includes(tool);
+  }
+  return true;
+}
+function isValidWorkflowMode(mode) {
+  return mode in WORKFLOW_MODE_CONFIGS;
+}
+var WORKFLOW_MODES = WORKFLOW_MODE_CONFIGS;
+
+// src/core/workflow/workflow-mode-manager.ts
+init_esm_shims();
+init_logger();
+var WorkflowModeManager = class {
+  name = "workflow-mode";
+  modeStack = [];
+  transitionListeners = /* @__PURE__ */ new Set();
+  turnCount = 0;
+  constructor(initialMode = "default") {
+    this.modeStack.push({
+      mode: initialMode,
+      enteredAt: Date.now(),
+      enteredAtTurn: 0,
+      reason: "initial"
+    });
+    logger.debug("WorkflowModeManager initialized", {
+      initialMode
+    });
+  }
+  /**
+   * Get the current active mode
+   */
+  getCurrentMode() {
+    const top = this.modeStack[this.modeStack.length - 1];
+    return top?.mode ?? "default";
+  }
+  /**
+   * Get the current mode configuration
+   */
+  getCurrentModeConfig() {
+    const mode = this.getCurrentMode();
+    const entry = this.modeStack[this.modeStack.length - 1];
+    const baseConfig = getWorkflowModeConfig(mode);
+    if (entry?.customConfig) {
+      return {
+        ...baseConfig,
+        ...entry.customConfig,
+        // Deep merge for nested objects
+        autoExitConditions: {
+          ...baseConfig.autoExitConditions,
+          ...entry.customConfig.autoExitConditions
+        }
+      };
+    }
+    return baseConfig;
+  }
+  /**
+   * Get the full mode stack
+   */
+  getModeStack() {
+    return [...this.modeStack];
+  }
+  /**
+   * Get the current stack depth
+   */
+  getStackDepth() {
+    return this.modeStack.length;
+  }
+  /**
+   * Push a new mode onto the stack
+   */
+  pushMode(mode, options) {
+    const currentConfig = this.getCurrentModeConfig();
+    if (!currentConfig.allowNesting) {
+      logger.warn("Cannot push mode: current mode does not allow nesting", {
+        currentMode: this.getCurrentMode(),
+        attemptedMode: mode
+      });
+      return false;
+    }
+    const maxDepth = currentConfig.maxNestingDepth ?? 3;
+    if (this.modeStack.length >= maxDepth) {
+      logger.warn("Cannot push mode: max nesting depth reached", {
+        currentDepth: this.modeStack.length,
+        maxDepth
+      });
+      return false;
+    }
+    const previousMode = this.getCurrentMode();
+    this.modeStack.push({
+      mode,
+      enteredAt: Date.now(),
+      enteredAtTurn: this.turnCount,
+      customConfig: options?.customConfig,
+      reason: options?.reason
+    });
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "push",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Pushed workflow mode", {
+      from: previousMode,
+      to: mode,
+      stackDepth: this.modeStack.length,
+      reason: options?.reason
+    });
+    return true;
+  }
+  /**
+   * Pop the current mode from the stack
+   */
+  popMode(reason) {
+    if (this.modeStack.length <= 1) {
+      logger.warn("Cannot pop mode: at base level");
+      return null;
+    }
+    const popped = this.modeStack.pop();
+    const newMode = this.getCurrentMode();
+    if (popped) {
+      this.emitTransition({
+        from: popped.mode,
+        to: newMode,
+        type: "pop",
+        timestamp: Date.now(),
+        reason
+      });
+      logger.info("Popped workflow mode", {
+        from: popped.mode,
+        to: newMode,
+        stackDepth: this.modeStack.length,
+        reason
+      });
+    }
+    return popped?.mode ?? null;
+  }
+  /**
+   * Replace the current mode (pop then push)
+   */
+  replaceMode(mode, options) {
+    const previousMode = this.getCurrentMode();
+    if (this.modeStack.length === 1) {
+      this.modeStack[0] = {
+        mode,
+        enteredAt: Date.now(),
+        enteredAtTurn: this.turnCount,
+        customConfig: options?.customConfig,
+        reason: options?.reason
+      };
+    } else {
+      this.modeStack.pop();
+      this.modeStack.push({
+        mode,
+        enteredAt: Date.now(),
+        enteredAtTurn: this.turnCount,
+        customConfig: options?.customConfig,
+        reason: options?.reason
+      });
+    }
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "replace",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Replaced workflow mode", {
+      from: previousMode,
+      to: mode,
+      reason: options?.reason
+    });
+    return true;
+  }
+  /**
+   * Set mode directly (clears stack and sets new base mode)
+   */
+  setMode(mode, options) {
+    const previousMode = this.getCurrentMode();
+    this.modeStack = [{
+      mode,
+      enteredAt: Date.now(),
+      enteredAtTurn: this.turnCount,
+      customConfig: options?.customConfig,
+      reason: options?.reason
+    }];
+    this.emitTransition({
+      from: previousMode,
+      to: mode,
+      type: "replace",
+      timestamp: Date.now(),
+      reason: options?.reason
+    });
+    logger.info("Set workflow mode", {
+      from: previousMode,
+      to: mode,
+      reason: options?.reason
+    });
+  }
+  /**
+   * Check if a tool is allowed in the current mode
+   */
+  isToolAllowed(tool) {
+    return isToolAllowedInMode(tool, this.getCurrentMode());
+  }
+  /**
+   * Get list of blocked tools in current mode
+   */
+  getBlockedTools() {
+    const config = this.getCurrentModeConfig();
+    return config.blockedTools || [];
+  }
+  /**
+   * Filter a list of tools based on current mode
+   */
+  filterTools(tools) {
+    return tools.filter((tool) => this.isToolAllowed(tool.name));
+  }
+  /**
+   * Update turn count (for auto-exit tracking)
+   */
+  updateTurnCount(turn) {
+    this.turnCount = turn;
+    this.checkAutoExit();
+  }
+  /**
+   * Check and handle auto-exit conditions
+   */
+  checkAutoExit() {
+    const config = this.getCurrentModeConfig();
+    const entry = this.modeStack[this.modeStack.length - 1];
+    if (!config.autoExitConditions || !entry) return;
+    if (config.autoExitConditions.maxTurns) {
+      const turnsInMode = this.turnCount - entry.enteredAtTurn;
+      if (turnsInMode >= config.autoExitConditions.maxTurns) {
+        logger.info("Auto-exiting mode due to max turns", {
+          mode: this.getCurrentMode(),
+          turnsInMode,
+          maxTurns: config.autoExitConditions.maxTurns
+        });
+        this.popMode("max_turns_reached");
+      }
+    }
+  }
+  /**
+   * Notify that a tool was used (for auto-exit on tool use)
+   */
+  notifyToolUsed(tool) {
+    const config = this.getCurrentModeConfig();
+    if (config.autoExitConditions?.onToolUse?.includes(tool)) {
+      logger.info("Auto-exiting mode due to tool use", {
+        mode: this.getCurrentMode(),
+        tool
+      });
+      this.popMode(`tool_used:${tool}`);
+    }
+  }
+  /**
+   * Add a mode transition listener
+   */
+  onTransition(listener) {
+    this.transitionListeners.add(listener);
+    return () => this.transitionListeners.delete(listener);
+  }
+  /**
+   * Emit a transition event to all listeners
+   */
+  emitTransition(event) {
+    for (const listener of this.transitionListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        logger.error("Mode transition listener error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  // InstructionProvider implementation
+  /**
+   * Check if mode instructions should be generated
+   */
+  shouldGenerate(context) {
+    return this.getCurrentMode() !== "default";
+  }
+  /**
+   * Get mode-specific instructions
+   */
+  async getInstructions(context) {
+    const config = this.getCurrentModeConfig();
+    const instructions = [];
+    if (config.systemInstructions && config.systemInstructions.length > 0) {
+      instructions.push({
+        type: "mode",
+        priority: "high",
+        content: config.systemInstructions,
+        source: "automatosx",
+        createdAt: Date.now(),
+        id: `mode-${config.name}-${Date.now()}`
+      });
+    }
+    if (config.blockedTools && config.blockedTools.length > 0) {
+      instructions.push({
+        type: "mode",
+        priority: "critical",
+        content: `**Tool Restrictions:** The following tools are NOT available in ${config.displayName}: ${config.blockedTools.join(", ")}`,
+        source: "automatosx",
+        createdAt: Date.now(),
+        id: `mode-blocked-tools-${Date.now()}`
+      });
+    }
+    return instructions;
+  }
+  /**
+   * Reset to default state
+   */
+  reset() {
+    const previousMode = this.getCurrentMode();
+    this.modeStack = [{
+      mode: "default",
+      enteredAt: Date.now(),
+      enteredAtTurn: 0,
+      reason: "reset"
+    }];
+    this.turnCount = 0;
+    if (previousMode !== "default") {
+      this.emitTransition({
+        from: previousMode,
+        to: "default",
+        type: "replace",
+        timestamp: Date.now(),
+        reason: "reset"
+      });
+    }
+    logger.debug("WorkflowModeManager reset");
+  }
+  /**
+   * Get status information for debugging
+   */
+  getStatus() {
+    return {
+      currentMode: this.getCurrentMode(),
+      stackDepth: this.modeStack.length,
+      stack: this.modeStack.map((entry) => ({
+        mode: entry.mode,
+        enteredAt: entry.enteredAt,
+        reason: entry.reason
+      })),
+      blockedTools: this.getBlockedTools(),
+      turnCount: this.turnCount
+    };
+  }
+};
+
+// src/cli/commands/mode.ts
+var modeCommand = {
+  command: "mode [mode]",
+  describe: "Manage workflow modes for embedded instructions (v11.3.0)",
+  builder: (yargs2) => {
+    return yargs2.positional("mode", {
+      describe: "Workflow mode to set (default, plan, iterate, review)",
+      type: "string"
+    }).option("list", {
+      alias: "l",
+      describe: "List available workflow modes",
+      type: "boolean",
+      default: false
+    }).option("status", {
+      alias: "s",
+      describe: "Show current workflow mode status",
+      type: "boolean",
+      default: false
+    }).example("$0 mode plan", "Enter plan mode (restricts code-modifying tools)").example("$0 mode iterate", "Enter iterate mode (for autonomous execution)").example("$0 mode default", "Return to default mode").example("$0 mode --list", "List all available modes").example("$0 mode --status", "Show current mode status");
+  },
+  handler: async (argv) => {
+    try {
+      if (argv.list) {
+        displayModeList();
+        return;
+      }
+      if (argv.status || !argv.mode) {
+        displayModeStatus();
+        return;
+      }
+      const modeName = argv.mode.toLowerCase();
+      if (!isValidWorkflowMode(modeName)) {
+        console.error(chalk5.red.bold(`
+\u274C Invalid workflow mode: ${argv.mode}
+`));
+        console.log(chalk5.gray("Available modes:"));
+        Object.keys(WORKFLOW_MODES).forEach((mode) => {
+          console.log(chalk5.cyan(`  \u2022 ${mode}`));
+        });
+        console.log();
+        process.exit(1);
+      }
+      const modeConfig = WORKFLOW_MODES[modeName];
+      console.log(chalk5.green.bold(`
+\u2705 Workflow mode set to: ${modeName}
+`));
+      console.log(chalk5.gray(`Description: ${modeConfig.description}`));
+      if (modeConfig.blockedTools && modeConfig.blockedTools.length > 0) {
+        console.log(chalk5.yellow("\nRestricted tools in this mode:"));
+        modeConfig.blockedTools.forEach((tool) => {
+          console.log(chalk5.yellow(`  \u2022 ${tool}`));
+        });
+      }
+      if (modeConfig.allowedTools && modeConfig.allowedTools.length > 0) {
+        console.log(chalk5.cyan("\nAllowed tools in this mode:"));
+        modeConfig.allowedTools.forEach((tool) => {
+          console.log(chalk5.cyan(`  \u2022 ${tool}`));
+        });
+      }
+      console.log();
+      console.log(chalk5.gray("Note: Mode setting applies to the current session."));
+      console.log(chalk5.gray("Use with --iterate flag in ax run for persistent mode.\n"));
+      logger.info("Workflow mode set", { mode: modeName });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      logger.error("Mode command failed", { error: err.message });
+      process.exit(1);
+    }
+  }
+};
+function displayModeList() {
+  console.log(chalk5.blue.bold("\n\u{1F4CB} Available Workflow Modes\n"));
+  console.log(chalk5.dim("\u2500".repeat(60)));
+  for (const [name, config] of Object.entries(WORKFLOW_MODES)) {
+    console.log();
+    console.log(chalk5.cyan.bold(`  ${name}`));
+    console.log(chalk5.gray(`    ${config.description}`));
+    if (config.blockedTools && config.blockedTools.length > 0) {
+      console.log(chalk5.yellow(`    Blocked: ${config.blockedTools.join(", ")}`));
+    }
+    if (config.maxNestingDepth !== void 0) {
+      console.log(chalk5.gray(`    Max nesting depth: ${config.maxNestingDepth}`));
+    }
+  }
+  console.log();
+  console.log(chalk5.dim("\u2500".repeat(60)));
+  console.log(chalk5.gray("\nUsage: ax mode <mode-name>"));
+  console.log(chalk5.gray("Example: ax mode plan\n"));
+}
+function displayModeStatus() {
+  const currentMode = "default";
+  const modeConfig = WORKFLOW_MODES[currentMode];
+  console.log(chalk5.blue.bold("\n\u{1F4CA} Workflow Mode Status\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log(`  Current mode: ${chalk5.cyan.bold(currentMode)}`);
+  console.log(`  Description: ${chalk5.gray(modeConfig.description)}`);
+  if (modeConfig.blockedTools && modeConfig.blockedTools.length > 0) {
+    console.log(`  Blocked tools: ${chalk5.yellow(modeConfig.blockedTools.length)}`);
+  } else {
+    console.log(`  Blocked tools: ${chalk5.green("none")}`);
+  }
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log();
+  console.log(chalk5.gray("To change mode: ax mode <mode-name>"));
+  console.log(chalk5.gray("To list modes: ax mode --list\n"));
+}
+
+// src/cli/commands/debug-instructions.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/orchestration-service.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/types.ts
+init_esm_shims();
+z.object({
+  type: z.enum(["task", "memory", "session", "delegation", "mode"]),
+  priority: z.enum(["critical", "high", "normal", "low"]),
+  content: z.string().min(1).max(5e3),
+  source: z.literal("automatosx"),
+  expiresAfter: z.number().int().positive().optional(),
+  createdAt: z.number(),
+  id: z.string().optional()
+});
+var TodoItemSchema = z.object({
+  id: z.string(),
+  content: z.string().min(1).max(1e3),
+  status: z.enum(["pending", "in_progress", "completed"]),
+  activeForm: z.string().min(1).max(1e3),
+  createdAt: z.number(),
+  updatedAt: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  name: z.enum(["default", "plan", "iterate", "review"]),
+  description: z.string(),
+  allowedTools: z.array(z.string()).optional(),
+  blockedTools: z.array(z.string()).optional(),
+  systemInstructions: z.string(),
+  allowNesting: z.boolean()
+});
+z.object({
+  todos: z.array(TodoItemSchema),
+  currentTask: z.string().optional(),
+  agentName: z.string().optional(),
+  turnCount: z.number().int().nonnegative(),
+  workflowMode: z.enum(["default", "plan", "iterate", "review"]),
+  sessionId: z.string().optional(),
+  parentAgent: z.string().optional(),
+  memories: z.array(z.object({
+    content: z.string(),
+    relevance: z.number().min(0).max(1),
+    agent: z.string().optional(),
+    timestamp: z.number()
+  })).optional()
+});
+var DEFAULT_TOKEN_BUDGET = {
+  maxTotal: 2e3,
+  perType: {
+    task: 500,
+    memory: 600,
+    session: 300,
+    delegation: 200,
+    mode: 400
+  },
+  criticalReserve: 300
+};
+var TokenBudgetConfigSchema = z.object({
+  maxTotal: z.number().int().positive().max(1e4),
+  perType: z.record(
+    z.enum(["task", "memory", "session", "delegation", "mode"]),
+    z.number().int().nonnegative()
+  ),
+  criticalReserve: z.number().int().nonnegative()
+});
+var DEFAULT_ORCHESTRATION_CONFIG = {
+  enabled: true,
+  tokenBudget: DEFAULT_TOKEN_BUDGET,
+  todoIntegration: {
+    enabled: true,
+    reminderFrequency: 3,
+    compactMode: false
+  },
+  memoryIntegration: {
+    enabled: true,
+    maxEntries: 5,
+    minRelevance: 0.5
+  },
+  sessionIntegration: {
+    enabled: true,
+    showCollaboration: true
+  },
+  agentTemplates: {
+    enabled: true,
+    reminderFrequency: 5
+  }
+};
+z.object({
+  enabled: z.boolean(),
+  tokenBudget: TokenBudgetConfigSchema,
+  todoIntegration: z.object({
+    enabled: z.boolean(),
+    reminderFrequency: z.number().int().positive(),
+    compactMode: z.boolean()
+  }),
+  memoryIntegration: z.object({
+    enabled: z.boolean(),
+    maxEntries: z.number().int().nonnegative(),
+    minRelevance: z.number().min(0).max(1)
+  }),
+  sessionIntegration: z.object({
+    enabled: z.boolean(),
+    showCollaboration: z.boolean()
+  }),
+  agentTemplates: z.object({
+    enabled: z.boolean(),
+    reminderFrequency: z.number().int().positive()
+  })
+});
+
+// src/core/orchestration/instruction-injector.ts
+init_esm_shims();
+init_logger();
+
+// src/core/orchestration/token-budget.ts
+init_esm_shims();
+init_logger();
+var TokenBudgetManager = class _TokenBudgetManager {
+  config;
+  /** Characters per token estimate (conservative) */
+  static CHARS_PER_TOKEN = 4;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_TOKEN_BUDGET,
+      ...config,
+      perType: {
+        ...DEFAULT_TOKEN_BUDGET.perType,
+        ...config?.perType
+      }
+    };
+    logger.debug("TokenBudgetManager initialized", {
+      maxTotal: this.config.maxTotal,
+      criticalReserve: this.config.criticalReserve
+    });
+  }
+  /**
+   * Estimate tokens for a string
+   */
+  estimateTokens(content) {
+    const characters = content.length;
+    const tokens = Math.ceil(characters / _TokenBudgetManager.CHARS_PER_TOKEN);
+    return {
+      tokens,
+      characters,
+      isEstimate: true
+    };
+  }
+  /**
+   * Estimate tokens for an instruction (including formatting overhead)
+   */
+  estimateInstructionTokens(instruction) {
+    const overhead = 50;
+    const contentTokens = this.estimateTokens(instruction.content).tokens;
+    return contentTokens + overhead;
+  }
+  /**
+   * Allocate budget for instructions
+   *
+   * Priority order:
+   * 1. Critical instructions (always included, use reserve)
+   * 2. High priority (included if budget allows)
+   * 3. Normal priority (included if budget allows)
+   * 4. Low priority (only if significant budget remains)
+   */
+  allocateBudget(instructions) {
+    const included = [];
+    const excluded = [];
+    const perTypeUsage = {
+      task: 0,
+      memory: 0,
+      session: 0,
+      delegation: 0,
+      mode: 0
+    };
+    let tokensUsed = 0;
+    const availableBudget = this.config.maxTotal;
+    const priorityOrder = {
+      critical: 0,
+      high: 1,
+      normal: 2,
+      low: 3
+    };
+    const sorted = [...instructions].sort((a, b) => {
+      const aPriority = priorityOrder[a.priority] ?? 2;
+      const bPriority = priorityOrder[b.priority] ?? 2;
+      const priorityDiff = aPriority - bPriority;
+      if (priorityDiff !== 0) return priorityDiff;
+      return a.createdAt - b.createdAt;
+    });
+    for (const instruction of sorted) {
+      const instructionTokens = this.estimateInstructionTokens(instruction);
+      const typeLimit = this.config.perType[instruction.type] || 0;
+      const currentTypeUsage = perTypeUsage[instruction.type] || 0;
+      const wouldExceedTotal = tokensUsed + instructionTokens > availableBudget;
+      const wouldExceedTypeLimit = currentTypeUsage + instructionTokens > typeLimit;
+      if (instruction.priority === "critical") {
+        const criticalBudget = availableBudget + this.config.criticalReserve;
+        if (tokensUsed + instructionTokens <= criticalBudget) {
+          included.push(instruction);
+          tokensUsed += instructionTokens;
+          perTypeUsage[instruction.type] = currentTypeUsage + instructionTokens;
+          continue;
+        }
+      }
+      if (!wouldExceedTotal && !wouldExceedTypeLimit) {
+        included.push(instruction);
+        tokensUsed += instructionTokens;
+        perTypeUsage[instruction.type] = currentTypeUsage + instructionTokens;
+      } else {
+        excluded.push(instruction);
+        logger.debug("Instruction excluded from budget", {
+          type: instruction.type,
+          priority: instruction.priority,
+          tokens: instructionTokens,
+          reason: wouldExceedTotal ? "total_limit" : "type_limit"
+        });
+      }
+    }
+    const result = {
+      included,
+      excluded,
+      tokensUsed,
+      remaining: availableBudget - tokensUsed,
+      perTypeUsage
+    };
+    logger.debug("Budget allocation complete", {
+      included: included.length,
+      excluded: excluded.length,
+      tokensUsed,
+      remaining: result.remaining
+    });
+    return result;
+  }
+  /**
+   * Check if an instruction fits within budget
+   */
+  fitsInBudget(instruction, currentUsage, typeUsage) {
+    const instructionTokens = this.estimateInstructionTokens(instruction);
+    const typeLimit = this.config.perType[instruction.type] || 0;
+    const currentTypeUsage = typeUsage[instruction.type] || 0;
+    if (instruction.priority === "critical") {
+      return currentUsage + instructionTokens <= this.config.maxTotal + this.config.criticalReserve;
+    }
+    return currentUsage + instructionTokens <= this.config.maxTotal && currentTypeUsage + instructionTokens <= typeLimit;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates,
+      perType: {
+        ...this.config.perType,
+        ...updates.perType
+      }
+    };
+    logger.debug("TokenBudgetManager config updated", {
+      maxTotal: this.config.maxTotal
+    });
+  }
+  /**
+   * Get remaining budget for a specific type
+   */
+  getRemainingTypeBudget(type, currentTypeUsage) {
+    const limit = this.config.perType[type] || 0;
+    const used = currentTypeUsage[type] || 0;
+    return Math.max(0, limit - used);
+  }
+  /**
+   * Format budget status for debugging
+   */
+  formatBudgetStatus(allocation) {
+    const lines = [
+      `Token Budget Status:`,
+      `  Total: ${allocation.tokensUsed}/${this.config.maxTotal} (${allocation.remaining} remaining)`,
+      `  Per-Type Usage:`
+    ];
+    for (const [type, used] of Object.entries(allocation.perTypeUsage)) {
+      const limit = this.config.perType[type] || 0;
+      lines.push(`    ${type}: ${used}/${limit}`);
+    }
+    if (allocation.excluded.length > 0) {
+      lines.push(`  Excluded: ${allocation.excluded.length} instruction(s)`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/core/orchestration/instruction-injector.ts
+var OrchestrationInstructionInjector = class {
+  providers = /* @__PURE__ */ new Map();
+  budgetManager;
+  config;
+  lastInjectionTime = 0;
+  instructionCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_ORCHESTRATION_CONFIG,
+      ...config
+    };
+    this.budgetManager = new TokenBudgetManager(this.config.tokenBudget);
+    logger.debug("OrchestrationInstructionInjector initialized", {
+      enabled: this.config.enabled,
+      providers: this.providers.size
+    });
+  }
+  /**
+   * Register an instruction provider
+   */
+  registerProvider(provider) {
+    if (this.providers.has(provider.name)) {
+      logger.warn("Provider already registered, replacing", {
+        name: provider.name
+      });
+    }
+    this.providers.set(provider.name, provider);
+    logger.debug("Instruction provider registered", {
+      name: provider.name,
+      totalProviders: this.providers.size
+    });
+  }
+  /**
+   * Unregister an instruction provider
+   */
+  unregisterProvider(name) {
+    const removed = this.providers.delete(name);
+    if (removed) {
+      logger.debug("Instruction provider unregistered", { name });
+    }
+    return removed;
+  }
+  /**
+   * Get all registered providers
+   */
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Generate and inject instructions based on context
+   */
+  async inject(context, options = {}) {
+    if (!this.config.enabled) {
+      return this.emptyResult();
+    }
+    const startTime = Date.now();
+    const allInstructions = [];
+    for (const provider of this.providers.values()) {
+      try {
+        if (!provider.shouldGenerate(context)) {
+          continue;
+        }
+        const instructions = await provider.getInstructions(context);
+        let filtered = instructions;
+        if (options.includeTypes) {
+          filtered = filtered.filter((i) => options.includeTypes.includes(i.type));
+        }
+        if (options.excludeTypes) {
+          filtered = filtered.filter((i) => !options.excludeTypes.includes(i.type));
+        }
+        allInstructions.push(...filtered);
+      } catch (error) {
+        logger.error("Provider failed to generate instructions", {
+          provider: provider.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const activeInstructions = this.filterExpiredInstructions(
+      allInstructions,
+      context.turnCount
+    );
+    let allocation;
+    if (options.skipBudget) {
+      allocation = {
+        included: activeInstructions,
+        excluded: [],
+        tokensUsed: activeInstructions.reduce(
+          (sum, i) => sum + this.budgetManager.estimateInstructionTokens(i),
+          0
+        ),
+        remaining: 0,
+        perTypeUsage: this.calculateTypeUsage(activeInstructions)
+      };
+    } else {
+      allocation = this.budgetManager.allocateBudget(activeInstructions);
+    }
+    const formattedText = this.formatInstructions(allocation.included);
+    this.lastInjectionTime = Date.now();
+    const duration = Date.now() - startTime;
+    logger.debug("Instruction injection complete", {
+      providers: this.providers.size,
+      instructionsGenerated: allInstructions.length,
+      instructionsIncluded: allocation.included.length,
+      tokensUsed: allocation.tokensUsed,
+      durationMs: duration
+    });
+    return {
+      formattedText,
+      instructions: allocation.included,
+      allocation,
+      hasInstructions: allocation.included.length > 0
+    };
+  }
+  /**
+   * Format instructions as system reminder tags
+   */
+  formatInstructions(instructions) {
+    if (instructions.length === 0) {
+      return "";
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const instruction of instructions) {
+      const existing = grouped.get(instruction.type) || [];
+      existing.push(instruction);
+      grouped.set(instruction.type, existing);
+    }
+    const parts = [];
+    const typeOrder = ["mode", "task", "memory", "session", "delegation"];
+    for (const type of typeOrder) {
+      const typeInstructions = grouped.get(type);
+      if (!typeInstructions || typeInstructions.length === 0) continue;
+      for (const instruction of typeInstructions) {
+        parts.push(this.formatSingleInstruction(instruction));
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Format a single instruction as a system reminder
+   */
+  formatSingleInstruction(instruction) {
+    return `<system-reminder>
+${instruction.content}
+</system-reminder>`;
+  }
+  /**
+   * Filter out expired instructions
+   */
+  filterExpiredInstructions(instructions, currentTurn) {
+    return instructions.filter((instruction) => {
+      if (instruction.expiresAfter === void 0) {
+        return true;
+      }
+      const turnsSinceCreation = currentTurn;
+      return turnsSinceCreation < instruction.expiresAfter;
+    });
+  }
+  /**
+   * Calculate per-type token usage
+   */
+  calculateTypeUsage(instructions) {
+    const usage = {
+      task: 0,
+      memory: 0,
+      session: 0,
+      delegation: 0,
+      mode: 0
+    };
+    for (const instruction of instructions) {
+      const tokens = this.budgetManager.estimateInstructionTokens(instruction);
+      usage[instruction.type] = (usage[instruction.type] || 0) + tokens;
+    }
+    return usage;
+  }
+  /**
+   * Create an empty result
+   */
+  emptyResult() {
+    return {
+      formattedText: "",
+      instructions: [],
+      allocation: {
+        included: [],
+        excluded: [],
+        tokensUsed: 0,
+        remaining: this.budgetManager.getConfig().maxTotal,
+        perTypeUsage: {
+          task: 0,
+          memory: 0,
+          session: 0,
+          delegation: 0,
+          mode: 0
+        }
+      },
+      hasInstructions: false
+    };
+  }
+  /**
+   * Clear instruction cache
+   */
+  clearCache() {
+    this.instructionCache.clear();
+    logger.debug("Instruction cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.tokenBudget) {
+      this.budgetManager.updateConfig(updates.tokenBudget);
+    }
+    logger.debug("OrchestrationInstructionInjector config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Get budget manager for direct access
+   */
+  getBudgetManager() {
+    return this.budgetManager;
+  }
+  /**
+   * Check if orchestration is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Enable or disable orchestration
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+    logger.debug("Orchestration enabled state changed", { enabled });
+  }
+};
+
+// src/core/orchestration/todo-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_TODO_CONFIG = {
+  enabled: true,
+  reminderFrequency: 3,
+  compactMode: false,
+  maxCompactItems: 5,
+  showCompleted: false
+};
+var TodoInstructionProvider = class {
+  name = "todo";
+  config;
+  lastStateHash = "";
+  lastReminderTurn = 0;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_TODO_CONFIG,
+      ...config
+    };
+    logger.debug("TodoInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      reminderFrequency: this.config.reminderFrequency
+    });
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!context.todos || context.todos.length === 0) {
+      return false;
+    }
+    const currentHash = this.computeStateHash(context.todos);
+    const stateChanged = currentHash !== this.lastStateHash;
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const reminderDue = turnsSinceReminder >= this.config.reminderFrequency;
+    return stateChanged || reminderDue;
+  }
+  /**
+   * Generate instructions based on todo state
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    if (!context.todos || context.todos.length === 0) {
+      return instructions;
+    }
+    const currentHash = this.computeStateHash(context.todos);
+    const stateChanged = currentHash !== this.lastStateHash;
+    const activeTodos = context.todos.filter(
+      (todo) => todo.status !== "completed" || this.config.showCompleted
+    );
+    const inProgressTasks = activeTodos.filter((todo) => todo.status === "in_progress");
+    const pendingTasks = activeTodos.filter((todo) => todo.status === "pending");
+    const completedTasks = context.todos.filter((todo) => todo.status === "completed");
+    let content;
+    let priority;
+    if (stateChanged) {
+      content = this.formatFullTodoList(inProgressTasks, pendingTasks, completedTasks);
+      priority = "high";
+    } else if (this.config.compactMode) {
+      content = this.formatCompactReminder(inProgressTasks, pendingTasks);
+      priority = "normal";
+    } else {
+      content = this.formatStandardReminder(inProgressTasks, pendingTasks);
+      priority = "normal";
+    }
+    instructions.push({
+      type: "task",
+      priority,
+      content,
+      source: "automatosx",
+      createdAt: Date.now(),
+      expiresAfter: this.config.reminderFrequency + 1,
+      id: `todo-${currentHash.substring(0, 8)}`
+    });
+    this.lastStateHash = currentHash;
+    this.lastReminderTurn = context.turnCount;
+    logger.debug("Todo instructions generated", {
+      inProgress: inProgressTasks.length,
+      pending: pendingTasks.length,
+      completed: completedTasks.length,
+      stateChanged
+    });
+    return instructions;
+  }
+  /**
+   * Format full todo list (used when state changes)
+   */
+  formatFullTodoList(inProgress, pending, completed) {
+    const lines = [
+      "## Current Task List"
+    ];
+    if (inProgress.length > 0) {
+      lines.push("");
+      lines.push("### Currently Working On:");
+      for (const task of inProgress) {
+        lines.push(`- **${task.activeForm}**`);
+      }
+    }
+    if (pending.length > 0) {
+      lines.push("");
+      lines.push("### Pending Tasks:");
+      for (const task of pending) {
+        lines.push(`- [ ] ${task.content}`);
+      }
+    }
+    if (this.config.showCompleted && completed.length > 0) {
+      lines.push("");
+      lines.push("### Completed:");
+      for (const task of completed.slice(-3)) {
+        lines.push(`- [x] ${task.content}`);
+      }
+    }
+    lines.push("");
+    lines.push("**Remember:** Complete the current in-progress task before starting new ones.");
+    lines.push("Mark tasks as completed as soon as they are done.");
+    return lines.join("\n");
+  }
+  /**
+   * Format standard reminder
+   */
+  formatStandardReminder(inProgress, pending) {
+    const lines = [];
+    if (inProgress.length > 0) {
+      lines.push(`**Current Task:** ${inProgress[0].activeForm}`);
+    }
+    if (pending.length > 0) {
+      lines.push(`**Next:** ${pending[0].content}`);
+      if (pending.length > 1) {
+        lines.push(`(${pending.length - 1} more tasks pending)`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format compact reminder (minimal tokens)
+   */
+  formatCompactReminder(inProgress, pending) {
+    const parts = [];
+    if (inProgress.length > 0) {
+      parts.push(`Doing: ${inProgress[0].activeForm}`);
+    }
+    if (pending.length > 0) {
+      const count = Math.min(pending.length, this.config.maxCompactItems);
+      parts.push(`Next: ${pending.slice(0, count).map((t) => t.content).join(", ")}`);
+    }
+    return parts.join(" | ");
+  }
+  /**
+   * Compute hash of todo state for change detection
+   */
+  computeStateHash(todos) {
+    const stateString = todos.map((t) => `${t.id}:${t.status}:${t.content}`).sort().join("|");
+    return crypto2.createHash("sha256").update(stateString).digest("hex").substring(0, 16);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("TodoInstructionProvider config updated", {
+      enabled: this.config.enabled,
+      compactMode: this.config.compactMode
+    });
+  }
+  /**
+   * Reset state tracking (useful for testing)
+   */
+  reset() {
+    this.lastStateHash = "";
+    this.lastReminderTurn = 0;
+    logger.debug("TodoInstructionProvider state reset");
+  }
+};
+
+// src/core/orchestration/memory-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: true,
+  maxEntries: 5,
+  minRelevance: 0.5,
+  searchFrequency: 3,
+  maxAge: 0,
+  // No limit by default
+  includeMetadata: true,
+  cacheTTL: 6e4
+  // 1 minute
+};
+var MemoryInstructionProvider = class {
+  name = "memory";
+  config;
+  searchProvider;
+  cache;
+  lastSearchTurn = 0;
+  constructor(searchProvider, config) {
+    this.config = {
+      ...DEFAULT_MEMORY_CONFIG,
+      ...config
+    };
+    this.searchProvider = searchProvider;
+    logger.debug("MemoryInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      maxEntries: this.config.maxEntries,
+      hasSearchProvider: !!searchProvider
+    });
+  }
+  /**
+   * Set the memory search provider
+   */
+  setSearchProvider(provider) {
+    this.searchProvider = provider;
+    this.clearCache();
+    logger.debug("Memory search provider set");
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!this.searchProvider) {
+      return false;
+    }
+    if (!context.currentTask && context.todos.length === 0) {
+      return false;
+    }
+    const turnsSinceSearch = context.turnCount - this.lastSearchTurn;
+    const searchDue = turnsSinceSearch >= this.config.searchFrequency;
+    const cacheValid = this.cache && Date.now() - this.cache.timestamp < this.config.cacheTTL;
+    return searchDue || !cacheValid;
+  }
+  /**
+   * Generate instructions based on relevant memories
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    if (!this.searchProvider) {
+      return instructions;
+    }
+    const searchQuery = this.buildSearchQuery(context);
+    if (!searchQuery) {
+      return instructions;
+    }
+    try {
+      const memories = await this.searchMemories(searchQuery, context);
+      if (memories.length === 0) {
+        return instructions;
+      }
+      this.lastSearchTurn = context.turnCount;
+      const content = this.formatMemories(memories);
+      instructions.push({
+        type: "memory",
+        priority: "normal",
+        content,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.searchFrequency + 1,
+        id: `memory-${Date.now()}`
+      });
+      logger.debug("Memory instructions generated", {
+        memoriesFound: memories.length,
+        query: searchQuery.substring(0, 50)
+      });
+    } catch (error) {
+      logger.error("Failed to search memories", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return instructions;
+  }
+  /**
+   * Build search query from context
+   */
+  buildSearchQuery(context) {
+    const parts = [];
+    if (context.currentTask) {
+      parts.push(context.currentTask);
+    }
+    const inProgressTodos = context.todos.filter((t) => t.status === "in_progress");
+    for (const todo of inProgressTodos.slice(0, 2)) {
+      parts.push(todo.content);
+    }
+    if (context.agentName) {
+      parts.push(context.agentName);
+    }
+    if (parts.length === 0) {
+      return null;
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Search for relevant memories
+   */
+  async searchMemories(query, context) {
+    if (!this.searchProvider) {
+      return [];
+    }
+    if (this.cache && this.cache.query === query) {
+      const age = Date.now() - this.cache.timestamp;
+      if (age < this.config.cacheTTL) {
+        logger.debug("Using cached memory results", {
+          cacheAge: age,
+          resultCount: this.cache.results.length
+        });
+        return this.cache.results;
+      }
+    }
+    const results = await this.searchProvider.search({
+      text: query,
+      limit: this.config.maxEntries * 2,
+      // Get extra in case some are filtered
+      filters: context.agentName ? { agentId: context.agentName } : void 0
+    });
+    const filtered = results.filter((r) => r.score >= this.config.minRelevance).filter((r) => this.isWithinMaxAge(r.createdAt)).slice(0, this.config.maxEntries);
+    const memories = filtered.map((r) => ({
+      content: r.content,
+      relevance: r.score,
+      agent: r.metadata?.agentId,
+      timestamp: r.createdAt.getTime()
+    }));
+    this.cache = {
+      query,
+      results: memories,
+      timestamp: Date.now()
+    };
+    return memories;
+  }
+  /**
+   * Check if memory is within max age limit
+   */
+  isWithinMaxAge(createdAt) {
+    if (this.config.maxAge === 0) {
+      return true;
+    }
+    const age = Date.now() - createdAt.getTime();
+    return age <= this.config.maxAge;
+  }
+  /**
+   * Format memories into instruction content
+   */
+  formatMemories(memories) {
+    const lines = [
+      "## Relevant Context from Memory",
+      ""
+    ];
+    for (let i = 0; i < memories.length; i++) {
+      const memory = memories[i];
+      if (!memory) continue;
+      const relevancePercent = Math.round(memory.relevance * 100);
+      if (this.config.includeMetadata && memory.agent) {
+        lines.push(`### Memory ${i + 1} (${relevancePercent}% relevant, from ${memory.agent})`);
+      } else {
+        lines.push(`### Memory ${i + 1} (${relevancePercent}% relevant)`);
+      }
+      const maxLength = 500;
+      const content = memory.content.length > maxLength ? memory.content.substring(0, maxLength) + "..." : memory.content;
+      lines.push(content);
+      lines.push("");
+    }
+    lines.push("**Note:** Use this context to inform your decisions, but verify current state.");
+    return lines.join("\n");
+  }
+  /**
+   * Clear the memory cache
+   */
+  clearCache() {
+    this.cache = void 0;
+    logger.debug("Memory cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.minRelevance !== void 0 || updates.maxEntries !== void 0) {
+      this.clearCache();
+    }
+    logger.debug("MemoryInstructionProvider config updated", {
+      enabled: this.config.enabled,
+      maxEntries: this.config.maxEntries
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.cache = void 0;
+    this.lastSearchTurn = 0;
+    logger.debug("MemoryInstructionProvider reset");
+  }
+  /**
+   * Check if search provider is configured
+   */
+  hasSearchProvider() {
+    return !!this.searchProvider;
+  }
+};
+
+// src/core/orchestration/session-instruction-provider.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_SESSION_CONFIG = {
+  enabled: true,
+  showCollaboration: true,
+  showProgress: true,
+  reminderFrequency: 5,
+  showHandoffContext: true
+};
+var SessionInstructionProvider = class {
+  name = "session";
+  config;
+  stateProvider;
+  lastReminderTurn = 0;
+  cachedState;
+  cacheExpiry = 0;
+  CACHE_TTL = 3e4;
+  // 30 seconds
+  constructor(stateProvider, config) {
+    this.config = {
+      ...DEFAULT_SESSION_CONFIG,
+      ...config
+    };
+    this.stateProvider = stateProvider;
+    logger.debug("SessionInstructionProvider initialized", {
+      enabled: this.config.enabled,
+      hasStateProvider: !!stateProvider
+    });
+  }
+  /**
+   * Set the session state provider
+   */
+  setStateProvider(provider) {
+    this.stateProvider = provider;
+    this.clearCache();
+    logger.debug("Session state provider set");
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!context.sessionId && !this.stateProvider) {
+      return false;
+    }
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    return turnsSinceReminder >= this.config.reminderFrequency;
+  }
+  /**
+   * Generate instructions based on session state
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    const state = await this.getSessionState(context);
+    if (!state && !context.sessionId) {
+      return instructions;
+    }
+    const content = this.formatSessionContext(context, state);
+    if (content) {
+      instructions.push({
+        type: "session",
+        priority: "normal",
+        content,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.reminderFrequency,
+        id: `session-${context.sessionId || "default"}-${Date.now()}`
+      });
+    }
+    this.lastReminderTurn = context.turnCount;
+    logger.debug("Session instructions generated", {
+      sessionId: context.sessionId,
+      hasState: !!state
+    });
+    return instructions;
+  }
+  /**
+   * Get session state from provider or cache
+   */
+  async getSessionState(context) {
+    if (!context.sessionId) {
+      return null;
+    }
+    if (this.cachedState && this.cachedState.id === context.sessionId && Date.now() < this.cacheExpiry) {
+      return this.cachedState;
+    }
+    if (!this.stateProvider) {
+      return null;
+    }
+    try {
+      const state = await this.stateProvider.getSessionState(context.sessionId);
+      if (state) {
+        this.cachedState = state;
+        this.cacheExpiry = Date.now() + this.CACHE_TTL;
+      }
+      return state;
+    } catch (error) {
+      logger.error("Failed to get session state", {
+        sessionId: context.sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Format session context into instruction content
+   */
+  formatSessionContext(context, state) {
+    const lines = [];
+    if (context.sessionId) {
+      lines.push("## Session Context");
+      lines.push("");
+    }
+    if (this.config.showCollaboration && state && state.participants.length > 1) {
+      lines.push("### Multi-Agent Collaboration");
+      lines.push(`- **Session:** ${state.id.substring(0, 8)}...`);
+      lines.push(`- **Participants:** ${state.participants.join(", ")}`);
+      if (state.activeAgent) {
+        lines.push(`- **Currently Active:** ${state.activeAgent}`);
+      }
+      lines.push("");
+    }
+    if (this.config.showProgress && state) {
+      const totalTasks = state.completedTasks + state.remainingTasks;
+      if (totalTasks > 0) {
+        const progress = Math.round(state.completedTasks / totalTasks * 100);
+        lines.push("### Session Progress");
+        lines.push(`- Completed: ${state.completedTasks}/${totalTasks} (${progress}%)`);
+        if (state.remainingTasks > 0) {
+          lines.push(`- Remaining: ${state.remainingTasks} task(s)`);
+        }
+        lines.push("");
+      }
+    }
+    if (this.config.showHandoffContext && context.parentAgent) {
+      lines.push("### Delegation Context");
+      lines.push(`- **Delegated from:** ${context.parentAgent}`);
+      if (context.currentTask) {
+        lines.push(`- **Task:** ${context.currentTask}`);
+      }
+      lines.push("");
+      lines.push("**Note:** Complete this task and return control to the parent agent.");
+      lines.push("");
+    }
+    if (context.agentName && !context.parentAgent) {
+      lines.push(`**Current Agent:** ${context.agentName}`);
+      lines.push("");
+    }
+    if (lines.length <= 2) {
+      return null;
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Clear cached state
+   */
+  clearCache() {
+    this.cachedState = void 0;
+    this.cacheExpiry = 0;
+    logger.debug("Session cache cleared");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("SessionInstructionProvider config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.lastReminderTurn = 0;
+    this.clearCache();
+    logger.debug("SessionInstructionProvider reset");
+  }
+  /**
+   * Check if state provider is configured
+   */
+  hasStateProvider() {
+    return !!this.stateProvider;
+  }
+};
+
+// src/agents/agent-instruction-injector.ts
+init_esm_shims();
+init_logger();
+
+// src/agents/instruction-templates.ts
+init_esm_shims();
+var BACKEND_TEMPLATE = {
+  domain: "backend",
+  displayName: "Backend Engineer",
+  domainReminders: [
+    "Follow RESTful API design principles",
+    "Use proper HTTP status codes",
+    "Implement input validation at API boundaries",
+    "Consider database query performance",
+    "Handle errors gracefully with meaningful messages"
+  ],
+  qualityChecklist: [
+    "API endpoints follow REST conventions",
+    "Database queries are optimized (no N+1)",
+    "Input is validated before processing",
+    "Errors are logged with context",
+    "Sensitive data is not exposed in responses"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["security", "authentication", "authorization", "OWASP", "vulnerability"],
+      suggestedAgent: "security",
+      reason: "Security-related tasks benefit from specialized security review"
+    },
+    {
+      keywords: ["frontend", "UI", "React", "CSS", "component"],
+      suggestedAgent: "frontend",
+      reason: "Frontend implementation should be handled by frontend specialist"
+    },
+    {
+      keywords: ["test", "testing", "unit test", "integration test"],
+      suggestedAgent: "quality",
+      reason: "Testing strategy benefits from QA expertise"
+    }
+  ],
+  antiPatterns: [
+    "Avoid SQL injection by using parameterized queries",
+    "Don't expose internal error details to clients",
+    "Avoid synchronous blocking operations",
+    "Don't hardcode configuration values"
+  ],
+  bestPractices: [
+    "Use prepared statements for database queries",
+    "Implement proper logging with correlation IDs",
+    "Use dependency injection for testability",
+    "Follow the principle of least privilege"
+  ]
+};
+var FRONTEND_TEMPLATE = {
+  domain: "frontend",
+  displayName: "Frontend Engineer",
+  domainReminders: [
+    "Ensure accessibility (WCAG compliance)",
+    "Optimize for performance (Core Web Vitals)",
+    "Handle loading and error states",
+    "Implement responsive design",
+    "Consider keyboard navigation"
+  ],
+  qualityChecklist: [
+    "Components are accessible (ARIA labels, roles)",
+    "Loading states are handled",
+    "Error boundaries catch failures gracefully",
+    "Forms have proper validation feedback",
+    "Images have alt text"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["API", "endpoint", "database", "backend", "server"],
+      suggestedAgent: "backend",
+      reason: "Backend changes should be handled by backend specialist"
+    },
+    {
+      keywords: ["security", "XSS", "CSRF", "sanitize"],
+      suggestedAgent: "security",
+      reason: "Security concerns require specialized review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid inline styles for reusable components",
+    "Don't mutate state directly",
+    "Avoid excessive re-renders",
+    "Don't ignore accessibility requirements"
+  ],
+  bestPractices: [
+    "Use semantic HTML elements",
+    "Implement proper form validation",
+    "Optimize bundle size",
+    "Use React.memo for expensive components"
+  ]
+};
+var SECURITY_TEMPLATE = {
+  domain: "security",
+  displayName: "Security Engineer",
+  domainReminders: [
+    "Apply OWASP Top 10 security guidelines",
+    "Validate and sanitize ALL user input",
+    "Use parameterized queries to prevent SQL injection",
+    "Implement proper authentication and authorization",
+    "Never expose sensitive data in logs or responses"
+  ],
+  qualityChecklist: [
+    "Input validation is present at all entry points",
+    "Authentication tokens are handled securely",
+    "Sensitive data is encrypted at rest and in transit",
+    "Error messages don't leak implementation details",
+    "Dependencies are checked for known vulnerabilities"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["performance", "optimization", "speed", "latency"],
+      suggestedAgent: "backend",
+      reason: "Performance optimization is a backend concern"
+    }
+  ],
+  antiPatterns: [
+    "Never trust user input without validation",
+    "Don't store passwords in plain text",
+    "Avoid security through obscurity",
+    "Don't disable security features for convenience"
+  ],
+  bestPractices: [
+    "Follow the principle of least privilege",
+    "Implement defense in depth",
+    "Use secure defaults",
+    "Fail securely (deny by default)"
+  ]
+};
+var QUALITY_TEMPLATE = {
+  domain: "quality",
+  displayName: "Quality Assurance Engineer",
+  domainReminders: [
+    "Write tests that verify behavior, not implementation",
+    "Cover edge cases and error scenarios",
+    "Ensure test isolation (no shared state)",
+    "Use meaningful test descriptions",
+    "Follow the Arrange-Act-Assert pattern"
+  ],
+  qualityChecklist: [
+    "Unit tests cover critical paths",
+    "Integration tests verify component interactions",
+    "Edge cases are tested",
+    "Error handling is verified",
+    "Tests are maintainable and readable"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "build", "create", "develop"],
+      suggestedAgent: "backend",
+      reason: "Implementation tasks should go to domain specialists"
+    },
+    {
+      keywords: ["security", "vulnerability", "penetration"],
+      suggestedAgent: "security",
+      reason: "Security testing requires specialized expertise"
+    }
+  ],
+  antiPatterns: [
+    "Avoid testing implementation details",
+    "Don't use flaky tests",
+    "Avoid excessive mocking",
+    "Don't ignore failing tests"
+  ],
+  bestPractices: [
+    "Test behavior, not implementation",
+    "Use descriptive test names",
+    "Keep tests independent",
+    "Follow the testing pyramid"
+  ]
+};
+var ARCHITECTURE_TEMPLATE = {
+  domain: "architecture",
+  displayName: "Software Architect",
+  domainReminders: [
+    "Consider scalability implications",
+    "Document architectural decisions (ADRs)",
+    "Evaluate trade-offs explicitly",
+    "Design for maintainability",
+    "Consider operational concerns"
+  ],
+  qualityChecklist: [
+    "Architecture supports future scaling",
+    "Components have clear boundaries",
+    "Dependencies are managed properly",
+    "System is observable (logging, metrics)",
+    "Failure modes are handled"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "code", "fix", "bug"],
+      suggestedAgent: "backend",
+      reason: "Implementation details should be handled by domain specialists"
+    },
+    {
+      keywords: ["security", "compliance", "audit"],
+      suggestedAgent: "security",
+      reason: "Security architecture needs specialized review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid premature optimization",
+    "Don't over-engineer solutions",
+    "Avoid tight coupling between components",
+    "Don't ignore non-functional requirements"
+  ],
+  bestPractices: [
+    "Design for change",
+    "Use well-known patterns",
+    "Document decisions and rationale",
+    "Consider operational requirements"
+  ]
+};
+var DEVOPS_TEMPLATE = {
+  domain: "devops",
+  displayName: "DevOps Engineer",
+  domainReminders: [
+    "Automate repetitive tasks",
+    "Implement proper monitoring and alerting",
+    "Follow infrastructure as code principles",
+    "Consider disaster recovery",
+    "Optimize for reliability and cost"
+  ],
+  qualityChecklist: [
+    "Deployments are automated and repeatable",
+    "Monitoring covers key metrics",
+    "Alerts are actionable",
+    "Backups are tested",
+    "Security is integrated into CI/CD"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["code", "feature", "bug", "implement"],
+      suggestedAgent: "backend",
+      reason: "Application code changes should go to developers"
+    },
+    {
+      keywords: ["security", "credentials", "secrets"],
+      suggestedAgent: "security",
+      reason: "Security-sensitive changes need security review"
+    }
+  ],
+  antiPatterns: [
+    "Avoid manual deployments",
+    "Don't store secrets in code",
+    "Avoid single points of failure",
+    "Don't ignore monitoring gaps"
+  ],
+  bestPractices: [
+    "Use infrastructure as code",
+    "Implement CI/CD pipelines",
+    "Follow GitOps practices",
+    "Use immutable infrastructure"
+  ]
+};
+var WRITER_TEMPLATE = {
+  domain: "writer",
+  displayName: "Technical Writer",
+  domainReminders: [
+    "Write for the target audience",
+    "Use clear, concise language",
+    "Include practical examples",
+    "Structure content logically",
+    "Keep documentation up to date"
+  ],
+  qualityChecklist: [
+    "Documentation matches current code",
+    "Examples are working and tested",
+    "Content is well-organized",
+    "Technical terms are explained",
+    "Links and references are valid"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["implement", "code", "fix", "develop"],
+      suggestedAgent: "backend",
+      reason: "Code changes should be handled by developers"
+    }
+  ],
+  antiPatterns: [
+    "Avoid jargon without explanation",
+    "Don't assume reader knowledge",
+    "Avoid outdated examples",
+    "Don't ignore code comments"
+  ],
+  bestPractices: [
+    "Use consistent terminology",
+    "Include code examples",
+    "Keep documentation near code",
+    "Update docs with code changes"
+  ]
+};
+var STANDARD_TEMPLATE = {
+  domain: "standard",
+  displayName: "General Assistant",
+  domainReminders: [
+    "Understand the task before starting",
+    "Ask clarifying questions when needed",
+    "Break complex tasks into smaller steps",
+    "Verify your work before completing",
+    "Document your changes"
+  ],
+  qualityChecklist: [
+    "Task requirements are understood",
+    "Changes are tested",
+    "Code follows project conventions",
+    "Documentation is updated",
+    "No regressions introduced"
+  ],
+  delegationTriggers: [
+    {
+      keywords: ["security", "vulnerability", "authentication"],
+      suggestedAgent: "security",
+      reason: "Security tasks need specialized attention"
+    },
+    {
+      keywords: ["test", "testing", "QA", "quality"],
+      suggestedAgent: "quality",
+      reason: "Testing benefits from QA expertise"
+    },
+    {
+      keywords: ["architecture", "design", "scalability"],
+      suggestedAgent: "architecture",
+      reason: "Architectural decisions need careful consideration"
+    }
+  ],
+  antiPatterns: [
+    "Avoid making changes without understanding context",
+    "Don't skip testing",
+    "Avoid large, monolithic changes",
+    "Don't ignore existing patterns"
+  ],
+  bestPractices: [
+    "Follow existing code conventions",
+    "Write self-documenting code",
+    "Test your changes",
+    "Keep changes focused"
+  ]
+};
+var AGENT_TEMPLATES = {
+  backend: BACKEND_TEMPLATE,
+  frontend: FRONTEND_TEMPLATE,
+  fullstack: { ...BACKEND_TEMPLATE, domain: "fullstack", displayName: "Fullstack Engineer" },
+  security: SECURITY_TEMPLATE,
+  quality: QUALITY_TEMPLATE,
+  architecture: ARCHITECTURE_TEMPLATE,
+  devops: DEVOPS_TEMPLATE,
+  data: { ...BACKEND_TEMPLATE, domain: "data", displayName: "Data Engineer" },
+  mobile: { ...FRONTEND_TEMPLATE, domain: "mobile", displayName: "Mobile Engineer" },
+  writer: WRITER_TEMPLATE,
+  researcher: { ...STANDARD_TEMPLATE, domain: "researcher", displayName: "Researcher" },
+  standard: STANDARD_TEMPLATE
+};
+function getAgentTemplate(domain) {
+  return AGENT_TEMPLATES[domain] || STANDARD_TEMPLATE;
+}
+function isValidAgentDomain(domain) {
+  return domain in AGENT_TEMPLATES;
+}
+function getDelegationSuggestions(text, currentDomain) {
+  const template = getAgentTemplate(currentDomain);
+  const suggestions = [];
+  const textLower = text.toLowerCase();
+  for (const trigger of template.delegationTriggers) {
+    const matchedKeywords = trigger.keywords.filter(
+      (kw) => textLower.includes(kw.toLowerCase())
+    );
+    if (matchedKeywords.length > 0) {
+      suggestions.push({
+        agent: trigger.suggestedAgent,
+        reason: trigger.reason,
+        keywords: matchedKeywords
+      });
+    }
+  }
+  return suggestions;
+}
+
+// src/agents/agent-instruction-injector.ts
+var DEFAULT_AGENT_CONFIG = {
+  enabled: true,
+  reminderFrequency: 5,
+  delegationDetection: true,
+  minDelegationKeywords: 1,
+  includeQualityChecklist: true,
+  qualityChecklistFrequency: 10,
+  includeAntiPatterns: true
+};
+var AgentInstructionInjector = class {
+  name = "agent-template";
+  config;
+  lastReminderTurn = 0;
+  lastQualityCheckTurn = 0;
+  currentDomain;
+  recentTaskText = "";
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_AGENT_CONFIG,
+      ...config
+    };
+    logger.debug("AgentInstructionInjector initialized", {
+      enabled: this.config.enabled,
+      reminderFrequency: this.config.reminderFrequency
+    });
+  }
+  /**
+   * Set the current agent domain
+   */
+  setDomain(domain) {
+    if (isValidAgentDomain(domain)) {
+      this.currentDomain = domain;
+      logger.debug("Agent domain set", { domain });
+    } else {
+      this.currentDomain = "standard";
+      logger.debug("Unknown domain, using standard", { domain });
+    }
+  }
+  /**
+   * Get the current domain
+   */
+  getDomain() {
+    return this.currentDomain;
+  }
+  /**
+   * Check if provider should generate instructions
+   */
+  shouldGenerate(context) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    const domain = this.resolveDomain(context);
+    if (!domain) {
+      return false;
+    }
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const reminderDue = turnsSinceReminder >= this.config.reminderFrequency;
+    const turnsSinceQuality = context.turnCount - this.lastQualityCheckTurn;
+    const qualityDue = this.config.includeQualityChecklist && turnsSinceQuality >= this.config.qualityChecklistFrequency;
+    const hasDelegationTriggers = this.config.delegationDetection && this.checkDelegationTriggers(context);
+    return reminderDue || qualityDue || hasDelegationTriggers;
+  }
+  /**
+   * Generate instructions based on agent domain
+   */
+  async getInstructions(context) {
+    const instructions = [];
+    const domain = this.resolveDomain(context);
+    if (!domain) {
+      return instructions;
+    }
+    const template = getAgentTemplate(domain);
+    const turnsSinceReminder = context.turnCount - this.lastReminderTurn;
+    const turnsSinceQuality = context.turnCount - this.lastQualityCheckTurn;
+    if (turnsSinceReminder >= this.config.reminderFrequency) {
+      const reminderContent = this.formatDomainReminders(template);
+      instructions.push({
+        type: "delegation",
+        priority: "normal",
+        content: reminderContent,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.reminderFrequency,
+        id: `agent-reminder-${domain}-${Date.now()}`
+      });
+      this.lastReminderTurn = context.turnCount;
+    }
+    if (this.config.includeQualityChecklist && turnsSinceQuality >= this.config.qualityChecklistFrequency) {
+      const checklistContent = this.formatQualityChecklist(template);
+      instructions.push({
+        type: "delegation",
+        priority: "normal",
+        content: checklistContent,
+        source: "automatosx",
+        createdAt: Date.now(),
+        expiresAfter: this.config.qualityChecklistFrequency,
+        id: `agent-quality-${domain}-${Date.now()}`
+      });
+      this.lastQualityCheckTurn = context.turnCount;
+    }
+    if (this.config.delegationDetection) {
+      const taskText = this.extractTaskText(context);
+      if (taskText !== this.recentTaskText) {
+        this.recentTaskText = taskText;
+        const delegationContent = this.checkAndFormatDelegation(template, taskText);
+        if (delegationContent) {
+          instructions.push({
+            type: "delegation",
+            priority: "high",
+            content: delegationContent,
+            source: "automatosx",
+            createdAt: Date.now(),
+            expiresAfter: 3,
+            id: `agent-delegation-${Date.now()}`
+          });
+        }
+      }
+    }
+    logger.debug("Agent instructions generated", {
+      domain,
+      instructionCount: instructions.length
+    });
+    return instructions;
+  }
+  /**
+   * Resolve domain from context or current setting
+   */
+  resolveDomain(context) {
+    if (context.agentName && isValidAgentDomain(context.agentName)) {
+      return context.agentName;
+    }
+    return this.currentDomain;
+  }
+  /**
+   * Extract task text from context for delegation detection
+   */
+  extractTaskText(context) {
+    const parts = [];
+    if (context.currentTask) {
+      parts.push(context.currentTask);
+    }
+    for (const todo of context.todos.filter((t) => t.status === "in_progress")) {
+      parts.push(todo.content);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Check if delegation triggers are present
+   */
+  checkDelegationTriggers(context) {
+    const domain = this.resolveDomain(context);
+    if (!domain) return false;
+    const taskText = this.extractTaskText(context);
+    if (!taskText) return false;
+    const suggestions = getDelegationSuggestions(taskText, domain);
+    return suggestions.some((s) => s.keywords.length >= this.config.minDelegationKeywords);
+  }
+  /**
+   * Format domain reminders
+   */
+  formatDomainReminders(template) {
+    const lines = [
+      `## ${template.displayName} Reminders`,
+      ""
+    ];
+    for (const reminder of template.domainReminders) {
+      lines.push(`- ${reminder}`);
+    }
+    if (this.config.includeAntiPatterns && template.antiPatterns.length > 0) {
+      lines.push("");
+      lines.push("**Avoid:**");
+      for (const antiPattern of template.antiPatterns.slice(0, 3)) {
+        lines.push(`- ${antiPattern}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format quality checklist
+   */
+  formatQualityChecklist(template) {
+    const lines = [
+      `## Quality Checklist (${template.displayName})`,
+      "",
+      "Before completing, verify:"
+    ];
+    for (const item of template.qualityChecklist) {
+      lines.push(`- [ ] ${item}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Check for delegation triggers and format suggestion
+   */
+  checkAndFormatDelegation(template, taskText) {
+    const suggestions = getDelegationSuggestions(taskText, template.domain);
+    const relevantSuggestions = suggestions.filter(
+      (s) => s.keywords.length >= this.config.minDelegationKeywords
+    );
+    if (relevantSuggestions.length === 0) {
+      return null;
+    }
+    const lines = [
+      "## Delegation Suggestion",
+      ""
+    ];
+    for (const suggestion of relevantSuggestions) {
+      lines.push(`**Consider delegating to @${suggestion.agent}**`);
+      lines.push(`- Reason: ${suggestion.reason}`);
+      lines.push(`- Triggered by: ${suggestion.keywords.join(", ")}`);
+      lines.push("");
+    }
+    lines.push("Use `DELEGATE TO @agent: task` or `@agent task` syntax to delegate.");
+    return lines.join("\n");
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    logger.debug("AgentInstructionInjector config updated", {
+      enabled: this.config.enabled
+    });
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.lastReminderTurn = 0;
+    this.lastQualityCheckTurn = 0;
+    this.recentTaskText = "";
+    logger.debug("AgentInstructionInjector reset");
+  }
+};
+
+// src/core/orchestration/orchestration-service.ts
+var OrchestrationService = class {
+  config;
+  injector;
+  tokenBudgetManager;
+  workflowModeManager;
+  agentInjector;
+  todoProvider;
+  memoryProvider;
+  sessionProvider;
+  turnCount = 0;
+  currentTodos = [];
+  constructor(serviceConfig = {}) {
+    this.config = {
+      ...DEFAULT_ORCHESTRATION_CONFIG,
+      ...serviceConfig
+    };
+    this.injector = new OrchestrationInstructionInjector(this.config);
+    this.tokenBudgetManager = new TokenBudgetManager(this.config.tokenBudget);
+    this.workflowModeManager = new WorkflowModeManager();
+    this.agentInjector = new AgentInstructionInjector({
+      enabled: this.config.agentTemplates?.enabled ?? true,
+      reminderFrequency: this.config.agentTemplates?.reminderFrequency ?? 5
+    });
+    this.initializeProviders(serviceConfig);
+    logger.debug("OrchestrationService initialized", {
+      todoEnabled: this.config.todoIntegration?.enabled,
+      memoryEnabled: this.config.memoryIntegration?.enabled,
+      sessionEnabled: this.config.sessionIntegration?.enabled,
+      agentTemplatesEnabled: this.config.agentTemplates?.enabled
+    });
+  }
+  /**
+   * Initialize instruction providers
+   */
+  initializeProviders(serviceConfig) {
+    if (this.config.todoIntegration?.enabled !== false) {
+      this.todoProvider = new TodoInstructionProvider({
+        enabled: true,
+        reminderFrequency: this.config.todoIntegration?.reminderFrequency ?? 3,
+        compactMode: this.config.todoIntegration?.compactMode ?? false
+      });
+      this.injector.registerProvider(this.todoProvider);
+    }
+    if (this.config.memoryIntegration?.enabled !== false && serviceConfig.memorySearchProvider) {
+      this.memoryProvider = new MemoryInstructionProvider(
+        serviceConfig.memorySearchProvider,
+        {
+          enabled: true,
+          maxEntries: this.config.memoryIntegration?.maxEntries ?? 5,
+          minRelevance: this.config.memoryIntegration?.minRelevance ?? 0.5
+        }
+      );
+      this.injector.registerProvider(this.memoryProvider);
+    }
+    if (this.config.sessionIntegration?.enabled !== false) {
+      this.sessionProvider = new SessionInstructionProvider(
+        serviceConfig.sessionStateProvider,
+        {
+          enabled: true,
+          showCollaboration: this.config.sessionIntegration?.showCollaboration ?? true,
+          showProgress: true,
+          reminderFrequency: 5,
+          showHandoffContext: true
+        }
+      );
+      this.injector.registerProvider(this.sessionProvider);
+    }
+    if (this.config.agentTemplates?.enabled !== false) {
+      if (serviceConfig.agentDomain) {
+        this.agentInjector.setDomain(serviceConfig.agentDomain);
+      }
+      this.injector.registerProvider(this.agentInjector);
+    }
+  }
+  /**
+   * Set the current agent domain for agent-specific instructions
+   */
+  setAgentDomain(domain) {
+    this.agentInjector.setDomain(domain);
+    logger.debug("Agent domain set", { domain });
+  }
+  /**
+   * Set the memory search provider
+   */
+  setMemoryProvider(provider) {
+    if (this.memoryProvider) {
+      this.memoryProvider.setSearchProvider(provider);
+    } else if (this.config.memoryIntegration?.enabled !== false) {
+      this.memoryProvider = new MemoryInstructionProvider(provider, {
+        enabled: true,
+        maxEntries: this.config.memoryIntegration?.maxEntries ?? 5,
+        minRelevance: this.config.memoryIntegration?.minRelevance ?? 0.5
+      });
+      this.injector.registerProvider(this.memoryProvider);
+    }
+  }
+  /**
+   * Set the session state provider
+   */
+  setSessionProvider(provider) {
+    if (this.sessionProvider) {
+      this.sessionProvider.setStateProvider(provider);
+    }
+  }
+  /**
+   * Update the current todo list
+   */
+  updateTodos(todos) {
+    this.currentTodos = todos;
+  }
+  /**
+   * Set the workflow mode
+   */
+  setWorkflowMode(mode) {
+    this.workflowModeManager.setMode(mode);
+    logger.debug("Workflow mode set", { mode });
+  }
+  /**
+   * Get current workflow mode
+   */
+  getWorkflowMode() {
+    return this.workflowModeManager.getCurrentMode();
+  }
+  /**
+   * Check if a tool is allowed in current workflow mode
+   */
+  isToolAllowed(toolName) {
+    return this.workflowModeManager.isToolAllowed(toolName);
+  }
+  /**
+   * Filter tools based on current workflow mode
+   */
+  filterTools(tools) {
+    return this.workflowModeManager.filterTools(tools);
+  }
+  /**
+   * Increment turn count (called after each agent response)
+   */
+  incrementTurn() {
+    this.turnCount++;
+  }
+  /**
+   * Get current turn count
+   */
+  getTurnCount() {
+    return this.turnCount;
+  }
+  /**
+   * Generate and inject instructions for the current context
+   */
+  async injectInstructions(options = {}) {
+    const context = {
+      todos: this.currentTodos,
+      turnCount: this.turnCount,
+      workflowMode: this.workflowModeManager.getCurrentMode(),
+      currentTask: options.task,
+      agentName: options.agentName,
+      sessionId: options.sessionId,
+      parentAgent: options.parentAgent
+    };
+    const result = await this.injector.inject(context);
+    logger.debug("Instructions injected", {
+      instructionCount: result.instructions.length,
+      tokensUsed: result.allocation.tokensUsed,
+      hasInstructions: result.hasInstructions
+    });
+    return {
+      content: result.formattedText,
+      instructions: result.instructions,
+      tokenCount: result.allocation.tokensUsed,
+      applied: result.hasInstructions
+    };
+  }
+  /**
+   * Format instructions as system reminder tags
+   */
+  formatAsSystemReminder(content) {
+    if (!content || content.trim().length === 0) {
+      return "";
+    }
+    return `<system-reminder>
+${content}
+</system-reminder>`;
+  }
+  /**
+   * Get debug information about current orchestration state
+   */
+  getDebugInfo() {
+    const budgetConfig = this.tokenBudgetManager.getConfig();
+    const providers = this.injector.getProviders().map((p) => p.name);
+    return {
+      turnCount: this.turnCount,
+      workflowMode: this.workflowModeManager.getCurrentMode(),
+      todoCount: this.currentTodos.length,
+      providers,
+      tokenBudget: {
+        used: 0,
+        // Would need to track this
+        total: budgetConfig.maxTotal,
+        remaining: budgetConfig.maxTotal
+      }
+    };
+  }
+  /**
+   * Reset all state (for new conversations)
+   */
+  reset() {
+    this.turnCount = 0;
+    this.currentTodos = [];
+    this.workflowModeManager.reset();
+    this.agentInjector.reset();
+    this.injector.clearCache();
+    if (this.todoProvider) {
+      this.todoProvider.reset();
+    }
+    if (this.memoryProvider) {
+      this.memoryProvider.clearCache();
+    }
+    if (this.sessionProvider) {
+      this.sessionProvider.reset();
+    }
+    logger.debug("OrchestrationService reset");
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    if (updates.tokenBudget) {
+      this.tokenBudgetManager = new TokenBudgetManager(updates.tokenBudget);
+    }
+    logger.debug("OrchestrationService config updated", { updates });
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/cli/commands/debug-instructions.ts
+var debugInstructionsCommand = {
+  command: "debug:instructions",
+  describe: "Show current embedded instructions state (v11.3.0)",
+  builder: (yargs2) => {
+    return yargs2.option("tokens", {
+      alias: "t",
+      describe: "Show token budget details",
+      type: "boolean",
+      default: false
+    }).option("providers", {
+      alias: "p",
+      describe: "Show registered instruction providers",
+      type: "boolean",
+      default: false
+    }).option("templates", {
+      describe: "Show available agent templates",
+      type: "boolean",
+      default: false
+    }).option("agent", {
+      alias: "a",
+      describe: "Show template for specific agent domain",
+      type: "string"
+    }).option("verbose", {
+      alias: "v",
+      describe: "Show verbose output",
+      type: "boolean",
+      default: false
+    }).example("$0 debug:instructions", "Show overall instruction state").example("$0 debug:instructions --tokens", "Show token budget details").example("$0 debug:instructions --providers", "List instruction providers").example("$0 debug:instructions --templates", "List agent templates").example("$0 debug:instructions --agent backend", "Show backend agent template");
+  },
+  handler: async (argv) => {
+    try {
+      if (argv.tokens) {
+        displayTokenBudget(argv.verbose);
+        return;
+      }
+      if (argv.providers) {
+        displayProviders(argv.verbose);
+        return;
+      }
+      if (argv.templates) {
+        displayAgentTemplates(argv.verbose);
+        return;
+      }
+      if (argv.agent) {
+        displayAgentTemplate(argv.agent, argv.verbose);
+        return;
+      }
+      displayOverallState(argv.verbose);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk5.red.bold(`
+\u274C Error: ${err.message}
+`));
+      logger.error("Debug instructions command failed", { error: err.message });
+      process.exit(1);
+    }
+  }
+};
+function displayOverallState(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F50D} Embedded Instructions Debug Info\n"));
+  console.log(chalk5.dim("\u2550".repeat(60)));
+  const service = new OrchestrationService();
+  const debugInfo = service.getDebugInfo();
+  console.log(chalk5.cyan("\n\u{1F4CA} Current State"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  console.log(`  Turn count: ${chalk5.yellow(debugInfo.turnCount)}`);
+  console.log(`  Workflow mode: ${chalk5.cyan(debugInfo.workflowMode)}`);
+  console.log(`  Active todos: ${chalk5.yellow(debugInfo.todoCount)}`);
+  console.log(`  Registered providers: ${chalk5.green(debugInfo.providers.length)}`);
+  console.log(chalk5.cyan("\n\u{1F4B0} Token Budget"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  console.log(`  Used: ${chalk5.yellow(debugInfo.tokenBudget.used)} / ${debugInfo.tokenBudget.total}`);
+  const usagePercent = Math.round(debugInfo.tokenBudget.used / debugInfo.tokenBudget.total * 100);
+  const barLength = 30;
+  const filledLength = Math.round(usagePercent / 100 * barLength);
+  const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
+  const barColor = usagePercent > 80 ? chalk5.red : usagePercent > 50 ? chalk5.yellow : chalk5.green;
+  console.log(`  ${barColor(bar)} ${usagePercent}%`);
+  if (debugInfo.providers.length > 0) {
+    console.log(chalk5.cyan("\n\u{1F50C} Active Providers"));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    debugInfo.providers.forEach((provider, index) => {
+      console.log(`  ${index + 1}. ${chalk5.green(provider)}`);
+    });
+  }
+  console.log(chalk5.cyan("\n\u{1F504} Workflow Modes"));
+  console.log(chalk5.dim("\u2500".repeat(40)));
+  Object.keys(WORKFLOW_MODES).forEach((mode) => {
+    const isCurrent = mode === debugInfo.workflowMode;
+    const prefix = isCurrent ? chalk5.green("\u25BA") : " ";
+    const modeText = isCurrent ? chalk5.green.bold(mode) : chalk5.gray(mode);
+    console.log(`  ${prefix} ${modeText}`);
+  });
+  console.log(chalk5.dim("\n" + "\u2550".repeat(60)));
+  console.log(chalk5.gray("\nUse --tokens, --providers, or --templates for detailed info.\n"));
+}
+function displayTokenBudget(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F4B0} Token Budget Details\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  const budgetManager = new TokenBudgetManager();
+  const config = budgetManager.getConfig();
+  console.log(`
+  Total budget: ${chalk5.cyan(config.maxTotal)} tokens`);
+  console.log(`  Critical reserve: ${chalk5.yellow(config.criticalReserve)} tokens`);
+  console.log(`  Available: ${chalk5.green(config.maxTotal - config.criticalReserve)} tokens`);
+  console.log(chalk5.cyan("\n  Per-Type Allocations:"));
+  const typeAllocations = [
+    { type: "task", budget: 500, description: "Todo/task reminders" },
+    { type: "memory", budget: 400, description: "Memory context" },
+    { type: "session", budget: 300, description: "Session state" },
+    { type: "delegation", budget: 300, description: "Agent delegation hints" },
+    { type: "mode", budget: 200, description: "Workflow mode instructions" }
+  ];
+  typeAllocations.forEach(({ type, budget, description }) => {
+    console.log(`    \u2022 ${chalk5.cyan(type)}: ${budget} tokens`);
+    if (verbose) {
+      console.log(chalk5.gray(`      ${description}`));
+    }
+  });
+  console.log(chalk5.cyan("\n  Token Estimation:"));
+  console.log(chalk5.gray("    ~4 characters = 1 token (approximation)"));
+  console.log(chalk5.gray("    Actual usage may vary by content"));
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log();
+}
+function displayProviders(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F50C} Instruction Providers\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  const providers = [
+    {
+      name: "TodoInstructionProvider",
+      description: "Generates task reminders from todo list",
+      triggers: "Todo state changes, periodic reminders",
+      priority: "high"
+    },
+    {
+      name: "MemoryInstructionProvider",
+      description: "Injects relevant context from memory",
+      triggers: "Task keywords, memory relevance",
+      priority: "normal"
+    },
+    {
+      name: "SessionInstructionProvider",
+      description: "Shows multi-agent collaboration state",
+      triggers: "Session changes, periodic reminders",
+      priority: "normal"
+    },
+    {
+      name: "AgentInstructionInjector",
+      description: "Domain-specific reminders and delegation hints",
+      triggers: "Agent domain, task keywords",
+      priority: "normal"
+    },
+    {
+      name: "WorkflowModeManager",
+      description: "Mode-specific instructions and tool filtering",
+      triggers: "Mode changes",
+      priority: "high"
+    }
+  ];
+  providers.forEach((provider, index) => {
+    console.log(`
+  ${index + 1}. ${chalk5.cyan.bold(provider.name)}`);
+    console.log(chalk5.gray(`     ${provider.description}`));
+    if (verbose) {
+      console.log(`     Triggers: ${chalk5.yellow(provider.triggers)}`);
+      console.log(`     Priority: ${chalk5.green(provider.priority)}`);
+    }
+  });
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log();
+}
+function displayAgentTemplates(verbose) {
+  console.log(chalk5.blue.bold("\n\u{1F4CB} Agent Instruction Templates\n"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  for (const [domain, template] of Object.entries(AGENT_TEMPLATES)) {
+    console.log(`
+  ${chalk5.cyan.bold(template.displayName)} (${domain})`);
+    if (verbose) {
+      console.log(chalk5.gray(`    Reminders: ${template.domainReminders.length}`));
+      console.log(chalk5.gray(`    Checklist items: ${template.qualityChecklist.length}`));
+      console.log(chalk5.gray(`    Delegation triggers: ${template.delegationTriggers.length}`));
+      console.log(chalk5.gray(`    Anti-patterns: ${template.antiPatterns.length}`));
+      console.log(chalk5.gray(`    Best practices: ${template.bestPractices.length}`));
+    }
+  }
+  console.log(chalk5.dim("\n\u2500".repeat(50)));
+  console.log(chalk5.gray("\nUse --agent <domain> to see template details.\n"));
+}
+function displayAgentTemplate(domain, verbose) {
+  const template = AGENT_TEMPLATES[domain];
+  if (!template) {
+    console.error(chalk5.red.bold(`
+\u274C Unknown agent domain: ${domain}
+`));
+    console.log(chalk5.gray("Available domains:"));
+    Object.keys(AGENT_TEMPLATES).forEach((d) => {
+      console.log(chalk5.cyan(`  \u2022 ${d}`));
+    });
+    console.log();
+    process.exit(1);
+  }
+  console.log(chalk5.blue.bold(`
+\u{1F4CB} ${template.displayName} Agent Template
+`));
+  console.log(chalk5.dim("\u2550".repeat(60)));
+  console.log(chalk5.cyan("\n\u{1F514} Domain Reminders:"));
+  template.domainReminders.forEach((reminder, i) => {
+    console.log(`  ${i + 1}. ${reminder}`);
+  });
+  console.log(chalk5.cyan("\n\u2705 Quality Checklist:"));
+  template.qualityChecklist.forEach((item, i) => {
+    console.log(`  ${i + 1}. ${item}`);
+  });
+  if (template.delegationTriggers.length > 0) {
+    console.log(chalk5.cyan("\n\u{1F500} Delegation Triggers:"));
+    template.delegationTriggers.forEach((trigger, i) => {
+      console.log(`  ${i + 1}. \u2192 ${chalk5.yellow(trigger.suggestedAgent)}`);
+      console.log(chalk5.gray(`     Keywords: ${trigger.keywords.join(", ")}`));
+      if (verbose) {
+        console.log(chalk5.gray(`     Reason: ${trigger.reason}`));
+      }
+    });
+  }
+  if (verbose && template.antiPatterns.length > 0) {
+    console.log(chalk5.red("\n\u26A0\uFE0F  Anti-Patterns to Avoid:"));
+    template.antiPatterns.forEach((pattern, i) => {
+      console.log(`  ${i + 1}. ${pattern}`);
+    });
+  }
+  if (verbose && template.bestPractices.length > 0) {
+    console.log(chalk5.green("\n\u2728 Best Practices:"));
+    template.bestPractices.forEach((practice, i) => {
+      console.log(`  ${i + 1}. ${practice}`);
+    });
+  }
+  console.log(chalk5.dim("\n\u2550".repeat(60)));
+  console.log();
+}
+
 // src/cli/index.ts
 installExitHandlers();
 var VERSION2 = getVersion();
@@ -48541,7 +51427,7 @@ globalTracker.mark("cli_start");
       type: "string",
       description: "Path to custom config file",
       global: true
-    }).command(setupCommand).command(initCommand).command(configureCommand).command(cliCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
+    }).command(setupCommand).command(initCommand).command(configureCommand).command(cliCommand).command(agentCommand).command(listCommand).command(runCommand).command(resumeCommand).command(runsCommand).command(sessionCommand).command(workspaceCommand).command(cacheCommand).command(configCommand).command(statusCommand4).command(doctorCommand2).command(cleanupCommand2).command(analyticsCommand).command(memoryCommand).command(mcpCommand).command(geminiCommand).command(providerLimitsCommand).command(providersCommand).command(flagsCommand).command(specCommand).command(genCommand).command(updateCommand).command(uninstallCommand).command(modeCommand).command(debugInstructionsCommand).demandCommand(1, "You must provide a command. Run --help for usage.").help().version(VERSION2).alias("h", "help").alias("v", "version").strict().wrap(Math.min(120, yargs().terminalWidth())).parse();
     globalTracker.mark("yargs_parse_end");
     globalTracker.measure("yargs_parsing", "yargs_parse_start", "yargs_parse_end");
     globalTracker.mark("options_setup_start");