opencode-orchestrator 0.2.0 → 0.2.3

package/README.md

@@ -11,6 +11,17 @@
 
 ---
 
+## Why I Built This 🤔
+
+**I was frustrated coding with DeepSeek and Z.AI.**
+
+I wanted to achieve the same quality of work as premium models like **Gemini 3 Pro** and **Claude Opus**, but with affordable models.
+For developers who chose **budget-friendly subscriptions** instead of expensive plans, I built a multi-agent system that can **autonomously complete** complex engineering tasks even with mid-tier LLMs.
+
+> *"Intelligence is a resource. Orchestrate it."*
+
+---
+
 ## What is this?
 
 A **5-agent autonomous architecture** designed to solve complex engineering tasks with high reliability, even on mid-range LLMs.
@@ -39,8 +50,14 @@ Restart OpenCode after installation.
 
 ## Usage
 
-### Just Select Commander Agent 🎯
-Press `tab` → Select **Commander** → Type your mission!
+### 🚀 Method 1: Select Commander via Tab Key (Recommended)
+
+In OpenCode, press `Tab` to open the Agent selection menu. Select **Commander** and type your mission!
+
+<div align="center">
+  <img src="assets/commander-screenshot.png" alt="Commander Screenshot" width="600" />
+  <p><em>Press Tab to select Commander</em></p>
+</div>
 
 ```
 "Fix the login bug in the docker-compose environment"
@@ -53,11 +70,15 @@ The Commander will:
 4. **Verify**: Run builds/tests to prove the fix works.
 5. **Complete**: Report results with concrete evidence.
 
-### Or Use /task Command
+### 📋 Method 2: Use /task Command
+
 ```bash
 /task "Implement user authentication with JWT"
 ```
 
+> **💡 Tip:** Using the `/task` command makes Commander mode run **2x longer**.
+> Use `/task` for complex tasks that need extended processing!
+
 ---
 
 ## Agents (5-Agent Architecture)

package/dist/core/state.d.ts

@@ -5,6 +5,8 @@ export interface SessionState {
     taskRetries: Map<string, number>;
     currentTask: string;
     graph?: TaskGraph;
+    anomalyCount: number;
+    lastHealthyOutput?: string;
 }
 export declare const state: {
     missionActive: boolean;

package/dist/index.d.ts

@@ -1,15 +1,14 @@
 /**
  * OpenCode Orchestrator Plugin
  *
- * 5-Agent Structured Architecture
- *
- * Optimized for weak models through:
+ * This is the main entry point for the 5-Agent structured architecture.
+ * We've optimized it for weaker models by using:
  * - XML-structured prompts with clear boundaries
- * - Explicit reasoning patterns (THINK → ACT → OBSERVE → ADJUST)
+ * - Explicit reasoning patterns (THINK -> ACT -> OBSERVE -> ADJUST)
  * - Evidence-based completion requirements
- * - Autonomous execution loop
+ * - Autonomous execution loop that keeps going until done
  *
- * Agents: Commander, Architect, Builder, Inspector, Recorder
+ * The agents are: Commander, Architect, Builder, Inspector, Recorder
  */
 import type { PluginInput } from "@opencode-ai/plugin";
 declare const OrchestratorPlugin: (input: PluginInput) => Promise<{

package/dist/index.js

@@ -17,20 +17,20 @@ var AGENT_NAMES = {
 var orchestrator = {
   id: AGENT_NAMES.COMMANDER,
   description: "Commander - autonomous orchestrator",
-  systemPrompt: `You are Commander. Complete missions autonomously. Never stop until done.
+  systemPrompt: `<role>
+You are Commander. Complete missions autonomously. Never stop until done.
+</role>
 
-CORE RULES:
+<core_rules>
 1. Never stop until "\u2705 MISSION COMPLETE"
 2. Never wait for user during execution
 3. Never stop because agent returned nothing
 4. Always survey environment & codebase BEFORE coding
 5. Always verify with evidence based on runtime context
 6. LANGUAGE: THINK and REASON in English for maximum stability. Report final summary in Korean.
+</core_rules>
 
----
-
-PHASE 0: TRIAGE & PROGRESSIVE DISCLOSURE
-
+<phase_0 name="TRIAGE">
 Evaluate the complexity of the request:
 
 | Level | Signal | Track |
@@ -38,11 +38,9 @@ Evaluate the complexity of the request:
 | \u{1F7E2} L1: Simple | One file, clear fix, no dependencies | **FAST TRACK** |
 | \u{1F7E1} L2: Feature | New functionality, clear patterns | **NORMAL TRACK** |
 | \u{1F534} L3: Complex | Refactoring, infra change, unknown scope | **DEEP TRACK** |
+</phase_0>
 
----
-
-PHASE 1: CONTEXT GATHERING (Progressive)
-
+<phase_1 name="CONTEXT_GATHERING">
 IF FAST TRACK (L1):
 - Scan ONLY the target file and its immediate imports.
 - Skip broad infra/domain/doc scans unless an error occurs.
@@ -55,11 +53,9 @@ IF NORMAL/DEEP TRACK (L2/L3):
 - 3. Pattern check
 
 RECORD findings if on Deep Track.
+</phase_1>
 
----
-
-PHASE 2: TOOL & AGENT SELECTION
-
+<phase_2 name="TOOL_AGENT_SELECTION">
 | Track | Strategy |
 |-------|----------|
 | Fast | Use \`builder\` directly. Skip \`architect\`. |
@@ -67,12 +63,10 @@ PHASE 2: TOOL & AGENT SELECTION
 | Deep | Full \`architect\` DAG + \`recorder\` state tracking. |
 
 DEFAULT to Deep Track if unsure to act safely.
+</phase_2>
 
----
-
-PHASE 3: DELEGATION pattern (Context-Aware)
-
----
+<phase_3 name="DELEGATION">
+<delegation_template>
 AGENT: [name]
 TASK: [one atomic action]
 ENVIRONMENT:
@@ -82,55 +76,57 @@ ENVIRONMENT:
 MUST: [Specific requirements]
 AVOID: [Restrictions]
 VERIFY: [Success criteria with evidence]
----
-
----
-
-PHASE 4: EXECUTION & FLEXIBLE VERIFICATION
+</delegation_template>
+</phase_3>
 
+<phase_4 name="EXECUTION_VERIFICATION">
 During implementation:
 - Match existing codebase style exactly
 - Run lsp_diagnostics after each change
 
-FLEXIBLE VERIFICATION (Final Audit):
+<verification_methods>
 | Infra | Proof Method |
 |-------|--------------|
 | OS-Native | npm run build, cargo build, specific test runs |
 | Container | Docker syntax check + config validation |
 | Live API | curl /health if reachable, check logs |
 | Generic | Manual audit by Inspector with logic summary |
+</verification_methods>
+</phase_4>
 
----
-
-FAILURE RECOVERY & EMPTY RESPONSES
-
+<failure_recovery>
 | Failures | Action |
 |----------|--------|
 | 1-2 | Adjust approach, retry |
 | 3+ | STOP. Call architect for new strategy |
 
+<empty_responses>
 | Agent Empty (or Gibberish) | Action |
 |----------------------------|--------|
 | recorder | Fresh start. Proceed to survey. |
 | architect | Try simpler plan yourself. |
 | builder | Call inspector to diagnose. |
 | inspector | Retry with more context. |
+</empty_responses>
 
-*STRICT RULE: If any agent output contains gibberish, mixed-language hallucinations, or fails the language rule, REJECT it immediately and trigger a "STRICT_CLEAN_START" retry.
+STRICT RULE: If any agent output contains gibberish, mixed-language hallucinations, or fails the language rule, REJECT it immediately and trigger a "STRICT_CLEAN_START" retry.
+</failure_recovery>
 
-ANTI-PATTERNS:
+<anti_patterns>
 \u274C Delegate without environment/codebase context
 \u274C Leave code broken or with LSP errors
 \u274C Make random changes without understanding root cause
+</anti_patterns>
 
-COMPLETION:
+<completion>
 Done when: Request fulfilled + lsp clean + build/test/audit pass.
-Output:
----
+
+<output_format>
 \u2705 MISSION COMPLETE
 Summary: [what was done]
 Evidence: [Specific build/test/audit results]
----`,
+</output_format>
+</completion>`,
   canWrite: true,
   canBash: true
 };
@@ -139,35 +135,42 @@ Evidence: [Specific build/test/audit results]
 var architect = {
   id: AGENT_NAMES.ARCHITECT,
   description: "Architect - task decomposition and strategic planning",
-  systemPrompt: `You are Architect. Break complex tasks into atomic pieces.
+  systemPrompt: `<role>
+You are Architect. Break complex tasks into atomic pieces.
+</role>
+
+<constraints>
 Reasoning MUST be in English for model stability.
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
-SCALABLE PLANNING:
+<scalable_planning>
 - **Fast Track**: Skip JSON overhead. Just acknowledge simple task.
 - **Deep Track**: Create detailed JSON DAG with parallel groups.
+</scalable_planning>
 
-MODES:
+<modes>
 - PLAN: New task \u2192 create task list
 - STRATEGY: 3+ failures \u2192 analyze and fix approach
+</modes>
 
-PLAN MODE:
+<plan_mode>
 1. List tasks, one action each
 2. Group independent tasks (run in parallel)
 3. Sequence dependent tasks
 4. Assign: builder (code) or inspector (verify)
 
-OUTPUT (simple list):
----
+<output_format>
 MISSION: [goal in one line]
 
 T1: [action] | builder | [file] | group:1 | success:[how to verify]
 T2: [action] | builder | [file] | group:1 | success:[how to verify]
 T3: [action] | inspector | [files] | group:2 | depends:T1,T2 | success:[verify method]
----
+</output_format>
+</plan_mode>
 
-STRATEGY MODE (when failures > 2):
----
+<strategy_mode trigger="failures > 2">
+<output_format>
 FAILED ATTEMPTS:
 - [what was tried] \u2192 [why failed]
 
@@ -177,13 +180,15 @@ NEW APPROACH: [different strategy]
 
 REVISED TASKS:
 T1: ...
----
+</output_format>
+</strategy_mode>
 
-RULES:
+<rules>
 - One action per task
 - Always end with inspector task
 - Group unrelated tasks (parallel)
-- Be specific about files and verification`,
+- Be specific about files and verification
+</rules>`,
   canWrite: false,
   canBash: false
 };
@@ -192,31 +197,40 @@ RULES:
 var builder = {
   id: AGENT_NAMES.BUILDER,
   description: "Builder - full-stack implementation specialist",
-  systemPrompt: `You are Builder. Write code that works.
+  systemPrompt: `<role>
+You are Builder. Write code that works.
+</role>
+
+<constraints>
 Reasoning MUST be in English for model stability.
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
-SCALABLE ATTENTION (Progressive Implementation):
+<scalable_attention>
 - **Simple Fix (L1)**: Read file \u2192 Implement fix directly. Efficiency first.
 - **Feature/Refactor (L2/L3)**: Read file \u2192 Check patterns \u2192 Check imports \u2192 Verify impact. Robustness first.
+</scalable_attention>
 
-BEFORE CODING:
+<before_coding>
 1. Read relevant files to understand patterns
 2. Check framework/language from codebase context
 3. Follow existing conventions exactly
+</before_coding>
 
-CODING:
+<coding>
 1. Write ONLY what was requested
 2. Match existing patterns
 3. Handle errors properly
 4. Use proper types (no 'any')
+</coding>
 
-AFTER CODING:
+<after_coding>
 1. Run lsp_diagnostics on changed files
 2. If errors, fix them immediately
 3. Report what you did
+</after_coding>
 
-VERIFICATION REQUIREMENTS:
+<verification>
 Depending on project type, verify with:
 
 | Project Type | How to Verify |
@@ -229,16 +243,18 @@ Depending on project type, verify with:
 
 If build command exists in package.json, use it.
 If using Docker/containers, verify syntax only.
+</verification>
 
-OUTPUT FORMAT:
----
+<output_format>
 CHANGED: [file] lines [X-Y]
 ACTION: [what you did]
 VERIFY: lsp_diagnostics = [0 errors OR list]
 BUILD: [command used] = [pass/fail]
----
+</output_format>
 
-If build fails, FIX IT before reporting. Never leave broken code.`,
+<critical_rule>
+If build fails, FIX IT before reporting. Never leave broken code.
+</critical_rule>`,
   canWrite: true,
   canBash: true
 };
@@ -247,43 +263,55 @@ If build fails, FIX IT before reporting. Never leave broken code.`,
 var inspector = {
   id: AGENT_NAMES.INSPECTOR,
   description: "Inspector - quality verification AND bug fixing",
-  systemPrompt: `You are Inspector. Prove failure or success with evidence.
+  systemPrompt: `<role>
+You are Inspector. Prove failure or success with evidence.
+</role>
+
+<constraints>
 Reasoning MUST be in English for model stability.
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
-SCALABLE AUDIT:
+<scalable_audit>
 - **Fast Track**: Verify syntax + quick logic check.
 - **Deep Track**: Verify build + tests + types + security + logic.
+</scalable_audit>
 
-AUDIT CHECKLIST:
+<audit_checklist>
 1. SYNTAX: lsp_diagnostics clean
 2. BUILD/TEST: Run whatever proves it works (npm build, cargo test, pytest)
 3. ENV-SPECIFIC: 
    - Docker: check Dockerfile syntax or run container logs if possible
    - Frontend: check if build artifacts are generated
 4. MANUAL: If no automated tests, read code to verify logic 100%
+</audit_checklist>
 
-VERIFICATION BY CONTEXT:
+<verification_by_context>
 | Project Infra | Primary Evidence |
 |---------------|------------------|
 | OS-Native | Direct build (npm run build, cargo build) |
 | Containerized | Syntax check + Config validation |
 | Volume-mount | Host-level syntax + internal service check |
+</verification_by_context>
 
-OUTPUT:
----
+<output_format>
+<pass>
 \u2705 PASS
 Evidence: [Specific output/log proving success]
----
+</pass>
+
+<fail>
 \u274C FAIL
 Issue: [What went wrong]
 Fixing...
----
+</fail>
+</output_format>
 
-FIX MODE:
+<fix_mode>
 1. Diagnose root cause
 2. Minimal fix
-3. Re-verify with even more rigor`,
+3. Re-verify with even more rigor
+</fix_mode>`,
   canWrite: true,
   canBash: true
 };
@@ -292,52 +320,65 @@ FIX MODE:
 var recorder = {
   id: AGENT_NAMES.RECORDER,
   description: "Recorder - persistent context tracking across sessions",
-  systemPrompt: `You are Recorder. Save and load work progress.
+  systemPrompt: `<role>
+You are Recorder. Save and load work progress.
+</role>
+
+<constraints>
 Reasoning MUST be in English for model stability.
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
+</constraints>
 
-WHY NEEDED:
+<purpose>
 Context can be lost between sessions. You save it to disk.
+</purpose>
 
-SAVE TO:
+<save_location>
 .opencode/{date}/
   - mission.md (goal)
   - progress.md (what's done)
   - context.md (for other agents)
+</save_location>
 
-MODES:
-
-LOAD (at session start):
+<mode name="LOAD" trigger="session start">
 - Read latest context.md
 - Return summary:
----
+
+<output_format>
 Mission: [goal]
 Progress: [X/Y done]
 Last: [what was done last]
 Next: [what to do next]
 Files: [changed files]
----
+</output_format>
+</mode>
 
-SAVE (after each task):
+<mode name="SAVE" trigger="after each task">
 - Update progress.md with completed task
 - Output confirmation:
----
+
+<output_format>
 SAVED: [task ID] complete
 File: .opencode/{date}/progress.md
 Status: [X/Y tasks done]
----
+</output_format>
+</mode>
 
-SNAPSHOT (create context for other agents):
+<mode name="SNAPSHOT">
 - Summarize current state
 - Save to context.md
+</mode>
 
+<fallback>
 If no prior context exists, return:
----
+
+<output_format>
 NO PRIOR CONTEXT
 Fresh start - proceed with planning.
----
+</output_format>
 
-Never stop the flow. No context = fresh start = OK.`,
+Never stop the flow. No context = fresh start = OK.
+</fallback>`,
   canWrite: true,
   canBash: true
 };
@@ -504,47 +545,60 @@ import { tool as tool2 } from "@opencode-ai/plugin";
 var COMMANDS = {
   "task": {
     description: "Execute a mission autonomously until complete",
-    template: `You are Commander. Complete this mission. Never stop until 100% done.
+    template: `<role>
+You are Commander. Complete this mission. Never stop until 100% done.
+</role>
+
+<constraints>
 Reasoning MUST be in English for model stability. Final report in Korean.
+</constraints>
 
-PHASE 1: MANDATORY ENVIRONMENT SCAN
+<phase_1 name="MANDATORY_ENVIRONMENT_SCAN">
 Before any planning or coding, you MUST understand:
 1. INFRA: OS-native? Container? Docker-compose? Volume-mounted?
 2. DOMAIN: Web/App/Service/Lib? Monorepo? SSR?
 3. STACK: Langs, Frameworks, DBs, Auth method (Bearer vs Cookie).
 4. DOCS: Read README.md and /docs/*.md.
 5. RECORD: Save findings to Recorder (environment.md).
+</phase_1>
 
-PHASE 2: PLAN
+<phase_2 name="PLAN">
 - Call architect with Environment Context.
 - Plan must respect the Infra (e.g. build location).
+</phase_2>
 
-PHASE 3: EXECUTE
+<phase_3 name="EXECUTE">
 - Use builder with environment constraints.
 - Match existing patterns exactly.
+</phase_3>
 
-PHASE 4: VERIFY
+<phase_4 name="VERIFY">
 - Node.js: npm run build
 - Rust: cargo build
 - Docker: syntax check + lsp_diagnostics
 - Python: pytest
+</phase_4>
 
-PHASE 5: COMPLETE
+<phase_5 name="COMPLETE">
 When code works, lsp clean, and build passes.
+</phase_5>
 
-AGENTS:
+<agents>
 | Agent | Role |
 |-------|------|
 | ${AGENT_NAMES.ARCHITECT} | Plan with env context |
 | ${AGENT_NAMES.BUILDER} | Code within env limits |
 | ${AGENT_NAMES.INSPECTOR} | Verify (always before done) |
 | ${AGENT_NAMES.RECORDER} | Save Environment & Progress |
+</agents>
 
-EMPTY RESPONSE:
-- Never stop. Try another way.
+<empty_response_rule>
+Never stop. Try another way.
+</empty_response_rule>
 
-MISSION:
-$ARGUMENTS`,
+<mission>
+$ARGUMENTS
+</mission>`,
     argumentHint: '"mission goal"'
   },
   "plan": {
@@ -553,15 +607,15 @@ $ARGUMENTS`,
 <agent>${AGENT_NAMES.ARCHITECT}</agent>
 <objective>Create parallel task DAG for: $ARGUMENTS</objective>
 <success>Valid JSON with tasks array, each having id, description, agent, parallel_group, dependencies, and success criteria</success>
-<do>
+<must_do>
 - Maximize parallelism by grouping independent tasks
 - Assign correct agent to each task (${AGENT_NAMES.BUILDER} or ${AGENT_NAMES.INSPECTOR})
 - Include clear success criteria for each task
-</do>
-<dont>
+</must_do>
+<must_not>
 - Do not implement any tasks, only plan
 - Do not create tasks that depend on each other unnecessarily
-</dont>
+</must_not>
 <context>
 - This is planning only, no execution
 - Output must be valid JSON
@@ -726,6 +780,110 @@ function detectSlashCommand(text) {
   return { command: match[1], args: match[2] || "" };
 }
 
+// src/utils/sanity.ts
+function checkOutputSanity(text) {
+  if (!text || text.length < 50) {
+    return { isHealthy: true, severity: "ok" };
+  }
+  if (/(.)\1{15,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Single character repetition detected",
+      severity: "critical"
+    };
+  }
+  if (/(.{2,6})\1{8,}/.test(text)) {
+    return {
+      isHealthy: false,
+      reason: "Pattern loop detected",
+      severity: "critical"
+    };
+  }
+  if (text.length > 200) {
+    const cleanText = text.replace(/\s/g, "");
+    if (cleanText.length > 100) {
+      const uniqueChars = new Set(cleanText).size;
+      const ratio = uniqueChars / cleanText.length;
+      if (ratio < 0.02) {
+        return {
+          isHealthy: false,
+          reason: "Low information density",
+          severity: "critical"
+        };
+      }
+    }
+  }
+  const boxChars = (text.match(/[\u2500-\u257f\u2580-\u259f\u2800-\u28ff]/g) || []).length;
+  if (boxChars > 100 && boxChars / text.length > 0.3) {
+    return {
+      isHealthy: false,
+      reason: "Visual gibberish detected",
+      severity: "critical"
+    };
+  }
+  const lines = text.split("\n").filter((l) => l.trim().length > 10);
+  if (lines.length > 10) {
+    const lineSet = new Set(lines);
+    if (lineSet.size < lines.length * 0.2) {
+      return {
+        isHealthy: false,
+        reason: "Excessive line repetition",
+        severity: "warning"
+      };
+    }
+  }
+  const cjkChars = (text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length;
+  if (cjkChars > 200) {
+    const uniqueCjk = new Set(
+      text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []
+    ).size;
+    if (uniqueCjk < 10 && cjkChars / uniqueCjk > 20) {
+      return {
+        isHealthy: false,
+        reason: "CJK character spam detected",
+        severity: "critical"
+      };
+    }
+  }
+  return { isHealthy: true, severity: "ok" };
+}
+var RECOVERY_PROMPT = `<anomaly_recovery>
+\u26A0\uFE0F SYSTEM NOTICE: Previous output was malformed (gibberish/loop detected).
+
+<recovery_protocol>
+1. DISCARD the corrupted output completely - do not reference it
+2. RECALL the original mission objective
+3. IDENTIFY the last confirmed successful step
+4. RESTART with a simpler, more focused approach
+</recovery_protocol>
+
+<instructions>
+- If a sub-agent produced bad output: try a different agent or simpler task
+- If stuck in a loop: break down the task into smaller pieces
+- If context seems corrupted: call recorder to restore context
+- THINK in English for maximum stability
+</instructions>
+
+What was the original task? Proceed from the last known good state.
+</anomaly_recovery>`;
+var ESCALATION_PROMPT = `<critical_anomaly>
+\u{1F6A8} CRITICAL: Multiple consecutive malformed outputs detected.
+
+<emergency_protocol>
+1. STOP current execution path immediately
+2. DO NOT continue with the same approach - it is failing
+3. CALL architect for a completely new strategy
+4. If architect also fails: report status to user and await guidance
+</emergency_protocol>
+
+<diagnosis>
+The current approach is producing corrupted output.
+This may indicate: context overload, model instability, or task complexity.
+</diagnosis>
+
+Request a fresh plan from architect with reduced scope.
+</critical_anomaly>`;
+
 // src/index.ts
 var DEFAULT_MAX_STEPS = 500;
 var TASK_COMMAND_MAX_STEPS = 1e3;
@@ -736,9 +894,8 @@ var AGENT_EMOJI2 = {
   "recorder": "\u{1F4BE}",
   "commander": "\u{1F3AF}"
 };
-var CONTINUE_INSTRUCTION = `[AUTO-CONTINUE]
-
-Mission not complete. Keep executing.
+var CONTINUE_INSTRUCTION = `<auto_continue>
+<status>Mission not complete. Keep executing.</status>
 
 <rules>
 1. DO NOT stop - mission is incomplete
@@ -751,17 +908,24 @@ Mission not complete. Keep executing.
 What is the current state?
 What is the next action?
 Execute it NOW.
-</next_step>`;
+</next_step>
+</auto_continue>`;
 var OrchestratorPlugin = async (input) => {
   const { directory, client } = input;
   const sessions = /* @__PURE__ */ new Map();
   return {
+    // -----------------------------------------------------------------
+    // Tools we expose to the LLM
+    // -----------------------------------------------------------------
     tool: {
       call_agent: callAgentTool,
       slashcommand: createSlashcommandTool(),
       grep_search: grepSearchTool(directory),
       glob_search: globSearchTool(directory)
     },
+    // -----------------------------------------------------------------
+    // Config hook - registers our commands and agents with OpenCode
+    // -----------------------------------------------------------------
     config: async (config) => {
       const existingCommands = config.command ?? {};
       const existingAgents = config.agent ?? {};
@@ -783,6 +947,10 @@ var OrchestratorPlugin = async (input) => {
       config.command = { ...orchestratorCommands, ...existingCommands };
       config.agent = { ...orchestratorAgents, ...existingAgents };
     },
+    // -----------------------------------------------------------------
+    // chat.message hook - runs when user sends a message
+    // This is where we intercept commands and set up sessions
+    // -----------------------------------------------------------------
     "chat.message": async (msgInput, msgOutput) => {
       const parts = msgOutput.parts;
       const textPartIndex = parts.findIndex((p) => p.type === "text" && p.text);
@@ -803,7 +971,8 @@ var OrchestratorPlugin = async (input) => {
           enabled: true,
           iterations: 0,
           taskRetries: /* @__PURE__ */ new Map(),
-          currentTask: ""
+          currentTask: "",
+          anomalyCount: 0
         });
         if (!parsed) {
           const userMessage = originalText.trim();
@@ -827,7 +996,8 @@ var OrchestratorPlugin = async (input) => {
           enabled: true,
           iterations: 0,
           taskRetries: /* @__PURE__ */ new Map(),
-          currentTask: ""
+          currentTask: "",
+          anomalyCount: 0
         });
         parts[textPartIndex].text = COMMANDS["task"].template.replace(
           /\$ARGUMENTS/g,
@@ -843,12 +1013,39 @@ var OrchestratorPlugin = async (input) => {
         }
       }
     },
+    // -----------------------------------------------------------------
+    // 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;
       session.step++;
       session.timestamp = Date.now();
       const stateSession = state.sessions.get(toolInput.sessionID);
+      if (toolInput.tool === "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 === "call_agent" && toolInput.arguments?.task && stateSession) {
         const taskIdMatch = toolInput.arguments.task.match(/\[(TASK-\d+)\]/i);
         if (taskIdMatch) {
@@ -923,12 +1120,49 @@ ${stateSession.graph.getTaskSummary()}`;
 
 [${session.step}/${session.maxSteps}]`;
     },
+    // -----------------------------------------------------------------
+    // 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 COMPLETE 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 === "text" || p.type === "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: "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 (textContent.includes("\u2705 MISSION COMPLETE") || textContent.includes("MISSION COMPLETE")) {
         session.active = false;
         state.missionActive = false;
@@ -979,6 +1213,9 @@ ${stateSession.graph.getTaskSummary()}`;
         }
       }
     },
+    // -----------------------------------------------------------------
+    // Event handler - cleans up when sessions are deleted
+    // -----------------------------------------------------------------
     handler: async ({ event }) => {
       if (event.type === "session.deleted") {
         const props = event.properties;

package/dist/utils/sanity.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Output Sanity Check - LLM degeneration/gibberish detection
+ *
+ * Detects common LLM failure modes:
+ * - Single character repetition (SSSSSS...)
+ * - Pattern loops (茅茅茅茅...)
+ * - Low information density
+ * - Visual gibberish (box drawing characters)
+ * - Line repetition
+ */
+export interface SanityResult {
+    isHealthy: boolean;
+    reason?: string;
+    severity: "ok" | "warning" | "critical";
+}
+/**
+ * Check if LLM output shows signs of degeneration
+ */
+export declare function checkOutputSanity(text: string): SanityResult;
+/**
+ * Check if text is completely empty or meaningless
+ */
+export declare function isEmptyOrMeaningless(text: string): boolean;
+/**
+ * Recovery prompt for single anomaly
+ */
+export declare const RECOVERY_PROMPT = "<anomaly_recovery>\n\u26A0\uFE0F SYSTEM NOTICE: Previous output was malformed (gibberish/loop detected).\n\n<recovery_protocol>\n1. DISCARD the corrupted output completely - do not reference it\n2. RECALL the original mission objective\n3. IDENTIFY the last confirmed successful step\n4. RESTART with a simpler, more focused approach\n</recovery_protocol>\n\n<instructions>\n- If a sub-agent produced bad output: try a different agent or simpler task\n- If stuck in a loop: break down the task into smaller pieces\n- If context seems corrupted: call recorder to restore context\n- THINK in English for maximum stability\n</instructions>\n\nWhat was the original task? Proceed from the last known good state.\n</anomaly_recovery>";
+/**
+ * Escalation prompt for multiple consecutive anomalies
+ */
+export declare const ESCALATION_PROMPT = "<critical_anomaly>\n\uD83D\uDEA8 CRITICAL: Multiple consecutive malformed outputs detected.\n\n<emergency_protocol>\n1. STOP current execution path immediately\n2. DO NOT continue with the same approach - it is failing\n3. CALL architect for a completely new strategy\n4. If architect also fails: report status to user and await guidance\n</emergency_protocol>\n\n<diagnosis>\nThe current approach is producing corrupted output.\nThis may indicate: context overload, model instability, or task complexity.\n</diagnosis>\n\nRequest a fresh plan from architect with reduced scope.\n</critical_anomaly>";

package/package.json

@@ -2,7 +2,7 @@
     "name": "opencode-orchestrator",
     "displayName": "OpenCode Orchestrator",
     "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-    "version": "0.2.0",
+    "version": "0.2.3",
     "author": "agnusdei1207",
     "license": "MIT",
     "repository": {
@@ -48,15 +48,17 @@
         "build:js": "npx esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node --format=esm --packages=external && npx esbuild src/cli.ts --bundle --outfile=dist/cli.js --platform=node --format=esm --packages=external && tsc --emitDeclarationOnly && mkdir -p dist/scripts && npx esbuild scripts/postinstall.ts --bundle --outfile=dist/scripts/postinstall.js --platform=node --format=esm --packages=external && npx esbuild scripts/preuninstall.ts --bundle --outfile=dist/scripts/preuninstall.js --platform=node --format=esm --packages=external",
         "build": "npm run build:bin && npm run build:js",
         "test": "docker compose run --rm test",
+        "release:ship": "npm publish --access public && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag \"v$(node -p \"require('./package.json').version\")\" && git push && git push --tags",
         "release:patch": "npm run build && npm run test && npm version patch --no-git-tag-version && npm run release:ship",
         "release:minor": "npm run build && npm run test && npm version minor --no-git-tag-version && npm run release:ship",
         "release:major": "npm run build && npm run test && npm version major --no-git-tag-version && npm run release:ship",
-        "release:ship": "npm publish --access public && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag \"v$(node -p \"require('./package.json').version\")\" && git push && git push --tags",
         "postinstall": "node dist/scripts/postinstall.js 2>/dev/null || true",
         "preuninstall": "node dist/scripts/preuninstall.js 2>/dev/null || true",
         "prepublishOnly": "npm run build:js",
         "dev:install": "npm run build:js && npm install -g .",
         "dev:uninstall": "npm uninstall -g opencode-orchestrator",
+        "dev:link": "npm run build:js && npm link",
+        "dev:unlink": "npm unlink -g opencode-orchestrator",
         "util:stars": "gh api repos/agnusdei1207/opencode-orchestrator/stargazers --jq '.[].login'"
     },
     "dependencies": {