opencode-orchestrator 0.4.21 → 0.4.23

package/dist/index.d.ts

@@ -13,24 +13,6 @@
 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: {
@@ -126,13 +108,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" | "all" | "done" | "error" | undefined;
+                status?: "running" | "done" | "error" | "all" | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         kill_background: {
@@ -157,8 +139,7 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
         output: string;
         metadata: any;
     }) => Promise<void>;
-    "assistant.done": (assistantInput: any, assistantOutput: any) => Promise<void>;
-    handler: ({ event }: {
+    event: (input: {
         event: {
             type: string;
             properties?: unknown;

package/dist/index.js

@@ -13798,206 +13798,6 @@ 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";
@@ -15674,476 +15474,6 @@ 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+(.*))?$/);
@@ -16178,30 +15508,12 @@ 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
@@ -16219,13 +15531,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
@@ -16436,107 +15748,17 @@ ${stateSession.graph.getTaskSummary()}`;
 \u23F1\uFE0F [${currentTime}] Step ${session.step}/${session.maxSteps} | This step: ${stepDuration} | Total: ${totalElapsed}`;
     },
     // -----------------------------------------------------------------
-    // 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
+    // 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": 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
     // -----------------------------------------------------------------
-    handler: async ({ event }) => {
+    event: async (input2) => {
+      const { event } = input2;
       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" | "all" | "done" | "error" | undefined;
+        status?: "running" | "done" | "error" | "all" | 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" | "diff" | "current" | "list" | "recent" | "all";
+        action: "status" | "all" | "diff" | "current" | "list" | "recent";
         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.4.21",
+  "version": "0.4.23",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {
@@ -51,7 +51,8 @@
     "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 install -g opencode-orchestrator"
+    "setup": "brew install opencode && npm install -g opencode-orchestrator",
+    "set": "npm run delete && npm run setup"
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.1",