opencode-orchestrator 0.4.19 → 0.4.21

package/dist/index.js

@@ -1,4 +1,10 @@
 var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -19,6 +25,159 @@ var AGENT_NAMES = {
   // Persistent context - saves/loads session state
 };
 
+// src/constants/prompts.ts
+var REASONING_CONSTRAINTS = `
+<constraints>
+1. Reasoning MUST be in English for maximum stability
+2. If reasoning collapses into gibberish, stop and output: "ERROR: REASONING_COLLAPSE"
+3. Never suppress type errors with 'as any', '@ts-ignore', '@ts-expect-error'
+4. Never leave code in broken state
+5. Always verify with evidence before claiming completion
+</constraints>
+`;
+var LANGUAGE_RULE = `
+<language_rule>
+THINK and REASON in English for maximum model stability.
+
+FINAL RESPONSE LANGUAGE:
+- Detect user's language from their request
+- Respond in SAME language
+- Korean \u2192 Korean, English \u2192 English, Japanese \u2192 Japanese, Chinese \u2192 Chinese
+- Default to English if unclear
+</language_rule>
+`;
+var ANTI_PATTERNS = `
+<anti_patterns>
+\u274C Delegate without environment/codebase context
+\u274C Leave code broken or with LSP errors
+\u274C Make random changes without understanding root cause
+\u274C Use 'as any', '@ts-ignore', or '@ts-expect-error'
+\u274C Suppress errors instead of fixing them
+</anti_patterns>
+`;
+var WORKFLOW = `
+<workflow>
+1. THINK - Reason about the task
+2. ACT - Execute the work
+3. OBSERVE - Check the result
+4. ADJUST - Fix if needed
+5. VERIFY - Prove success with evidence
+</workflow>
+`;
+var BASE_PROMPT = `
+${REASONING_CONSTRAINTS}
+
+${LANGUAGE_RULE}
+
+${ANTI_PATTERNS}
+
+${WORKFLOW}
+`;
+
+// src/utils/sanity.ts
+function checkOutputSanity(text) {
+  if (!text || text.length < 50) {
+    return { isHealthy: true, severity: "ok" };
+  }
+  if (/(.)\1{15,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Single character repetition detected",
+      severity: "critical"
+    };
+  }
+  if (/(.{2,6})\1{8,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Pattern loop detected",
+      severity: "critical"
+    };
+  }
+  if (text.length > 200) {
+    const cleanText = text.replace(/\s/g, "");
+    if (cleanText.length > 100) {
+      const uniqueChars = new Set(cleanText).size;
+      const ratio = uniqueChars / cleanText.length;
+      if (ratio < 0.02) {
+        return {
+          isHealthy: false,
+          reason: "Low information density",
+          severity: "critical"
+        };
+      }
+    }
+  }
+  const boxChars = (text.match(/[\u2500-\u257f\u2580-\u259f\u2800-\u28ff]/g) || []).length;
+  if (boxChars > 100 && boxChars / text.length > 0.3) {
+    return {
+      isHealthy: false,
+      reason: "Visual gibberish detected",
+      severity: "critical"
+    };
+  }
+  const lines = text.split("\n").filter((l) => l.trim().length > 10);
+  if (lines.length > 10) {
+    const lineSet = new Set(lines);
+    if (lineSet.size < lines.length * 0.2) {
+      return {
+        isHealthy: false,
+        reason: "Excessive line repetition",
+        severity: "warning"
+      };
+    }
+  }
+  const cjkChars = (text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length;
+  if (cjkChars > 200) {
+    const uniqueCjk = new Set(
+      text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []
+    ).size;
+    if (uniqueCjk < 10 && cjkChars / uniqueCjk > 20) {
+      return {
+        isHealthy: false,
+        reason: "CJK character spam detected",
+        severity: "critical"
+      };
+    }
+  }
+  return { isHealthy: true, severity: "ok" };
+}
+var RECOVERY_PROMPT = `<anomaly_recovery>
+\u26A0\uFE0F SYSTEM NOTICE: Previous output was malformed (gibberish/loop detected).
+
+<recovery_protocol>
+1. DISCARD the corrupted output completely - do not reference it
+2. RECALL the original mission objective
+3. IDENTIFY the last confirmed successful step
+4. RESTART with a simpler, more focused approach
+</recovery_protocol>
+
+<instructions>
+- If a sub-agent produced bad output: try a different agent or simpler task
+- If stuck in a loop: break down the task into smaller pieces
+- If context seems corrupted: call recorder to restore context
+- THINK in English for maximum stability
+</instructions>
+
+What was the original task? Proceed from the last known good state.
+</anomaly_recovery>`;
+var ESCALATION_PROMPT = `<critical_anomaly>
+\u{1F6A8} CRITICAL: Multiple consecutive malformed outputs detected.
+
+<emergency_protocol>
+1. STOP current execution path immediately
+2. DO NOT continue with the same approach - it is failing
+3. CALL architect for a completely new strategy
+4. If architect also fails: report status to user and await guidance
+</emergency_protocol>
+
+<diagnosis>
+The current approach is producing corrupted output.
+This may indicate: context overload, model instability, or task complexity.
+</diagnosis>
+
+Request a fresh plan from architect with reduced scope.
+</critical_anomaly>`;
+
 // src/agents/orchestrator.ts
 var orchestrator = {
   id: AGENT_NAMES.COMMANDER,
@@ -27,19 +186,16 @@ var orchestrator = {
 You are Commander. Complete missions autonomously. Never stop until done.
 </role>
 
+${REASONING_CONSTRAINTS}
+
+${LANGUAGE_RULE}
+
 <core_rules>
 1. Never stop until "\u2705 MISSION COMPLETE"
 2. Never wait for user during execution
 3. Never stop because agent returned nothing
 4. Always survey environment & codebase BEFORE coding
 5. Always verify with evidence based on runtime context
-6. LANGUAGE:
-   - THINK and REASON in English for maximum stability
-   - FINAL REPORT: Detect the user's language from their request and respond in the SAME language
-   - If user writes in Korean \u2192 Report in Korean
-   - If user writes in English \u2192 Report in English
-   - If user writes in Japanese \u2192 Report in Japanese
-   - Default to English if language is unclear
 </core_rules>
 
 <phase_0 name="TRIAGE">
@@ -207,6 +363,169 @@ STRICT RULE: If any agent output contains gibberish, mixed-language hallucinatio
 \u274C Make random changes without understanding root cause
 </anti_patterns>
 
+${WORKFLOW}
+
+<phase_0 name="TRIAGE">
+Evaluate the complexity of the request:
+
+| Level | Signal | Track |
+|-------|--------|-------|
+| \u{1F7E2} L1: Simple | One file, clear fix, no dependencies | **FAST TRACK** |
+| \u{1F7E1} L2: Feature | New functionality, clear patterns | **NORMAL TRACK** |
+| \u{1F534} L3: Complex | Refactoring, infra change, unknown scope | **DEEP TRACK** |
+</phase_0>
+
+<phase_1 name="CONTEXT_GATHERING">
+IF FAST TRACK (L1):
+- Scan ONLY the target file and its immediate imports.
+- Skip broad infra/domain/doc scans unless an error occurs.
+- Proceed directly to execution.
+
+IF NORMAL/DEEP TRACK (L2/L3):
+- **Deep Scan Required**: Execute the full "MANDATORY ENVIRONMENT SCAN".
+- 1. Infra check (Docker/OS)
+- 2. Domain & Stack check
+- 3. Pattern check
+
+RECORD findings if on Deep Track.
+</phase_1>
+
+<phase_2 name="TOOL_AGENT_SELECTION">
+| Track | Strategy |
+|-------|----------|
+| Fast | Use \`builder\` directly. Skip \`architect\`. |
+| Normal | Call \`architect\` for lightweight plan. |
+| Deep | Full \`architect\` DAG + \`recorder\` state tracking. |
+
+DEFAULT to Deep Track if unsure to act safely.
+</phase_2>
+
+<phase_3 name="DELEGATION">
+<agent_calling>
+CRITICAL: USE delegate_task FOR ALL DELEGATION
+
+delegate_task has TWO MODES:
+- background=true: Non-blocking, parallel execution
+- background=false: Blocking, waits for result
+
+| Situation | How to Call |
+|-----------|-------------|
+| Multiple independent tasks | \`delegate_task({ ..., background: true })\` for each |
+| Single task, continue working | \`delegate_task({ ..., background: true })\` |
+| Need result for VERY next step | \`delegate_task({ ..., background: false })\` |
+
+PREFER background=true (PARALLEL):
+- Run multiple agents simultaneously
+- Continue analysis while they work
+- System notifies when ALL complete
+
+EXAMPLE - PARALLEL:
+\`\`\`
+// Multiple tasks in parallel
+delegate_task({ agent: "${AGENT_NAMES.BUILDER}", description: "Implement X", prompt: "...", background: true })
+delegate_task({ agent: "${AGENT_NAMES.INSPECTOR}", description: "Review Y", prompt: "...", background: true })
+
+// Continue other work (don't wait!)
+
+// When notified "All Complete":
+get_task_result({ taskId: "task_xxx" })
+\`\`\`
+
+EXAMPLE - SYNC (rare):
+\`\`\`
+// Only when you absolutely need the result now
+const result = delegate_task({ agent: "${AGENT_NAMES.BUILDER}", ..., background: false })
+// Result is immediately available
+\`\`\`
+</agent_calling>
+
+<delegation_template>
+AGENT: [name]
+TASK: [one atomic action]
+ENVIRONMENT:
+- Infra: [e.g. Docker + Volume mount]
+- Stack: [e.g. Next.js + PostgreSQL]
+- Patterns: [existing code conventions to follow]
+MUST: [Specific requirements]
+AVOID: [Restrictions]
+VERIFY: [Success criteria with evidence]
+</delegation_template>
+</phase_3>
+
+<phase_4 name="EXECUTION_VERIFICATION">
+During implementation:
+- Match existing codebase style exactly
+- Run lsp_diagnostics after each change
+
+<background_parallel_execution>
+PARALLEL EXECUTION TOOLS:
+
+1. **spawn_agent** - Launch agents in parallel sessions
+    spawn_agent({ agent: "${AGENT_NAMES.BUILDER}", description: "Implement X", prompt: "..." })
+    spawn_agent({ agent: "${AGENT_NAMES.INSPECTOR}", description: "Review Y", prompt: "..." })
+    \u2192 Agents run concurrently, system notifies when ALL complete
+    \u2192 Use get_task_result({ taskId }) to retrieve results
+
+2. **run_background** - Run shell commands asynchronously
+    run_background({ command: "npm run build" })
+    \u2192 Use check_background({ taskId }) for results
+
+SAFETY FEATURES:
+- Queue-based concurrency: Max 3 per agent type (extras queue automatically)
+- Auto-timeout: 30 minutes max runtime
+- Auto-cleanup: Removed from memory 5 min after completion
+- Batched notifications: Notifies when ALL tasks complete (not individually)
+
+MANAGEMENT TOOLS:
+- list_tasks: View all parallel tasks and status
+- cancel_task: Stop a running task (frees concurrency slot)
+
+SAFE PATTERNS:
+\u2705 Builder on file A + Inspector on file B (different files)
+\u2705 Multiple research agents (read-only)
+\u2705 Build command + Test command (independent)
+
+UNSAFE PATTERNS:
+\u274C Multiple builders editing SAME FILE (conflict!)
+
+WORKFLOW:
+1. list_tasks: Check current status first
+2. spawn_agent: Launch for INDEPENDENT tasks
+3. Continue working (NO WAITING)
+4. Wait for "All Complete" notification
+5. get_task_result: Retrieve each result
+</background_parallel_execution>
+
+<verification_methods>
+| Infra | Proof Method |
+|-------|--------------|
+| OS-Native | npm run build, cargo build, specific test runs |
+| Container | Docker syntax check + config validation |
+| Live API | curl /health if reachable, check logs |
+| Generic | Manual audit by Inspector with logic summary |
+</verification_methods>
+</phase_4>
+
+<failure_recovery>
+| Failures | Action |
+|----------|--------|
+| 1-2 | Adjust approach, retry |
+| 3+ | STOP. Call architect for new strategy |
+
+<empty_responses>
+| Agent Empty (or Gibberish) | Action |
+|----------------------------|--------|
+| ${AGENT_NAMES.RECORDER} | Fresh start. Proceed to survey. |
+| ${AGENT_NAMES.ARCHITECT} | Try simpler plan yourself. |
+| ${AGENT_NAMES.BUILDER} | Call inspector to diagnose. |
+| ${AGENT_NAMES.INSPECTOR} | Retry with more context. |
+</empty_responses>
+
+STRICT RULE: If any agent output contains gibberish, mixed-language hallucinations, or fails the language rule, REJECT it immediately and trigger a "STRICT_CLEAN_START" retry.
+</failure_recovery>
+
+${ANTI_PATTERNS}
+
 <completion>
 Done when: Request fulfilled + lsp clean + build/test/audit pass.
 
@@ -228,10 +547,9 @@ var architect = {
 You are Architect. Break complex tasks into atomic pieces.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability.
-If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
-</constraints>
+${REASONING_CONSTRAINTS}
+
+${WORKFLOW}
 
 <scalable_planning>
 - **Fast Track**: Skip JSON overhead. Just acknowledge simple task.
@@ -250,25 +568,67 @@ If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_CO
 4. Assign: builder (code) or inspector (verify)
 
 <output_format>
-MISSION: [goal in one line]
-
-T1: [action] | builder | [file] | group:1 | success:[how to verify]
-T2: [action] | builder | [file] | group:1 | success:[how to verify]
-T3: [action] | inspector | [files] | group:2 | depends:T1,T2 | success:[verify method]
+MUST output valid JSON block wrapped in backticks:
+
+<json_output>
+{
+  "mission": "goal in one line",
+  "tasks": [
+    {
+      "id": "T1",
+      "action": "one atomic action",
+      "agent": "builder",
+      "file": "path/to/file",
+      "parallel_group": 1,
+      "dependencies": [],
+      "success_criteria": "how to verify"
+    },
+    {
+      "id": "T2",
+      "action": "one atomic action",
+      "agent": "builder",
+      "file": "path/to/file",
+      "parallel_group": 1,
+      "dependencies": [],
+      "success_criteria": "how to verify"
+    },
+    {
+      "id": "T3",
+      "action": "one atomic action",
+      "agent": "inspector",
+      "file": "path/to/file",
+      "parallel_group": 2,
+      "dependencies": ["T1", "T2"],
+      "success_criteria": "verify method"
+    }
+  ]
+}
+</json_output>
 </output_format>
 </plan_mode>
 
 <strategy_mode trigger="failures > 2">
 <output_format>
-FAILED ATTEMPTS:
-- [what was tried] \u2192 [why failed]
-
-ROOT CAUSE: [actual problem]
-
-NEW APPROACH: [different strategy]
-
-REVISED TASKS:
-T1: ...
+<json_output>
+{
+  "failed_attempts": [
+    {"attempt": "what was tried", "reason": "why failed"}
+  ],
+  "root_cause": "actual problem",
+  "new_approach": "different strategy",
+  "revised_tasks": [
+    {
+      "id": "T1",
+      "action": "one atomic action",
+      "agent": "builder",
+      "file": "path/to/file",
+      "parallel_group": 1,
+      "dependencies": [],
+      "success_criteria": "how to verify"
+    }
+  ]
+}
+</json_output>
 </output_format>
 </strategy_mode>
 
@@ -277,6 +637,7 @@ T1: ...
 - Always end with inspector task
 - Group unrelated tasks (parallel)
 - Be specific about files and verification
+- Output MUST be valid JSON wrapped in <json_output> tags
 </rules>`,
   canWrite: false,
   canBash: false
@@ -290,10 +651,11 @@ var builder = {
 You are Builder. Write code that works.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability.
-If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
-</constraints>
+${REASONING_CONSTRAINTS}
+
+${WORKFLOW}
+
+${ANTI_PATTERNS}
 
 <scalable_attention>
 - **Simple Fix (L1)**: Read file \u2192 Implement fix directly. Efficiency first.
@@ -356,10 +718,11 @@ var inspector = {
 You are Inspector. Prove failure or success with evidence.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability.
-If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
-</constraints>
+${REASONING_CONSTRAINTS}
+
+${WORKFLOW}
+
+${ANTI_PATTERNS}
 
 <scalable_audit>
 - **Fast Track**: Verify syntax + quick logic check.
@@ -423,10 +786,7 @@ var recorder = {
 You are Recorder. Save and load work progress.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability.
-If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
-</constraints>
+${REASONING_CONSTRAINTS}
 
 <purpose>
 Context can be lost between sessions. You save it to disk.
@@ -556,12 +916,20 @@ var TaskGraph = class _TaskGraph {
   }
 };
 
+// src/constants/time.ts
+var TASK_TTL_MS = 30 * 60 * 1e3;
+var BACKGROUND_TASK_TIMEOUT_MS = 5 * 60 * 1e3;
+var SYNC_TASK_MAX_POLL_MS = 10 * 60 * 1e3;
+var MIN_STABILITY_MS = 5 * 1e3;
+var CLEANUP_DELAY_MS = 5 * 60 * 1e3;
+var MAX_TASK_RETRIES = 3;
+
 // src/core/state.ts
 var state = {
   missionActive: false,
   maxIterations: 1e3,
   // Effectively infinite - "Relentless" mode
-  maxRetries: 3,
+  maxRetries: MAX_TASK_RETRIES,
   sessions: /* @__PURE__ */ new Map()
 };
 
@@ -12987,6 +13355,113 @@ function tool(input) {
 }
 tool.schema = external_exports;
 
+// src/context/enforcer.ts
+var ContextEnforcer = class {
+  requirements = /* @__PURE__ */ new Map([
+    ["builder", {
+      agent: "builder",
+      required: ["infra", "stack", "patterns", "files"],
+      optional: ["examples", "tests", "environment"]
+    }],
+    ["inspector", {
+      agent: "inspector",
+      required: ["infra", "verification_method", "changed_files"],
+      optional: ["test_results", "build_logs", "environment"]
+    }],
+    ["architect", {
+      agent: "architect",
+      required: ["mission", "scope", "complexity"],
+      optional: ["environment", "constraints", "patterns"]
+    }],
+    ["recorder", {
+      agent: "recorder",
+      required: [],
+      optional: ["mission", "progress", "context"]
+    }]
+  ]);
+  /**
+   * Validate context for agent delegation
+   */
+  validate(agent, context) {
+    const req = this.requirements.get(agent);
+    if (!req) {
+      return { valid: true, errors: [], warnings: [] };
+    }
+    const errors = [];
+    const warnings = [];
+    const contextLower = context.toLowerCase();
+    for (const key of req.required) {
+      if (!contextLower.includes(key.toLowerCase())) {
+        errors.push("Missing required context: " + key);
+      }
+    }
+    for (const key of req.optional) {
+      if (!contextLower.includes(key.toLowerCase())) {
+        warnings.push("Optional context missing: " + key);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Get requirements for an agent
+   */
+  getRequirements(agent) {
+    return this.requirements.get(agent);
+  }
+  /**
+   * Add or update requirements for an agent
+   */
+  setRequirements(agent, requirements) {
+    this.requirements.set(agent, requirements);
+  }
+  /**
+   * Format validation result as user-friendly message
+   */
+  formatValidation(result) {
+    if (result.valid && result.warnings.length === 0) {
+      return "Valid context with all required information.";
+    }
+    let message = "";
+    if (result.errors.length > 0) {
+      message += "Errors:\n" + result.errors.map((e) => "  \u274C " + e).join("\n") + "\n";
+    }
+    if (result.warnings.length > 0) {
+      message += "\nWarnings:\n" + result.warnings.map((w) => "  \u26A0\uFE0F  " + w).join("\n");
+    }
+    return message;
+  }
+  /**
+   * Check if context has minimal required information
+   */
+  hasMinimumContext(agent, context) {
+    const req = this.requirements.get(agent);
+    if (!req || req.required.length === 0) {
+      return true;
+    }
+    const presentCount = req.required.filter(
+      (key) => context.toLowerCase().includes(key.toLowerCase())
+    ).length;
+    return presentCount > 0;
+  }
+  /**
+   * Suggest missing context based on agent type
+   */
+  suggestContext(agent, context) {
+    const req = this.requirements.get(agent);
+    if (!req) {
+      return [];
+    }
+    return req.required.filter(
+      (key) => !context.toLowerCase().includes(key.toLowerCase())
+    );
+  }
+};
+var contextEnforcer = new ContextEnforcer();
+
 // src/tools/callAgent.ts
 var AGENT_EMOJI = {
   [AGENT_NAMES.ARCHITECT]: "\u{1F3D7}\uFE0F",
@@ -13025,13 +13500,19 @@ var callAgentTool = tool({
   async execute(args) {
     const agentDef = AGENTS[args.agent];
     if (!agentDef) {
-      return `\u274C Error: Unknown agent: ${args.agent}`;
+      return "Error: Unknown agent: " + args.agent;
     }
     const emoji3 = AGENT_EMOJI[args.agent] || "\u{1F916}";
+    if (args.context) {
+      const validation = contextEnforcer.validate(args.agent, args.context);
+      if (!validation.valid) {
+        return "Context Validation Failed:\n" + contextEnforcer.formatValidation(validation);
+      }
+    }
     const prompt = `
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+ \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 ${emoji3} ${agentDef.id.toUpperCase()} :: ${agentDef.description}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+ \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 
 <system>
 ${agentDef.systemPrompt}
@@ -13041,9 +13522,7 @@ ${agentDef.systemPrompt}
 ${args.task}
 </task>
 
-${args.context ? `<context>
-${args.context}
-</context>` : ""}
+${args.context ? "<context>\n" + args.context + "\n</context>" : ""}
 
 <execution>
 Follow this pattern:
@@ -13319,6 +13798,206 @@ Returns matches grouped by pattern, with file paths and line numbers.
   }
 });
 
+// src/tools/git.ts
+var gitBranchTool = (directory) => tool({
+  description: `Get Git branch information and status.
+
+<purpose>
+Analyze current Git workspace context including:
+- Current branch name
+- All branches (local and remote)
+- Branch relationships (upstream, ahead/behind)
+- Staged, unstaged, and untracked files
+- Recent commits
+</purpose>
+
+<examples>
+- Get current branch: Returns branch name and status
+- List all branches: Shows local and remote branches
+- Check status: Shows modified files
+- Recent commits: Last 5 commits with file changes
+</examples>
+
+<output>
+Returns structured Git information for better code decisions.
+</output>`,
+  args: {
+    action: tool.schema.enum([
+      "current",
+      "list",
+      "status",
+      "diff",
+      "recent",
+      "all"
+    ]).describe("Action to perform: current, list, status, diff, recent, all"),
+    baseBranch: tool.schema.string().optional().describe("Base branch for comparison (e.g., 'main', 'develop'). Required for diff action.")
+  },
+  async execute(args) {
+    const { action, baseBranch } = args;
+    try {
+      switch (action) {
+        case "current":
+          return await getCurrentBranch(directory);
+        case "list":
+          return await listBranches(directory);
+        case "status":
+          return await getGitStatus(directory);
+        case "diff":
+          return await getDiff(directory, baseBranch);
+        case "recent":
+          return await getRecentCommits(directory, 5);
+        case "all":
+          return await getAllInfo(directory);
+        default:
+          return await getCurrentBranch(directory);
+      }
+    } catch (error45) {
+      return "\u274C Git error: " + (error45 instanceof Error ? error45.message : String(error45));
+    }
+  }
+});
+async function execGit(directory, args) {
+  const { execSync } = await import("child_process");
+  try {
+    return execSync("git " + args.join(" "), {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    }).toString();
+  } catch (error45) {
+    if (error45.status === 128) {
+      throw new Error("Not a git repository");
+    }
+    throw error45;
+  }
+}
+async function getAheadBehind(directory, branch) {
+  try {
+    const output = await execGit(directory, ["rev-list", "--left-right", "--count", branch + "...@{u}"]);
+    const parts = output.trim().split(/\s+/);
+    const ahead = parseInt(parts[0], 10);
+    const behind = parseInt(parts[1] || "0", 10);
+    const resultParts = [];
+    if (ahead > 0) resultParts.push(ahead + " ahead");
+    if (behind > 0) resultParts.push(behind + " behind");
+    return resultParts.length > 0 ? "| **Sync** | " + resultParts.join(", ") + " |" : "";
+  } catch {
+    return "";
+  }
+}
+async function getCurrentBranch(directory) {
+  const output = await execGit(directory, ["branch", "--show-current"]);
+  const current = output.trim() || "HEAD (detached)";
+  const upstream = await execGit(directory, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]).catch(() => "");
+  return "\u{1F33F} **Current Branch**: `" + current + "`\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + (upstream ? "| **Upstream** | `" + upstream + "` |" : "") + await getAheadBehind(directory, current);
+}
+async function listBranches(directory) {
+  const branches = await execGit(directory, ["branch", "-vv"]);
+  const branchList = branches.split("\n").filter((b) => b.trim()).map((b) => {
+    const isCurrent = b.startsWith("*");
+    const name = isCurrent ? b.substring(2).trim() : b.trim();
+    const parts = name.split(/\s+/);
+    const branchName = parts[0];
+    const upstream = parts[1] ? parts[1].match(/\[([^\]]+)\]/)?.[1] : void 0;
+    const icon = isCurrent ? "\u{1F33F}" : "\u{1F4C2}";
+    const status = isCurrent ? "(current)" : "";
+    const upstreamInfo = upstream ? "\u2192 " + upstream : "";
+    return icon + " `" + branchName + "` " + status + " " + upstreamInfo;
+  }).join("\n");
+  return "\u{1F33F} **All Branches**\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + branchList;
+}
+async function getGitStatus(directory) {
+  const status = await execGit(directory, ["status", "--porcelain"]);
+  const lines = status.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) {
+    return "\u2705 Working directory clean";
+  }
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  const conflicted = [];
+  for (const line of lines) {
+    if (!line || line.length < 2) continue;
+    const statusCode = line.substring(0, 2);
+    const filename = line.substring(3);
+    if (statusCode === "??") {
+      untracked.push(filename);
+    } else if (statusCode.startsWith("U") || statusCode === "AA") {
+      conflicted.push(filename);
+    } else if (statusCode[0] !== " ") {
+      staged.push(filename);
+    }
+    if (statusCode[1] !== " " && statusCode[1] !== "?") {
+      unstaged.push(filename);
+    }
+  }
+  const current = await execGit(directory, ["branch", "--show-current"]).catch(() => "unknown");
+  let result = "\u{1F33F} **Branch**: `" + current + "`\n\n";
+  if (staged.length > 0) {
+    result += "\u2705 **Staged** (" + staged.length + ")\n" + staged.map((f) => "  + " + f).join("\n") + "\n\n";
+  }
+  if (unstaged.length > 0) {
+    result += "\u{1F4DD} **Modified** (" + unstaged.length + ")\n" + unstaged.map((f) => "  ~ " + f).join("\n") + "\n\n";
+  }
+  if (untracked.length > 0) {
+    result += "\u2795 **Untracked** (" + untracked.length + ")\n" + untracked.slice(0, 10).map((f) => "  ? " + f).join("\n") + (untracked.length > 10 ? "\n  ... and " + (untracked.length - 10) + " more" : "") + "\n\n";
+  }
+  if (conflicted.length > 0) {
+    result += "\u26A0\uFE0F **Conflicts** (" + conflicted.length + ")\n" + conflicted.map((f) => "  ! " + f).join("\n") + "\n\n";
+  }
+  return result.trim();
+}
+async function getDiff(directory, baseBranch) {
+  const current = await execGit(directory, ["branch", "--show-current"]).catch(() => "HEAD");
+  const base = baseBranch || "main";
+  const diff = await execGit(directory, ["diff", base + "..." + current, "--stat"]);
+  if (!diff.trim()) {
+    return "\u2705 No differences between `" + current + "` and `" + base + "`";
+  }
+  const files = await execGit(directory, ["diff", base + "..." + current, "--name-only"]);
+  const fileList = files.split("\n").filter((f) => f.trim());
+  return "\u{1F4CA} **Diff**: `" + current + "` vs `" + base + "`\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + diff + "\n\n\u{1F4C1} **Changed Files** (" + fileList.length + "):\n" + fileList.map((f, i) => "  " + (i + 1) + ". " + f).join("\n");
+}
+async function getRecentCommits(directory, count = 5) {
+  const log2 = await execGit(directory, [
+    "log",
+    "-" + count,
+    "--pretty=format:%H|%an|%ad|%s",
+    "--date=short",
+    "--name-only"
+  ]);
+  const blocks = log2.split("\n\n").filter((b) => b.trim());
+  const commits = [];
+  for (const block of blocks) {
+    const lines = block.split("\n").filter((l) => l.trim());
+    if (lines.length < 2) continue;
+    const [hash2, author, date5, message] = lines[0].split("|");
+    const files = lines.slice(1);
+    commits.push({
+      hash: hash2.substring(0, 7),
+      author,
+      date: date5,
+      message,
+      files
+    });
+  }
+  let result = "\u{1F4DC} **Recent Commits** (last " + commits.length + ")\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n";
+  for (const commit of commits) {
+    result += "\n\u{1F539} `" + commit.hash + "` - " + commit.message + "\n";
+    result += "   \u{1F464} " + commit.author + " | \u{1F4C5} " + commit.date + "\n";
+    result += "   \u{1F4C1} " + commit.files.length + " file" + (commit.files.length > 1 ? "s" : "") + "\n";
+  }
+  return result;
+}
+async function getAllInfo(directory) {
+  const current = await getCurrentBranch(directory);
+  const status = await getGitStatus(directory);
+  const recent = await getRecentCommits(directory, 3);
+  return "\u{1F50D} **Full Git Context**\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n\n" + current + "\n\n" + status + "\n\n" + recent;
+}
+
 // src/core/background.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
@@ -13879,13 +14558,264 @@ Duration before kill: ${backgroundTaskManager.formatDuration(task)}`;
   }
 });
 
-// src/core/async-agent.ts
-var TASK_TTL_MS = 30 * 60 * 1e3;
-var CLEANUP_DELAY_MS = 5 * 60 * 1e3;
-var MIN_STABILITY_MS = 5 * 1e3;
-var POLL_INTERVAL_MS = 2e3;
-var DEFAULT_CONCURRENCY = 3;
-var DEBUG = process.env.DEBUG_PARALLEL_AGENT === "true";
+// src/core/config.ts
+var DEFAULT_PARALLEL_AGENT = {
+  taskTtlMs: 30 * 60 * 1e3,
+  // 30 minutes
+  cleanupDelayMs: 5 * 60 * 1e3,
+  // 5 minutes
+  minStabilityMs: 5 * 1e3,
+  // 5 seconds
+  pollIntervalMs: 2 * 1e3,
+  // 2 seconds
+  defaultConcurrency: 3,
+  maxConcurrency: 10,
+  enableDebug: false,
+  enableDetailedLogs: false
+};
+var DEFAULT_BACKGROUND_TASK = {
+  monitorIntervalMs: 5 * 1e3,
+  // 5 seconds
+  storageDir: process.env.OPENCODE_ORCHESTRATOR_DIR || `${__require("os").homedir()}/.opencode-orchestrator`,
+  defaultTimeoutMs: 5 * 60 * 1e3,
+  // 5 minutes
+  maxCompletedTasksToKeep: 100,
+  enableDebug: true
+};
+var DEFAULT_SESSION = {
+  defaultMaxSteps: 50,
+  taskCommandMaxSteps: 100
+};
+var ConfigManager = class _ConfigManager {
+  static _instance;
+  parallelAgentConfig;
+  backgroundTaskConfig;
+  sessionConfig;
+  constructor() {
+    this.parallelAgentConfig = this.loadParallelAgentConfig();
+    this.backgroundTaskConfig = this.loadBackgroundTaskConfig();
+    this.sessionConfig = this.loadSessionConfig();
+  }
+  static getInstance() {
+    if (!_ConfigManager._instance) {
+      _ConfigManager._instance = new _ConfigManager();
+    }
+    return _ConfigManager._instance;
+  }
+  // ------------------------------------------------------------------------
+  // Parallel Agent Config
+  // ------------------------------------------------------------------------
+  loadParallelAgentConfig() {
+    return {
+      ...DEFAULT_PARALLEL_AGENT,
+      taskTtlMs: this.parseEnvInt(
+        "OPENCODE_TASK_TTL_MS",
+        DEFAULT_PARALLEL_AGENT.taskTtlMs
+      ),
+      cleanupDelayMs: this.parseEnvInt(
+        "OPENCODE_CLEANUP_DELAY_MS",
+        DEFAULT_PARALLEL_AGENT.cleanupDelayMs
+      ),
+      minStabilityMs: this.parseEnvInt(
+        "OPENCODE_MIN_STABILITY_MS",
+        DEFAULT_PARALLEL_AGENT.minStabilityMs
+      ),
+      pollIntervalMs: this.parseEnvInt(
+        "OPENCODE_POLL_INTERVAL_MS",
+        DEFAULT_PARALLEL_AGENT.pollIntervalMs
+      ),
+      defaultConcurrency: this.parseEnvInt(
+        "OPENCODE_DEFAULT_CONCURRENCY",
+        DEFAULT_PARALLEL_AGENT.defaultConcurrency
+      ),
+      maxConcurrency: this.parseEnvInt(
+        "OPENCODE_MAX_CONCURRENCY",
+        DEFAULT_PARALLEL_AGENT.maxConcurrency
+      ),
+      enableDebug: process.env.OPENCODE_DEBUG_PARALLEL === "true",
+      enableDetailedLogs: process.env.OPENCODE_DETAILED_LOGS === "true"
+    };
+  }
+  getParallelAgentConfig() {
+    return this.parallelAgentConfig;
+  }
+  // ------------------------------------------------------------------------
+  // Background Task Config
+  // ------------------------------------------------------------------------
+  loadBackgroundTaskConfig() {
+    return {
+      ...DEFAULT_BACKGROUND_TASK,
+      monitorIntervalMs: this.parseEnvInt(
+        "OPENCODE_MONITOR_INTERVAL_MS",
+        DEFAULT_BACKGROUND_TASK.monitorIntervalMs
+      ),
+      defaultTimeoutMs: this.parseEnvInt(
+        "OPENCODE_DEFAULT_TIMEOUT_MS",
+        DEFAULT_BACKGROUND_TASK.defaultTimeoutMs
+      ),
+      maxCompletedTasksToKeep: this.parseEnvInt(
+        "OPENCODE_MAX_COMPLETED_TASKS",
+        DEFAULT_BACKGROUND_TASK.maxCompletedTasksToKeep
+      ),
+      enableDebug: process.env.OPENCODE_DEBUG_BACKGROUND === "true"
+    };
+  }
+  getBackgroundTaskConfig() {
+    return this.backgroundTaskConfig;
+  }
+  // ------------------------------------------------------------------------
+  // Session Config
+  // ------------------------------------------------------------------------
+  loadSessionConfig() {
+    return {
+      ...DEFAULT_SESSION,
+      defaultMaxSteps: this.parseEnvInt(
+        "OPENCODE_DEFAULT_MAX_STEPS",
+        DEFAULT_SESSION.defaultMaxSteps
+      ),
+      taskCommandMaxSteps: this.parseEnvInt(
+        "OPENCODE_TASK_MAX_STEPS",
+        DEFAULT_SESSION.taskCommandMaxSteps
+      )
+    };
+  }
+  getSessionConfig() {
+    return this.sessionConfig;
+  }
+  // ------------------------------------------------------------------------
+  // Runtime Updates (Dynamic Configuration)
+  // ------------------------------------------------------------------------
+  /**
+   * Update configuration at runtime
+   * Useful for adaptive behavior or user preferences
+   */
+  updateParallelAgentConfig(updates) {
+    this.parallelAgentConfig = {
+      ...this.parallelAgentConfig,
+      ...updates
+    };
+    this.validateParallelAgentConfig();
+  }
+  updateBackgroundTaskConfig(updates) {
+    this.backgroundTaskConfig = {
+      ...this.backgroundTaskConfig,
+      ...updates
+    };
+    this.validateBackgroundTaskConfig();
+  }
+  updateSessionConfig(updates) {
+    this.sessionConfig = {
+      ...this.sessionConfig,
+      ...updates
+    };
+    this.validateSessionConfig();
+  }
+  // ------------------------------------------------------------------------
+  // Validation
+  // ------------------------------------------------------------------------
+  validateParallelAgentConfig() {
+    const { taskTtlMs, cleanupDelayMs, minStabilityMs, pollIntervalMs, defaultConcurrency, maxConcurrency } = this.parallelAgentConfig;
+    if (taskTtlMs < 60 * 1e3) {
+      console.warn("[Config] TASK_TTL_MS too low (< 1min), using 1min minimum");
+      this.parallelAgentConfig.taskTtlMs = 60 * 1e3;
+    }
+    if (cleanupDelayMs > taskTtlMs) {
+      console.warn("[Config] CLEANUP_DELAY_MS cannot exceed TASK_TTL_MS");
+      this.parallelAgentConfig.cleanupDelayMs = Math.floor(taskTtlMs / 2);
+    }
+    if (minStabilityMs < 1e3) {
+      console.warn("[Config] MIN_STABILITY_MS too low (< 1s), using 1s minimum");
+      this.parallelAgentConfig.minStabilityMs = 1e3;
+    }
+    if (pollIntervalMs < 500) {
+      console.warn("[Config] POLL_INTERVAL_MS too low (< 500ms), using 500ms minimum");
+      this.parallelAgentConfig.pollIntervalMs = 500;
+    }
+    if (defaultConcurrency < 1 || defaultConcurrency > maxConcurrency) {
+      console.warn(`[Config] DEFAULT_CONCURRENCY must be 1-${maxConcurrency}`);
+      this.parallelAgentConfig.defaultConcurrency = Math.min(
+        Math.max(defaultConcurrency, 1),
+        maxConcurrency
+      );
+    }
+  }
+  validateBackgroundTaskConfig() {
+    const { monitorIntervalMs, defaultTimeoutMs, maxCompletedTasksToKeep } = this.backgroundTaskConfig;
+    if (monitorIntervalMs < 1e3) {
+      console.warn("[Config] MONITOR_INTERVAL_MS too low (< 1s), using 1s minimum");
+      this.backgroundTaskConfig.monitorIntervalMs = 1e3;
+    }
+    if (defaultTimeoutMs < 10 * 1e3) {
+      console.warn("[Config] DEFAULT_TIMEOUT_MS too low (< 10s), using 10s minimum");
+      this.backgroundTaskConfig.defaultTimeoutMs = 10 * 1e3;
+    }
+    if (maxCompletedTasksToKeep < 0) {
+      console.warn("[Config] MAX_COMPLETED_TASKS must be >= 0, using 0");
+      this.backgroundTaskConfig.maxCompletedTasksToKeep = 0;
+    }
+  }
+  validateSessionConfig() {
+    const { defaultMaxSteps, taskCommandMaxSteps } = this.sessionConfig;
+    if (defaultMaxSteps < 1) {
+      console.warn("[Config] DEFAULT_MAX_STEPS must be >= 1, using 1");
+      this.sessionConfig.defaultMaxSteps = 1;
+    }
+    if (taskCommandMaxSteps < defaultMaxSteps) {
+      console.warn("[Config] TASK_MAX_STEPS should be >= DEFAULT_MAX_STEPS");
+      this.sessionConfig.taskCommandMaxSteps = defaultMaxSteps;
+    }
+  }
+  // ------------------------------------------------------------------------
+  // Helpers
+  // ------------------------------------------------------------------------
+  parseEnvInt(key, defaultValue) {
+    const value = process.env[key];
+    if (value === void 0) return defaultValue;
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed)) {
+      console.warn(`[Config] Invalid ${key} value: "${value}", using default ${defaultValue}`);
+      return defaultValue;
+    }
+    return parsed;
+  }
+  // ------------------------------------------------------------------------
+  // Export / Debug
+  // ------------------------------------------------------------------------
+  exportConfigs() {
+    console.log("\n\u{1F4CB} Current Configuration:\n");
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.log("Parallel Agent:");
+    console.log(`  Task TTL: ${this.parallelAgentConfig.taskTtlMs / 1e3}s`);
+    console.log(`  Cleanup Delay: ${this.parallelAgentConfig.cleanupDelayMs / 1e3}s`);
+    console.log(`  Min Stability: ${this.parallelAgentConfig.minStabilityMs / 1e3}s`);
+    console.log(`  Poll Interval: ${this.parallelAgentConfig.pollIntervalMs / 1e3}s`);
+    console.log(`  Default Concurrency: ${this.parallelAgentConfig.defaultConcurrency}`);
+    console.log(`  Max Concurrency: ${this.parallelAgentConfig.maxConcurrency}`);
+    console.log(`  Debug: ${this.parallelAgentConfig.enableDebug}`);
+    console.log("");
+    console.log("Background Task:");
+    console.log(`  Monitor Interval: ${this.backgroundTaskConfig.monitorIntervalMs / 1e3}s`);
+    console.log(`  Default Timeout: ${this.backgroundTaskConfig.defaultTimeoutMs / 1e3}s`);
+    console.log(`  Max Completed Tasks: ${this.backgroundTaskConfig.maxCompletedTasksToKeep}`);
+    console.log(`  Storage Dir: ${this.backgroundTaskConfig.storageDir}`);
+    console.log(`  Debug: ${this.backgroundTaskConfig.enableDebug}`);
+    console.log("");
+    console.log("Session:");
+    console.log(`  Default Max Steps: ${this.sessionConfig.defaultMaxSteps}`);
+    console.log(`  Task Max Steps: ${this.sessionConfig.taskCommandMaxSteps}`);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+  }
+};
+var configManager = ConfigManager.getInstance();
+
+// src/core/async-agent.ts
+var TASK_TTL_MS2 = configManager.getParallelAgentConfig().taskTtlMs;
+var CLEANUP_DELAY_MS2 = configManager.getParallelAgentConfig().cleanupDelayMs;
+var MIN_STABILITY_MS2 = configManager.getParallelAgentConfig().minStabilityMs;
+var POLL_INTERVAL_MS = configManager.getParallelAgentConfig().pollIntervalMs;
+var DEFAULT_CONCURRENCY = configManager.getParallelAgentConfig().defaultConcurrency;
+var MAX_CONCURRENCY = configManager.getParallelAgentConfig().maxConcurrency;
+var DEBUG = configManager.getParallelAgentConfig().enableDebug;
 var log = (...args) => {
   if (DEBUG) console.log("[parallel-agent]", ...args);
 };
@@ -13894,7 +14824,9 @@ var ConcurrencyController = class {
   queues = /* @__PURE__ */ new Map();
   limits = /* @__PURE__ */ new Map();
   setLimit(key, limit) {
-    this.limits.set(key, limit);
+    const cappedLimit = Math.min(limit, MAX_CONCURRENCY);
+    this.limits.set(key, cappedLimit);
+    log(`Set limit for ${key}: ${cappedLimit}`);
   }
   getLimit(key) {
     return this.limits.get(key) ?? DEFAULT_CONCURRENCY;
@@ -13934,6 +14866,21 @@ var ConcurrencyController = class {
   getQueueLength(key) {
     return this.queues.get(key)?.length ?? 0;
   }
+  updateConcurrency(agentType, newLimit) {
+    this.setLimit(agentType, newLimit);
+    log(`Updated concurrency for ${agentType}: ${newLimit}`);
+  }
+  getStats() {
+    const stats = {};
+    for (const [agentType, limit] of this.limits.entries()) {
+      stats[agentType] = {
+        running: this.counts.get(agentType) ?? 0,
+        queued: this.getQueueLength(agentType),
+        limit
+      };
+    }
+    return stats;
+  }
 };
 var ParallelAgentManager = class _ParallelAgentManager {
   static _instance;
@@ -14113,11 +15060,23 @@ var ParallelAgentManager = class _ParallelAgentManager {
     }
   }
   /**
-   * Set concurrency limit for agent type
-   */
+    * Set concurrency limit for agent type
+    */
   setConcurrencyLimit(agentType, limit) {
     this.concurrency.setLimit(agentType, limit);
   }
+  /**
+    * Get concurrency statistics for all agent types
+    */
+  getConcurrencyStats() {
+    return this.concurrency.getStats();
+  }
+  /**
+    * Update concurrency limit dynamically at runtime
+    */
+  updateConcurrency(agentType, newLimit) {
+    this.concurrency.updateConcurrency(agentType, newLimit);
+  }
   /**
    * Get pending notification count
    */
@@ -14197,7 +15156,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
         const sessionStatus = allStatuses[task.sessionID];
         if (sessionStatus?.type === "idle") {
           const elapsed = Date.now() - task.startedAt.getTime();
-          if (elapsed < MIN_STABILITY_MS) continue;
+          if (elapsed < MIN_STABILITY_MS2) continue;
           const hasOutput = await this.validateSessionHasOutput(task.sessionID);
           if (!hasOutput) continue;
           task.status = "completed";
@@ -14251,7 +15210,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
     const now = Date.now();
     for (const [taskId, task] of this.tasks.entries()) {
       const age = now - task.startedAt.getTime();
-      if (age > TASK_TTL_MS) {
+      if (age > TASK_TTL_MS2) {
         log(`Timeout: ${taskId} (${Math.round(age / 1e3)}s)`);
         if (task.status === "running") {
           task.status = "timeout";
@@ -14302,7 +15261,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
       }
       this.tasks.delete(taskId);
       log(`Cleaned up ${taskId} from memory`);
-    }, CLEANUP_DELAY_MS);
+    }, CLEANUP_DELAY_MS2);
   }
   // ========================================================================
   // Internal: Notifications
@@ -14495,7 +15454,7 @@ Session ID: ${sessionID}`;
       }
       const POLL_INTERVAL_MS2 = 500;
       const MAX_POLL_TIME_MS = 10 * 60 * 1e3;
-      const MIN_STABILITY_MS2 = 5e3;
+      const MIN_STABILITY_MS3 = 5e3;
       const STABILITY_POLLS_REQUIRED = 3;
       let stablePolls = 0;
       let lastMsgCount = 0;
@@ -14509,7 +15468,7 @@ Session ID: ${sessionID}`;
           lastMsgCount = 0;
           continue;
         }
-        if (Date.now() - startTime < MIN_STABILITY_MS2) continue;
+        if (Date.now() - startTime < MIN_STABILITY_MS3) continue;
         const messagesResult2 = await session.messages({
           path: { id: sessionID }
         });
@@ -14715,6 +15674,476 @@ function createAsyncAgentTools(manager, client) {
   };
 }
 
+// src/core/batch-processor.ts
+var SmartBatchProcessor = class {
+  parallelAgentManager;
+  tasks = /* @__PURE__ */ new Map();
+  constructor(parallelAgentManager2) {
+    this.parallelAgentManager = parallelAgentManager2;
+  }
+  /**
+   * Process a batch of tasks with smart validation
+   */
+  async processBatch(tasks, options = {
+    concurrency: 3,
+    maxRetries: 2,
+    validateAfterEach: false,
+    continueOnError: true
+  }) {
+    const startTime = Date.now();
+    for (const task of tasks) {
+      this.tasks.set(task.id, {
+        ...task,
+        status: "pending",
+        attempts: 0
+      });
+    }
+    console.log(`
+\u{1F4E6} [Smart Batch] Starting ${tasks.length} tasks with concurrency ${options.concurrency}`);
+    console.log(`   Strategy: ${options.validateAfterEach ? "Validate each" : "Centralized validation"}`);
+    await this.executePhase(tasks, options, "initial");
+    const failedTasks = Array.from(this.tasks.values()).filter((t) => t.status === "failed" || t.status === "pending");
+    if (failedTasks.length === 0) {
+      console.log(`
+\u2705 [Smart Batch] All ${tasks.length} tasks succeeded!`);
+      return this.buildResult(startTime, tasks);
+    }
+    console.log(`
+\u{1F50D} [Smart Batch] Validation complete: ${failedTasks.length}/${tasks.length} tasks need retry`);
+    let retryCount = 0;
+    while (failedTasks.length > 0 && retryCount < options.maxRetries) {
+      retryCount++;
+      console.log(`
+\u{1F504} [Smart Batch] Retry round ${retryCount}/${options.maxRetries} for ${failedTasks.length} tasks`);
+      await this.executePhase(failedTasks, options, `retry-${retryCount}`);
+      const stillFailed = Array.from(this.tasks.values()).filter((t) => t.status === "failed");
+      if (stillFailed.length === failedTasks.length) {
+        console.log(`\u26A0\uFE0F [Smart Batch] No progress in retry round ${retryCount}, stopping`);
+        break;
+      }
+    }
+    return this.buildResult(startTime, tasks);
+  }
+  /**
+   * Execute a phase with concurrency control
+   */
+  async executePhase(tasks, options, phase) {
+    for (const task of tasks) {
+      this.parallelAgentManager.setConcurrencyLimit(task.agent, options.concurrency);
+    }
+    const batches = [];
+    for (let i = 0; i < tasks.length; i += options.concurrency) {
+      batches.push(tasks.slice(i, i + options.concurrency));
+    }
+    for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+      const batch = batches[batchIndex];
+      console.log(`   [${phase}] Processing batch ${batchIndex + 1}/${batches.length} (${batch.length} tasks)`);
+      const batchPromises = batch.map((task) => this.executeTask(task, options));
+      await Promise.all(batchPromises);
+      if (!options.validateAfterEach) {
+        continue;
+      }
+      const failedInBatch = batch.filter((t) => t.status === "failed");
+      if (failedInBatch.length > 0) {
+        console.log(`   [${phase}] ${failedInBatch.length} failed in batch, immediate retry`);
+        const retryPromises = failedInBatch.map((t) => this.executeTask(t, options));
+        await Promise.all(retryPromises);
+      }
+    }
+  }
+  /**
+   * Execute a single task
+   */
+  async executeTask(task, options) {
+    const currentTask = this.tasks.get(task.id);
+    if (!options.continueOnError && currentTask.status === "failed") {
+      return;
+    }
+    try {
+      currentTask.attempts++;
+      currentTask.status = "pending";
+      const launched = await this.parallelAgentManager.launch({
+        agent: task.agent,
+        description: task.description,
+        prompt: task.prompt,
+        parentSessionID: ""
+        // Would need actual parent ID
+      });
+      const maxWaitTime = 5 * 60 * 1e3;
+      const startTime = Date.now();
+      while (Date.now() - startTime < maxWaitTime) {
+        const taskData = this.parallelAgentManager.getTask(launched.id);
+        if (!taskData) break;
+        if (taskData.status === "completed") {
+          currentTask.status = "success";
+          console.log(`   \u2705 [${task.id}] Success on attempt ${currentTask.attempts}`);
+          return;
+        }
+        if (taskData.status === "error" || taskData.status === "timeout") {
+          currentTask.status = "failed";
+          currentTask.error = taskData.error || "Unknown error";
+          console.log(`   \u274C [${task.id}] Failed: ${currentTask.error}`);
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+      currentTask.status = "failed";
+      currentTask.error = "Timeout";
+    } catch (error45) {
+      currentTask.status = "failed";
+      currentTask.error = error45 instanceof Error ? error45.message : String(error45);
+      console.log(`   \u274C [${task.id}] Exception: ${currentTask.error}`);
+    }
+  }
+  /**
+   * Build result summary
+   */
+  buildResult(startTime, tasks) {
+    const allTasks = Array.from(this.tasks.values());
+    const successCount = allTasks.filter((t) => t.status === "success").length;
+    const failedCount = allTasks.filter((t) => t.status === "failed").length;
+    const retriedCount = allTasks.filter((t) => t.attempts > 1).length;
+    return {
+      total: tasks.length,
+      success: successCount,
+      failed: failedCount,
+      retried: retriedCount,
+      duration: Date.now() - startTime,
+      tasks: allTasks
+    };
+  }
+  /**
+   * Export failed tasks for manual review
+   */
+  exportFailedTasks() {
+    const failedTasks = Array.from(this.tasks.values()).filter((t) => t.status === "failed");
+    if (failedTasks.length === 0) {
+      return "\u2705 No failed tasks to export.";
+    }
+    const output = failedTasks.map((task) => {
+      return `
+---
+Task ID: ${task.id}
+Agent: ${task.agent}
+Attempts: ${task.attempts}
+Error: ${task.error}
+Description: ${task.description}
+---
+      `.trim();
+    }).join("\n");
+    return `\u274C ${failedTasks.length} failed tasks:
+${output}`;
+  }
+  /**
+   * Clear all tasks
+   */
+  clear() {
+    this.tasks.clear();
+  }
+};
+
+// src/tools/batch.ts
+var createProcessBatchTool = (parallelAgentManager2, client) => tool({
+  description: `Execute a batch of tasks with intelligent validation and retry.
+
+<strategy>
+1. Execute all tasks in parallel (respecting concurrency limits)
+2. Centralized validation: Identify ALL failed tasks at once
+3. Retry ONLY failed tasks (not everything)
+</strategy>
+
+<benefits>
+- Faster than naive retry: Failed tasks batch-identified
+- More efficient: No redundant work on successful tasks
+- Controlled: Concurrency limits prevent API overload
+</benefits>
+
+<examples>
+process_batch({
+  concurrency: 10,
+  tasks: [
+    { id: "task1", agent: "builder", description: "Test A", prompt: "..." },
+    { id: "task2", agent: "inspector", description: "Test B", prompt: "..." }
+  ]
+})
+</examples>`,
+  args: {
+    concurrency: tool.schema.string().describe("Concurrency limit (default: 3, max: 10)"),
+    maxRetries: tool.schema.string().optional().describe("Maximum retry rounds (default: 2)"),
+    validateAfterEach: tool.schema.boolean().optional().describe("Validate after each task (default: false = centralized validation)"),
+    tasks: tool.schema.string().describe("Array of task objects in JSON format")
+  },
+  async execute(args) {
+    const { concurrency, maxRetries = "2", validateAfterEach = false, tasks } = args;
+    let taskList;
+    try {
+      taskList = JSON.parse(tasks);
+    } catch {
+      return "\u274C Invalid tasks JSON. Must be valid array.";
+    }
+    if (!Array.isArray(taskList)) {
+      return "\u274C tasks must be an array of task objects.";
+    }
+    for (const task of taskList) {
+      if (!task.id || !task.agent || !task.description || !task.prompt) {
+        return `\u274C Task missing required fields (id, agent, description, prompt)`;
+      }
+    }
+    const numConcurrency = parseInt(concurrency, 10);
+    const numRetries = parseInt(maxRetries, 10);
+    if (isNaN(numConcurrency) || numConcurrency < 1 || numConcurrency > 10) {
+      return "\u274C Invalid concurrency. Must be 1-10.";
+    }
+    if (isNaN(numRetries) || numRetries < 0 || numRetries > 5) {
+      return "\u274C Invalid maxRetries. Must be 0-5.";
+    }
+    const processor = new SmartBatchProcessor(parallelAgentManager2);
+    const result = await processor.processBatch(taskList, {
+      concurrency: numConcurrency,
+      maxRetries: numRetries,
+      validateAfterEach,
+      continueOnError: true
+    });
+    const durationSecs = Math.floor(result.duration / 1e3);
+    const successRate = (result.success / result.total * 100).toFixed(1);
+    let output = `\u2705 **Batch Processing Complete**
+
+| Metric | Value |
+|---------|--------|
+| **Total Tasks** | ${result.total} |
+| **Successful** | ${result.success} (${successRate}%) |
+| **Failed** | ${result.failed} |
+| **Retried** | ${result.retried} |
+| **Duration** | ${durationSecs}s |
+
+`;
+    if (result.failed > 0) {
+      output += `\u26A0\uFE0F **Failed Tasks**
+
+Use \`export_failed_tasks()\` to review failed tasks and manually fix issues.
+
+---
+
+Failed Task IDs:
+${result.tasks.filter((t) => t.status === "failed").map((t) => `  - ${t.id}`).join("\n")}
+---
+`;
+    }
+    return output;
+  }
+});
+var createExportFailedTasksTool = (parallelAgentManager2) => tool({
+  description: `Export failed tasks from the last batch for manual review.`,
+  args: {},
+  async execute() {
+    const processor = new SmartBatchProcessor(parallelAgentManager2);
+    return processor.exportFailedTasks();
+  }
+});
+var createCompareStrategiesTool = (parallelAgentManager2) => tool({
+  description: `Compare naive retry vs smart batch validation performance.
+
+<comparison>
+**Naive Strategy** (current):
+- Concurrency: 3 fixed
+- Retry: Per-task immediate retry
+- Issue: Slow for large batches, redundant work
+
+**Smart Batch Strategy** (new):
+- Concurrency: Configurable (up to 10)
+- Validation: Centralized, batch-identify failures
+- Retry: Only failed tasks
+- Benefit: Faster, less redundant work
+</comparison>`,
+  args: {
+    taskCount: tool.schema.string().describe("Number of simulated tasks (default: 100)"),
+    concurrency1: tool.schema.string().optional().describe("Strategy 1 concurrency (default: 3)"),
+    concurrency2: tool.schema.string().optional().describe("Strategy 2 concurrency (default: 10)")
+  },
+  async execute(args) {
+    const taskCount = parseInt(args.taskCount || "100", 10);
+    const concurrency1 = parseInt(args.concurrency1 || "3", 10);
+    const concurrency2 = parseInt(args.concurrency2 || "10", 10);
+    const naiveBatches = Math.ceil(taskCount / concurrency1);
+    const naiveTime = naiveBatches * 60;
+    const smartBatches = Math.ceil(taskCount / concurrency2);
+    const smartTime = smartBatches * 60 + 30;
+    const timeDiff = naiveTime - smartTime;
+    const improvement = (timeDiff / naiveTime * 100).toFixed(1);
+    return `\u{1F4CA} **Strategy Comparison for ${taskCount} tasks**
+
+**Strategy 1: Naive (Current)**
+| Metric | Value |
+|---------|--------|
+| Concurrency | ${concurrency1} |
+| Batches | ${naiveBatches} |
+| Est. Time | ${naiveTime}s |
+
+**Strategy 2: Smart Batch (Proposed)**
+| Metric | Value |
+|---------|--------|
+| Concurrency | ${concurrency2} |
+| Batches | ${smartBatches} |
+| Est. Time | ${smartTime}s |
+
+**Summary**
+| Metric | Value |
+|---------|--------|
+| Time Saved | ${timeDiff}s (${improvement}%) |
+| Batches Saved | ${naiveBatches - smartBatches} |
+
+Recommendation: Use **Smart Batch** with concurrency ${concurrency2} for ${timeDiff}s improvement.`;
+  }
+});
+function createBatchTools(parallelAgentManager2, client) {
+  return {
+    process_batch: createProcessBatchTool(parallelAgentManager2, client),
+    export_failed_tasks: createExportFailedTasksTool(parallelAgentManager2),
+    compare_strategies: createCompareStrategiesTool(parallelAgentManager2)
+  };
+}
+
+// src/tools/config.ts
+var createShowConfigTool = () => tool({
+  description: `Display current OpenCode Orchestrator configuration.
+
+Shows all dynamic settings including timeouts, concurrency limits, and debug flags.`,
+  args: {},
+  async execute() {
+    configManager.exportConfigs();
+    return "";
+  }
+});
+var createSetConcurrencyTool = (client) => tool({
+  description: `Update concurrency limit for a specific agent type.
+
+<examples>
+set_concurrency({ agent: "builder", limit: 5 })
+set_concurrency({ agent: "inspector", limit: 2 })
+</examples>
+
+<notes>
+- Changes take effect immediately
+- Queued tasks will start when slots become available
+- Limit cannot exceed global max (10)
+</notes>`,
+  args: {
+    agent: tool.schema.string().describe('Agent type (e.g., "builder", "inspector", "architect")'),
+    limit: tool.schema.string().describe("New concurrency limit (number)")
+  },
+  async execute(args) {
+    const { agent, limit } = args;
+    const numLimit = parseInt(limit, 10);
+    if (isNaN(numLimit) || numLimit < 1) {
+      return `\u274C Invalid limit: "${limit}". Must be a number >= 1.`;
+    }
+    const maxLimit = configManager.getParallelAgentConfig().maxConcurrency;
+    if (numLimit > maxLimit) {
+      return `\u274C Limit ${numLimit} exceeds global max ${maxLimit}. Using ${maxLimit}.`;
+    }
+    configManager.updateParallelAgentConfig({
+      defaultConcurrency: numLimit
+    });
+    return `\u2705 **Concurrency Updated**
+
+| Property | Value |
+|----------|-------|
+| **Agent** | ${agent} |
+| **New Limit** | ${numLimit} parallel tasks |
+
+Changes take effect immediately. New tasks will respect to the new limit.`;
+  }
+});
+var createSetTimeoutTool = () => tool({
+  description: `Update task timeout duration.
+
+<examples>
+set_timeout({ taskTtlMinutes: 45 })
+set_timeout({ cleanupDelayMinutes: 2 })
+</examples>`,
+  args: {
+    taskTtlMinutes: tool.schema.string().optional().describe("Task timeout in minutes (default: 30)"),
+    cleanupDelayMinutes: tool.schema.string().optional().describe("Cleanup delay after completion in minutes (default: 5)")
+  },
+  async execute(args) {
+    const { taskTtlMinutes, cleanupDelayMinutes } = args;
+    const updates = {};
+    if (taskTtlMinutes) {
+      const ttl = parseInt(taskTtlMinutes, 10);
+      if (isNaN(ttl) || ttl < 1) {
+        return `\u274C Invalid taskTtlMinutes: "${taskTtlMinutes}". Must be number >= 1.`;
+      }
+      updates.taskTtlMs = ttl * 60 * 1e3;
+    }
+    if (cleanupDelayMinutes) {
+      const delay = parseInt(cleanupDelayMinutes, 10);
+      if (isNaN(delay) || delay < 0) {
+        return `\u274C Invalid cleanupDelayMinutes: "${cleanupDelayMinutes}". Must be number >= 0.`;
+      }
+      updates.cleanupDelayMs = delay * 60 * 1e3;
+    }
+    if (Object.keys(updates).length === 0) {
+      return "\u26A0\uFE0F No changes specified. Provide at least one parameter.";
+    }
+    configManager.updateParallelAgentConfig(updates);
+    let output = "\u2705 **Timeout Configuration Updated**\n\n";
+    if (updates.taskTtlMs) {
+      output += `| Task TTL | ${updates.taskTtlMs / 60 / 1e3} minutes |
+`;
+    }
+    if (updates.cleanupDelayMs) {
+      output += `| Cleanup Delay | ${updates.cleanupDelayMs / 60 / 1e3} minutes |
+`;
+    }
+    output += "\nChanges take effect immediately.";
+    return output;
+  }
+});
+var createSetDebugTool = () => tool({
+  description: `Enable or disable debug logging.
+
+<examples>
+set_debug({ component: "parallel_agent", enable: true })
+set_debug({ component: "background_task", enable: false })
+</examples>`,
+  args: {
+    component: tool.schema.string().describe('Component to debug: "parallel_agent", "background_task", or "all"'),
+    enable: tool.schema.boolean().describe("Enable (true) or disable (false) debug logs")
+  },
+  async execute(args) {
+    const { component, enable } = args;
+    const enableValue = enable ? "true" : "false";
+    if (component === "parallel_agent" || component === "all") {
+      process.env.OPENCODE_DEBUG_PARALLEL = enableValue;
+      configManager.updateParallelAgentConfig({
+        enableDebug: enable
+      });
+    }
+    if (component === "background_task" || component === "all") {
+      process.env.OPENCODE_DEBUG_BACKGROUND = enableValue;
+      configManager.updateBackgroundTaskConfig({
+        enableDebug: enable
+      });
+    }
+    return `\u2705 **Debug Logging ${enable ? "Enabled" : "Disabled"}**
+
+| Component | Debug Status |
+|-----------|--------------|
+| ${component === "all" ? "parallel_agent" : component} | ${enable ? "\u{1F527} Enabled" : "\u{1F507} Disabled"} |
+${component === "all" ? "| background_task | \u{1F527} Enabled |" : ""}
+
+Changes take effect immediately.`;
+  }
+});
+function createConfigTools(client) {
+  return {
+    show_config: createShowConfigTool(),
+    set_concurrency: createSetConcurrencyTool(client),
+    set_timeout: createSetTimeoutTool(),
+    set_debug: createSetDebugTool()
+  };
+}
+
 // src/utils/common.ts
 function detectSlashCommand(text) {
   const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
@@ -14738,110 +16167,6 @@ function formatElapsedTime(startMs, endMs = Date.now()) {
   return parts.join(" ");
 }
 
-// src/utils/sanity.ts
-function checkOutputSanity(text) {
-  if (!text || text.length < 50) {
-    return { isHealthy: true, severity: "ok" };
-  }
-  if (/(.)\1{15,}/.test(text)) {
-    return {
-      isHealthy: false,
-      reason: "Single character repetition detected",
-      severity: "critical"
-    };
-  }
-  if (/(.{2,6})\1{8,}/.test(text)) {
-    return {
-      isHealthy: false,
-      reason: "Pattern loop detected",
-      severity: "critical"
-    };
-  }
-  if (text.length > 200) {
-    const cleanText = text.replace(/\s/g, "");
-    if (cleanText.length > 100) {
-      const uniqueChars = new Set(cleanText).size;
-      const ratio = uniqueChars / cleanText.length;
-      if (ratio < 0.02) {
-        return {
-          isHealthy: false,
-          reason: "Low information density",
-          severity: "critical"
-        };
-      }
-    }
-  }
-  const boxChars = (text.match(/[\u2500-\u257f\u2580-\u259f\u2800-\u28ff]/g) || []).length;
-  if (boxChars > 100 && boxChars / text.length > 0.3) {
-    return {
-      isHealthy: false,
-      reason: "Visual gibberish detected",
-      severity: "critical"
-    };
-  }
-  const lines = text.split("\n").filter((l) => l.trim().length > 10);
-  if (lines.length > 10) {
-    const lineSet = new Set(lines);
-    if (lineSet.size < lines.length * 0.2) {
-      return {
-        isHealthy: false,
-        reason: "Excessive line repetition",
-        severity: "warning"
-      };
-    }
-  }
-  const cjkChars = (text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length;
-  if (cjkChars > 200) {
-    const uniqueCjk = new Set(
-      text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []
-    ).size;
-    if (uniqueCjk < 10 && cjkChars / uniqueCjk > 20) {
-      return {
-        isHealthy: false,
-        reason: "CJK character spam detected",
-        severity: "critical"
-      };
-    }
-  }
-  return { isHealthy: true, severity: "ok" };
-}
-var RECOVERY_PROMPT = `<anomaly_recovery>
-\u26A0\uFE0F SYSTEM NOTICE: Previous output was malformed (gibberish/loop detected).
-
-<recovery_protocol>
-1. DISCARD the corrupted output completely - do not reference it
-2. RECALL the original mission objective
-3. IDENTIFY the last confirmed successful step
-4. RESTART with a simpler, more focused approach
-</recovery_protocol>
-
-<instructions>
-- If a sub-agent produced bad output: try a different agent or simpler task
-- If stuck in a loop: break down the task into smaller pieces
-- If context seems corrupted: call recorder to restore context
-- THINK in English for maximum stability
-</instructions>
-
-What was the original task? Proceed from the last known good state.
-</anomaly_recovery>`;
-var ESCALATION_PROMPT = `<critical_anomaly>
-\u{1F6A8} CRITICAL: Multiple consecutive malformed outputs detected.
-
-<emergency_protocol>
-1. STOP current execution path immediately
-2. DO NOT continue with the same approach - it is failing
-3. CALL architect for a completely new strategy
-4. If architect also fails: report status to user and await guidance
-</emergency_protocol>
-
-<diagnosis>
-The current approach is producing corrupted output.
-This may indicate: context overload, model instability, or task complexity.
-</diagnosis>
-
-Request a fresh plan from architect with reduced scope.
-</critical_anomaly>`;
-
 // src/index.ts
 var PLUGIN_VERSION = "0.2.4";
 var DEFAULT_MAX_STEPS = 500;
@@ -14875,6 +16200,8 @@ var OrchestratorPlugin = async (input) => {
   const sessions = /* @__PURE__ */ new Map();
   const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
+  const batchTools = createBatchTools(parallelAgentManager2, client);
+  const configTools = createConfigTools(client);
   return {
     // -----------------------------------------------------------------
     // Tools we expose to the LLM
@@ -14892,7 +16219,13 @@ var OrchestratorPlugin = async (input) => {
       list_background: listBackgroundTool,
       kill_background: killBackgroundTool,
       // Async agent tools - spawn agents in parallel sessions
-      ...asyncAgentTools
+      ...asyncAgentTools,
+      // Git tools - branch info and status
+      git_branch: gitBranchTool(directory),
+      // Smart batch tools - centralized validation and retry
+      ...batchTools,
+      // Configuration tools - dynamic runtime settings
+      ...configTools
     },
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode