opencode-orchestrator 0.5.1 → 0.5.3

package/dist/index.d.ts

@@ -13,6 +13,24 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
     tool: {
+        git_branch: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    status: "status";
+                    diff: "diff";
+                    current: "current";
+                    list: "list";
+                    recent: "recent";
+                    all: "all";
+                }>;
+                baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                action: "status" | "diff" | "current" | "list" | "recent" | "all";
+                baseBranch?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
         call_agent: {
             description: string;
             args: {
@@ -108,13 +126,13 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
             args: {
                 status: import("zod").ZodOptional<import("zod").ZodEnum<{
                     running: "running";
+                    all: "all";
                     done: "done";
                     error: "error";
-                    all: "all";
                 }>>;
             };
             execute(args: {
-                status?: "running" | "done" | "error" | "all" | undefined;
+                status?: "running" | "all" | "done" | "error" | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         kill_background: {
@@ -139,7 +157,8 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
         output: string;
         metadata: any;
     }) => Promise<void>;
-    event: (input: {
+    "assistant.done": (assistantInput: any, assistantOutput: any) => Promise<void>;
+    handler: ({ event }: {
         event: {
             type: string;
             properties?: unknown;

package/dist/index.js

@@ -13798,6 +13798,206 @@ Returns matches grouped by pattern, with file paths and line numbers.
   }
 });
 
+// src/tools/git.ts
+var gitBranchTool = (directory) => tool({
+  description: `Get Git branch information and status.
+
+<purpose>
+Analyze current Git workspace context including:
+- Current branch name
+- All branches (local and remote)
+- Branch relationships (upstream, ahead/behind)
+- Staged, unstaged, and untracked files
+- Recent commits
+</purpose>
+
+<examples>
+- Get current branch: Returns branch name and status
+- List all branches: Shows local and remote branches
+- Check status: Shows modified files
+- Recent commits: Last 5 commits with file changes
+</examples>
+
+<output>
+Returns structured Git information for better code decisions.
+</output>`,
+  args: {
+    action: tool.schema.enum([
+      "current",
+      "list",
+      "status",
+      "diff",
+      "recent",
+      "all"
+    ]).describe("Action to perform: current, list, status, diff, recent, all"),
+    baseBranch: tool.schema.string().optional().describe("Base branch for comparison (e.g., 'main', 'develop'). Required for diff action.")
+  },
+  async execute(args) {
+    const { action, baseBranch } = args;
+    try {
+      switch (action) {
+        case "current":
+          return await getCurrentBranch(directory);
+        case "list":
+          return await listBranches(directory);
+        case "status":
+          return await getGitStatus(directory);
+        case "diff":
+          return await getDiff(directory, baseBranch);
+        case "recent":
+          return await getRecentCommits(directory, 5);
+        case "all":
+          return await getAllInfo(directory);
+        default:
+          return await getCurrentBranch(directory);
+      }
+    } catch (error45) {
+      return "\u274C Git error: " + (error45 instanceof Error ? error45.message : String(error45));
+    }
+  }
+});
+async function execGit(directory, args) {
+  const { execSync } = await import("child_process");
+  try {
+    return execSync("git " + args.join(" "), {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    }).toString();
+  } catch (error45) {
+    if (error45.status === 128) {
+      throw new Error("Not a git repository");
+    }
+    throw error45;
+  }
+}
+async function getAheadBehind(directory, branch) {
+  try {
+    const output = await execGit(directory, ["rev-list", "--left-right", "--count", branch + "...@{u}"]);
+    const parts = output.trim().split(/\s+/);
+    const ahead = parseInt(parts[0], 10);
+    const behind = parseInt(parts[1] || "0", 10);
+    const resultParts = [];
+    if (ahead > 0) resultParts.push(ahead + " ahead");
+    if (behind > 0) resultParts.push(behind + " behind");
+    return resultParts.length > 0 ? "| **Sync** | " + resultParts.join(", ") + " |" : "";
+  } catch {
+    return "";
+  }
+}
+async function getCurrentBranch(directory) {
+  const output = await execGit(directory, ["branch", "--show-current"]);
+  const current = output.trim() || "HEAD (detached)";
+  const upstream = await execGit(directory, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]).catch(() => "");
+  return "\u{1F33F} **Current Branch**: `" + current + "`\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + (upstream ? "| **Upstream** | `" + upstream + "` |" : "") + await getAheadBehind(directory, current);
+}
+async function listBranches(directory) {
+  const branches = await execGit(directory, ["branch", "-vv"]);
+  const branchList = branches.split("\n").filter((b) => b.trim()).map((b) => {
+    const isCurrent = b.startsWith("*");
+    const name = isCurrent ? b.substring(2).trim() : b.trim();
+    const parts = name.split(/\s+/);
+    const branchName = parts[0];
+    const upstream = parts[1] ? parts[1].match(/\[([^\]]+)\]/)?.[1] : void 0;
+    const icon = isCurrent ? "\u{1F33F}" : "\u{1F4C2}";
+    const status = isCurrent ? "(current)" : "";
+    const upstreamInfo = upstream ? "\u2192 " + upstream : "";
+    return icon + " `" + branchName + "` " + status + " " + upstreamInfo;
+  }).join("\n");
+  return "\u{1F33F} **All Branches**\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + branchList;
+}
+async function getGitStatus(directory) {
+  const status = await execGit(directory, ["status", "--porcelain"]);
+  const lines = status.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) {
+    return "\u2705 Working directory clean";
+  }
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  const conflicted = [];
+  for (const line of lines) {
+    if (!line || line.length < 2) continue;
+    const statusCode = line.substring(0, 2);
+    const filename = line.substring(3);
+    if (statusCode === "??") {
+      untracked.push(filename);
+    } else if (statusCode.startsWith("U") || statusCode === "AA") {
+      conflicted.push(filename);
+    } else if (statusCode[0] !== " ") {
+      staged.push(filename);
+    }
+    if (statusCode[1] !== " " && statusCode[1] !== "?") {
+      unstaged.push(filename);
+    }
+  }
+  const current = await execGit(directory, ["branch", "--show-current"]).catch(() => "unknown");
+  let result = "\u{1F33F} **Branch**: `" + current + "`\n\n";
+  if (staged.length > 0) {
+    result += "\u2705 **Staged** (" + staged.length + ")\n" + staged.map((f) => "  + " + f).join("\n") + "\n\n";
+  }
+  if (unstaged.length > 0) {
+    result += "\u{1F4DD} **Modified** (" + unstaged.length + ")\n" + unstaged.map((f) => "  ~ " + f).join("\n") + "\n\n";
+  }
+  if (untracked.length > 0) {
+    result += "\u2795 **Untracked** (" + untracked.length + ")\n" + untracked.slice(0, 10).map((f) => "  ? " + f).join("\n") + (untracked.length > 10 ? "\n  ... and " + (untracked.length - 10) + " more" : "") + "\n\n";
+  }
+  if (conflicted.length > 0) {
+    result += "\u26A0\uFE0F **Conflicts** (" + conflicted.length + ")\n" + conflicted.map((f) => "  ! " + f).join("\n") + "\n\n";
+  }
+  return result.trim();
+}
+async function getDiff(directory, baseBranch) {
+  const current = await execGit(directory, ["branch", "--show-current"]).catch(() => "HEAD");
+  const base = baseBranch || "main";
+  const diff = await execGit(directory, ["diff", base + "..." + current, "--stat"]);
+  if (!diff.trim()) {
+    return "\u2705 No differences between `" + current + "` and `" + base + "`";
+  }
+  const files = await execGit(directory, ["diff", base + "..." + current, "--name-only"]);
+  const fileList = files.split("\n").filter((f) => f.trim());
+  return "\u{1F4CA} **Diff**: `" + current + "` vs `" + base + "`\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n" + diff + "\n\n\u{1F4C1} **Changed Files** (" + fileList.length + "):\n" + fileList.map((f, i) => "  " + (i + 1) + ". " + f).join("\n");
+}
+async function getRecentCommits(directory, count = 5) {
+  const log2 = await execGit(directory, [
+    "log",
+    "-" + count,
+    "--pretty=format:%H|%an|%ad|%s",
+    "--date=short",
+    "--name-only"
+  ]);
+  const blocks = log2.split("\n\n").filter((b) => b.trim());
+  const commits = [];
+  for (const block of blocks) {
+    const lines = block.split("\n").filter((l) => l.trim());
+    if (lines.length < 2) continue;
+    const [hash2, author, date5, message] = lines[0].split("|");
+    const files = lines.slice(1);
+    commits.push({
+      hash: hash2.substring(0, 7),
+      author,
+      date: date5,
+      message,
+      files
+    });
+  }
+  let result = "\u{1F4DC} **Recent Commits** (last " + commits.length + ")\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n";
+  for (const commit of commits) {
+    result += "\n\u{1F539} `" + commit.hash + "` - " + commit.message + "\n";
+    result += "   \u{1F464} " + commit.author + " | \u{1F4C5} " + commit.date + "\n";
+    result += "   \u{1F4C1} " + commit.files.length + " file" + (commit.files.length > 1 ? "s" : "") + "\n";
+  }
+  return result;
+}
+async function getAllInfo(directory) {
+  const current = await getCurrentBranch(directory);
+  const status = await getGitStatus(directory);
+  const recent = await getRecentCommits(directory, 3);
+  return "\u{1F50D} **Full Git Context**\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n\n" + current + "\n\n" + status + "\n\n" + recent;
+}
+
 // src/core/background.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
@@ -15474,6 +15674,476 @@ function createAsyncAgentTools(manager, client) {
   };
 }
 
+// src/core/batch-processor.ts
+var SmartBatchProcessor = class {
+  parallelAgentManager;
+  tasks = /* @__PURE__ */ new Map();
+  constructor(parallelAgentManager2) {
+    this.parallelAgentManager = parallelAgentManager2;
+  }
+  /**
+   * Process a batch of tasks with smart validation
+   */
+  async processBatch(tasks, options = {
+    concurrency: 3,
+    maxRetries: 2,
+    validateAfterEach: false,
+    continueOnError: true
+  }) {
+    const startTime = Date.now();
+    for (const task of tasks) {
+      this.tasks.set(task.id, {
+        ...task,
+        status: "pending",
+        attempts: 0
+      });
+    }
+    console.log(`
+\u{1F4E6} [Smart Batch] Starting ${tasks.length} tasks with concurrency ${options.concurrency}`);
+    console.log(`   Strategy: ${options.validateAfterEach ? "Validate each" : "Centralized validation"}`);
+    await this.executePhase(tasks, options, "initial");
+    const failedTasks = Array.from(this.tasks.values()).filter((t) => t.status === "failed" || t.status === "pending");
+    if (failedTasks.length === 0) {
+      console.log(`
+\u2705 [Smart Batch] All ${tasks.length} tasks succeeded!`);
+      return this.buildResult(startTime, tasks);
+    }
+    console.log(`
+\u{1F50D} [Smart Batch] Validation complete: ${failedTasks.length}/${tasks.length} tasks need retry`);
+    let retryCount = 0;
+    while (failedTasks.length > 0 && retryCount < options.maxRetries) {
+      retryCount++;
+      console.log(`
+\u{1F504} [Smart Batch] Retry round ${retryCount}/${options.maxRetries} for ${failedTasks.length} tasks`);
+      await this.executePhase(failedTasks, options, `retry-${retryCount}`);
+      const stillFailed = Array.from(this.tasks.values()).filter((t) => t.status === "failed");
+      if (stillFailed.length === failedTasks.length) {
+        console.log(`\u26A0\uFE0F [Smart Batch] No progress in retry round ${retryCount}, stopping`);
+        break;
+      }
+    }
+    return this.buildResult(startTime, tasks);
+  }
+  /**
+   * Execute a phase with concurrency control
+   */
+  async executePhase(tasks, options, phase) {
+    for (const task of tasks) {
+      this.parallelAgentManager.setConcurrencyLimit(task.agent, options.concurrency);
+    }
+    const batches = [];
+    for (let i = 0; i < tasks.length; i += options.concurrency) {
+      batches.push(tasks.slice(i, i + options.concurrency));
+    }
+    for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+      const batch = batches[batchIndex];
+      console.log(`   [${phase}] Processing batch ${batchIndex + 1}/${batches.length} (${batch.length} tasks)`);
+      const batchPromises = batch.map((task) => this.executeTask(task, options));
+      await Promise.all(batchPromises);
+      if (!options.validateAfterEach) {
+        continue;
+      }
+      const failedInBatch = batch.filter((t) => t.status === "failed");
+      if (failedInBatch.length > 0) {
+        console.log(`   [${phase}] ${failedInBatch.length} failed in batch, immediate retry`);
+        const retryPromises = failedInBatch.map((t) => this.executeTask(t, options));
+        await Promise.all(retryPromises);
+      }
+    }
+  }
+  /**
+   * Execute a single task
+   */
+  async executeTask(task, options) {
+    const currentTask = this.tasks.get(task.id);
+    if (!options.continueOnError && currentTask.status === "failed") {
+      return;
+    }
+    try {
+      currentTask.attempts++;
+      currentTask.status = "pending";
+      const launched = await this.parallelAgentManager.launch({
+        agent: task.agent,
+        description: task.description,
+        prompt: task.prompt,
+        parentSessionID: ""
+        // Would need actual parent ID
+      });
+      const maxWaitTime = 5 * 60 * 1e3;
+      const startTime = Date.now();
+      while (Date.now() - startTime < maxWaitTime) {
+        const taskData = this.parallelAgentManager.getTask(launched.id);
+        if (!taskData) break;
+        if (taskData.status === "completed") {
+          currentTask.status = "success";
+          console.log(`   \u2705 [${task.id}] Success on attempt ${currentTask.attempts}`);
+          return;
+        }
+        if (taskData.status === "error" || taskData.status === "timeout") {
+          currentTask.status = "failed";
+          currentTask.error = taskData.error || "Unknown error";
+          console.log(`   \u274C [${task.id}] Failed: ${currentTask.error}`);
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+      currentTask.status = "failed";
+      currentTask.error = "Timeout";
+    } catch (error45) {
+      currentTask.status = "failed";
+      currentTask.error = error45 instanceof Error ? error45.message : String(error45);
+      console.log(`   \u274C [${task.id}] Exception: ${currentTask.error}`);
+    }
+  }
+  /**
+   * Build result summary
+   */
+  buildResult(startTime, tasks) {
+    const allTasks = Array.from(this.tasks.values());
+    const successCount = allTasks.filter((t) => t.status === "success").length;
+    const failedCount = allTasks.filter((t) => t.status === "failed").length;
+    const retriedCount = allTasks.filter((t) => t.attempts > 1).length;
+    return {
+      total: tasks.length,
+      success: successCount,
+      failed: failedCount,
+      retried: retriedCount,
+      duration: Date.now() - startTime,
+      tasks: allTasks
+    };
+  }
+  /**
+   * Export failed tasks for manual review
+   */
+  exportFailedTasks() {
+    const failedTasks = Array.from(this.tasks.values()).filter((t) => t.status === "failed");
+    if (failedTasks.length === 0) {
+      return "\u2705 No failed tasks to export.";
+    }
+    const output = failedTasks.map((task) => {
+      return `
+---
+Task ID: ${task.id}
+Agent: ${task.agent}
+Attempts: ${task.attempts}
+Error: ${task.error}
+Description: ${task.description}
+---
+      `.trim();
+    }).join("\n");
+    return `\u274C ${failedTasks.length} failed tasks:
+${output}`;
+  }
+  /**
+   * Clear all tasks
+   */
+  clear() {
+    this.tasks.clear();
+  }
+};
+
+// src/tools/batch.ts
+var createProcessBatchTool = (parallelAgentManager2, client) => tool({
+  description: `Execute a batch of tasks with intelligent validation and retry.
+
+<strategy>
+1. Execute all tasks in parallel (respecting concurrency limits)
+2. Centralized validation: Identify ALL failed tasks at once
+3. Retry ONLY failed tasks (not everything)
+</strategy>
+
+<benefits>
+- Faster than naive retry: Failed tasks batch-identified
+- More efficient: No redundant work on successful tasks
+- Controlled: Concurrency limits prevent API overload
+</benefits>
+
+<examples>
+process_batch({
+  concurrency: 10,
+  tasks: [
+    { id: "task1", agent: "builder", description: "Test A", prompt: "..." },
+    { id: "task2", agent: "inspector", description: "Test B", prompt: "..." }
+  ]
+})
+</examples>`,
+  args: {
+    concurrency: tool.schema.string().describe("Concurrency limit (default: 3, max: 10)"),
+    maxRetries: tool.schema.string().optional().describe("Maximum retry rounds (default: 2)"),
+    validateAfterEach: tool.schema.boolean().optional().describe("Validate after each task (default: false = centralized validation)"),
+    tasks: tool.schema.string().describe("Array of task objects in JSON format")
+  },
+  async execute(args) {
+    const { concurrency, maxRetries = "2", validateAfterEach = false, tasks } = args;
+    let taskList;
+    try {
+      taskList = JSON.parse(tasks);
+    } catch {
+      return "\u274C Invalid tasks JSON. Must be valid array.";
+    }
+    if (!Array.isArray(taskList)) {
+      return "\u274C tasks must be an array of task objects.";
+    }
+    for (const task of taskList) {
+      if (!task.id || !task.agent || !task.description || !task.prompt) {
+        return `\u274C Task missing required fields (id, agent, description, prompt)`;
+      }
+    }
+    const numConcurrency = parseInt(concurrency, 10);
+    const numRetries = parseInt(maxRetries, 10);
+    if (isNaN(numConcurrency) || numConcurrency < 1 || numConcurrency > 10) {
+      return "\u274C Invalid concurrency. Must be 1-10.";
+    }
+    if (isNaN(numRetries) || numRetries < 0 || numRetries > 5) {
+      return "\u274C Invalid maxRetries. Must be 0-5.";
+    }
+    const processor = new SmartBatchProcessor(parallelAgentManager2);
+    const result = await processor.processBatch(taskList, {
+      concurrency: numConcurrency,
+      maxRetries: numRetries,
+      validateAfterEach,
+      continueOnError: true
+    });
+    const durationSecs = Math.floor(result.duration / 1e3);
+    const successRate = (result.success / result.total * 100).toFixed(1);
+    let output = `\u2705 **Batch Processing Complete**
+
+| Metric | Value |
+|---------|--------|
+| **Total Tasks** | ${result.total} |
+| **Successful** | ${result.success} (${successRate}%) |
+| **Failed** | ${result.failed} |
+| **Retried** | ${result.retried} |
+| **Duration** | ${durationSecs}s |
+
+`;
+    if (result.failed > 0) {
+      output += `\u26A0\uFE0F **Failed Tasks**
+
+Use \`export_failed_tasks()\` to review failed tasks and manually fix issues.
+
+---
+
+Failed Task IDs:
+${result.tasks.filter((t) => t.status === "failed").map((t) => `  - ${t.id}`).join("\n")}
+---
+`;
+    }
+    return output;
+  }
+});
+var createExportFailedTasksTool = (parallelAgentManager2) => tool({
+  description: `Export failed tasks from the last batch for manual review.`,
+  args: {},
+  async execute() {
+    const processor = new SmartBatchProcessor(parallelAgentManager2);
+    return processor.exportFailedTasks();
+  }
+});
+var createCompareStrategiesTool = (parallelAgentManager2) => tool({
+  description: `Compare naive retry vs smart batch validation performance.
+
+<comparison>
+**Naive Strategy** (current):
+- Concurrency: 3 fixed
+- Retry: Per-task immediate retry
+- Issue: Slow for large batches, redundant work
+
+**Smart Batch Strategy** (new):
+- Concurrency: Configurable (up to 10)
+- Validation: Centralized, batch-identify failures
+- Retry: Only failed tasks
+- Benefit: Faster, less redundant work
+</comparison>`,
+  args: {
+    taskCount: tool.schema.string().describe("Number of simulated tasks (default: 100)"),
+    concurrency1: tool.schema.string().optional().describe("Strategy 1 concurrency (default: 3)"),
+    concurrency2: tool.schema.string().optional().describe("Strategy 2 concurrency (default: 10)")
+  },
+  async execute(args) {
+    const taskCount = parseInt(args.taskCount || "100", 10);
+    const concurrency1 = parseInt(args.concurrency1 || "3", 10);
+    const concurrency2 = parseInt(args.concurrency2 || "10", 10);
+    const naiveBatches = Math.ceil(taskCount / concurrency1);
+    const naiveTime = naiveBatches * 60;
+    const smartBatches = Math.ceil(taskCount / concurrency2);
+    const smartTime = smartBatches * 60 + 30;
+    const timeDiff = naiveTime - smartTime;
+    const improvement = (timeDiff / naiveTime * 100).toFixed(1);
+    return `\u{1F4CA} **Strategy Comparison for ${taskCount} tasks**
+
+**Strategy 1: Naive (Current)**
+| Metric | Value |
+|---------|--------|
+| Concurrency | ${concurrency1} |
+| Batches | ${naiveBatches} |
+| Est. Time | ${naiveTime}s |
+
+**Strategy 2: Smart Batch (Proposed)**
+| Metric | Value |
+|---------|--------|
+| Concurrency | ${concurrency2} |
+| Batches | ${smartBatches} |
+| Est. Time | ${smartTime}s |
+
+**Summary**
+| Metric | Value |
+|---------|--------|
+| Time Saved | ${timeDiff}s (${improvement}%) |
+| Batches Saved | ${naiveBatches - smartBatches} |
+
+Recommendation: Use **Smart Batch** with concurrency ${concurrency2} for ${timeDiff}s improvement.`;
+  }
+});
+function createBatchTools(parallelAgentManager2, client) {
+  return {
+    process_batch: createProcessBatchTool(parallelAgentManager2, client),
+    export_failed_tasks: createExportFailedTasksTool(parallelAgentManager2),
+    compare_strategies: createCompareStrategiesTool(parallelAgentManager2)
+  };
+}
+
+// src/tools/config.ts
+var createShowConfigTool = () => tool({
+  description: `Display current OpenCode Orchestrator configuration.
+
+Shows all dynamic settings including timeouts, concurrency limits, and debug flags.`,
+  args: {},
+  async execute() {
+    configManager.exportConfigs();
+    return "";
+  }
+});
+var createSetConcurrencyTool = (client) => tool({
+  description: `Update concurrency limit for a specific agent type.
+
+<examples>
+set_concurrency({ agent: "builder", limit: 5 })
+set_concurrency({ agent: "inspector", limit: 2 })
+</examples>
+
+<notes>
+- Changes take effect immediately
+- Queued tasks will start when slots become available
+- Limit cannot exceed global max (10)
+</notes>`,
+  args: {
+    agent: tool.schema.string().describe('Agent type (e.g., "builder", "inspector", "architect")'),
+    limit: tool.schema.string().describe("New concurrency limit (number)")
+  },
+  async execute(args) {
+    const { agent, limit } = args;
+    const numLimit = parseInt(limit, 10);
+    if (isNaN(numLimit) || numLimit < 1) {
+      return `\u274C Invalid limit: "${limit}". Must be a number >= 1.`;
+    }
+    const maxLimit = configManager.getParallelAgentConfig().maxConcurrency;
+    if (numLimit > maxLimit) {
+      return `\u274C Limit ${numLimit} exceeds global max ${maxLimit}. Using ${maxLimit}.`;
+    }
+    configManager.updateParallelAgentConfig({
+      defaultConcurrency: numLimit
+    });
+    return `\u2705 **Concurrency Updated**
+
+| Property | Value |
+|----------|-------|
+| **Agent** | ${agent} |
+| **New Limit** | ${numLimit} parallel tasks |
+
+Changes take effect immediately. New tasks will respect to the new limit.`;
+  }
+});
+var createSetTimeoutTool = () => tool({
+  description: `Update task timeout duration.
+
+<examples>
+set_timeout({ taskTtlMinutes: 45 })
+set_timeout({ cleanupDelayMinutes: 2 })
+</examples>`,
+  args: {
+    taskTtlMinutes: tool.schema.string().optional().describe("Task timeout in minutes (default: 30)"),
+    cleanupDelayMinutes: tool.schema.string().optional().describe("Cleanup delay after completion in minutes (default: 5)")
+  },
+  async execute(args) {
+    const { taskTtlMinutes, cleanupDelayMinutes } = args;
+    const updates = {};
+    if (taskTtlMinutes) {
+      const ttl = parseInt(taskTtlMinutes, 10);
+      if (isNaN(ttl) || ttl < 1) {
+        return `\u274C Invalid taskTtlMinutes: "${taskTtlMinutes}". Must be number >= 1.`;
+      }
+      updates.taskTtlMs = ttl * 60 * 1e3;
+    }
+    if (cleanupDelayMinutes) {
+      const delay = parseInt(cleanupDelayMinutes, 10);
+      if (isNaN(delay) || delay < 0) {
+        return `\u274C Invalid cleanupDelayMinutes: "${cleanupDelayMinutes}". Must be number >= 0.`;
+      }
+      updates.cleanupDelayMs = delay * 60 * 1e3;
+    }
+    if (Object.keys(updates).length === 0) {
+      return "\u26A0\uFE0F No changes specified. Provide at least one parameter.";
+    }
+    configManager.updateParallelAgentConfig(updates);
+    let output = "\u2705 **Timeout Configuration Updated**\n\n";
+    if (updates.taskTtlMs) {
+      output += `| Task TTL | ${updates.taskTtlMs / 60 / 1e3} minutes |
+`;
+    }
+    if (updates.cleanupDelayMs) {
+      output += `| Cleanup Delay | ${updates.cleanupDelayMs / 60 / 1e3} minutes |
+`;
+    }
+    output += "\nChanges take effect immediately.";
+    return output;
+  }
+});
+var createSetDebugTool = () => tool({
+  description: `Enable or disable debug logging.
+
+<examples>
+set_debug({ component: "parallel_agent", enable: true })
+set_debug({ component: "background_task", enable: false })
+</examples>`,
+  args: {
+    component: tool.schema.string().describe('Component to debug: "parallel_agent", "background_task", or "all"'),
+    enable: tool.schema.boolean().describe("Enable (true) or disable (false) debug logs")
+  },
+  async execute(args) {
+    const { component, enable } = args;
+    const enableValue = enable ? "true" : "false";
+    if (component === "parallel_agent" || component === "all") {
+      process.env.OPENCODE_DEBUG_PARALLEL = enableValue;
+      configManager.updateParallelAgentConfig({
+        enableDebug: enable
+      });
+    }
+    if (component === "background_task" || component === "all") {
+      process.env.OPENCODE_DEBUG_BACKGROUND = enableValue;
+      configManager.updateBackgroundTaskConfig({
+        enableDebug: enable
+      });
+    }
+    return `\u2705 **Debug Logging ${enable ? "Enabled" : "Disabled"}**
+
+| Component | Debug Status |
+|-----------|--------------|
+| ${component === "all" ? "parallel_agent" : component} | ${enable ? "\u{1F527} Enabled" : "\u{1F507} Disabled"} |
+${component === "all" ? "| background_task | \u{1F527} Enabled |" : ""}
+
+Changes take effect immediately.`;
+  }
+});
+function createConfigTools(client) {
+  return {
+    show_config: createShowConfigTool(),
+    set_concurrency: createSetConcurrencyTool(client),
+    set_timeout: createSetTimeoutTool(),
+    set_debug: createSetDebugTool()
+  };
+}
+
 // src/utils/common.ts
 function detectSlashCommand(text) {
   const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
@@ -15498,7 +16168,7 @@ function formatElapsedTime(startMs, endMs = Date.now()) {
 }
 
 // src/index.ts
-var PLUGIN_VERSION = "0.4.26";
+var PLUGIN_VERSION = "0.2.4";
 var DEFAULT_MAX_STEPS = 500;
 var TASK_COMMAND_MAX_STEPS = 1e3;
 var AGENT_EMOJI2 = {
@@ -15508,12 +16178,30 @@ var AGENT_EMOJI2 = {
   [AGENT_NAMES.RECORDER]: "\u{1F4BE}",
   [AGENT_NAMES.COMMANDER]: "\u{1F3AF}"
 };
+var CONTINUE_INSTRUCTION = `<auto_continue>
+<status>Mission not complete. Keep executing.</status>
+
+<rules>
+1. DO NOT stop - mission is incomplete
+2. DO NOT wait for user input
+3. If previous action failed, try different approach
+4. If agent returned nothing, proceed to next step
+</rules>
+
+<next_step>
+What is the current state?
+What is the next action?
+Execute it NOW.
+</next_step>
+</auto_continue>`;
 var OrchestratorPlugin = async (input) => {
   const { directory, client } = input;
   console.log(`[orchestrator] v${PLUGIN_VERSION} loaded`);
   const sessions = /* @__PURE__ */ new Map();
   const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
+  const batchTools = createBatchTools(parallelAgentManager2, client);
+  const configTools = createConfigTools(client);
   return {
     // -----------------------------------------------------------------
     // Tools we expose to the LLM
@@ -15531,13 +16219,13 @@ var OrchestratorPlugin = async (input) => {
       list_background: listBackgroundTool,
       kill_background: killBackgroundTool,
       // Async agent tools - spawn agents in parallel sessions
-      ...asyncAgentTools
+      ...asyncAgentTools,
       // Git tools - branch info and status
-      // git_branch: gitBranchTool(directory),
+      git_branch: gitBranchTool(directory),
       // Smart batch tools - centralized validation and retry
-      // ...batchTools,
+      ...batchTools,
       // Configuration tools - dynamic runtime settings
-      // ...configTools,
+      ...configTools
     },
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode
@@ -15748,17 +16436,107 @@ ${stateSession.graph.getTaskSummary()}`;
 \u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | This step: ${stepDuration} | Total: ${totalElapsed}`;
     },
     // -----------------------------------------------------------------
-    // NOTE: assistant.done hook has been REMOVED
-    // It was NOT in the official OpenCode plugin API and was causing
-    // UI rendering issues. The "relentless loop" feature needs to be
-    // reimplemented using supported hooks like tool.execute.after
-    // or the event hook.
+    // 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;
+        sessions.delete(sessionID);
+        state.sessions.delete(sessionID);
+        return;
+      }
+      if (textContent.includes("/stop") || textContent.includes("/cancel")) {
+        session.active = false;
+        state.missionActive = false;
+        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;
+      }
+      try {
+        if (client?.session?.prompt) {
+          await client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [{
+                type: "text",
+                text: CONTINUE_INSTRUCTION + `
+
+\u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | 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: "text", text: "continue" }] }
+            });
+          }
+        } catch {
+          session.active = false;
+          state.missionActive = false;
+        }
+      }
+    },
     // -----------------------------------------------------------------
     // Event handler - cleans up when sessions are deleted
     // -----------------------------------------------------------------
-    event: async (input2) => {
-      const { event } = input2;
+    handler: async ({ event }) => {
       if (event.type === "session.deleted") {
         const props = event.properties;
         if (props?.info?.id) {

package/dist/tools/background.d.ts

@@ -37,13 +37,13 @@ export declare const listBackgroundTool: {
     args: {
         status: import("zod").ZodOptional<import("zod").ZodEnum<{
             running: "running";
+            all: "all";
             done: "done";
             error: "error";
-            all: "all";
         }>>;
     };
     execute(args: {
-        status?: "running" | "done" | "error" | "all" | undefined;
+        status?: "running" | "all" | "done" | "error" | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare const killBackgroundTool: {

package/dist/tools/git.d.ts

@@ -33,16 +33,16 @@ export declare const gitBranchTool: (directory: string) => {
     args: {
         action: import("zod").ZodEnum<{
             status: "status";
-            all: "all";
             diff: "diff";
             current: "current";
             list: "list";
             recent: "recent";
+            all: "all";
         }>;
         baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
     };
     execute(args: {
-        action: "status" | "all" | "diff" | "current" | "list" | "recent";
+        action: "status" | "diff" | "current" | "list" | "recent" | "all";
         baseBranch?: 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.5.1",
+  "version": "0.5.3",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {
@@ -51,8 +51,7 @@
     "dev:status": "echo '=== Global Link Status ===' && shx ls -l $(npm root -g)/opencode-orchestrator || echo 'Not linked'",
     "dev:test": "node dist/scripts/postinstall.js && echo '---' && node dist/scripts/preuninstall.js",
     "delete": "brew uninstall opencode && rm -rf ~/.config/opencode && npm uninstall -g opencode-orchestrator",
-    "setup": "brew install opencode && npm run dev:link",
-    "set": "npm run delete && npm run setup"
+    "install": "brew install opencode && npm install -g opencode-orchestrator"
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.1",