opencode-orchestrator 0.5.3 → 0.5.5

package/dist/index.js

@@ -1,183 +1,18 @@
 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 });
 };
 
-// src/shared/contracts/names.ts
+// src/shared/agent.ts
 var AGENT_NAMES = {
-  // Core Agents (5)
   COMMANDER: "commander",
-  // Orchestrator - ReAct loop controller
   ARCHITECT: "architect",
-  // Planner + Strategist - Plan-and-Execute
   BUILDER: "builder",
-  // Coder + Visualist combined (full-stack)
   INSPECTOR: "inspector",
-  // Reviewer + Fixer combined (quality + fix)
   RECORDER: "recorder"
-  // 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,
@@ -186,10 +21,6 @@ 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
@@ -255,8 +86,8 @@ PREFER background=true (PARALLEL):
 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 })
+delegate_task({ agent: "builder", description: "Implement X", prompt: "...", background: true })
+delegate_task({ agent: "inspector", description: "Review Y", prompt: "...", background: true })
 
 // Continue other work (don't wait!)
 
@@ -267,7 +98,7 @@ 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 })
+const result = delegate_task({ agent: "builder", ..., background: false })
 // Result is immediately available
 \`\`\`
 </agent_calling>
@@ -294,10 +125,10 @@ During implementation:
 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
+   spawn_agent({ agent: "builder", description: "Implement X", prompt: "..." })
+   spawn_agent({ agent: "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" })
@@ -348,10 +179,10 @@ WORKFLOW:
 <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. |
+| recorder | Fresh start. Proceed to survey. |
+| architect | Try simpler plan yourself. |
+| builder | Call inspector to diagnose. |
+| 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.
@@ -363,299 +194,93 @@ STRICT RULE: If any agent output contains gibberish, mixed-language hallucinatio
 \u274C Make random changes without understanding root cause
 </anti_patterns>
 
-${WORKFLOW}
+<completion>
+Done when: Request fulfilled + lsp clean + build/test/audit pass.
 
-<phase_0 name="TRIAGE">
-Evaluate the complexity of the request:
+<output_format>
+\u2705 MISSION COMPLETE
+Summary: [what was done]
+Evidence: [Specific build/test/audit results]
+</output_format>
+</completion>`,
+  canWrite: true,
+  canBash: true
+};
 
-| 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>
+// src/agents/subagents/architect.ts
+var architect = {
+  id: AGENT_NAMES.ARCHITECT,
+  description: "Architect - task decomposition and strategic planning",
+  systemPrompt: `<role>
+You are Architect. Break complex tasks into atomic pieces.
+</role>
 
-<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.
+<constraints>
 
-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
+If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
-RECORD findings if on Deep Track.
-</phase_1>
+<scalable_planning>
+- **Fast Track**: Skip JSON overhead. Just acknowledge simple task.
+- **Deep Track**: Create detailed JSON DAG with parallel groups.
+</scalable_planning>
 
-<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. |
+<modes>
+- PLAN: New task \u2192 create task list
+- STRATEGY: 3+ failures \u2192 analyze and fix approach
+</modes>
 
-DEFAULT to Deep Track if unsure to act safely.
-</phase_2>
+<plan_mode>
+1. List tasks, one action each
+2. Group independent tasks (run in parallel)
+3. Sequence dependent tasks
+4. Assign: builder (code) or inspector (verify)
 
-<phase_3 name="DELEGATION">
-<agent_calling>
-CRITICAL: USE delegate_task FOR ALL DELEGATION
+<output_format>
+MISSION: [goal in one line]
 
-delegate_task has TWO MODES:
-- background=true: Non-blocking, parallel execution
-- background=false: Blocking, waits for result
+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]
+</output_format>
+</plan_mode>
 
-| 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 })\` |
+<strategy_mode trigger="failures > 2">
+<output_format>
+FAILED ATTEMPTS:
+- [what was tried] \u2192 [why failed]
 
-PREFER background=true (PARALLEL):
-- Run multiple agents simultaneously
-- Continue analysis while they work
-- System notifies when ALL complete
+ROOT CAUSE: [actual problem]
 
-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 })
+NEW APPROACH: [different strategy]
 
-// Continue other work (don't wait!)
+REVISED TASKS:
+T1: ...
+</output_format>
+</strategy_mode>
 
-// When notified "All Complete":
-get_task_result({ taskId: "task_xxx" })
-\`\`\`
+<rules>
+- One action per task
+- Always end with inspector task
+- Group unrelated tasks (parallel)
+- Be specific about files and verification
+</rules>`,
+  canWrite: false,
+  canBash: false
+};
 
-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>
+// src/agents/subagents/builder.ts
+var builder = {
+  id: AGENT_NAMES.BUILDER,
+  description: "Builder - full-stack implementation specialist",
+  systemPrompt: `<role>
+You are Builder. Write code that works.
+</role>
 
-<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>
+<constraints>
 
-<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.
-
-<output_format>
-\u2705 MISSION COMPLETE
-Summary: [what was done]
-Evidence: [Specific build/test/audit results]
-</output_format>
-</completion>`,
-  canWrite: true,
-  canBash: true
-};
-
-// src/agents/subagents/architect.ts
-var architect = {
-  id: AGENT_NAMES.ARCHITECT,
-  description: "Architect - task decomposition and strategic planning",
-  systemPrompt: `<role>
-You are Architect. Break complex tasks into atomic pieces.
-</role>
-
-${REASONING_CONSTRAINTS}
-
-${WORKFLOW}
-
-<scalable_planning>
-- **Fast Track**: Skip JSON overhead. Just acknowledge simple task.
-- **Deep Track**: Create detailed JSON DAG with parallel groups.
-</scalable_planning>
-
-<modes>
-- PLAN: New task \u2192 create task list
-- STRATEGY: 3+ failures \u2192 analyze and fix approach
-</modes>
-
-<plan_mode>
-1. List tasks, one action each
-2. Group independent tasks (run in parallel)
-3. Sequence dependent tasks
-4. Assign: builder (code) or inspector (verify)
-
-<output_format>
-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>
-<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>
-
-<rules>
-- One action per task
-- 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
-};
-
-// src/agents/subagents/builder.ts
-var builder = {
-  id: AGENT_NAMES.BUILDER,
-  description: "Builder - full-stack implementation specialist",
-  systemPrompt: `<role>
-You are Builder. Write code that works.
-</role>
-
-${REASONING_CONSTRAINTS}
-
-${WORKFLOW}
-
-${ANTI_PATTERNS}
+If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
 <scalable_attention>
 - **Simple Fix (L1)**: Read file \u2192 Implement fix directly. Efficiency first.
@@ -718,11 +343,10 @@ var inspector = {
 You are Inspector. Prove failure or success with evidence.
 </role>
 
-${REASONING_CONSTRAINTS}
-
-${WORKFLOW}
+<constraints>
 
-${ANTI_PATTERNS}
+If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
 <scalable_audit>
 - **Fast Track**: Verify syntax + quick logic check.
@@ -786,7 +410,10 @@ var recorder = {
 You are Recorder. Save and load work progress.
 </role>
 
-${REASONING_CONSTRAINTS}
+<constraints>
+
+If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
 <purpose>
 Context can be lost between sessions. You save it to disk.
@@ -851,7 +478,7 @@ var AGENTS = {
   [AGENT_NAMES.RECORDER]: recorder
 };
 
-// src/core/tasks.ts
+// src/core/orchestrator/task-graph.ts
 var TaskGraph = class _TaskGraph {
   tasks = /* @__PURE__ */ new Map();
   constructor(tasks) {
@@ -892,7 +519,7 @@ var TaskGraph = class _TaskGraph {
     const notCompleted = tasks.filter((t) => t.status !== "completed");
     let summary = "\u{1F4CB} **Mission Status**\n";
     if (completed.length > 0) {
-      summary += `\u2705 Completed: ${completed.length} tasks (Hidden to save tokens)
+      summary += `\u2705 Completed: ${completed.length} tasks
 `;
     }
     for (const task of notCompleted) {
@@ -909,27 +536,17 @@ var TaskGraph = class _TaskGraph {
     try {
       const tasks = JSON.parse(json2);
       return new _TaskGraph(tasks);
-    } catch (e) {
-      console.error("Failed to parse TaskGraph JSON:", e);
+    } catch {
       return new _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
+// src/core/orchestrator/state.ts
 var state = {
   missionActive: false,
   maxIterations: 1e3,
-  // Effectively infinite - "Relentless" mode
-  maxRetries: MAX_TASK_RETRIES,
+  maxRetries: 3,
   sessions: /* @__PURE__ */ new Map()
 };
 
@@ -13355,113 +12972,6 @@ 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",
@@ -13500,19 +13010,13 @@ var callAgentTool = tool({
   async execute(args) {
     const agentDef = AGENTS[args.agent];
     if (!agentDef) {
-      return "Error: Unknown agent: " + args.agent;
+      return `\u274C 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}
@@ -13522,7 +13026,9 @@ ${agentDef.systemPrompt}
 ${args.task}
 </task>
 
-${args.context ? "<context>\n" + args.context + "\n</context>" : ""}
+${args.context ? `<context>
+${args.context}
+</context>` : ""}
 
 <execution>
 Follow this pattern:
@@ -13547,10 +13053,6 @@ var COMMANDS = {
 You are Commander. Complete this mission. Never stop until 100% done.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability. Final report in Korean.
-</constraints>
-
 <phase_1 name="MANDATORY_ENVIRONMENT_SCAN">
 Before any planning or coding, you MUST understand:
 1. INFRA: OS-native? Container? Docker-compose? Volume-mounted?
@@ -13768,255 +13270,72 @@ var globSearchTool = (directory) => tool({
   }
 });
 var mgrepTool = (directory) => tool({
-  description: `Search multiple patterns in parallel (high-performance).
-
-<purpose>
-Search for multiple regex patterns simultaneously using Rust's parallel execution.
-Much faster than running grep multiple times sequentially.
-</purpose>
-
-<examples>
-- patterns: ["useState", "useEffect", "useContext"] \u2192 Find all React hooks usage
-- patterns: ["TODO", "FIXME", "HACK"] \u2192 Find all code annotations
-- patterns: ["import.*lodash", "require.*lodash"] \u2192 Find all lodash imports
-</examples>
-
-<output>
-Returns matches grouped by pattern, with file paths and line numbers.
-</output>`,
-  args: {
-    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns to search for"),
-    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)"),
-    max_results_per_pattern: tool.schema.number().optional().describe("Max results per pattern (default: 50)")
-  },
-  async execute(args) {
-    return callRustTool("mgrep", {
-      patterns: args.patterns,
-      directory: args.dir || directory,
-      max_results_per_pattern: args.max_results_per_pattern || 50
-    });
-  }
-});
-
-// 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>`,
+  description: `Search multiple patterns (runs grep for each pattern).`,
   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.")
+    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns"),
+    dir: tool.schema.string().optional().describe("Directory (defaults to project root)")
   },
   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));
+    const results = {};
+    const dir = args.dir || directory;
+    for (const pattern of args.patterns) {
+      const result = await callRustTool("grep_search", { pattern, directory: dir });
+      results[pattern] = result;
     }
+    return JSON.stringify(results, null, 2);
   }
 });
-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
+// src/core/commands/manager.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
-import { mkdirSync, readFileSync, writeFileSync, existsSync as existsSync3 } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
+
+// src/shared/constants.ts
+var TIME = {
+  SECOND: 1e3,
+  MINUTE: 60 * 1e3,
+  HOUR: 60 * 60 * 1e3
+};
+var ID_PREFIX = {
+  /** Parallel agent task ID (e.g., task_a1b2c3d4) */
+  TASK: "task_",
+  /** Background command job ID (e.g., job_a1b2c3d4) */
+  JOB: "job_",
+  /** Session ID prefix */
+  SESSION: "session_"
+};
+var PARALLEL_TASK = {
+  TTL_MS: 30 * TIME.MINUTE,
+  CLEANUP_DELAY_MS: 5 * TIME.MINUTE,
+  MIN_STABILITY_MS: 5 * TIME.SECOND,
+  POLL_INTERVAL_MS: 2e3,
+  DEFAULT_CONCURRENCY: 3,
+  MAX_CONCURRENCY: 10
+};
+var BACKGROUND_TASK = {
+  DEFAULT_TIMEOUT_MS: 5 * TIME.MINUTE,
+  MAX_OUTPUT_LENGTH: 1e4
+};
+var STATUS_EMOJI = {
+  pending: "\u23F3",
+  running: "\u{1F504}",
+  completed: "\u2705",
+  done: "\u2705",
+  error: "\u274C",
+  timeout: "\u23F0",
+  cancelled: "\u{1F6AB}"
+};
+function getStatusEmoji(status) {
+  return STATUS_EMOJI[status] ?? "\u2753";
+}
+
+// src/core/commands/manager.ts
 var BackgroundTaskManager = class _BackgroundTaskManager {
   static _instance;
   tasks = /* @__PURE__ */ new Map();
-  debugMode = true;
-  // Enable debug mode
-  storageDir;
-  storageFile;
-  monitoringInterval;
+  debugMode = process.env.DEBUG_BG_TASK === "true";
+  // Disabled by default
   constructor() {
-    this.storageDir = join2(homedir(), ".opencode-orchestrator");
-    this.storageFile = join2(this.storageDir, "tasks.json");
-    this.loadFromDisk();
-    this.startMonitoring();
   }
   static get instance() {
     if (!_BackgroundTaskManager._instance) {
@@ -14024,144 +13343,15 @@ var BackgroundTaskManager = class _BackgroundTaskManager {
     }
     return _BackgroundTaskManager._instance;
   }
-  /**
-   * Generate a unique task ID in the format job_xxxxxxxx
-   */
   generateId() {
-    const hex3 = randomBytes(4).toString("hex");
-    return `job_${hex3}`;
-  }
-  /**
-   * Ensure storage directory exists
-   */
-  ensureStorageDir() {
-    if (!existsSync3(this.storageDir)) {
-      mkdirSync(this.storageDir, { recursive: true });
-      this.debug("system", `Created storage directory: ${this.storageDir}`);
-    }
-  }
-  /**
-   * Load tasks from disk on startup
-   */
-  loadFromDisk() {
-    this.ensureStorageDir();
-    if (!existsSync3(this.storageFile)) {
-      this.debug("system", "No existing task data on disk");
-      return;
-    }
-    try {
-      const data = readFileSync(this.storageFile, "utf-8");
-      const tasksData = JSON.parse(data);
-      for (const [id, taskData] of Object.entries(tasksData)) {
-        const task = taskData;
-        task.process = void 0;
-        if (task.status === "running") {
-          task.status = "error";
-          task.errorOutput += "\n[Process lost on restart]";
-          task.endTime = Date.now();
-          task.exitCode = null;
-        }
-        this.tasks.set(id, task);
-      }
-      this.debug("system", `Loaded ${this.tasks.size} tasks from disk`);
-    } catch (error45) {
-      this.debug(
-        "system",
-        `Failed to load tasks: ${error45 instanceof Error ? error45.message : String(error45)}`
-      );
-    }
+    return `${ID_PREFIX.JOB}${randomBytes(4).toString("hex")}`;
   }
-  /**
-   * Save tasks to disk
-   */
-  saveToDisk() {
-    this.ensureStorageDir();
-    try {
-      const tasksData = {};
-      for (const [id, task] of this.tasks.entries()) {
-        tasksData[id] = task;
-      }
-      writeFileSync(
-        this.storageFile,
-        JSON.stringify(tasksData, null, 2),
-        "utf-8"
-      );
-    } catch (error45) {
-      this.debug(
-        "system",
-        `Failed to save tasks: ${error45 instanceof Error ? error45.message : String(error45)}`
-      );
+  debug(taskId, message) {
+    if (this.debugMode) {
+      const ts = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+      console.log(`[BG ${ts}] ${taskId}: ${message}`);
     }
   }
-  /**
-   * Start periodic monitoring of running processes
-   */
-  startMonitoring() {
-    const MONITOR_INTERVAL_MS = 5e3;
-    this.monitoringInterval = setInterval(() => {
-      this.monitorRunningProcesses();
-    }, MONITOR_INTERVAL_MS);
-    if (this.monitoringInterval) {
-      this.monitoringInterval.unref();
-    }
-  }
-  /**
-   * Stop monitoring
-   */
-  stopMonitoring() {
-    if (this.monitoringInterval) {
-      clearInterval(this.monitoringInterval);
-      this.monitoringInterval = void 0;
-    }
-  }
-  /**
-   * Monitor running processes and detect zombie processes
-   */
-  monitorRunningProcesses() {
-    const now = Date.now();
-    let hasRunningTasks = false;
-    for (const [id, task] of this.tasks.entries()) {
-      if (task.status !== "running") continue;
-      hasRunningTasks = true;
-      if (task.process && task.process.pid) {
-        const pid = task.process.pid;
-        try {
-          process.kill(pid, 0);
-        } catch (error45) {
-          task.status = "error";
-          task.errorOutput += `
-Process disappeared (PID ${pid})`;
-          task.endTime = Date.now();
-          task.exitCode = null;
-          task.process = void 0;
-          this.saveToDisk();
-          this.debug(id, `Process dead (PID ${pid}), marked as error`);
-        }
-      } else if (task.process) {
-        task.status = "error";
-        task.errorOutput += "\nProcess reference lost";
-        task.endTime = Date.now();
-        task.exitCode = null;
-        this.saveToDisk();
-        this.debug(id, "Process reference lost, marked as error");
-      }
-    }
-    if (!hasRunningTasks && this.monitoringInterval) {
-      this.stopMonitoring();
-    }
-  }
-  /**
-   * Debug logging helper
-   */
-  debug(taskId, message) {
-    if (this.debugMode) {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
-      console.log(`[BG-DEBUG ${timestamp}] ${taskId}: ${message}`);
-    }
-  }
-  /**
-   * Run a command in the background
-   */
   run(options) {
     const id = this.generateId();
     const { command, cwd = process.cwd(), timeout = 3e5, label } = options;
@@ -14182,8 +13372,7 @@ Process disappeared (PID ${pid})`;
       timeout
     };
     this.tasks.set(id, task);
-    this.saveToDisk();
-    this.debug(id, `Starting: ${command} (cwd: ${cwd})`);
+    this.debug(id, `Starting: ${command}`);
     try {
       const proc = spawn2(shell, task.args, {
         cwd,
@@ -14192,29 +13381,17 @@ Process disappeared (PID ${pid})`;
       });
       task.process = proc;
       proc.stdout?.on("data", (data) => {
-        const text = data.toString();
-        task.output += text;
-        this.debug(
-          id,
-          `stdout: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`
-        );
+        task.output += data.toString();
       });
       proc.stderr?.on("data", (data) => {
-        const text = data.toString();
-        task.errorOutput += text;
-        this.debug(
-          id,
-          `stderr: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`
-        );
+        task.errorOutput += data.toString();
       });
       proc.on("close", (code) => {
         task.exitCode = code;
         task.endTime = Date.now();
         task.status = code === 0 ? "done" : "error";
         task.process = void 0;
-        this.saveToDisk();
-        const duration3 = ((task.endTime - task.startTime) / 1e3).toFixed(2);
-        this.debug(id, `Completed with code ${code} in ${duration3}s`);
+        this.debug(id, `Done (code=${code})`);
       });
       proc.on("error", (err) => {
         task.status = "error";
@@ -14222,68 +13399,31 @@ Process disappeared (PID ${pid})`;
 Process error: ${err.message}`;
         task.endTime = Date.now();
         task.process = void 0;
-        this.saveToDisk();
-        this.debug(id, `Error: ${err.message}`);
       });
       setTimeout(() => {
         if (task.status === "running" && task.process) {
-          this.debug(id, `Timeout after ${timeout}ms, killing process`);
           task.process.kill("SIGKILL");
           task.status = "timeout";
           task.endTime = Date.now();
-          task.errorOutput += `
-Process killed: timeout after ${timeout}ms`;
-          this.saveToDisk();
+          this.debug(id, "Timeout");
         }
       }, timeout);
     } catch (err) {
       task.status = "error";
-      task.errorOutput = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
+      task.errorOutput = `Spawn failed: ${err instanceof Error ? err.message : String(err)}`;
       task.endTime = Date.now();
-      this.saveToDisk();
-      this.debug(id, `Spawn failed: ${task.errorOutput}`);
     }
     return task;
   }
-  /**
-   * Get task by ID
-   */
   get(taskId) {
     return this.tasks.get(taskId);
   }
-  /**
-   * Get all tasks
-   */
   getAll() {
     return Array.from(this.tasks.values());
   }
-  /**
-   * Get tasks by status
-   */
   getByStatus(status) {
     return this.getAll().filter((t) => t.status === status);
   }
-  /**
-   * Clean up tasks by session ID
-   */
-  cleanupBySession(sessionID) {
-    let count = 0;
-    for (const [id, task] of this.tasks) {
-      if (task.sessionID === sessionID) {
-        if (task.process && task.status === "running") {
-          task.process.kill("SIGKILL");
-        }
-        this.tasks.delete(id);
-        count++;
-        this.debug(id, `Cleaned up for session ${sessionID}`);
-      }
-    }
-    this.saveToDisk();
-    return count;
-  }
-  /**
-   * Clear completed/failed tasks
-   */
   clearCompleted() {
     let count = 0;
     for (const [id, task] of this.tasks) {
@@ -14292,12 +13432,8 @@ Process killed: timeout after ${timeout}ms`;
         count++;
       }
     }
-    this.saveToDisk();
     return count;
   }
-  /**
-   * Kill a running task
-   */
   kill(taskId) {
     const task = this.tasks.get(taskId);
     if (task?.process) {
@@ -14305,116 +13441,60 @@ Process killed: timeout after ${timeout}ms`;
       task.status = "error";
       task.errorOutput += "\nKilled by user";
       task.endTime = Date.now();
-      this.saveToDisk();
-      this.debug(taskId, "Killed by user");
       return true;
     }
     return false;
   }
-  /**
-   * Format duration for display
-   */
   formatDuration(task) {
     const end = task.endTime || Date.now();
     const seconds = (end - task.startTime) / 1e3;
-    if (seconds < 60) {
-      return `${seconds.toFixed(1)}s`;
-    }
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+    if (seconds < 60) return `${seconds.toFixed(1)}s`;
+    return `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(0)}s`;
   }
-  /**
-   * Get status emoji
-   */
   getStatusEmoji(status) {
-    switch (status) {
-      case "pending":
-        return "\u23F8\uFE0F";
-      case "running":
-        return "\u23F3";
-      case "done":
-        return "\u2705";
-      case "error":
-        return "\u274C";
-      case "timeout":
-        return "\u23F0";
-      default:
-        return "\u2753";
-    }
+    return getStatusEmoji(status);
   }
 };
 var backgroundTaskManager = BackgroundTaskManager.instance;
 
-// src/tools/background.ts
+// src/tools/background-cmd/run.ts
 var runBackgroundTool = tool({
   description: `Run a shell command in the background and get a task ID.
 
 <purpose>
-Execute long-running commands (builds, tests, etc.) without blocking.
-The command runs asynchronously - use check_background to get results.
-</purpose>
-
-<examples>
-- "npm run build" \u2192 Build project in background
-- "cargo test" \u2192 Run Rust tests
-- "sleep 10 && echo done" \u2192 Delayed execution
-</examples>
-
-<flow>
-1. Call run_background with command
-2. Get task ID immediately (e.g., job_a1b2c3d4)
-3. Continue other work
-4. Call check_background with task ID to get results
-</flow>`,
+Execute long-running commands (builds, tests) without blocking.
+Use check_background to get results.
+</purpose>`,
   args: {
     command: tool.schema.string().describe("Shell command to execute"),
-    cwd: tool.schema.string().optional().describe("Working directory (default: project root)"),
-    timeout: tool.schema.number().optional().describe("Timeout in milliseconds (default: 300000 = 5 min)"),
-    label: tool.schema.string().optional().describe("Human-readable label for this task"),
-    sessionID: tool.schema.string().optional().describe("Session ID for automatic cleanup on session deletion")
+    cwd: tool.schema.string().optional().describe("Working directory"),
+    timeout: tool.schema.number().optional().describe("Timeout in ms (default: 300000)"),
+    label: tool.schema.string().optional().describe("Task label")
   },
   async execute(args) {
-    const { command, cwd, timeout, label, sessionID } = args;
+    const { command, cwd, timeout, label } = args;
     const task = backgroundTaskManager.run({
       command,
       cwd: cwd || process.cwd(),
       timeout: timeout || 3e5,
-      label,
-      sessionID
+      label
     });
     const displayLabel = label ? ` (${label})` : "";
     return `\u{1F680} **Background Task Started**${displayLabel}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${task.id}\` |
-| **Command** | \`${command}\` |
-| **Status** | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
-| **Working Dir** | ${task.cwd} |
-| **Timeout** | ${(task.timeout / 1e3).toFixed(0)}s |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+| Task ID | \`${task.id}\` |
+| Command | \`${command}\` |
+| Status | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
 
-\u{1F4CC} **Next Step**: Use \`check_background\` with task ID \`${task.id}\` to get results.`;
+\u{1F4CC} Use \`check_background({ taskId: "${task.id}" })\` to get results.`;
   }
 });
-var checkBackgroundTool = tool({
-  description: `Check the status and output of a background task.
-
-<purpose>
-Retrieve the current status and output of a previously started background task.
-Use this after run_background to get results.
-</purpose>
 
-<output_includes>
-- Status: running/done/error/timeout
-- Exit code (if completed)
-- Duration
-- Full output (stdout + stderr)
-</output_includes>`,
+// src/tools/background-cmd/check.ts
+var checkBackgroundTool = tool({
+  description: `Check the status and output of a background task.`,
   args: {
-    taskId: tool.schema.string().describe("Task ID from run_background (e.g., job_a1b2c3d4)"),
-    tailLines: tool.schema.number().optional().describe("Limit output to last N lines (default: show all)")
+    taskId: tool.schema.string().describe("Task ID from run_background"),
+    tailLines: tool.schema.number().optional().describe("Limit output to last N lines")
   },
   async execute(args) {
     const { taskId, tailLines } = args;
@@ -14427,7 +13507,7 @@ Use this after run_background to get results.
       const taskList = allTasks.map((t) => `- \`${t.id}\`: ${t.command.substring(0, 30)}...`).join("\n");
       return `\u274C Task \`${taskId}\` not found.
 
-**Available tasks:**
+**Available:**
 ${taskList}`;
     }
     const duration3 = backgroundTaskManager.formatDuration(task);
@@ -14435,64 +13515,41 @@ ${taskList}`;
     let output = task.output;
     let stderr = task.errorOutput;
     if (tailLines && tailLines > 0) {
-      const outputLines = output.split("\n");
-      const stderrLines = stderr.split("\n");
-      output = outputLines.slice(-tailLines).join("\n");
-      stderr = stderrLines.slice(-tailLines).join("\n");
+      output = output.split("\n").slice(-tailLines).join("\n");
+      stderr = stderr.split("\n").slice(-tailLines).join("\n");
     }
     const maxLen = 1e4;
-    if (output.length > maxLen) {
-      output = `[...truncated ${output.length - maxLen} chars...]
-` + output.substring(output.length - maxLen);
-    }
-    if (stderr.length > maxLen) {
-      stderr = `[...truncated ${stderr.length - maxLen} chars...]
-` + stderr.substring(stderr.length - maxLen);
-    }
-    const labelDisplay = task.label ? ` (${task.label})` : "";
-    let result = `${statusEmoji} **Task ${task.id}**${labelDisplay}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| Property | Value |
-|----------|-------|
-| **Command** | \`${task.command}\` |
-| **Status** | ${statusEmoji} **${task.status.toUpperCase()}** |
-| **Duration** | ${duration3}${task.status === "running" ? " (ongoing)" : ""} |
-${task.exitCode !== null ? `| **Exit Code** | ${task.exitCode} |` : ""}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
-    if (output.trim()) {
-      result += `
-
-\u{1F4E4} **Output (stdout)**:
+    if (output.length > maxLen) output = `[...truncated...]\\n` + output.slice(-maxLen);
+    if (stderr.length > maxLen) stderr = `[...truncated...]\\n` + stderr.slice(-maxLen);
+    let result = `${statusEmoji} **Task ${task.id}**${task.label ? ` (${task.label})` : ""}
+| Command | \`${task.command}\` |
+| Status | ${statusEmoji} **${task.status.toUpperCase()}** |
+| Duration | ${duration3}${task.status === "running" ? " (ongoing)" : ""} |
+${task.exitCode !== null ? `| Exit Code | ${task.exitCode} |` : ""}`;
+    if (output.trim()) result += `
+
+\u{1F4E4} **stdout:**
 \`\`\`
 ${output.trim()}
 \`\`\``;
-    }
-    if (stderr.trim()) {
-      result += `
+    if (stderr.trim()) result += `
 
-\u26A0\uFE0F **Errors (stderr)**:
+\u26A0\uFE0F **stderr:**
 \`\`\`
 ${stderr.trim()}
 \`\`\``;
-    }
-    if (task.status === "running") {
-      result += `
+    if (task.status === "running") result += `
 
-\u23F3 Task still running... Check again later with:
-\`check_background({ taskId: "${task.id}" })\``;
-    }
+\u23F3 Still running... check again.`;
     return result;
   }
 });
-var listBackgroundTool = tool({
-  description: `List all background tasks and their current status.
 
-<purpose>
-Get an overview of all running and completed background tasks.
-Useful to check what's in progress before starting new tasks.
-</purpose>`,
+// src/tools/background-cmd/list.ts
+var listBackgroundTool = tool({
+  description: `List all background tasks and their status.`,
   args: {
-    status: tool.schema.enum(["all", "running", "done", "error"]).optional().describe("Filter by status (default: all)")
+    status: tool.schema.enum(["all", "running", "done", "error"]).optional().describe("Filter by status")
   },
   async execute(args) {
     const { status = "all" } = args;
@@ -14503,344 +13560,102 @@ Useful to check what's in progress before starting new tasks.
       tasks = backgroundTaskManager.getByStatus(status);
     }
     if (tasks.length === 0) {
-      return `\u{1F4CB} **No background tasks** ${status !== "all" ? `with status "${status}"` : ""}
-
-Use \`run_background\` to start a new background task.`;
+      return `\u{1F4CB} No background tasks${status !== "all" ? ` with status "${status}"` : ""}`;
     }
     tasks.sort((a, b) => b.startTime - a.startTime);
-    const rows = tasks.map((task) => {
-      const emoji3 = backgroundTaskManager.getStatusEmoji(task.status);
-      const duration3 = backgroundTaskManager.formatDuration(task);
-      const cmdShort = task.command.length > 25 ? task.command.substring(0, 22) + "..." : task.command;
-      const labelPart = task.label ? ` [${task.label}]` : "";
-      return `| \`${task.id}\` | ${emoji3} ${task.status.padEnd(7)} | ${cmdShort.padEnd(25)}${labelPart} | ${duration3.padStart(8)} |`;
+    const rows = tasks.map((t) => {
+      const emoji3 = backgroundTaskManager.getStatusEmoji(t.status);
+      const cmd = t.command.length > 25 ? t.command.slice(0, 22) + "..." : t.command;
+      const label = t.label ? ` [${t.label}]` : "";
+      return `| \`${t.id}\` | ${emoji3} ${t.status} | ${cmd}${label} | ${backgroundTaskManager.formatDuration(t)} |`;
     }).join("\n");
-    const runningCount = tasks.filter((t) => t.status === "running").length;
-    const doneCount = tasks.filter((t) => t.status === "done").length;
-    const errorCount = tasks.filter((t) => t.status === "error" || t.status === "timeout").length;
-    return `\u{1F4CB} **Background Tasks** (${tasks.length} total)
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| \u23F3 Running: ${runningCount} | \u2705 Done: ${doneCount} | \u274C Error/Timeout: ${errorCount} |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+    const running = tasks.filter((t) => t.status === "running").length;
+    const done = tasks.filter((t) => t.status === "done").length;
+    const error45 = tasks.filter((t) => t.status === "error" || t.status === "timeout").length;
+    return `\u{1F4CB} **Background Tasks** (${tasks.length})
+\u23F3 Running: ${running} | \u2705 Done: ${done} | \u274C Error: ${error45}
 
-| Task ID | Status | Command | Duration |
-|---------|--------|---------|----------|
-${rows}
-
-\u{1F4A1} Use \`check_background({ taskId: "job_xxxxx" })\` to see full output.`;
+| ID | Status | Command | Duration |
+|----|--------|---------|----------|
+${rows}`;
   }
 });
-var killBackgroundTool = tool({
-  description: `Kill a running background task.
 
-<purpose>
-Stop a background task that is taking too long or no longer needed.
-</purpose>`,
+// src/tools/background-cmd/kill.ts
+var killBackgroundTool = tool({
+  description: `Kill a running background task.`,
   args: {
-    taskId: tool.schema.string().describe("Task ID to kill (e.g., job_a1b2c3d4)")
+    taskId: tool.schema.string().describe("Task ID to kill")
   },
   async execute(args) {
     const { taskId } = args;
     const task = backgroundTaskManager.get(taskId);
-    if (!task) {
-      return `\u274C Task \`${taskId}\` not found.`;
-    }
-    if (task.status !== "running") {
-      return `\u26A0\uFE0F Task \`${taskId}\` is not running (status: ${task.status}).`;
-    }
+    if (!task) return `\u274C Task \`${taskId}\` not found.`;
+    if (task.status !== "running") return `\u26A0\uFE0F Task \`${taskId}\` is not running (${task.status}).`;
     const killed = backgroundTaskManager.kill(taskId);
     if (killed) {
-      return `\u{1F6D1} Task \`${taskId}\` has been killed.
+      return `\u{1F6D1} Task \`${taskId}\` killed.
 Command: \`${task.command}\`
-Duration before kill: ${backgroundTaskManager.formatDuration(task)}`;
+Duration: ${backgroundTaskManager.formatDuration(task)}`;
     }
-    return `\u26A0\uFE0F Could not kill task \`${taskId}\`. It may have already finished.`;
+    return `\u26A0\uFE0F Could not kill task \`${taskId}\`.`;
   }
 });
 
-// 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
+// src/core/agents/concurrency.ts
+var DEBUG = process.env.DEBUG_PARALLEL_AGENT === "true";
+var log = (...args) => {
+  if (DEBUG) console.log("[concurrency]", ...args);
 };
-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
-      )
-    };
+var ConcurrencyController = class {
+  counts = /* @__PURE__ */ new Map();
+  queues = /* @__PURE__ */ new Map();
+  limits = /* @__PURE__ */ new Map();
+  config;
+  constructor(config2) {
+    this.config = config2 ?? {};
   }
-  getSessionConfig() {
-    return this.sessionConfig;
+  setLimit(key, limit) {
+    this.limits.set(key, limit);
   }
-  // ------------------------------------------------------------------------
-  // Runtime Updates (Dynamic Configuration)
-  // ------------------------------------------------------------------------
   /**
-   * Update configuration at runtime
-   * Useful for adaptive behavior or user preferences
+   * Get concurrency limit for a key.
+   * Priority: explicit limit > model > provider > agent > default
    */
-  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;
+  getConcurrencyLimit(key) {
+    const explicitLimit = this.limits.get(key);
+    if (explicitLimit !== void 0) {
+      return explicitLimit === 0 ? Infinity : explicitLimit;
     }
-    if (maxCompletedTasksToKeep < 0) {
-      console.warn("[Config] MAX_COMPLETED_TASKS must be >= 0, using 0");
-      this.backgroundTaskConfig.maxCompletedTasksToKeep = 0;
+    if (this.config.modelConcurrency?.[key] !== void 0) {
+      const limit = this.config.modelConcurrency[key];
+      return limit === 0 ? Infinity : limit;
     }
-  }
-  validateSessionConfig() {
-    const { defaultMaxSteps, taskCommandMaxSteps } = this.sessionConfig;
-    if (defaultMaxSteps < 1) {
-      console.warn("[Config] DEFAULT_MAX_STEPS must be >= 1, using 1");
-      this.sessionConfig.defaultMaxSteps = 1;
+    const provider = key.split("/")[0];
+    if (this.config.providerConcurrency?.[provider] !== void 0) {
+      const limit = this.config.providerConcurrency[provider];
+      return limit === 0 ? Infinity : limit;
     }
-    if (taskCommandMaxSteps < defaultMaxSteps) {
-      console.warn("[Config] TASK_MAX_STEPS should be >= DEFAULT_MAX_STEPS");
-      this.sessionConfig.taskCommandMaxSteps = defaultMaxSteps;
+    if (this.config.agentConcurrency?.[key] !== void 0) {
+      const limit = this.config.agentConcurrency[key];
+      return limit === 0 ? Infinity : limit;
     }
+    return this.config.defaultConcurrency ?? PARALLEL_TASK.DEFAULT_CONCURRENCY;
   }
-  // ------------------------------------------------------------------------
-  // 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);
-};
-var ConcurrencyController = class {
-  counts = /* @__PURE__ */ new Map();
-  queues = /* @__PURE__ */ new Map();
-  limits = /* @__PURE__ */ new Map();
-  setLimit(key, limit) {
-    const cappedLimit = Math.min(limit, MAX_CONCURRENCY);
-    this.limits.set(key, cappedLimit);
-    log(`Set limit for ${key}: ${cappedLimit}`);
-  }
+  // Backwards compatible alias
   getLimit(key) {
-    return this.limits.get(key) ?? DEFAULT_CONCURRENCY;
+    return this.getConcurrencyLimit(key);
   }
   async acquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === 0) return;
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return;
     const current = this.counts.get(key) ?? 0;
     if (current < limit) {
       this.counts.set(key, current + 1);
-      log(`Acquired slot for ${key}: ${current + 1}/${limit}`);
+      log(`Acquired ${key}: ${current + 1}/${limit}`);
       return;
     }
-    log(`Queueing for ${key}: ${current}/${limit} (waiting...)`);
+    log(`Queueing ${key}: ${current}/${limit}`);
     return new Promise((resolve) => {
       const queue = this.queues.get(key) ?? [];
       queue.push(resolve);
@@ -14848,97 +13663,196 @@ var ConcurrencyController = class {
     });
   }
   release(key) {
-    const limit = this.getLimit(key);
-    if (limit === 0) return;
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return;
     const queue = this.queues.get(key);
     if (queue && queue.length > 0) {
       const next = queue.shift();
-      log(`Released slot for ${key}: next in queue`);
+      log(`Released ${key}: next in queue`);
       next();
     } else {
       const current = this.counts.get(key) ?? 0;
       if (current > 0) {
         this.counts.set(key, current - 1);
-        log(`Released slot for ${key}: ${current - 1}`);
+        log(`Released ${key}: ${current - 1}/${limit}`);
       }
     }
   }
   getQueueLength(key) {
     return this.queues.get(key)?.length ?? 0;
   }
-  updateConcurrency(agentType, newLimit) {
-    this.setLimit(agentType, newLimit);
-    log(`Updated concurrency for ${agentType}: ${newLimit}`);
+  getActiveCount(key) {
+    return this.counts.get(key) ?? 0;
   }
-  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;
+  /**
+   * Get formatted concurrency info string (e.g., "2/5 slots")
+   */
+  getConcurrencyInfo(key) {
+    const active = this.getActiveCount(key);
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return "";
+    return ` (${active}/${limit} slots)`;
   }
 };
-var ParallelAgentManager = class _ParallelAgentManager {
-  static _instance;
-  // Core state
+
+// src/core/agents/task-store.ts
+var TaskStore = class {
   tasks = /* @__PURE__ */ new Map();
   pendingByParent = /* @__PURE__ */ new Map();
   notifications = /* @__PURE__ */ new Map();
-  // Dependencies
+  set(id, task) {
+    this.tasks.set(id, task);
+  }
+  get(id) {
+    return this.tasks.get(id);
+  }
+  getAll() {
+    return Array.from(this.tasks.values());
+  }
+  getRunning() {
+    return this.getAll().filter((t) => t.status === "running");
+  }
+  getByParent(parentSessionID) {
+    return this.getAll().filter((t) => t.parentSessionID === parentSessionID);
+  }
+  delete(id) {
+    return this.tasks.delete(id);
+  }
+  clear() {
+    this.tasks.clear();
+    this.pendingByParent.clear();
+    this.notifications.clear();
+  }
+  // Pending tracking
+  trackPending(parentSessionID, taskId) {
+    const pending = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
+    pending.add(taskId);
+    this.pendingByParent.set(parentSessionID, pending);
+  }
+  untrackPending(parentSessionID, taskId) {
+    const pending = this.pendingByParent.get(parentSessionID);
+    if (pending) {
+      pending.delete(taskId);
+      if (pending.size === 0) {
+        this.pendingByParent.delete(parentSessionID);
+      }
+    }
+  }
+  getPendingCount(parentSessionID) {
+    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
+  }
+  hasPending(parentSessionID) {
+    return this.getPendingCount(parentSessionID) > 0;
+  }
+  // Notifications
+  queueNotification(task) {
+    const queue = this.notifications.get(task.parentSessionID) ?? [];
+    queue.push(task);
+    this.notifications.set(task.parentSessionID, queue);
+  }
+  getNotifications(parentSessionID) {
+    return this.notifications.get(parentSessionID) ?? [];
+  }
+  clearNotifications(parentSessionID) {
+    this.notifications.delete(parentSessionID);
+  }
+  cleanEmptyNotifications() {
+    for (const [sessionID, queue] of this.notifications.entries()) {
+      if (queue.length === 0) {
+        this.notifications.delete(sessionID);
+      }
+    }
+  }
+  /**
+   * Remove a specific task from all notification queues
+   */
+  clearNotificationsForTask(taskId) {
+    for (const [sessionID, tasks] of this.notifications.entries()) {
+      const filtered = tasks.filter((t) => t.id !== taskId);
+      if (filtered.length === 0) {
+        this.notifications.delete(sessionID);
+      } else if (filtered.length !== tasks.length) {
+        this.notifications.set(sessionID, filtered);
+      }
+    }
+  }
+};
+
+// src/core/agents/config.ts
+var CONFIG = {
+  TASK_TTL_MS: PARALLEL_TASK.TTL_MS,
+  CLEANUP_DELAY_MS: PARALLEL_TASK.CLEANUP_DELAY_MS,
+  MIN_STABILITY_MS: PARALLEL_TASK.MIN_STABILITY_MS,
+  POLL_INTERVAL_MS: PARALLEL_TASK.POLL_INTERVAL_MS
+};
+
+// src/core/agents/logger.ts
+var DEBUG2 = process.env.DEBUG_PARALLEL_AGENT === "true";
+function log2(...args) {
+  if (DEBUG2) console.log("[parallel-agent]", ...args);
+}
+
+// src/core/agents/format.ts
+function formatDuration(start, end) {
+  const duration3 = (end ?? /* @__PURE__ */ new Date()).getTime() - start.getTime();
+  const seconds = Math.floor(duration3 / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function buildNotificationMessage(tasks) {
+  const summary = tasks.map((t) => {
+    const status = t.status === "completed" ? "\u2705" : "\u274C";
+    return `${status} \`${t.id}\`: ${t.description}`;
+  }).join("\n");
+  return `<system-notification>
+**All Parallel Tasks Complete**
+
+${summary}
+
+Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve results.
+</system-notification>`;
+}
+
+// src/core/agents/manager.ts
+var ParallelAgentManager = class _ParallelAgentManager {
+  static _instance;
+  store = new TaskStore();
   client;
   directory;
-  concurrency;
-  // Polling
+  concurrency = new ConcurrencyController();
   pollingInterval;
   constructor(client, directory) {
     this.client = client;
     this.directory = directory;
-    this.concurrency = new ConcurrencyController();
   }
   static getInstance(client, directory) {
     if (!_ParallelAgentManager._instance) {
       if (!client || !directory) {
-        throw new Error(
-          "ParallelAgentManager requires client and directory on first call"
-        );
+        throw new Error("ParallelAgentManager requires client and directory on first call");
       }
-      _ParallelAgentManager._instance = new _ParallelAgentManager(
-        client,
-        directory
-      );
+      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
     }
     return _ParallelAgentManager._instance;
   }
   // ========================================================================
   // Public API
   // ========================================================================
-  /**
-   * Launch an agent in a new session (async, non-blocking)
-   */
   async launch(input) {
     const concurrencyKey = input.agent;
     await this.concurrency.acquire(concurrencyKey);
     this.pruneExpiredTasks();
     try {
       const createResult = await this.client.session.create({
-        body: {
-          parentID: input.parentSessionID,
-          title: `Parallel: ${input.description}`
-        },
-        query: {
-          directory: this.directory
-        }
+        body: { parentID: input.parentSessionID, title: `Parallel: ${input.description}` },
+        query: { directory: this.directory }
       });
       if (createResult.error) {
         this.concurrency.release(concurrencyKey);
         throw new Error(`Failed to create session: ${createResult.error}`);
       }
       const sessionID = createResult.data.id;
-      const taskId = `task_${crypto.randomUUID().slice(0, 8)}`;
+      const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
       const task = {
         id: taskId,
         sessionID,
@@ -14949,191 +13863,172 @@ var ParallelAgentManager = class _ParallelAgentManager {
         startedAt: /* @__PURE__ */ new Date(),
         concurrencyKey
       };
-      this.tasks.set(taskId, task);
-      this.trackPending(input.parentSessionID, taskId);
+      this.store.set(taskId, task);
+      this.store.trackPending(input.parentSessionID, taskId);
       this.startPolling();
       this.client.session.prompt({
         path: { id: sessionID },
-        body: {
-          agent: input.agent,
-          parts: [{ type: "text", text: input.prompt }]
-        }
+        body: { agent: input.agent, parts: [{ type: "text", text: input.prompt }] }
       }).catch((error45) => {
-        log(`Prompt error for ${taskId}:`, error45);
+        log2(`Prompt error for ${taskId}:`, error45);
         this.handleTaskError(taskId, error45);
       });
-      log(`Launched ${taskId} in session ${sessionID}`);
+      log2(`Launched ${taskId} in session ${sessionID}`);
       return task;
     } catch (error45) {
       this.concurrency.release(concurrencyKey);
       throw error45;
     }
   }
-  /**
-   * Get task by ID
-   */
   getTask(id) {
-    return this.tasks.get(id);
+    return this.store.get(id);
   }
-  /**
-   * Get all running tasks
-   */
   getRunningTasks() {
-    return Array.from(this.tasks.values()).filter(
-      (t) => t.status === "running"
-    );
+    return this.store.getRunning();
   }
-  /**
-   * Get all tasks
-   */
   getAllTasks() {
-    return Array.from(this.tasks.values());
+    return this.store.getAll();
   }
-  /**
-   * Get tasks by parent session
-   */
   getTasksByParent(parentSessionID) {
-    return Array.from(this.tasks.values()).filter(
-      (t) => t.parentSessionID === parentSessionID
-    );
+    return this.store.getByParent(parentSessionID);
   }
-  /**
-   * Cancel a running task
-   */
   async cancelTask(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task || task.status !== "running") {
-      return false;
-    }
+    const task = this.store.get(taskId);
+    if (!task || task.status !== "running") return false;
     task.status = "error";
     task.error = "Cancelled by user";
     task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-    }
-    this.untrackPending(task.parentSessionID, taskId);
+    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+    this.store.untrackPending(task.parentSessionID, taskId);
     try {
-      await this.client.session.delete({
-        path: { id: task.sessionID }
-      });
-      console.log(
-        `[parallel] \u{1F5D1}\uFE0F Session ${task.sessionID.slice(0, 8)}... deleted`
-      );
+      await this.client.session.delete({ path: { id: task.sessionID } });
+      log2(`Session ${task.sessionID.slice(0, 8)}... deleted`);
     } catch {
-      console.log(
-        `[parallel] \u{1F5D1}\uFE0F Session ${task.sessionID.slice(0, 8)}... already gone`
-      );
+      log2(`Session ${task.sessionID.slice(0, 8)}... already gone`);
     }
     this.scheduleCleanup(taskId);
-    console.log(`[parallel] \u{1F6D1} CANCELLED ${taskId}`);
-    log(`Cancelled ${taskId}`);
+    log2(`Cancelled ${taskId}`);
     return true;
   }
-  /**
-   * Get result from completed task
-   */
   async getResult(taskId) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     if (!task) return null;
     if (task.result) return task.result;
     if (task.status === "error") return `Error: ${task.error}`;
     if (task.status === "running") return null;
     try {
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionID }
-      });
-      if (messagesResult.error) {
-        return `Error: ${messagesResult.error}`;
-      }
-      const messages = messagesResult.data ?? [];
-      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant").reverse();
-      const lastMsg = assistantMsgs[0];
+      const result = await this.client.session.messages({ path: { id: task.sessionID } });
+      if (result.error) return `Error: ${result.error}`;
+      const messages = result.data ?? [];
+      const lastMsg = messages.filter((m) => m.info?.role === "assistant").reverse()[0];
       if (!lastMsg) return "(No response)";
-      const textParts = lastMsg.parts?.filter(
-        (p) => p.type === "text" || p.type === "reasoning"
-      ) ?? [];
-      const result = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n");
-      task.result = result;
-      return result;
+      const text = lastMsg.parts?.filter((p) => p.type === "text" || p.type === "reasoning").map((p) => p.text ?? "").filter(Boolean).join("\n") ?? "";
+      task.result = text;
+      return text;
     } catch (error45) {
       return `Error: ${error45 instanceof Error ? error45.message : String(error45)}`;
     }
   }
-  /**
-    * 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
-   */
   getPendingCount(parentSessionID) {
-    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
+    return this.store.getPendingCount(parentSessionID);
   }
-  /**
-   * Cleanup all state
-   */
   cleanup() {
     this.stopPolling();
-    this.tasks.clear();
-    this.pendingByParent.clear();
-    this.notifications.clear();
+    this.store.clear();
   }
+  formatDuration = formatDuration;
   // ========================================================================
-  // Internal: Tracking
+  // Event Handling (from OpenCode hooks)
   // ========================================================================
-  trackPending(parentSessionID, taskId) {
-    const pending = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
-    pending.add(taskId);
-    this.pendingByParent.set(parentSessionID, pending);
-  }
-  untrackPending(parentSessionID, taskId) {
-    const pending = this.pendingByParent.get(parentSessionID);
-    if (pending) {
-      pending.delete(taskId);
-      if (pending.size === 0) {
-        this.pendingByParent.delete(parentSessionID);
+  /**
+   * Handle OpenCode session events for proper resource cleanup.
+   * Call this from your plugin's event hook.
+   */
+  handleEvent(event) {
+    const props = event.properties;
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== "running") return;
+      this.handleSessionIdle(task).catch((err) => {
+        log2("Error handling session.idle:", err);
+      });
+    }
+    if (event.type === "session.deleted") {
+      const sessionID = props?.info?.id ?? props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task) return;
+      log2(`Session deleted event for task ${task.id}`);
+      if (task.status === "running") {
+        task.status = "error";
+        task.error = "Session deleted";
+        task.completedAt = /* @__PURE__ */ new Date();
       }
+      if (task.concurrencyKey) {
+        this.concurrency.release(task.concurrencyKey);
+        task.concurrencyKey = void 0;
+      }
+      this.store.untrackPending(task.parentSessionID, task.id);
+      this.store.clearNotificationsForTask(task.id);
+      this.store.delete(task.id);
+      log2(`Cleaned up deleted session task: ${task.id}`);
     }
   }
+  /**
+   * Find task by session ID
+   */
+  findBySession(sessionID) {
+    return this.store.getAll().find((t) => t.sessionID === sessionID);
+  }
+  /**
+   * Handle session.idle event - validate and complete task
+   */
+  async handleSessionIdle(task) {
+    const elapsed = Date.now() - task.startedAt.getTime();
+    if (elapsed < CONFIG.MIN_STABILITY_MS) {
+      log2(`Session idle but too early for ${task.id}, waiting...`);
+      return;
+    }
+    const hasOutput = await this.validateSessionHasOutput(task.sessionID);
+    if (!hasOutput) {
+      log2(`Session idle but no output for ${task.id}, waiting...`);
+      return;
+    }
+    task.status = "completed";
+    task.completedAt = /* @__PURE__ */ new Date();
+    if (task.concurrencyKey) {
+      this.concurrency.release(task.concurrencyKey);
+      task.concurrencyKey = void 0;
+    }
+    this.store.untrackPending(task.parentSessionID, task.id);
+    this.store.queueNotification(task);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+    this.scheduleCleanup(task.id);
+    log2(`Task ${task.id} completed via session.idle event (${formatDuration(task.startedAt, task.completedAt)})`);
+  }
   // ========================================================================
-  // Internal: Error Handling
+  // Internal
   // ========================================================================
   handleTaskError(taskId, error45) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     if (!task) return;
     task.status = "error";
     task.error = error45 instanceof Error ? error45.message : String(error45);
     task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-    }
-    this.untrackPending(task.parentSessionID, taskId);
-    this.queueNotification(task);
+    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+    this.store.untrackPending(task.parentSessionID, taskId);
+    this.store.queueNotification(task);
     this.notifyParentIfAllComplete(task.parentSessionID);
     this.scheduleCleanup(taskId);
   }
-  // ========================================================================
-  // Internal: Polling
-  // ========================================================================
   startPolling() {
     if (this.pollingInterval) return;
-    this.pollingInterval = setInterval(() => {
-      this.pollRunningTasks();
-    }, POLL_INTERVAL_MS);
+    this.pollingInterval = setInterval(() => this.pollRunningTasks(), CONFIG.POLL_INTERVAL_MS);
     this.pollingInterval.unref();
   }
   stopPolling() {
@@ -15144,1003 +14039,322 @@ var ParallelAgentManager = class _ParallelAgentManager {
   }
   async pollRunningTasks() {
     this.pruneExpiredTasks();
-    const runningTasks = this.getRunningTasks();
-    if (runningTasks.length === 0) {
+    const running = this.store.getRunning();
+    if (running.length === 0) {
       this.stopPolling();
       return;
     }
     try {
       const statusResult = await this.client.session.status();
       const allStatuses = statusResult.data ?? {};
-      for (const task of runningTasks) {
-        const sessionStatus = allStatuses[task.sessionID];
-        if (sessionStatus?.type === "idle") {
+      for (const task of running) {
+        try {
+          const sessionStatus = allStatuses[task.sessionID];
+          if (sessionStatus?.type === "idle") {
+            const elapsed2 = Date.now() - task.startedAt.getTime();
+            if (elapsed2 < CONFIG.MIN_STABILITY_MS) continue;
+            if (!await this.validateSessionHasOutput(task.sessionID)) continue;
+            await this.completeTask(task);
+            continue;
+          }
+          await this.updateTaskProgress(task);
           const elapsed = Date.now() - task.startedAt.getTime();
-          if (elapsed < MIN_STABILITY_MS2) continue;
-          const hasOutput = await this.validateSessionHasOutput(task.sessionID);
-          if (!hasOutput) continue;
-          task.status = "completed";
-          task.completedAt = /* @__PURE__ */ new Date();
-          if (task.concurrencyKey) {
-            this.concurrency.release(task.concurrencyKey);
+          if (elapsed >= CONFIG.MIN_STABILITY_MS && task.stablePolls && task.stablePolls >= 3) {
+            if (await this.validateSessionHasOutput(task.sessionID)) {
+              log2(`Task ${task.id} stable for 3 polls, completing...`);
+              await this.completeTask(task);
+            }
           }
-          this.untrackPending(task.parentSessionID, task.id);
-          this.queueNotification(task);
-          this.notifyParentIfAllComplete(task.parentSessionID);
-          this.scheduleCleanup(task.id);
-          const duration3 = this.formatDuration(
-            task.startedAt,
-            task.completedAt
-          );
-          console.log(
-            `[parallel] \u2705 COMPLETED ${task.id} \u2192 ${task.agent}: ${task.description} (${duration3})`
-          );
-          log(`Completed ${task.id}`);
+        } catch (error45) {
+          log2(`Poll error for task ${task.id}:`, error45);
         }
       }
     } catch (error45) {
-      log("Polling error:", error45);
+      log2("Polling error:", error45);
     }
   }
-  // ========================================================================
-  // Internal: Validation
-  // ========================================================================
+  /**
+   * Update task progress and stability tracking
+   */
+  async updateTaskProgress(task) {
+    try {
+      const result = await this.client.session.messages({ path: { id: task.sessionID } });
+      if (result.error) return;
+      const messages = result.data ?? [];
+      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
+      let toolCalls = 0;
+      let lastTool;
+      let lastMessage;
+      for (const msg of assistantMsgs) {
+        for (const part of msg.parts ?? []) {
+          if (part.type === "tool_use" || part.tool) {
+            toolCalls++;
+            lastTool = part.tool || part.name;
+          }
+          if (part.type === "text" && part.text) {
+            lastMessage = part.text;
+          }
+        }
+      }
+      task.progress = {
+        toolCalls,
+        lastTool,
+        lastMessage: lastMessage?.slice(0, 100),
+        lastUpdate: /* @__PURE__ */ new Date()
+      };
+      const currentMsgCount = messages.length;
+      if (task.lastMsgCount === currentMsgCount) {
+        task.stablePolls = (task.stablePolls ?? 0) + 1;
+      } else {
+        task.stablePolls = 0;
+      }
+      task.lastMsgCount = currentMsgCount;
+    } catch {
+    }
+  }
+  /**
+   * Complete a task and cleanup
+   */
+  async completeTask(task) {
+    task.status = "completed";
+    task.completedAt = /* @__PURE__ */ new Date();
+    if (task.concurrencyKey) {
+      this.concurrency.release(task.concurrencyKey);
+      task.concurrencyKey = void 0;
+    }
+    this.store.untrackPending(task.parentSessionID, task.id);
+    this.store.queueNotification(task);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+    this.scheduleCleanup(task.id);
+    log2(`Completed ${task.id} (${formatDuration(task.startedAt, task.completedAt)})`);
+  }
   async validateSessionHasOutput(sessionID) {
     try {
-      const response = await this.client.session.messages({
-        path: { id: sessionID }
-      });
+      const response = await this.client.session.messages({ path: { id: sessionID } });
       const messages = response.data ?? [];
-      const hasContent = messages.some((m) => {
-        if (m.info?.role !== "assistant") return false;
-        const parts = m.parts ?? [];
-        return parts.some(
-          (p) => p.type === "text" && p.text?.trim() || p.type === "reasoning" && p.text?.trim() || p.type === "tool"
-        );
-      });
-      return hasContent;
+      return messages.some((m) => m.info?.role === "assistant" && m.parts?.some((p) => p.type === "text" && p.text?.trim() || p.type === "tool"));
     } catch {
       return true;
     }
   }
-  // ========================================================================
-  // Internal: Cleanup & TTL
-  // ========================================================================
   pruneExpiredTasks() {
     const now = Date.now();
-    for (const [taskId, task] of this.tasks.entries()) {
+    for (const [taskId, task] of this.store.getAll().map((t) => [t.id, t])) {
       const age = now - task.startedAt.getTime();
-      if (age > TASK_TTL_MS2) {
-        log(`Timeout: ${taskId} (${Math.round(age / 1e3)}s)`);
-        if (task.status === "running") {
-          task.status = "timeout";
-          task.error = "Task exceeded 30 minute time limit";
-          task.completedAt = /* @__PURE__ */ new Date();
-          if (task.concurrencyKey) {
-            this.concurrency.release(task.concurrencyKey);
-          }
-          this.untrackPending(task.parentSessionID, taskId);
-          console.log(
-            `[parallel] \u23F1\uFE0F TIMEOUT ${taskId} \u2192 ${task.agent}: ${task.description}`
-          );
-        }
-        this.client.session.delete({
-          path: { id: task.sessionID }
-        }).then(() => {
-          console.log(
-            `[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (timeout session deleted)`
-          );
-        }).catch(() => {
-          console.log(
-            `[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (timeout session already gone)`
-          );
-        });
-        this.tasks.delete(taskId);
-      }
-    }
-    for (const [sessionID, queue] of this.notifications.entries()) {
-      if (queue.length === 0) {
-        this.notifications.delete(sessionID);
-      }
+      if (age <= CONFIG.TASK_TTL_MS) continue;
+      log2(`Timeout: ${taskId}`);
+      if (task.status === "running") {
+        task.status = "timeout";
+        task.error = "Task exceeded 30 minute time limit";
+        task.completedAt = /* @__PURE__ */ new Date();
+        if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+        this.store.untrackPending(task.parentSessionID, taskId);
+      }
+      this.client.session.delete({ path: { id: task.sessionID } }).catch(() => {
+      });
+      this.store.delete(taskId);
     }
+    this.store.cleanEmptyNotifications();
   }
   scheduleCleanup(taskId) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     const sessionID = task?.sessionID;
     setTimeout(async () => {
       if (sessionID) {
-        try {
-          await this.client.session.delete({
-            path: { id: sessionID }
-          });
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (session deleted)`);
-          log(`Deleted session ${sessionID}`);
-        } catch {
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (session already gone)`);
-        }
-      }
-      this.tasks.delete(taskId);
-      log(`Cleaned up ${taskId} from memory`);
-    }, CLEANUP_DELAY_MS2);
-  }
-  // ========================================================================
-  // Internal: Notifications
-  // ========================================================================
-  queueNotification(task) {
-    const queue = this.notifications.get(task.parentSessionID) ?? [];
-    queue.push(task);
-    this.notifications.set(task.parentSessionID, queue);
-  }
-  async notifyParentIfAllComplete(parentSessionID) {
-    const pending = this.pendingByParent.get(parentSessionID);
-    if (pending && pending.size > 0) {
-      log(`${pending.size} tasks still pending for ${parentSessionID}`);
-      return;
-    }
-    const completedTasks = this.notifications.get(parentSessionID) ?? [];
-    if (completedTasks.length === 0) return;
-    const summary = completedTasks.map((t) => {
-      const status = t.status === "completed" ? "\u2705" : "\u274C";
-      const duration3 = this.formatDuration(t.startedAt, t.completedAt);
-      return `${status} \`${t.id}\` (${duration3}): ${t.description}`;
-    }).join("\n");
-    const notification = `<system-notification>
-**All Parallel Tasks Complete**
-
-${summary}
-
----
-
-**Retrieval Options**
-
-Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve full results.
-
----
-
-**Task Summary**
-
-Total Tasks: ${completedTasks.length}
-Status: All Complete
-Mode: Background (non-blocking)
-</system-notification>`;
-    try {
-      await this.client.session.prompt({
-        path: { id: parentSessionID },
-        body: {
-          noReply: true,
-          parts: [{ type: "text", text: notification }]
-        }
-      });
-      log(`Notified parent ${parentSessionID}: ${completedTasks.length} tasks`);
-    } catch (error45) {
-      log("Notification error:", error45);
-    }
-    this.notifications.delete(parentSessionID);
-  }
-  // ========================================================================
-  // Internal: Formatting
-  // ========================================================================
-  formatDuration(start, end) {
-    const duration3 = (end ?? /* @__PURE__ */ new Date()).getTime() - start.getTime();
-    const seconds = Math.floor(duration3 / 1e3);
-    const minutes = Math.floor(seconds / 60);
-    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-    return `${seconds}s`;
-  }
-};
-var parallelAgentManager = {
-  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
-};
-
-// src/tools/async-agent.ts
-var createDelegateTaskTool = (manager, client) => tool({
-  description: `Delegate a task to an agent.
-
-<mode>
-- background=true: Non-blocking. Task runs in parallel session. Use get_task_result later.
-- background=false: Blocking. Waits for result. Use when you need output immediately.
-</mode>
-
-<when_to_use_background_true>
-- Multiple independent tasks to run in parallel
-- Long-running tasks (build, test, analysis)
-- You have other work to do while waiting
-- Example: "Build module A" + "Test module B" in parallel
-</when_to_use_background_true>
-
-<when_to_use_background_false>
-- You need the result for the very next step
-- Single task with nothing else to do
-- Quick questions that return fast
-</when_to_use_background_false>
-
-<safety>
-- Max 3 background tasks per agent type (extras queue automatically)
-- Auto-timeout: 30 minutes
-- Auto-cleanup: 5 minutes after completion
-</safety>`,
-  args: {
-    agent: tool.schema.string().describe(
-      `Agent name (e.g., '${AGENT_NAMES.BUILDER}', '${AGENT_NAMES.INSPECTOR}', '${AGENT_NAMES.ARCHITECT}')`
-    ),
-    description: tool.schema.string().describe("Short task description"),
-    prompt: tool.schema.string().describe("Full prompt/instructions for the agent"),
-    background: tool.schema.boolean().describe(
-      "true=async (returns task_id), false=sync (waits for result). REQUIRED."
-    )
-  },
-  async execute(args, context) {
-    const { agent, description, prompt, background } = args;
-    const ctx = context;
-    const sessionClient = client;
-    if (background === void 0) {
-      return `\u274C 'background' parameter is REQUIRED.
-- background=true: Run in parallel, returns task ID
-- background=false: Wait for result (blocking)`;
-    }
-    if (background === true) {
-      try {
-        const task = await manager.launch({
-          agent,
-          description,
-          prompt,
-          parentSessionID: ctx.sessionID
-        });
-        const runningCount = manager.getRunningTasks().length;
-        const pendingCount = manager.getPendingCount(ctx.sessionID);
-        console.log(
-          `[parallel] \u{1F680} SPAWNED ${task.id} \u2192 ${agent}: ${description}`
-        );
-        return `
-## \u{1F680} BACKGROUND TASK SPAWNED
-
-**Task Details**
-- **ID**: \`${task.id}\`
-- **Agent**: ${agent}
-- **Description**: ${description}
-- **Status**: \u23F3 Running in background (non-blocking)
-
-**Active Tasks**
-- Running: ${runningCount}
-- Pending: ${pendingCount}
-
----
-
-**Monitoring Commands**
-
-Check progress anytime:
-- \`list_tasks()\` - View all parallel tasks
-- \`get_task_result({ taskId: "${task.id}" })\` - Get latest result
-- \`cancel_task({ taskId: "${task.id}" })\` - Stop this task
-
----
-
-\u2713 System will notify when ALL tasks complete. You can continue working!`;
-      } catch (error45) {
-        const message = error45 instanceof Error ? error45.message : String(error45);
-        console.log(`[parallel] \u274C FAILED: ${message}`);
-        return `\u274C Failed to spawn background task: ${message}`;
-      }
-    }
-    console.log(`[delegate] \u23F3 SYNC ${agent}: ${description}`);
-    try {
-      const session = sessionClient.session;
-      const directory = ".";
-      const createResult = await session.create({
-        body: {
-          parentID: ctx.sessionID,
-          title: `Task: ${description}`
-        },
-        query: { directory }
-      });
-      if (createResult.error || !createResult.data?.id) {
-        return `\u274C Failed to create session: ${createResult.error || "No session ID"}`;
-      }
-      const sessionID = createResult.data.id;
-      const startTime = Date.now();
-      try {
-        await session.prompt({
-          path: { id: sessionID },
-          body: {
-            agent,
-            parts: [{ type: "text", text: prompt }]
-          }
-        });
-      } catch (promptError) {
-        const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
-        return `\u274C Failed to send prompt: ${errorMessage}
-
-Session ID: ${sessionID}`;
-      }
-      const POLL_INTERVAL_MS2 = 500;
-      const MAX_POLL_TIME_MS = 10 * 60 * 1e3;
-      const MIN_STABILITY_MS3 = 5e3;
-      const STABILITY_POLLS_REQUIRED = 3;
-      let stablePolls = 0;
-      let lastMsgCount = 0;
-      while (Date.now() - startTime < MAX_POLL_TIME_MS) {
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS2));
-        const statusResult = await session.status();
-        const allStatuses = statusResult.data ?? {};
-        const sessionStatus = allStatuses[sessionID];
-        if (sessionStatus?.type !== "idle") {
-          stablePolls = 0;
-          lastMsgCount = 0;
-          continue;
-        }
-        if (Date.now() - startTime < MIN_STABILITY_MS3) continue;
-        const messagesResult2 = await session.messages({
-          path: { id: sessionID }
-        });
-        const messages2 = messagesResult2.data ?? [];
-        const currentMsgCount = messages2.length;
-        if (currentMsgCount === lastMsgCount) {
-          stablePolls++;
-          if (stablePolls >= STABILITY_POLLS_REQUIRED) break;
-        } else {
-          stablePolls = 0;
-          lastMsgCount = currentMsgCount;
-        }
-      }
-      const messagesResult = await session.messages({
-        path: { id: sessionID }
-      });
-      const messages = messagesResult.data ?? [];
-      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant").reverse();
-      const lastMsg = assistantMsgs[0];
-      if (!lastMsg) {
-        return `\u274C No assistant response found.
-
-Session ID: ${sessionID}`;
-      }
-      const textParts = lastMsg.parts?.filter(
-        (p) => p.type === "text" || p.type === "reasoning"
-      ) ?? [];
-      const textContent = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n");
-      const duration3 = Math.floor((Date.now() - startTime) / 1e3);
-      console.log(
-        `[delegate] \u2705 COMPLETED ${agent}: ${description} (${duration3}s)`
-      );
-      return `\u2705 **Task Completed** (${duration3}s)
-
-Agent: ${agent}
-Session ID: ${sessionID}
-
----
-
-${textContent || "(No text output)"}`;
-    } catch (error45) {
-      const message = error45 instanceof Error ? error45.message : String(error45);
-      console.log(`[delegate] \u274C FAILED: ${message}`);
-      return `\u274C Task failed: ${message}`;
-    }
-  }
-});
-var createGetTaskResultTool = (manager) => tool({
-  description: `Get the result from a completed background task.
-
-<note>
-If the task is still running, returns status info.
-Wait for the "All Complete" notification before checking.
-</note>`,
-  args: {
-    taskId: tool.schema.string().describe("Task ID from delegate_task (e.g., 'task_a1b2c3d4')")
-  },
-  async execute(args) {
-    const { taskId } = args;
-    const task = manager.getTask(taskId);
-    if (!task) {
-      return `\u274C Task not found: \`${taskId}\`
-
-Use \`list_tasks\` to see available tasks.`;
-    }
-    if (task.status === "running") {
-      const elapsed = Math.floor(
-        (Date.now() - task.startedAt.getTime()) / 1e3
-      );
-      return `\u23F3 **Task Still Running**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Elapsed** | ${elapsed}s |
-
-Wait for "All Complete" notification, then try again.`;
-    }
-    const result = await manager.getResult(taskId);
-    const duration3 = manager.formatDuration(task.startedAt, task.completedAt);
-    if (task.status === "error" || task.status === "timeout") {
-      return `\u274C **Task ${task.status === "timeout" ? "Timed Out" : "Failed"}**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Error** | ${task.error} |
-| **Duration** | ${duration3} |`;
-    }
-    return `\u2705 **Task Completed**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Duration** | ${duration3} |
-
----
-
-**Result:**
-
-${result || "(No output)"}`;
-  }
-});
-var createListTasksTool = (manager) => tool({
-  description: `List all background tasks and their status.`,
-  args: {
-    status: tool.schema.string().optional().describe("Filter: 'all', 'running', 'completed', 'error'")
-  },
-  async execute(args) {
-    const { status = "all" } = args;
-    let tasks;
-    switch (status) {
-      case "running":
-        tasks = manager.getRunningTasks();
-        break;
-      case "completed":
-        tasks = manager.getAllTasks().filter((t) => t.status === "completed");
-        break;
-      case "error":
-        tasks = manager.getAllTasks().filter((t) => t.status === "error" || t.status === "timeout");
-        break;
-      default:
-        tasks = manager.getAllTasks();
-    }
-    if (tasks.length === 0) {
-      return `\u{1F4CB} No background tasks found${status !== "all" ? ` (filter: ${status})` : ""}.
-
-Use \`delegate_task({ ..., background: true })\` to spawn background tasks.`;
-    }
-    const runningCount = manager.getRunningTasks().length;
-    const completedCount = manager.getAllTasks().filter((t) => t.status === "completed").length;
-    const errorCount = manager.getAllTasks().filter((t) => t.status === "error" || t.status === "timeout").length;
-    const statusIcon = (s) => {
-      switch (s) {
-        case "running":
-          return "\u23F3";
-        case "completed":
-          return "\u2705";
-        case "error":
-          return "\u274C";
-        case "timeout":
-          return "\u23F1\uFE0F";
-        default:
-          return "\u2753";
-      }
-    };
-    const rows = tasks.map((t) => {
-      const elapsed = Math.floor(
-        (Date.now() - t.startedAt.getTime()) / 1e3
-      );
-      const desc = t.description.length > 25 ? t.description.slice(0, 22) + "..." : t.description;
-      return `| \`${t.id}\` | ${statusIcon(t.status)} ${t.status} | ${t.agent} | ${desc} | ${elapsed}s |`;
-    }).join("\n");
-    return `\u{1F4CB} **Background Tasks** (${tasks.length} shown)
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| \u23F3 Running: ${runningCount} | \u2705 Completed: ${completedCount} | \u274C Error: ${errorCount} |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-
-| Task ID | Status | Agent | Description | Elapsed |
-|---------|--------|-------|-------------|---------|
-${rows}
-
-\u{1F4A1} Use \`get_task_result({ taskId: "task_xxx" })\` to get results.
-\u{1F6D1} Use \`cancel_task({ taskId: "task_xxx" })\` to stop a running task.`;
-  }
-});
-var createCancelTaskTool = (manager) => tool({
-  description: `Cancel a running background task.
-
-<purpose>
-Stop a runaway or no-longer-needed task.
-Frees up concurrency slot for other tasks.
-</purpose>`,
-  args: {
-    taskId: tool.schema.string().describe("Task ID to cancel (e.g., 'task_a1b2c3d4')")
-  },
-  async execute(args) {
-    const { taskId } = args;
-    const cancelled = await manager.cancelTask(taskId);
-    if (cancelled) {
-      return `\u{1F6D1} **Task Cancelled**
-
-Task \`${taskId}\` has been stopped. Concurrency slot released.`;
-    }
-    const task = manager.getTask(taskId);
-    if (task) {
-      return `\u26A0\uFE0F Cannot cancel: Task \`${taskId}\` is ${task.status} (not running).`;
-    }
-    return `\u274C Task \`${taskId}\` not found.
-
-Use \`list_tasks\` to see available tasks.`;
-  }
-});
-function createAsyncAgentTools(manager, client) {
-  return {
-    delegate_task: createDelegateTaskTool(manager, client),
-    get_task_result: createGetTaskResultTool(manager),
-    list_tasks: createListTasksTool(manager),
-    cancel_task: createCancelTaskTool(manager)
-  };
-}
-
-// 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;
+        try {
+          await this.client.session.delete({ path: { id: sessionID } });
+        } catch {
         }
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
       }
-      currentTask.status = "failed";
-      currentTask.error = "Timeout";
+      this.store.delete(taskId);
+      log2(`Cleaned up ${taskId}`);
+    }, CONFIG.CLEANUP_DELAY_MS);
+  }
+  async notifyParentIfAllComplete(parentSessionID) {
+    if (this.store.hasPending(parentSessionID)) return;
+    const notifications = this.store.getNotifications(parentSessionID);
+    if (notifications.length === 0) return;
+    const message = buildNotificationMessage(notifications);
+    try {
+      await this.client.session.prompt({
+        path: { id: parentSessionID },
+        body: { noReply: true, parts: [{ type: "text", text: message }] }
+      });
+      log2(`Notified parent ${parentSessionID}`);
     } catch (error45) {
-      currentTask.status = "failed";
-      currentTask.error = error45 instanceof Error ? error45.message : String(error45);
-      console.log(`   \u274C [${task.id}] Exception: ${currentTask.error}`);
+      log2("Notification error:", error45);
     }
-  }
-  /**
-   * 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();
+    this.store.clearNotifications(parentSessionID);
   }
 };
+var parallelAgentManager = {
+  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
+};
 
-// 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>
+// src/tools/parallel/delegate-task.ts
+var createDelegateTaskTool = (manager, client) => tool({
+  description: `Delegate a task to an agent.
 
-<benefits>
-- Faster than naive retry: Failed tasks batch-identified
-- More efficient: No redundant work on successful tasks
-- Controlled: Concurrency limits prevent API overload
-</benefits>
+<mode>
+- background=true: Non-blocking. Returns task ID immediately.
+- background=false: Blocking. Waits for result.
+</mode>
 
-<examples>
-process_batch({
-  concurrency: 10,
-  tasks: [
-    { id: "task1", agent: "builder", description: "Test A", prompt: "..." },
-    { id: "task2", agent: "inspector", description: "Test B", prompt: "..." }
-  ]
-})
-</examples>`,
+<safety>
+- Max 3 tasks per agent type
+- Auto-timeout: 30 minutes
+</safety>`,
   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")
+    agent: tool.schema.string().describe("Agent name"),
+    description: tool.schema.string().describe("Task description"),
+    prompt: tool.schema.string().describe("Prompt for the agent"),
+    background: tool.schema.boolean().describe("true=async, false=sync")
   },
-  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.";
+  async execute(args, context) {
+    const { agent, description, prompt, background } = args;
+    const ctx = context;
+    const sessionClient = client;
+    if (background === void 0) {
+      return `\u274C 'background' parameter is REQUIRED.`;
     }
-    for (const task of taskList) {
-      if (!task.id || !task.agent || !task.description || !task.prompt) {
-        return `\u274C Task missing required fields (id, agent, description, prompt)`;
+    if (background === true) {
+      try {
+        const task = await manager.launch({
+          agent,
+          description,
+          prompt,
+          parentSessionID: ctx.sessionID
+        });
+        return `\u{1F680} Task spawned: \`${task.id}\` (${agent})`;
+      } catch (error45) {
+        return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
       }
     }
-    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.
-
----
+    try {
+      const session = sessionClient.session;
+      const createResult = await session.create({
+        body: { parentID: ctx.sessionID, title: `Task: ${description}` },
+        query: { directory: "." }
+      });
+      if (createResult.error || !createResult.data?.id) {
+        return `\u274C Failed to create session`;
+      }
+      const sessionID = createResult.data.id;
+      const startTime = Date.now();
+      await session.prompt({
+        path: { id: sessionID },
+        body: { agent, parts: [{ type: "text", text: prompt }] }
+      });
+      let stablePolls = 0, lastMsgCount = 0;
+      while (Date.now() - startTime < 10 * 60 * 1e3) {
+        await new Promise((r) => setTimeout(r, 500));
+        const statusResult = await session.status();
+        if (statusResult.data?.[sessionID]?.type !== "idle") {
+          stablePolls = 0;
+          continue;
+        }
+        if (Date.now() - startTime < 5e3) continue;
+        const msgs2 = await session.messages({ path: { id: sessionID } });
+        const count = (msgs2.data ?? []).length;
+        if (count === lastMsgCount) {
+          stablePolls++;
+          if (stablePolls >= 3) break;
+        } else {
+          stablePolls = 0;
+          lastMsgCount = count;
+        }
+      }
+      const msgs = await session.messages({ path: { id: sessionID } });
+      const messages = msgs.data ?? [];
+      const lastMsg = messages.filter((m) => m.info?.role === "assistant").reverse()[0];
+      const text = lastMsg?.parts?.filter((p) => p.type === "text" || p.type === "reasoning").map((p) => p.text ?? "").join("\n") || "";
+      return `\u2705 Completed (${Math.floor((Date.now() - startTime) / 1e3)}s)
 
-Failed Task IDs:
-${result.tasks.filter((t) => t.status === "failed").map((t) => `  - ${t.id}`).join("\n")}
----
-`;
+${text || "(No output)"}`;
+    } catch (error45) {
+      return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
     }
-    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>`,
+// src/tools/parallel/get-task-result.ts
+var createGetTaskResultTool = (manager) => tool({
+  description: `Get result from a completed background task.`,
   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)")
+    taskId: tool.schema.string().describe("Task ID")
   },
   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.
+    const task = manager.getTask(args.taskId);
+    if (!task) return `\u274C Task not found: \`${args.taskId}\``;
+    if (task.status === "running") return `\u23F3 Still running...`;
+    const result = await manager.getResult(args.taskId);
+    const duration3 = manager.formatDuration(task.startedAt, task.completedAt);
+    if (task.status === "error" || task.status === "timeout") {
+      return `\u274C ${task.status}: ${task.error}`;
+    }
+    return `\u2705 Completed (${duration3})
 
-Shows all dynamic settings including timeouts, concurrency limits, and debug flags.`,
-  args: {},
-  async execute() {
-    configManager.exportConfigs();
-    return "";
+${result || "(No output)"}`;
   }
 });
-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>`,
+// src/tools/parallel/list-tasks.ts
+var createListTasksTool = (manager) => tool({
+  description: `List all background tasks.`,
   args: {
-    agent: tool.schema.string().describe('Agent type (e.g., "builder", "inspector", "architect")'),
-    limit: tool.schema.string().describe("New concurrency limit (number)")
+    status: tool.schema.string().optional().describe("Filter: all, running, completed, error")
   },
   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}.`;
+    const { status = "all" } = args;
+    let tasks;
+    switch (status) {
+      case "running":
+        tasks = manager.getRunningTasks();
+        break;
+      case "completed":
+        tasks = manager.getAllTasks().filter((t) => t.status === "completed");
+        break;
+      case "error":
+        tasks = manager.getAllTasks().filter((t) => t.status === "error" || t.status === "timeout");
+        break;
+      default:
+        tasks = manager.getAllTasks();
     }
-    configManager.updateParallelAgentConfig({
-      defaultConcurrency: numLimit
-    });
-    return `\u2705 **Concurrency Updated**
-
-| Property | Value |
-|----------|-------|
-| **Agent** | ${agent} |
-| **New Limit** | ${numLimit} parallel tasks |
+    if (tasks.length === 0) return `\u{1F4CB} No tasks found.`;
+    const rows = tasks.map((t) => {
+      const elapsed = Math.floor((Date.now() - t.startedAt.getTime()) / 1e3);
+      return `| \`${t.id}\` | ${getStatusEmoji(t.status)} ${t.status} | ${t.agent} | ${elapsed}s |`;
+    }).join("\n");
+    return `\u{1F4CB} **Tasks**
 
-Changes take effect immediately. New tasks will respect to the new limit.`;
+| ID | Status | Agent | Time |
+|----|--------|-------|------|
+${rows}`;
   }
 });
-var createSetTimeoutTool = () => tool({
-  description: `Update task timeout duration.
 
-<examples>
-set_timeout({ taskTtlMinutes: 45 })
-set_timeout({ cleanupDelayMinutes: 2 })
-</examples>`,
+// src/tools/parallel/cancel-task.ts
+var createCancelTaskTool = (manager) => tool({
+  description: `Cancel a running task.`,
   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)")
+    taskId: tool.schema.string().describe("Task ID to cancel")
   },
   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;
+    const cancelled = await manager.cancelTask(args.taskId);
+    if (cancelled) return `\u{1F6D1} Cancelled: \`${args.taskId}\``;
+    const task = manager.getTask(args.taskId);
+    if (task) return `\u26A0\uFE0F Cannot cancel: Task is ${task.status}`;
+    return `\u274C Not found: \`${args.taskId}\``;
   }
 });
-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) {
+// src/tools/parallel/index.ts
+function createAsyncAgentTools(manager, client) {
   return {
-    show_config: createShowConfigTool(),
-    set_concurrency: createSetConcurrencyTool(client),
-    set_timeout: createSetTimeoutTool(),
-    set_debug: createSetDebugTool()
+    delegate_task: createDelegateTaskTool(manager, client),
+    get_task_result: createGetTaskResultTool(manager),
+    list_tasks: createListTasksTool(manager),
+    cancel_task: createCancelTaskTool(manager)
   };
 }
 
@@ -16167,16 +14381,120 @@ 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;
 var TASK_COMMAND_MAX_STEPS = 1e3;
 var AGENT_EMOJI2 = {
-  [AGENT_NAMES.ARCHITECT]: "\u{1F3D7}\uFE0F",
-  [AGENT_NAMES.BUILDER]: "\u{1F528}",
-  [AGENT_NAMES.INSPECTOR]: "\u{1F50D}",
-  [AGENT_NAMES.RECORDER]: "\u{1F4BE}",
-  [AGENT_NAMES.COMMANDER]: "\u{1F3AF}"
+  "architect": "\u{1F3D7}\uFE0F",
+  "builder": "\u{1F528}",
+  "inspector": "\u{1F50D}",
+  "recorder": "\u{1F4BE}",
+  "commander": "\u{1F3AF}"
 };
 var CONTINUE_INSTRUCTION = `<auto_continue>
 <status>Mission not complete. Keep executing.</status>
@@ -16200,8 +14518,6 @@ 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
@@ -16219,13 +14535,7 @@ var OrchestratorPlugin = async (input) => {
       list_background: listBackgroundTool,
       kill_background: killBackgroundTool,
       // Async agent tools - spawn agents in parallel sessions
-      ...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
+      ...asyncAgentTools
     },
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode
@@ -16243,7 +14553,7 @@ var OrchestratorPlugin = async (input) => {
       }
       const orchestratorAgents = {
         Commander: {
-          name: AGENT_NAMES.COMMANDER,
+          name: "Commander",
           description: "Autonomous orchestrator - executes until mission complete",
           systemPrompt: AGENTS.commander.systemPrompt
         }
@@ -16263,7 +14573,7 @@ var OrchestratorPlugin = async (input) => {
       const parsed = detectSlashCommand(originalText);
       const sessionID = msgInput.sessionID;
       const agentName = (msgInput.agent || "").toLowerCase();
-      if (agentName === AGENT_NAMES.COMMANDER && !sessions.has(sessionID)) {
+      if (agentName === "commander" && !sessions.has(sessionID)) {
         const now = Date.now();
         sessions.set(sessionID, {
           active: true,
@@ -16537,16 +14847,16 @@ ${stateSession.graph.getTaskSummary()}`;
     // Event handler - cleans up when sessions are deleted
     // -----------------------------------------------------------------
     handler: async ({ event }) => {
+      try {
+        const manager = ParallelAgentManager.getInstance();
+        manager.handleEvent(event);
+      } catch {
+      }
       if (event.type === "session.deleted") {
         const props = event.properties;
         if (props?.info?.id) {
-          const sessionID = props.info.id;
-          sessions.delete(sessionID);
-          state.sessions.delete(sessionID);
-          const cleanedCount = backgroundTaskManager.cleanupBySession(sessionID);
-          if (cleanedCount > 0) {
-            console.log(`[background] Cleaned up ${cleanedCount} tasks for deleted session ${sessionID}`);
-          }
+          sessions.delete(props.info.id);
+          state.sessions.delete(props.info.id);
         }
       }
     }