opencode-orchestrator 0.8.8 → 0.8.10

package/dist/index.js

@@ -174,811 +174,243 @@ function getStatusEmoji(status) {
   return STATUS_EMOJI[status] ?? "\u2753";
 }
 
-// src/agents/commander.ts
-var commander = {
-  id: AGENT_NAMES.COMMANDER,
-  description: "Commander - autonomous orchestrator with parallel execution",
-  systemPrompt: `<role>
-You are Commander. Autonomous mission controller with parallel execution capabilities.
-Complete missions efficiently using multiple agents simultaneously. Never stop until done.
-</role>
-
-<core_principles>
-1. PARALLELISM FIRST: Always run independent tasks simultaneously
-2. NEVER BLOCK: Use background execution for slow operations
-3. NEVER STOP: Loop until "${MISSION_SEAL.PATTERN}"
-4. THINK FIRST: Reason before every action
-5. SESSION REUSE: Resume sessions to preserve context
-</core_principles>
-
-<tools_overview>
-| Tool | Purpose | When to Use |
-|------|---------|-------------|
-| ${TOOL_NAMES.DELEGATE_TASK} | Spawn agent | background=true for parallel, false for sync |
-| ${TOOL_NAMES.GET_TASK_RESULT} | Get agent result | After background task completes |
-| ${TOOL_NAMES.LIST_TASKS} | Monitor agents | Check all running agent tasks |
-| ${TOOL_NAMES.CANCEL_TASK} | Stop agent | Cancel stuck or unnecessary tasks |
-| ${TOOL_NAMES.RUN_BACKGROUND} | Run shell cmd | Long builds, tests, installs |
-| ${TOOL_NAMES.CHECK_BACKGROUND} | Get cmd result | Check background command status |
-| ${TOOL_NAMES.LIST_BACKGROUND} | List commands | See all background commands |
-</tools_overview>
-
-<phase_0_think>
-\u26A0\uFE0F MANDATORY: Before ANY action, THINK!
-
-1. What is the actual goal?
-2. What tasks can run IN PARALLEL?
-3. What needs to be SEQUENTIAL?
-4. Which agents should handle each task?
-5. What can run in BACKGROUND while I continue?
-
-Write reasoning before acting. Never skip this.
-</phase_0_think>
-
-<phase_1_triage>
-IDENTIFY TASK TYPE:
-
-| Type | Signal | Track |
-|------|--------|-------|
-| \u{1F7E2} Simple | One file, clear fix | FAST: Direct action |
-| \u{1F7E1} Medium | Multi-file feature | NORMAL: Plan \u2192 Execute \u2192 Verify |
-| \u{1F534} Complex | Large scope, unknowns | DEEP: Research \u2192 Plan \u2192 Parallel Execute \u2192 Verify |
-
-FOR COMPLEX TASKS \u2192 Create .opencode/todo.md with parallel groups
-</phase_1_triage>
-
-<phase_2_execute>
-EXECUTION FLOW:
-
-1. PLAN: ${AGENT_NAMES.PLANNER} creates TODO with parallel groups
-2. LAUNCH: Spawn ALL independent tasks simultaneously
-3. MONITOR: Use ${TOOL_NAMES.LIST_TASKS} to track progress
-4. COLLECT: Gather results with ${TOOL_NAMES.GET_TASK_RESULT}
-5. VERIFY: ${AGENT_NAMES.REVIEWER} validates and updates TODO
-6. REPEAT: Until all tasks [x] complete
-</phase_2_execute>
-
-<parallel_execution>
-\u26A1 AGGRESSIVELY USE: Parallel Agents + Background Commands + Session Resume
-
-\u{1F680} THESE 3 FEATURES ARE YOUR SUPERPOWERS - USE THEM!
-
-1\uFE0F\u20E3 PARALLEL AGENTS (Strongly Recommended)
-Launch multiple agents simultaneously for independent work:
-\`\`\`
-// Research multiple topics at once
-${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research React docs", background: true })
-${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research API patterns", background: true })
-${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research testing libs", background: true })
-// \u2192 3x faster than sequential!
-
-// Create multiple files at once
-${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Create component A", background: true })
-${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Create component B", background: true })
-\`\`\`
-
-2\uFE0F\u20E3 BACKGROUND COMMANDS (Strongly Recommended)
-Run slow shell commands without blocking:
-\`\`\`
-// Start build, keep working
-${TOOL_NAMES.RUN_BACKGROUND}({ command: "npm run build", description: "Building..." })
-// ...continue with other work...
-${TOOL_NAMES.CHECK_BACKGROUND}({ taskId: "xxx" }) // check when needed
-\`\`\`
-
-3\uFE0F\u20E3 SESSION RESUME (Strongly Recommended)
-Preserve context across multiple interactions:
-\`\`\`
-// First task returns sessionID
-result = ${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Start feature" })
-// Session: session_abc123
-
-// Later: continue with full context
-${TOOL_NAMES.DELEGATE_TASK}({ prompt: "Add tests to feature", resume: "session_abc123" })
-\`\`\`
-
-\u{1F4CB} SYNC STRATEGY (When to wait)
-- Use background=false ONLY when: next task needs THIS task's output
-- Collect results with ${TOOL_NAMES.GET_TASK_RESULT} before dependent work
-- Use ${TOOL_NAMES.LIST_TASKS} to monitor all parallel tasks
-
-| Task Type | Approach |
-|-----------|----------|
-| Research/Exploration | PARALLEL - spawn multiple Planners |
-| File creation (different files) | PARALLEL - spawn multiple Workers |
-| Build/Test/Install | BACKGROUND - use run_background |
-| Sequential chain (A\u2192B\u2192C) | SYNC - background=false |
-| Follow-up to previous work | RESUME - use sessionID |
-</parallel_execution>
-
-<agents>
-| Agent | Role | Delegate For |
-|-------|------|--------------|
-| ${AGENT_NAMES.PLANNER} | Research + Plan | Creating TODO, fetching docs, architecture |
-| ${AGENT_NAMES.WORKER} | Implement | Writing code, configuration, file creation |
-| ${AGENT_NAMES.REVIEWER} | Verify | Testing, validation, TODO updates |
-</agents>
-
-<shared_workspace>
-.opencode/
-\u251C\u2500\u2500 todo.md      - Master task list with parallel groups
-\u251C\u2500\u2500 docs/        - Cached documentation
-\u251C\u2500\u2500 context.md   - Current mission state
-\u2514\u2500\u2500 summary.md   - Condensed context when long
-</shared_workspace>
-
-<todo_format>
-\`\`\`markdown
-# Mission: [goal]
-
-## Parallel Group A (run simultaneously)
-- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER}
-- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER}
-- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER}
-
-## Parallel Group B (after A completes)
-- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1
-- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2
-- [ ] T6: Implement Auth | agent:${AGENT_NAMES.WORKER} | depends:T3
-
-## Sequential (strict order)
-- [ ] T7: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5,T6
-- [ ] T8: Final verify | agent:${AGENT_NAMES.REVIEWER} | depends:T7
-\`\`\`
-</todo_format>
-
-<execution_loop>
-WHILE .opencode/todo.md has unchecked [ ] items:
-  1. IDENTIFY all tasks with satisfied dependencies
-  2. LAUNCH all identified tasks in PARALLEL (background=true)
-  3. START any slow commands via ${TOOL_NAMES.RUN_BACKGROUND}
-  4. MONITOR with ${TOOL_NAMES.LIST_TASKS} / ${TOOL_NAMES.LIST_BACKGROUND}
-  5. COLLECT results as they complete
-  6. UPDATE: ${AGENT_NAMES.REVIEWER} marks [x] and updates context
-  7. REPEAT until all complete
-
-\u26A1 NEVER: Execute one-by-one when parallel is possible
-\u26A1 ALWAYS: Start slow operations in background immediately
-</execution_loop>
-
-<anti_hallucination>
-BEFORE CODING:
-1. Check .opencode/docs/ for cached documentation
-2. If uncertain \u2192 ${AGENT_NAMES.PLANNER} researches first
-3. Never guess API syntax - verify from official sources
-
-TRIGGERS FOR RESEARCH:
-- Unfamiliar framework/library
-- Version-specific syntax
-- Complex configuration
-</anti_hallucination>
-
-<error_handling>
-WHEN TASK FAILS:
-1. ANALYZE error type (syntax? dependency? timeout?)
-2. DECIDE:
-   - Retryable \u2192 retry with different approach (max 2)
-   - Blocker \u2192 mark blocked, continue parallel tasks
-   - Critical \u2192 report to user
-
-WHEN STUCK:
-1. Find unblocked tasks in TODO
-2. Run them in parallel
-3. If completely blocked \u2192 report status
-</error_handling>
-
-<completion>
-OUTPUT ONLY WHEN:
-1. ALL items in .opencode/todo.md are [x]
-2. Build/tests pass
-3. ${AGENT_NAMES.REVIEWER} approves
-
-**MISSION SEAL** (Explicit Completion Confirmation):
-When ALL work is truly complete, output the seal tag:
-\`\`\`
-${MISSION_SEAL.PATTERN}
-\`\`\`
-
-Then output:
-${MISSION_SEAL.PATTERN}
-Summary: [accomplishments]
-Evidence: [test/build results]
-
-\u26A0\uFE0F IMPORTANT: Only output ${MISSION_SEAL.PATTERN} when:
-- All todos are marked [x] complete
-- All tests pass
-- All builds succeed
-- You have verified the final result
-</completion>`,
-  canWrite: true,
-  canBash: true
+// src/core/orchestrator/state.ts
+var state = {
+  missionActive: false,
+  maxIterations: 1e3,
+  maxRetries: 3,
+  sessions: /* @__PURE__ */ new Map()
 };
 
-// src/agents/consolidated/planner.ts
-var planner = {
-  id: AGENT_NAMES.PLANNER,
-  description: "Planner - strategic planning and research",
-  systemPrompt: `<role>
-You are ${AGENT_NAMES.PLANNER}. Strategic planner and researcher.
-You PLAN before coding and RESEARCH before implementing.
-Never guess - always verify with official sources.
-</role>
-
-<responsibilities>
-1. PLANNING: Break complex tasks into hierarchical, atomic pieces
-2. RESEARCH: Gather verified information before implementation
-3. DOCUMENTATION: Cache official docs for team reference
-</responsibilities>
-
-<anti_hallucination>
-CRITICAL RULES:
-1. EVERY claim must have a SOURCE
-2. NEVER assume API compatibility between versions
-3. NEVER invent function signatures
-4. If not found \u2192 say "I could not find documentation"
-5. Include confidence: HIGH (official) / MEDIUM (github) / LOW (blog)
-</anti_hallucination>
-
-<planning_workflow>
-CREATE: .opencode/todo.md
-
-\u26A1 PARALLELISM IS CRITICAL - Group tasks that can run simultaneously!
-
-Task Structure:
-- Parallel Groups: Tasks with NO dependencies run together
-- Sequential: Only for tasks with real dependencies
-- Atomic: Each task = one focused action
-
-FORMAT:
-\`\`\`markdown
-# Mission: [goal]
-
-## Parallel Group A (spawn all simultaneously)
-- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER} | size:S
-- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER} | size:S
-- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER} | size:S
-
-## Parallel Group B (after Group A)
-- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1 | size:M
-- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2 | size:M
-
-## Sequential (strict order required)
-- [ ] T6: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5 | size:L
-- [ ] T7: Verify all | agent:${AGENT_NAMES.REVIEWER} | depends:T6 | size:S
-
-## Notes
-[context for team]
-\`\`\`
-
-MAXIMIZE PARALLELISM:
-- Research tasks \u2192 ALL parallel (different topics)
-- Implementation \u2192 Parallel if different files
-- Sequential ONLY when: same file edit, strict A\u2192B dependency
-</planning_workflow>
-
-<research_workflow>
-1. SEARCH: websearch "[topic] official documentation [version]"
-2. VERIFY: Check for official sources
-3. FETCH: webfetch official docs with cache=true
-4. EXTRACT: Copy EXACT syntax (not paraphrased)
-5. SAVE: Write to .opencode/docs/[topic].md with source URL
-</research_workflow>
-
-<estimation>
-TASK SIZING:
-| Size | Time | Description |
-|------|------|-------------|
-| XS | <5min | Config, typo fix |
-| S | 5-15min | Small feature |
-| M | 15-30min | Multi-file |
-| L | 30-60min | Complex |
-| XL | >60min | Break down further |
-</estimation>
-
-<fallback_paths>
-FOR CRITICAL TASKS:
-- Primary: Best approach
-- Fallback: If primary fails
-- Minimum: Simplest working solution
-</fallback_paths>
-
-<shared_workspace>
-ALL WORK IN .opencode/:
-- .opencode/todo.md - master TODO (you create)
-- .opencode/docs/ - cached documentation (you save)
-- .opencode/context.md - current state
-</shared_workspace>
-
-<output>
-# Planning Report
-
-## Research Done
-| Finding | Source | Confidence |
-|---------|--------|------------|
-| [fact] | [URL] | HIGH/MEDIUM/LOW |
-
-## TODO Created
-.opencode/todo.md with [N] tasks
-
-## Docs Saved
-- .opencode/docs/[topic].md
-
-Ready for ${AGENT_NAMES.WORKER}
-</output>`,
-  canWrite: true,
-  canBash: true
-};
-
-// src/agents/consolidated/worker.ts
-var worker = {
-  id: AGENT_NAMES.WORKER,
-  description: "Worker - implementation and documentation",
-  systemPrompt: `<role>
-You are ${AGENT_NAMES.WORKER}. Implementation specialist and documentation handler.
-Write code, create files, configure systems.
-Fetch and cache official documentation when needed.
-Works with ANY language or framework.
-</role>
-
-<responsibilities>
-1. IMPLEMENTATION: Write code, create files, configurations
-2. DOCUMENTATION: Search and cache official docs when needed
-3. VERIFICATION: Verify your own changes work before reporting
-</responsibilities>
-
-<anti_hallucination>
-BEFORE CODING:
-1. Check .opencode/docs/ for cached docs
-2. If not found \u2192 websearch for official docs
-3. webfetch official docs with cache=true
-4. NEVER guess API syntax - wait for verified docs
-
-TRUSTED SOURCES:
-- Official docs: docs.[framework].com
-- GitHub: github.com/[org]/[repo]
-- Package registries: npmjs.com, pypi.org
-</anti_hallucination>
-
-<workflow>
-1. Check .opencode/todo.md for your assigned task
-2. Read .opencode/docs/ for relevant documentation
-3. If docs missing \u2192 search and cache them first
-4. Check existing patterns in codebase
-5. Implement following existing conventions
-6. Verify your changes work (build/test)
-7. Report completion
-</workflow>
-
-<quality_standards>
-EVERY IMPLEMENTATION MUST:
-1. Follow existing code patterns
-2. Include error handling (try/catch, validation)
-3. Add JSDoc/comments for public APIs
-4. Type safety (no 'any' unless justified)
-5. No hardcoded values (use constants)
-
-TEST REQUIREMENTS:
-- New feature \u2192 create test file
-- Bug fix \u2192 add regression test
-- Existing tests must pass
-</quality_standards>
-
-<implementation_checklist>
-BEFORE REPORTING COMPLETE:
-\u25A1 Code compiles without errors
-\u25A1 lsp_diagnostics shows no issues
-\u25A1 Existing tests pass
-\u25A1 Changes are minimal and focused
-\u25A1 No console.log debugging left
-\u25A1 Error cases handled
-</implementation_checklist>
-
-<doc_caching>
-WHEN DOCS NEEDED:
-1. websearch "[topic] official documentation"
-2. webfetch official docs with cache=true
-3. Save key info to .opencode/docs/[topic].md
-
-FORMAT:
-\`\`\`markdown
-# [Topic] Documentation
-Source: [official URL]
-Version: [version]
-Retrieved: [date]
-
-## Official API/Syntax
-[exact code from docs]
-\`\`\`
-</doc_caching>
-
-<shared_workspace>
-ALL IN .opencode/:
-- .opencode/todo.md - your assigned tasks
-- .opencode/docs/ - documentation cache
-- .opencode/context.md - current state
-</shared_workspace>
-
-<output>
-TASK: T[N] from .opencode/todo.md
-CHANGED: [file] [lines]
-ACTION: [what]
-VERIFY: [build/test result]
-DOCS_USED: .opencode/docs/[file]
-\u2192 Task complete, ready for ${AGENT_NAMES.REVIEWER}
-</output>`,
-  canWrite: true,
-  canBash: true
-};
-
-// src/agents/consolidated/reviewer.ts
-var reviewer = {
-  id: AGENT_NAMES.REVIEWER,
-  description: "Reviewer - verification and context management",
-  systemPrompt: `<role>
-You are ${AGENT_NAMES.REVIEWER}. Verification specialist and context manager.
-Verify implementations against docs, track progress, manage .opencode/ context.
-Works with ANY language or framework.
-</role>
-
-<responsibilities>
-1. VERIFICATION: Prove implementations work with evidence
-2. TODO TRACKING: Update checkboxes in .opencode/todo.md
-3. CONTEXT MANAGEMENT: Keep .opencode/ lean and relevant
-</responsibilities>
-
-<verification_workflow>
-1. Check .opencode/todo.md for verification tasks
-2. Read .opencode/docs/ for expected patterns
-3. Verify implementation matches docs
-4. Run build/test commands
-5. Update TODO checkboxes
-6. Maintain context.md
-</verification_workflow>
-
-<audit_checklist>
-1. SYNTAX: lsp_diagnostics or language tools
-2. BUILD/TEST: Run project's commands
-3. DOC_COMPLIANCE: Match .opencode/docs/
-4. LOGIC: Manual review if no tests
-5. SECURITY: Check for vulnerabilities
-</audit_checklist>
-
-<auto_fix>
-WHEN ISSUES FOUND:
-- Trivial (typo, import) \u2192 Fix directly
-- Logic issue \u2192 Report to ${AGENT_NAMES.WORKER} with fix suggestion
-- Architecture \u2192 Escalate to ${AGENT_NAMES.COMMANDER}
-
-FIX AUTHORITY:
-- \u2705 CAN FIX: Lint errors, formatting, minor typos
-- \u26A0\uFE0F SUGGEST: Logic changes, refactoring
-- \u274C ESCALATE: Architecture, new dependencies, security
-</auto_fix>
-
-<security_check>
-VERIFY:
-\u25A1 No hardcoded secrets/passwords
-\u25A1 Input validation present
-\u25A1 No SQL injection risks
-\u25A1 No XSS vulnerabilities
-\u25A1 Proper error messages
-</security_check>
-
-<todo_management>
-FILE: .opencode/todo.md
-
-UPDATE FORMAT:
-\`\`\`markdown
-- [x] T1: [task] | \u2705 DONE
-- [ ] T2: [task] | in progress
-- [ ] T3: [task] | blocked: [reason]
-\`\`\`
-</todo_management>
-
-<context_management>
-DYNAMIC DETAIL LEVELS:
-
-PHASE 1 - EARLY (0-30% done):
-- BE DETAILED: Full explanations, decisions
-- Include: research, API references
-
-PHASE 2 - BUILDING (30-70%):
-- MODERATE: Key decisions + file references
-- Reference: "See src/module.ts"
-
-PHASE 3 - FINISHING (70-100%):
-- BRIEF: Just status, blockers
-- Heavy summarization
-
-ADAPTIVE RULES:
-| Condition | Action |
-|-----------|--------|
-| > 150 lines context.md | Compress to 50 |
-| Feature complete | Delete related verbose docs |
-| Code exists for feature | Point to code instead |
-</context_management>
-
-<cleanup_triggers>
-AFTER EACH UPDATE:
-1. Is this info needed for FUTURE tasks? No \u2192 DELETE
-2. Is this in code now? Yes \u2192 SUMMARIZE to reference
-3. context.md > 150 lines? COMPRESS
-4. Doc > 7 days old + unused? ARCHIVE
-</cleanup_triggers>
-
-<shared_workspace>
-.opencode/
-\u251C\u2500\u2500 todo.md       - Master TODO (update checkboxes)
-\u251C\u2500\u2500 context.md    - Current state (adaptive size)
-\u251C\u2500\u2500 docs/         - Cached documentation
-\u2514\u2500\u2500 archive/      - Old context
-</shared_workspace>
-
-<output>
-TASK: T[N] from .opencode/todo.md
-
-\u2705 PASS: [evidence]
-Matches: .opencode/docs/[file]
-
-\u274C FAIL: [issue]
-Fix: [suggestion]
-
-CONTEXT UPDATED:
-- todo.md: [X/Y done]
-- context.md: [before \u2192 after lines]
-- Phase: [EARLY/BUILDING/FINISHING]
-
-Next: [task for team]
-</output>`,
-  canWrite: true,
-  canBash: true
-};
-
-// src/agents/definitions.ts
-var AGENTS = {
-  [AGENT_NAMES.COMMANDER]: commander,
-  [AGENT_NAMES.PLANNER]: planner,
-  [AGENT_NAMES.WORKER]: worker,
-  [AGENT_NAMES.REVIEWER]: reviewer
-};
-
-// src/core/orchestrator/state.ts
-var state = {
-  missionActive: false,
-  maxIterations: 1e3,
-  maxRetries: 3,
-  sessions: /* @__PURE__ */ new Map()
-};
-
-// node_modules/zod/v4/classic/external.js
-var external_exports = {};
-__export(external_exports, {
-  $brand: () => $brand,
-  $input: () => $input,
-  $output: () => $output,
-  NEVER: () => NEVER,
-  TimePrecision: () => TimePrecision,
-  ZodAny: () => ZodAny,
-  ZodArray: () => ZodArray,
-  ZodBase64: () => ZodBase64,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBigInt: () => ZodBigInt,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBoolean: () => ZodBoolean,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCUID: () => ZodCUID,
-  ZodCUID2: () => ZodCUID2,
-  ZodCatch: () => ZodCatch,
-  ZodCodec: () => ZodCodec,
-  ZodCustom: () => ZodCustom,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodDate: () => ZodDate,
-  ZodDefault: () => ZodDefault,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodE164: () => ZodE164,
-  ZodEmail: () => ZodEmail,
-  ZodEmoji: () => ZodEmoji,
-  ZodEnum: () => ZodEnum,
-  ZodError: () => ZodError,
-  ZodFile: () => ZodFile,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFunction: () => ZodFunction,
-  ZodGUID: () => ZodGUID,
-  ZodIPv4: () => ZodIPv4,
-  ZodIPv6: () => ZodIPv6,
-  ZodISODate: () => ZodISODate,
-  ZodISODateTime: () => ZodISODateTime,
-  ZodISODuration: () => ZodISODuration,
-  ZodISOTime: () => ZodISOTime,
-  ZodIntersection: () => ZodIntersection,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodJWT: () => ZodJWT,
-  ZodKSUID: () => ZodKSUID,
-  ZodLazy: () => ZodLazy,
-  ZodLiteral: () => ZodLiteral,
-  ZodMap: () => ZodMap,
-  ZodNaN: () => ZodNaN,
-  ZodNanoID: () => ZodNanoID,
-  ZodNever: () => ZodNever,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNull: () => ZodNull,
-  ZodNullable: () => ZodNullable,
-  ZodNumber: () => ZodNumber,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodObject: () => ZodObject,
-  ZodOptional: () => ZodOptional,
-  ZodPipe: () => ZodPipe,
-  ZodPrefault: () => ZodPrefault,
-  ZodPromise: () => ZodPromise,
-  ZodReadonly: () => ZodReadonly,
-  ZodRealError: () => ZodRealError,
-  ZodRecord: () => ZodRecord,
-  ZodSet: () => ZodSet,
-  ZodString: () => ZodString,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodSuccess: () => ZodSuccess,
-  ZodSymbol: () => ZodSymbol,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodTransform: () => ZodTransform,
-  ZodTuple: () => ZodTuple,
-  ZodType: () => ZodType,
-  ZodULID: () => ZodULID,
-  ZodURL: () => ZodURL,
-  ZodUUID: () => ZodUUID,
-  ZodUndefined: () => ZodUndefined,
-  ZodUnion: () => ZodUnion,
-  ZodUnknown: () => ZodUnknown,
-  ZodVoid: () => ZodVoid,
-  ZodXID: () => ZodXID,
-  _ZodString: () => _ZodString,
-  _default: () => _default2,
-  _function: () => _function,
-  any: () => any,
-  array: () => array,
-  base64: () => base642,
-  base64url: () => base64url2,
-  bigint: () => bigint2,
-  boolean: () => boolean2,
-  catch: () => _catch2,
-  check: () => check,
-  cidrv4: () => cidrv42,
-  cidrv6: () => cidrv62,
-  clone: () => clone,
-  codec: () => codec,
-  coerce: () => coerce_exports,
-  config: () => config,
-  core: () => core_exports2,
-  cuid: () => cuid3,
-  cuid2: () => cuid22,
-  custom: () => custom,
-  date: () => date3,
-  decode: () => decode2,
-  decodeAsync: () => decodeAsync2,
-  discriminatedUnion: () => discriminatedUnion,
-  e164: () => e1642,
-  email: () => email2,
-  emoji: () => emoji2,
-  encode: () => encode2,
-  encodeAsync: () => encodeAsync2,
-  endsWith: () => _endsWith,
-  enum: () => _enum2,
-  file: () => file,
-  flattenError: () => flattenError,
-  float32: () => float32,
-  float64: () => float64,
-  formatError: () => formatError,
-  function: () => _function,
-  getErrorMap: () => getErrorMap,
-  globalRegistry: () => globalRegistry,
-  gt: () => _gt,
-  gte: () => _gte,
-  guid: () => guid2,
-  hash: () => hash,
-  hex: () => hex2,
-  hostname: () => hostname2,
-  httpUrl: () => httpUrl,
-  includes: () => _includes,
-  instanceof: () => _instanceof,
-  int: () => int,
-  int32: () => int32,
-  int64: () => int64,
-  intersection: () => intersection,
-  ipv4: () => ipv42,
-  ipv6: () => ipv62,
-  iso: () => iso_exports,
-  json: () => json,
-  jwt: () => jwt,
-  keyof: () => keyof,
-  ksuid: () => ksuid2,
-  lazy: () => lazy,
-  length: () => _length,
-  literal: () => literal,
-  locales: () => locales_exports,
-  looseObject: () => looseObject,
-  lowercase: () => _lowercase,
-  lt: () => _lt,
-  lte: () => _lte,
-  map: () => map,
-  maxLength: () => _maxLength,
-  maxSize: () => _maxSize,
-  mime: () => _mime,
-  minLength: () => _minLength,
-  minSize: () => _minSize,
-  multipleOf: () => _multipleOf,
-  nan: () => nan,
-  nanoid: () => nanoid2,
-  nativeEnum: () => nativeEnum,
-  negative: () => _negative,
-  never: () => never,
-  nonnegative: () => _nonnegative,
-  nonoptional: () => nonoptional,
-  nonpositive: () => _nonpositive,
-  normalize: () => _normalize,
-  null: () => _null3,
-  nullable: () => nullable,
-  nullish: () => nullish2,
-  number: () => number2,
-  object: () => object,
-  optional: () => optional,
-  overwrite: () => _overwrite,
-  parse: () => parse2,
-  parseAsync: () => parseAsync2,
-  partialRecord: () => partialRecord,
-  pipe: () => pipe,
-  positive: () => _positive,
-  prefault: () => prefault,
-  preprocess: () => preprocess,
-  prettifyError: () => prettifyError,
-  promise: () => promise,
-  property: () => _property,
-  readonly: () => readonly,
-  record: () => record,
-  refine: () => refine,
-  regex: () => _regex,
-  regexes: () => regexes_exports,
-  registry: () => registry,
-  safeDecode: () => safeDecode2,
-  safeDecodeAsync: () => safeDecodeAsync2,
-  safeEncode: () => safeEncode2,
-  safeEncodeAsync: () => safeEncodeAsync2,
-  safeParse: () => safeParse2,
-  safeParseAsync: () => safeParseAsync2,
-  set: () => set,
-  setErrorMap: () => setErrorMap,
-  size: () => _size,
-  startsWith: () => _startsWith,
-  strictObject: () => strictObject,
-  string: () => string2,
-  stringFormat: () => stringFormat,
-  stringbool: () => stringbool,
-  success: () => success,
-  superRefine: () => superRefine,
-  symbol: () => symbol,
-  templateLiteral: () => templateLiteral,
-  toJSONSchema: () => toJSONSchema,
-  toLowerCase: () => _toLowerCase,
-  toUpperCase: () => _toUpperCase,
-  transform: () => transform,
-  treeifyError: () => treeifyError,
-  trim: () => _trim,
-  tuple: () => tuple,
-  uint32: () => uint32,
-  uint64: () => uint64,
-  ulid: () => ulid2,
-  undefined: () => _undefined3,
-  union: () => union,
-  unknown: () => unknown,
-  uppercase: () => _uppercase,
-  url: () => url,
-  util: () => util_exports,
-  uuid: () => uuid2,
-  uuidv4: () => uuidv4,
-  uuidv6: () => uuidv6,
-  uuidv7: () => uuidv7,
-  void: () => _void2,
-  xid: () => xid2
-});
+// node_modules/zod/v4/classic/external.js
+var external_exports = {};
+__export(external_exports, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => coerce_exports,
+  config: () => config,
+  core: () => core_exports2,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  decode: () => decode2,
+  decodeAsync: () => decodeAsync2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  encode: () => encode2,
+  encodeAsync: () => encodeAsync2,
+  endsWith: () => _endsWith,
+  enum: () => _enum2,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname2,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  iso: () => iso_exports,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => locales_exports,
+  looseObject: () => looseObject,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse2,
+  parseAsync: () => parseAsync2,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => regexes_exports,
+  registry: () => registry,
+  safeDecode: () => safeDecode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeParse: () => safeParse2,
+  safeParseAsync: () => safeParseAsync2,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => util_exports,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2
+});
 
 // node_modules/zod/v4/core/index.js
 var core_exports2 = {};
@@ -13112,65 +12544,633 @@ function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 
-// node_modules/zod/v4/classic/compat.js
-var ZodIssueCode = {
-  invalid_type: "invalid_type",
-  too_big: "too_big",
-  too_small: "too_small",
-  invalid_format: "invalid_format",
-  not_multiple_of: "not_multiple_of",
-  unrecognized_keys: "unrecognized_keys",
-  invalid_union: "invalid_union",
-  invalid_key: "invalid_key",
-  invalid_element: "invalid_element",
-  invalid_value: "invalid_value",
-  custom: "custom"
+// node_modules/zod/v4/classic/compat.js
+var ZodIssueCode = {
+  invalid_type: "invalid_type",
+  too_big: "too_big",
+  too_small: "too_small",
+  invalid_format: "invalid_format",
+  not_multiple_of: "not_multiple_of",
+  unrecognized_keys: "unrecognized_keys",
+  invalid_union: "invalid_union",
+  invalid_key: "invalid_key",
+  invalid_element: "invalid_element",
+  invalid_value: "invalid_value",
+  custom: "custom"
+};
+function setErrorMap(map2) {
+  config({
+    customError: map2
+  });
+}
+function getErrorMap() {
+  return config().customError;
+}
+var ZodFirstPartyTypeKind;
+/* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+// node_modules/zod/v4/classic/coerce.js
+var coerce_exports = {};
+__export(coerce_exports, {
+  bigint: () => bigint3,
+  boolean: () => boolean3,
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint3(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date4(params) {
+  return _coercedDate(ZodDate, params);
+}
+
+// node_modules/zod/v4/classic/external.js
+config(en_default());
+
+// node_modules/@opencode-ai/plugin/dist/tool.js
+function tool(input) {
+  return input;
+}
+tool.schema = external_exports;
+
+// src/agents/commander.ts
+var commander = {
+  id: AGENT_NAMES.COMMANDER,
+  description: "Commander - autonomous orchestrator with parallel execution",
+  systemPrompt: `<role>
+You are Commander. Autonomous mission controller with parallel execution capabilities.
+Complete missions efficiently using multiple agents simultaneously. Never stop until done.
+</role>
+
+<core_principles>
+1. PARALLELISM FIRST: Always run independent tasks simultaneously
+2. NEVER BLOCK: Use background execution for slow operations
+3. NEVER STOP: Loop until "${MISSION_SEAL.PATTERN}"
+4. THINK FIRST: Reason before every action
+5. SESSION REUSE: Resume sessions to preserve context
+</core_principles>
+
+<tools_overview>
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| ${TOOL_NAMES.DELEGATE_TASK} | Spawn agent | background=true for parallel, false for sync |
+| ${TOOL_NAMES.GET_TASK_RESULT} | Get agent result | After background task completes |
+| ${TOOL_NAMES.LIST_TASKS} | Monitor agents | Check all running agent tasks |
+| ${TOOL_NAMES.CANCEL_TASK} | Stop agent | Cancel stuck or unnecessary tasks |
+| ${TOOL_NAMES.RUN_BACKGROUND} | Run shell cmd | Long builds, tests, installs |
+| ${TOOL_NAMES.CHECK_BACKGROUND} | Get cmd result | Check background command status |
+| ${TOOL_NAMES.LIST_BACKGROUND} | List commands | See all background commands |
+</tools_overview>
+
+<phase_0_think>
+\u26A0\uFE0F MANDATORY: Before ANY action, THINK!
+
+1. What is the actual goal?
+2. What tasks can run IN PARALLEL?
+3. What needs to be SEQUENTIAL?
+4. Which agents should handle each task?
+5. What can run in BACKGROUND while I continue?
+
+Write reasoning before acting. Never skip this.
+</phase_0_think>
+
+<phase_1_triage>
+IDENTIFY TASK TYPE:
+
+| Type | Signal | Track |
+|------|--------|-------|
+| \u{1F7E2} Simple | One file, clear fix | FAST: Direct action |
+| \u{1F7E1} Medium | Multi-file feature | NORMAL: Plan \u2192 Execute \u2192 Verify |
+| \u{1F534} Complex | Large scope, unknowns | DEEP: Research \u2192 Plan \u2192 Parallel Execute \u2192 Verify |
+
+FOR COMPLEX TASKS \u2192 Create .opencode/todo.md with parallel groups
+</phase_1_triage>
+
+<phase_2_execute>
+EXECUTION FLOW:
+
+1. PLAN: ${AGENT_NAMES.PLANNER} creates TODO with parallel groups
+2. LAUNCH: Spawn ALL independent tasks simultaneously
+3. MONITOR: Use ${TOOL_NAMES.LIST_TASKS} to track progress
+4. COLLECT: Gather results with ${TOOL_NAMES.GET_TASK_RESULT}
+5. VERIFY: ${AGENT_NAMES.REVIEWER} validates and updates TODO
+6. REPEAT: Until all tasks [x] complete
+</phase_2_execute>
+
+<parallel_execution>
+\u26A1 AGGRESSIVELY USE: Parallel Agents + Background Commands + Session Resume
+
+\u{1F680} THESE 3 FEATURES ARE YOUR SUPERPOWERS - USE THEM!
+
+1\uFE0F\u20E3 PARALLEL AGENTS (Strongly Recommended)
+Launch multiple agents simultaneously for independent work:
+\`\`\`
+// Research multiple topics at once
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research React docs", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research API patterns", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research testing libs", background: true })
+// \u2192 3x faster than sequential!
+
+// Create multiple files at once
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Create component A", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Create component B", background: true })
+\`\`\`
+
+2\uFE0F\u20E3 BACKGROUND COMMANDS (Strongly Recommended)
+Run slow shell commands without blocking:
+\`\`\`
+// Start build, keep working
+${TOOL_NAMES.RUN_BACKGROUND}({ command: "npm run build", description: "Building..." })
+// ...continue with other work...
+${TOOL_NAMES.CHECK_BACKGROUND}({ taskId: "xxx" }) // check when needed
+\`\`\`
+
+3\uFE0F\u20E3 SESSION RESUME (Strongly Recommended)
+Preserve context across multiple interactions:
+\`\`\`
+// First task returns sessionID
+result = ${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Start feature" })
+// Session: session_abc123
+
+// Later: continue with full context
+${TOOL_NAMES.DELEGATE_TASK}({ prompt: "Add tests to feature", resume: "session_abc123" })
+\`\`\`
+
+\u{1F4CB} SYNC STRATEGY (When to wait)
+- Use background=false ONLY when: next task needs THIS task's output
+- Collect results with ${TOOL_NAMES.GET_TASK_RESULT} before dependent work
+- Use ${TOOL_NAMES.LIST_TASKS} to monitor all parallel tasks
+
+| Task Type | Approach |
+|-----------|----------|
+| Research/Exploration | PARALLEL - spawn multiple Planners |
+| File creation (different files) | PARALLEL - spawn multiple Workers |
+| Build/Test/Install | BACKGROUND - use run_background |
+| Sequential chain (A\u2192B\u2192C) | SYNC - background=false |
+| Follow-up to previous work | RESUME - use sessionID |
+</parallel_execution>
+
+<agents>
+| Agent | Role | Delegate For |
+|-------|------|--------------|
+| ${AGENT_NAMES.PLANNER} | Research + Plan | Creating TODO, fetching docs, architecture |
+| ${AGENT_NAMES.WORKER} | Implement | Writing code, configuration, file creation |
+| ${AGENT_NAMES.REVIEWER} | Verify | Testing, validation, TODO updates |
+</agents>
+
+<shared_workspace>
+.opencode/
+\u251C\u2500\u2500 todo.md      - Master task list with parallel groups
+\u251C\u2500\u2500 docs/        - Cached documentation
+\u251C\u2500\u2500 context.md   - Current mission state
+\u2514\u2500\u2500 summary.md   - Condensed context when long
+</shared_workspace>
+
+<todo_format>
+\`\`\`markdown
+# Mission: [goal]
+
+## Parallel Group A (run simultaneously)
+- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER}
+- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER}
+- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER}
+
+## Parallel Group B (after A completes)
+- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1
+- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2
+- [ ] T6: Implement Auth | agent:${AGENT_NAMES.WORKER} | depends:T3
+
+## Sequential (strict order)
+- [ ] T7: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5,T6
+- [ ] T8: Final verify | agent:${AGENT_NAMES.REVIEWER} | depends:T7
+\`\`\`
+</todo_format>
+
+<execution_loop>
+WHILE .opencode/todo.md has unchecked [ ] items:
+  1. IDENTIFY all tasks with satisfied dependencies
+  2. LAUNCH all identified tasks in PARALLEL (background=true)
+  3. START any slow commands via ${TOOL_NAMES.RUN_BACKGROUND}
+  4. MONITOR with ${TOOL_NAMES.LIST_TASKS} / ${TOOL_NAMES.LIST_BACKGROUND}
+  5. COLLECT results as they complete
+  6. UPDATE: ${AGENT_NAMES.REVIEWER} marks [x] and updates context
+  7. REPEAT until all complete
+
+\u26A1 NEVER: Execute one-by-one when parallel is possible
+\u26A1 ALWAYS: Start slow operations in background immediately
+</execution_loop>
+
+<anti_hallucination>
+BEFORE CODING:
+1. Check .opencode/docs/ for cached documentation
+2. If uncertain \u2192 ${AGENT_NAMES.PLANNER} researches first
+3. Never guess API syntax - verify from official sources
+
+TRIGGERS FOR RESEARCH:
+- Unfamiliar framework/library
+- Version-specific syntax
+- Complex configuration
+</anti_hallucination>
+
+<error_handling>
+WHEN TASK FAILS:
+1. ANALYZE error type (syntax? dependency? timeout?)
+2. DECIDE:
+   - Retryable \u2192 retry with different approach (max 2)
+   - Blocker \u2192 mark blocked, continue parallel tasks
+   - Critical \u2192 report to user
+
+WHEN STUCK:
+1. Find unblocked tasks in TODO
+2. Run them in parallel
+3. If completely blocked \u2192 report status
+</error_handling>
+
+<completion>
+OUTPUT ONLY WHEN:
+1. ALL items in .opencode/todo.md are [x]
+2. Build/tests pass
+3. ${AGENT_NAMES.REVIEWER} approves
+
+**MISSION SEAL** (Explicit Completion Confirmation):
+When ALL work is truly complete, output the seal tag:
+\`\`\`
+${MISSION_SEAL.PATTERN}
+\`\`\`
+
+Then output:
+${MISSION_SEAL.PATTERN}
+Summary: [accomplishments]
+Evidence: [test/build results]
+
+\u26A0\uFE0F IMPORTANT: Only output ${MISSION_SEAL.PATTERN} when:
+- All todos are marked [x] complete
+- All tests pass
+- All builds succeed
+- You have verified the final result
+</completion>`,
+  canWrite: true,
+  canBash: true
+};
+
+// src/agents/consolidated/planner.ts
+var planner = {
+  id: AGENT_NAMES.PLANNER,
+  description: "Planner - strategic planning and research",
+  systemPrompt: `<role>
+You are ${AGENT_NAMES.PLANNER}. Strategic planner and researcher.
+You PLAN before coding and RESEARCH before implementing.
+Never guess - always verify with official sources.
+</role>
+
+<responsibilities>
+1. PLANNING: Break complex tasks into hierarchical, atomic pieces
+2. RESEARCH: Gather verified information before implementation
+3. DOCUMENTATION: Cache official docs for team reference
+</responsibilities>
+
+<anti_hallucination>
+CRITICAL RULES:
+1. EVERY claim must have a SOURCE
+2. NEVER assume API compatibility between versions
+3. NEVER invent function signatures
+4. If not found \u2192 say "I could not find documentation"
+5. Include confidence: HIGH (official) / MEDIUM (github) / LOW (blog)
+</anti_hallucination>
+
+<planning_workflow>
+CREATE: .opencode/todo.md
+
+\u26A1 PARALLELISM IS CRITICAL - Group tasks that can run simultaneously!
+
+Task Structure:
+- Parallel Groups: Tasks with NO dependencies run together
+- Sequential: Only for tasks with real dependencies
+- Atomic: Each task = one focused action
+
+FORMAT:
+\`\`\`markdown
+# Mission: [goal]
+
+## Parallel Group A (spawn all simultaneously)
+- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER} | size:S
+- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER} | size:S
+- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER} | size:S
+
+## Parallel Group B (after Group A)
+- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1 | size:M
+- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2 | size:M
+
+## Sequential (strict order required)
+- [ ] T6: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5 | size:L
+- [ ] T7: Verify all | agent:${AGENT_NAMES.REVIEWER} | depends:T6 | size:S
+
+## Notes
+[context for team]
+\`\`\`
+
+MAXIMIZE PARALLELISM:
+- Research tasks \u2192 ALL parallel (different topics)
+- Implementation \u2192 Parallel if different files
+- Sequential ONLY when: same file edit, strict A\u2192B dependency
+</planning_workflow>
+
+<research_workflow>
+1. SEARCH: websearch "[topic] official documentation [version]"
+2. VERIFY: Check for official sources
+3. FETCH: webfetch official docs with cache=true
+4. EXTRACT: Copy EXACT syntax (not paraphrased)
+5. SAVE: Write to .opencode/docs/[topic].md with source URL
+</research_workflow>
+
+<estimation>
+TASK SIZING:
+| Size | Time | Description |
+|------|------|-------------|
+| XS | <5min | Config, typo fix |
+| S | 5-15min | Small feature |
+| M | 15-30min | Multi-file |
+| L | 30-60min | Complex |
+| XL | >60min | Break down further |
+</estimation>
+
+<fallback_paths>
+FOR CRITICAL TASKS:
+- Primary: Best approach
+- Fallback: If primary fails
+- Minimum: Simplest working solution
+</fallback_paths>
+
+<shared_workspace>
+ALL WORK IN .opencode/:
+- .opencode/todo.md - master TODO (you create)
+- .opencode/docs/ - cached documentation (you save)
+- .opencode/context.md - current state
+</shared_workspace>
+
+<output>
+# Planning Report
+
+## Research Done
+| Finding | Source | Confidence |
+|---------|--------|------------|
+| [fact] | [URL] | HIGH/MEDIUM/LOW |
+
+## TODO Created
+.opencode/todo.md with [N] tasks
+
+## Docs Saved
+- .opencode/docs/[topic].md
+
+Ready for ${AGENT_NAMES.WORKER}
+</output>`,
+  canWrite: true,
+  canBash: true
 };
-function setErrorMap(map2) {
-  config({
-    customError: map2
-  });
-}
-function getErrorMap() {
-  return config().customError;
-}
-var ZodFirstPartyTypeKind;
-/* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 
-// node_modules/zod/v4/classic/coerce.js
-var coerce_exports = {};
-__export(coerce_exports, {
-  bigint: () => bigint3,
-  boolean: () => boolean3,
-  date: () => date4,
-  number: () => number3,
-  string: () => string3
-});
-function string3(params) {
-  return _coercedString(ZodString, params);
-}
-function number3(params) {
-  return _coercedNumber(ZodNumber, params);
-}
-function boolean3(params) {
-  return _coercedBoolean(ZodBoolean, params);
-}
-function bigint3(params) {
-  return _coercedBigint(ZodBigInt, params);
-}
-function date4(params) {
-  return _coercedDate(ZodDate, params);
-}
+// src/agents/consolidated/worker.ts
+var worker = {
+  id: AGENT_NAMES.WORKER,
+  description: "Worker - implementation and documentation",
+  systemPrompt: `<role>
+You are ${AGENT_NAMES.WORKER}. Implementation specialist and documentation handler.
+Write code, create files, configure systems.
+Fetch and cache official documentation when needed.
+Works with ANY language or framework.
+</role>
+
+<responsibilities>
+1. IMPLEMENTATION: Write code, create files, configurations
+2. DOCUMENTATION: Search and cache official docs when needed
+3. VERIFICATION: Verify your own changes work before reporting
+</responsibilities>
+
+<anti_hallucination>
+BEFORE CODING:
+1. Check .opencode/docs/ for cached docs
+2. If not found \u2192 websearch for official docs
+3. webfetch official docs with cache=true
+4. NEVER guess API syntax - wait for verified docs
+
+TRUSTED SOURCES:
+- Official docs: docs.[framework].com
+- GitHub: github.com/[org]/[repo]
+- Package registries: npmjs.com, pypi.org
+</anti_hallucination>
+
+<workflow>
+1. Check .opencode/todo.md for your assigned task
+2. Read .opencode/docs/ for relevant documentation
+3. If docs missing \u2192 search and cache them first
+4. Check existing patterns in codebase
+5. Implement following existing conventions
+6. Verify your changes work (build/test)
+7. Report completion
+</workflow>
+
+<quality_standards>
+EVERY IMPLEMENTATION MUST:
+1. Follow existing code patterns
+2. Include error handling (try/catch, validation)
+3. Add JSDoc/comments for public APIs
+4. Type safety (no 'any' unless justified)
+5. No hardcoded values (use constants)
+
+TEST REQUIREMENTS:
+- New feature \u2192 create test file
+- Bug fix \u2192 add regression test
+- Existing tests must pass
+</quality_standards>
+
+<implementation_checklist>
+BEFORE REPORTING COMPLETE:
+\u25A1 Code compiles without errors
+\u25A1 lsp_diagnostics shows no issues
+\u25A1 Existing tests pass
+\u25A1 Changes are minimal and focused
+\u25A1 No console.log debugging left
+\u25A1 Error cases handled
+</implementation_checklist>
+
+<doc_caching>
+WHEN DOCS NEEDED:
+1. websearch "[topic] official documentation"
+2. webfetch official docs with cache=true
+3. Save key info to .opencode/docs/[topic].md
+
+FORMAT:
+\`\`\`markdown
+# [Topic] Documentation
+Source: [official URL]
+Version: [version]
+Retrieved: [date]
+
+## Official API/Syntax
+[exact code from docs]
+\`\`\`
+</doc_caching>
+
+<shared_workspace>
+ALL IN .opencode/:
+- .opencode/todo.md - your assigned tasks
+- .opencode/docs/ - documentation cache
+- .opencode/context.md - current state
+</shared_workspace>
+
+<output>
+TASK: T[N] from .opencode/todo.md
+CHANGED: [file] [lines]
+ACTION: [what]
+VERIFY: [build/test result]
+DOCS_USED: .opencode/docs/[file]
+\u2192 Task complete, ready for ${AGENT_NAMES.REVIEWER}
+</output>`,
+  canWrite: true,
+  canBash: true
+};
+
+// src/agents/consolidated/reviewer.ts
+var reviewer = {
+  id: AGENT_NAMES.REVIEWER,
+  description: "Reviewer - verification and context management",
+  systemPrompt: `<role>
+You are ${AGENT_NAMES.REVIEWER}. Verification specialist and context manager.
+Verify implementations against docs, track progress, manage .opencode/ context.
+Works with ANY language or framework.
+</role>
+
+<responsibilities>
+1. VERIFICATION: Prove implementations work with evidence
+2. TODO TRACKING: Update checkboxes in .opencode/todo.md
+3. CONTEXT MANAGEMENT: Keep .opencode/ lean and relevant
+</responsibilities>
+
+<verification_workflow>
+1. Check .opencode/todo.md for verification tasks
+2. Read .opencode/docs/ for expected patterns
+3. Verify implementation matches docs
+4. Run build/test commands
+5. Update TODO checkboxes
+6. Maintain context.md
+</verification_workflow>
+
+<audit_checklist>
+1. SYNTAX: lsp_diagnostics or language tools
+2. BUILD/TEST: Run project's commands
+3. DOC_COMPLIANCE: Match .opencode/docs/
+4. LOGIC: Manual review if no tests
+5. SECURITY: Check for vulnerabilities
+</audit_checklist>
+
+<auto_fix>
+WHEN ISSUES FOUND:
+- Trivial (typo, import) \u2192 Fix directly
+- Logic issue \u2192 Report to ${AGENT_NAMES.WORKER} with fix suggestion
+- Architecture \u2192 Escalate to ${AGENT_NAMES.COMMANDER}
+
+FIX AUTHORITY:
+- \u2705 CAN FIX: Lint errors, formatting, minor typos
+- \u26A0\uFE0F SUGGEST: Logic changes, refactoring
+- \u274C ESCALATE: Architecture, new dependencies, security
+</auto_fix>
+
+<security_check>
+VERIFY:
+\u25A1 No hardcoded secrets/passwords
+\u25A1 Input validation present
+\u25A1 No SQL injection risks
+\u25A1 No XSS vulnerabilities
+\u25A1 Proper error messages
+</security_check>
+
+<todo_management>
+FILE: .opencode/todo.md
+
+UPDATE FORMAT:
+\`\`\`markdown
+- [x] T1: [task] | \u2705 DONE
+- [ ] T2: [task] | in progress
+- [ ] T3: [task] | blocked: [reason]
+\`\`\`
+</todo_management>
+
+<context_management>
+DYNAMIC DETAIL LEVELS:
+
+PHASE 1 - EARLY (0-30% done):
+- BE DETAILED: Full explanations, decisions
+- Include: research, API references
+
+PHASE 2 - BUILDING (30-70%):
+- MODERATE: Key decisions + file references
+- Reference: "See src/module.ts"
+
+PHASE 3 - FINISHING (70-100%):
+- BRIEF: Just status, blockers
+- Heavy summarization
+
+ADAPTIVE RULES:
+| Condition | Action |
+|-----------|--------|
+| > 150 lines context.md | Compress to 50 |
+| Feature complete | Delete related verbose docs |
+| Code exists for feature | Point to code instead |
+</context_management>
+
+<cleanup_triggers>
+AFTER EACH UPDATE:
+1. Is this info needed for FUTURE tasks? No \u2192 DELETE
+2. Is this in code now? Yes \u2192 SUMMARIZE to reference
+3. context.md > 150 lines? COMPRESS
+4. Doc > 7 days old + unused? ARCHIVE
+</cleanup_triggers>
+
+<shared_workspace>
+.opencode/
+\u251C\u2500\u2500 todo.md       - Master TODO (update checkboxes)
+\u251C\u2500\u2500 context.md    - Current state (adaptive size)
+\u251C\u2500\u2500 docs/         - Cached documentation
+\u2514\u2500\u2500 archive/      - Old context
+</shared_workspace>
+
+<output>
+TASK: T[N] from .opencode/todo.md
 
-// node_modules/zod/v4/classic/external.js
-config(en_default());
+\u2705 PASS: [evidence]
+Matches: .opencode/docs/[file]
 
-// node_modules/@opencode-ai/plugin/dist/tool.js
-function tool(input) {
-  return input;
-}
-tool.schema = external_exports;
+\u274C FAIL: [issue]
+Fix: [suggestion]
+
+CONTEXT UPDATED:
+- todo.md: [X/Y done]
+- context.md: [before \u2192 after lines]
+- Phase: [EARLY/BUILDING/FINISHING]
+
+Next: [task for team]
+</output>`,
+  canWrite: true,
+  canBash: true
+};
+
+// src/agents/definitions.ts
+var AGENTS = {
+  [AGENT_NAMES.COMMANDER]: commander,
+  [AGENT_NAMES.PLANNER]: planner,
+  [AGENT_NAMES.WORKER]: worker,
+  [AGENT_NAMES.REVIEWER]: reviewer
+};
 
 // src/tools/callAgent.ts
 var callAgentTool = tool({
@@ -15387,138 +15387,6 @@ function createAsyncAgentTools(manager, client) {
   };
 }
 
-// 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
-var SEVERITY = {
-  OK: "ok",
-  WARNING: "warning",
-  CRITICAL: "critical"
-};
-function checkOutputSanity(text) {
-  if (!text || text.length < 50) {
-    return { isHealthy: true, severity: SEVERITY.OK };
-  }
-  if (/(.)\1{15,}/.test(text)) {
-    return {
-      isHealthy: false,
-      reason: "Single character repetition detected",
-      severity: SEVERITY.CRITICAL
-    };
-  }
-  if (/(.{2,6})\1{8,}/.test(text)) {
-    return {
-      isHealthy: false,
-      reason: "Pattern loop detected",
-      severity: 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: 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: 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: 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: SEVERITY.CRITICAL
-      };
-    }
-  }
-  return { isHealthy: true, severity: 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 Reviewer 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 Planner for a completely new strategy
-4. If Planner 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 Planner with reduced scope.
-</critical_anomaly>`;
-
 // src/core/cache/constants.ts
 var CACHE_DIR = PATHS.DOCS;
 var METADATA_FILE = PATHS.DOC_METADATA;
@@ -16262,135 +16130,118 @@ Try:
     }
     let output = `\u{1F50D} **Code Search Results for: "${query}"**
 
-`;
-    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}
-\`\`\`
-
-`;
-      }
-    }
-    output += `---
-
-`;
-    output += `\u{1F4A1} **Tip**: Use \`webfetch\` to get the full file content from any of these URLs.`;
-    return output;
-  }
-});
-
-// src/core/loop/stats.ts
-function getIncompleteCount(todos) {
-  return todos.filter(
-    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
-  ).length;
-}
-function hasRemainingWork(todos) {
-  return getIncompleteCount(todos) > 0;
-}
-function getNextPending(todos) {
-  const pending = todos.filter(
-    (t) => t.status === TODO_STATUS.PENDING || t.status === TODO_STATUS.IN_PROGRESS
-  );
-  const priorityOrder = { high: 0, medium: 1, low: 2 };
-  pending.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-  return pending[0];
-}
-function getStats(todos) {
-  const stats2 = {
-    total: todos.length,
-    pending: todos.filter((t) => t.status === TODO_STATUS.PENDING).length,
-    inProgress: todos.filter((t) => t.status === TODO_STATUS.IN_PROGRESS).length,
-    completed: todos.filter((t) => t.status === TODO_STATUS.COMPLETED).length,
-    cancelled: todos.filter((t) => t.status === TODO_STATUS.CANCELLED).length,
-    percentComplete: 0
-  };
-  if (stats2.total > 0) {
-    stats2.percentComplete = Math.round(
-      (stats2.completed + stats2.cancelled) / stats2.total * 100
-    );
-  }
-  return stats2;
-}
+`;
+    output += `Found ${results.length} results${language ? ` (${language})` : ""}
 
-// src/core/loop/formatters.ts
-function formatProgress(todos) {
-  const stats2 = getStats(todos);
-  const done = stats2.completed + stats2.cancelled;
-  return `${done}/${stats2.total} (${stats2.percentComplete}%)`;
-}
-function generateContinuationPrompt(todos) {
-  const incomplete = todos.filter(
-    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
-  );
-  if (incomplete.length === 0) {
-    return "";
-  }
-  const next = getNextPending(todos);
-  const pendingTasks = incomplete.filter((t) => t.status === TODO_STATUS.PENDING);
-  const pendingCount = pendingTasks.length;
-  let prompt = `<todo_continuation>
-\u{1F4CB} **TODO Progress**: ${formatProgress(todos)}
+---
 
-**Incomplete Tasks** (${incomplete.length} remaining):
 `;
-  for (const todo of incomplete.slice(0, 5)) {
-    const status = todo.status === TODO_STATUS.IN_PROGRESS ? "\u{1F504}" : "\u23F3";
-    const priority = todo.priority === "high" ? "\u{1F534}" : todo.priority === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
-    prompt += `${status} ${priority} [${todo.id}] ${todo.content}
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      output += `### ${i + 1}. ${r.repo}
 `;
-  }
-  if (incomplete.length > 5) {
-    prompt += `... and ${incomplete.length - 5} more
+      output += `\u{1F4C4} \`${r.file}\`${r.line ? `:${r.line}` : ""}
 `;
-  }
-  if (pendingCount >= 2) {
-    prompt += `
-\u26A1 **PARALLEL DISPATCH REQUIRED** \u26A1
-You have ${pendingCount} pending tasks. Launch them ALL IN PARALLEL for maximum efficiency:
+      output += `\u{1F517} [View on GitHub](${r.url})
 
-\`\`\`
-// EXECUTE NOW - Launch all ${pendingCount} tasks simultaneously:
 `;
-    for (const todo of pendingTasks.slice(0, 6)) {
-      prompt += `delegate_task({ agent: "Worker", prompt: "${todo.content}", background: true })
+      if (r.content && r.content !== "(Use webfetch for full content)") {
+        output += `\`\`\`
+${r.content}
+\`\`\`
+
 `;
+      }
     }
-    prompt += `\`\`\`
-
-\u26A0\uFE0F Do NOT run these sequentially. Use background=true for ALL.
-After launching, use list_tasks to monitor progress.
+    output += `---
 
 `;
-  } else {
-    prompt += `
-**Action Required**:
-1. Continue working on incomplete todos
-2. Mark each task complete when finished
-3. Do NOT stop until all todos are completed or cancelled
+    output += `\u{1F4A1} **Tip**: Use \`webfetch\` to get the full file content from any of these URLs.`;
+    return output;
+  }
+});
 
-`;
+// 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();
   }
-  if (next) {
-    prompt += `**Next Task**: [${next.id}] ${next.content}
-`;
+  progressHistory.set(sessionId, history);
+  return snapshot;
+}
+function getLatest(sessionId) {
+  const history = progressHistory.get(sessionId);
+  return history?.[history.length - 1];
+}
+function clearSession(sessionId) {
+  progressHistory.delete(sessionId);
+  sessionStartTimes.delete(sessionId);
+}
+
+// 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`;
   }
-  prompt += `</todo_continuation>`;
-  return prompt;
+}
+function formatCompact(snapshot) {
+  const parts = [];
+  if (snapshot.todos.total > 0) {
+    parts.push(`\u2705${snapshot.todos.completed}/${snapshot.todos.total}`);
+  }
+  if (snapshot.tasks.running > 0) {
+    parts.push(`\u26A1${snapshot.tasks.running}`);
+  }
+  parts.push(`\u23F1${formatElapsed(snapshot.elapsedMs)}`);
+  return parts.join(" | ");
+}
+
+// src/core/progress/tracker.ts
+function formatCompact2(sessionId) {
+  const snapshot = getLatest(sessionId);
+  if (!snapshot) return "...";
+  return formatCompact(snapshot);
 }
 
 // src/shared/error-patterns.ts
@@ -16417,7 +16268,7 @@ function detectErrorType(error45) {
 // src/core/recovery/constants.ts
 var MAX_RETRIES = 3;
 var BASE_DELAY = 1e3;
-var MAX_HISTORY2 = 100;
+var MAX_HISTORY3 = 100;
 
 // src/core/recovery/patterns.ts
 var errorPatterns = [
@@ -16502,7 +16353,7 @@ function handleError(context) {
         action,
         timestamp: /* @__PURE__ */ new Date()
       });
-      if (recoveryHistory.length > MAX_HISTORY2) {
+      if (recoveryHistory.length > MAX_HISTORY3) {
         recoveryHistory.shift();
       }
       return action;
@@ -16632,19 +16483,119 @@ async function handleSessionError(client, sessionID, error45, properties) {
     state2.isRecovering = false;
     return false;
   }
-}
-function markRecoveryComplete(sessionID) {
-  const state2 = recoveryState.get(sessionID);
-  if (state2) {
-    state2.isRecovering = false;
-    state2.errorCount = 0;
+}
+function markRecoveryComplete(sessionID) {
+  const state2 = recoveryState.get(sessionID);
+  if (state2) {
+    state2.isRecovering = false;
+    state2.errorCount = 0;
+  }
+}
+function cleanupSessionRecovery(sessionID) {
+  recoveryState.delete(sessionID);
+}
+function isSessionRecovering(sessionID) {
+  return recoveryState.get(sessionID)?.isRecovering ?? false;
+}
+
+// src/core/loop/stats.ts
+function getIncompleteCount(todos) {
+  return todos.filter(
+    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
+  ).length;
+}
+function hasRemainingWork(todos) {
+  return getIncompleteCount(todos) > 0;
+}
+function getNextPending(todos) {
+  const pending = todos.filter(
+    (t) => t.status === TODO_STATUS.PENDING || t.status === TODO_STATUS.IN_PROGRESS
+  );
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  pending.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return pending[0];
+}
+function getStats(todos) {
+  const stats2 = {
+    total: todos.length,
+    pending: todos.filter((t) => t.status === TODO_STATUS.PENDING).length,
+    inProgress: todos.filter((t) => t.status === TODO_STATUS.IN_PROGRESS).length,
+    completed: todos.filter((t) => t.status === TODO_STATUS.COMPLETED).length,
+    cancelled: todos.filter((t) => t.status === TODO_STATUS.CANCELLED).length,
+    percentComplete: 0
+  };
+  if (stats2.total > 0) {
+    stats2.percentComplete = Math.round(
+      (stats2.completed + stats2.cancelled) / stats2.total * 100
+    );
+  }
+  return stats2;
+}
+
+// src/core/loop/formatters.ts
+function formatProgress(todos) {
+  const stats2 = getStats(todos);
+  const done = stats2.completed + stats2.cancelled;
+  return `${done}/${stats2.total} (${stats2.percentComplete}%)`;
+}
+function generateContinuationPrompt(todos) {
+  const incomplete = todos.filter(
+    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
+  );
+  if (incomplete.length === 0) {
+    return "";
+  }
+  const next = getNextPending(todos);
+  const pendingTasks = incomplete.filter((t) => t.status === TODO_STATUS.PENDING);
+  const pendingCount = pendingTasks.length;
+  let prompt = `<todo_continuation>
+\u{1F4CB} **TODO Progress**: ${formatProgress(todos)}
+
+**Incomplete Tasks** (${incomplete.length} remaining):
+`;
+  for (const todo of incomplete.slice(0, 5)) {
+    const status = todo.status === TODO_STATUS.IN_PROGRESS ? "\u{1F504}" : "\u23F3";
+    const priority = todo.priority === "high" ? "\u{1F534}" : todo.priority === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+    prompt += `${status} ${priority} [${todo.id}] ${todo.content}
+`;
+  }
+  if (incomplete.length > 5) {
+    prompt += `... and ${incomplete.length - 5} more
+`;
+  }
+  if (pendingCount >= 2) {
+    prompt += `
+\u26A1 **PARALLEL DISPATCH REQUIRED** \u26A1
+You have ${pendingCount} pending tasks. Launch them ALL IN PARALLEL for maximum efficiency:
+
+\`\`\`
+// EXECUTE NOW - Launch all ${pendingCount} tasks simultaneously:
+`;
+    for (const todo of pendingTasks.slice(0, 6)) {
+      prompt += `delegate_task({ agent: "Worker", prompt: "${todo.content}", background: true })
+`;
+    }
+    prompt += `\`\`\`
+
+\u26A0\uFE0F Do NOT run these sequentially. Use background=true for ALL.
+After launching, use list_tasks to monitor progress.
+
+`;
+  } else {
+    prompt += `
+**Action Required**:
+1. Continue working on incomplete todos
+2. Mark each task complete when finished
+3. Do NOT stop until all todos are completed or cancelled
+
+`;
+  }
+  if (next) {
+    prompt += `**Next Task**: [${next.id}] ${next.content}
+`;
   }
-}
-function cleanupSessionRecovery(sessionID) {
-  recoveryState.delete(sessionID);
-}
-function isSessionRecovering(sessionID) {
-  return recoveryState.get(sessionID)?.isRecovering ?? false;
+  prompt += `</todo_continuation>`;
+  return prompt;
 }
 
 // src/core/loop/todo-continuation.ts
@@ -16652,6 +16603,8 @@ var sessionStates = /* @__PURE__ */ new Map();
 var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 1500;
 var MIN_TIME_BETWEEN_CONTINUATIONS_MS = 3e3;
+var COUNTDOWN_GRACE_PERIOD_MS = 500;
+var ABORT_WINDOW_MS = 3e3;
 function getState2(sessionID) {
   let state2 = sessionStates.get(sessionID);
   if (!state2) {
@@ -16757,6 +16710,15 @@ async function handleSessionIdle(client, sessionID, mainSessionID) {
     log2("[todo-continuation] Skipped: in recovery mode", { sessionID });
     return;
   }
+  if (state2.abortDetectedAt) {
+    const timeSinceAbort = Date.now() - state2.abortDetectedAt;
+    if (timeSinceAbort < ABORT_WINDOW_MS) {
+      log2("[todo-continuation] Skipped: abort detected recently", { sessionID, timeSinceAbort });
+      state2.abortDetectedAt = void 0;
+      return;
+    }
+    state2.abortDetectedAt = void 0;
+  }
   if (hasRunningBackgroundTasks(sessionID)) {
     log2("[todo-continuation] Skipped: background tasks running", { sessionID });
     return;
@@ -16799,11 +16761,28 @@ async function handleSessionIdle(client, sessionID, mainSessionID) {
 }
 function handleUserMessage(sessionID) {
   const state2 = getState2(sessionID);
+  if (state2.countdownStartedAt) {
+    const elapsed = Date.now() - state2.countdownStartedAt;
+    if (elapsed < COUNTDOWN_GRACE_PERIOD_MS) {
+      log2("[todo-continuation] Ignoring message in grace period", { sessionID, elapsed });
+      return;
+    }
+  }
   if (state2.countdownTimer) {
     log2("[todo-continuation] Cancelled: user interaction", { sessionID });
     cancelCountdown(sessionID);
   }
   state2.isAborting = false;
+  state2.abortDetectedAt = void 0;
+}
+function handleSessionError2(sessionID, error45) {
+  const state2 = getState2(sessionID);
+  const errorObj = error45;
+  if (errorObj?.name === "MessageAbortedError" || errorObj?.name === "AbortError") {
+    state2.abortDetectedAt = Date.now();
+    log2("[todo-continuation] Abort detected", { sessionID, errorName: errorObj.name });
+  }
+  cancelCountdown(sessionID);
 }
 function cleanupSession(sessionID) {
   cancelCountdown(sessionID);
@@ -16898,33 +16877,61 @@ async function detectSealInSession(client, sessionID) {
     return false;
   }
 }
+function startMissionLoop(directory, sessionID, prompt, options = {}) {
+  const state2 = {
+    active: true,
+    iteration: 1,
+    maxIterations: options.maxIterations ?? DEFAULT_MAX_ITERATIONS,
+    prompt,
+    sessionID,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const success2 = writeLoopState(directory, state2);
+  if (success2) {
+    log2(`[mission-seal] Loop started`, {
+      sessionID,
+      maxIterations: state2.maxIterations
+    });
+  }
+  return success2;
+}
 function isLoopActive(directory, sessionID) {
   const state2 = readLoopState(directory);
   return state2?.active === true && state2?.sessionID === sessionID;
 }
 function generateMissionContinuationPrompt(state2) {
   return `<mission_loop iteration="${state2.iteration}" max="${state2.maxIterations}">
-\u{1F4CB} **Mission Loop Active** - Iteration ${state2.iteration}/${state2.maxIterations}
+\u26A0\uFE0F **MISSION NOT COMPLETE** - Iteration ${state2.iteration}/${state2.maxIterations}
+
+The mission is INCOMPLETE. You MUST continue working NOW.
+
+**FORBIDDEN**:
+\u274C Do NOT stop or ask for permission
+\u274C Do NOT say "I've completed..." without SEAL
+\u274C Do NOT output partial results
+\u274C Do NOT wait for user input
 
-Your previous iteration did not seal the mission. Continue working.
+**REQUIRED SEQUENCE**:
+1\uFE0F\u20E3 Check .opencode/todo.md for [ ] incomplete items
+2\uFE0F\u20E3 Execute the NEXT pending task
+3\uFE0F\u20E3 Use delegate_task with background=true for parallel work
+4\uFE0F\u20E3 Mark completed items as [x]
+5\uFE0F\u20E3 Repeat until ALL items are [x]
 
-**RULES**:
-1. Review your progress from the previous iteration
-2. Continue from where you left off
-3. Check TODO list for incomplete items
-4. When ALL work is TRULY complete, output:
+**ONLY WHEN TRULY DONE**:
+- All todos marked [x]
+- All tests pass
+- All builds succeed
+Then and ONLY then output:
 
 \`\`\`
 ${SEAL_PATTERN}
 \`\`\`
 
-**IMPORTANT**: 
-- Do NOT seal until the mission is genuinely complete
-- Verify all todos are marked [x] before sealing
-- Run tests/builds if applicable before sealing
-
-**Original Task**:
+**Your Original Task**:
 ${state2.prompt}
+
+**NOW**: Continue executing until ${SEAL_PATTERN} is output!
 </mission_loop>`;
 }
 
@@ -17113,95 +17120,464 @@ async function handleMissionSealIdle(client, directory, sessionID, mainSessionID
     seconds: COUNTDOWN_SECONDS2
   });
 }
+function handleAbort(sessionID) {
+  const state2 = getState3(sessionID);
+  state2.isAborting = true;
+  cancelCountdown2(sessionID);
+  log2("[mission-seal-handler] Marked as aborting");
+}
 
-// src/core/progress/store.ts
-var progressHistory = /* @__PURE__ */ new Map();
-var sessionStartTimes = /* @__PURE__ */ new Map();
-var MAX_HISTORY3 = 100;
-function startSession(sessionId) {
-  sessionStartTimes.set(sessionId, /* @__PURE__ */ new Date());
-  progressHistory.set(sessionId, []);
+// src/plugin-handlers/event-handler.ts
+function createEventHandler(ctx) {
+  const { client, directory, sessions, state: state2 } = ctx;
+  return async (input) => {
+    const { event } = input;
+    try {
+      const manager = ParallelAgentManager.getInstance();
+      manager.handleEvent(event);
+    } catch {
+    }
+    if (event.type === "session.created") {
+      const sessionID = event.properties?.id || "";
+      log2("[event-handler] session.created", { sessionID });
+      presets.missionStarted(`Session ${sessionID.slice(0, 12)}...`);
+    }
+    if (event.type === "session.deleted") {
+      const sessionID = event.properties?.id || event.properties?.info?.id || "";
+      const session = sessions.get(sessionID);
+      if (session) {
+        const totalTime = Date.now() - session.startTime;
+        const duration3 = totalTime < 6e4 ? `${Math.round(totalTime / 1e3)}s` : `${Math.round(totalTime / 6e4)}m`;
+        log2("[event-handler] session.deleted", {
+          sessionID,
+          steps: session.step,
+          duration: duration3
+        });
+        sessions.delete(sessionID);
+        state2.sessions.delete(sessionID);
+        clearSession(sessionID);
+        cleanupSessionRecovery(sessionID);
+        cleanupSession(sessionID);
+        presets.sessionCompleted(sessionID, duration3);
+      }
+    }
+    if (event.type === "session.error") {
+      const sessionID = event.properties?.sessionId || event.properties?.sessionID || "";
+      const error45 = event.properties?.error;
+      log2("[event-handler] session.error", { sessionID, error: error45 });
+      if (sessionID) {
+        handleSessionError2(sessionID, error45);
+        handleAbort(sessionID);
+      }
+      if (sessionID && error45) {
+        const recovered = await handleSessionError(
+          client,
+          sessionID,
+          error45,
+          event.properties
+        );
+        if (recovered) {
+          log2("[event-handler] auto-recovery initiated", { sessionID });
+          return;
+        }
+      }
+      presets.taskFailed("session", String(error45).slice(0, 50));
+    }
+    if (event.type === "message.updated") {
+      const messageInfo = event.properties?.info;
+      const sessionID = messageInfo?.sessionID;
+      const role = messageInfo?.role;
+      if (sessionID && role === "assistant") {
+        markRecoveryComplete(sessionID);
+      }
+    }
+    if (event.type === "session.idle") {
+      const sessionID = event.properties?.sessionID || "";
+      if (sessionID) {
+        const isMainSession = sessions.has(sessionID);
+        if (isMainSession) {
+          setTimeout(async () => {
+            const session = sessions.get(sessionID);
+            if (session?.active) {
+              if (isLoopActive(directory, sessionID)) {
+                await handleMissionSealIdle(
+                  client,
+                  directory,
+                  sessionID,
+                  sessionID
+                ).catch((err) => {
+                  log2("[event-handler] mission-seal-handler error", err);
+                });
+              } else {
+                await handleSessionIdle(
+                  client,
+                  sessionID,
+                  sessionID
+                ).catch((err) => {
+                  log2("[event-handler] todo-continuation error", err);
+                });
+              }
+            }
+          }, 500);
+        }
+      }
+    }
+  };
 }
-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()
+
+// src/plugin-handlers/config-handler.ts
+function createConfigHandler() {
+  const commanderPrompt = AGENTS[AGENT_NAMES.COMMANDER]?.systemPrompt || "";
+  return async (config2) => {
+    const existingCommands = config2.command ?? {};
+    const existingAgents = config2.agent ?? {};
+    const orchestratorCommands = {};
+    for (const [name, cmd] of Object.entries(COMMANDS)) {
+      orchestratorCommands[name] = {
+        description: cmd.description,
+        template: cmd.template,
+        argumentHint: cmd.argumentHint
+      };
+    }
+    const orchestratorAgents = {
+      // Primary agent - the main orchestrator
+      [AGENT_NAMES.COMMANDER]: {
+        description: "Autonomous orchestrator - executes until mission complete",
+        mode: "primary",
+        prompt: commanderPrompt,
+        maxTokens: 64e3,
+        thinking: { type: "enabled", budgetTokens: 32e3 },
+        color: "#FF6B6B"
+      },
+      // Consolidated subagents (4 agents instead of 6)
+      [AGENT_NAMES.PLANNER]: {
+        description: "Strategic planning and research specialist",
+        mode: "subagent",
+        hidden: true,
+        prompt: AGENTS[AGENT_NAMES.PLANNER]?.systemPrompt || "",
+        maxTokens: 32e3,
+        color: "#9B59B6"
+      },
+      [AGENT_NAMES.WORKER]: {
+        description: "Implementation and documentation specialist",
+        mode: "subagent",
+        hidden: true,
+        prompt: AGENTS[AGENT_NAMES.WORKER]?.systemPrompt || "",
+        maxTokens: 32e3,
+        color: "#E67E22"
+      },
+      [AGENT_NAMES.REVIEWER]: {
+        description: "Verification and context management specialist",
+        mode: "subagent",
+        hidden: true,
+        prompt: AGENTS[AGENT_NAMES.REVIEWER]?.systemPrompt || "",
+        maxTokens: 32e3,
+        color: "#27AE60"
+      }
+    };
+    const processedExistingAgents = { ...existingAgents };
+    if (processedExistingAgents.build) {
+      processedExistingAgents.build = {
+        ...processedExistingAgents.build,
+        mode: "subagent",
+        hidden: true
+      };
+    }
+    if (processedExistingAgents.plan) {
+      processedExistingAgents.plan = {
+        ...processedExistingAgents.plan,
+        mode: "subagent"
+      };
+    }
+    config2.command = { ...existingCommands, ...orchestratorCommands };
+    config2.agent = { ...processedExistingAgents, ...orchestratorAgents };
+    config2.default_agent = AGENT_NAMES.COMMANDER;
+    console.log(`[orchestrator] Registered agents: ${Object.keys(orchestratorAgents).join(", ")}`);
+    console.log(`[orchestrator] Default agent: ${AGENT_NAMES.COMMANDER}`);
   };
-  const history = progressHistory.get(sessionId) || [];
-  history.push(snapshot);
-  if (history.length > MAX_HISTORY3) {
-    history.shift();
-  }
-  progressHistory.set(sessionId, history);
-  return snapshot;
 }
-function getLatest(sessionId) {
-  const history = progressHistory.get(sessionId);
-  return history?.[history.length - 1];
+
+// 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 clearSession(sessionId) {
-  progressHistory.delete(sessionId);
-  sessionStartTimes.delete(sessionId);
+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/plugin-handlers/chat-message-handler.ts
+function createChatMessageHandler(ctx) {
+  const { directory, sessions } = ctx;
+  return async (msgInput, msgOutput) => {
+    const parts = msgOutput.parts;
+    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();
+    log2("[chat-message-handler] hook triggered", { sessionID, agent: agentName, textLength: originalText.length });
+    if (sessionID) {
+      handleUserMessage(sessionID);
+    }
+    if (agentName === AGENT_NAMES.COMMANDER) {
+      if (!sessions.has(sessionID)) {
+        const now = Date.now();
+        sessions.set(sessionID, {
+          active: true,
+          step: 0,
+          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);
+        presets.taskStarted(sessionID, AGENT_NAMES.COMMANDER);
+      }
+      if (!parsed || parsed.command !== "task") {
+        const taskTemplate = COMMANDS["task"].template;
+        const userMessage = parsed?.args || originalText;
+        parts[textPartIndex].text = taskTemplate.replace(
+          /\$ARGUMENTS/g,
+          userMessage || PROMPTS.CONTINUE
+        );
+        startMissionLoop(directory, sessionID, userMessage || originalText);
+        log2("[chat-message-handler] Auto-applied mission mode + started loop", { originalLength: originalText.length });
+      }
+    }
+    if (parsed) {
+      const command = COMMANDS[parsed.command];
+      if (command && agentName !== AGENT_NAMES.COMMANDER) {
+        parts[textPartIndex].text = command.template.replace(
+          /\$ARGUMENTS/g,
+          parsed.args || PROMPTS.CONTINUE
+        );
+      } else if (command && parsed.command === "task") {
+        parts[textPartIndex].text = command.template.replace(
+          /\$ARGUMENTS/g,
+          parsed.args || PROMPTS.CONTINUE
+        );
+        startMissionLoop(directory, sessionID, parsed.args || "continue from where we left off");
+        log2("[chat-message-handler] /task command: started mission loop", { sessionID, args: parsed.args?.slice(0, 50) });
+      }
+    }
+  };
+}
+
+// src/utils/sanity.ts
+var SEVERITY = {
+  OK: "ok",
+  WARNING: "warning",
+  CRITICAL: "critical"
+};
+function checkOutputSanity(text) {
+  if (!text || text.length < 50) {
+    return { isHealthy: true, severity: SEVERITY.OK };
+  }
+  if (/(.)\1{15,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Single character repetition detected",
+      severity: SEVERITY.CRITICAL
+    };
+  }
+  if (/(.{2,6})\1{8,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Pattern loop detected",
+      severity: 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: 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: 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: 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: SEVERITY.CRITICAL
+      };
+    }
+  }
+  return { isHealthy: true, severity: 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 Reviewer 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 Planner for a completely new strategy
+4. If Planner also fails: report status to user and await guidance
+</emergency_protocol>
 
-// 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`;
-  }
-}
-function formatCompact(snapshot) {
-  const parts = [];
-  if (snapshot.todos.total > 0) {
-    parts.push(`\u2705${snapshot.todos.completed}/${snapshot.todos.total}`);
-  }
-  if (snapshot.tasks.running > 0) {
-    parts.push(`\u26A1${snapshot.tasks.running}`);
-  }
-  parts.push(`\u23F1${formatElapsed(snapshot.elapsedMs)}`);
-  return parts.join(" | ");
-}
+<diagnosis>
+The current approach is producing corrupted output.
+This may indicate: context overload, model instability, or task complexity.
+</diagnosis>
 
-// src/core/progress/tracker.ts
-function formatCompact2(sessionId) {
-  const snapshot = getLatest(sessionId);
-  if (!snapshot) return "...";
-  return formatCompact(snapshot);
+Request a fresh plan from Planner with reduced scope.
+</critical_anomaly>`;
+
+// src/plugin-handlers/tool-execute-handler.ts
+function createToolExecuteAfterHandler(ctx) {
+  const { sessions } = ctx;
+  return async (toolInput, toolOutput) => {
+    const session = sessions.get(toolInput.sessionID);
+    if (!session?.active) return;
+    const now = Date.now();
+    const stepDuration = formatElapsedTime(session.lastStepTime, now);
+    const totalElapsed = formatElapsedTime(session.startTime, now);
+    session.step++;
+    session.timestamp = now;
+    session.lastStepTime = now;
+    const stateSession = state.sessions.get(toolInput.sessionID);
+    if (toolInput.tool === TOOL_NAMES.CALL_AGENT && stateSession) {
+      const sanityResult = checkOutputSanity(toolOutput.output);
+      if (!sanityResult.isHealthy) {
+        stateSession.anomalyCount = (stateSession.anomalyCount || 0) + 1;
+        const agentName = toolInput.arguments?.agent || "unknown";
+        toolOutput.output = `\u26A0\uFE0F [${agentName.toUpperCase()}] OUTPUT ANOMALY DETECTED
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F Gibberish/loop detected: ${sanityResult.reason}
+Anomaly count: ${stateSession.anomalyCount}
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+` + (stateSession.anomalyCount >= 2 ? ESCALATION_PROMPT : RECOVERY_PROMPT);
+        return;
+      } else {
+        if (stateSession.anomalyCount > 0) {
+          stateSession.anomalyCount = 0;
+        }
+        if (toolOutput.output.length < 5e3) {
+          stateSession.lastHealthyOutput = toolOutput.output.substring(0, 1e3);
+        }
+      }
+    }
+    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();
+      }
+      const agentName = toolInput.arguments.agent;
+      const emoji3 = AGENT_EMOJI[agentName] || "\u{1F916}";
+      toolOutput.output = `${emoji3} [${agentName.toUpperCase()}] Working...
+
+` + toolOutput.output;
+    }
+    if (stateSession) {
+      const taskId = stateSession.currentTask;
+      if (toolOutput.output.includes("\u2705 PASS") || toolOutput.output.includes("AUDIT RESULT: PASS")) {
+        if (taskId) {
+          stateSession.taskRetries.clear();
+          toolOutput.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u2705 ${taskId} VERIFIED`;
+        }
+      } else if (toolOutput.output.includes("\u274C FAIL") || toolOutput.output.includes("AUDIT RESULT: FAIL")) {
+        if (taskId) {
+          const retries = (stateSession.taskRetries.get(taskId) || 0) + 1;
+          stateSession.taskRetries.set(taskId, retries);
+          if (retries >= state.maxRetries) {
+            toolOutput.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F ${taskId} FAILED (${retries}x)`;
+          } else {
+            toolOutput.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u{1F504} RETRY ${retries}/${state.maxRetries}`;
+          }
+        }
+      }
+    }
+    const currentTime = formatTimestamp();
+    toolOutput.output += `
+
+\u23F1\uFE0F [${currentTime}] Step ${session.step} | This step: ${stepDuration} | Total: ${totalElapsed}`;
+  };
 }
 
-// src/index.ts
-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;
+// src/plugin-handlers/assistant-done-handler.ts
 var CONTINUE_INSTRUCTION = `<auto_continue>
 <status>Mission not complete. Keep executing.</status>
 
@@ -17229,6 +17605,120 @@ You are ONLY done when:
 Then output: ${MISSION_SEAL.PATTERN}
 </completion_criteria>
 </auto_continue>`;
+function createAssistantDoneHandler(ctx) {
+  const { client, directory, sessions } = ctx;
+  return async (assistantInput, assistantOutput) => {
+    const sessionID = assistantInput.sessionID;
+    const session = sessions.get(sessionID);
+    if (!session?.active) return;
+    const parts = assistantOutput.parts;
+    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) {
+      stateSession.anomalyCount = (stateSession.anomalyCount || 0) + 1;
+      session.step++;
+      session.timestamp = Date.now();
+      const recoveryText = stateSession.anomalyCount >= 2 ? ESCALATION_PROMPT : RECOVERY_PROMPT;
+      try {
+        if (client?.session?.prompt) {
+          await client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [{
+                type: PART_TYPES.TEXT,
+                text: `\u26A0\uFE0F ANOMALY #${stateSession.anomalyCount}: ${sanityResult.reason}
+
+` + recoveryText + `
+
+[Recovery Step ${session.step}]`
+              }]
+            }
+          });
+        }
+      } catch {
+        session.active = false;
+        state.missionActive = false;
+      }
+      return;
+    }
+    if (stateSession && stateSession.anomalyCount > 0) {
+      stateSession.anomalyCount = 0;
+    }
+    if (isLoopActive(directory, sessionID) && detectSealInText(textContent)) {
+      session.active = false;
+      state.missionActive = false;
+      clearLoopState(directory);
+      presets.missionComplete("\u{1F396}\uFE0F Mission Sealed - Explicit completion confirmed");
+      log2("[assistant-done-handler] Mission sealed detected", { sessionID });
+      clearSession(sessionID);
+      sessions.delete(sessionID);
+      state.sessions.delete(sessionID);
+      return;
+    }
+    if (textContent.includes(MISSION.STOP_COMMAND) || textContent.includes(MISSION.CANCEL_COMMAND)) {
+      session.active = false;
+      state.missionActive = false;
+      presets.taskFailed(sessionID, "Cancelled by user");
+      clearSession(sessionID);
+      sessions.delete(sessionID);
+      state.sessions.delete(sessionID);
+      return;
+    }
+    const now = Date.now();
+    const stepDuration = formatElapsedTime(session.lastStepTime, now);
+    const totalElapsed = formatElapsedTime(session.startTime, now);
+    session.step++;
+    session.timestamp = now;
+    session.lastStepTime = now;
+    const currentTime = formatTimestamp();
+    recordSnapshot(sessionID, {
+      currentStep: session.step
+    });
+    const progressInfo = formatCompact2(sessionID);
+    try {
+      if (client?.session?.prompt) {
+        await client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{
+              type: PART_TYPES.TEXT,
+              text: CONTINUE_INSTRUCTION + `
+
+\u23F1\uFE0F [${currentTime}] Step ${session.step} | ${progressInfo} | This step: ${stepDuration} | Total: ${totalElapsed}`
+            }]
+          }
+        });
+      }
+    } catch (error45) {
+      log2("[assistant-done-handler] Continuation injection failed, retrying...", { sessionID, error: error45 });
+      try {
+        await new Promise((r) => setTimeout(r, 500));
+        if (client?.session?.prompt) {
+          await client.session.prompt({
+            path: { id: sessionID },
+            body: { parts: [{ type: PART_TYPES.TEXT, text: PROMPTS.CONTINUE }] }
+          });
+        }
+      } catch (retryError) {
+        log2("[assistant-done-handler] Both continuation attempts failed, waiting for idle handler", {
+          sessionID,
+          error: retryError,
+          loopActive: isLoopActive(directory, sessionID)
+        });
+        if (!isLoopActive(directory, sessionID)) {
+          log2("[assistant-done-handler] No active loop, stopping session", { sessionID });
+          session.active = false;
+          state.missionActive = false;
+        }
+      }
+    }
+  };
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version: PLUGIN_VERSION } = require2("../package.json");
 var OrchestratorPlugin = async (input) => {
   const { directory, client } = input;
   console.log(`[orchestrator] v${PLUGIN_VERSION} loaded`);
@@ -17242,6 +17732,12 @@ var OrchestratorPlugin = async (input) => {
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
   taskToastManager.setConcurrencyController(parallelAgentManager2.getConcurrency());
   log2("[index.ts] ParallelAgentManager initialized with TaskToastManager integration");
+  const handlerContext = {
+    client,
+    directory,
+    sessions,
+    state
+  };
   return {
     // -----------------------------------------------------------------
     // Tools we expose to the LLM
@@ -17252,443 +17748,39 @@ var OrchestratorPlugin = async (input) => {
       [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
+      // Background task tools
       [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
+      // Web tools
       [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
+      // Async agent tools
       ...asyncAgentTools
     },
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode
     // -----------------------------------------------------------------
-    config: async (config2) => {
-      const existingCommands = config2.command ?? {};
-      const existingAgents = config2.agent ?? {};
-      const orchestratorCommands = {};
-      for (const [name, cmd] of Object.entries(COMMANDS)) {
-        orchestratorCommands[name] = {
-          description: cmd.description,
-          template: cmd.template,
-          argumentHint: cmd.argumentHint
-        };
-      }
-      const commanderPrompt = AGENTS[AGENT_NAMES.COMMANDER]?.systemPrompt || "";
-      console.log(`[orchestrator] Commander prompt length: ${commanderPrompt.length} chars`);
-      const orchestratorAgents = {
-        // Primary agent - the main orchestrator
-        [AGENT_NAMES.COMMANDER]: {
-          description: "Autonomous orchestrator - executes until mission complete",
-          mode: "primary",
-          prompt: commanderPrompt,
-          maxTokens: 64e3,
-          thinking: { type: "enabled", budgetTokens: 32e3 },
-          color: "#FF6B6B"
-        },
-        // Consolidated subagents (4 agents instead of 6)
-        [AGENT_NAMES.PLANNER]: {
-          description: "Strategic planning and research specialist",
-          mode: "subagent",
-          hidden: true,
-          prompt: AGENTS[AGENT_NAMES.PLANNER]?.systemPrompt || "",
-          maxTokens: 32e3,
-          color: "#9B59B6"
-        },
-        [AGENT_NAMES.WORKER]: {
-          description: "Implementation and documentation specialist",
-          mode: "subagent",
-          hidden: true,
-          prompt: AGENTS[AGENT_NAMES.WORKER]?.systemPrompt || "",
-          maxTokens: 32e3,
-          color: "#E67E22"
-        },
-        [AGENT_NAMES.REVIEWER]: {
-          description: "Verification and context management specialist",
-          mode: "subagent",
-          hidden: true,
-          prompt: AGENTS[AGENT_NAMES.REVIEWER]?.systemPrompt || "",
-          maxTokens: 32e3,
-          color: "#27AE60"
-        }
-      };
-      const processedExistingAgents = { ...existingAgents };
-      if (processedExistingAgents.build) {
-        processedExistingAgents.build = {
-          ...processedExistingAgents.build,
-          mode: "subagent",
-          hidden: true
-        };
-      }
-      if (processedExistingAgents.plan) {
-        processedExistingAgents.plan = {
-          ...processedExistingAgents.plan,
-          mode: "subagent"
-        };
-      }
-      config2.command = { ...existingCommands, ...orchestratorCommands };
-      config2.agent = { ...processedExistingAgents, ...orchestratorAgents };
-      config2.default_agent = AGENT_NAMES.COMMANDER;
-      console.log(`[orchestrator] Registered agents: ${Object.keys(orchestratorAgents).join(", ")}`);
-      console.log(`[orchestrator] Default agent: ${AGENT_NAMES.COMMANDER}`);
-    },
+    config: createConfigHandler(),
     // -----------------------------------------------------------------
-    // Event hook - handles OpenCode events (SDK official)
-    // Replaces non-standard session.start/session.end hooks
+    // Event hook - handles OpenCode events
     // -----------------------------------------------------------------
-    event: async (input2) => {
-      const { event } = input2;
-      try {
-        const manager = ParallelAgentManager.getInstance();
-        manager.handleEvent(event);
-      } catch {
-      }
-      if (event.type === "session.created") {
-        const sessionID = event.properties?.id || "";
-        log2("[index.ts] event: session.created", { sessionID });
-        presets.missionStarted(`Session ${sessionID.slice(0, 12)}...`);
-      }
-      if (event.type === "session.deleted") {
-        const sessionID = event.properties?.id || event.properties?.info?.id || "";
-        const session = sessions.get(sessionID);
-        if (session) {
-          const totalTime = Date.now() - session.startTime;
-          const duration3 = totalTime < 6e4 ? `${Math.round(totalTime / 1e3)}s` : `${Math.round(totalTime / 6e4)}m`;
-          log2("[index.ts] event: session.deleted", {
-            sessionID,
-            steps: session.step,
-            duration: duration3
-          });
-          sessions.delete(sessionID);
-          state.sessions.delete(sessionID);
-          clearSession(sessionID);
-          cleanupSessionRecovery(sessionID);
-          cleanupSession(sessionID);
-          presets.sessionCompleted(sessionID, duration3);
-        }
-      }
-      if (event.type === "session.error") {
-        const sessionID = event.properties?.sessionId || event.properties?.sessionID || "";
-        const error45 = event.properties?.error;
-        log2("[index.ts] event: session.error", { sessionID, error: error45 });
-        if (sessionID && error45) {
-          const recovered = await handleSessionError(
-            client,
-            sessionID,
-            error45,
-            event.properties
-          );
-          if (recovered) {
-            log2("[index.ts] session.error: auto-recovery initiated", { sessionID });
-            return;
-          }
-        }
-        presets.taskFailed("session", String(error45).slice(0, 50));
-      }
-      if (event.type === "message.updated") {
-        const messageInfo = event.properties?.info;
-        const sessionID = messageInfo?.sessionID;
-        const role = messageInfo?.role;
-        if (sessionID && role === "assistant") {
-          markRecoveryComplete(sessionID);
-        }
-      }
-      if (event.type === "session.idle") {
-        const sessionID = event.properties?.sessionID || "";
-        if (sessionID) {
-          const isMainSession = sessions.has(sessionID);
-          if (isMainSession) {
-            setTimeout(async () => {
-              const session = sessions.get(sessionID);
-              if (session?.active) {
-                if (isLoopActive(directory, sessionID)) {
-                  await handleMissionSealIdle(
-                    client,
-                    directory,
-                    sessionID,
-                    sessionID
-                  ).catch((err) => {
-                    log2("[index.ts] mission-seal-handler error", err);
-                  });
-                } else {
-                  await handleSessionIdle(
-                    client,
-                    sessionID,
-                    sessionID
-                  ).catch((err) => {
-                    log2("[index.ts] todo-continuation error", err);
-                  });
-                }
-              }
-            }, 500);
-          }
-        }
-      }
-    },
+    event: createEventHandler(handlerContext),
     // -----------------------------------------------------------------
-    // chat.message hook - runs when user sends a message
-    // This is where we intercept commands and set up sessions
+    // chat.message hook - intercepts commands and sets up sessions
     // -----------------------------------------------------------------
-    "chat.message": async (msgInput, msgOutput) => {
-      const parts = msgOutput.parts;
-      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();
-      log2("[index.ts] chat.message hook", { sessionID, agent: agentName, textLength: originalText.length });
-      if (sessionID) {
-        handleUserMessage(sessionID);
-      }
-      if (agentName === AGENT_NAMES.COMMANDER) {
-        if (!sessions.has(sessionID)) {
-          const now = Date.now();
-          sessions.set(sessionID, {
-            active: true,
-            step: 0,
-            maxSteps: DEFAULT_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);
-          presets.taskStarted(sessionID, AGENT_NAMES.COMMANDER);
-        }
-        if (!parsed || parsed.command !== "task") {
-          const taskTemplate = COMMANDS["task"].template;
-          const userMessage = parsed?.args || originalText;
-          parts[textPartIndex].text = taskTemplate.replace(
-            /\$ARGUMENTS/g,
-            userMessage || PROMPTS.CONTINUE
-          );
-          log2("[index.ts] Auto-applied mission mode", { originalLength: originalText.length });
-        }
-      }
-      if (parsed) {
-        const command = COMMANDS[parsed.command];
-        if (command && agentName !== AGENT_NAMES.COMMANDER) {
-          parts[textPartIndex].text = command.template.replace(
-            /\$ARGUMENTS/g,
-            parsed.args || PROMPTS.CONTINUE
-          );
-        } else if (command && parsed.command === "task") {
-          parts[textPartIndex].text = command.template.replace(
-            /\$ARGUMENTS/g,
-            parsed.args || PROMPTS.CONTINUE
-          );
-        }
-      }
-    },
+    "chat.message": createChatMessageHandler(handlerContext),
     // -----------------------------------------------------------------
     // tool.execute.after hook - runs after any tool call completes
-    // We use this to track progress and detect problems
     // -----------------------------------------------------------------
-    "tool.execute.after": async (toolInput, toolOutput) => {
-      const session = sessions.get(toolInput.sessionID);
-      if (!session?.active) return;
-      const now = Date.now();
-      const stepDuration = formatElapsedTime(session.lastStepTime, now);
-      const totalElapsed = formatElapsedTime(session.startTime, now);
-      session.step++;
-      session.timestamp = now;
-      session.lastStepTime = now;
-      const stateSession = state.sessions.get(toolInput.sessionID);
-      if (toolInput.tool === TOOL_NAMES.CALL_AGENT && stateSession) {
-        const sanityResult = checkOutputSanity(toolOutput.output);
-        if (!sanityResult.isHealthy) {
-          stateSession.anomalyCount = (stateSession.anomalyCount || 0) + 1;
-          const agentName = toolInput.arguments?.agent || "unknown";
-          toolOutput.output = `\u26A0\uFE0F [${agentName.toUpperCase()}] OUTPUT ANOMALY DETECTED
-
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\u26A0\uFE0F Gibberish/loop detected: ${sanityResult.reason}
-Anomaly count: ${stateSession.anomalyCount}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-
-` + (stateSession.anomalyCount >= 2 ? ESCALATION_PROMPT : RECOVERY_PROMPT);
-          return;
-        } else {
-          if (stateSession.anomalyCount > 0) {
-            stateSession.anomalyCount = 0;
-          }
-          if (toolOutput.output.length < 5e3) {
-            stateSession.lastHealthyOutput = toolOutput.output.substring(0, 1e3);
-          }
-        }
-      }
-      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();
-        }
-        const agentName = toolInput.arguments.agent;
-        const emoji3 = AGENT_EMOJI[agentName] || "\u{1F916}";
-        toolOutput.output = `${emoji3} [${agentName.toUpperCase()}] Working...
-
-` + toolOutput.output;
-      }
-      if (session.step >= session.maxSteps) {
-        session.active = false;
-        state.missionActive = false;
-        return;
-      }
-      if (stateSession) {
-        const taskId = stateSession.currentTask;
-        if (toolOutput.output.includes("\u2705 PASS") || toolOutput.output.includes("AUDIT RESULT: PASS")) {
-          if (taskId) {
-            stateSession.taskRetries.clear();
-            toolOutput.output += `
-
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\u2705 ${taskId} VERIFIED`;
-          }
-        } else if (toolOutput.output.includes("\u274C FAIL") || toolOutput.output.includes("AUDIT RESULT: FAIL")) {
-          if (taskId) {
-            const retries = (stateSession.taskRetries.get(taskId) || 0) + 1;
-            stateSession.taskRetries.set(taskId, retries);
-            if (retries >= state.maxRetries) {
-              toolOutput.output += `
-
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\u26A0\uFE0F ${taskId} FAILED (${retries}x)`;
-            } else {
-              toolOutput.output += `
-
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\u{1F504} RETRY ${retries}/${state.maxRetries}`;
-            }
-          }
-        }
-      }
-      const currentTime = formatTimestamp();
-      toolOutput.output += `
-
-\u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | This step: ${stepDuration} | Total: ${totalElapsed}`;
-    },
+    "tool.execute.after": createToolExecuteAfterHandler(handlerContext),
     // -----------------------------------------------------------------
     // assistant.done hook - runs when the LLM finishes responding
-    // This is the heart of the "relentless loop" - we keep pushing it
-    // to continue until we see <mission_seal>SEALED</mission_seal> or hit the limit
     // -----------------------------------------------------------------
-    "assistant.done": async (assistantInput, assistantOutput) => {
-      const sessionID = assistantInput.sessionID;
-      const session = sessions.get(sessionID);
-      if (!session?.active) return;
-      const parts = assistantOutput.parts;
-      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) {
-        stateSession.anomalyCount = (stateSession.anomalyCount || 0) + 1;
-        session.step++;
-        session.timestamp = Date.now();
-        const recoveryText = stateSession.anomalyCount >= 2 ? ESCALATION_PROMPT : RECOVERY_PROMPT;
-        try {
-          if (client?.session?.prompt) {
-            await client.session.prompt({
-              path: { id: sessionID },
-              body: {
-                parts: [{
-                  type: PART_TYPES.TEXT,
-                  text: `\u26A0\uFE0F ANOMALY #${stateSession.anomalyCount}: ${sanityResult.reason}
-
-` + recoveryText + `
-
-[Recovery Step ${session.step}/${session.maxSteps}]`
-                }]
-              }
-            });
-          }
-        } catch {
-          session.active = false;
-          state.missionActive = false;
-        }
-        return;
-      }
-      if (stateSession && stateSession.anomalyCount > 0) {
-        stateSession.anomalyCount = 0;
-      }
-      if (detectSealInText(textContent)) {
-        session.active = false;
-        state.missionActive = false;
-        clearLoopState(directory);
-        presets.missionComplete("\u{1F396}\uFE0F Mission Sealed - Explicit completion confirmed");
-        log2("[index.ts] Mission sealed detected", { sessionID });
-        clearSession(sessionID);
-        sessions.delete(sessionID);
-        state.sessions.delete(sessionID);
-        return;
-      }
-      if (textContent.includes(MISSION.STOP_COMMAND) || textContent.includes(MISSION.CANCEL_COMMAND)) {
-        session.active = false;
-        state.missionActive = false;
-        presets.taskFailed(sessionID, "Cancelled by user");
-        clearSession(sessionID);
-        sessions.delete(sessionID);
-        state.sessions.delete(sessionID);
-        return;
-      }
-      const now = Date.now();
-      const stepDuration = formatElapsedTime(session.lastStepTime, now);
-      const totalElapsed = formatElapsedTime(session.startTime, now);
-      session.step++;
-      session.timestamp = now;
-      session.lastStepTime = now;
-      const currentTime = formatTimestamp();
-      if (session.step >= session.maxSteps) {
-        session.active = false;
-        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: PART_TYPES.TEXT,
-                text: CONTINUE_INSTRUCTION + `
-
-\u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | ${progressInfo} | This step: ${stepDuration} | Total: ${totalElapsed}`
-              }]
-            }
-          });
-        }
-      } catch {
-        try {
-          await new Promise((r) => setTimeout(r, 500));
-          if (client?.session?.prompt) {
-            await client.session.prompt({
-              path: { id: sessionID },
-              body: { parts: [{ type: PART_TYPES.TEXT, text: PROMPTS.CONTINUE }] }
-            });
-          }
-        } catch {
-          session.active = false;
-          state.missionActive = false;
-        }
-      }
-    }
+    "assistant.done": createAssistantDoneHandler(handlerContext)
   };
 };
 var index_default = OrchestratorPlugin;