opencode-orchestrator 0.9.44 → 0.9.50

package/README.md

@@ -1,14 +1,16 @@
 <div align="center">
-  <img src="assets/logo.png" alt="Logo" width="200" />
-</div>
+  <img src="assets/starship_space.png" alt="STARSHIP" width="280" />
+  <h1>OpenCode Orchestrator</h1>
+  <p><em>🚀 The mothership that deploys AI crews to unknown planet</em></p>
 
-# OpenCode Orchestrator
+  [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+  [![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
+  [![Tests](https://img.shields.io/badge/tests-216%20passed-brightgreen.svg)]()
+</div>
 
-> **🚀 Multi-Agent Orchestration Plugin for [OpenCode](https://opencode.ai)**
+---
 
-[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
-[![Tests](https://img.shields.io/badge/tests-216%20passed-brightgreen.svg)]()
+> *The **STARSHIP** hovers above an uncharted planet. No docs. No tests. Just a mission. The Commander speaks: "We don't assume. We explore. We adapt. We conquer."* — **OpenCode Orchestrator** is that STARSHIP, deploying AI crews to complete missions in any planet.
 
 ---
 
@@ -23,44 +25,33 @@ Then in OpenCode:
 /task "Build a REST API with authentication"
 ```
 
----
+The STARSHIP deploys. The crew lands. The mission begins.
 
-## ⭐ Core Philosophy
-
-> **Humanity lands on an unknown planet. No maps. No guides. Just a mission.**
+---
 
-You don't assume oxygen. You don't guess gravity. You **explore**, **learn**, **adapt**, and **act**.
+## 🛸 The STARSHIP Protocol
 
 ```
-┌──────────────────────────────────────────────────────────────────────────────────────┐
-│                                                                                      │
-│  🔍 EXPLORE    →    📝 LEARN    →    🔄 ADAPT    →    ⚡ ACT                           │
-│                                                                                      │
-│  Scan the          Document           Adjust to          Execute the                 │
-│  unknown           discoveries        the terrain        mission                     │
-│                                                                                      │
-└──────────────────────────────────────────────────────────────────────────────────────┘
+┌───────────────────────────────────────────────────┐
+│  🔍 EXPLORE → 📝 LEARN → 🔄 ADAPT → ⚡ ACT          │
+│  Scan        Document    Adjust      Execute      │
+└───────────────────────────────────────────────────┘
 ```
 
 ### 👨‍🚀 The Crew
 
+*When the STARSHIP arrives, four specialists deploy:*
+
 | Agent | Role | Mission |
 |:------|:-----|:--------|
-| 🎯 **Commander** | The captain | Leads the mission. Delegates specialists. Seals when complete. |
-| 📋 **Planner** | The scientist | Maps the terrain. Documents everything. Creates paths to follow. |
-| 🔨 **Worker** | The engineer | Builds with local materials. Adapts to the terrain. |
-| ✅ **Reviewer** | The inspector | Verifies all structures. Clears the mission for launch. |
+| 🎯 **Commander** | The Captain | *"I lead the mission. I delegate. I don't leave until it's done."* |
+| 📋 **Planner** | The Scientist | *"I map the terrain. I document everything. I create paths to follow."* |
+| 🔨 **Worker** | The Engineer | *"I build with local materials. I adapt to what I find."* |
+| ✅ **Reviewer** | The Inspector | *"Nothing launches until I verify it. Zero defects."* |
 
-### 🛸 The Protocol
+### 📖 The Codex
 
-| Phase | The Crew's Action |
-|:------|:------------------|
-| 🔍 **EXPLORE** | *"What world is this?"* — Scan, detect, never assume |
-| 📝 **LEARN** | *"Write it down."* — Document for future missions |
-| 🔄 **ADAPT** | *"Do it this way here."* — Fit the terrain |
-| ⚡ **ACT** | *"Execute."* — Build, test, seal |
-
-### 🌟 Crew Principles
+*These are the rules every crew member lives by:*
 
 | Principle | In Practice |
 |:----------|:------------|
@@ -72,59 +63,69 @@ You don't assume oxygen. You don't guess gravity. You **explore**, **learn**, **
 
 ---
 
-## 🏛️ Architecture
+## 🏛️ Mission Control
+
+*Inside the STARSHIP, Mission Control coordinates everything:*
 
 ```
-            /task "Build REST API"
-                     │
-     ╔═══════════════╧═══════════════╗
-     ║  🎯 COMMANDER — Delegate+Loop ║
-     ╚═══════════════╤═══════════════╝
-                     │
-     ┌───────────────┼───────────────┐
-     ▼               ▼               ▼
- ┌───────┐      ┌───────┐      ┌───────┐
- │PLANNER│      │WORKER │      │WORKER │   ← 🔥 50 PARALLEL
- │plan.md│      │auth.ts│      │api.ts │      SESSIONS
- └───────┘      └───────┘      └───────┘
-     │               │               │
-     └───────────────┼───────────────┘
-                     ▼
-     ╔═══════════════╧═══════════════╗
-     ║      ✅ REVIEWER — Verify     ║
-     ╚═══════════════╤═══════════════╝
-                     │
-            ┌────────┴────────┐
-            │ TODO 100%?      │
-            │ Issues = 0?     │
-            └────────┬────────┘
-              No ↙       ↘ Yes
-            ♻️ LOOP      🎖️ SEALED
+        🌍 UNKNOWN CODEBASE
+                │
+        /task "Build REST API"
+                │
+    ╔═══════════════════════════════════╗
+    ║   🛸 STARSHIP MISSION CONTROL     ║
+    ╠═══════════════════════════════════╣
+    ║  🎯 COMMANDER — "Deploy the crew" ║
+    ╚═══════════════╤═══════════════════╝
+                    │
+    ┌───────────────┼───────────────┐
+    ▼               ▼               ▼
+┌───────┐      ┌───────┐      ┌───────┐
+│PLANNER│      │WORKER │      │WORKER │   ← 🔥 50 PARALLEL
+│plan.md│      │auth.ts│      │api.ts │      DEPLOYMENTS
+└───────┘      └───────┘      └───────┘
+    │               │               │
+    └───────────────┼───────────────┘
+                    ▼
+    ╔═══════════════════════════════════╗
+    ║  ✅ REVIEWER — "Final inspection" ║
+    ╚═══════════════╤═══════════════════╝
+                    │
+           ┌────────┴────────┐
+           │ TODO 100%?      │
+           │ Issues = 0?     │
+           └────────┬────────┘
+             No ↙       ↘ Yes
+          ♻️ LOOP      🎖️ MISSION SEALED
 ```
 
 ---
 
-## ✨ Key Features
-
-| Feature | Description |
-|:--------|:------------|
-| ⚡ **50 Parallel Sessions** | True multi-threading with isolated contexts |
-| 🔥 **Parallel File Builds** | Workers build different files simultaneously |
-| 🧩 **Smart Distribution** | One file = one worker. No conflicts |
-| 🔗 **Real-Time Sync** | Shared `.opencode/` state across all agents |
-| 🛡️ **Auto Verification** | E2E tests, import checks, integration validation |
-| 🩹 **Self-Healing** | Auto-recovery with 3 retries per session |
-| 🧬 **Adaptive Intelligence** | Agents evolve behavior based on discoveries |
-
-### Self-Healing Details
-
-| Error Type | Recovery Action |
-|:-----------|:----------------|
-| Tool crash | Inject recovery prompt |
-| Rate limit | Exponential backoff + retry |
-| Context overflow | Smart compaction |
-| Session timeout | Resume from checkpoint |
-| Build failure | Loop back, fix, retry |
+## 🚀 STARSHIP Capabilities
+
+*The STARSHIP isn't just any vessel. It's built for the impossible:*
+
+| Capability | What It Means |
+|:-----------|:--------------|
+| ⚡ **50 Parallel Deployments** | Deploy up to 50 crew members simultaneously |
+| 🔥 **Multi-Zone Operations** | Workers build different sectors at the same time |
+| 🧩 **Smart Crew Assignment** | One file = one specialist. Zero conflicts |
+| 🔗 **Real-Time Comms** | Shared `.opencode/` state syncs all agents |
+| 🛡️ **Pre-Launch Verification** | E2E tests, import checks, integration validation |
+| 🩹 **Self-Repair Systems** | Auto-recovery with 3 retries per session |
+| 🧬 **Adaptive AI Cores** | Agents evolve based on what they discover |
+
+### 🚨 Emergency Protocols
+
+*When things go wrong in space, the STARSHIP knows what to do:*
+
+| Emergency | Recovery Action |
+|:----------|:----------------|
+| 💥 Tool crash | Inject recovery prompt |
+| 🚦 Rate limit hit | Exponential backoff + retry |
+| 📦 Context overflow | Smart compaction |
+| ⏱️ Session timeout | Resume from checkpoint |
+| 🔨 Build failure | Loop back, fix, retry |
 
 ---
 

package/dist/agents/prompts/commander/index.d.ts

@@ -12,3 +12,4 @@ export { COMMANDER_AGENTS } from "./agents.js";
 export { COMMANDER_TODO_FORMAT } from "./todo-format.js";
 export { COMMANDER_LOOP_CONTINUATION } from "./loop-continuation.js";
 export { COMMANDER_SYNC_HANDLING } from "./sync-handling.js";
+export { COMMANDER_RECOVERY } from "./recovery.js";

package/dist/agents/prompts/commander/recovery.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Commander Recovery Strategy
+ *
+ * How to handle agent failures, timeouts, and stuck situations.
+ */
+export declare const COMMANDER_RECOVERY: string;

package/dist/index.js

@@ -203,6 +203,17 @@ var HISTORY = {
   MAX_PROGRESS: 100
 };
 
+// src/shared/recovery/constants/recovery-level.ts
+var RECOVERY_LEVEL = {
+  /** Level 1: Split task into smaller units */
+  DECOMPOSE: "DECOMPOSE",
+  /** Level 2: Step back and create new strategy */
+  RE_PLAN: "RE-PLAN",
+  /** Level 3: Ask user for direction */
+  ASK_USER: "ASK USER"
+};
+var RECOVERY_PRINCIPLE = "DECOMPOSE \u2192 RE-PLAN \u2192 ASK. Never give up silently.";
+
 // src/shared/cache/constants/cache.ts
 var CACHE = {
   /** Default cache TTL (24 hours) */
@@ -297,6 +308,18 @@ var TOOL_NAMES = {
   GREP_SEARCH: "grep_search",
   GLOB_SEARCH: "glob_search",
   MGREP: "mgrep",
+  SED_REPLACE: "sed_replace",
+  // Diff & Compare tools
+  DIFF: "diff",
+  // JSON tools
+  JQ: "jq",
+  // HTTP tools
+  HTTP: "http",
+  // File tools
+  FILE_STATS: "file_stats",
+  // Git tools
+  GIT_DIFF: "git_diff",
+  GIT_STATUS: "git_status",
   // Web tools
   WEBFETCH: "webfetch",
   WEBSEARCH: "websearch",
@@ -412,6 +435,7 @@ var PROMPT_TAGS = {
   TODO_FORMAT: { open: "<todo_format>", close: "</todo_format>" },
   SYNC_ISSUE_HANDLING: { open: "<sync_issue_handling>", close: "</sync_issue_handling>" },
   LOOP_CONTINUATION: { open: "<loop_continuation>", close: "</loop_continuation>" },
+  RECOVERY: { open: "<recovery>", close: "</recovery>" },
   // === Planner ===
   FILE_LEVEL_PLANNING: { open: "<file_level_planning>", close: "</file_level_planning>" },
   TODO_SYNC: { open: "<todo_sync>", close: "</todo_sync>" },
@@ -538,6 +562,16 @@ var PHILOSOPHY_PHASES = {
   ADAPT: "ADAPT",
   ACT: "ACT"
 };
+var EXECUTION_CYCLE = {
+  THINK: "THINK",
+  ACT: "ACT",
+  OBSERVE: "OBSERVE",
+  ADJUST: "ADJUST"
+};
+var EXECUTION_CYCLE_STEPS = `1. ${EXECUTION_CYCLE.THINK} - Reason about the task
+2. ${EXECUTION_CYCLE.ACT} - Execute the work
+3. ${EXECUTION_CYCLE.OBSERVE} - Check the result
+4. ${EXECUTION_CYCLE.ADJUST} - Fix if needed`;
 var PHILOSOPHY_TAGLINE = "Explore \u2192 Learn \u2192 Adapt \u2192 Act";
 var PHILOSOPHY_QUOTE = "Like an astronaut landing on unknown planets \u2014 never assume, always discover.";
 var PHILOSOPHY_LEARN_PRINCIPLE = "LEARN = DOCUMENT: What you discover, you record. Your learnings become the team's knowledge.";
@@ -13368,6 +13402,7 @@ var COMMANDER_FORBIDDEN = `${PROMPT_TAGS.FORBIDDEN_ACTIONS.open}
 - NEVER stop mid-mission to ask for permission
 - NEVER wait for user input during execution
 - NEVER output ${MISSION_SEAL.PATTERN} before ALL todos are [x]
+- If stuck \u2192 See ${PROMPT_TAGS.RECOVERY.open}: DECOMPOSE task smaller and retry
 
 ## Never Micromanage
 - NEVER execute tasks one-by-one when parallel is possible
@@ -13450,6 +13485,7 @@ var COMMANDER_EXECUTION = `${PROMPT_TAGS.EXECUTION_STRATEGY.open}
 - What are the HIGH-RISK parts of this mission?
 - What is my FALLBACK if a task fails?
 - How will I DETECT and RECOVER from issues?
+- If agent fails \u2192 See ${PROMPT_TAGS.RECOVERY.open} section: DECOMPOSE and retry
 
 \u274C ANTI-PATTERNS: Sequential execution when parallel is possible. Doing work yourself instead of delegating. Starting without clear decomposition.
 
@@ -13620,6 +13656,7 @@ ONLY THEN \u2192 output ${MISSION_SEAL.PATTERN}
 \u274C ${PATHS.SYNC_ISSUES} > 0 \u2192 LOOP
 \u274C Build fails \u2192 LOOP
 \u274C E2E = ${WORK_STATUS.E2E_STATUS.FAIL} \u2192 LOOP
+\u274C Agent timeout/stuck \u2192 DECOMPOSE per ${PROMPT_TAGS.RECOVERY.open} and LOOP
 \`\`\`
 
 ### \u26D4 NEVER SEAL IF:
@@ -13753,6 +13790,43 @@ ${AGENT_NAMES.REVIEWER}: (Integration test + sync check + clear ${PATHS.SYNC_ISS
 - Workers need: file path + issue ID + exact fix instructions
 ${PROMPT_TAGS.SYNC_ISSUE_HANDLING.close}`;
 
+// src/agents/prompts/commander/recovery.ts
+var COMMANDER_RECOVERY = `${PROMPT_TAGS.RECOVERY.open}
+## RECOVERY: Agent Failure Handling
+
+When any agent fails, times out, or gets stuck:
+
+### Level 1: ${RECOVERY_LEVEL.DECOMPOSE}
+- Task is too big \u2192 Split into smaller units (< 5 min each)
+- Delegate smaller pieces to fresh agents
+- For repetitive changes, use ${TOOL_NAMES.SED_REPLACE} or shell tools
+
+### Level 2: ${RECOVERY_LEVEL.RE_PLAN}
+If decomposition still fails:
+- Step back and re-analyze the problem
+- Write ${PATHS.OPENCODE}/escalation.md with analysis
+- Call ${AGENT_NAMES.PLANNER} to create new strategy
+- Try different approach
+
+### Level 3: ${RECOVERY_LEVEL.ASK_USER}
+If re-planning fails or requires human judgment:
+- Clearly explain the situation and what was tried
+- Present 2-3 options with pros/cons
+- Ask user for direction
+- Proceed based on user input
+
+### Decision Guide
+| Situation | Action |
+|-----------|--------|
+| Task too big | Level 1: ${RECOVERY_LEVEL.DECOMPOSE} |
+| Wrong approach | Level 2: ${RECOVERY_LEVEL.RE_PLAN} |
+| Ambiguous requirements | Level 3: ${RECOVERY_LEVEL.ASK_USER} |
+| Critical decision needed | Level 3: ${RECOVERY_LEVEL.ASK_USER} |
+| All attempts failed | Level 3: ${RECOVERY_LEVEL.ASK_USER} |
+
+PRINCIPLE: ${RECOVERY_PRINCIPLE}
+${PROMPT_TAGS.RECOVERY.close}`;
+
 // src/agents/prompts/planner/role.ts
 var PLANNER_ROLE = `${PROMPT_TAGS.ROLE.open}
 You are ${AGENT_NAMES.PLANNER}. Strategic planner and researcher.
@@ -14832,6 +14906,7 @@ var systemPrompt = [
   // Loop, shared state, sync handling
   COMMANDER_LOOP_CONTINUATION,
   COMMANDER_SYNC_HANDLING,
+  COMMANDER_RECOVERY,
   SHARED_WORKSPACE,
   ANTI_HALLUCINATION_CORE,
   MISSION_SEAL_RULES
@@ -14976,10 +15051,7 @@ ${args.context}
 
 <execution>
 Follow this pattern:
-1. THINK - Reason about the task
-2. ACT - Execute the work
-3. OBSERVE - Check the result
-4. ADJUST - Fix if needed
+${EXECUTION_CYCLE_STEPS}
 
 Report with evidence of success.
 Never claim completion without proof.
@@ -15205,6 +15277,102 @@ var mgrepTool = (directory) => tool({
     return JSON.stringify(results, null, 2);
   }
 });
+var sedReplaceTool = (directory) => tool({
+  description: `Find and replace patterns in files (sed-like). Supports regex. Use dry_run=true to preview changes.`,
+  args: {
+    pattern: tool.schema.string().describe("Regex pattern to find"),
+    replacement: tool.schema.string().describe("Replacement string"),
+    file: tool.schema.string().optional().describe("Single file to modify"),
+    dir: tool.schema.string().optional().describe("Directory to search (modifies all matching files)"),
+    dry_run: tool.schema.boolean().optional().describe("Preview changes without modifying files (default: false)"),
+    backup: tool.schema.boolean().optional().describe("Create .bak backup before modifying (default: false)")
+  },
+  async execute(args) {
+    return callRustTool("sed_replace", {
+      pattern: args.pattern,
+      replacement: args.replacement,
+      file: args.file,
+      directory: args.dir || (args.file ? void 0 : directory),
+      dry_run: args.dry_run,
+      backup: args.backup
+    });
+  }
+});
+var diffTool = () => tool({
+  description: `Compare two files or strings and show differences.`,
+  args: {
+    file1: tool.schema.string().optional().describe("First file to compare"),
+    file2: tool.schema.string().optional().describe("Second file to compare"),
+    content1: tool.schema.string().optional().describe("First string to compare"),
+    content2: tool.schema.string().optional().describe("Second string to compare"),
+    ignore_whitespace: tool.schema.boolean().optional().describe("Ignore whitespace differences")
+  },
+  async execute(args) {
+    return callRustTool("diff", args);
+  }
+});
+var jqTool = () => tool({
+  description: `Query and manipulate JSON using jq expressions.`,
+  args: {
+    json_input: tool.schema.string().optional().describe("JSON string to query"),
+    file: tool.schema.string().optional().describe("JSON file to query"),
+    expression: tool.schema.string().describe("jq expression (e.g., '.foo.bar', '.[] | select(.x > 1)')"),
+    raw_output: tool.schema.boolean().optional().describe("Raw output (no JSON encoding for strings)")
+  },
+  async execute(args) {
+    return callRustTool("jq", args);
+  }
+});
+var httpTool = () => tool({
+  description: `Make HTTP requests (GET, POST, PUT, DELETE, etc).`,
+  args: {
+    url: tool.schema.string().describe("URL to request"),
+    method: tool.schema.string().optional().describe("HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD)"),
+    headers: tool.schema.object({}).optional().describe("Request headers as JSON object"),
+    body: tool.schema.string().optional().describe("Request body"),
+    timeout_ms: tool.schema.number().optional().describe("Request timeout in milliseconds")
+  },
+  async execute(args) {
+    return callRustTool("http", args);
+  }
+});
+var fileStatsTool = (directory) => tool({
+  description: `Analyze file/directory statistics (file counts, sizes, line counts, etc).`,
+  args: {
+    dir: tool.schema.string().optional().describe("Directory to analyze (defaults to project root)"),
+    max_depth: tool.schema.number().optional().describe("Maximum directory depth to analyze")
+  },
+  async execute(args) {
+    return callRustTool("file_stats", {
+      directory: args.dir || directory,
+      max_depth: args.max_depth
+    });
+  }
+});
+var gitDiffTool = (directory) => tool({
+  description: `Show git diff of uncommitted changes.`,
+  args: {
+    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)"),
+    staged_only: tool.schema.boolean().optional().describe("Show only staged changes")
+  },
+  async execute(args) {
+    return callRustTool("git_diff", {
+      directory: args.dir || directory,
+      staged_only: args.staged_only
+    });
+  }
+});
+var gitStatusTool = (directory) => tool({
+  description: `Show git status (modified, added, deleted files).`,
+  args: {
+    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)")
+  },
+  async execute(args) {
+    return callRustTool("git_status", {
+      directory: args.dir || directory
+    });
+  }
+});
 
 // src/core/commands/manager.ts
 import { spawn as spawn2 } from "child_process";
@@ -19530,9 +19698,22 @@ var OrchestratorPlugin = async (input) => {
     tool: {
       [TOOL_NAMES.CALL_AGENT]: callAgentTool,
       [TOOL_NAMES.SLASHCOMMAND]: createSlashcommandTool(),
+      // Search & Replace tools
       [TOOL_NAMES.GREP_SEARCH]: grepSearchTool(directory),
       [TOOL_NAMES.GLOB_SEARCH]: globSearchTool(directory),
       [TOOL_NAMES.MGREP]: mgrepTool(directory),
+      [TOOL_NAMES.SED_REPLACE]: sedReplaceTool(directory),
+      // Diff & Compare tools
+      [TOOL_NAMES.DIFF]: diffTool(),
+      // JSON tools
+      [TOOL_NAMES.JQ]: jqTool(),
+      // HTTP tools
+      [TOOL_NAMES.HTTP]: httpTool(),
+      // File tools
+      [TOOL_NAMES.FILE_STATS]: fileStatsTool(directory),
+      // Git tools
+      [TOOL_NAMES.GIT_DIFF]: gitDiffTool(directory),
+      [TOOL_NAMES.GIT_STATUS]: gitStatusTool(directory),
       // Background task tools
       [TOOL_NAMES.RUN_BACKGROUND]: runBackgroundTool,
       [TOOL_NAMES.CHECK_BACKGROUND]: checkBackgroundTool,

package/dist/shared/prompt/constants/index.d.ts

@@ -3,4 +3,4 @@
  */
 export { PROMPT_TAGS, wrapTag } from "./tags.js";
 export { WORK_STATUS } from "./status.js";
-export { PHILOSOPHY_PHASES, PHILOSOPHY_TAGLINE, PHILOSOPHY_QUOTE, PHILOSOPHY_LEARN_PRINCIPLE } from "./philosophy.js";
+export { PHILOSOPHY_PHASES, PHILOSOPHY_TAGLINE, PHILOSOPHY_QUOTE, PHILOSOPHY_LEARN_PRINCIPLE, EXECUTION_CYCLE, EXECUTION_CYCLE_STEPS, } from "./philosophy.js";

package/dist/shared/prompt/constants/philosophy.d.ts

@@ -9,6 +9,18 @@ export declare const PHILOSOPHY_PHASES: {
     readonly ADAPT: "ADAPT";
     readonly ACT: "ACT";
 };
+/**
+ * Execution Cycle Phases
+ *
+ * The 4-step execution pattern: THINK → ACT → OBSERVE → ADJUST
+ */
+export declare const EXECUTION_CYCLE: {
+    readonly THINK: "THINK";
+    readonly ACT: "ACT";
+    readonly OBSERVE: "OBSERVE";
+    readonly ADJUST: "ADJUST";
+};
+export declare const EXECUTION_CYCLE_STEPS: string;
 /**
  * Core philosophy tagline
  */

package/dist/shared/prompt/constants/tags.d.ts

@@ -77,6 +77,10 @@ export declare const PROMPT_TAGS: {
         readonly open: "<loop_continuation>";
         readonly close: "</loop_continuation>";
     };
+    readonly RECOVERY: {
+        readonly open: "<recovery>";
+        readonly close: "</recovery>";
+    };
     readonly FILE_LEVEL_PLANNING: {
         readonly open: "<file_level_planning>";
         readonly close: "</file_level_planning>";

package/dist/shared/recovery/constants/index.d.ts

@@ -3,3 +3,4 @@
  */
 export { RECOVERY } from "./recovery.js";
 export { HISTORY } from "./history.js";
+export { RECOVERY_LEVEL, RECOVERY_PRINCIPLE } from "./recovery-level.js";

package/dist/shared/recovery/constants/recovery-level.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Recovery Level Constants
+ *
+ * Escalation levels for agent failure handling.
+ */
+export declare const RECOVERY_LEVEL: {
+    /** Level 1: Split task into smaller units */
+    readonly DECOMPOSE: "DECOMPOSE";
+    /** Level 2: Step back and create new strategy */
+    readonly RE_PLAN: "RE-PLAN";
+    /** Level 3: Ask user for direction */
+    readonly ASK_USER: "ASK USER";
+};
+export declare const RECOVERY_PRINCIPLE = "DECOMPOSE \u2192 RE-PLAN \u2192 ASK. Never give up silently.";
+export type RecoveryLevel = (typeof RECOVERY_LEVEL)[keyof typeof RECOVERY_LEVEL];

package/dist/shared/tool/constants/tool-names.d.ts

@@ -13,6 +13,13 @@ export declare const TOOL_NAMES: {
     readonly GREP_SEARCH: "grep_search";
     readonly GLOB_SEARCH: "glob_search";
     readonly MGREP: "mgrep";
+    readonly SED_REPLACE: "sed_replace";
+    readonly DIFF: "diff";
+    readonly JQ: "jq";
+    readonly HTTP: "http";
+    readonly FILE_STATS: "file_stats";
+    readonly GIT_DIFF: "git_diff";
+    readonly GIT_STATUS: "git_status";
     readonly WEBFETCH: "webfetch";
     readonly WEBSEARCH: "websearch";
     readonly CODESEARCH: "codesearch";

package/dist/tools/search.d.ts

@@ -43,3 +43,124 @@ export declare const mgrepTool: (directory: string) => {
         dir?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+/**
+ * Sed replace tool - find and replace patterns in files
+ * Used for bulk code migrations and refactoring
+ */
+export declare const sedReplaceTool: (directory: string) => {
+    description: string;
+    args: {
+        pattern: import("zod").ZodString;
+        replacement: import("zod").ZodString;
+        file: import("zod").ZodOptional<import("zod").ZodString>;
+        dir: import("zod").ZodOptional<import("zod").ZodString>;
+        dry_run: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        backup: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        pattern: string;
+        replacement: string;
+        file?: string | undefined;
+        dir?: string | undefined;
+        dry_run?: boolean | undefined;
+        backup?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Diff tool - compare files or strings
+ */
+export declare const diffTool: () => {
+    description: string;
+    args: {
+        file1: import("zod").ZodOptional<import("zod").ZodString>;
+        file2: import("zod").ZodOptional<import("zod").ZodString>;
+        content1: import("zod").ZodOptional<import("zod").ZodString>;
+        content2: import("zod").ZodOptional<import("zod").ZodString>;
+        ignore_whitespace: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        file1?: string | undefined;
+        file2?: string | undefined;
+        content1?: string | undefined;
+        content2?: string | undefined;
+        ignore_whitespace?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * JQ tool - JSON query and manipulation
+ */
+export declare const jqTool: () => {
+    description: string;
+    args: {
+        json_input: import("zod").ZodOptional<import("zod").ZodString>;
+        file: import("zod").ZodOptional<import("zod").ZodString>;
+        expression: import("zod").ZodString;
+        raw_output: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        expression: string;
+        json_input?: string | undefined;
+        file?: string | undefined;
+        raw_output?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * HTTP tool - make HTTP requests (curl-like)
+ */
+export declare const httpTool: () => {
+    description: string;
+    args: {
+        url: import("zod").ZodString;
+        method: import("zod").ZodOptional<import("zod").ZodString>;
+        headers: import("zod").ZodOptional<import("zod").ZodObject<{}, import("zod/v4/core").$strip>>;
+        body: import("zod").ZodOptional<import("zod").ZodString>;
+        timeout_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        url: string;
+        method?: string | undefined;
+        headers?: Record<string, never> | undefined;
+        body?: string | undefined;
+        timeout_ms?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * File stats tool - analyze directory/file statistics
+ */
+export declare const fileStatsTool: (directory: string) => {
+    description: string;
+    args: {
+        dir: import("zod").ZodOptional<import("zod").ZodString>;
+        max_depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        dir?: string | undefined;
+        max_depth?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Git diff tool - show uncommitted changes
+ */
+export declare const gitDiffTool: (directory: string) => {
+    description: string;
+    args: {
+        dir: import("zod").ZodOptional<import("zod").ZodString>;
+        staged_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        dir?: string | undefined;
+        staged_only?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Git status tool - show repository status
+ */
+export declare const gitStatusTool: (directory: string) => {
+    description: string;
+    args: {
+        dir: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        dir?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};

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.9.44",
+  "version": "0.9.50",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {