@pruddiman/dispatch 1.5.0-beta.236e011 → 1.5.0-beta.30f06ab

package/dist/cli.js

@@ -7988,6 +7988,7 @@ import { execFile as execFile7 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
+import { rm } from "fs/promises";
 async function git4(args, cwd) {
   const { stdout } = await exec7("git", args, { cwd, shell: process.platform === "win32" });
   return stdout;
@@ -8002,40 +8003,83 @@ async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
   const name = worktreeName(issueFilename);
   const worktreePath = join7(repoRoot, WORKTREE_DIR, name);
   if (existsSync2(worktreePath)) {
-    log.debug(`Reusing existing worktree at ${worktreePath}`);
-    return worktreePath;
+    try {
+      const listOutput = await git4(["worktree", "list", "--porcelain"], repoRoot);
+      const isRegistered = listOutput.includes(`worktree ${worktreePath}
+`);
+      if (isRegistered) {
+        try {
+          await git4(["checkout", "--force", branchName], worktreePath);
+          await git4(["clean", "-fd"], worktreePath);
+          log.debug(`Reusing validated worktree at ${worktreePath}`);
+          return worktreePath;
+        } catch {
+          log.debug(`Worktree checkout failed, removing and recreating: ${worktreePath}`);
+        }
+      } else {
+        log.debug(`Directory exists but not a registered worktree: ${worktreePath}`);
+      }
+    } catch {
+      log.debug(`Worktree validation failed for ${worktreePath}`);
+    }
+    await rm(worktreePath, { recursive: true, force: true });
+    await git4(["worktree", "prune"], repoRoot).catch(() => {
+    });
   }
-  try {
-    const args = ["worktree", "add", worktreePath, "-b", branchName];
-    if (startPoint) args.push(startPoint);
-    await git4(args, repoRoot);
-    log.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
-  } catch (err) {
-    const message = log.extractMessage(err);
-    if (message.includes("already exists")) {
-      try {
-        await git4(["worktree", "add", worktreePath, branchName], repoRoot);
-        log.debug(`Created worktree at ${worktreePath} using existing branch ${branchName}`);
-        return worktreePath;
-      } catch (retryErr) {
-        const retryMsg = log.extractMessage(retryErr);
-        if (retryMsg.includes("already used by worktree")) {
-          await git4(["worktree", "prune"], repoRoot);
+  const MAX_RETRIES = 5;
+  const BASE_DELAY_MS = 200;
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const args = ["worktree", "add", worktreePath, "-b", branchName];
+      if (startPoint) args.push(startPoint);
+      await git4(args, repoRoot);
+      log.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
+      return worktreePath;
+    } catch (err) {
+      lastError = err;
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        try {
+          await git4(["worktree", "add", worktreePath, branchName], repoRoot);
+          log.debug(`Created worktree at ${worktreePath} using existing branch ${branchName}`);
+          return worktreePath;
+        } catch (retryErr) {
+          lastError = retryErr;
+          const retryMsg = log.extractMessage(retryErr);
+          if (retryMsg.includes("already used by worktree")) {
+            await git4(["worktree", "prune"], repoRoot);
+            try {
+              await git4(["worktree", "add", worktreePath, branchName], repoRoot);
+              log.debug(`Created worktree at ${worktreePath} after pruning stale ref`);
+              return worktreePath;
+            } catch (pruneRetryErr) {
+              lastError = pruneRetryErr;
+            }
+          } else {
+            throw retryErr;
+          }
+        }
+      } else if (message.includes("already used by worktree")) {
+        await git4(["worktree", "prune"], repoRoot);
+        try {
           await git4(["worktree", "add", worktreePath, branchName], repoRoot);
           log.debug(`Created worktree at ${worktreePath} after pruning stale ref`);
-        } else {
-          throw retryErr;
+          return worktreePath;
+        } catch (pruneRetryErr) {
+          lastError = pruneRetryErr;
         }
+      } else if (!message.includes("lock") && !message.includes("already")) {
+        throw err;
+      }
+      if (attempt < MAX_RETRIES) {
+        const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+        log.debug(`Worktree creation attempt ${attempt}/${MAX_RETRIES} failed (${message}), retrying in ${delay}ms...`);
+        await new Promise((resolve6) => setTimeout(resolve6, delay));
       }
-    } else if (message.includes("already used by worktree")) {
-      await git4(["worktree", "prune"], repoRoot);
-      await git4(["worktree", "add", worktreePath, branchName], repoRoot);
-      log.debug(`Created worktree at ${worktreePath} after pruning stale ref`);
-    } else {
-      throw err;
     }
   }
-  return worktreePath;
+  throw lastError;
 }
 async function removeWorktree(repoRoot, issueFilename) {
   const name = worktreeName(issueFilename);
@@ -9967,6 +10011,13 @@ async function dispatchTask(instance, task, cwd, plan, worktreeRoot) {
       fileLoggerStorage.getStore()?.warn("dispatchTask: null response");
       return { task, success: false, error: "No response from agent" };
     }
+    const isRateLimited = rateLimitPatterns.some((p) => p.test(response));
+    if (isRateLimited) {
+      const truncated = response.slice(0, 200);
+      log.debug(`Task dispatch hit rate limit: ${truncated}`);
+      fileLoggerStorage.getStore()?.warn(`dispatchTask: rate limit detected \u2014 ${truncated}`);
+      return { task, success: false, error: `Rate limit: ${truncated}` };
+    }
     log.debug(`Task dispatch completed (${response.length} chars response)`);
     fileLoggerStorage.getStore()?.response("dispatchTask", response);
     return { task, success: true };
@@ -10042,12 +10093,19 @@ function buildWorktreeIsolation(worktreeRoot) {
     `- **Worktree isolation:** You are operating inside a git worktree at \`${worktreeRoot}\`. You MUST NOT read, write, or execute commands that access files outside this directory. All file paths must resolve within \`${worktreeRoot}\`.`
   ];
 }
+var rateLimitPatterns;
 var init_dispatcher = __esm({
   "src/dispatcher.ts"() {
     "use strict";
     init_logger();
     init_file_logger();
     init_environment();
+    rateLimitPatterns = [
+      /you[''\u2019]?ve hit your (rate )?limit/i,
+      /rate limit exceeded/i,
+      /too many requests/i,
+      /quota exceeded/i
+    ];
   }
 });
 
@@ -10837,7 +10895,7 @@ ${err.stack}` : ""}`);
             const taskId = buildTaskId(task);
             const taskText = task.text;
             if (type === "task_start") {
-              progressCallback({ type, taskId, taskText, phase: extra?.phase });
+              progressCallback({ type, taskId, taskText, phase: extra?.phase, file: task.file, line: task.line });
             } else if (type === "task_done") {
               progressCallback({ type, taskId, taskText });
             } else {
@@ -11867,6 +11925,12 @@ function registerLiveRun(runId) {
 function unregisterLiveRun(runId) {
   liveRuns.delete(runId);
 }
+function addLogCallback(runId, cb) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    run.callbacks.push(cb);
+  }
+}
 function emitLog(runId, message, level = "info") {
   const run = liveRuns.get(runId);
   if (run) {
@@ -11971,6 +12035,12 @@ function listRunsByStatus(status, limit = 20) {
   ).all(status, limit);
   return rows.map(rowToRun);
 }
+function createTask(opts) {
+  getDb().prepare(`
+    INSERT INTO tasks (run_id, task_id, task_text, file, line, status)
+    VALUES (?, ?, ?, ?, ?, 'pending')
+  `).run(opts.runId, opts.taskId, opts.taskText, opts.file, opts.line);
+}
 function updateTaskStatus(runId, taskId, status, opts) {
   const now = Date.now();
   const isTerminal = status === "success" || status === "failed" || status === "skipped";
@@ -12035,9 +12105,114 @@ var init_manager = __esm({
   }
 });
 
+// src/mcp/tools/_fork-run.ts
+import { fork } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname6, join as join16 } from "path";
+function forkDispatchRun(runId, server, workerMessage, options) {
+  wireRunLogs(runId, server);
+  const worker = fork(WORKER_PATH, [], { stdio: ["pipe", "pipe", "pipe", "ipc"] });
+  worker.send(workerMessage);
+  const heartbeat = setInterval(() => {
+    emitLog(runId, `Run ${runId} still in progress...`);
+  }, HEARTBEAT_INTERVAL_MS);
+  worker.on("message", (msg) => {
+    const msgType = msg["type"];
+    switch (msgType) {
+      case "progress": {
+        const event = msg["event"];
+        const eventType = event["type"];
+        switch (eventType) {
+          case "task_start":
+            createTask({
+              runId,
+              taskId: event["taskId"],
+              taskText: event["taskText"],
+              file: event["file"] ?? event["taskId"].split(":")[0] ?? "",
+              line: event["line"] ?? parseInt(event["taskId"].split(":")[1] ?? "0", 10)
+            });
+            updateTaskStatus(runId, event["taskId"], "running");
+            emitLog(runId, `Task started: ${event["taskText"]}`);
+            break;
+          case "task_done":
+            updateTaskStatus(runId, event["taskId"], "success");
+            emitLog(runId, `Task done: ${event["taskText"]}`);
+            break;
+          case "task_failed":
+            updateTaskStatus(runId, event["taskId"], "failed", { error: event["error"] });
+            emitLog(runId, `Task failed: ${event["taskText"]} \u2014 ${event["error"]}`, "error");
+            break;
+          case "phase_change":
+            emitLog(runId, event["message"] ?? `Phase: ${event["phase"]}`);
+            break;
+          case "log":
+            emitLog(runId, event["message"]);
+            break;
+        }
+        break;
+      }
+      case "spec_progress": {
+        const event = msg["event"];
+        const eventType = event["type"];
+        switch (eventType) {
+          case "item_start":
+            emitLog(runId, `Generating spec for: ${event["itemTitle"] ?? event["itemId"]}`);
+            break;
+          case "item_done":
+            emitLog(runId, `Spec done: ${event["itemTitle"] ?? event["itemId"]}`);
+            break;
+          case "item_failed":
+            emitLog(runId, `Spec failed: ${event["itemTitle"] ?? event["itemId"]} \u2014 ${event["error"]}`, "error");
+            break;
+          case "log":
+            emitLog(runId, event["message"]);
+            break;
+        }
+        break;
+      }
+      case "done": {
+        const result = msg["result"];
+        if (options?.onDone) {
+          options.onDone(result);
+        } else if ("completed" in result) {
+          updateRunCounters(runId, result["total"], result["completed"], result["failed"]);
+          finishRun(runId, result["failed"] > 0 ? "failed" : "completed");
+          emitLog(runId, `Dispatch complete: ${result["completed"]}/${result["total"]} tasks succeeded`);
+        }
+        break;
+      }
+      case "error": {
+        finishRun(runId, "failed", msg["message"]);
+        emitLog(runId, `Run error: ${msg["message"]}`, "error");
+        break;
+      }
+    }
+  });
+  worker.on("exit", (code) => {
+    clearInterval(heartbeat);
+    if (code !== 0 && code !== null) {
+      finishRun(runId, "failed", `Worker process exited with code ${code}`);
+      emitLog(runId, `Worker process exited unexpectedly (code ${code})`, "error");
+    }
+  });
+  return worker;
+}
+var __filename, __dirname, WORKER_PATH, HEARTBEAT_INTERVAL_MS;
+var init_fork_run = __esm({
+  "src/mcp/tools/_fork-run.ts"() {
+    "use strict";
+    init_manager();
+    init_server();
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = dirname6(__filename);
+    WORKER_PATH = join16(__dirname, "..", "dispatch-worker.js");
+    HEARTBEAT_INTERVAL_MS = 3e4;
+  }
+});
+
 // src/mcp/tools/spec.ts
 import { z as z2 } from "zod";
-import { join as join16, resolve as resolve4, sep as sep2 } from "path";
+import { join as join17, resolve as resolve4, sep as sep2 } from "path";
 import { readdir as readdir2, readFile as readFile11 } from "fs/promises";
 function registerSpecTools(server, cwd) {
   server.tool(
@@ -12054,50 +12229,27 @@ function registerSpecTools(server, cwd) {
     },
     async (args) => {
       const runId = createSpecRun({ cwd, issues: args.issues });
-      setImmediate(() => {
-        void (async () => {
-          try {
-            emitLog(runId, `Starting spec generation for: ${args.issues}`);
-            const result = await runSpecPipeline({
-              issues: args.issues,
-              provider: args.provider ?? "opencode",
-              issueSource: args.source,
-              concurrency: args.concurrency,
-              dryRun: args.dryRun,
-              cwd,
-              progressCallback: (event) => {
-                switch (event.type) {
-                  case "item_start":
-                    emitLog(runId, `Generating spec for: ${event.itemTitle ?? event.itemId}`);
-                    break;
-                  case "item_done":
-                    emitLog(runId, `Spec done: ${event.itemTitle ?? event.itemId}`);
-                    break;
-                  case "item_failed":
-                    emitLog(runId, `Spec failed: ${event.itemTitle ?? event.itemId} \u2014 ${event.error}`, "error");
-                    break;
-                  case "log":
-                    emitLog(runId, event.message);
-                    break;
-                  default: {
-                    const _exhaustive = event;
-                    void _exhaustive;
-                  }
-                }
-              }
-            });
+      forkDispatchRun(runId, server, {
+        type: "spec",
+        cwd,
+        opts: {
+          issues: args.issues,
+          provider: args.provider ?? "opencode",
+          issueSource: args.source,
+          concurrency: args.concurrency,
+          dryRun: args.dryRun,
+          cwd
+        }
+      }, {
+        onDone: (result) => {
+          if ("generated" in result) {
             finishSpecRun(runId, "completed", {
-              total: result.total,
-              generated: result.generated,
-              failed: result.failed
+              total: result["total"],
+              generated: result["generated"],
+              failed: result["failed"]
             });
-            emitLog(runId, `Spec generation complete: ${result.generated} generated, ${result.failed} failed`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            finishSpecRun(runId, "failed", { total: 0, generated: 0, failed: 0 }, msg);
-            emitLog(runId, `Spec generation error: ${msg}`, "error");
           }
-        })();
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId, status: "running" }) }]
@@ -12109,15 +12261,25 @@ function registerSpecTools(server, cwd) {
     "List spec files in the .dispatch/specs directory.",
     {},
     async () => {
-      const specsDir = join16(cwd, ".dispatch", "specs");
+      const specsDir = join17(cwd, ".dispatch", "specs");
       let files = [];
+      let dirError;
       try {
         const entries = await readdir2(specsDir);
         files = entries.filter((f) => f.endsWith(".md")).sort();
+      } catch (err) {
+        const isNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+        if (!isNotFound) {
+          dirError = `Error reading specs directory: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
+      let recentRuns = [];
+      try {
+        recentRuns = listSpecRuns(5);
       } catch {
       }
       return {
-        content: [{ type: "text", text: JSON.stringify({ files, specsDir }) }]
+        content: [{ type: "text", text: JSON.stringify({ files, specsDir, recentRuns, ...dirError ? { error: dirError } : {} }) }]
       };
     }
   );
@@ -12129,7 +12291,7 @@ function registerSpecTools(server, cwd) {
     },
     async (args) => {
       const specsDir = resolve4(cwd, ".dispatch", "specs");
-      const candidatePath = args.file.includes("/") || args.file.includes("\\") ? resolve4(specsDir, args.file) : join16(specsDir, args.file);
+      const candidatePath = args.file.includes("/") || args.file.includes("\\") ? resolve4(specsDir, args.file) : join17(specsDir, args.file);
       if (!candidatePath.startsWith(specsDir + sep2) && candidatePath !== specsDir) {
         return {
           content: [{ type: "text", text: `Access denied: path must be inside the specs directory` }],
@@ -12158,10 +12320,17 @@ function registerSpecTools(server, cwd) {
       limit: z2.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async (args) => {
-      const runs = listSpecRuns(args.limit ?? 20);
-      return {
-        content: [{ type: "text", text: JSON.stringify(runs) }]
-      };
+      try {
+        const runs = listSpecRuns(args.limit ?? 20);
+        return {
+          content: [{ type: "text", text: JSON.stringify(runs) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
     }
   );
   server.tool(
@@ -12171,26 +12340,33 @@ function registerSpecTools(server, cwd) {
       runId: z2.string().describe("The runId returned by spec_generate")
     },
     async (args) => {
-      const run = getSpecRun(args.runId);
-      if (!run) {
+      try {
+        const run = getSpecRun(args.runId);
+        if (!run) {
+          return {
+            content: [{ type: "text", text: `Run ${args.runId} not found` }],
+            isError: true
+          };
+        }
         return {
-          content: [{ type: "text", text: `Run ${args.runId} not found` }],
+          content: [{ type: "text", text: JSON.stringify(run) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
           isError: true
         };
       }
-      return {
-        content: [{ type: "text", text: JSON.stringify(run) }]
-      };
     }
   );
 }
 var init_spec2 = __esm({
   "src/mcp/tools/spec.ts"() {
     "use strict";
-    init_spec_pipeline();
     init_manager();
     init_interface2();
     init_interface();
+    init_fork_run();
   }
 });
 
@@ -12212,64 +12388,20 @@ function registerDispatchTools(server, cwd) {
     },
     async (args) => {
       const runId = createRun({ cwd, issueIds: args.issueIds });
-      setImmediate(() => {
-        void (async () => {
-          try {
-            const orchestrator = await boot9({ cwd });
-            emitLog(runId, `Starting dispatch for issues: ${args.issueIds.join(", ")}`);
-            const result = await orchestrator.orchestrate({
-              issueIds: args.issueIds,
-              dryRun: false,
-              provider: args.provider ?? "opencode",
-              source: args.source,
-              concurrency: args.concurrency ?? 1,
-              noPlan: args.noPlan,
-              noBranch: args.noBranch,
-              noWorktree: args.noWorktree,
-              retries: args.retries,
-              progressCallback: (event) => {
-                switch (event.type) {
-                  case "task_start":
-                    emitLog(runId, `Task started: ${event.taskText}`);
-                    updateTaskStatus(runId, event.taskId, "running");
-                    break;
-                  case "task_done":
-                    emitLog(runId, `Task done: ${event.taskText}`);
-                    updateTaskStatus(runId, event.taskId, "success");
-                    break;
-                  case "task_failed":
-                    emitLog(runId, `Task failed: ${event.taskText} \u2014 ${event.error}`, "error");
-                    updateTaskStatus(runId, event.taskId, "failed", { error: event.error });
-                    break;
-                  case "phase_change":
-                    emitLog(runId, event.message ?? `Phase: ${event.phase}`);
-                    break;
-                  case "log":
-                    emitLog(runId, event.message);
-                    break;
-                  default: {
-                    const _exhaustive = event;
-                    void _exhaustive;
-                  }
-                }
-                updateRunCounters(
-                  runId,
-                  0,
-                  // we'll update with final counts at the end
-                  0,
-                  0
-                );
-              }
-            });
-            updateRunCounters(runId, result.total, result.completed, result.failed);
-            finishRun(runId, result.failed > 0 ? "failed" : "completed");
-            emitLog(runId, `Dispatch complete: ${result.completed}/${result.total} tasks succeeded`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            finishRun(runId, "failed", msg);
-            emitLog(runId, `Dispatch error: ${msg}`, "error");
-          }
-        })();
+      forkDispatchRun(runId, server, {
+        type: "dispatch",
+        cwd,
+        opts: {
+          issueIds: args.issueIds,
+          dryRun: false,
+          provider: args.provider ?? "opencode",
+          source: args.source,
+          concurrency: args.concurrency ?? 1,
+          noPlan: args.noPlan,
+          noBranch: args.noBranch,
+          noWorktree: args.noWorktree,
+          retries: args.retries
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId, status: "running" }) }]
@@ -12310,12 +12442,13 @@ var init_dispatch = __esm({
     init_manager();
     init_interface2();
     init_interface();
+    init_fork_run();
   }
 });
 
 // src/mcp/tools/monitor.ts
 import { z as z4 } from "zod";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function registerMonitorTools(server, cwd) {
   server.tool(
     "status_get",
@@ -12324,17 +12457,24 @@ function registerMonitorTools(server, cwd) {
       runId: z4.string().describe("The runId returned by dispatch_run or spec_generate")
     },
     async (args) => {
-      const run = getRun(args.runId);
-      if (!run) {
+      try {
+        const run = getRun(args.runId);
+        if (!run) {
+          return {
+            content: [{ type: "text", text: `Run ${args.runId} not found` }],
+            isError: true
+          };
+        }
+        const tasks = getTasksForRun(args.runId);
         return {
-          content: [{ type: "text", text: `Run ${args.runId} not found` }],
+          content: [{ type: "text", text: JSON.stringify({ run, tasks }) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
           isError: true
         };
       }
-      const tasks = getTasksForRun(args.runId);
-      return {
-        content: [{ type: "text", text: JSON.stringify({ run, tasks }) }]
-      };
     }
   );
   server.tool(
@@ -12345,10 +12485,17 @@ function registerMonitorTools(server, cwd) {
       limit: z4.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async (args) => {
-      const runs = args.status ? listRunsByStatus(args.status, args.limit ?? 20) : listRuns(args.limit ?? 20);
-      return {
-        content: [{ type: "text", text: JSON.stringify(runs) }]
-      };
+      try {
+        const runs = args.status ? listRunsByStatus(args.status, args.limit ?? 20) : listRuns(args.limit ?? 20);
+        return {
+          content: [{ type: "text", text: JSON.stringify(runs) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
     }
   );
   server.tool(
@@ -12364,7 +12511,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join17(cwd, ".dispatch"));
+        const config = await loadConfig(join18(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12409,7 +12556,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join17(cwd, ".dispatch"));
+        const config = await loadConfig(join18(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12457,7 +12604,7 @@ var init_monitor = __esm({
 
 // src/mcp/tools/recovery.ts
 import { z as z5 } from "zod";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function registerRecoveryTools(server, cwd) {
   server.tool(
     "run_retry",
@@ -12477,63 +12624,25 @@ function registerRecoveryTools(server, cwd) {
       }
       const tasks = getTasksForRun(args.runId);
       const failedTasks = tasks.filter((t) => t.status === "failed");
-      if (failedTasks.length === 0) {
+      if (failedTasks.length === 0 && originalRun.status !== "failed") {
         return {
           content: [{ type: "text", text: JSON.stringify({ message: "No failed tasks found", originalRunId: args.runId }) }]
         };
       }
-      const config = await loadConfig(join18(cwd, ".dispatch"));
+      const config = await loadConfig(join19(cwd, ".dispatch"));
       const issueIds = issueIdsSchema.parse(JSON.parse(originalRun.issueIds));
       const newRunId = createRun({ cwd, issueIds });
-      setImmediate(() => {
-        void (async () => {
-          try {
-            const orchestrator = await boot9({ cwd });
-            emitLog(newRunId, `Retrying ${failedTasks.length} failed task(s) from run ${args.runId}`);
-            const result = await orchestrator.orchestrate({
-              issueIds,
-              dryRun: false,
-              provider: args.provider ?? config.provider ?? "opencode",
-              source: config.source,
-              concurrency: args.concurrency ?? config.concurrency ?? 1,
-              force: true,
-              // re-run even previously completed tasks? No — force just skips run-state check
-              progressCallback: (event) => {
-                switch (event.type) {
-                  case "task_start":
-                    emitLog(newRunId, `Task started: ${event.taskText}`);
-                    updateTaskStatus(newRunId, event.taskId, "running");
-                    break;
-                  case "task_done":
-                    emitLog(newRunId, `Task done: ${event.taskText}`);
-                    updateTaskStatus(newRunId, event.taskId, "success");
-                    break;
-                  case "task_failed":
-                    emitLog(newRunId, `Task failed: ${event.taskText} \u2014 ${event.error}`, "error");
-                    updateTaskStatus(newRunId, event.taskId, "failed", { error: event.error });
-                    break;
-                  case "phase_change":
-                    emitLog(newRunId, event.message ?? `Phase: ${event.phase}`);
-                    break;
-                  case "log":
-                    emitLog(newRunId, event.message);
-                    break;
-                  default: {
-                    const _exhaustive = event;
-                    void _exhaustive;
-                  }
-                }
-              }
-            });
-            updateRunCounters(newRunId, result.total, result.completed, result.failed);
-            finishRun(newRunId, result.failed > 0 ? "failed" : "completed");
-            emitLog(newRunId, `Retry complete: ${result.completed}/${result.total} succeeded`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            finishRun(newRunId, "failed", msg);
-            emitLog(newRunId, `Retry error: ${msg}`, "error");
-          }
-        })();
+      forkDispatchRun(newRunId, server, {
+        type: "dispatch",
+        cwd,
+        opts: {
+          issueIds,
+          dryRun: false,
+          provider: args.provider ?? config.provider ?? "opencode",
+          source: config.source,
+          concurrency: args.concurrency ?? config.concurrency ?? 1,
+          force: true
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId: newRunId, status: "running", originalRunId: args.runId }) }]
@@ -12564,54 +12673,20 @@ function registerRecoveryTools(server, cwd) {
           isError: true
         };
       }
-      const config = await loadConfig(join18(cwd, ".dispatch"));
+      const config = await loadConfig(join19(cwd, ".dispatch"));
       const issueIds = issueIdsSchema.parse(JSON.parse(originalRun.issueIds));
       const newRunId = createRun({ cwd, issueIds });
-      setImmediate(() => {
-        void (async () => {
-          try {
-            const orchestrator = await boot9({ cwd });
-            emitLog(newRunId, `Retrying task: ${task.taskText}`);
-            const result = await orchestrator.orchestrate({
-              issueIds,
-              dryRun: false,
-              provider: args.provider ?? config.provider ?? "opencode",
-              source: config.source,
-              concurrency: 1,
-              force: true,
-              progressCallback: (event) => {
-                switch (event.type) {
-                  case "task_start":
-                    emitLog(newRunId, `Task started: ${event.taskText}`);
-                    break;
-                  case "task_done":
-                    emitLog(newRunId, `Task done: ${event.taskText}`);
-                    break;
-                  case "task_failed":
-                    emitLog(newRunId, `Task failed: ${event.taskText} \u2014 ${event.error}`, "error");
-                    break;
-                  case "phase_change":
-                    emitLog(newRunId, event.message ?? `Phase: ${event.phase}`);
-                    break;
-                  case "log":
-                    emitLog(newRunId, event.message);
-                    break;
-                  default: {
-                    const _exhaustive = event;
-                    void _exhaustive;
-                  }
-                }
-              }
-            });
-            updateRunCounters(newRunId, result.total, result.completed, result.failed);
-            finishRun(newRunId, result.failed > 0 ? "failed" : "completed");
-            emitLog(newRunId, `Task retry complete`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            finishRun(newRunId, "failed", msg);
-            emitLog(newRunId, `Task retry error: ${msg}`, "error");
-          }
-        })();
+      forkDispatchRun(newRunId, server, {
+        type: "dispatch",
+        cwd,
+        opts: {
+          issueIds,
+          dryRun: false,
+          provider: args.provider ?? config.provider ?? "opencode",
+          source: config.source,
+          concurrency: 1,
+          force: true
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId: newRunId, status: "running", taskId: args.taskId }) }]
@@ -12624,22 +12699,22 @@ var init_recovery = __esm({
   "src/mcp/tools/recovery.ts"() {
     "use strict";
     init_manager();
-    init_runner();
     init_config();
     init_interface2();
+    init_fork_run();
     issueIdsSchema = z5.array(z5.string());
   }
 });
 
 // src/mcp/tools/config.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function registerConfigTools(server, cwd) {
   server.tool(
     "config_get",
     "Get the current Dispatch configuration from .dispatch/config.json.",
     {},
     async () => {
-      const config = await loadConfig(join19(cwd, ".dispatch"));
+      const config = await loadConfig(join20(cwd, ".dispatch"));
       const { nextIssueId: _, ...safeConfig } = config;
       return {
         content: [{ type: "text", text: JSON.stringify(safeConfig) }]
@@ -12798,6 +12873,17 @@ async function createMcpServer(opts) {
     }
   };
 }
+function wireRunLogs(runId, server) {
+  addLogCallback(runId, (message, level) => {
+    server.sendLoggingMessage({
+      level: level === "error" ? "error" : level === "warn" ? "warning" : "info",
+      logger: `dispatch.run.${runId}`,
+      data: message
+    }).catch((err) => {
+      console.error("[dispatch-mcp] sendLoggingMessage error:", err);
+    });
+  });
+}
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
@@ -12881,7 +12967,7 @@ init_cleanup();
 init_providers();
 init_datasources();
 init_config();
-import { resolve as resolve5, join as join20 } from "path";
+import { resolve as resolve5, join as join21 } from "path";
 import { Command, Option, CommanderError } from "commander";
 var MAX_CONCURRENCY = CONFIG_BOUNDS.concurrency.max;
 var HELP = `
@@ -13174,7 +13260,7 @@ async function main() {
       }
       throw err;
     }
-    const configDir = join20(configProgram.opts().cwd ?? process.cwd(), ".dispatch");
+    const configDir = join21(configProgram.opts().cwd ?? process.cwd(), ".dispatch");
     await handleConfigCommand(rawArgv.slice(1), configDir);
     process.exit(0);
   }
@@ -13219,7 +13305,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.5.0-beta.236e011"}`);
+    console.log(`dispatch v${"1.5.0-beta.30f06ab"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });