@pruddiman/dispatch 1.5.0-beta.b8296d7 → 1.5.0-beta.c0bcc82

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 {
@@ -11862,11 +11920,26 @@ var init_database = __esm({
 // src/mcp/state/manager.ts
 import { randomUUID as randomUUID6 } from "crypto";
 function registerLiveRun(runId) {
-  liveRuns.set(runId, { runId, callbacks: [] });
+  liveRuns.set(runId, { runId, callbacks: [], completionCallbacks: [] });
 }
 function unregisterLiveRun(runId) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    for (const cb of run.completionCallbacks) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
   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) {
@@ -11879,6 +11952,48 @@ function emitLog(runId, message, level = "info") {
     }
   }
 }
+function isLiveRun(runId) {
+  return liveRuns.has(runId);
+}
+function addCompletionCallback(runId, cb) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    run.completionCallbacks.push(cb);
+  }
+}
+function waitForRunCompletion(runId, waitMs, getStatus) {
+  const effectiveWait = Math.min(Math.max(waitMs, 0), 12e4);
+  if (effectiveWait <= 0) return Promise.resolve(false);
+  const currentStatus = getStatus();
+  if (currentStatus !== null && currentStatus !== "running") {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve6) => {
+    let settled = false;
+    let pollTimer;
+    let timeoutTimer;
+    const cleanup = () => {
+      if (pollTimer) clearInterval(pollTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+    };
+    const settle = (completed) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve6(completed);
+    };
+    if (isLiveRun(runId)) {
+      addCompletionCallback(runId, () => settle(true));
+    }
+    pollTimer = setInterval(() => {
+      const s = getStatus();
+      if (s !== null && s !== "running") {
+        settle(true);
+      }
+    }, 2e3);
+    timeoutTimer = setTimeout(() => settle(false), effectiveWait);
+  });
+}
 function assertRunStatus(value) {
   if (RUN_STATUSES.includes(value)) return value;
   throw new Error(`Invalid RunStatus from database: "${value}"`);
@@ -11971,6 +12086,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 +12156,141 @@ 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/_resolve-config.ts
+import { join as join17 } from "path";
+async function loadMcpConfig(cwd, overrides) {
+  const config = await loadConfig(join17(cwd, ".dispatch"));
+  const provider = overrides?.provider ?? config.provider;
+  if (!provider) {
+    throw new Error(
+      "Missing required configuration: provider. Run 'dispatch config' to set up defaults."
+    );
+  }
+  let source = overrides?.source ?? config.source;
+  if (!source) {
+    const detected = await detectDatasource(cwd);
+    if (detected) {
+      source = detected;
+    }
+  }
+  return { ...config, provider, source };
+}
+var init_resolve_config = __esm({
+  "src/mcp/tools/_resolve-config.ts"() {
+    "use strict";
+    init_config();
+    init_datasources();
+  }
+});
+
 // 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 join18, resolve as resolve4, sep as sep2 } from "path";
 import { readdir as readdir2, readFile as readFile11 } from "fs/promises";
 function registerSpecTools(server, cwd) {
   server.tool(
@@ -12047,57 +12300,52 @@ function registerSpecTools(server, cwd) {
       issues: z2.string().describe(
         "Comma-separated issue IDs (e.g. '42,43'), a glob pattern (e.g. 'drafts/*.md'), or an inline description."
       ),
-      provider: z2.enum(PROVIDER_NAMES).optional().describe("Agent provider name (default: opencode)"),
-      source: z2.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md"),
+      provider: z2.enum(PROVIDER_NAMES).optional().describe("Agent provider name (default: from config)"),
+      source: z2.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)"),
       concurrency: z2.number().int().min(1).max(32).optional().describe("Max parallel spec generations"),
       dryRun: z2.boolean().optional().describe("Preview without generating")
     },
     async (args) => {
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider, source: args.source });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       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: config.provider,
+          model: config.model,
+          issueSource: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          concurrency: args.concurrency ?? config.concurrency,
+          specTimeout: config.specTimeout,
+          specWarnTimeout: config.specWarnTimeout,
+          specKillTimeout: config.specKillTimeout,
+          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 +12357,25 @@ function registerSpecTools(server, cwd) {
     "List spec files in the .dispatch/specs directory.",
     {},
     async () => {
-      const specsDir = join16(cwd, ".dispatch", "specs");
+      const specsDir = join18(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 +12387,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) : join18(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,39 +12416,69 @@ 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(
     "spec_run_status",
-    "Get the status of a specific spec generation run.",
+    "Get the status of a specific spec generation run. Use waitMs to hold the response until the run completes or the timeout elapses.",
     {
-      runId: z2.string().describe("The runId returned by spec_generate")
+      runId: z2.string().describe("The runId returned by spec_generate"),
+      waitMs: z2.number().int().min(0).max(12e4).optional().default(0).describe("Hold response until run completes or timeout (ms). 0 = return immediately.")
     },
     async (args) => {
-      const run = getSpecRun(args.runId);
-      if (!run) {
+      try {
+        let run = getSpecRun(args.runId);
+        if (!run) {
+          return {
+            content: [{ type: "text", text: `Run ${args.runId} not found` }],
+            isError: true
+          };
+        }
+        if (run.status === "running" && args.waitMs > 0) {
+          const completed = await waitForRunCompletion(
+            args.runId,
+            args.waitMs,
+            () => getSpecRun(args.runId)?.status ?? null
+          );
+          if (completed) {
+            run = getSpecRun(args.runId);
+          }
+        }
+        const response = { ...run };
+        if (run.status === "running") {
+          response.retryAfterMs = 5e3;
+        }
         return {
-          content: [{ type: "text", text: `Run ${args.runId} not found` }],
+          content: [{ type: "text", text: JSON.stringify(response) }]
+        };
+      } 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();
+    init_resolve_config();
   }
 });
 
@@ -12202,8 +12490,8 @@ function registerDispatchTools(server, cwd) {
     "Execute dispatch pipeline for one or more issue IDs. Returns a runId immediately; progress is pushed via logging notifications.",
     {
       issueIds: z3.array(z3.string()).min(1).describe("Issue IDs to dispatch (e.g. ['42', '43'])"),
-      provider: z3.enum(PROVIDER_NAMES).optional().describe("Agent provider (default: opencode)"),
-      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md"),
+      provider: z3.enum(PROVIDER_NAMES).optional().describe("Agent provider (default: from config)"),
+      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)"),
       concurrency: z3.number().int().min(1).max(32).optional().describe("Max parallel tasks"),
       noPlan: z3.boolean().optional().describe("Skip the planner agent"),
       noBranch: z3.boolean().optional().describe("Skip branch creation and PR lifecycle"),
@@ -12211,65 +12499,41 @@ function registerDispatchTools(server, cwd) {
       retries: z3.number().int().min(0).max(10).optional().describe("Retry attempts per task")
     },
     async (args) => {
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider, source: args.source });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       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: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
+          concurrency: args.concurrency ?? config.concurrency ?? 1,
+          noPlan: args.noPlan,
+          noBranch: args.noBranch,
+          noWorktree: args.noWorktree,
+          retries: args.retries
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId, status: "running" }) }]
@@ -12281,15 +12545,28 @@ function registerDispatchTools(server, cwd) {
     "Preview tasks that would be dispatched for the given issue IDs without executing anything.",
     {
       issueIds: z3.array(z3.string()).min(1).describe("Issue IDs to preview"),
-      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md")
+      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)")
     },
     async (args) => {
       try {
+        const config = await loadMcpConfig(cwd, { source: args.source });
         const orchestrator = await boot9({ cwd });
         const result = await orchestrator.orchestrate({
           issueIds: args.issueIds,
           dryRun: true,
-          source: args.source
+          provider: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout
         });
         return {
           content: [{ type: "text", text: JSON.stringify(result) }]
@@ -12310,31 +12587,55 @@ var init_dispatch = __esm({
     init_manager();
     init_interface2();
     init_interface();
+    init_fork_run();
+    init_resolve_config();
   }
 });
 
 // src/mcp/tools/monitor.ts
 import { z as z4 } from "zod";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function registerMonitorTools(server, cwd) {
   server.tool(
     "status_get",
-    "Get the current status of a dispatch or spec run, including per-task details.",
+    "Get the current status of a dispatch or spec run, including per-task details. Use waitMs to hold the response until the run completes or the timeout elapses.",
     {
-      runId: z4.string().describe("The runId returned by dispatch_run or spec_generate")
+      runId: z4.string().describe("The runId returned by dispatch_run or spec_generate"),
+      waitMs: z4.number().int().min(0).max(12e4).optional().default(0).describe("Hold response until run completes or timeout (ms). 0 = return immediately.")
     },
     async (args) => {
-      const run = getRun(args.runId);
-      if (!run) {
+      try {
+        let run = getRun(args.runId);
+        if (!run) {
+          return {
+            content: [{ type: "text", text: `Run ${args.runId} not found` }],
+            isError: true
+          };
+        }
+        if (run.status === "running" && args.waitMs > 0) {
+          const completed = await waitForRunCompletion(
+            args.runId,
+            args.waitMs,
+            () => getRun(args.runId)?.status ?? null
+          );
+          if (completed) {
+            run = getRun(args.runId);
+          }
+        }
+        const tasks = getTasksForRun(args.runId);
+        const response = { run, tasks };
+        if (run.status === "running") {
+          response.retryAfterMs = 5e3;
+        }
         return {
-          content: [{ type: "text", text: `Run ${args.runId} not found` }],
+          content: [{ type: "text", text: JSON.stringify(response) }]
+        };
+      } 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 +12646,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 +12672,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join17(cwd, ".dispatch"));
+        const config = await loadConfig(join19(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12409,7 +12717,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join17(cwd, ".dispatch"));
+        const config = await loadConfig(join19(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12457,7 +12765,6 @@ var init_monitor = __esm({
 
 // src/mcp/tools/recovery.ts
 import { z as z5 } from "zod";
-import { join as join18 } from "path";
 function registerRecoveryTools(server, cwd) {
   server.tool(
     "run_retry",
@@ -12477,63 +12784,44 @@ 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"));
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       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: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
+          concurrency: args.concurrency ?? config.concurrency ?? 1,
+          force: true
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId: newRunId, status: "running", originalRunId: args.runId }) }]
@@ -12564,54 +12852,39 @@ function registerRecoveryTools(server, cwd) {
           isError: true
         };
       }
-      const config = await loadConfig(join18(cwd, ".dispatch"));
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       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: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
+          concurrency: 1,
+          force: true
+        }
       });
       return {
         content: [{ type: "text", text: JSON.stringify({ runId: newRunId, status: "running", taskId: args.taskId }) }]
@@ -12624,22 +12897,22 @@ var init_recovery = __esm({
   "src/mcp/tools/recovery.ts"() {
     "use strict";
     init_manager();
-    init_runner();
-    init_config();
     init_interface2();
+    init_fork_run();
+    init_resolve_config();
     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) }]
@@ -12658,7 +12931,33 @@ var init_config2 = __esm({
 import http from "http";
 import { randomUUID as randomUUID7 } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+async function createStdioMcpServer(cwd) {
+  const mcpServer = new McpServer(
+    { name: "dispatch", version: "1.0.0" },
+    { capabilities: { logging: {} } }
+  );
+  registerSpecTools(mcpServer, cwd);
+  registerDispatchTools(mcpServer, cwd);
+  registerMonitorTools(mcpServer, cwd);
+  registerRecoveryTools(mcpServer, cwd);
+  registerConfigTools(mcpServer, cwd);
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  return {
+    close: async () => {
+      await transport.close().catch((err) => {
+        process.stderr.write(`[dispatch-mcp] transport.close error: ${String(err)}
+`);
+      });
+      await mcpServer.close().catch((err) => {
+        process.stderr.write(`[dispatch-mcp] mcpServer.close error: ${String(err)}
+`);
+      });
+    }
+  };
+}
 async function createMcpServer(opts) {
   const { port, host, cwd } = opts;
   const mcpServer = new McpServer(
@@ -12772,6 +13071,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";
@@ -12787,7 +13097,8 @@ var init_server = __esm({
 // src/mcp/index.ts
 var mcp_exports = {};
 __export(mcp_exports, {
-  startMcpServer: () => startMcpServer
+  startMcpServer: () => startMcpServer,
+  startStdioMcpServer: () => startStdioMcpServer
 });
 async function startMcpServer(opts) {
   const { port, host, cwd } = opts;
@@ -12813,6 +13124,32 @@ Received ${signal}, shutting down MCP server...`);
   process.on("SIGINT", () => void shutdown("SIGINT"));
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
 }
+async function startStdioMcpServer(opts) {
+  const { cwd } = opts;
+  openDatabase(cwd);
+  const handle = await createStdioMcpServer(cwd);
+  process.stderr.write("Dispatch MCP server ready (stdio transport). Press Ctrl+C to stop.\n");
+  async function shutdown(signal) {
+    process.stderr.write(`
+Received ${signal}, shutting down MCP server...
+`);
+    try {
+      await handle.close();
+    } catch (err) {
+      process.stderr.write(`[dispatch-mcp] Error during server close: ${String(err)}
+`);
+    }
+    try {
+      closeDatabase();
+    } catch (err) {
+      process.stderr.write(`[dispatch-mcp] Error closing database: ${String(err)}
+`);
+    }
+    process.exit(0);
+  }
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
 var init_mcp = __esm({
   "src/mcp/index.ts"() {
     "use strict";
@@ -12828,7 +13165,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 = `
@@ -13121,14 +13458,14 @@ 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);
   }
   if (rawArgv[0] === "mcp") {
     const mcpProgram = new Command("dispatch-mcp").exitOverride().configureOutput({ writeOut: () => {
     }, writeErr: () => {
-    } }).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).option("--port <number>", "Port to listen on", (v) => parseInt(v, 10), 9110).option("--host <host>", "Host to bind to", "127.0.0.1").option("--cwd <dir>", "Working directory", (v) => resolve5(v));
+    } }).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).option("--http", "Use HTTP transport instead of stdio (for remote/multi-client use)").option("--port <number>", "Port to listen on (HTTP mode only)", (v) => parseInt(v, 10), 9110).option("--host <host>", "Host to bind to (HTTP mode only)", "127.0.0.1").option("--cwd <dir>", "Working directory", (v) => resolve5(v));
     try {
       mcpProgram.parse(rawArgv.slice(1), { from: "user" });
     } catch (err) {
@@ -13139,12 +13476,14 @@ async function main() {
       throw err;
     }
     const mcpOpts = mcpProgram.opts();
-    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-    await startMcpServer2({
-      port: mcpOpts.port,
-      host: mcpOpts.host,
-      cwd: mcpOpts.cwd ?? process.cwd()
-    });
+    const cwd = mcpOpts.cwd ?? process.cwd();
+    if (mcpOpts.http) {
+      const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await startMcpServer2({ port: mcpOpts.port, host: mcpOpts.host, cwd });
+    } else {
+      const { startStdioMcpServer: startStdioMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await startStdioMcpServer2({ cwd });
+    }
     return;
   }
   const [args, explicitFlags] = parseArgs(rawArgv);
@@ -13164,7 +13503,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.5.0-beta.b8296d7"}`);
+    console.log(`dispatch v${"1.5.0-beta.c0bcc82"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });