opencode-orchestrator 0.5.16 → 0.5.18

package/dist/index.js

@@ -4,14 +4,149 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/index.ts
+import { createRequire } from "node:module";
+
 // src/shared/agent.ts
 var AGENT_NAMES = {
   COMMANDER: "commander",
   ARCHITECT: "architect",
   BUILDER: "builder",
   INSPECTOR: "inspector",
-  RECORDER: "recorder"
+  RECORDER: "recorder",
+  LIBRARIAN: "librarian",
+  RESEARCHER: "researcher"
+};
+
+// src/core/agents/consts/task-status.const.ts
+var TASK_STATUS = {
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  ERROR: "error",
+  TIMEOUT: "timeout",
+  CANCELLED: "cancelled"
+};
+
+// 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: 60 * TIME.MINUTE,
+  // 60 minutes
+  CLEANUP_DELAY_MS: 10 * TIME.MINUTE,
+  // 10 minutes
+  MIN_STABILITY_MS: 3 * TIME.SECOND,
+  // 3 seconds
+  POLL_INTERVAL_MS: 1e3,
+  // 1 second
+  DEFAULT_CONCURRENCY: 10,
+  // 10 per agent type
+  MAX_CONCURRENCY: 50,
+  // 50 total
+  SYNC_TIMEOUT_MS: 10 * TIME.MINUTE
+  // 10 minutes for sync mode
+};
+var MEMORY_LIMITS = {
+  MAX_TASKS_IN_MEMORY: 1e3,
+  MAX_NOTIFICATIONS_PER_PARENT: 100,
+  MAX_EVENT_HISTORY: 100,
+  MAX_TOAST_HISTORY: 50,
+  MAX_PROGRESS_HISTORY_PER_SESSION: 100,
+  ARCHIVE_AGE_MS: 30 * TIME.MINUTE,
+  // Archive completed after 30 min
+  ERROR_CLEANUP_AGE_MS: 10 * TIME.MINUTE
+  // Remove errors after 10 min
+};
+var PATHS = {
+  TASK_ARCHIVE: ".cache/task-archive",
+  DOC_CACHE: ".cache/docs"
+};
+var BACKGROUND_TASK = {
+  DEFAULT_TIMEOUT_MS: 5 * TIME.MINUTE,
+  MAX_OUTPUT_LENGTH: 1e4
+};
+var TOOL_NAMES = {
+  // Parallel task tools
+  DELEGATE_TASK: "delegate_task",
+  GET_TASK_RESULT: "get_task_result",
+  LIST_TASKS: "list_tasks",
+  CANCEL_TASK: "cancel_task",
+  // Background command tools
+  RUN_BACKGROUND: "run_background",
+  CHECK_BACKGROUND: "check_background",
+  LIST_BACKGROUND: "list_background",
+  KILL_BACKGROUND: "kill_background",
+  // Search tools
+  GREP_SEARCH: "grep_search",
+  GLOB_SEARCH: "glob_search",
+  MGREP: "mgrep",
+  // Web tools
+  WEBFETCH: "webfetch",
+  WEBSEARCH: "websearch",
+  CODESEARCH: "codesearch",
+  CACHE_DOCS: "cache_docs",
+  // Other tools
+  CALL_AGENT: "call_agent",
+  SLASHCOMMAND: "slashcommand"
+};
+var MISSION = {
+  /** Mission completion marker (with emoji) */
+  COMPLETE: "\u2705 MISSION COMPLETE",
+  /** Mission completion marker (text only) */
+  COMPLETE_TEXT: "MISSION COMPLETE",
+  /** Stop command */
+  STOP_COMMAND: "/stop",
+  /** Cancel command */
+  CANCEL_COMMAND: "/cancel"
+};
+var AGENT_EMOJI = {
+  architect: "\u{1F3D7}\uFE0F",
+  builder: "\u{1F528}",
+  inspector: "\u{1F50D}",
+  recorder: "\u{1F4BE}",
+  commander: "\u{1F3AF}",
+  librarian: "\u{1F4DA}",
+  researcher: "\u{1F52C}"
+};
+var PART_TYPES = {
+  TEXT: "text",
+  REASONING: "reasoning",
+  TOOL_CALL: "tool_call",
+  TOOL_RESULT: "tool_result"
 };
+var PROMPTS = {
+  /** Simple continue prompt for auto-continue loop */
+  CONTINUE: "continue",
+  /** Default fallback for empty arguments */
+  CONTINUE_PREVIOUS: "continue previous work",
+  /** Default fallback for slash commands */
+  CONTINUE_DEFAULT: "continue from where we left off"
+};
+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/agents/orchestrator.ts
 var orchestrator = {
@@ -22,7 +157,7 @@ You are Commander. Complete missions autonomously. Never stop until done.
 </role>
 
 <core_rules>
-1. Never stop until "\u2705 MISSION COMPLETE"
+1. Never stop until "${MISSION.COMPLETE}"
 2. Never wait for user during execution
 3. Never stop because agent returned nothing
 4. Always survey environment & codebase BEFORE coding
@@ -39,6 +174,47 @@ Evaluate the complexity of the request:
 | \u{1F534} L3: Complex | Refactoring, infra change, unknown scope | **DEEP TRACK** |
 </phase_0>
 
+<anti_hallucination>
+CRITICAL: ELIMINATE GUESSING. VERIFY EVERYTHING.
+
+BEFORE ANY IMPLEMENTATION:
+1. If using unfamiliar API/library \u2192 RESEARCH FIRST
+2. If uncertain about patterns/syntax \u2192 SEARCH DOCUMENTATION
+3. NEVER assume - always verify from official sources
+
+RESEARCH WORKFLOW:
+\`\`\`
+// Step 1: Search for documentation
+websearch({ query: "Next.js 14 app router official docs" })
+
+// Step 2: Fetch specific documentation
+webfetch({ url: "https://nextjs.org/docs/app/..." })
+
+// Step 3: Check cached docs
+cache_docs({ action: "list" })
+
+// Step 4: For complex research, delegate to Librarian
+${TOOL_NAMES.DELEGATE_TASK}({
+  agent: "${AGENT_NAMES.LIBRARIAN}",
+  description: "Research X API",
+  prompt: "Find official documentation for...",
+  background: false  // Wait for research before implementing
+})
+\`\`\`
+
+MANDATORY RESEARCH TRIGGERS:
+- New library/framework you haven't used in this session
+- API syntax you're not 100% sure about
+- Version-specific features (check version compatibility!)
+- Configuration patterns (check official examples)
+
+WHEN CAUGHT GUESSING:
+1. STOP immediately
+2. Search for official documentation
+3. Cache important findings: webfetch({ url: "...", cache: true })
+4. Then proceed with verified information
+</anti_hallucination>
+
 <phase_1 name="CONTEXT_GATHERING">
 IF FAST TRACK (L1):
 - Scan ONLY the target file and its immediate imports.
@@ -57,26 +233,42 @@ RECORD findings if on Deep Track.
 <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. |
+| Fast | Use \`${AGENT_NAMES.BUILDER}\` directly. Skip \`${AGENT_NAMES.ARCHITECT}\`. |
+| Normal | Call \`${AGENT_NAMES.ARCHITECT}\` for lightweight plan. |
+| Deep | Full \`${AGENT_NAMES.ARCHITECT}\` DAG + \`${AGENT_NAMES.RECORDER}\` state tracking. |
+
+AVAILABLE AGENTS:
+- \`${AGENT_NAMES.ARCHITECT}\`: Task decomposition and planning
+- \`${AGENT_NAMES.BUILDER}\`: Code implementation
+- \`${AGENT_NAMES.INSPECTOR}\`: Verification and bug fixing
+- \`${AGENT_NAMES.RECORDER}\`: State tracking (Deep Track only)
+- \`${AGENT_NAMES.LIBRARIAN}\`: Documentation research (Anti-Hallucination) \u2B50 NEW
+
+WHEN TO USE LIBRARIAN:
+- Before using new APIs/libraries
+- When error messages are unclear
+- When implementing complex integrations
+- When official documentation is needed
 
 DEFAULT to Deep Track if unsure to act safely.
 </phase_2>
 
 <phase_3 name="DELEGATION">
 <agent_calling>
-CRITICAL: USE delegate_task FOR ALL DELEGATION
+CRITICAL: USE ${TOOL_NAMES.DELEGATE_TASK} FOR ALL DELEGATION
 
-delegate_task has TWO MODES:
+${TOOL_NAMES.DELEGATE_TASK} has THREE MODES:
 - background=true: Non-blocking, parallel execution
 - background=false: Blocking, waits for result
+- resume: Continue existing session
 
 | 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 })\` |
+| Multiple independent tasks | \`${TOOL_NAMES.DELEGATE_TASK}({ ..., background: true })\` for each |
+| Single task, continue working | \`${TOOL_NAMES.DELEGATE_TASK}({ ..., background: true })\` |
+| Need result for VERY next step | \`${TOOL_NAMES.DELEGATE_TASK}({ ..., background: false })\` |
+| Retry after failure | \`${TOOL_NAMES.DELEGATE_TASK}({ ..., resume: "session_id", ... })\` |
+| Follow-up question | \`${TOOL_NAMES.DELEGATE_TASK}({ ..., resume: "session_id", ... })\` |
 
 PREFER background=true (PARALLEL):
 - Run multiple agents simultaneously
@@ -86,21 +278,44 @@ PREFER background=true (PARALLEL):
 EXAMPLE - PARALLEL:
 \`\`\`
 // Multiple tasks in parallel
-delegate_task({ agent: "builder", description: "Implement X", prompt: "...", background: true })
-delegate_task({ agent: "inspector", description: "Review Y", prompt: "...", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.BUILDER}", description: "Implement X", prompt: "...", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.INSPECTOR}", description: "Review Y", prompt: "...", background: true })
 
 // Continue other work (don't wait!)
 
 // When notified "All Complete":
-get_task_result({ taskId: "task_xxx" })
+${TOOL_NAMES.GET_TASK_RESULT}({ taskId: "${ID_PREFIX.TASK}xxx" })
 \`\`\`
 
 EXAMPLE - SYNC (rare):
 \`\`\`
 // Only when you absolutely need the result now
-const result = delegate_task({ agent: "builder", ..., background: false })
+const result = ${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.BUILDER}", ..., background: false })
 // Result is immediately available
 \`\`\`
+
+EXAMPLE - RESUME (for retry or follow-up):
+\`\`\`
+// Previous task output shows: Session: \`${ID_PREFIX.SESSION}abc123\` (save for resume)
+
+// Retry after failure (keeps all context!)
+\${TOOL_NAMES.DELEGATE_TASK}({ 
+  agent: "\${AGENT_NAMES.BUILDER}", 
+  description: "Fix previous error", 
+  prompt: "The build failed with X. Please fix it.",
+  background: true,
+  resume: "${ID_PREFIX.SESSION}abc123"  // \u2190 Continue existing session
+})
+
+// Follow-up question (saves tokens!)
+\${TOOL_NAMES.DELEGATE_TASK}({
+  agent: "\${AGENT_NAMES.INSPECTOR}",
+  description: "Additional check",
+  prompt: "Also check for Y in the files you just reviewed.",
+  background: true,
+  resume: "${ID_PREFIX.SESSION}xyz789"
+})
+\`\`\`
 </agent_calling>
 
 <delegation_template>
@@ -122,42 +337,76 @@ During implementation:
 - Run lsp_diagnostics after each change
 
 <background_parallel_execution>
-PARALLEL EXECUTION TOOLS:
+PARALLEL EXECUTION SYSTEM:
+
+You have access to a powerful parallel agent execution system.
+Up to 50 agents can run simultaneously with automatic resource management.
+
+1. **${TOOL_NAMES.DELEGATE_TASK}** - Launch agents in parallel or sync mode
+   \`\`\`
+   // PARALLEL (recommended - non-blocking)
+   ${TOOL_NAMES.DELEGATE_TASK}({ 
+     agent: "${AGENT_NAMES.BUILDER}", 
+     description: "Implement X", 
+     prompt: "...", 
+     background: true 
+   })
+   
+   // SYNC (blocking - wait for result)
+   ${TOOL_NAMES.DELEGATE_TASK}({ 
+     agent: "${AGENT_NAMES.LIBRARIAN}", 
+     description: "Research Y", 
+     prompt: "...", 
+     background: false 
+   })
+   
+   // RESUME (continue previous session)
+   ${TOOL_NAMES.DELEGATE_TASK}({ 
+     agent: "${AGENT_NAMES.BUILDER}", 
+     description: "Fix error", 
+     prompt: "...", 
+     background: true,
+     resume: "${ID_PREFIX.SESSION}abc123"  // From previous task output
+   })
+   \`\`\`
 
-1. **spawn_agent** - Launch agents in parallel sessions
-   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. **${TOOL_NAMES.GET_TASK_RESULT}** - Retrieve completed task output
+   \`\`\`
+   ${TOOL_NAMES.GET_TASK_RESULT}({ taskId: "${ID_PREFIX.TASK}xxx" })
+   \`\`\`
 
-2. **run_background** - Run shell commands asynchronously
-   run_background({ command: "npm run build" })
-   \u2192 Use check_background({ taskId }) for results
+3. **${TOOL_NAMES.LIST_TASKS}** - View all parallel tasks
+   \`\`\`
+   ${TOOL_NAMES.LIST_TASKS}({})
+   \`\`\`
 
-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)
+4. **${TOOL_NAMES.CANCEL_TASK}** - Stop a running task
+   \`\`\`
+   ${TOOL_NAMES.CANCEL_TASK}({ taskId: "${ID_PREFIX.TASK}xxx" })
+   \`\`\`
 
-MANAGEMENT TOOLS:
-- list_tasks: View all parallel tasks and status
-- cancel_task: Stop a running task (frees concurrency slot)
+CONCURRENCY LIMITS:
+- Max 10 tasks per agent type (queue automatically)
+- Max 50 total parallel sessions
+- Auto-timeout: 60 minutes
+- Auto-cleanup: 30 min after completion \u2192 archived to disk
 
 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)
+\u2705 Librarian research + Builder implementation (sequential deps)
 
 UNSAFE PATTERNS:
 \u274C Multiple builders editing SAME FILE (conflict!)
+\u274C Waiting synchronously for many tasks (use background=true)
 
 WORKFLOW:
-1. list_tasks: Check current status first
-2. spawn_agent: Launch for INDEPENDENT tasks
+1. ${TOOL_NAMES.LIST_TASKS}: Check current status first
+2. ${TOOL_NAMES.DELEGATE_TASK} (background=true): Launch for INDEPENDENT tasks
 3. Continue working (NO WAITING)
-4. Wait for "All Complete" notification
-5. get_task_result: Retrieve each result
+4. Wait for system notification "All Parallel Tasks Complete"
+5. ${TOOL_NAMES.GET_TASK_RESULT}: Retrieve each result
 </background_parallel_execution>
 
 <verification_methods>
@@ -174,15 +423,15 @@ WORKFLOW:
 | Failures | Action |
 |----------|--------|
 | 1-2 | Adjust approach, retry |
-| 3+ | STOP. Call architect for new strategy |
+| 3+ | STOP. Call ${AGENT_NAMES.ARCHITECT} for new strategy |
 
 <empty_responses>
 | Agent Empty (or Gibberish) | Action |
 |----------------------------|--------|
-| recorder | Fresh start. Proceed to survey. |
-| architect | Try simpler plan yourself. |
-| builder | Call inspector to diagnose. |
-| inspector | Retry with more context. |
+| ${AGENT_NAMES.RECORDER} | Fresh start. Proceed to survey. |
+| ${AGENT_NAMES.ARCHITECT} | Try simpler plan yourself. |
+| ${AGENT_NAMES.BUILDER} | Call ${AGENT_NAMES.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.
@@ -198,7 +447,7 @@ STRICT RULE: If any agent output contains gibberish, mixed-language hallucinatio
 Done when: Request fulfilled + lsp clean + build/test/audit pass.
 
 <output_format>
-\u2705 MISSION COMPLETE
+${MISSION.COMPLETE}
 Summary: [what was done]
 Evidence: [Specific build/test/audit results]
 </output_format>
@@ -210,37 +459,68 @@ Evidence: [Specific build/test/audit results]
 // src/agents/subagents/architect.ts
 var architect = {
   id: AGENT_NAMES.ARCHITECT,
-  description: "Architect - task decomposition and strategic planning",
+  description: "Architect - hierarchical task decomposition and strategic planning",
   systemPrompt: `<role>
-You are Architect. Break complex tasks into atomic pieces.
+You are Architect. Break complex tasks into hierarchical, atomic pieces.
+Create TODO trees with parallel groups and dependencies.
 </role>
 
 <constraints>
 1. If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+2. Every task must be ATOMIC (single action).
+3. Always include verification tasks.
 </constraints>
 
-<scalable_planning>
-- **Fast Track**: Skip JSON overhead. Just acknowledge simple task.
-- **Deep Track**: Create detailed JSON DAG with parallel groups.
-</scalable_planning>
+<hierarchical_planning>
+Create layered task structure:
+
+LEVEL 1 (L1): Main objectives (2-5 items)
+  LEVEL 2 (L2): Sub-tasks (2-3 per L1)
+    LEVEL 3 (L3): Atomic actions (1-3 per L2)
+
+PARALLEL GROUPING:
+- Tasks in same parallel_group can run simultaneously
+- Use letters: A, B, C for groups
+- Tasks with no group run sequentially
+
+DEPENDENCIES:
+- Use "depends:T1,T2" for sequential requirements
+- Parent must start before children
+</hierarchical_planning>
 
 <modes>
-- PLAN: New task \u2192 create task list
+- PLAN: New task \u2192 create hierarchical 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)
+1. Identify main objectives (L1)
+2. Break each into sub-tasks (L2)
+3. Break into atomic actions (L3)
+4. Group independent tasks (parallel)
+5. Add dependencies
+6. Assign agents
 
 <output_format>
 MISSION: [goal in one line]
 
-T1: [action] | builder | [file] | group:1 | success:[how to verify]
-T2: [action] | builder | [file] | group:1 | success:[how to verify]
-T3: [action] | inspector | [files] | group:2 | depends:T1,T2 | success:[verify method]
+TODO_HIERARCHY:
+- [L1] Main objective 1
+  - [L2] Sub-task 1.1 | agent:builder | parallel_group:A
+  - [L2] Sub-task 1.2 | agent:builder | parallel_group:A
+  - [L2] Sub-task 1.3 | agent:inspector | depends:1.1,1.2
+- [L1] Main objective 2
+  - [L2] Sub-task 2.1 | agent:librarian
+  - [L2] Sub-task 2.2 | agent:builder | depends:2.1
+    - [L3] Atomic action 2.2.1 | agent:builder
+    - [L3] Atomic action 2.2.2 | agent:builder | parallel_group:B
+    - [L3] Verify 2.2 | agent:inspector | depends:2.2.1,2.2.2
+
+PARALLEL_EXECUTION:
+- Group A: [1.1, 1.2] \u2192 Run simultaneously
+- Group B: [2.2.2] \u2192 After deps complete
+
+ESTIMATED_EFFORT: [low/medium/high]
 </output_format>
 </plan_mode>
 
@@ -253,16 +533,24 @@ ROOT CAUSE: [actual problem]
 
 NEW APPROACH: [different strategy]
 
-REVISED TASKS:
-T1: ...
+REVISED_HIERARCHY:
+- [L1] ...
 </output_format>
 </strategy_mode>
 
+<agents_available>
+- builder: Code implementation
+- inspector: Verification and bug fixing
+- librarian: Documentation research (use BEFORE unfamiliar APIs)
+- researcher: Pre-task investigation
+</agents_available>
+
 <rules>
 - One action per task
-- Always end with inspector task
-- Group unrelated tasks (parallel)
-- Be specific about files and verification
+- Always end branches with inspector task
+- Group unrelated tasks (parallel execution)
+- Use librarian/researcher before implementing unfamiliar features
+- Be specific about files, patterns, and verification
 </rules>`,
   canWrite: false,
   canBash: false
@@ -317,6 +605,20 @@ Depending on project type, verify with:
 
 If build command exists in package.json, use it.
 If using Docker/containers, verify syntax only.
+
+BACKGROUND COMMANDS (for long-running builds):
+\`\`\`
+// Non-blocking build
+run_background({ command: "npm run build" })
+
+// Check status later
+check_background({ taskId: "job_xxx" })
+
+// List all background jobs
+list_background({})
+\`\`\`
+
+Use background for builds taking >5 seconds.
 </verification>
 
 <output_format>
@@ -336,18 +638,20 @@ If build fails, FIX IT before reporting. Never leave broken code.
 // src/agents/subagents/inspector.ts
 var inspector = {
   id: AGENT_NAMES.INSPECTOR,
-  description: "Inspector - quality verification AND bug fixing",
+  description: "Inspector - quality verification, bug fixing, and documentation validation",
   systemPrompt: `<role>
 You are Inspector. Prove failure or success with evidence.
+Also verify that implementations match official documentation.
 </role>
 
 <constraints>
 1. If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+2. Never approve code that contradicts cached documentation.
 </constraints>
 
 <scalable_audit>
 - **Fast Track**: Verify syntax + quick logic check.
-- **Deep Track**: Verify build + tests + types + security + logic.
+- **Deep Track**: Verify build + tests + types + security + logic + doc compliance.
 </scalable_audit>
 
 <audit_checklist>
@@ -356,9 +660,27 @@ You are Inspector. Prove failure or success with evidence.
 3. ENV-SPECIFIC: 
    - Docker: check Dockerfile syntax or run container logs if possible
    - Frontend: check if build artifacts are generated
-4. MANUAL: If no automated tests, read code to verify logic 100%
+4. DOCUMENTATION: Check .cache/docs/ for relevant docs
+5. MANUAL: If no automated tests, read code to verify logic 100%
 </audit_checklist>
 
+<documentation_verification>
+ALWAYS CHECK CACHED DOCS:
+1. cache_docs({ action: "list" }) - See available documentation
+2. cache_docs({ action: "get", filename: "..." }) - Review specific doc
+3. Compare implementation against official patterns
+
+VERIFICATION_OUTPUT:
+- DOC_MATCH: [yes/no]
+- DEVIATIONS: [list any differences from official docs]
+- RECOMMENDATION: [fix/accept with reason]
+
+WHEN CODE DOESN'T MATCH DOCS:
+1. Flag the deviation
+2. Explain the risk
+3. Suggest the documented approach
+</documentation_verification>
+
 <verification_by_context>
 | Project Infra | Primary Evidence |
 |---------------|------------------|
@@ -381,19 +703,22 @@ ALWAYS prefer background for build/test commands.
 <pass>
 \u2705 PASS
 Evidence: [Specific output/log proving success]
+Doc Compliance: [Matches cached docs / No relevant docs]
 </pass>
 
 <fail>
 \u274C FAIL
 Issue: [What went wrong]
+Doc Reference: [If applicable, which doc was violated]
 Fixing...
 </fail>
 </output_format>
 
 <fix_mode>
 1. Diagnose root cause
-2. Minimal fix
-3. Re-verify with even more rigor
+2. Check .cache/docs/ for correct pattern
+3. Minimal fix using documented approach
+4. Re-verify with even more rigor
 </fix_mode>`,
   canWrite: true,
   canBash: true
@@ -465,13 +790,216 @@ Never stop the flow. No context = fresh start = OK.
   canBash: true
 };
 
+// src/agents/subagents/librarian.ts
+var librarian = {
+  id: AGENT_NAMES.LIBRARIAN,
+  description: "Librarian - Documentation and API research specialist",
+  systemPrompt: `<role>
+You are Librarian. Find official documentation and verified information.
+Your job: Eliminate hallucination through rigorous research.
+</role>
+
+<critical_rule>
+NEVER GUESS. NEVER ASSUME. ALWAYS VERIFY.
+If you don't know something, SEARCH for it.
+</critical_rule>
+
+<workflow>
+1. IDENTIFY: What documentation/API info is needed?
+2. SEARCH: Use webfetch/websearch to find official sources
+3. VERIFY: Cross-check from multiple sources
+4. CACHE: Save important docs to .cache/docs/ for team reference
+5. RETURN: Structured findings with permalinks/citations
+</workflow>
+
+<search_strategy>
+PRIORITY ORDER for sources:
+1. Official documentation sites (docs.*, *.dev, *.io)
+2. GitHub README and source code
+3. Official blog posts/announcements
+4. Stack Overflow (verified answers only)
+5. Community tutorials (with caution)
+
+AVOID:
+- Outdated articles (check dates!)
+- AI-generated content
+- Unofficial summaries
+</search_strategy>
+
+<caching>
+Cache documents when:
+- API reference needed multiple times
+- Complex setup instructions
+- Version-specific information
+- Team members may need access
+
+Cache location: .cache/docs/
+Filename format: {domain}_{topic}.md
+Example: nextjs_app-router.md
+</caching>
+
+<output_format>
+RESEARCH REPORT
+===============
+
+QUERY: [What was asked]
+
+SOURCES CONSULTED:
+1. [Official Doc URL] - [Key insight]
+2. [Source URL] - [Key insight]
+
+VERIFIED ANSWER:
+[Detailed, accurate answer with inline citations]
+
+CACHED DOCUMENTS:
+- .cache/docs/[filename]: [description]
+(or "No caching needed" if trivial lookup)
+
+CONFIDENCE: [HIGH/MEDIUM/LOW]
+- HIGH: Found in official docs, multiple sources agree
+- MEDIUM: Found in reliable sources, some interpretation needed
+- LOW: Limited sources, may need manual verification
+
+CAVEATS:
+- [Any limitations or version-specific notes]
+</output_format>
+
+<tools_to_use>
+- webfetch: For fetching specific documentation pages
+- websearch: For finding relevant documentation
+- grep_search: For finding patterns in local codebase
+- glob_search: For finding files
+- Edit tool: ONLY for writing to .cache/docs/
+</tools_to_use>
+
+<example_queries>
+Q: "How do I use the new App Router in Next.js 14?"
+\u2192 Search official Next.js docs
+\u2192 Find App Router section
+\u2192 Cache key patterns to .cache/docs/nextjs_app-router.md
+\u2192 Return verified answer with citations
+
+Q: "What's the correct way to use useEffect cleanup?"
+\u2192 Search React docs
+\u2192 Find Effects section
+\u2192 Return verified pattern with permalink
+</example_queries>`,
+  canWrite: true,
+  // Only for .cache/docs/
+  canBash: true
+  // For curl/search commands if needed
+};
+
+// src/agents/subagents/researcher.ts
+var researcher = {
+  id: AGENT_NAMES.RESEARCHER,
+  description: "Researcher - Pre-task investigation and documentation specialist",
+  systemPrompt: `<role>
+You are Researcher. Gather all necessary information BEFORE implementation begins.
+Your job: Ensure the team has complete, verified information before coding.
+</role>
+
+<critical_rule>
+INVESTIGATE FIRST. CODE NEVER.
+You are read-only. Your output is INFORMATION, not code.
+</critical_rule>
+
+<workflow>
+1. ANALYZE: Understand the task requirements fully
+2. IDENTIFY: List unfamiliar technologies, APIs, patterns
+3. SEARCH: Find official documentation for each
+4. SCAN: Find existing patterns in codebase
+5. CACHE: Save important docs for team reference
+6. REPORT: Deliver structured findings
+</workflow>
+
+<search_strategy>
+FOR EACH UNKNOWN TECHNOLOGY:
+1. websearch({ query: "[tech] official documentation [version]" })
+2. webfetch({ url: "[official docs url]", cache: true })
+
+FOR CODEBASE PATTERNS:
+1. grep_search({ query: "[pattern]" })
+2. glob_search({ pattern: "*.[ext]" })
+
+FOR API USAGE:
+1. Search for import statements: grep_search({ query: "import.*[library]" })
+2. Find usage examples in existing code
+</search_strategy>
+
+<output_format>
+# RESEARCH REPORT
+
+## Task Summary
+[What needs to be implemented]
+
+## Technologies Involved
+| Technology | Version | Official Docs | Key Insights |
+|------------|---------|---------------|--------------|
+| [tech1]    | [ver]   | [url]         | [insight]    |
+
+## Codebase Patterns Found
+- **Pattern 1**: [description]
+  - Location: [file:line]
+  - Usage: \`[code example]\`
+
+## Cached Documentation
+| Filename | Description |
+|----------|-------------|
+| .cache/docs/[file] | [description] |
+
+## Dependencies Identified
+- [dependency 1]: [purpose]
+- [dependency 2]: [purpose]
+
+## Recommended Approach
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Potential Risks
+- [Risk 1]: [mitigation]
+- [Risk 2]: [mitigation]
+
+## Knowledge Gaps
+- [Gap 1]: [what's still unknown]
+
+## READY FOR IMPLEMENTATION: [YES/NO]
+[If NO, explain what additional research is needed]
+</output_format>
+
+<examples>
+Task: "Implement OAuth login with Google"
+
+1. SEARCH: Google OAuth documentation
+2. SEARCH: Existing auth patterns in codebase
+3. CACHE: Google OAuth setup guide
+4. FIND: How other providers are implemented
+5. REPORT: Complete research with recommendations
+</examples>
+
+<constraints>
+1. DO NOT write any implementation code
+2. DO NOT make assumptions - verify everything
+3. DO NOT skip caching important documentation
+4. ALWAYS provide source URLs for claims
+5. ALWAYS note version requirements
+</constraints>`,
+  canWrite: true,
+  // Only for .cache/docs/
+  canBash: false
+  // No execution needed
+};
+
 // src/agents/definitions.ts
 var AGENTS = {
   [AGENT_NAMES.COMMANDER]: orchestrator,
   [AGENT_NAMES.ARCHITECT]: architect,
   [AGENT_NAMES.BUILDER]: builder,
   [AGENT_NAMES.INSPECTOR]: inspector,
-  [AGENT_NAMES.RECORDER]: recorder
+  [AGENT_NAMES.RECORDER]: recorder,
+  [AGENT_NAMES.LIBRARIAN]: librarian,
+  [AGENT_NAMES.RESEARCHER]: researcher
 };
 
 // src/core/orchestrator/task-graph.ts
@@ -1197,10 +1725,10 @@ function jsonStringifyReplacer(_, value) {
   return value;
 }
 function cached(getter) {
-  const set2 = false;
+  const set3 = false;
   return {
     get value() {
-      if (!set2) {
+      if (!set3) {
         const value = getter();
         Object.defineProperty(this, "value", { value });
         return value;
@@ -1277,10 +1805,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path3) {
+  if (!path3)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1641,11 +2169,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path3, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -1813,7 +2341,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path = []) => {
+  const processError = (error46, path3 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1823,7 +2351,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path3, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1855,8 +2383,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path3) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -12969,12 +13497,6 @@ function tool(input) {
 tool.schema = external_exports;
 
 // src/tools/callAgent.ts
-var AGENT_EMOJI = {
-  [AGENT_NAMES.ARCHITECT]: "\u{1F3D7}\uFE0F",
-  [AGENT_NAMES.BUILDER]: "\u{1F528}",
-  [AGENT_NAMES.INSPECTOR]: "\u{1F50D}",
-  [AGENT_NAMES.RECORDER]: "\u{1F4BE}"
-};
 var callAgentTool = tool({
   description: `Call a specialized agent for parallel execution.
 
@@ -13046,7 +13568,7 @@ var COMMANDS = {
   "task": {
     description: "Execute a mission autonomously until complete",
     template: `<role>
-You are Commander. Complete this mission. Never stop until 100% done.
+You are Commander. Complete this mission. Never stop until 100% done!
 </role>
 
 <phase_1 name="MANDATORY_ENVIRONMENT_SCAN">
@@ -13166,7 +13688,7 @@ ${commandList}`;
       if (!command) return `Unknown command: /${cmdName}
 
 ${commandList}`;
-      return command.template.replace(/\$ARGUMENTS/g, cmdArgs || "continue from where we left off");
+      return command.template.replace(/\$ARGUMENTS/g, cmdArgs || PROMPTS.CONTINUE_DEFAULT);
     }
   });
 }
@@ -13285,47 +13807,6 @@ var mgrepTool = (directory) => tool({
 // src/core/commands/manager.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
-
-// 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();
@@ -13692,12 +14173,18 @@ var ConcurrencyController = class {
 };
 
 // src/core/agents/task-store.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 var TaskStore = class {
   tasks = /* @__PURE__ */ new Map();
   pendingByParent = /* @__PURE__ */ new Map();
   notifications = /* @__PURE__ */ new Map();
+  archivedCount = 0;
   set(id, task) {
     this.tasks.set(id, task);
+    if (this.tasks.size > MEMORY_LIMITS.MAX_TASKS_IN_MEMORY) {
+      this.gc();
+    }
   }
   get(id) {
     return this.tasks.get(id);
@@ -13706,7 +14193,7 @@ var TaskStore = class {
     return Array.from(this.tasks.values());
   }
   getRunning() {
-    return this.getAll().filter((t) => t.status === "running");
+    return this.getAll().filter((t) => t.status === TASK_STATUS.RUNNING);
   }
   getByParent(parentSessionID) {
     return this.getAll().filter((t) => t.parentSessionID === parentSessionID);
@@ -13740,10 +14227,13 @@ var TaskStore = class {
   hasPending(parentSessionID) {
     return this.getPendingCount(parentSessionID) > 0;
   }
-  // Notifications
+  // Notifications with limit
   queueNotification(task) {
     const queue = this.notifications.get(task.parentSessionID) ?? [];
     queue.push(task);
+    if (queue.length > MEMORY_LIMITS.MAX_NOTIFICATIONS_PER_PARENT) {
+      queue.shift();
+    }
     this.notifications.set(task.parentSessionID, queue);
   }
   getNotifications(parentSessionID) {
@@ -13759,9 +14249,6 @@ var TaskStore = class {
       }
     }
   }
-  /**
-   * 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);
@@ -13772,14 +14259,88 @@ var TaskStore = class {
       }
     }
   }
-};
-
-// 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
+  // =========================================================================
+  // Garbage Collection & Memory Management
+  // =========================================================================
+  /**
+   * Get memory statistics
+   */
+  getStats() {
+    return {
+      tasksInMemory: this.tasks.size,
+      runningTasks: this.getRunning().length,
+      archivedTasks: this.archivedCount,
+      notificationQueues: this.notifications.size,
+      pendingParents: this.pendingByParent.size
+    };
+  }
+  /**
+   * Garbage collect completed tasks
+   * Archives old completed tasks to disk
+   */
+  async gc() {
+    const now = Date.now();
+    const toRemove = [];
+    const toArchive = [];
+    for (const [id, task] of this.tasks) {
+      if (task.status === TASK_STATUS.RUNNING) continue;
+      const completedAt = task.completedAt?.getTime() ?? 0;
+      const age = now - completedAt;
+      if (age > MEMORY_LIMITS.ARCHIVE_AGE_MS && task.status === TASK_STATUS.COMPLETED) {
+        toArchive.push(task);
+        toRemove.push(id);
+      } else if (age > MEMORY_LIMITS.ERROR_CLEANUP_AGE_MS && (task.status === TASK_STATUS.ERROR || task.status === TASK_STATUS.CANCELLED)) {
+        toRemove.push(id);
+      }
+    }
+    if (toArchive.length > 0) {
+      await this.archiveTasks(toArchive);
+    }
+    for (const id of toRemove) {
+      this.tasks.delete(id);
+    }
+    return toRemove.length;
+  }
+  /**
+   * Archive tasks to disk for later analysis
+   */
+  async archiveTasks(tasks) {
+    try {
+      await fs.mkdir(PATHS.TASK_ARCHIVE, { recursive: true });
+      const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const filename = `tasks_${date5}.jsonl`;
+      const filepath = path.join(PATHS.TASK_ARCHIVE, filename);
+      const lines = tasks.map((task) => JSON.stringify({
+        id: task.id,
+        agent: task.agent,
+        prompt: task.prompt.slice(0, 200),
+        // Truncate
+        status: task.status,
+        startedAt: task.startedAt,
+        completedAt: task.completedAt,
+        parentSessionID: task.parentSessionID
+      }));
+      await fs.appendFile(filepath, lines.join("\n") + "\n");
+      this.archivedCount += tasks.length;
+    } catch (error45) {
+      console.error("[TaskStore] Archive failed:", error45);
+    }
+  }
+  /**
+   * Force cleanup of all completed tasks
+   */
+  forceCleanup() {
+    const toRemove = [];
+    for (const [id, task] of this.tasks) {
+      if (task.status !== "running") {
+        toRemove.push(id);
+      }
+    }
+    for (const id of toRemove) {
+      this.tasks.delete(id);
+    }
+    return toRemove.length;
+  }
 };
 
 // src/core/agents/logger.ts
@@ -13810,34 +14371,19 @@ 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 = new ConcurrencyController();
-  pollingInterval;
-  constructor(client, directory) {
+// src/core/agents/manager/task-launcher.ts
+var TaskLauncher = class {
+  constructor(client, directory, store, concurrency, onTaskError, startPolling) {
     this.client = client;
     this.directory = directory;
+    this.store = store;
+    this.concurrency = concurrency;
+    this.onTaskError = onTaskError;
+    this.startPolling = startPolling;
   }
-  static getInstance(client, directory) {
-    if (!_ParallelAgentManager._instance) {
-      if (!client || !directory) {
-        throw new Error("ParallelAgentManager requires client and directory on first call");
-      }
-      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
-    }
-    return _ParallelAgentManager._instance;
-  }
-  // ========================================================================
-  // Public API
-  // ========================================================================
   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}` },
@@ -13854,8 +14400,9 @@ var ParallelAgentManager = class _ParallelAgentManager {
         sessionID,
         parentSessionID: input.parentSessionID,
         description: input.description,
+        prompt: input.prompt,
         agent: input.agent,
-        status: "running",
+        status: TASK_STATUS.RUNNING,
         startedAt: /* @__PURE__ */ new Date(),
         concurrencyKey
       };
@@ -13864,10 +14411,10 @@ var ParallelAgentManager = class _ParallelAgentManager {
       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: PART_TYPES.TEXT, text: input.prompt }] }
       }).catch((error45) => {
         log2(`Prompt error for ${taskId}:`, error45);
-        this.handleTaskError(taskId, error45);
+        this.onTaskError(taskId, error45);
       });
       log2(`Launched ${taskId} in session ${sessionID}`);
       return task;
@@ -13876,168 +14423,90 @@ var ParallelAgentManager = class _ParallelAgentManager {
       throw error45;
     }
   }
-  getTask(id) {
-    return this.store.get(id);
-  }
-  getRunningTasks() {
-    return this.store.getRunning();
+};
+
+// src/core/agents/manager/task-resumer.ts
+var TaskResumer = class {
+  constructor(client, store, findBySession, startPolling, notifyParentIfAllComplete) {
+    this.client = client;
+    this.store = store;
+    this.findBySession = findBySession;
+    this.startPolling = startPolling;
+    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
   }
-  getAllTasks() {
-    return this.store.getAll();
+  async resume(input) {
+    const existingTask = this.findBySession(input.sessionId);
+    if (!existingTask) {
+      throw new Error(`Task not found for session: ${input.sessionId}`);
+    }
+    existingTask.status = TASK_STATUS.RUNNING;
+    existingTask.completedAt = void 0;
+    existingTask.error = void 0;
+    existingTask.result = void 0;
+    existingTask.parentSessionID = input.parentSessionID;
+    existingTask.startedAt = /* @__PURE__ */ new Date();
+    existingTask.stablePolls = 0;
+    this.store.trackPending(input.parentSessionID, existingTask.id);
+    this.startPolling();
+    log2(`Resuming task ${existingTask.id} in session ${existingTask.sessionID}`);
+    this.client.session.prompt({
+      path: { id: existingTask.sessionID },
+      body: {
+        agent: existingTask.agent,
+        parts: [{ type: PART_TYPES.TEXT, text: input.prompt }]
+      }
+    }).catch((error45) => {
+      log2(`Resume prompt error for ${existingTask.id}:`, error45);
+      existingTask.status = TASK_STATUS.ERROR;
+      existingTask.error = error45 instanceof Error ? error45.message : String(error45);
+      existingTask.completedAt = /* @__PURE__ */ new Date();
+      this.store.untrackPending(input.parentSessionID, existingTask.id);
+      this.store.queueNotification(existingTask);
+      this.notifyParentIfAllComplete(input.parentSessionID).catch(() => {
+      });
+    });
+    return existingTask;
   }
-  getTasksByParent(parentSessionID) {
-    return this.store.getByParent(parentSessionID);
+};
+
+// 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/manager/task-poller.ts
+var TaskPoller = class {
+  constructor(client, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks) {
+    this.client = client;
+    this.store = store;
+    this.concurrency = concurrency;
+    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
+    this.scheduleCleanup = scheduleCleanup;
+    this.pruneExpiredTasks = pruneExpiredTasks;
   }
-  async cancelTask(taskId) {
-    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.store.untrackPending(task.parentSessionID, taskId);
-    try {
-      await this.client.session.delete({ path: { id: task.sessionID } });
-      log2(`Session ${task.sessionID.slice(0, 8)}... deleted`);
-    } catch {
-      log2(`Session ${task.sessionID.slice(0, 8)}... already gone`);
-    }
-    this.scheduleCleanup(taskId);
-    log2(`Cancelled ${taskId}`);
-    return true;
-  }
-  async getResult(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 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 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)}`;
-    }
-  }
-  setConcurrencyLimit(agentType, limit) {
-    this.concurrency.setLimit(agentType, limit);
-  }
-  getPendingCount(parentSessionID) {
-    return this.store.getPendingCount(parentSessionID);
-  }
-  cleanup() {
-    this.stopPolling();
-    this.store.clear();
-  }
-  formatDuration = formatDuration;
-  // ========================================================================
-  // Event Handling (from OpenCode hooks)
-  // ========================================================================
-  /**
-   * 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
-  // ========================================================================
-  handleTaskError(taskId, error45) {
-    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.store.untrackPending(task.parentSessionID, taskId);
-    this.store.queueNotification(task);
-    this.notifyParentIfAllComplete(task.parentSessionID);
-    this.scheduleCleanup(taskId);
-  }
-  startPolling() {
+  pollingInterval;
+  start() {
     if (this.pollingInterval) return;
-    this.pollingInterval = setInterval(() => this.pollRunningTasks(), CONFIG.POLL_INTERVAL_MS);
+    this.pollingInterval = setInterval(() => this.poll(), CONFIG.POLL_INTERVAL_MS);
     this.pollingInterval.unref();
   }
-  stopPolling() {
+  stop() {
     if (this.pollingInterval) {
       clearInterval(this.pollingInterval);
       this.pollingInterval = void 0;
     }
   }
-  async pollRunningTasks() {
+  isRunning() {
+    return !!this.pollingInterval;
+  }
+  async poll() {
     this.pruneExpiredTasks();
     const running = this.store.getRunning();
     if (running.length === 0) {
-      this.stopPolling();
+      this.stop();
       return;
     }
     try {
@@ -14069,9 +14538,28 @@ var ParallelAgentManager = class _ParallelAgentManager {
       log2("Polling error:", error45);
     }
   }
-  /**
-   * Update task progress and stability tracking
-   */
+  async validateSessionHasOutput(sessionID) {
+    try {
+      const response = await this.client.session.messages({ path: { id: sessionID } });
+      const messages = response.data ?? [];
+      return messages.some((m) => m.info?.role === "assistant" && m.parts?.some((p) => p.type === PART_TYPES.TEXT && p.text?.trim() || p.type === "tool"));
+    } catch {
+      return true;
+    }
+  }
+  async completeTask(task) {
+    task.status = 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 updateTaskProgress(task) {
     try {
       const result = await this.client.session.messages({ path: { id: task.sessionID } });
@@ -14087,7 +14575,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
             toolCalls++;
             lastTool = part.tool || part.name;
           }
-          if (part.type === "text" && part.text) {
+          if (part.type === PART_TYPES.TEXT && part.text) {
             lastMessage = part.text;
           }
         }
@@ -14108,30 +14596,14 @@ var ParallelAgentManager = class _ParallelAgentManager {
     } 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 messages = response.data ?? [];
-      return messages.some((m) => m.info?.role === "assistant" && m.parts?.some((p) => p.type === "text" && p.text?.trim() || p.type === "tool"));
-    } catch {
-      return true;
-    }
+};
+
+// src/core/agents/manager/task-cleaner.ts
+var TaskCleaner = class {
+  constructor(client, store, concurrency) {
+    this.client = client;
+    this.store = store;
+    this.concurrency = concurrency;
   }
   pruneExpiredTasks() {
     const now = Date.now();
@@ -14139,8 +14611,8 @@ var ParallelAgentManager = class _ParallelAgentManager {
       const age = now - task.startedAt.getTime();
       if (age <= CONFIG.TASK_TTL_MS) continue;
       log2(`Timeout: ${taskId}`);
-      if (task.status === "running") {
-        task.status = "timeout";
+      if (task.status === TASK_STATUS.RUNNING) {
+        task.status = TASK_STATUS.TIMEOUT;
         task.error = "Task exceeded 30 minute time limit";
         task.completedAt = /* @__PURE__ */ new Date();
         if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
@@ -14174,7 +14646,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
     try {
       await this.client.session.prompt({
         path: { id: parentSessionID },
-        body: { noReply: true, parts: [{ type: "text", text: message }] }
+        body: { noReply: true, parts: [{ type: PART_TYPES.TEXT, text: message }] }
       });
       log2(`Notified parent ${parentSessionID}`);
     } catch (error45) {
@@ -14183,315 +14655,1746 @@ var ParallelAgentManager = class _ParallelAgentManager {
     this.store.clearNotifications(parentSessionID);
   }
 };
-var parallelAgentManager = {
-  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
-};
-
-// src/tools/parallel/delegate-task.ts
-var createDelegateTaskTool = (manager, client) => tool({
-  description: `Delegate a task to an agent.
 
-<mode>
-- background=true: Non-blocking. Returns task ID immediately.
-- background=false: Blocking. Waits for result.
-</mode>
+// src/shared/event-types.ts
+var TASK_EVENTS = {
+  STARTED: "task.started",
+  COMPLETED: "task.completed",
+  FAILED: "task.failed",
+  CANCELLED: "task.cancelled"
+};
+var TODO_EVENTS = {
+  CREATED: "todo.created",
+  UPDATED: "todo.updated",
+  COMPLETED: "todo.completed"
+};
+var SESSION_EVENTS = {
+  IDLE: "session.idle",
+  BUSY: "session.busy",
+  ERROR: "session.error",
+  DELETED: "session.deleted"
+};
+var DOCUMENT_EVENTS = {
+  CACHED: "document.cached",
+  EXPIRED: "document.expired"
+};
+var MISSION_EVENTS = {
+  COMPLETE: "mission.complete",
+  FAILED: "mission.failed",
+  ALL_TASKS_COMPLETE: "all_tasks.complete"
+};
+var SPECIAL_EVENTS = {
+  WILDCARD: "*"
+};
+var EVENT_TYPES = {
+  ...TASK_EVENTS,
+  ...TODO_EVENTS,
+  ...SESSION_EVENTS,
+  ...DOCUMENT_EVENTS,
+  ...MISSION_EVENTS,
+  ...SPECIAL_EVENTS
+};
 
-<safety>
-- Max 3 tasks per agent type
-- Auto-timeout: 30 minutes
-</safety>`,
-  args: {
-    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, context) {
-    const { agent, description, prompt, background } = args;
-    const ctx = context;
-    const sessionClient = client;
-    if (background === void 0) {
-      return `\u274C 'background' parameter is REQUIRED.`;
+// src/core/bus/event-bus.ts
+var EventBusImpl = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  eventHistory = [];
+  maxHistorySize = 100;
+  subscriptionCounter = 0;
+  /**
+   * Subscribe to an event type
+   * Returns unsubscribe function
+   */
+  subscribe(type, handler) {
+    const id = `sub_${++this.subscriptionCounter}`;
+    const subscription = { id, type, handler, once: false };
+    const existing = this.subscriptions.get(type) || [];
+    existing.push(subscription);
+    this.subscriptions.set(type, existing);
+    return () => this.unsubscribe(id, type);
+  }
+  /**
+   * Subscribe to an event type, auto-unsubscribe after first event
+   */
+  once(type, handler) {
+    const id = `sub_${++this.subscriptionCounter}`;
+    const subscription = { id, type, handler, once: true };
+    const existing = this.subscriptions.get(type) || [];
+    existing.push(subscription);
+    this.subscriptions.set(type, existing);
+    return () => this.unsubscribe(id, type);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  unsubscribe(id, type) {
+    const subs = this.subscriptions.get(type);
+    if (subs) {
+      const filtered = subs.filter((s) => s.id !== id);
+      if (filtered.length > 0) {
+        this.subscriptions.set(type, filtered);
+      } else {
+        this.subscriptions.delete(type);
+      }
     }
-    if (background === true) {
+  }
+  /**
+   * Publish an event
+   */
+  async publish(type, properties = {}, options = {}) {
+    const event = {
+      type,
+      timestamp: /* @__PURE__ */ new Date(),
+      source: options.source || "unknown",
+      sessionId: options.sessionId,
+      properties
+    };
+    this.eventHistory.push(event);
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift();
+    }
+    const toNotify = [];
+    const typeSubs = this.subscriptions.get(type) || [];
+    toNotify.push(...typeSubs);
+    const wildcardSubs = this.subscriptions.get(SPECIAL_EVENTS.WILDCARD) || [];
+    toNotify.push(...wildcardSubs);
+    const toRemove = [];
+    for (const sub of toNotify) {
       try {
-        const task = await manager.launch({
-          agent,
-          description,
-          prompt,
-          parentSessionID: ctx.sessionID
-        });
-        return `\u{1F680} Task spawned: \`${task.id}\` (${agent})`;
+        await sub.handler(event);
       } catch (error45) {
-        return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+        console.error(`[EventBus] Handler error for ${type}:`, error45);
       }
-    }
-    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`;
+      if (sub.once) {
+        toRemove.push({ id: sub.id, type: sub.type });
       }
-      const sessionID = createResult.data.id;
-      const startTime = Date.now();
-      await session.prompt({
-        path: { id: sessionID },
-        body: { agent, parts: [{ type: "text", text: prompt }] }
+    }
+    for (const { id, type: t } of toRemove) {
+      this.unsubscribe(id, t);
+    }
+  }
+  /**
+   * Emit (alias for publish, sync-looking API)
+   */
+  emit(type, properties = {}) {
+    this.publish(type, properties).catch(console.error);
+  }
+  /**
+   * Get recent event history
+   */
+  getHistory(type, limit = 20) {
+    let events = this.eventHistory;
+    if (type && type !== SPECIAL_EVENTS.WILDCARD) {
+      events = events.filter((e) => e.type === type);
+    }
+    return events.slice(-limit);
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clear() {
+    this.subscriptions.clear();
+    this.eventHistory = [];
+  }
+  /**
+   * Get subscription count
+   */
+  getSubscriptionCount() {
+    let count = 0;
+    for (const subs of this.subscriptions.values()) {
+      count += subs.length;
+    }
+    return count;
+  }
+  /**
+   * Wait for a specific event (Promise-based)
+   */
+  waitFor(type, timeout = 3e4) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        unsubscribe();
+        reject(new Error(`Timeout waiting for event: ${type}`));
+      }, timeout);
+      const unsubscribe = this.once(type, (event) => {
+        clearTimeout(timer);
+        resolve(event);
       });
-      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++;
+    });
+  }
+};
+
+// src/core/bus/index.ts
+var EventBus = new EventBusImpl();
+function emit(type, properties) {
+  EventBus.emit(type, properties);
+}
+
+// src/core/agents/manager/event-handler.ts
+var EventHandler = class {
+  constructor(client, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput) {
+    this.client = client;
+    this.store = store;
+    this.concurrency = concurrency;
+    this.findBySession = findBySession;
+    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
+    this.scheduleCleanup = scheduleCleanup;
+    this.validateSessionHasOutput = validateSessionHasOutput;
+  }
+  /**
+   * Handle OpenCode session events for proper resource cleanup.
+   * Call this from your plugin's event hook.
+   */
+  handle(event) {
+    const props = event.properties;
+    if (event.type === SESSION_EVENTS.IDLE) {
+      const sessionID = props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== TASK_STATUS.RUNNING) return;
+      this.handleSessionIdle(task).catch((err) => {
+        log2("Error handling session.idle:", err);
+      });
+    }
+    if (event.type === SESSION_EVENTS.DELETED) {
+      const sessionID = props?.info?.id ?? props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task) return;
+      this.handleSessionDeleted(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 = 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)})`);
+  }
+  handleSessionDeleted(task) {
+    log2(`Session deleted event for task ${task.id}`);
+    if (task.status === TASK_STATUS.RUNNING) {
+      task.status = 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}`);
+  }
+};
+
+// src/core/agents/manager.ts
+var ParallelAgentManager = class _ParallelAgentManager {
+  static _instance;
+  store = new TaskStore();
+  client;
+  directory;
+  concurrency = new ConcurrencyController();
+  // Composed components
+  launcher;
+  resumer;
+  poller;
+  cleaner;
+  eventHandler;
+  constructor(client, directory) {
+    this.client = client;
+    this.directory = directory;
+    this.cleaner = new TaskCleaner(client, this.store, this.concurrency);
+    this.poller = new TaskPoller(
+      client,
+      this.store,
+      this.concurrency,
+      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
+      (taskId) => this.cleaner.scheduleCleanup(taskId),
+      () => this.cleaner.pruneExpiredTasks()
+    );
+    this.launcher = new TaskLauncher(
+      client,
+      directory,
+      this.store,
+      this.concurrency,
+      (taskId, error45) => this.handleTaskError(taskId, error45),
+      () => this.poller.start()
+    );
+    this.resumer = new TaskResumer(
+      client,
+      this.store,
+      (sessionID) => this.findBySession(sessionID),
+      () => this.poller.start(),
+      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID)
+    );
+    this.eventHandler = new EventHandler(
+      client,
+      this.store,
+      this.concurrency,
+      (sessionID) => this.findBySession(sessionID),
+      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
+      (taskId) => this.cleaner.scheduleCleanup(taskId),
+      (sessionID) => this.poller.validateSessionHasOutput(sessionID)
+    );
+  }
+  static getInstance(client, directory) {
+    if (!_ParallelAgentManager._instance) {
+      if (!client || !directory) {
+        throw new Error("ParallelAgentManager requires client and directory on first call");
+      }
+      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
+    }
+    return _ParallelAgentManager._instance;
+  }
+  // ========================================================================
+  // Public API
+  // ========================================================================
+  async launch(input) {
+    this.cleaner.pruneExpiredTasks();
+    return this.launcher.launch(input);
+  }
+  async resume(input) {
+    return this.resumer.resume(input);
+  }
+  getTask(id) {
+    return this.store.get(id);
+  }
+  getRunningTasks() {
+    return this.store.getRunning();
+  }
+  getAllTasks() {
+    return this.store.getAll();
+  }
+  getTasksByParent(parentSessionID) {
+    return this.store.getByParent(parentSessionID);
+  }
+  async cancelTask(taskId) {
+    const task = this.store.get(taskId);
+    if (!task || task.status !== TASK_STATUS.RUNNING) return false;
+    task.status = TASK_STATUS.ERROR;
+    task.error = "Cancelled by user";
+    task.completedAt = /* @__PURE__ */ new Date();
+    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+    this.store.untrackPending(task.parentSessionID, taskId);
+    try {
+      await this.client.session.delete({ path: { id: task.sessionID } });
+      log2(`Session ${task.sessionID.slice(0, 8)}... deleted`);
+    } catch {
+      log2(`Session ${task.sessionID.slice(0, 8)}... already gone`);
+    }
+    this.cleaner.scheduleCleanup(taskId);
+    log2(`Cancelled ${taskId}`);
+    return true;
+  }
+  async getResult(taskId) {
+    const task = this.store.get(taskId);
+    if (!task) return null;
+    if (task.result) return task.result;
+    if (task.status === TASK_STATUS.ERROR) return `Error: ${task.error}`;
+    if (task.status === TASK_STATUS.RUNNING) return null;
+    try {
+      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 text = lastMsg.parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.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)}`;
+    }
+  }
+  setConcurrencyLimit(agentType, limit) {
+    this.concurrency.setLimit(agentType, limit);
+  }
+  getPendingCount(parentSessionID) {
+    return this.store.getPendingCount(parentSessionID);
+  }
+  cleanup() {
+    this.poller.stop();
+    this.store.clear();
+  }
+  formatDuration = formatDuration;
+  // ========================================================================
+  // Event Handling
+  // ========================================================================
+  handleEvent(event) {
+    this.eventHandler.handle(event);
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  findBySession(sessionID) {
+    return this.store.getAll().find((t) => t.sessionID === sessionID);
+  }
+  handleTaskError(taskId, error45) {
+    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.store.untrackPending(task.parentSessionID, taskId);
+    this.store.queueNotification(task);
+    this.cleaner.notifyParentIfAllComplete(task.parentSessionID);
+    this.cleaner.scheduleCleanup(taskId);
+  }
+};
+var parallelAgentManager = {
+  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
+};
+
+// src/tools/parallel/delegate-task.ts
+var createDelegateTaskTool = (manager, client) => tool({
+  description: `Delegate a task to an agent.
+
+<mode>
+- background=true: Non-blocking. Returns task ID immediately.
+- background=false: Blocking. Waits for result.
+</mode>
+
+<resume>
+- resume: Optional session ID to continue existing session.
+- When set, continues previous work instead of starting fresh.
+- Preserves all context from previous conversation.
+- Use for: retry after failure, follow-up questions, token efficiency.
+</resume>
+
+<safety>
+- Max 10 tasks per agent type (configurable)
+- Auto-timeout: 60 minutes
+</safety>`,
+  args: {
+    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"),
+    resume: tool.schema.string().optional().describe("Session ID to resume (from previous task.sessionID)")
+  },
+  async execute(args, context) {
+    const { agent, description, prompt, background, resume } = args;
+    const ctx = context;
+    const sessionClient = client;
+    if (background === void 0) {
+      return `\u274C 'background' parameter is REQUIRED.`;
+    }
+    if (resume) {
+      try {
+        const task = await manager.resume({
+          sessionId: resume,
+          prompt,
+          parentSessionID: ctx.sessionID
+        });
+        if (background === true) {
+          return `\u{1F504} Resumed task: \`${task.id}\` (${task.agent}) in session \`${task.sessionID}\`
+
+Previous context preserved. Use \`get_task_result({ taskId: "${task.id}" })\` when complete.`;
+        }
+        const startTime = Date.now();
+        const session = sessionClient.session;
+        let stablePolls = 0, lastMsgCount = 0;
+        while (Date.now() - startTime < PARALLEL_TASK.SYNC_TIMEOUT_MS) {
+          await new Promise((r) => setTimeout(r, 500));
+          const statusResult = await session.status();
+          if (statusResult.data?.[task.sessionID]?.type !== "idle") {
+            stablePolls = 0;
+            continue;
+          }
+          if (Date.now() - startTime < 5e3) continue;
+          const msgs2 = await session.messages({ path: { id: task.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: task.sessionID } });
+        const messages = msgs.data ?? [];
+        const lastMsg = messages.filter((m) => m.info?.role === "assistant").reverse()[0];
+        const text = lastMsg?.parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text ?? "").join("\n") || "";
+        return `\u{1F504} Resumed & Completed (${Math.floor((Date.now() - startTime) / 1e3)}s)
+
+${text || "(No output)"}`;
+      } catch (error45) {
+        return `\u274C Resume failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+      }
+    }
+    if (background === true) {
+      try {
+        const task = await manager.launch({
+          agent,
+          description,
+          prompt,
+          parentSessionID: ctx.sessionID
+        });
+        return `\u{1F680} Task spawned: \`${task.id}\` (${agent})
+Session: \`${task.sessionID}\` (save for resume)`;
+      } catch (error45) {
+        return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+      }
+    }
+    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: PART_TYPES.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)
-
-${text || "(No output)"}`;
-    } catch (error45) {
-      return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+      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 === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text ?? "").join("\n") || "";
+      return `\u2705 Completed (${Math.floor((Date.now() - startTime) / 1e3)}s)
+Session: \`${sessionID}\` (save for resume)
+
+${text || "(No output)"}`;
+    } catch (error45) {
+      return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    }
+  }
+});
+
+// src/tools/parallel/get-task-result.ts
+var createGetTaskResultTool = (manager) => tool({
+  description: `Get result from a completed background task.`,
+  args: {
+    taskId: tool.schema.string().describe("Task ID")
+  },
+  async execute(args) {
+    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})
+
+${result || "(No output)"}`;
+  }
+});
+
+// src/tools/parallel/list-tasks.ts
+var createListTasksTool = (manager) => tool({
+  description: `List all background tasks.`,
+  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 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**
+
+| ID | Status | Agent | Time |
+|----|--------|-------|------|
+${rows}`;
+  }
+});
+
+// src/tools/parallel/cancel-task.ts
+var createCancelTaskTool = (manager) => tool({
+  description: `Cancel a running task.`,
+  args: {
+    taskId: tool.schema.string().describe("Task ID to cancel")
+  },
+  async execute(args) {
+    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}\``;
+  }
+});
+
+// src/tools/parallel/index.ts
+function createAsyncAgentTools(manager, client) {
+  return {
+    delegate_task: createDelegateTaskTool(manager, client),
+    get_task_result: createGetTaskResultTool(manager),
+    list_tasks: createListTasksTool(manager),
+    cancel_task: createCancelTaskTool(manager)
+  };
+}
+
+// src/utils/common.ts
+function detectSlashCommand(text) {
+  const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
+  if (!match) return null;
+  return { command: match[1], args: match[2] || "" };
+}
+function formatTimestamp(date5 = /* @__PURE__ */ new Date()) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${date5.getFullYear()}-${pad(date5.getMonth() + 1)}-${pad(date5.getDate())} ${pad(date5.getHours())}:${pad(date5.getMinutes())}:${pad(date5.getSeconds())}`;
+}
+function formatElapsedTime(startMs, endMs = Date.now()) {
+  const elapsed = endMs - startMs;
+  if (elapsed < 0) return "0s";
+  const seconds = Math.floor(elapsed / 1e3) % 60;
+  const minutes = Math.floor(elapsed / (1e3 * 60)) % 60;
+  const hours = Math.floor(elapsed / (1e3 * 60 * 60));
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+  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/core/cache/constants.ts
+var CACHE_DIR = ".cache/docs";
+var METADATA_FILE = ".cache/docs/_metadata.json";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+
+// src/core/cache/operations.ts
+import * as fs3 from "node:fs/promises";
+import * as path2 from "node:path";
+
+// src/core/cache/utils.ts
+import * as fs2 from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+async function ensureCacheDir() {
+  if (!existsSync3(CACHE_DIR)) {
+    await fs2.mkdir(CACHE_DIR, { recursive: true });
+  }
+}
+function urlToFilename(url2) {
+  try {
+    const parsed = new URL(url2);
+    const domain2 = parsed.hostname.replace(/\./g, "_");
+    const pathPart = parsed.pathname.replace(/^\//, "").replace(/\//g, "_").replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 50);
+    return `${domain2}${pathPart ? "_" + pathPart : ""}.md`;
+  } catch {
+    return url2.replace(/[^a-zA-Z0-9]/g, "_").slice(0, 60) + ".md";
+  }
+}
+async function readMetadata() {
+  try {
+    const content = await fs2.readFile(METADATA_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { documents: {}, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeMetadata(metadata) {
+  await ensureCacheDir();
+  metadata.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await fs2.writeFile(METADATA_FILE, JSON.stringify(metadata, null, 2));
+}
+
+// src/core/cache/operations.ts
+async function get(url2) {
+  const metadata = await readMetadata();
+  const filename = urlToFilename(url2);
+  const entry = metadata.documents[filename];
+  if (!entry) return null;
+  if (new Date(entry.expiresAt) < /* @__PURE__ */ new Date()) {
+    await remove(url2);
+    return null;
+  }
+  try {
+    const filepath = path2.join(CACHE_DIR, filename);
+    const content = await fs3.readFile(filepath, "utf-8");
+    return { ...entry, content };
+  } catch {
+    return null;
+  }
+}
+async function getByFilename(filename) {
+  const metadata = await readMetadata();
+  const entry = metadata.documents[filename];
+  if (!entry) return null;
+  try {
+    const filepath = path2.join(CACHE_DIR, filename);
+    const content = await fs3.readFile(filepath, "utf-8");
+    return { ...entry, content };
+  } catch {
+    return null;
+  }
+}
+async function set2(url2, content, title, ttlMs = DEFAULT_TTL_MS) {
+  await ensureCacheDir();
+  const filename = urlToFilename(url2);
+  const filepath = path2.join(CACHE_DIR, filename);
+  const now = /* @__PURE__ */ new Date();
+  const header = `# ${title}
+
+> Source: ${url2}
+> Cached: ${now.toISOString()}
+
+---
+
+`;
+  const fullContent = header + content;
+  await fs3.writeFile(filepath, fullContent);
+  const metadata = await readMetadata();
+  metadata.documents[filename] = {
+    url: url2,
+    title,
+    fetchedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+    size: fullContent.length
+  };
+  await writeMetadata(metadata);
+  return filename;
+}
+async function remove(url2) {
+  const filename = urlToFilename(url2);
+  const filepath = path2.join(CACHE_DIR, filename);
+  try {
+    await fs3.unlink(filepath);
+    const metadata = await readMetadata();
+    delete metadata.documents[filename];
+    await writeMetadata(metadata);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function list() {
+  const metadata = await readMetadata();
+  const now = /* @__PURE__ */ new Date();
+  return Object.entries(metadata.documents).map(([filename, entry]) => ({
+    filename,
+    ...entry,
+    expired: new Date(entry.expiresAt) < now
+  }));
+}
+async function clear() {
+  const metadata = await readMetadata();
+  const count = Object.keys(metadata.documents).length;
+  for (const filename of Object.keys(metadata.documents)) {
+    const filepath = path2.join(CACHE_DIR, filename);
+    try {
+      await fs3.unlink(filepath);
+    } catch {
+    }
+  }
+  await writeMetadata({ documents: {}, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
+  return count;
+}
+async function stats() {
+  const docs = await list();
+  if (docs.length === 0) {
+    return {
+      totalDocuments: 0,
+      totalSize: 0,
+      expiredCount: 0,
+      oldestDocument: null,
+      newestDocument: null
+    };
+  }
+  const sorted = docs.sort(
+    (a, b) => new Date(a.fetchedAt).getTime() - new Date(b.fetchedAt).getTime()
+  );
+  return {
+    totalDocuments: docs.length,
+    totalSize: docs.reduce((sum, d) => sum + d.size, 0),
+    expiredCount: docs.filter((d) => d.expired).length,
+    oldestDocument: sorted[0]?.filename ?? null,
+    newestDocument: sorted[sorted.length - 1]?.filename ?? null
+  };
+}
+
+// src/tools/web/webfetch.ts
+function htmlToMarkdown(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<h1[^>]*>(.*?)<\/h1>/gi, "# $1\n\n").replace(/<h2[^>]*>(.*?)<\/h2>/gi, "## $1\n\n").replace(/<h3[^>]*>(.*?)<\/h3>/gi, "### $1\n\n").replace(/<h4[^>]*>(.*?)<\/h4>/gi, "#### $1\n\n").replace(/<h5[^>]*>(.*?)<\/h5>/gi, "##### $1\n\n").replace(/<h6[^>]*>(.*?)<\/h6>/gi, "###### $1\n\n").replace(/<p[^>]*>(.*?)<\/p>/gi, "$1\n\n").replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, "```\n$1\n```\n\n").replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`").replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n").replace(/<ul[^>]*>/gi, "\n").replace(/<\/ul>/gi, "\n").replace(/<ol[^>]*>/gi, "\n").replace(/<\/ol>/gi, "\n").replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)").replace(/<strong[^>]*>(.*?)<\/strong>/gi, "**$1**").replace(/<b[^>]*>(.*?)<\/b>/gi, "**$1**").replace(/<em[^>]*>(.*?)<\/em>/gi, "*$1*").replace(/<i[^>]*>(.*?)<\/i>/gi, "*$1*").replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, "> $1\n\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function extractTitle(html) {
+  const match = html.match(/<title[^>]*>(.*?)<\/title>/i);
+  return match ? match[1].trim() : "Untitled";
+}
+function extractMainContent(html) {
+  const patterns = [
+    /<article[^>]*>([\s\S]*?)<\/article>/i,
+    /<main[^>]*>([\s\S]*?)<\/main>/i,
+    /<div[^>]*class="[^"]*content[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*article[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    /<div[^>]*class="[^"]*post[^"]*"[^>]*>([\s\S]*?)<\/div>/i
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+  return bodyMatch ? bodyMatch[1] : html;
+}
+var webfetchTool = tool({
+  description: `Fetch content from a URL and convert to markdown.
+
+<usage>
+- Fetches web pages and converts HTML to readable markdown
+- Automatically caches content for future reference
+- Use for documentation, API references, blog posts
+</usage>
+
+<examples>
+webfetch({ url: "https://nextjs.org/docs/app/building-your-application" })
+webfetch({ url: "https://react.dev/reference/react/useEffect", cache: true })
+</examples>`,
+  args: {
+    url: tool.schema.string().describe("URL to fetch"),
+    cache: tool.schema.boolean().optional().describe("Cache the result (default: true)"),
+    selector: tool.schema.string().optional().describe("CSS selector to extract specific content (not implemented yet)")
+  },
+  async execute(args) {
+    const { url: url2, cache = true } = args;
+    if (cache) {
+      const cached2 = await get(url2);
+      if (cached2) {
+        return `\u{1F4DA} **CACHED** (fetched: ${cached2.fetchedAt})
+
+${cached2.content}`;
+      }
+    }
+    try {
+      const response = await fetch(url2, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Orchestrator/1.0)",
+          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        },
+        signal: AbortSignal.timeout(3e4)
+        // 30 second timeout
+      });
+      if (!response.ok) {
+        return `\u274C Failed to fetch: HTTP ${response.status} ${response.statusText}`;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      const html = await response.text();
+      if (contentType.includes("application/json")) {
+        const content = JSON.stringify(JSON.parse(html), null, 2);
+        if (cache) {
+          const filename = await set2(url2, content, "JSON Response");
+          return `\u{1F4C4} **JSON fetched** (cached: .cache/docs/${filename})
+
+\`\`\`json
+${content.slice(0, 5e3)}
+\`\`\``;
+        }
+        return `\u{1F4C4} **JSON fetched**
+
+\`\`\`json
+${content.slice(0, 5e3)}
+\`\`\``;
+      }
+      if (contentType.includes("text/plain")) {
+        if (cache) {
+          const filename = await set2(url2, html, "Plain Text");
+          return `\u{1F4C4} **Text fetched** (cached: .cache/docs/${filename})
+
+${html.slice(0, 1e4)}`;
+        }
+        return `\u{1F4C4} **Text fetched**
+
+${html.slice(0, 1e4)}`;
+      }
+      const title = extractTitle(html);
+      const mainContent = extractMainContent(html);
+      const markdown = htmlToMarkdown(mainContent);
+      const truncated = markdown.length > 15e3 ? markdown.slice(0, 15e3) + "\n\n... [Content truncated]" : markdown;
+      if (cache) {
+        const filename = await set2(url2, truncated, title);
+        return `\u{1F4DA} **${title}**
+Source: ${url2}
+Cached: .cache/docs/${filename}
+
+---
+
+${truncated}`;
+      }
+      return `\u{1F4DA} **${title}**
+Source: ${url2}
+
+---
+
+${truncated}`;
+    } catch (error45) {
+      if (error45 instanceof Error) {
+        if (error45.name === "TimeoutError") {
+          return `\u274C Request timed out after 30 seconds`;
+        }
+        return `\u274C Fetch error: ${error45.message}`;
+      }
+      return `\u274C Unknown error occurred`;
+    }
+  }
+});
+
+// src/tools/web/websearch.ts
+async function searchSearXNG(query) {
+  const instances = [
+    "https://searxng.site",
+    "https://search.bus-hit.me",
+    "https://paulgo.io"
+  ];
+  for (const instance of instances) {
+    try {
+      const url2 = `${instance}/search?q=${encodeURIComponent(query)}&format=json&engines=google,duckduckgo,bing`;
+      const response = await fetch(url2, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; OpenCode/1.0)",
+          "Accept": "application/json"
+        },
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (!response.ok) continue;
+      const data = await response.json();
+      if (data.results && data.results.length > 0) {
+        return data.results.slice(0, 15).map((r) => ({
+          title: r.title || "",
+          url: r.url || "",
+          snippet: r.content || "",
+          source: r.engine || "searxng"
+        }));
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [];
+}
+async function searchBrave(query) {
+  const url2 = `https://search.brave.com/api/suggest?q=${encodeURIComponent(query)}`;
+  try {
+    const webUrl = `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`;
+    const response = await fetch(webUrl, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+        "Accept": "text/html"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    const results = [];
+    const snippetPattern = /<div class="snippet[^"]*"[^>]*>([\s\S]*?)<\/div>/gi;
+    const titlePattern = /<a[^>]*class="[^"]*result-header[^"]*"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    const titles = [];
+    const urls = [];
+    const snippets = [];
+    while ((match = titlePattern.exec(html)) !== null) {
+      urls.push(match[1]);
+      titles.push(match[2].replace(/<[^>]+>/g, "").trim());
+    }
+    while ((match = snippetPattern.exec(html)) !== null) {
+      const text = match[1].replace(/<[^>]+>/g, "").trim();
+      if (text.length > 20) {
+        snippets.push(text);
+      }
+    }
+    for (let i = 0; i < Math.min(titles.length, 10); i++) {
+      if (titles[i] && urls[i]) {
+        results.push({
+          title: titles[i],
+          url: urls[i],
+          snippet: snippets[i] || "",
+          source: "brave"
+        });
+      }
+    }
+    return results;
+  } catch (error45) {
+    console.error("Brave search error:", error45);
+    return [];
+  }
+}
+async function searchDuckDuckGo(query) {
+  const encodedQuery = encodeURIComponent(query);
+  const url2 = `https://api.duckduckgo.com/?q=${encodedQuery}&format=json&no_html=1&skip_disambig=1`;
+  try {
+    const response = await fetch(url2, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Orchestrator/1.0)"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const results = [];
+    if (data.Abstract && data.AbstractURL) {
+      results.push({
+        title: data.Heading || data.AbstractSource || "Main Result",
+        url: data.AbstractURL,
+        snippet: data.Abstract,
+        source: "duckduckgo"
+      });
+    }
+    for (const topic of (data.RelatedTopics || []).slice(0, 8)) {
+      if (topic.Text && topic.FirstURL) {
+        results.push({
+          title: topic.Text.split(" - ")[0] || topic.Text.slice(0, 50),
+          url: topic.FirstURL,
+          snippet: topic.Text,
+          source: "duckduckgo"
+        });
+      }
+    }
+    for (const result of (data.Results || []).slice(0, 5)) {
+      if (result.Text && result.FirstURL) {
+        results.push({
+          title: result.Text.split(" - ")[0] || result.Text.slice(0, 50),
+          url: result.FirstURL,
+          snippet: result.Text,
+          source: "duckduckgo"
+        });
+      }
+    }
+    return results;
+  } catch (error45) {
+    console.error("DuckDuckGo search error:", error45);
+    return [];
+  }
+}
+async function searchDuckDuckGoHtml(query) {
+  const encodedQuery = encodeURIComponent(query);
+  const url2 = `https://html.duckduckgo.com/html/?q=${encodedQuery}`;
+  try {
+    const response = await fetch(url2, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    const results = [];
+    const resultPattern = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>(.*?)<\/a>/gi;
+    let match;
+    while ((match = resultPattern.exec(html)) !== null && results.length < 10) {
+      results.push({
+        title: match[2].replace(/<[^>]+>/g, "").trim(),
+        url: decodeURIComponent(match[1].replace(/.*uddg=/, "").split("&")[0] || match[1]),
+        snippet: match[3].replace(/<[^>]+>/g, "").trim(),
+        source: "duckduckgo_html"
+      });
+    }
+    return results;
+  } catch (error45) {
+    console.error("DuckDuckGo HTML search error:", error45);
+    return [];
+  }
+}
+var websearchTool = tool({
+  description: `Search the web for information using multiple search providers.
+
+<usage>
+- Uses SearXNG (meta-search) > Brave Search > DuckDuckGo
+- Returns relevant results with URLs
+- Use for finding documentation, tutorials, solutions
+</usage>
+
+<tips>
+- Add "docs" or "documentation" for official docs
+- Add "site:github.com" for GitHub results
+- Add specific version numbers when relevant
+- Add current year for latest information
+</tips>
+
+<examples>
+websearch({ query: "Next.js 14 app router documentation" })
+websearch({ query: "React useEffect cleanup best practices 2025" })
+websearch({ query: "TypeScript generic constraints site:typescriptlang.org" })
+</examples>`,
+  args: {
+    query: tool.schema.string().describe("Search query"),
+    maxResults: tool.schema.number().optional().describe("Maximum number of results (default: 10)")
+  },
+  async execute(args) {
+    const { query, maxResults = 10 } = args;
+    let results = [];
+    let provider = "";
+    results = await searchSearXNG(query);
+    if (results.length > 0) {
+      provider = "SearXNG";
+    }
+    if (results.length === 0) {
+      results = await searchBrave(query);
+      if (results.length > 0) {
+        provider = "Brave";
+      }
+    }
+    if (results.length === 0) {
+      results = await searchDuckDuckGo(query);
+      if (results.length > 0) {
+        provider = "DuckDuckGo";
+      }
+    }
+    if (results.length === 0) {
+      results = await searchDuckDuckGoHtml(query);
+      if (results.length > 0) {
+        provider = "DuckDuckGo HTML";
+      }
+    }
+    if (results.length === 0) {
+      return `\u{1F50D} No results found for: "${query}"
+
+Try:
+- Different keywords
+- More specific terms
+- Check spelling
+- Add "docs" or "official" for documentation`;
+    }
+    const limitedResults = results.slice(0, maxResults);
+    let output = `\u{1F50D} **Web Search Results for: "${query}"**
+
+`;
+    output += `\u{1F4E1} Provider: ${provider} | Found ${results.length} results (showing ${limitedResults.length})
+
+---
+
+`;
+    for (let i = 0; i < limitedResults.length; i++) {
+      const result = limitedResults[i];
+      output += `### ${i + 1}. ${result.title}
+`;
+      output += `\u{1F517} ${result.url}
+
+`;
+      if (result.snippet) {
+        output += `${result.snippet}
+
+`;
+      }
+    }
+    output += `---
+
+`;
+    output += `\u{1F4A1} **Tip**: Use \`webfetch\` to get full content from any of these URLs.`;
+    return output;
+  }
+});
+
+// src/tools/web/cache-docs.ts
+var cacheDocsTool = tool({
+  description: `Manage cached documentation.
+
+<usage>
+- list: Show all cached documents
+- get: Retrieve a specific cached document
+- clear: Clear all cached documents
+- stats: Show cache statistics
+</usage>
+
+<examples>
+cache_docs({ action: "list" })
+cache_docs({ action: "get", filename: "nextjs_app-router.md" })
+cache_docs({ action: "stats" })
+cache_docs({ action: "clear" })
+</examples>`,
+  args: {
+    action: tool.schema.enum(["list", "get", "clear", "stats"]).describe("Action to perform"),
+    filename: tool.schema.string().optional().describe("Filename for 'get' action")
+  },
+  async execute(args) {
+    const { action, filename } = args;
+    switch (action) {
+      case "list": {
+        const docs = await list();
+        if (docs.length === 0) {
+          return "\u{1F4DA} **Document Cache**: Empty\n\nNo documents cached yet. Use `webfetch` with `cache: true` to cache documents.";
+        }
+        let output = `\u{1F4DA} **Document Cache** (${docs.length} documents)
+
+`;
+        for (const doc of docs) {
+          const status = doc.expired ? "\u26A0\uFE0F EXPIRED" : "\u2705";
+          const size = doc.size > 1024 ? `${(doc.size / 1024).toFixed(1)}KB` : `${doc.size}B`;
+          output += `${status} **${doc.filename}** (${size})
+`;
+          output += `   Source: ${doc.url}
+`;
+          output += `   Cached: ${new Date(doc.fetchedAt).toLocaleString()}
+
+`;
+        }
+        return output;
+      }
+      case "get": {
+        if (!filename) {
+          return "\u274C Please specify `filename` to retrieve";
+        }
+        const doc = await getByFilename(filename);
+        if (!doc) {
+          return `\u274C Document not found: ${filename}
+
+Use \`cache_docs({ action: "list" })\` to see available documents.`;
+        }
+        return `\u{1F4DA} **${doc.title}**
+Source: ${doc.url}
+Cached: ${doc.fetchedAt}
+
+---
+
+${doc.content}`;
+      }
+      case "clear": {
+        const count = await clear();
+        return `\u{1F5D1}\uFE0F Cleared ${count} cached documents`;
+      }
+      case "stats": {
+        const stats2 = await stats();
+        if (stats2.totalDocuments === 0) {
+          return "\u{1F4CA} **Cache Statistics**\n\nCache is empty.";
+        }
+        const sizeStr = stats2.totalSize > 1024 * 1024 ? `${(stats2.totalSize / (1024 * 1024)).toFixed(2)}MB` : stats2.totalSize > 1024 ? `${(stats2.totalSize / 1024).toFixed(1)}KB` : `${stats2.totalSize}B`;
+        return `\u{1F4CA} **Cache Statistics**
+
+- Total Documents: ${stats2.totalDocuments}
+- Total Size: ${sizeStr}
+- Expired: ${stats2.expiredCount}
+- Oldest: ${stats2.oldestDocument || "N/A"}
+- Newest: ${stats2.newestDocument || "N/A"}`;
+      }
+      default:
+        return `\u274C Unknown action: ${action}`;
+    }
+  }
+});
+
+// src/tools/web/codesearch.ts
+async function searchGrepApp(query, options) {
+  const params = new URLSearchParams({
+    q: query,
+    ...options.language && { filter: `lang:${options.language}` },
+    ...options.repo && { filter: `repo:${options.repo}` }
+  });
+  const url2 = `https://grep.app/api/search?${params}`;
+  try {
+    const response = await fetch(url2, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Orchestrator/1.0)",
+        "Accept": "application/json"
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    const results = [];
+    for (const hit of (data.hits?.hits || []).slice(0, 10)) {
+      const repo = hit.repo?.raw || "";
+      const file2 = hit.path?.raw || "";
+      const line = hit.lineno || 0;
+      const content = hit.content?.snippet?.replace(/<[^>]+>/g, "") || "";
+      if (repo && file2) {
+        results.push({
+          repo,
+          file: file2,
+          line,
+          content: content.slice(0, 200),
+          url: `https://github.com/${repo}/blob/main/${file2}#L${line}`
+        });
+      }
+    }
+    return results;
+  } catch (error45) {
+    console.error("grep.app search error:", error45);
+    return [];
+  }
+}
+async function searchGitHub(query, options) {
+  const params = new URLSearchParams({
+    q: query + (options.language ? ` language:${options.language}` : ""),
+    type: "code"
+  });
+  const url2 = `https://github.com/search?${params}`;
+  try {
+    const response = await fetch(url2, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+        "Accept": "text/html"
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const html = await response.text();
+    const results = [];
+    const repoPattern = /href="\/([^"]+)\/blob\/([^"]+)"/g;
+    let match;
+    let count = 0;
+    while ((match = repoPattern.exec(html)) !== null && count < 10) {
+      const [, repoPath, filePath] = match;
+      if (repoPath && filePath) {
+        results.push({
+          repo: repoPath,
+          file: filePath,
+          line: 0,
+          content: "(Use webfetch for full content)",
+          url: `https://github.com/${repoPath}/blob/${filePath}`
+        });
+        count++;
+      }
     }
+    return results;
+  } catch (error45) {
+    console.error("GitHub search error:", error45);
+    return [];
   }
-});
+}
+var codesearchTool = tool({
+  description: `Search open source code for patterns and examples.
 
-// src/tools/parallel/get-task-result.ts
-var createGetTaskResultTool = (manager) => tool({
-  description: `Get result from a completed background task.`,
+<usage>
+- Find real-world usage patterns from verified repositories
+- Discover best practices from popular projects
+- Verify API usage with actual examples
+</usage>
+
+<tips>
+- Be specific with search queries
+- Add language filter for better results
+- Use for verification, not just discovery
+</tips>
+
+<examples>
+codesearch({ query: "useEffect cleanup function", language: "typescript" })
+codesearch({ query: "prisma middleware logging" })
+codesearch({ query: "next.js middleware redirect", repo: "vercel/next.js" })
+</examples>`,
   args: {
-    taskId: tool.schema.string().describe("Task ID")
+    query: tool.schema.string().describe("Code pattern to search for"),
+    language: tool.schema.string().optional().describe("Programming language filter"),
+    repo: tool.schema.string().optional().describe("Specific repository (owner/repo)")
   },
   async execute(args) {
-    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}`;
+    const { query, language, repo } = args;
+    let results = await searchGrepApp(query, { language, repo });
+    if (results.length === 0) {
+      results = await searchGitHub(query, { language });
     }
-    return `\u2705 Completed (${duration3})
+    if (results.length === 0) {
+      return `\u{1F50D} No code results found for: "${query}"
 
-${result || "(No output)"}`;
-  }
-});
+Try:
+- Different search terms
+- Broader language filter
+- Check spelling`;
+    }
+    let output = `\u{1F50D} **Code Search Results for: "${query}"**
 
-// src/tools/parallel/list-tasks.ts
-var createListTasksTool = (manager) => tool({
-  description: `List all background tasks.`,
-  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();
+`;
+    output += `Found ${results.length} results${language ? ` (${language})` : ""}
+
+---
+
+`;
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      output += `### ${i + 1}. ${r.repo}
+`;
+      output += `\u{1F4C4} \`${r.file}\`${r.line ? `:${r.line}` : ""}
+`;
+      output += `\u{1F517} [View on GitHub](${r.url})
+
+`;
+      if (r.content && r.content !== "(Use webfetch for full content)") {
+        output += `\`\`\`
+${r.content}
+\`\`\`
+
+`;
+      }
     }
-    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**
+    output += `---
 
-| ID | Status | Agent | Time |
-|----|--------|-------|------|
-${rows}`;
+`;
+    output += `\u{1F4A1} **Tip**: Use \`webfetch\` to get the full file content from any of these URLs.`;
+    return output;
   }
 });
 
-// src/tools/parallel/cancel-task.ts
-var createCancelTaskTool = (manager) => tool({
-  description: `Cancel a running task.`,
-  args: {
-    taskId: tool.schema.string().describe("Task ID to cancel")
-  },
-  async execute(args) {
-    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}\``;
+// src/core/notification/toast-core.ts
+var toasts = [];
+var MAX_HISTORY = 50;
+var handlers = [];
+function show(options) {
+  const toast = {
+    id: `toast_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+    title: options.title,
+    message: options.message,
+    variant: options.variant || "info",
+    timestamp: /* @__PURE__ */ new Date(),
+    duration: options.duration ?? 5e3,
+    dismissed: false
+  };
+  toasts.push(toast);
+  if (toasts.length > MAX_HISTORY) {
+    toasts.shift();
   }
-});
+  for (const handler of handlers) {
+    try {
+      handler(toast);
+    } catch (error45) {
+      console.error("[Toast] Handler error:", error45);
+    }
+  }
+  const icons = { info: "\u2139\uFE0F", success: "\u2705", warning: "\u26A0\uFE0F", error: "\u274C" };
+  console.log(`${icons[toast.variant]} [${toast.title}] ${toast.message}`);
+  return toast;
+}
 
-// src/tools/parallel/index.ts
-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/notification/presets.ts
+var presets = {
+  taskStarted: (taskId, agent) => show({
+    title: "Task Started",
+    message: `${agent}: ${taskId}`,
+    variant: "info",
+    duration: 3e3
+  }),
+  taskCompleted: (taskId, agent) => show({
+    title: "Task Completed",
+    message: `${agent}: ${taskId}`,
+    variant: "success",
+    duration: 3e3
+  }),
+  taskFailed: (taskId, error45) => show({
+    title: "Task Failed",
+    message: `${taskId}: ${error45}`,
+    variant: "error",
+    duration: 0
+    // Persistent
+  }),
+  allTasksComplete: (count) => show({
+    title: "All Tasks Complete",
+    message: `${count} tasks finished successfully`,
+    variant: "success",
+    duration: 5e3
+  }),
+  missionComplete: (summary) => show({
+    title: "\u{1F389} Mission Complete",
+    message: summary,
+    variant: "success",
+    duration: 0
+  }),
+  documentCached: (filename) => show({
+    title: "Document Cached",
+    message: `.cache/docs/${filename}`,
+    variant: "info",
+    duration: 2e3
+  }),
+  researchStarted: (topic) => show({
+    title: "Research Started",
+    message: topic,
+    variant: "info",
+    duration: 3e3
+  }),
+  warningRateLimited: () => show({
+    title: "Rate Limited",
+    message: "Waiting before retry...",
+    variant: "warning",
+    duration: 5e3
+  }),
+  errorRecovery: (action) => show({
+    title: "Error Recovery",
+    message: `Attempting: ${action}`,
+    variant: "warning",
+    duration: 3e3
+  })
+};
+
+// src/core/notification/event-integration.ts
+function enableAutoToasts() {
+  const unsubscribers = [];
+  unsubscribers.push(EventBus.subscribe(TASK_EVENTS.STARTED, (event) => {
+    const { taskId, agent } = event.properties;
+    presets.taskStarted(taskId, agent);
+  }));
+  unsubscribers.push(EventBus.subscribe(TASK_EVENTS.COMPLETED, (event) => {
+    const { taskId, agent } = event.properties;
+    presets.taskCompleted(taskId, agent);
+  }));
+  unsubscribers.push(EventBus.subscribe(TASK_EVENTS.FAILED, (event) => {
+    const { taskId, error: error45 } = event.properties;
+    presets.taskFailed(taskId, error45);
+  }));
+  unsubscribers.push(EventBus.subscribe(MISSION_EVENTS.ALL_TASKS_COMPLETE, (event) => {
+    const { count } = event.properties;
+    presets.allTasksComplete(count);
+  }));
+  unsubscribers.push(EventBus.subscribe(MISSION_EVENTS.COMPLETE, (event) => {
+    const { summary } = event.properties;
+    presets.missionComplete(summary);
+  }));
+  unsubscribers.push(EventBus.subscribe(DOCUMENT_EVENTS.CACHED, (event) => {
+    const { filename } = event.properties;
+    presets.documentCached(filename);
+  }));
+  return () => {
+    for (const unsub of unsubscribers) {
+      unsub();
+    }
   };
 }
 
-// src/utils/common.ts
-function detectSlashCommand(text) {
-  const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
-  if (!match) return null;
-  return { command: match[1], args: match[2] || "" };
+// src/core/progress/store.ts
+var progressHistory = /* @__PURE__ */ new Map();
+var sessionStartTimes = /* @__PURE__ */ new Map();
+var MAX_HISTORY2 = 100;
+function startSession(sessionId) {
+  sessionStartTimes.set(sessionId, /* @__PURE__ */ new Date());
+  progressHistory.set(sessionId, []);
+}
+function recordSnapshot(sessionId, data) {
+  const startedAt = sessionStartTimes.get(sessionId) || /* @__PURE__ */ new Date();
+  const now = /* @__PURE__ */ new Date();
+  const snapshot = {
+    sessionId,
+    timestamp: now,
+    todos: {
+      total: data.todoTotal || 0,
+      completed: data.todoCompleted || 0,
+      pending: (data.todoTotal || 0) - (data.todoCompleted || 0),
+      percentage: data.todoTotal ? Math.round((data.todoCompleted || 0) / data.todoTotal * 100) : 0
+    },
+    tasks: {
+      total: data.taskTotal || 0,
+      running: data.taskRunning || 0,
+      completed: data.taskCompleted || 0,
+      failed: data.taskFailed || 0,
+      percentage: data.taskTotal ? Math.round(((data.taskCompleted || 0) + (data.taskFailed || 0)) / data.taskTotal * 100) : 0
+    },
+    steps: {
+      current: data.currentStep || 0,
+      max: data.maxSteps || Infinity
+    },
+    startedAt,
+    elapsedMs: now.getTime() - startedAt.getTime()
+  };
+  const history = progressHistory.get(sessionId) || [];
+  history.push(snapshot);
+  if (history.length > MAX_HISTORY2) {
+    history.shift();
+  }
+  progressHistory.set(sessionId, history);
+  return snapshot;
 }
-function formatTimestamp(date5 = /* @__PURE__ */ new Date()) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  return `${date5.getFullYear()}-${pad(date5.getMonth() + 1)}-${pad(date5.getDate())} ${pad(date5.getHours())}:${pad(date5.getMinutes())}:${pad(date5.getSeconds())}`;
+function getLatest(sessionId) {
+  const history = progressHistory.get(sessionId);
+  return history?.[history.length - 1];
 }
-function formatElapsedTime(startMs, endMs = Date.now()) {
-  const elapsed = endMs - startMs;
-  if (elapsed < 0) return "0s";
-  const seconds = Math.floor(elapsed / 1e3) % 60;
-  const minutes = Math.floor(elapsed / (1e3 * 60)) % 60;
-  const hours = Math.floor(elapsed / (1e3 * 60 * 60));
-  const parts = [];
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
-  return parts.join(" ");
+function clearSession(sessionId) {
+  progressHistory.delete(sessionId);
+  sessionStartTimes.delete(sessionId);
 }
 
-// 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"
-    };
+// src/core/progress/formatters.ts
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  } else {
+    return `${seconds}s`;
   }
-  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"
-      };
-    }
+}
+function formatCompact(snapshot) {
+  const parts = [];
+  if (snapshot.todos.total > 0) {
+    parts.push(`\u2705${snapshot.todos.completed}/${snapshot.todos.total}`);
   }
-  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"
-      };
-    }
+  if (snapshot.tasks.running > 0) {
+    parts.push(`\u26A1${snapshot.tasks.running}`);
   }
-  return { isHealthy: true, severity: "ok" };
+  parts.push(`\u23F1${formatElapsed(snapshot.elapsedMs)}`);
+  return parts.join(" | ");
 }
-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/core/progress/tracker.ts
+function formatCompact2(sessionId) {
+  const snapshot = getLatest(sessionId);
+  if (!snapshot) return "...";
+  return formatCompact(snapshot);
+}
 
 // src/index.ts
-var PLUGIN_VERSION = "0.2.4";
-var DEFAULT_MAX_STEPS = 500;
-var TASK_COMMAND_MAX_STEPS = 1e3;
-var AGENT_EMOJI2 = {
-  "architect": "\u{1F3D7}\uFE0F",
-  "builder": "\u{1F528}",
-  "inspector": "\u{1F50D}",
-  "recorder": "\u{1F4BE}",
-  "commander": "\u{1F3AF}"
-};
+var require2 = createRequire(import.meta.url);
+var { version: PLUGIN_VERSION } = require2("../package.json");
+var UNLIMITED_MODE = true;
+var DEFAULT_MAX_STEPS = UNLIMITED_MODE ? Infinity : 500;
 var CONTINUE_INSTRUCTION = `<auto_continue>
 <status>Mission not complete. Keep executing.</status>
 
@@ -14500,17 +16403,30 @@ var CONTINUE_INSTRUCTION = `<auto_continue>
 2. DO NOT wait for user input
 3. If previous action failed, try different approach
 4. If agent returned nothing, proceed to next step
+5. Check your todo list - complete ALL pending items
 </rules>
 
 <next_step>
-What is the current state?
-What is the next action?
-Execute it NOW.
+1. Check todo list for incomplete items
+2. Identify the highest priority pending task
+3. Execute it NOW
+4. Mark complete when done
+5. Continue until ALL todos are complete
 </next_step>
+
+<completion_criteria>
+You are ONLY done when:
+- All todos are marked complete or cancelled
+- All features are implemented and tested
+- Final verification passes
+Then output: \u2705 MISSION COMPLETE
+</completion_criteria>
 </auto_continue>`;
 var OrchestratorPlugin = async (input) => {
   const { directory, client } = input;
   console.log(`[orchestrator] v${PLUGIN_VERSION} loaded`);
+  const disableAutoToasts = enableAutoToasts();
+  console.log(`[orchestrator] Toast notifications enabled`);
   const sessions = /* @__PURE__ */ new Map();
   const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
@@ -14519,17 +16435,22 @@ var OrchestratorPlugin = async (input) => {
     // Tools we expose to the LLM
     // -----------------------------------------------------------------
     tool: {
-      call_agent: callAgentTool,
-      slashcommand: createSlashcommandTool(),
-      grep_search: grepSearchTool(directory),
-      glob_search: globSearchTool(directory),
-      mgrep: mgrepTool(directory),
+      [TOOL_NAMES.CALL_AGENT]: callAgentTool,
+      [TOOL_NAMES.SLASHCOMMAND]: createSlashcommandTool(),
+      [TOOL_NAMES.GREP_SEARCH]: grepSearchTool(directory),
+      [TOOL_NAMES.GLOB_SEARCH]: globSearchTool(directory),
+      [TOOL_NAMES.MGREP]: mgrepTool(directory),
       // Multi-pattern grep (parallel, Rust-powered)
       // Background task tools - run shell commands asynchronously
-      run_background: runBackgroundTool,
-      check_background: checkBackgroundTool,
-      list_background: listBackgroundTool,
-      kill_background: killBackgroundTool,
+      [TOOL_NAMES.RUN_BACKGROUND]: runBackgroundTool,
+      [TOOL_NAMES.CHECK_BACKGROUND]: checkBackgroundTool,
+      [TOOL_NAMES.LIST_BACKGROUND]: listBackgroundTool,
+      [TOOL_NAMES.KILL_BACKGROUND]: killBackgroundTool,
+      // Web tools - documentation research and caching
+      [TOOL_NAMES.WEBFETCH]: webfetchTool,
+      [TOOL_NAMES.WEBSEARCH]: websearchTool,
+      [TOOL_NAMES.CACHE_DOCS]: cacheDocsTool,
+      [TOOL_NAMES.CODESEARCH]: codesearchTool,
       // Async agent tools - spawn agents in parallel sessions
       ...asyncAgentTools
     },
@@ -14548,10 +16469,20 @@ var OrchestratorPlugin = async (input) => {
         };
       }
       const orchestratorAgents = {
-        Commander: {
-          name: "Commander",
+        [AGENT_NAMES.COMMANDER]: {
+          name: AGENT_NAMES.COMMANDER,
           description: "Autonomous orchestrator - executes until mission complete",
           systemPrompt: AGENTS.commander.systemPrompt
+        },
+        [AGENT_NAMES.LIBRARIAN]: {
+          name: AGENT_NAMES.LIBRARIAN,
+          description: "Documentation research specialist - reduces hallucination",
+          systemPrompt: AGENTS.librarian?.systemPrompt || ""
+        },
+        [AGENT_NAMES.RESEARCHER]: {
+          name: AGENT_NAMES.RESEARCHER,
+          description: "Pre-task investigation - gathers all info before implementation",
+          systemPrompt: AGENTS.researcher?.systemPrompt || ""
         }
       };
       config2.command = { ...orchestratorCommands, ...existingCommands };
@@ -14563,13 +16494,13 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     "chat.message": async (msgInput, msgOutput) => {
       const parts = msgOutput.parts;
-      const textPartIndex = parts.findIndex((p) => p.type === "text" && p.text);
+      const textPartIndex = parts.findIndex((p) => p.type === PART_TYPES.TEXT && p.text);
       if (textPartIndex === -1) return;
       const originalText = parts[textPartIndex].text || "";
       const parsed = detectSlashCommand(originalText);
       const sessionID = msgInput.sessionID;
       const agentName = (msgInput.agent || "").toLowerCase();
-      if (agentName === "commander" && !sessions.has(sessionID)) {
+      if (agentName === AGENT_NAMES.COMMANDER && !sessions.has(sessionID)) {
         const now = Date.now();
         sessions.set(sessionID, {
           active: true,
@@ -14587,44 +16518,19 @@ var OrchestratorPlugin = async (input) => {
           currentTask: "",
           anomalyCount: 0
         });
-        if (!parsed) {
-          const userMessage = originalText.trim();
-          if (userMessage) {
-            parts[textPartIndex].text = COMMANDS["task"].template.replace(
-              /\$ARGUMENTS/g,
-              userMessage
-            );
-          }
-        }
-      }
-      if (parsed?.command === "task") {
-        const now = Date.now();
-        sessions.set(sessionID, {
-          active: true,
-          step: 0,
-          maxSteps: TASK_COMMAND_MAX_STEPS,
-          timestamp: now,
-          startTime: now,
-          lastStepTime: now
-        });
-        state.missionActive = true;
-        state.sessions.set(sessionID, {
-          enabled: true,
-          iterations: 0,
-          taskRetries: /* @__PURE__ */ new Map(),
-          currentTask: "",
-          anomalyCount: 0
+        startSession(sessionID);
+        emit(TASK_EVENTS.STARTED, {
+          taskId: sessionID,
+          agent: AGENT_NAMES.COMMANDER,
+          description: "Mission started"
         });
-        parts[textPartIndex].text = COMMANDS["task"].template.replace(
-          /\$ARGUMENTS/g,
-          parsed.args || "continue previous work"
-        );
-      } else if (parsed) {
+      }
+      if (parsed) {
         const command = COMMANDS[parsed.command];
         if (command) {
           parts[textPartIndex].text = command.template.replace(
             /\$ARGUMENTS/g,
-            parsed.args || "continue"
+            parsed.args || PROMPTS.CONTINUE
           );
         }
       }
@@ -14643,7 +16549,7 @@ var OrchestratorPlugin = async (input) => {
       session.timestamp = now;
       session.lastStepTime = now;
       const stateSession = state.sessions.get(toolInput.sessionID);
-      if (toolInput.tool === "call_agent" && stateSession) {
+      if (toolInput.tool === TOOL_NAMES.CALL_AGENT && stateSession) {
         const sanityResult = checkOutputSanity(toolOutput.output);
         if (!sanityResult.isHealthy) {
           stateSession.anomalyCount = (stateSession.anomalyCount || 0) + 1;
@@ -14666,14 +16572,14 @@ Anomaly count: ${stateSession.anomalyCount}
           }
         }
       }
-      if (toolInput.tool === "call_agent" && toolInput.arguments?.task && stateSession) {
+      if (toolInput.tool === TOOL_NAMES.CALL_AGENT && toolInput.arguments?.task && stateSession) {
         const taskIdMatch = toolInput.arguments.task.match(/\[(TASK-\d+)\]/i);
         if (taskIdMatch) {
           stateSession.currentTask = taskIdMatch[1].toUpperCase();
-          stateSession.graph?.updateTask(stateSession.currentTask, { status: "running" });
+          stateSession.graph?.updateTask(stateSession.currentTask, { status: TASK_STATUS.RUNNING });
         }
         const agentName = toolInput.arguments.agent;
-        const emoji3 = AGENT_EMOJI2[agentName] || "\u{1F916}";
+        const emoji3 = AGENT_EMOJI[agentName] || "\u{1F916}";
         toolOutput.output = `${emoji3} [${agentName.toUpperCase()}] Working...
 
 ` + toolOutput.output;
@@ -14683,7 +16589,7 @@ Anomaly count: ${stateSession.anomalyCount}
         state.missionActive = false;
         return;
       }
-      if (toolOutput.output.includes("[") && toolOutput.output.includes("{") && toolInput.tool === "call_agent" && stateSession) {
+      if (toolOutput.output.includes("[") && toolOutput.output.includes("{") && toolInput.tool === TOOL_NAMES.CALL_AGENT && stateSession) {
         const jsonMatch = toolOutput.output.match(/```json\n([\s\S]*?)\n```/) || toolOutput.output.match(/\[\s*\{[\s\S]*?\}\s*\]/);
         if (jsonMatch) {
           try {
@@ -14704,7 +16610,7 @@ ${stateSession.graph.getTaskSummary()}`;
         const taskId = stateSession.currentTask;
         if (toolOutput.output.includes("\u2705 PASS") || toolOutput.output.includes("AUDIT RESULT: PASS")) {
           if (taskId) {
-            stateSession.graph.updateTask(taskId, { status: "completed" });
+            stateSession.graph.updateTask(taskId, { status: TASK_STATUS.COMPLETED });
             stateSession.taskRetries.clear();
             toolOutput.output += `
 
@@ -14717,7 +16623,7 @@ ${stateSession.graph.getTaskSummary()}`;
             const retries = (stateSession.taskRetries.get(taskId) || 0) + 1;
             stateSession.taskRetries.set(taskId, retries);
             if (retries >= state.maxRetries) {
-              stateSession.graph.updateTask(taskId, { status: "failed" });
+              stateSession.graph.updateTask(taskId, { status: TASK_STATUS.FAILED });
               toolOutput.output += `
 
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
@@ -14751,7 +16657,7 @@ ${stateSession.graph.getTaskSummary()}`;
       const session = sessions.get(sessionID);
       if (!session?.active) return;
       const parts = assistantOutput.parts;
-      const textContent = parts?.filter((p) => p.type === "text" || p.type === "reasoning").map((p) => p.text || "").join("\n") || "";
+      const textContent = parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text || "").join("\n") || "";
       const stateSession = state.sessions.get(sessionID);
       const sanityResult = checkOutputSanity(textContent);
       if (!sanityResult.isHealthy && stateSession) {
@@ -14765,7 +16671,7 @@ ${stateSession.graph.getTaskSummary()}`;
               path: { id: sessionID },
               body: {
                 parts: [{
-                  type: "text",
+                  type: PART_TYPES.TEXT,
                   text: `\u26A0\uFE0F ANOMALY #${stateSession.anomalyCount}: ${sanityResult.reason}
 
 ` + recoveryText + `
@@ -14784,16 +16690,26 @@ ${stateSession.graph.getTaskSummary()}`;
       if (stateSession && stateSession.anomalyCount > 0) {
         stateSession.anomalyCount = 0;
       }
-      if (textContent.includes("\u2705 MISSION COMPLETE") || textContent.includes("MISSION COMPLETE")) {
+      if (textContent.includes(MISSION.COMPLETE) || textContent.includes(MISSION.COMPLETE_TEXT)) {
         session.active = false;
         state.missionActive = false;
+        emit(MISSION_EVENTS.COMPLETE, {
+          sessionId: sessionID,
+          summary: "Mission completed successfully"
+        });
+        clearSession(sessionID);
         sessions.delete(sessionID);
         state.sessions.delete(sessionID);
         return;
       }
-      if (textContent.includes("/stop") || textContent.includes("/cancel")) {
+      if (textContent.includes(MISSION.STOP_COMMAND) || textContent.includes(MISSION.CANCEL_COMMAND)) {
         session.active = false;
         state.missionActive = false;
+        emit(TASK_EVENTS.FAILED, {
+          taskId: sessionID,
+          error: "Cancelled by user"
+        });
+        clearSession(sessionID);
         sessions.delete(sessionID);
         state.sessions.delete(sessionID);
         return;
@@ -14810,16 +16726,21 @@ ${stateSession.graph.getTaskSummary()}`;
         state.missionActive = false;
         return;
       }
+      recordSnapshot(sessionID, {
+        currentStep: session.step,
+        maxSteps: session.maxSteps
+      });
+      const progressInfo = formatCompact2(sessionID);
       try {
         if (client?.session?.prompt) {
           await client.session.prompt({
             path: { id: sessionID },
             body: {
               parts: [{
-                type: "text",
+                type: PART_TYPES.TEXT,
                 text: CONTINUE_INSTRUCTION + `
 
-\u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | This step: ${stepDuration} | Total: ${totalElapsed}`
+\u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | ${progressInfo} | This step: ${stepDuration} | Total: ${totalElapsed}`
               }]
             }
           });
@@ -14830,7 +16751,7 @@ ${stateSession.graph.getTaskSummary()}`;
           if (client?.session?.prompt) {
             await client.session.prompt({
               path: { id: sessionID },
-              body: { parts: [{ type: "text", text: "continue" }] }
+              body: { parts: [{ type: PART_TYPES.TEXT, text: PROMPTS.CONTINUE }] }
             });
           }
         } catch {
@@ -14841,18 +16762,22 @@ ${stateSession.graph.getTaskSummary()}`;
     },
     // -----------------------------------------------------------------
     // Event handler - cleans up when sessions are deleted
+    // Uses 'event' hook (not 'handler') to match oh-my-opencode pattern
     // -----------------------------------------------------------------
-    handler: async ({ event }) => {
+    event: async (input2) => {
+      const { event } = input2;
       try {
         const manager = ParallelAgentManager.getInstance();
         manager.handleEvent(event);
       } catch {
       }
-      if (event.type === "session.deleted") {
+      if (event.type === SESSION_EVENTS.DELETED) {
         const props = event.properties;
         if (props?.info?.id) {
-          sessions.delete(props.info.id);
-          state.sessions.delete(props.info.id);
+          const sessionId = props.info.id;
+          sessions.delete(sessionId);
+          state.sessions.delete(sessionId);
+          clearSession(sessionId);
         }
       }
     }