@pruddiman/dispatch 0.0.1

package/dist/cli.js

@@ -0,0 +1,4613 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/helpers/logger.ts
+import chalk from "chalk";
+var MAX_CAUSE_CHAIN_DEPTH, log;
+var init_logger = __esm({
+  "src/helpers/logger.ts"() {
+    "use strict";
+    MAX_CAUSE_CHAIN_DEPTH = 5;
+    log = {
+      /** When true, `debug()` messages are printed. Set by `--verbose`. */
+      verbose: false,
+      info(msg) {
+        console.log(chalk.blue("\u2139"), msg);
+      },
+      success(msg) {
+        console.log(chalk.green("\u2714"), msg);
+      },
+      warn(msg) {
+        console.log(chalk.yellow("\u26A0"), msg);
+      },
+      error(msg) {
+        console.error(chalk.red("\u2716"), msg);
+      },
+      task(index, total, msg) {
+        console.log(chalk.cyan(`[${index + 1}/${total}]`), msg);
+      },
+      dim(msg) {
+        console.log(chalk.dim(msg));
+      },
+      /**
+       * Print a debug/verbose message. Only visible when `log.verbose` is true.
+       * Messages are prefixed with a dim arrow to visually nest them under the
+       * preceding info/error line.
+       */
+      debug(msg) {
+        if (!this.verbose) return;
+        console.log(chalk.dim(`  \u2937 ${msg}`));
+      },
+      /**
+       * Extract and format the full error cause chain. Node.js network errors
+       * (e.g. `TypeError: fetch failed`) bury the real reason in nested `.cause`
+       * properties — this helper surfaces them all.
+       */
+      formatErrorChain(err) {
+        const parts = [];
+        let current = err;
+        let depth = 0;
+        while (current && depth < MAX_CAUSE_CHAIN_DEPTH) {
+          if (current instanceof Error) {
+            const prefix = depth === 0 ? "Error" : "Cause";
+            parts.push(`${prefix}: ${current.message}`);
+            if (current.cause) {
+              current = current.cause;
+            } else {
+              break;
+            }
+          } else {
+            parts.push(`${depth === 0 ? "Error" : "Cause"}: ${String(current)}`);
+            break;
+          }
+          depth++;
+        }
+        return parts.join("\n  \u2937 ");
+      },
+      /**
+       * Extract the raw error message string from an unknown thrown value.
+       * Returns `err.message` for Error instances, `String(err)` for other
+       * truthy values, and `""` for null/undefined.
+       */
+      extractMessage(err) {
+        if (err instanceof Error) return err.message;
+        if (err != null) return String(err);
+        return "";
+      }
+    };
+  }
+});
+
+// src/providers/opencode.ts
+import {
+  createOpencode,
+  createOpencodeClient
+} from "@opencode-ai/sdk";
+async function listModels(opts) {
+  let client;
+  let stopServer;
+  if (opts?.url) {
+    client = createOpencodeClient({ baseUrl: opts.url });
+  } else {
+    if (opts?.cwd) {
+      log.debug(`listModels: requested cwd "${opts.cwd}" \u2014 OpenCode SDK does not support spawn-level cwd`);
+    }
+    try {
+      const oc = await createOpencode({ port: 0 });
+      client = oc.client;
+      stopServer = () => oc.server.close();
+    } catch (err) {
+      log.debug(`listModels: failed to start OpenCode server: ${log.formatErrorChain(err)}`);
+      throw err;
+    }
+  }
+  try {
+    const { data } = await client.config.providers();
+    if (!data) return [];
+    return data.providers.filter((p) => p.source === "env" || p.source === "config" || p.source === "custom").flatMap((p) => Object.keys(p.models).map((modelId) => `${p.id}/${modelId}`)).sort();
+  } finally {
+    stopServer?.();
+  }
+}
+async function boot(opts) {
+  let client;
+  let stopServer;
+  let cleaned = false;
+  if (opts?.url) {
+    log.debug(`Connecting to existing OpenCode server at ${opts.url}`);
+    client = createOpencodeClient({ baseUrl: opts.url });
+  } else {
+    log.debug("No --server-url provided, spawning local OpenCode server...");
+    if (opts?.cwd) {
+      log.debug(`Requested cwd "${opts.cwd}" \u2014 OpenCode SDK does not support spawn-level cwd; relying on prompt-level cwd`);
+    }
+    try {
+      const oc = await createOpencode({ port: 0 });
+      client = oc.client;
+      stopServer = () => oc.server.close();
+      log.debug("OpenCode server started successfully");
+    } catch (err) {
+      log.debug(`Failed to start OpenCode server: ${log.formatErrorChain(err)}`);
+      throw err;
+    }
+  }
+  let modelOverride;
+  if (opts?.model) {
+    const slash = opts.model.indexOf("/");
+    if (slash > 0) {
+      modelOverride = {
+        providerID: opts.model.slice(0, slash),
+        modelID: opts.model.slice(slash + 1)
+      };
+      log.debug(`Model override: ${opts.model}`);
+    } else {
+      log.debug(`Ignoring model override "${opts.model}": must be in "provider/model" format`);
+    }
+  }
+  let model = opts?.model;
+  if (!model) {
+    try {
+      const { data: config } = await client.config.get();
+      if (config?.model) {
+        model = config.model;
+        log.debug(`Detected model: ${model}`);
+      }
+    } catch (err) {
+      log.debug(`Failed to retrieve model from config: ${log.formatErrorChain(err)}`);
+    }
+  }
+  return {
+    name: "opencode",
+    model,
+    async createSession() {
+      log.debug("Creating OpenCode session...");
+      try {
+        const { data: session } = await client.session.create();
+        if (!session) {
+          throw new Error("Failed to create OpenCode session");
+        }
+        log.debug(`Session created: ${session.id}`);
+        return session.id;
+      } catch (err) {
+        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async prompt(sessionId, text) {
+      log.debug(`Sending async prompt to session ${sessionId} (${text.length} chars)...`);
+      try {
+        const { error: promptError } = await client.session.promptAsync({
+          path: { id: sessionId },
+          body: {
+            parts: [{ type: "text", text }],
+            ...modelOverride ? { model: modelOverride } : {}
+          }
+        });
+        if (promptError) {
+          throw new Error(`OpenCode promptAsync failed: ${JSON.stringify(promptError)}`);
+        }
+        log.debug("Async prompt accepted, subscribing to events...");
+        const controller = new AbortController();
+        const { stream } = await client.event.subscribe({
+          signal: controller.signal
+        });
+        try {
+          for await (const event of stream) {
+            if (!isSessionEvent(event, sessionId)) continue;
+            if (event.type === "message.part.updated" && event.properties.part.type === "text") {
+              const delta = event.properties.delta;
+              if (delta) {
+                log.debug(`Streaming text (+${delta.length} chars)...`);
+              }
+              continue;
+            }
+            if (event.type === "session.error") {
+              const err = event.properties.error;
+              throw new Error(
+                `OpenCode session error: ${err ? JSON.stringify(err) : "unknown error"}`
+              );
+            }
+            if (event.type === "session.idle") {
+              log.debug("Session went idle, fetching result...");
+              break;
+            }
+          }
+        } finally {
+          controller.abort();
+        }
+        const { data: messages } = await client.session.messages({
+          path: { id: sessionId }
+        });
+        if (!messages || messages.length === 0) {
+          log.debug("No messages found in session");
+          return null;
+        }
+        const lastAssistant = [...messages].reverse().find((m) => m.info.role === "assistant");
+        if (!lastAssistant) {
+          log.debug("No assistant message found in session");
+          return null;
+        }
+        if (lastAssistant.info.role === "assistant" && "error" in lastAssistant.info && lastAssistant.info.error) {
+          throw new Error(
+            `OpenCode assistant error: ${JSON.stringify(lastAssistant.info.error)}`
+          );
+        }
+        const textParts = lastAssistant.parts.filter(
+          (p) => p.type === "text" && "text" in p
+        );
+        const result = textParts.map((p) => p.text).join("\n") || null;
+        log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
+        return result;
+      } catch (err) {
+        log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      log.debug("Cleaning up OpenCode provider...");
+      try {
+        stopServer?.();
+      } catch (err) {
+        log.debug(`Failed to stop OpenCode server: ${log.formatErrorChain(err)}`);
+      }
+    }
+  };
+}
+function isSessionEvent(event, sessionId) {
+  const props = event.properties;
+  if (props.sessionID === sessionId) return true;
+  if (props.info && typeof props.info === "object" && props.info.sessionID === sessionId) {
+    return true;
+  }
+  if (props.part && typeof props.part === "object" && props.part.sessionID === sessionId) {
+    return true;
+  }
+  return false;
+}
+var init_opencode = __esm({
+  "src/providers/opencode.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/providers/copilot.ts
+import { CopilotClient, approveAll } from "@github/copilot-sdk";
+async function listModels2(opts) {
+  const client = new CopilotClient({
+    ...opts?.url ? { cliUrl: opts.url } : {}
+  });
+  try {
+    await client.start();
+    const models = await client.listModels();
+    return models.map((m) => m.id).sort();
+  } finally {
+    await client.stop().catch(() => {
+    });
+  }
+}
+async function boot2(opts) {
+  log.debug(opts?.url ? `Connecting to Copilot CLI at ${opts.url}` : "Starting Copilot CLI...");
+  const client = new CopilotClient({
+    ...opts?.url ? { cliUrl: opts.url } : {},
+    ...opts?.cwd ? { cwd: opts.cwd } : {}
+  });
+  try {
+    await client.start();
+    log.debug("Copilot CLI started successfully");
+  } catch (err) {
+    log.debug(`Failed to start Copilot CLI: ${log.formatErrorChain(err)}`);
+    throw err;
+  }
+  let model;
+  let modelDetected = false;
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    name: "copilot",
+    get model() {
+      return model;
+    },
+    async createSession() {
+      log.debug("Creating Copilot session...");
+      try {
+        const session = await client.createSession({
+          ...opts?.model ? { model: opts.model } : {},
+          ...opts?.cwd ? { workingDirectory: opts.cwd } : {},
+          onPermissionRequest: approveAll
+        });
+        sessions.set(session.sessionId, session);
+        log.debug(`Session created: ${session.sessionId}`);
+        if (!modelDetected) {
+          modelDetected = true;
+          try {
+            const result = await session.rpc.model.getCurrent();
+            if (result.modelId) {
+              model = result.modelId;
+              log.debug(`Detected model: ${model}`);
+            }
+          } catch (err) {
+            log.debug(`Failed to detect model from session: ${log.formatErrorChain(err)}`);
+          }
+        }
+        return session.sessionId;
+      } catch (err) {
+        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async prompt(sessionId, text) {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        throw new Error(`Copilot session ${sessionId} not found`);
+      }
+      log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      try {
+        await session.send({ prompt: text });
+        log.debug("Async prompt accepted, waiting for session to become idle...");
+        await new Promise((resolve2, reject) => {
+          const unsubIdle = session.on("session.idle", () => {
+            unsubIdle();
+            unsubErr();
+            resolve2();
+          });
+          const unsubErr = session.on("session.error", (event) => {
+            unsubIdle();
+            unsubErr();
+            reject(new Error(`Copilot session error: ${event.data.message}`));
+          });
+        });
+        log.debug("Session went idle, fetching result...");
+        const events = await session.getMessages();
+        const last = [...events].reverse().find((e) => e.type === "assistant.message");
+        const result = last?.data?.content ?? null;
+        log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
+        return result;
+      } catch (err) {
+        log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async cleanup() {
+      log.debug("Cleaning up Copilot provider...");
+      const destroyOps = [...sessions.values()].map(
+        (s) => s.destroy().catch((err) => {
+          log.debug(`Failed to destroy Copilot session: ${log.formatErrorChain(err)}`);
+        })
+      );
+      await Promise.all(destroyOps);
+      sessions.clear();
+      await client.stop().catch((err) => {
+        log.debug(`Failed to stop Copilot client: ${log.formatErrorChain(err)}`);
+      });
+    }
+  };
+}
+var init_copilot = __esm({
+  "src/providers/copilot.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/providers/claude.ts
+import { randomUUID } from "crypto";
+import { unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
+async function listModels3(_opts) {
+  return [
+    "claude-haiku-3-5",
+    "claude-opus-4-6",
+    "claude-sonnet-4",
+    "claude-sonnet-4-5"
+  ];
+}
+async function boot3(opts) {
+  const model = opts?.model ?? "claude-sonnet-4";
+  const cwd = opts?.cwd;
+  log.debug(`Booting Claude provider with model ${model}`);
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    name: "claude",
+    model,
+    async createSession() {
+      log.debug("Creating Claude session...");
+      try {
+        const sessionOpts = { model, permissionMode: "acceptEdits", ...cwd ? { cwd } : {} };
+        const session = unstable_v2_createSession(sessionOpts);
+        const sessionId = randomUUID();
+        sessions.set(sessionId, session);
+        log.debug(`Session created: ${sessionId}`);
+        return sessionId;
+      } catch (err) {
+        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async prompt(sessionId, text) {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        throw new Error(`Claude session ${sessionId} not found`);
+      }
+      log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      try {
+        await session.send(text);
+        const parts = [];
+        for await (const msg of session.stream()) {
+          if (msg.type === "assistant") {
+            const msgText = msg.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+            if (msgText) parts.push(msgText);
+          }
+        }
+        const result = parts.join("") || null;
+        log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
+        return result;
+      } catch (err) {
+        log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async cleanup() {
+      log.debug("Cleaning up Claude provider...");
+      for (const session of sessions.values()) {
+        try {
+          session.close();
+        } catch {
+        }
+      }
+      sessions.clear();
+    }
+  };
+}
+var init_claude = __esm({
+  "src/providers/claude.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/providers/codex.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function loadAgentLoop() {
+  return import("@openai/codex");
+}
+async function listModels4(_opts) {
+  return [
+    "codex-mini-latest",
+    "o3-mini",
+    "o4-mini"
+  ];
+}
+async function boot4(opts) {
+  const model = opts?.model ?? "o4-mini";
+  log.debug(`Booting Codex provider with model ${model}`);
+  const { AgentLoop } = await loadAgentLoop();
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    name: "codex",
+    model,
+    async createSession() {
+      log.debug("Creating Codex session...");
+      try {
+        const sessionId = randomUUID2();
+        const agent = new AgentLoop({
+          model,
+          config: { model, instructions: "" },
+          approvalPolicy: "full-auto",
+          additionalWritableRoots: opts?.cwd ? [opts.cwd] : [],
+          getCommandConfirmation: async () => ({ approved: true }),
+          onItem: () => {
+          },
+          onLoading: () => {
+          },
+          onLastResponseId: () => {
+          }
+        });
+        sessions.set(sessionId, agent);
+        log.debug(`Session created: ${sessionId}`);
+        return sessionId;
+      } catch (err) {
+        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async prompt(sessionId, text) {
+      const agent = sessions.get(sessionId);
+      if (!agent) {
+        throw new Error(`Codex session ${sessionId} not found`);
+      }
+      log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      try {
+        const items = await agent.run([text]);
+        const parts = [];
+        for (const item of items) {
+          if (item.type === "message" && "content" in item) {
+            const content = item.content;
+            const itemText = content.filter((block) => block.type === "output_text").map((block) => block.text ?? "").join("");
+            if (itemText) parts.push(itemText);
+          }
+        }
+        const result = parts.join("") || null;
+        log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
+        return result;
+      } catch (err) {
+        log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async cleanup() {
+      log.debug("Cleaning up Codex provider...");
+      for (const agent of sessions.values()) {
+        try {
+          agent.terminate();
+        } catch {
+        }
+      }
+      sessions.clear();
+    }
+  };
+}
+var init_codex = __esm({
+  "src/providers/codex.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/providers/detect.ts
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+async function checkProviderInstalled(name) {
+  try {
+    await exec6(PROVIDER_BINARIES[name], ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var exec6, PROVIDER_BINARIES;
+var init_detect = __esm({
+  "src/providers/detect.ts"() {
+    "use strict";
+    exec6 = promisify6(execFile6);
+    PROVIDER_BINARIES = {
+      opencode: "opencode",
+      copilot: "copilot",
+      claude: "claude",
+      codex: "codex"
+    };
+  }
+});
+
+// src/providers/index.ts
+async function bootProvider(name, opts) {
+  const bootFn = PROVIDERS[name];
+  if (!bootFn) {
+    throw new Error(
+      `Unknown provider "${name}". Available: ${PROVIDER_NAMES.join(", ")}`
+    );
+  }
+  return bootFn(opts);
+}
+async function listProviderModels(name, opts) {
+  const fn = LIST_MODELS[name];
+  if (!fn) {
+    throw new Error(
+      `Unknown provider "${name}". Available: ${PROVIDER_NAMES.join(", ")}`
+    );
+  }
+  return fn(opts);
+}
+var PROVIDERS, LIST_MODELS, PROVIDER_NAMES;
+var init_providers = __esm({
+  "src/providers/index.ts"() {
+    "use strict";
+    init_opencode();
+    init_copilot();
+    init_claude();
+    init_codex();
+    init_detect();
+    PROVIDERS = {
+      opencode: boot,
+      copilot: boot2,
+      claude: boot3,
+      codex: boot4
+    };
+    LIST_MODELS = {
+      opencode: listModels,
+      copilot: listModels2,
+      claude: listModels3,
+      codex: listModels4
+    };
+    PROVIDER_NAMES = Object.keys(PROVIDERS);
+  }
+});
+
+// src/helpers/cleanup.ts
+function registerCleanup(fn) {
+  cleanups.push(fn);
+}
+async function runCleanup() {
+  const fns = cleanups.splice(0);
+  for (const fn of fns) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+}
+var cleanups;
+var init_cleanup = __esm({
+  "src/helpers/cleanup.ts"() {
+    "use strict";
+    cleanups = [];
+  }
+});
+
+// src/orchestrator/fix-tests-pipeline.ts
+var fix_tests_pipeline_exports = {};
+__export(fix_tests_pipeline_exports, {
+  buildFixTestsPrompt: () => buildFixTestsPrompt,
+  detectTestCommand: () => detectTestCommand,
+  runFixTestsPipeline: () => runFixTestsPipeline,
+  runTestCommand: () => runTestCommand
+});
+import { readFile as readFile8 } from "fs/promises";
+import { join as join10 } from "path";
+import { execFile as execFileCb } from "child_process";
+async function detectTestCommand(cwd) {
+  try {
+    const raw = await readFile8(join10(cwd, "package.json"), "utf-8");
+    let pkg;
+    try {
+      pkg = JSON.parse(raw);
+    } catch {
+      log.debug(
+        `Failed to parse package.json: ${raw.slice(0, 200)}`
+      );
+      return null;
+    }
+    const testScript = pkg?.scripts?.test;
+    if (typeof testScript === "string" && testScript !== 'echo "Error: no test specified" && exit 1') {
+      return "npm test";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runTestCommand(command, cwd) {
+  return new Promise((resolve2) => {
+    const [cmd, ...args] = command.split(" ");
+    execFileCb(
+      cmd,
+      args,
+      { cwd, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        const exitCode = error && "code" in error ? error.code ?? 1 : error ? 1 : 0;
+        resolve2({ exitCode, stdout, stderr, command });
+      }
+    );
+  });
+}
+function buildFixTestsPrompt(testResult, cwd) {
+  const output = [testResult.stdout, testResult.stderr].filter(Boolean).join("\n");
+  return [
+    `You are fixing failing tests in a project.`,
+    ``,
+    `**Working directory:** ${cwd}`,
+    `**Test command:** ${testResult.command}`,
+    `**Exit code:** ${testResult.exitCode}`,
+    ``,
+    `## Test Output`,
+    ``,
+    "```",
+    output,
+    "```",
+    ``,
+    `## Instructions`,
+    ``,
+    `- Read the failing test files and the source code they test.`,
+    `- Understand why the tests are failing.`,
+    `- Make minimal fixes \u2014 fix the tests or fix the source code, whichever is appropriate.`,
+    `- Do NOT commit changes \u2014 the developer controls commits.`,
+    `- Do NOT modify tests to simply skip or ignore failures.`,
+    `- When finished, confirm by saying "Tests fixed."`
+  ].join("\n");
+}
+async function runFixTestsPipeline(opts) {
+  const { cwd } = opts;
+  const testTimeoutMs = (opts.testTimeout ?? 5) * 6e4;
+  const start = Date.now();
+  const testCommand = await detectTestCommand(cwd);
+  if (!testCommand) {
+    log.error(
+      'No test command found. Ensure package.json has a "test" script.'
+    );
+    return { mode: "fix-tests", success: false, error: "No test command found" };
+  }
+  log.info(`Detected test command: ${testCommand}`);
+  if (opts.dryRun) {
+    log.info(`Dry run \u2014 would execute: ${testCommand}`);
+    log.dim(`  Working directory: ${cwd}`);
+    return { mode: "fix-tests", success: false };
+  }
+  try {
+    log.info("Running test suite...");
+    const testResult = await runTestCommand(testCommand, cwd);
+    if (testResult.exitCode === 0) {
+      log.success("All tests pass \u2014 nothing to fix.");
+      return { mode: "fix-tests", success: true };
+    }
+    log.warn(
+      `Tests failed (exit code ${testResult.exitCode}). Dispatching AI to fix...`
+    );
+    const provider = opts.provider ?? "opencode";
+    const instance = await bootProvider(provider, { url: opts.serverUrl, cwd });
+    registerCleanup(() => instance.cleanup());
+    const prompt = buildFixTestsPrompt(testResult, cwd);
+    log.debug(`Prompt built (${prompt.length} chars)`);
+    const sessionId = await instance.createSession();
+    const response = await instance.prompt(sessionId, prompt);
+    if (response === null) {
+      log.error("No response from AI agent.");
+      await instance.cleanup();
+      return { mode: "fix-tests", success: false, error: "No response from agent" };
+    }
+    log.success("AI agent completed fixes.");
+    log.info("Re-running tests to verify fixes...");
+    const verifyResult = await runTestCommand(testCommand, cwd);
+    await instance.cleanup();
+    if (verifyResult.exitCode === 0) {
+      log.success("All tests pass after fixes!");
+      return { mode: "fix-tests", success: true };
+    }
+    log.warn(
+      `Tests still failing after fix attempt (exit code ${verifyResult.exitCode}).`
+    );
+    return { mode: "fix-tests", success: false, error: "Tests still failing after fix attempt" };
+  } catch (err) {
+    const message = log.extractMessage(err);
+    log.error(`Fix-tests pipeline failed: ${log.formatErrorChain(err)}`);
+    log.debug(log.formatErrorChain(err));
+    return { mode: "fix-tests", success: false, error: message };
+  }
+}
+var init_fix_tests_pipeline = __esm({
+  "src/orchestrator/fix-tests-pipeline.ts"() {
+    "use strict";
+    init_providers();
+    init_cleanup();
+    init_logger();
+  }
+});
+
+// src/cli.ts
+import { resolve, join as join11 } from "path";
+
+// src/spec-generator.ts
+import { cpus, freemem } from "os";
+
+// src/datasources/index.ts
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+
+// src/datasources/github.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/helpers/slugify.ts
+var MAX_SLUG_LENGTH = 60;
+function slugify(input2, maxLength) {
+  const slug = input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return maxLength != null ? slug.slice(0, maxLength) : slug;
+}
+
+// src/datasources/github.ts
+init_logger();
+var exec = promisify(execFile);
+async function git(args, cwd) {
+  const { stdout } = await exec("git", args, { cwd });
+  return stdout;
+}
+async function gh(args, cwd) {
+  const { stdout } = await exec("gh", args, { cwd });
+  return stdout;
+}
+function buildBranchName(issueNumber, title, username = "unknown") {
+  const slug = slugify(title, 50);
+  return `${username}/dispatch/${issueNumber}-${slug}`;
+}
+async function getDefaultBranch(cwd) {
+  try {
+    const ref = await git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+    const parts = ref.trim().split("/");
+    return parts[parts.length - 1];
+  } catch {
+    try {
+      await git(["rev-parse", "--verify", "main"], cwd);
+      return "main";
+    } catch {
+      return "master";
+    }
+  }
+}
+var datasource = {
+  name: "github",
+  async list(opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { stdout } = await exec(
+      "gh",
+      [
+        "issue",
+        "list",
+        "--state",
+        "open",
+        "--json",
+        "number,title,body,labels,state,url"
+      ],
+      { cwd }
+    );
+    let issues;
+    try {
+      issues = JSON.parse(stdout);
+    } catch {
+      throw new Error(`Failed to parse GitHub CLI output: ${stdout.slice(0, 200)}`);
+    }
+    return issues.map(
+      (issue) => ({
+        number: String(issue.number),
+        title: issue.title ?? "",
+        body: issue.body ?? "",
+        labels: (issue.labels ?? []).map((l) => l.name),
+        state: issue.state ?? "OPEN",
+        url: issue.url ?? "",
+        comments: [],
+        acceptanceCriteria: ""
+      })
+    );
+  },
+  async fetch(issueId, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { stdout } = await exec(
+      "gh",
+      [
+        "issue",
+        "view",
+        issueId,
+        "--json",
+        "number,title,body,labels,state,url,comments"
+      ],
+      { cwd }
+    );
+    let issue;
+    try {
+      issue = JSON.parse(stdout);
+    } catch {
+      throw new Error(`Failed to parse GitHub CLI output: ${stdout.slice(0, 200)}`);
+    }
+    const comments = [];
+    if (issue.comments && Array.isArray(issue.comments)) {
+      for (const c of issue.comments) {
+        const author = c.author?.login ?? "unknown";
+        comments.push(`**${author}:** ${c.body}`);
+      }
+    }
+    return {
+      number: String(issue.number),
+      title: issue.title ?? "",
+      body: issue.body ?? "",
+      labels: (issue.labels ?? []).map((l) => l.name),
+      state: issue.state ?? "OPEN",
+      url: issue.url ?? "",
+      comments,
+      acceptanceCriteria: ""
+    };
+  },
+  async update(issueId, title, body, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    await exec("gh", ["issue", "edit", issueId, "--title", title, "--body", body], { cwd });
+  },
+  async close(issueId, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    await exec("gh", ["issue", "close", issueId], { cwd });
+  },
+  async create(title, body, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { stdout } = await exec(
+      "gh",
+      ["issue", "create", "--title", title, "--body", body],
+      { cwd }
+    );
+    const url = stdout.trim();
+    const match = url.match(/\/issues\/(\d+)$/);
+    const number = match ? match[1] : "0";
+    return {
+      number,
+      title,
+      body,
+      labels: [],
+      state: "open",
+      url,
+      comments: [],
+      acceptanceCriteria: ""
+    };
+  },
+  async getUsername(opts) {
+    try {
+      const name = await git(["config", "user.name"], opts.cwd);
+      const slug = slugify(name.trim());
+      return slug || "unknown";
+    } catch {
+      return "unknown";
+    }
+  },
+  getDefaultBranch(opts) {
+    return getDefaultBranch(opts.cwd);
+  },
+  buildBranchName(issueNumber, title, username) {
+    return buildBranchName(issueNumber, title, username ?? "unknown");
+  },
+  async createAndSwitchBranch(branchName, opts) {
+    const cwd = opts.cwd;
+    try {
+      await git(["checkout", "-b", branchName], cwd);
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        await git(["checkout", branchName], cwd);
+      } else {
+        throw err;
+      }
+    }
+  },
+  async switchBranch(branchName, opts) {
+    await git(["checkout", branchName], opts.cwd);
+  },
+  async pushBranch(branchName, opts) {
+    await git(["push", "--set-upstream", "origin", branchName], opts.cwd);
+  },
+  async commitAllChanges(message, opts) {
+    const cwd = opts.cwd;
+    await git(["add", "-A"], cwd);
+    const status = await git(["diff", "--cached", "--stat"], cwd);
+    if (!status.trim()) {
+      return;
+    }
+    await git(["commit", "-m", message], cwd);
+  },
+  async createPullRequest(branchName, issueNumber, title, body, opts) {
+    const cwd = opts.cwd;
+    const prBody = body || `Closes #${issueNumber}`;
+    try {
+      const url = await gh(
+        [
+          "pr",
+          "create",
+          "--title",
+          title,
+          "--body",
+          prBody,
+          "--head",
+          branchName
+        ],
+        cwd
+      );
+      return url.trim();
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        const existing = await gh(
+          ["pr", "view", branchName, "--json", "url", "--jq", ".url"],
+          cwd
+        );
+        return existing.trim();
+      }
+      throw err;
+    }
+  }
+};
+
+// src/datasources/azdevops.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+init_logger();
+var exec2 = promisify2(execFile2);
+async function detectWorkItemType(opts = {}) {
+  try {
+    const args = ["boards", "work-item", "type", "list", "--output", "json"];
+    if (opts.project) args.push("--project", opts.project);
+    if (opts.org) args.push("--org", opts.org);
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd()
+    });
+    const types = JSON.parse(stdout);
+    if (!Array.isArray(types) || types.length === 0) return null;
+    const names = types.map((t) => t.name);
+    const preferred = ["User Story", "Product Backlog Item", "Requirement", "Issue"];
+    for (const p of preferred) {
+      if (names.includes(p)) return p;
+    }
+    return names[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+var datasource2 = {
+  name: "azdevops",
+  async list(opts = {}) {
+    const wiql = "SELECT [System.Id] FROM workitems WHERE [System.State] <> 'Closed' AND [System.State] <> 'Removed' ORDER BY [System.CreatedDate] DESC";
+    const args = ["boards", "query", "--wiql", wiql, "--output", "json"];
+    if (opts.org) args.push("--org", opts.org);
+    if (opts.project) args.push("--project", opts.project);
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd()
+    });
+    let data;
+    try {
+      data = JSON.parse(stdout);
+    } catch {
+      throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
+    }
+    const items = [];
+    if (Array.isArray(data)) {
+      for (const row of data) {
+        const id = String(row.id ?? row.ID ?? "");
+        if (id) {
+          const detail = await datasource2.fetch(id, opts);
+          items.push(detail);
+        }
+      }
+    }
+    return items;
+  },
+  async fetch(issueId, opts = {}) {
+    const args = [
+      "boards",
+      "work-item",
+      "show",
+      "--id",
+      issueId,
+      "--output",
+      "json"
+    ];
+    if (opts.org) {
+      args.push("--org", opts.org);
+    }
+    if (opts.project) {
+      args.push("--project", opts.project);
+    }
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd()
+    });
+    let item;
+    try {
+      item = JSON.parse(stdout);
+    } catch {
+      throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
+    }
+    const fields = item.fields ?? {};
+    const comments = await fetchComments(issueId, opts);
+    return {
+      number: String(item.id ?? issueId),
+      title: fields["System.Title"] ?? "",
+      body: fields["System.Description"] ?? "",
+      labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
+      state: fields["System.State"] ?? "",
+      url: item._links?.html?.href ?? item.url ?? "",
+      comments,
+      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
+    };
+  },
+  async update(issueId, title, body, opts = {}) {
+    const args = [
+      "boards",
+      "work-item",
+      "update",
+      "--id",
+      issueId,
+      "--title",
+      title,
+      "--description",
+      body
+    ];
+    if (opts.org) args.push("--org", opts.org);
+    if (opts.project) args.push("--project", opts.project);
+    await exec2("az", args, { cwd: opts.cwd || process.cwd() });
+  },
+  async close(issueId, opts = {}) {
+    const args = [
+      "boards",
+      "work-item",
+      "update",
+      "--id",
+      issueId,
+      "--state",
+      "Closed"
+    ];
+    if (opts.org) args.push("--org", opts.org);
+    if (opts.project) args.push("--project", opts.project);
+    await exec2("az", args, { cwd: opts.cwd || process.cwd() });
+  },
+  async create(title, body, opts = {}) {
+    const workItemType = opts.workItemType ?? await detectWorkItemType(opts);
+    if (!workItemType) {
+      throw new Error(
+        "Could not determine work item type. Set workItemType in your config (for example via `dispatch config`)."
+      );
+    }
+    const args = [
+      "boards",
+      "work-item",
+      "create",
+      "--type",
+      workItemType,
+      "--title",
+      title,
+      "--description",
+      body,
+      "--output",
+      "json"
+    ];
+    if (opts.org) args.push("--org", opts.org);
+    if (opts.project) args.push("--project", opts.project);
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd()
+    });
+    let item;
+    try {
+      item = JSON.parse(stdout);
+    } catch {
+      throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
+    }
+    const fields = item.fields ?? {};
+    return {
+      number: String(item.id),
+      title: fields["System.Title"] ?? title,
+      body: fields["System.Description"] ?? body,
+      labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
+      state: fields["System.State"] ?? "New",
+      url: item._links?.html?.href ?? item.url ?? "",
+      comments: [],
+      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
+    };
+  },
+  async getDefaultBranch(opts) {
+    try {
+      const { stdout } = await exec2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: opts.cwd });
+      const parts = stdout.trim().split("/");
+      return parts[parts.length - 1];
+    } catch {
+      try {
+        await exec2("git", ["rev-parse", "--verify", "main"], { cwd: opts.cwd });
+        return "main";
+      } catch {
+        return "master";
+      }
+    }
+  },
+  async getUsername(opts) {
+    try {
+      const { stdout } = await exec2("git", ["config", "user.name"], { cwd: opts.cwd });
+      const name = stdout.trim();
+      if (!name) return "unknown";
+      return slugify(name);
+    } catch {
+      return "unknown";
+    }
+  },
+  buildBranchName(issueNumber, title, username) {
+    const slug = slugify(title, 50);
+    return `${username}/dispatch/${issueNumber}-${slug}`;
+  },
+  async createAndSwitchBranch(branchName, opts) {
+    try {
+      await exec2("git", ["checkout", "-b", branchName], { cwd: opts.cwd });
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        await exec2("git", ["checkout", branchName], { cwd: opts.cwd });
+      } else {
+        throw err;
+      }
+    }
+  },
+  async switchBranch(branchName, opts) {
+    await exec2("git", ["checkout", branchName], { cwd: opts.cwd });
+  },
+  async pushBranch(branchName, opts) {
+    await exec2("git", ["push", "--set-upstream", "origin", branchName], { cwd: opts.cwd });
+  },
+  async commitAllChanges(message, opts) {
+    await exec2("git", ["add", "-A"], { cwd: opts.cwd });
+    const { stdout } = await exec2("git", ["diff", "--cached", "--stat"], { cwd: opts.cwd });
+    if (!stdout.trim()) {
+      return;
+    }
+    await exec2("git", ["commit", "-m", message], { cwd: opts.cwd });
+  },
+  async createPullRequest(branchName, issueNumber, title, body, opts) {
+    try {
+      const { stdout } = await exec2(
+        "az",
+        [
+          "repos",
+          "pr",
+          "create",
+          "--title",
+          title,
+          "--description",
+          body || `Resolves AB#${issueNumber}`,
+          "--source-branch",
+          branchName,
+          "--work-items",
+          issueNumber,
+          "--output",
+          "json"
+        ],
+        { cwd: opts.cwd }
+      );
+      let pr;
+      try {
+        pr = JSON.parse(stdout);
+      } catch {
+        throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
+      }
+      return pr.url ?? "";
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        const { stdout } = await exec2(
+          "az",
+          [
+            "repos",
+            "pr",
+            "list",
+            "--source-branch",
+            branchName,
+            "--status",
+            "active",
+            "--output",
+            "json"
+          ],
+          { cwd: opts.cwd }
+        );
+        let prs;
+        try {
+          prs = JSON.parse(stdout);
+        } catch {
+          throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
+        }
+        if (Array.isArray(prs) && prs.length > 0) {
+          return prs[0].url ?? "";
+        }
+        return "";
+      }
+      throw err;
+    }
+  }
+};
+async function fetchComments(workItemId, opts) {
+  try {
+    const args = [
+      "boards",
+      "work-item",
+      "relation",
+      "list-comment",
+      "--work-item-id",
+      workItemId,
+      "--output",
+      "json"
+    ];
+    if (opts.org) {
+      args.push("--org", opts.org);
+    }
+    if (opts.project) {
+      args.push("--project", opts.project);
+    }
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd()
+    });
+    const data = JSON.parse(stdout);
+    if (data.comments && Array.isArray(data.comments)) {
+      return data.comments.map(
+        (c) => {
+          const author = c.createdBy?.displayName ?? "unknown";
+          return `**${author}:** ${c.text ?? ""}`;
+        }
+      );
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+// src/datasources/md.ts
+import { execFile as execFile3 } from "child_process";
+import { readFile, writeFile, readdir, mkdir, rename } from "fs/promises";
+import { join, parse as parsePath } from "path";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile3);
+var DEFAULT_DIR = ".dispatch/specs";
+function resolveDir(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  return join(cwd, DEFAULT_DIR);
+}
+function extractTitle(content, filename) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match) return match[1].trim();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const cleaned = trimmed.replace(/^[#>*\-]+\s*/, "").trim();
+    if (!cleaned) continue;
+    if (cleaned.length <= 80) return cleaned;
+    const truncated = cleaned.slice(0, 80);
+    const lastSpace = truncated.lastIndexOf(" ");
+    return lastSpace > 0 ? truncated.slice(0, lastSpace) : truncated;
+  }
+  return parsePath(filename).name;
+}
+function toIssueDetails(filename, content, dir) {
+  return {
+    number: filename,
+    title: extractTitle(content, filename),
+    body: content,
+    labels: [],
+    state: "open",
+    url: join(dir, filename),
+    comments: [],
+    acceptanceCriteria: ""
+  };
+}
+var datasource3 = {
+  name: "md",
+  async list(opts) {
+    const dir = resolveDir(opts);
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return [];
+    }
+    const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
+    const results = [];
+    for (const filename of mdFiles) {
+      const filePath = join(dir, filename);
+      const content = await readFile(filePath, "utf-8");
+      results.push(toIssueDetails(filename, content, dir));
+    }
+    return results;
+  },
+  async fetch(issueId, opts) {
+    const dir = resolveDir(opts);
+    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
+    const filePath = join(dir, filename);
+    const content = await readFile(filePath, "utf-8");
+    return toIssueDetails(filename, content, dir);
+  },
+  async update(issueId, _title, body, opts) {
+    const dir = resolveDir(opts);
+    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
+    const filePath = join(dir, filename);
+    await writeFile(filePath, body, "utf-8");
+  },
+  async close(issueId, opts) {
+    const dir = resolveDir(opts);
+    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
+    const filePath = join(dir, filename);
+    const archiveDir = join(dir, "archive");
+    await mkdir(archiveDir, { recursive: true });
+    await rename(filePath, join(archiveDir, filename));
+  },
+  async create(title, body, opts) {
+    const dir = resolveDir(opts);
+    await mkdir(dir, { recursive: true });
+    const filename = `${slugify(title)}.md`;
+    const filePath = join(dir, filename);
+    await writeFile(filePath, body, "utf-8");
+    return toIssueDetails(filename, body, dir);
+  },
+  async getDefaultBranch(_opts) {
+    return "main";
+  },
+  async getUsername(opts) {
+    try {
+      const { stdout } = await exec3("git", ["config", "user.name"], { cwd: opts.cwd });
+      const name = stdout.trim();
+      if (!name) return "local";
+      return slugify(name);
+    } catch {
+      return "local";
+    }
+  },
+  buildBranchName(issueNumber, title, username) {
+    const slug = slugify(title, 50);
+    return `${username}/dispatch/${issueNumber}-${slug}`;
+  },
+  async createAndSwitchBranch(_branchName, _opts) {
+  },
+  async switchBranch(_branchName, _opts) {
+  },
+  async pushBranch(_branchName, _opts) {
+  },
+  async commitAllChanges(_message, _opts) {
+  },
+  async createPullRequest(_branchName, _issueNumber, _title, _body, _opts) {
+    return "";
+  }
+};
+
+// src/datasources/index.ts
+var exec4 = promisify4(execFile4);
+var DATASOURCES = {
+  github: datasource,
+  azdevops: datasource2,
+  md: datasource3
+};
+var DATASOURCE_NAMES = Object.keys(DATASOURCES);
+function getDatasource(name) {
+  const datasource4 = DATASOURCES[name];
+  if (!datasource4) {
+    throw new Error(
+      `Unknown datasource "${name}". Available: ${DATASOURCE_NAMES.join(", ")}`
+    );
+  }
+  return datasource4;
+}
+async function getGitRemoteUrl(cwd) {
+  try {
+    const { stdout } = await exec4("git", ["remote", "get-url", "origin"], {
+      cwd
+    });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var SOURCE_PATTERNS = [
+  { pattern: /github\.com/i, source: "github" },
+  { pattern: /dev\.azure\.com/i, source: "azdevops" },
+  { pattern: /visualstudio\.com/i, source: "azdevops" }
+];
+async function detectDatasource(cwd) {
+  const url = await getGitRemoteUrl(cwd);
+  if (!url) return null;
+  for (const { pattern, source } of SOURCE_PATTERNS) {
+    if (pattern.test(url)) {
+      return source;
+    }
+  }
+  return null;
+}
+
+// src/spec-generator.ts
+init_logger();
+var MB_PER_CONCURRENT_TASK = 500;
+var RECOGNIZED_H2 = /* @__PURE__ */ new Set([
+  "## Context",
+  "## Why",
+  "## Approach",
+  "## Integration Points",
+  "## Tasks",
+  "## References",
+  "## Key Guidelines"
+]);
+function defaultConcurrency() {
+  return Math.max(1, Math.min(cpus().length, Math.floor(freemem() / 1024 / 1024 / MB_PER_CONCURRENT_TASK)));
+}
+function isIssueNumbers(input2) {
+  if (Array.isArray(input2)) return false;
+  return /^\d+(,\s*\d+)*$/.test(input2);
+}
+function isGlobOrFilePath(input2) {
+  if (Array.isArray(input2)) return true;
+  if (/[*?\[{]/.test(input2)) return true;
+  if (/[/\\]/.test(input2)) return true;
+  if (/^\.\.?\//.test(input2)) return true;
+  if (/\.(md|txt|yaml|yml|json|ts|js|tsx|jsx)$/i.test(input2)) return true;
+  return false;
+}
+function extractSpecContent(raw) {
+  let content = raw;
+  const fenceMatch = content.match(/^\s*```(?:markdown)?\s*\n([\s\S]*?)\n\s*```\s*$/);
+  if (fenceMatch) {
+    content = fenceMatch[1];
+  } else {
+    const innerFenceMatch = content.match(/```(?:markdown)?\s*\n([\s\S]*?)\n\s*```/);
+    if (innerFenceMatch && /^# /m.test(innerFenceMatch[1])) {
+      content = innerFenceMatch[1];
+    }
+  }
+  const h1Index = content.search(/^# /m);
+  if (h1Index === -1) {
+    return raw;
+  }
+  content = content.slice(h1Index);
+  const lines = content.split("\n");
+  let lastRecognizedSectionEnd = lines.length;
+  let foundLastRecognized = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trimEnd();
+    if (trimmed.startsWith("## ")) {
+      if (RECOGNIZED_H2.has(trimmed)) {
+        foundLastRecognized = true;
+        break;
+      } else {
+        lastRecognizedSectionEnd = i;
+      }
+    }
+  }
+  if (foundLastRecognized || lastRecognizedSectionEnd < lines.length) {
+    let end = lastRecognizedSectionEnd;
+    while (end > 0 && lines[end - 1].trim() === "") {
+      end--;
+    }
+    content = lines.slice(0, end).join("\n");
+  }
+  if (!content.endsWith("\n")) {
+    content += "\n";
+  }
+  return content;
+}
+function validateSpecStructure(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("# ")) {
+    const reason = 'Spec does not start with an H1 heading (expected "# ")';
+    log.warn(reason);
+    return { valid: false, reason };
+  }
+  const tasksIndex = content.search(/^## Tasks\s*$/m);
+  if (tasksIndex === -1) {
+    const reason = 'Spec is missing a "## Tasks" section';
+    log.warn(reason);
+    return { valid: false, reason };
+  }
+  const afterTasks = content.slice(tasksIndex);
+  if (!/- \[ \]/.test(afterTasks)) {
+    const reason = '"## Tasks" section contains no unchecked tasks (expected at least one "- [ ]")';
+    log.warn(reason);
+    return { valid: false, reason };
+  }
+  return { valid: true };
+}
+async function resolveSource(issues, issueSource, cwd) {
+  if (issueSource) {
+    return issueSource;
+  }
+  log.info("Detecting datasource from git remote...");
+  const detected = await detectDatasource(cwd);
+  if (detected) {
+    log.info(`Detected datasource: ${detected}`);
+    return detected;
+  }
+  if (!isIssueNumbers(issues)) {
+    return "md";
+  }
+  log.error(
+    `Could not detect datasource from the repository remote URL.
+  Supported sources: ${DATASOURCE_NAMES.join(", ")}
+  Use --source <name> to specify explicitly, or ensure the git remote
+  points to a supported platform (github.com, dev.azure.com).`
+  );
+  return null;
+}
+
+// src/orchestrator/runner.ts
+init_logger();
+
+// src/helpers/confirm-large-batch.ts
+init_logger();
+import { input } from "@inquirer/prompts";
+import chalk2 from "chalk";
+var LARGE_BATCH_THRESHOLD = 100;
+async function confirmLargeBatch(count, threshold = LARGE_BATCH_THRESHOLD) {
+  if (count <= threshold) return true;
+  log.warn(
+    `This operation will process ${chalk2.bold(String(count))} specs, which exceeds the safety threshold of ${threshold}.`
+  );
+  const answer = await input({
+    message: `Type ${chalk2.bold('"yes"')} to proceed:`
+  });
+  return answer.trim().toLowerCase() === "yes";
+}
+
+// src/helpers/prereqs.ts
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var exec5 = promisify5(execFile5);
+var MIN_NODE_VERSION = "20.12.0";
+function parseSemver(version) {
+  const [major, minor, patch] = version.split(".").map(Number);
+  return [major ?? 0, minor ?? 0, patch ?? 0];
+}
+function semverGte(current, minimum) {
+  const [cMaj, cMin, cPat] = parseSemver(current);
+  const [mMaj, mMin, mPat] = parseSemver(minimum);
+  if (cMaj !== mMaj) return cMaj > mMaj;
+  if (cMin !== mMin) return cMin > mMin;
+  return cPat >= mPat;
+}
+async function checkPrereqs(context) {
+  const failures = [];
+  try {
+    await exec5("git", ["--version"]);
+  } catch {
+    failures.push("git is required but was not found on PATH. Install it from https://git-scm.com");
+  }
+  const nodeVersion = process.versions.node;
+  if (!semverGte(nodeVersion, MIN_NODE_VERSION)) {
+    failures.push(
+      `Node.js >= ${MIN_NODE_VERSION} is required but found ${nodeVersion}. Please upgrade Node.js`
+    );
+  }
+  if (context?.datasource === "github") {
+    try {
+      await exec5("gh", ["--version"]);
+    } catch {
+      failures.push(
+        "gh (GitHub CLI) is required for the github datasource but was not found on PATH. Install it from https://cli.github.com/"
+      );
+    }
+  }
+  if (context?.datasource === "azdevops") {
+    try {
+      await exec5("az", ["--version"]);
+    } catch {
+      failures.push(
+        "az (Azure CLI) is required for the azdevops datasource but was not found on PATH. Install it from https://learn.microsoft.com/en-us/cli/azure/"
+      );
+    }
+  }
+  return failures;
+}
+
+// src/helpers/gitignore.ts
+init_logger();
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function ensureGitignoreEntry(repoRoot, entry) {
+  const gitignorePath = join2(repoRoot, ".gitignore");
+  let contents = "";
+  try {
+    contents = await readFile2(gitignorePath, "utf8");
+  } catch {
+  }
+  const lines = contents.split("\n").map((l) => l.trim());
+  const bare = entry.replace(/\/$/, "");
+  if (lines.includes(entry) || lines.includes(bare)) {
+    return;
+  }
+  try {
+    const separator = contents.length > 0 && !contents.endsWith("\n") ? "\n" : "";
+    await writeFile2(gitignorePath, `${contents}${separator}${entry}
+`, "utf8");
+    log.debug(`Added '${entry}' to .gitignore`);
+  } catch (err) {
+    log.warn(`Could not update .gitignore: ${String(err)}`);
+  }
+}
+
+// src/orchestrator/cli-config.ts
+init_logger();
+import { join as join4 } from "path";
+import { access } from "fs/promises";
+import { constants } from "fs";
+
+// src/config.ts
+init_providers();
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { join as join3, dirname } from "path";
+
+// src/config-prompts.ts
+init_logger();
+import { select, confirm } from "@inquirer/prompts";
+import chalk3 from "chalk";
+init_providers();
+async function runInteractiveConfigWizard(configDir) {
+  console.log();
+  log.info(chalk3.bold("Dispatch Configuration Wizard"));
+  console.log();
+  const existing = await loadConfig(configDir);
+  const hasExisting = Object.keys(existing).length > 0;
+  if (hasExisting) {
+    log.dim("Current configuration:");
+    for (const [key, value] of Object.entries(existing)) {
+      if (value !== void 0) {
+        log.dim(`  ${key} = ${value}`);
+      }
+    }
+    console.log();
+    const reconfigure = await confirm({
+      message: "Do you want to reconfigure?",
+      default: true
+    });
+    if (!reconfigure) {
+      log.dim("Configuration unchanged.");
+      return;
+    }
+    console.log();
+  }
+  const installStatuses = await Promise.all(
+    PROVIDER_NAMES.map((name) => checkProviderInstalled(name))
+  );
+  const provider = await select({
+    message: "Select a provider:",
+    choices: PROVIDER_NAMES.map((name, i) => ({
+      name: `${installStatuses[i] ? chalk3.green("\u25CF") : chalk3.red("\u25CF")} ${name}`,
+      value: name
+    })),
+    default: existing.provider
+  });
+  let selectedModel = existing.model;
+  try {
+    log.dim("Fetching available models...");
+    const models = await listProviderModels(provider);
+    if (models.length > 0) {
+      const modelChoice = await select({
+        message: "Select a model:",
+        choices: [
+          { name: "default (provider decides)", value: "" },
+          ...models.map((m) => ({ name: m, value: m }))
+        ],
+        default: existing.model ?? ""
+      });
+      selectedModel = modelChoice || void 0;
+    } else {
+      log.dim("No models returned by provider \u2014 skipping model selection.");
+      selectedModel = existing.model;
+    }
+  } catch {
+    log.dim("Could not list models (provider may not be running) \u2014 skipping model selection.");
+    selectedModel = existing.model;
+  }
+  const detectedSource = await detectDatasource(process.cwd());
+  const datasourceDefault = existing.source ?? "auto";
+  if (detectedSource) {
+    log.info(
+      `Detected datasource ${chalk3.cyan(detectedSource)} from git remote`
+    );
+  }
+  const selectedSource = await select({
+    message: "Select a datasource:",
+    choices: [
+      {
+        name: "auto",
+        value: "auto",
+        description: "detect from git remote at runtime"
+      },
+      ...DATASOURCE_NAMES.map((name) => ({ name, value: name }))
+    ],
+    default: datasourceDefault
+  });
+  const source = selectedSource === "auto" ? void 0 : selectedSource;
+  const newConfig = {
+    provider,
+    source
+  };
+  if (selectedModel !== void 0) {
+    newConfig.model = selectedModel;
+  }
+  console.log();
+  log.info(chalk3.bold("Configuration summary:"));
+  for (const [key, value] of Object.entries(newConfig)) {
+    if (value !== void 0) {
+      console.log(`  ${chalk3.cyan(key)} = ${value}`);
+    }
+  }
+  if (selectedSource === "auto") {
+    console.log(
+      `  ${chalk3.cyan("source")} = auto (detect from git remote at runtime)`
+    );
+  }
+  console.log();
+  const shouldSave = await confirm({
+    message: "Save this configuration?",
+    default: true
+  });
+  if (shouldSave) {
+    await saveConfig(newConfig, configDir);
+    log.success("Configuration saved.");
+  } else {
+    log.dim("Configuration not saved.");
+  }
+}
+
+// src/config.ts
+var CONFIG_KEYS = ["provider", "model", "source", "testTimeout"];
+function getConfigPath(configDir) {
+  const dir = configDir ?? join3(process.cwd(), ".dispatch");
+  return join3(dir, "config.json");
+}
+async function loadConfig(configDir) {
+  const configPath = getConfigPath(configDir);
+  try {
+    const raw = await readFile3(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config, configDir) {
+  const configPath = getConfigPath(configDir);
+  await mkdir2(dirname(configPath), { recursive: true });
+  await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+async function handleConfigCommand(_argv, configDir) {
+  await runInteractiveConfigWizard(configDir);
+}
+
+// src/orchestrator/cli-config.ts
+var CONFIG_TO_CLI = {
+  provider: "provider",
+  model: "model",
+  source: "issueSource",
+  testTimeout: "testTimeout"
+};
+function setCliField(target, key, value) {
+  target[key] = value;
+}
+async function resolveCliConfig(args) {
+  const { explicitFlags } = args;
+  const configDir = join4(args.cwd, ".dispatch");
+  const config = await loadConfig(configDir);
+  const merged = { ...args };
+  for (const configKey of CONFIG_KEYS) {
+    const cliField = CONFIG_TO_CLI[configKey];
+    const configValue = config[configKey];
+    if (configValue !== void 0 && !explicitFlags.has(cliField)) {
+      setCliField(merged, cliField, configValue);
+    }
+  }
+  const providerConfigured = explicitFlags.has("provider") || config.provider !== void 0;
+  if (!providerConfigured) {
+    log.error("Missing required configuration: provider");
+    log.dim("  Run 'dispatch config' to configure defaults interactively.");
+    log.dim("  Or pass it as a CLI flag: --provider <name>");
+    process.exit(1);
+  }
+  if (merged.outputDir) {
+    try {
+      await access(merged.outputDir, constants.W_OK);
+    } catch {
+      log.error(
+        `--output-dir path does not exist or is not writable: ${merged.outputDir}`
+      );
+      process.exit(1);
+    }
+  }
+  const sourceConfigured = explicitFlags.has("issueSource") || config.source !== void 0;
+  const needsSource = !merged.fixTests && !merged.spec && !merged.respec;
+  if (needsSource && !sourceConfigured) {
+    const detected = await detectDatasource(merged.cwd);
+    if (detected) {
+      log.info(`Auto-detected datasource from git remote: ${detected}`);
+      merged.issueSource = detected;
+    } else {
+      log.error("Datasource auto-detection failed \u2014 could not determine issue source from git remote.");
+      log.dim(`  Available datasources: ${DATASOURCE_NAMES.join(", ")}`);
+      log.dim("  Run 'dispatch config' to configure defaults interactively.");
+      log.dim("  Or pass it as a CLI flag: --issue-source <name>");
+      process.exit(1);
+    }
+  }
+  log.verbose = merged.verbose;
+  return merged;
+}
+
+// src/orchestrator/spec-pipeline.ts
+import { join as join6 } from "path";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename2, unlink as unlink2 } from "fs/promises";
+import { glob } from "glob";
+init_providers();
+
+// src/agents/spec.ts
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4, unlink } from "fs/promises";
+import { join as join5 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+init_logger();
+async function boot5(opts) {
+  const { provider } = opts;
+  if (!provider) {
+    throw new Error("Spec agent requires a provider instance in boot options");
+  }
+  return {
+    name: "spec",
+    async generate(genOpts) {
+      const { issue, filePath, fileContent, inlineText, cwd: workingDir, outputPath } = genOpts;
+      try {
+        const tmpDir = join5(workingDir, ".dispatch", "tmp");
+        await mkdir3(tmpDir, { recursive: true });
+        const tmpFilename = `spec-${randomUUID3()}.md`;
+        const tmpPath = join5(tmpDir, tmpFilename);
+        let prompt;
+        if (issue) {
+          prompt = buildSpecPrompt(issue, workingDir, tmpPath);
+        } else if (inlineText) {
+          prompt = buildInlineTextSpecPrompt(inlineText, workingDir, tmpPath);
+        } else if (filePath && fileContent !== void 0) {
+          prompt = buildFileSpecPrompt(filePath, fileContent, workingDir, tmpPath);
+        } else {
+          return {
+            content: "",
+            success: false,
+            error: "Either issue, inlineText, or filePath+fileContent must be provided",
+            valid: false
+          };
+        }
+        const sessionId = await provider.createSession();
+        log.debug(`Spec prompt built (${prompt.length} chars)`);
+        const response = await provider.prompt(sessionId, prompt);
+        if (response === null) {
+          return {
+            content: "",
+            success: false,
+            error: "AI agent returned no response",
+            valid: false
+          };
+        }
+        log.debug(`Spec agent response (${response.length} chars)`);
+        let rawContent;
+        try {
+          rawContent = await readFile4(tmpPath, "utf-8");
+        } catch {
+          return {
+            content: "",
+            success: false,
+            error: `Spec agent did not write the file to ${tmpPath}. Agent response: ${response.slice(0, 300)}`,
+            valid: false
+          };
+        }
+        const cleanedContent = extractSpecContent(rawContent);
+        log.debug(`Post-processed spec (${rawContent.length} \u2192 ${cleanedContent.length} chars)`);
+        const validation = validateSpecStructure(cleanedContent);
+        if (!validation.valid) {
+          log.warn(`Spec validation warning for ${outputPath}: ${validation.reason}`);
+        }
+        await writeFile4(outputPath, cleanedContent, "utf-8");
+        log.debug(`Wrote cleaned spec to ${outputPath}`);
+        try {
+          await unlink(tmpPath);
+        } catch {
+        }
+        return {
+          content: cleanedContent,
+          success: true,
+          valid: validation.valid,
+          validationReason: validation.reason
+        };
+      } catch (err) {
+        const message = log.extractMessage(err);
+        return {
+          content: "",
+          success: false,
+          error: message,
+          valid: false
+        };
+      }
+    },
+    async cleanup() {
+    }
+  };
+}
+function buildSpecPrompt(issue, cwd, outputPath) {
+  const sections = [
+    `You are a **spec agent**. Your job is to explore the codebase, understand the issue below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
+    ``,
+    `**Important:** This file will be consumed by a two-stage pipeline:`,
+    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
+    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
+    ``,
+    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
+    ``,
+    `**CRITICAL \u2014 Output constraints (read carefully):**`,
+    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
+    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
+    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
+    `- **No summaries:** Do not append a summary or recap of what you wrote`,
+    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
+    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
+    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
+    ``,
+    `## Issue Details`,
+    ``,
+    `- **Number:** #${issue.number}`,
+    `- **Title:** ${issue.title}`,
+    `- **State:** ${issue.state}`,
+    `- **URL:** ${issue.url}`
+  ];
+  if (issue.labels.length > 0) {
+    sections.push(`- **Labels:** ${issue.labels.join(", ")}`);
+  }
+  if (issue.body) {
+    sections.push(``, `### Description`, ``, issue.body);
+  }
+  if (issue.acceptanceCriteria) {
+    sections.push(``, `### Acceptance Criteria`, ``, issue.acceptanceCriteria);
+  }
+  if (issue.comments.length > 0) {
+    sections.push(``, `### Discussion`, ``);
+    for (const comment of issue.comments) {
+      sections.push(comment, ``);
+    }
+  }
+  sections.push(
+    ``,
+    `## Working Directory`,
+    ``,
+    `\`${cwd}\``,
+    ``,
+    `## Instructions`,
+    ``,
+    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
+    ``,
+    `2. **Understand the issue** \u2014 analyze the issue description, acceptance criteria, and discussion comments to fully understand what needs to be done and why.`,
+    ``,
+    `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
+    ``,
+    `4. **Identify integration points** \u2014 determine which existing modules, interfaces, patterns, and conventions the implementation must align with. Note the key files and modules involved, but do NOT prescribe exact code changes \u2014 the planner agent will handle that.`,
+    ``,
+    `5. **DO NOT make any code changes** \u2014 you are only producing a spec, not implementing.`,
+    ``,
+    `## Output`,
+    ``,
+    `Write the complete spec as a markdown file to this exact path:`,
+    ``,
+    `\`${outputPath}\``,
+    ``,
+    `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
+    ``,
+    `# <Issue title> (#<number>)`,
+    ``,
+    `> <One-line summary: what this issue achieves and why it matters>`,
+    ``,
+    `## Context`,
+    ``,
+    `<Describe the relevant parts of the codebase: key modules, directory structure,`,
+    `language/framework, and architectural patterns. Name specific files and modules`,
+    `that are involved so the planner agent knows where to look, but do not include`,
+    `code snippets or line-level details.>`,
+    ``,
+    `## Why`,
+    ``,
+    `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
+    `what user or system benefit it provides. Pull from the issue description,`,
+    `acceptance criteria, and discussion.>`,
+    ``,
+    `## Approach`,
+    ``,
+    `<High-level description of the implementation strategy. Explain the overall`,
+    `approach, which patterns to follow, what to extend vs. create new, and how`,
+    `the change fits into the existing architecture. Mention relevant standards,`,
+    `technologies, and conventions the implementation MUST align with.>`,
+    ``,
+    `## Integration Points`,
+    ``,
+    `<List the specific modules, interfaces, configurations, and conventions that`,
+    `the implementation must integrate with. For example: existing provider`,
+    `interfaces to implement, CLI argument patterns to follow, test framework`,
+    `and conventions to match, build system requirements, etc.>`,
+    ``,
+    `## Tasks`,
+    ``,
+    `Each task MUST be prefixed with an execution-mode tag:`,
+    ``,
+    `- \`(P)\` \u2014 **Parallel-safe.** This task has no dependency on the output of a prior task and can run concurrently with other \`(P)\` tasks.`,
+    `- \`(S)\` \u2014 **Serial / dependent.** This task depends on a prior task's output or modifies shared state that conflicts with concurrent work. It acts as a barrier: all preceding tasks complete before it starts, and it completes before subsequent tasks begin.`,
+    `- \`(I)\` \u2014 **Isolated / barrier.** This task must run alone after all preceding tasks complete and before any subsequent tasks begin. Use for validation tasks like running tests, linting, or builds that read the output of prior tasks.`,
+    ``,
+    `**Default to \`(P)\`.** Most tasks are independent (e.g., adding a function in one module, writing tests in another). Only use \`(S)\` when a task genuinely depends on the result of a prior task (e.g., "refactor module X" followed by "update callers of module X"). Use \`(I)\` for validation or barrier tasks that must run alone after all prior work completes (e.g., "run tests", "run linting", "build the project").`,
+    ``,
+    `If a task has no \`(P)\`, \`(S)\`, or \`(I)\` prefix, the system treats it as serial, so always tag explicitly.`,
+    ``,
+    `Example:`,
+    ``,
+    `- [ ] (P) Add validation helper to the form utils module`,
+    `- [ ] (P) Add unit tests for the new validation helper`,
+    `- [ ] (S) Refactor the form component to use the new validation helper`,
+    `- [ ] (P) Update documentation for the form utils module`,
+    `- [ ] (I) Run the full test suite to verify all changes pass`,
+    ``,
+    ``,
+    `## References`,
+    ``,
+    `- <Links to relevant docs, related issues, or external resources>`,
+    ``,
+    `## Key Guidelines`,
+    ``,
+    `- **Stay high-level.** Do NOT include code snippets, exact line numbers, diffs, or step-by-step coding instructions. A dedicated planner agent will produce those details for each task at execution time.`,
+    `- **Respect the project's stack.** Your spec must align with the languages, frameworks, libraries, test tools, and conventions already in use. Never suggest technologies that conflict with the existing project.`,
+    `- **Explain WHAT, WHY, and HOW (strategically).** Each task should say what needs to happen, why it's needed, and which part of the codebase it touches \u2014 but leave the tactical "how" to the planner agent.`,
+    `- **Detail integration points.** The prose sections (Context, Approach, Integration Points) are critical \u2014 they tell the planner agent where to look and what constraints to respect.`,
+    `- **Keep tasks atomic and ordered.** Each \`- [ ]\` task must be a single, clear unit of work. Order them so dependencies come first.`,
+    `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
+    `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
+    `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
+  );
+  return sections.join("\n");
+}
+function buildFileSpecPrompt(filePath, content, cwd, outputPath) {
+  const title = extractTitle(content, filePath);
+  const writePath = outputPath ?? filePath;
+  const sections = [
+    `You are a **spec agent**. Your job is to explore the codebase, understand the content below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
+    ``,
+    `**Important:** This file will be consumed by a two-stage pipeline:`,
+    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
+    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
+    ``,
+    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
+    ``,
+    `**CRITICAL \u2014 Output constraints (read carefully):**`,
+    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
+    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
+    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
+    `- **No summaries:** Do not append a summary or recap of what you wrote`,
+    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
+    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
+    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
+    ``,
+    `## File Details`,
+    ``,
+    `- **Title:** ${title}`,
+    `- **Source file:** ${filePath}`
+  ];
+  if (content) {
+    sections.push(``, `### Content`, ``, content);
+  }
+  sections.push(
+    ``,
+    `## Working Directory`,
+    ``,
+    `\`${cwd}\``,
+    ``,
+    `## Instructions`,
+    ``,
+    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
+    ``,
+    `2. **Understand the content** \u2014 analyze the file content to fully understand what needs to be done and why.`,
+    ``,
+    `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
+    ``,
+    `4. **Identify integration points** \u2014 determine which existing modules, interfaces, patterns, and conventions the implementation must align with. Note the key files and modules involved, but do NOT prescribe exact code changes \u2014 the planner agent will handle that.`,
+    ``,
+    `5. **DO NOT make any code changes** \u2014 you are only producing a spec, not implementing.`,
+    ``,
+    `## Output`,
+    ``,
+    `Write the complete spec as a markdown file to this exact path:`,
+    ``,
+    `\`${writePath}\``,
+    ``,
+    `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
+    ``,
+    `# <Title>`,
+    ``,
+    `> <One-line summary: what this achieves and why it matters>`,
+    ``,
+    `## Context`,
+    ``,
+    `<Describe the relevant parts of the codebase: key modules, directory structure,`,
+    `language/framework, and architectural patterns. Name specific files and modules`,
+    `that are involved so the planner agent knows where to look, but do not include`,
+    `code snippets or line-level details.>`,
+    ``,
+    `## Why`,
+    ``,
+    `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
+    `what user or system benefit it provides. Pull from the file content.>`,
+    ``,
+    `## Approach`,
+    ``,
+    `<High-level description of the implementation strategy. Explain the overall`,
+    `approach, which patterns to follow, what to extend vs. create new, and how`,
+    `the change fits into the existing architecture. Mention relevant standards,`,
+    `technologies, and conventions the implementation MUST align with.>`,
+    ``,
+    `## Integration Points`,
+    ``,
+    `<List the specific modules, interfaces, configurations, and conventions that`,
+    `the implementation must integrate with. For example: existing provider`,
+    `interfaces to implement, CLI argument patterns to follow, test framework`,
+    `and conventions to match, build system requirements, etc.>`,
+    ``,
+    `## Tasks`,
+    ``,
+    `Each task MUST be prefixed with an execution-mode tag:`,
+    ``,
+    `- \`(P)\` \u2014 **Parallel-safe.** This task has no dependency on the output of a prior task and can run concurrently with other \`(P)\` tasks.`,
+    `- \`(S)\` \u2014 **Serial / dependent.** This task depends on a prior task's output or modifies shared state that conflicts with concurrent work. It acts as a barrier: all preceding tasks complete before it starts, and it completes before subsequent tasks begin.`,
+    `- \`(I)\` \u2014 **Isolated / barrier.** This task must run alone after all preceding tasks complete and before any subsequent tasks begin. Use for validation tasks like running tests, linting, or builds that read the output of prior tasks.`,
+    ``,
+    `**Default to \`(P)\`.** Most tasks are independent (e.g., adding a function in one module, writing tests in another). Only use \`(S)\` when a task genuinely depends on the result of a prior task (e.g., "refactor module X" followed by "update callers of module X"). Use \`(I)\` for validation or barrier tasks that must run alone after all prior work completes (e.g., "run tests", "run linting", "build the project").`,
+    ``,
+    `If a task has no \`(P)\`, \`(S)\`, or \`(I)\` prefix, the system treats it as serial, so always tag explicitly.`,
+    ``,
+    `Example:`,
+    ``,
+    `- [ ] (P) Add validation helper to the form utils module`,
+    `- [ ] (P) Add unit tests for the new validation helper`,
+    `- [ ] (S) Refactor the form component to use the new validation helper`,
+    `- [ ] (P) Update documentation for the form utils module`,
+    `- [ ] (I) Run the full test suite to verify all changes pass`,
+    ``,
+    ``,
+    `## References`,
+    ``,
+    `- <Links to relevant docs, related issues, or external resources>`,
+    ``,
+    `## Key Guidelines`,
+    ``,
+    `- **Stay high-level.** Do NOT include code snippets, exact line numbers, diffs, or step-by-step coding instructions. A dedicated planner agent will produce those details for each task at execution time.`,
+    `- **Respect the project's stack.** Your spec must align with the languages, frameworks, libraries, test tools, and conventions already in use. Never suggest technologies that conflict with the existing project.`,
+    `- **Explain WHAT, WHY, and HOW (strategically).** Each task should say what needs to happen, why it's needed, and which part of the codebase it touches \u2014 but leave the tactical "how" to the planner agent.`,
+    `- **Detail integration points.** The prose sections (Context, Approach, Integration Points) are critical \u2014 they tell the planner agent where to look and what constraints to respect.`,
+    `- **Keep tasks atomic and ordered.** Each \`- [ ]\` task must be a single, clear unit of work. Order them so dependencies come first.`,
+    `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
+    `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
+    `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
+  );
+  return sections.join("\n");
+}
+function buildInlineTextSpecPrompt(text, cwd, outputPath) {
+  const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
+  const sections = [
+    `You are a **spec agent**. Your job is to explore the codebase, understand the request below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
+    ``,
+    `**Important:** This file will be consumed by a two-stage pipeline:`,
+    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
+    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
+    ``,
+    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
+    ``,
+    `**CRITICAL \u2014 Output constraints (read carefully):**`,
+    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
+    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
+    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
+    `- **No summaries:** Do not append a summary or recap of what you wrote`,
+    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
+    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
+    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
+    ``,
+    `## Inline Text`,
+    ``,
+    `- **Title:** ${title}`,
+    ``,
+    `### Description`,
+    ``,
+    text
+  ];
+  sections.push(
+    ``,
+    `## Working Directory`,
+    ``,
+    `\`${cwd}\``,
+    ``,
+    `## Instructions`,
+    ``,
+    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
+    ``,
+    `2. **Understand the request** \u2014 analyze the inline text to fully understand what needs to be done and why. Since this is a brief description rather than a detailed issue or document, you may need to infer details from the codebase.`,
+    ``,
+    `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
+    ``,
+    `4. **Identify integration points** \u2014 determine which existing modules, interfaces, patterns, and conventions the implementation must align with. Note the key files and modules involved, but do NOT prescribe exact code changes \u2014 the planner agent will handle that.`,
+    ``,
+    `5. **DO NOT make any code changes** \u2014 you are only producing a spec, not implementing.`,
+    ``,
+    `## Output`,
+    ``,
+    `Write the complete spec as a markdown file to this exact path:`,
+    ``,
+    `\`${outputPath}\``,
+    ``,
+    `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
+    ``,
+    `# <Title>`,
+    ``,
+    `> <One-line summary: what this achieves and why it matters>`,
+    ``,
+    `## Context`,
+    ``,
+    `<Describe the relevant parts of the codebase: key modules, directory structure,`,
+    `language/framework, and architectural patterns. Name specific files and modules`,
+    `that are involved so the planner agent knows where to look, but do not include`,
+    `code snippets or line-level details.>`,
+    ``,
+    `## Why`,
+    ``,
+    `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
+    `what user or system benefit it provides. Pull from the inline text description.>`,
+    ``,
+    `## Approach`,
+    ``,
+    `<High-level description of the implementation strategy. Explain the overall`,
+    `approach, which patterns to follow, what to extend vs. create new, and how`,
+    `the change fits into the existing architecture. Mention relevant standards,`,
+    `technologies, and conventions the implementation MUST align with.>`,
+    ``,
+    `## Integration Points`,
+    ``,
+    `<List the specific modules, interfaces, configurations, and conventions that`,
+    `the implementation must integrate with. For example: existing provider`,
+    `interfaces to implement, CLI argument patterns to follow, test framework`,
+    `and conventions to match, build system requirements, etc.>`,
+    ``,
+    `## Tasks`,
+    ``,
+    `Each task MUST be prefixed with an execution-mode tag:`,
+    ``,
+    `- \`(P)\` \u2014 **Parallel-safe.** This task has no dependency on the output of a prior task and can run concurrently with other \`(P)\` tasks.`,
+    `- \`(S)\` \u2014 **Serial / dependent.** This task depends on a prior task's output or modifies shared state that conflicts with concurrent work. It acts as a barrier: all preceding tasks complete before it starts, and it completes before subsequent tasks begin.`,
+    `- \`(I)\` \u2014 **Isolated / barrier.** This task must run alone after all preceding tasks complete and before any subsequent tasks begin. Use for validation tasks like running tests, linting, or builds that read the output of prior tasks.`,
+    ``,
+    `**Default to \`(P)\`.** Most tasks are independent (e.g., adding a function in one module, writing tests in another). Only use \`(S)\` when a task genuinely depends on the result of a prior task (e.g., "refactor module X" followed by "update callers of module X"). Use \`(I)\` for validation or barrier tasks that must run alone after all prior work completes (e.g., "run tests", "run linting", "build the project").`,
+    ``,
+    `If a task has no \`(P)\`, \`(S)\`, or \`(I)\` prefix, the system treats it as serial, so always tag explicitly.`,
+    ``,
+    `Example:`,
+    ``,
+    `- [ ] (P) Add validation helper to the form utils module`,
+    `- [ ] (P) Add unit tests for the new validation helper`,
+    `- [ ] (S) Refactor the form component to use the new validation helper`,
+    `- [ ] (P) Update documentation for the form utils module`,
+    `- [ ] (I) Run the full test suite to verify all changes pass`,
+    ``,
+    ``,
+    `## References`,
+    ``,
+    `- <Links to relevant docs, related issues, or external resources>`,
+    ``,
+    `## Key Guidelines`,
+    ``,
+    `- **Stay high-level.** Do NOT include code snippets, exact line numbers, diffs, or step-by-step coding instructions. A dedicated planner agent will produce those details for each task at execution time.`,
+    `- **Respect the project's stack.** Your spec must align with the languages, frameworks, libraries, test tools, and conventions already in use. Never suggest technologies that conflict with the existing project.`,
+    `- **Explain WHAT, WHY, and HOW (strategically).** Each task should say what needs to happen, why it's needed, and which part of the codebase it touches \u2014 but leave the tactical "how" to the planner agent.`,
+    `- **Detail integration points.** The prose sections (Context, Approach, Integration Points) are critical \u2014 they tell the planner agent where to look and what constraints to respect.`,
+    `- **Keep tasks atomic and ordered.** Each \`- [ ]\` task must be a single, clear unit of work. Order them so dependencies come first.`,
+    `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
+    `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
+    `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
+  );
+  return sections.join("\n");
+}
+
+// src/orchestrator/spec-pipeline.ts
+init_cleanup();
+init_logger();
+import chalk5 from "chalk";
+
+// src/helpers/format.ts
+import chalk4 from "chalk";
+function elapsed(ms) {
+  const s = Math.floor(ms / 1e3);
+  const m = Math.floor(s / 60);
+  const sec = s % 60;
+  if (m > 0) return `${m}m ${sec}s`;
+  return `${sec}s`;
+}
+function renderHeaderLines(info) {
+  const lines = [];
+  lines.push(chalk4.bold.white("  \u26A1 dispatch") + chalk4.dim(` \u2014 AI task orchestration`));
+  if (info.provider) {
+    lines.push(chalk4.dim(`  provider: ${info.provider}`));
+  }
+  if (info.model) {
+    lines.push(chalk4.dim(`  model: ${info.model}`));
+  }
+  if (info.source) {
+    lines.push(chalk4.dim(`  source: ${info.source}`));
+  }
+  return lines;
+}
+
+// src/helpers/retry.ts
+init_logger();
+async function withRetry(fn, maxRetries, options) {
+  const maxAttempts = maxRetries + 1;
+  const label = options?.label;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const suffix = label ? ` [${label}]` : "";
+      if (attempt < maxAttempts) {
+        log.warn(
+          `Attempt ${attempt}/${maxAttempts} failed${suffix}: ${log.extractMessage(err)}`
+        );
+        log.debug(`Retrying${suffix} (attempt ${attempt + 1}/${maxAttempts})`);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/orchestrator/spec-pipeline.ts
+async function runSpecPipeline(opts) {
+  const {
+    issues,
+    provider,
+    model,
+    serverUrl,
+    cwd: specCwd,
+    outputDir = join6(specCwd, ".dispatch", "specs"),
+    org,
+    project,
+    workItemType,
+    concurrency = defaultConcurrency(),
+    dryRun,
+    retries = 2
+  } = opts;
+  const pipelineStart = Date.now();
+  const source = await resolveSource(issues, opts.issueSource, specCwd);
+  if (!source) {
+    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  const datasource4 = getDatasource(source);
+  const fetchOpts = { cwd: specCwd, org, project, workItemType };
+  const isTrackerMode = isIssueNumbers(issues);
+  const isInlineText = !isTrackerMode && !isGlobOrFilePath(issues);
+  let items;
+  if (isTrackerMode) {
+    const issueNumbers2 = issues.split(",").map((s) => s.trim()).filter(Boolean);
+    if (issueNumbers2.length === 0) {
+      log.error("No issue numbers provided. Use --spec 1,2,3");
+      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: 0, fileDurationsMs: {} };
+    }
+    const fetchStart = Date.now();
+    log.info(`Fetching ${issueNumbers2.length} issue(s) from ${source} (concurrency: ${concurrency})...`);
+    items = [];
+    const fetchQueue = [...issueNumbers2];
+    while (fetchQueue.length > 0) {
+      const batch = fetchQueue.splice(0, concurrency);
+      log.debug(`Fetching batch of ${batch.length}: #${batch.join(", #")}`);
+      const batchResults = await Promise.all(
+        batch.map(async (id) => {
+          try {
+            const details = await datasource4.fetch(id, fetchOpts);
+            log.success(`Fetched #${id}: ${details.title}`);
+            log.debug(`Body: ${details.body?.length ?? 0} chars, Labels: ${details.labels.length}, Comments: ${details.comments.length}`);
+            return { id, details };
+          } catch (err) {
+            const message = log.extractMessage(err);
+            log.error(`Failed to fetch #${id}: ${log.formatErrorChain(err)}`);
+            log.debug(log.formatErrorChain(err));
+            return { id, details: null, error: message };
+          }
+        })
+      );
+      items.push(...batchResults);
+    }
+    log.debug(`Issue fetching completed in ${elapsed(Date.now() - fetchStart)}`);
+  } else if (isInlineText) {
+    const text = Array.isArray(issues) ? issues.join(" ") : issues;
+    const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
+    const slug = slugify(text, MAX_SLUG_LENGTH);
+    const filename = `${slug}.md`;
+    const filepath = join6(outputDir, filename);
+    const details = {
+      number: filepath,
+      title,
+      body: text,
+      labels: [],
+      state: "open",
+      url: filepath,
+      comments: [],
+      acceptanceCriteria: ""
+    };
+    log.info(`Inline text spec: "${title}"`);
+    items = [{ id: filepath, details }];
+  } else {
+    const files = await glob(issues, { cwd: specCwd, absolute: true });
+    if (files.length === 0) {
+      log.error(`No files matched the pattern "${Array.isArray(issues) ? issues.join(", ") : issues}".`);
+      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: 0, fileDurationsMs: {} };
+    }
+    log.info(`Matched ${files.length} file(s) for spec generation (concurrency: ${concurrency})...`);
+    items = [];
+    for (const filePath of files) {
+      try {
+        const content = await readFile5(filePath, "utf-8");
+        const title = extractTitle(content, filePath);
+        const details = {
+          number: filePath,
+          title,
+          body: content,
+          labels: [],
+          state: "open",
+          url: filePath,
+          comments: [],
+          acceptanceCriteria: ""
+        };
+        items.push({ id: filePath, details });
+      } catch (err) {
+        items.push({ id: filePath, details: null, error: log.extractMessage(err) });
+      }
+    }
+  }
+  const validItems = items.filter(
+    (i) => i.details !== null
+  );
+  if (validItems.length === 0) {
+    const noun = isTrackerMode ? "issues" : isInlineText ? "inline specs" : "files";
+    log.error(`No ${noun} could be loaded. Aborting spec generation.`);
+    return { total: items.length, generated: 0, failed: items.length, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  if (dryRun) {
+    const mode = isTrackerMode ? "tracker" : isInlineText ? "inline" : "file";
+    log.info(`[DRY RUN] Would generate ${validItems.length} spec(s) (mode: ${mode}):
+`);
+    for (const { id, details } of validItems) {
+      let filepath;
+      if (isTrackerMode) {
+        const slug = slugify(details.title, 60);
+        filepath = join6(outputDir, `${id}-${slug}.md`);
+      } else {
+        filepath = id;
+      }
+      const label = isTrackerMode ? `#${id}` : filepath;
+      log.info(`[DRY RUN] Would generate spec for ${label}: "${details.title}"`);
+      log.dim(`    \u2192 ${filepath}`);
+    }
+    return {
+      total: items.length,
+      generated: 0,
+      failed: items.filter((i) => i.details === null).length,
+      files: [],
+      issueNumbers: [],
+      durationMs: Date.now() - pipelineStart,
+      fileDurationsMs: {}
+    };
+  }
+  const confirmed = await confirmLargeBatch(validItems.length);
+  if (!confirmed) {
+    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  const bootStart = Date.now();
+  log.info(`Booting ${provider} provider...`);
+  log.debug(serverUrl ? `Using server URL: ${serverUrl}` : "No --server-url, will spawn local server");
+  const instance = await bootProvider(provider, { url: serverUrl, cwd: specCwd, model });
+  registerCleanup(() => instance.cleanup());
+  log.debug(`Provider booted in ${elapsed(Date.now() - bootStart)}`);
+  const headerLines = renderHeaderLines({
+    provider,
+    model: instance.model,
+    source
+  });
+  console.log("");
+  for (const line of headerLines) {
+    console.log(line);
+  }
+  console.log(chalk5.dim("  \u2500".repeat(24)));
+  console.log("");
+  const specAgent = await boot5({ provider: instance, cwd: specCwd });
+  await mkdir4(outputDir, { recursive: true });
+  const generatedFiles = [];
+  const issueNumbers = [];
+  const dispatchIdentifiers = [];
+  let failed = items.filter((i) => i.details === null).length;
+  const fileDurationsMs = {};
+  const genQueue = [...validItems];
+  let modelLoggedInBanner = !!instance.model;
+  while (genQueue.length > 0) {
+    const batch = genQueue.splice(0, concurrency);
+    log.info(`Generating specs for batch of ${batch.length} (${generatedFiles.length + failed}/${items.length} done)...`);
+    const batchResults = await Promise.all(
+      batch.map(async ({ id, details }) => {
+        const specStart = Date.now();
+        if (!details) {
+          log.error(`Skipping item ${id}: missing issue details`);
+          return null;
+        }
+        let filepath;
+        if (isTrackerMode) {
+          const slug = slugify(details.title, MAX_SLUG_LENGTH);
+          const filename = `${id}-${slug}.md`;
+          filepath = join6(outputDir, filename);
+        } else if (isInlineText) {
+          filepath = id;
+        } else {
+          filepath = id;
+        }
+        try {
+          log.info(`Generating spec for ${isTrackerMode ? `#${id}` : filepath}: ${details.title}...`);
+          const result = await withRetry(
+            () => specAgent.generate({
+              issue: isTrackerMode ? details : void 0,
+              filePath: isTrackerMode ? void 0 : id,
+              fileContent: isTrackerMode ? void 0 : details.body,
+              cwd: specCwd,
+              outputPath: filepath
+            }),
+            retries,
+            { label: `specAgent.generate(${isTrackerMode ? `#${id}` : filepath})` }
+          );
+          if (!result.success) {
+            throw new Error(result.error ?? "Spec generation failed");
+          }
+          if (isTrackerMode || isInlineText) {
+            const h1Title = extractTitle(result.content, filepath);
+            const h1Slug = slugify(h1Title, MAX_SLUG_LENGTH);
+            const finalFilename = isTrackerMode ? `${id}-${h1Slug}.md` : `${h1Slug}.md`;
+            const finalFilepath = join6(outputDir, finalFilename);
+            if (finalFilepath !== filepath) {
+              await rename2(filepath, finalFilepath);
+              filepath = finalFilepath;
+            }
+          }
+          const specDuration = Date.now() - specStart;
+          fileDurationsMs[filepath] = specDuration;
+          log.success(`Spec written: ${filepath} (${elapsed(specDuration)})`);
+          let identifier = filepath;
+          try {
+            if (isTrackerMode) {
+              await datasource4.update(id, details.title, result.content, fetchOpts);
+              log.success(`Updated issue #${id} with spec content`);
+              await unlink2(filepath);
+              log.success(`Deleted local spec ${filepath} (now tracked as issue #${id})`);
+              identifier = id;
+              issueNumbers.push(id);
+            } else if (datasource4.name !== "md") {
+              const created = await datasource4.create(details.title, result.content, fetchOpts);
+              log.success(`Created issue #${created.number} from ${filepath}`);
+              await unlink2(filepath);
+              log.success(`Deleted local spec ${filepath} (now tracked as issue #${created.number})`);
+              identifier = created.number;
+              issueNumbers.push(created.number);
+            }
+          } catch (err) {
+            const label = isTrackerMode ? `issue #${id}` : filepath;
+            log.warn(`Could not sync ${label} to datasource: ${log.formatErrorChain(err)}`);
+          }
+          return { filepath, identifier };
+        } catch (err) {
+          log.error(`Failed to generate spec for ${isTrackerMode ? `#${id}` : filepath}: ${log.formatErrorChain(err)}`);
+          log.debug(log.formatErrorChain(err));
+          return null;
+        }
+      })
+    );
+    for (const result of batchResults) {
+      if (result !== null) {
+        generatedFiles.push(result.filepath);
+        dispatchIdentifiers.push(result.identifier);
+      } else {
+        failed++;
+      }
+    }
+    if (!modelLoggedInBanner && instance.model) {
+      log.info(`Detected model: ${instance.model}`);
+      modelLoggedInBanner = true;
+    }
+  }
+  try {
+    await specAgent.cleanup();
+  } catch (err) {
+    log.warn(`Spec agent cleanup failed: ${log.formatErrorChain(err)}`);
+  }
+  try {
+    await instance.cleanup();
+  } catch (err) {
+    log.warn(`Provider cleanup failed: ${log.formatErrorChain(err)}`);
+  }
+  const totalDuration = Date.now() - pipelineStart;
+  log.info(
+    `Spec generation complete: ${generatedFiles.length} generated, ${failed} failed in ${elapsed(totalDuration)}`
+  );
+  if (generatedFiles.length > 0) {
+    log.dim(`
+  Run these specs with:`);
+    const allNumeric = dispatchIdentifiers.every((id) => /^\d+$/.test(id));
+    if (allNumeric) {
+      log.dim(`    dispatch ${dispatchIdentifiers.join(",")}
+`);
+    } else {
+      log.dim(`    dispatch ${dispatchIdentifiers.map((f) => '"' + f + '"').join(" ")}
+`);
+    }
+  }
+  return {
+    total: items.length,
+    generated: generatedFiles.length,
+    failed,
+    files: generatedFiles,
+    issueNumbers,
+    identifiers: dispatchIdentifiers,
+    durationMs: totalDuration,
+    fileDurationsMs
+  };
+}
+
+// src/orchestrator/dispatch-pipeline.ts
+import { readFile as readFile7 } from "fs/promises";
+
+// src/parser.ts
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+var UNCHECKED_RE = /^(\s*[-*]\s)\[ \]\s+(.+)$/;
+var CHECKED_SUB = "$1[x] $2";
+var MODE_PREFIX_RE = /^\(([PSI])\)\s+/;
+function buildTaskContext(content, task) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const filtered = lines.filter((line, i) => {
+    if (i + 1 === task.line) return true;
+    if (UNCHECKED_RE.test(line)) return false;
+    return true;
+  });
+  return filtered.join("\n");
+}
+function parseTaskContent(content, filePath) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const tasks = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(UNCHECKED_RE);
+    if (match) {
+      let text = match[2].trim();
+      let mode = "serial";
+      const modeMatch = text.match(MODE_PREFIX_RE);
+      if (modeMatch) {
+        const modeMap = {
+          P: "parallel",
+          S: "serial",
+          I: "isolated"
+        };
+        mode = modeMap[modeMatch[1]] ?? "serial";
+        text = text.slice(modeMatch[0].length);
+      }
+      tasks.push({
+        index: tasks.length,
+        text,
+        line: i + 1,
+        raw: lines[i],
+        file: filePath,
+        mode
+      });
+    }
+  }
+  return { path: filePath, tasks, content };
+}
+async function parseTaskFile(filePath) {
+  const content = await readFile6(filePath, "utf-8");
+  return parseTaskContent(content, filePath);
+}
+async function markTaskComplete(task) {
+  const content = await readFile6(task.file, "utf-8");
+  const lines = content.split("\n");
+  const lineIndex = task.line - 1;
+  if (lineIndex < 0 || lineIndex >= lines.length) {
+    throw new Error(
+      `Line ${task.line} out of range in ${task.file} (${lines.length} lines)`
+    );
+  }
+  const original = lines[lineIndex];
+  const updated = original.replace(UNCHECKED_RE, CHECKED_SUB);
+  if (original === updated) {
+    throw new Error(
+      `Line ${task.line} in ${task.file} does not match expected unchecked pattern: "${original}"`
+    );
+  }
+  lines[lineIndex] = updated;
+  await writeFile5(task.file, lines.join("\n"), "utf-8");
+}
+function groupTasksByMode(tasks) {
+  if (tasks.length === 0) return [];
+  const groups = [];
+  let current = [];
+  for (const task of tasks) {
+    const mode = task.mode ?? "serial";
+    if (mode === "parallel") {
+      current.push(task);
+    } else if (mode === "isolated") {
+      if (current.length > 0) {
+        groups.push(current);
+        current = [];
+      }
+      groups.push([task]);
+    } else {
+      current.push(task);
+      groups.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) {
+    groups.push(current);
+  }
+  return groups;
+}
+
+// src/agents/planner.ts
+init_logger();
+async function boot6(opts) {
+  const { provider, cwd } = opts;
+  if (!provider) {
+    throw new Error("Planner agent requires a provider instance in boot options");
+  }
+  return {
+    name: "planner",
+    async plan(task, fileContext, cwdOverride) {
+      try {
+        const sessionId = await provider.createSession();
+        const prompt = buildPlannerPrompt(task, cwdOverride ?? cwd, fileContext);
+        const plan = await provider.prompt(sessionId, prompt);
+        if (!plan?.trim()) {
+          return { prompt: "", success: false, error: "Planner returned empty plan" };
+        }
+        return { prompt: plan, success: true };
+      } catch (err) {
+        const message = log.extractMessage(err);
+        return { prompt: "", success: false, error: message };
+      }
+    },
+    async cleanup() {
+    }
+  };
+}
+function buildPlannerPrompt(task, cwd, fileContext) {
+  const sections = [
+    `You are a **planning agent**. Your job is to explore the codebase, understand the task below, and produce a detailed execution prompt that another agent will follow to implement the changes.`,
+    ``,
+    `## Task`,
+    `- **Working directory:** ${cwd}`,
+    `- **Source file:** ${task.file}`,
+    `- **Task (line ${task.line}):** ${task.text}`
+  ];
+  if (fileContext) {
+    sections.push(
+      ``,
+      `## Task File Contents`,
+      ``,
+      `The task comes from a markdown file that may contain important implementation`,
+      `details, requirements, and context in its non-task content (headings, prose,`,
+      `notes). Review this carefully \u2014 it may describe conventions, constraints, or`,
+      `technical details that are critical for the implementation.`,
+      ``,
+      `\`\`\`markdown`,
+      fileContext,
+      `\`\`\``
+    );
+  }
+  sections.push(
+    ``,
+    `## Instructions`,
+    ``,
+    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, and understand the project structure, conventions, and patterns.`,
+    `2. **Review the task file contents above** \u2014 pay close attention to non-task text (headings, prose, notes) as it often contains important implementation details, requirements, and constraints.`,
+    `3. **Identify the files** that need to be created or modified to complete this task.`,
+    `4. **Research the implementation** \u2014 understand the existing code patterns, imports, types, and APIs involved.`,
+    `5. **DO NOT make any changes** \u2014 you are only planning, not executing.`,
+    ``,
+    `## Output Format`,
+    ``,
+    `Produce your response as a **system prompt for an executor agent**. The executor will receive your output verbatim as its instructions. Write it in second person ("You will...", "Modify the file...").`,
+    ``,
+    `Your output MUST include:`,
+    ``,
+    `1. **Context** \u2014 A brief summary of the relevant project structure, conventions, and patterns the executor needs to know. Include any important details from the task file's non-task content.`,
+    `2. **Files to modify** \u2014 The exact file paths that need to be created or changed, with the rationale for each.`,
+    `3. **Step-by-step implementation** \u2014 Precise, ordered steps the executor should follow. Include:`,
+    `   - Exact file paths`,
+    `   - What to add, change, or remove`,
+    `   - Code snippets, type signatures, or patterns to follow (based on existing code you read)`,
+    `   - Import statements needed`,
+    `4. **Constraints** \u2014 Any important constraints:`,
+    `   - If the task description includes a commit instruction, include a final step in the plan to commit the changes using conventional commit conventions (supported types: feat, fix, docs, refactor, test, chore, style, perf, ci). If the task does not mention committing, instruct the executor to NOT commit changes.`,
+    `   - Make minimal, correct changes \u2014 do not refactor unrelated code.`,
+    `   - Follow existing code style and conventions found in the project.`,
+    ``,
+    `Be specific and concrete. Reference actual code you found during exploration. The executor has no prior context about this codebase \u2014 your prompt is all it gets.`
+  );
+  return sections.join("\n");
+}
+
+// src/dispatcher.ts
+init_logger();
+async function dispatchTask(instance, task, cwd, plan) {
+  try {
+    log.debug(`Dispatching task: ${task.file}:${task.line} \u2014 ${task.text.slice(0, 80)}`);
+    const sessionId = await instance.createSession();
+    const prompt = plan ? buildPlannedPrompt(task, cwd, plan) : buildPrompt(task, cwd);
+    log.debug(`Prompt built (${prompt.length} chars, ${plan ? "with plan" : "no plan"})`);
+    const response = await instance.prompt(sessionId, prompt);
+    if (response === null) {
+      log.debug("Task dispatch returned null response");
+      return { task, success: false, error: "No response from agent" };
+    }
+    log.debug(`Task dispatch completed (${response.length} chars response)`);
+    return { task, success: true };
+  } catch (err) {
+    const message = log.extractMessage(err);
+    log.debug(`Task dispatch failed: ${log.formatErrorChain(err)}`);
+    return { task, success: false, error: message };
+  }
+}
+function buildPrompt(task, cwd) {
+  return [
+    `You are completing a task from a markdown task file.`,
+    ``,
+    `**Working directory:** ${cwd}`,
+    `**Source file:** ${task.file}`,
+    `**Task (line ${task.line}):** ${task.text}`,
+    ``,
+    `Instructions:`,
+    `- Complete ONLY this specific task \u2014 do not work on other tasks.`,
+    `- Make the minimal, correct changes needed.`,
+    buildCommitInstruction(task.text),
+    `- When finished, confirm by saying "Task complete."`
+  ].join("\n");
+}
+function buildPlannedPrompt(task, cwd, plan) {
+  return [
+    `You are an **executor agent** completing a task that has been pre-planned by a planner agent.`,
+    `The planner has already explored the codebase and produced detailed instructions below.`,
+    ``,
+    `**Working directory:** ${cwd}`,
+    `**Source file:** ${task.file}`,
+    `**Task (line ${task.line}):** ${task.text}`,
+    ``,
+    `---`,
+    ``,
+    `## Execution Plan`,
+    ``,
+    plan,
+    ``,
+    `---`,
+    ``,
+    `## Executor Constraints`,
+    `- Follow the plan above precisely \u2014 do not deviate, skip steps, or reorder.`,
+    `- Complete ONLY this specific task \u2014 do not work on other tasks.`,
+    `- Make the minimal, correct changes needed \u2014 do not refactor unrelated code.`,
+    `- Do NOT explore the codebase. The planner has already done all necessary research. Only read or modify the files explicitly referenced in the plan.`,
+    `- Do NOT re-plan, question, or revise the plan. Trust it as given and execute it faithfully.`,
+    `- Do NOT search for additional context using grep, find, or similar tools unless the plan explicitly instructs you to.`,
+    buildCommitInstruction(task.text),
+    `- When finished, confirm by saying "Task complete."`
+  ].join("\n");
+}
+function taskRequestsCommit(taskText) {
+  return /\bcommit\b/i.test(taskText);
+}
+function buildCommitInstruction(taskText) {
+  if (taskRequestsCommit(taskText)) {
+    return `- The task description includes a commit instruction. After completing the implementation, stage all changes and create a conventional commit. Use one of these types: feat, fix, docs, refactor, test, chore, style, perf, ci.`;
+  }
+  return `- Do NOT commit changes \u2014 the orchestrator handles commits.`;
+}
+
+// src/agents/executor.ts
+init_logger();
+async function boot7(opts) {
+  const { provider } = opts;
+  if (!provider) {
+    throw new Error("Executor agent requires a provider instance in boot options");
+  }
+  return {
+    name: "executor",
+    async execute(input2) {
+      const { task, cwd, plan } = input2;
+      const startTime = Date.now();
+      try {
+        const result = await dispatchTask(provider, task, cwd, plan ?? void 0);
+        if (result.success) {
+          await markTaskComplete(task);
+        }
+        return {
+          dispatchResult: result,
+          success: result.success,
+          error: result.error,
+          elapsedMs: Date.now() - startTime
+        };
+      } catch (err) {
+        const message = log.extractMessage(err);
+        return {
+          dispatchResult: { task, success: false, error: message },
+          success: false,
+          error: message,
+          elapsedMs: Date.now() - startTime
+        };
+      }
+    },
+    async cleanup() {
+    }
+  };
+}
+
+// src/agents/commit.ts
+init_logger();
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+async function boot8(opts) {
+  const { provider } = opts;
+  if (!provider) {
+    throw new Error(
+      "Commit agent requires a provider instance in boot options"
+    );
+  }
+  return {
+    name: "commit",
+    async generate(genOpts) {
+      try {
+        const tmpDir = join7(genOpts.cwd, ".dispatch", "tmp");
+        await mkdir5(tmpDir, { recursive: true });
+        const tmpFilename = `commit-${randomUUID4()}.md`;
+        const tmpPath = join7(tmpDir, tmpFilename);
+        const prompt = buildCommitPrompt(genOpts);
+        const sessionId = await provider.createSession();
+        log.debug(`Commit prompt built (${prompt.length} chars)`);
+        const response = await provider.prompt(sessionId, prompt);
+        if (!response?.trim()) {
+          return {
+            commitMessage: "",
+            prTitle: "",
+            prDescription: "",
+            success: false,
+            error: "Commit agent returned empty response"
+          };
+        }
+        log.debug(`Commit agent response (${response.length} chars)`);
+        const parsed = parseCommitResponse(response);
+        if (!parsed.commitMessage && !parsed.prTitle) {
+          return {
+            commitMessage: "",
+            prTitle: "",
+            prDescription: "",
+            success: false,
+            error: "Failed to parse commit agent response: no commit message or PR title found"
+          };
+        }
+        const outputContent = formatOutputFile(parsed);
+        await writeFile6(tmpPath, outputContent, "utf-8");
+        log.debug(`Wrote commit agent output to ${tmpPath}`);
+        return {
+          ...parsed,
+          success: true,
+          outputPath: tmpPath
+        };
+      } catch (err) {
+        const message = log.extractMessage(err);
+        return {
+          commitMessage: "",
+          prTitle: "",
+          prDescription: "",
+          success: false,
+          error: message
+        };
+      }
+    },
+    async cleanup() {
+    }
+  };
+}
+function buildCommitPrompt(opts) {
+  const { branchDiff, issue, taskResults } = opts;
+  const sections = [
+    `You are a **commit message agent**. Your job is to analyze the git diff below and generate a meaningful, conventional-commit-compliant commit message, a PR title, and a PR description.`,
+    ``,
+    `## Conventional Commit Guidelines`,
+    ``,
+    `Follow the Conventional Commits specification (https://www.conventionalcommits.org/):`,
+    `- Format: \`<type>(<optional scope>): <description>\``,
+    `- Types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\``,
+    `- The description should be concise, imperative mood, lowercase first letter, no period at the end`,
+    `- If the change includes breaking changes, add \`!\` after the type/scope (e.g., \`feat!: ...\`)`,
+    ``,
+    `## Issue Context`,
+    ``,
+    `- **Issue #${issue.number}:** ${issue.title}`
+  ];
+  if (issue.body) {
+    sections.push(
+      `- **Description:** ${issue.body.slice(0, 500)}${issue.body.length > 500 ? "..." : ""}`
+    );
+  }
+  if (issue.labels.length > 0) {
+    sections.push(`- **Labels:** ${issue.labels.join(", ")}`);
+  }
+  const completed = taskResults.filter((r) => r.success);
+  const failed = taskResults.filter((r) => !r.success);
+  if (taskResults.length > 0) {
+    sections.push(``, `## Tasks`);
+    if (completed.length > 0) {
+      sections.push(``, `### Completed`);
+      for (const r of completed) {
+        sections.push(`- ${r.task.text}`);
+      }
+    }
+    if (failed.length > 0) {
+      sections.push(``, `### Failed`);
+      for (const r of failed) {
+        sections.push(
+          `- ${r.task.text}${r.error ? ` (error: ${r.error})` : ""}`
+        );
+      }
+    }
+  }
+  const maxDiffLength = 5e4;
+  const truncatedDiff = branchDiff.length > maxDiffLength ? branchDiff.slice(0, maxDiffLength) + "\n\n... (diff truncated due to size)" : branchDiff;
+  sections.push(
+    ``,
+    `## Git Diff`,
+    ``,
+    `\`\`\`diff`,
+    truncatedDiff,
+    `\`\`\``,
+    ``,
+    `## Required Output Format`,
+    ``,
+    `You MUST respond with exactly the following three sections, using these exact headers:`,
+    ``,
+    `### COMMIT_MESSAGE`,
+    `<your conventional commit message here>`,
+    ``,
+    `### PR_TITLE`,
+    `<your PR title here>`,
+    ``,
+    `### PR_DESCRIPTION`,
+    `<your PR description in markdown here>`,
+    ``,
+    `**Rules:**`,
+    `- The commit message MUST follow conventional commit format`,
+    `- The PR title should be a concise, descriptive summary of the overall change`,
+    `- The PR description should explain what changed and why, referencing the issue context`,
+    `- Do NOT include any text outside these three sections`
+  );
+  return sections.join("\n");
+}
+function parseCommitResponse(response) {
+  const result = {
+    commitMessage: "",
+    prTitle: "",
+    prDescription: ""
+  };
+  const commitMatch = response.match(
+    /###\s*COMMIT_MESSAGE\s*\n([\s\S]*?)(?=###\s*PR_TITLE|$)/i
+  );
+  const titleMatch = response.match(
+    /###\s*PR_TITLE\s*\n([\s\S]*?)(?=###\s*PR_DESCRIPTION|$)/i
+  );
+  const descMatch = response.match(
+    /###\s*PR_DESCRIPTION\s*\n([\s\S]*?)$/i
+  );
+  if (commitMatch?.[1]) {
+    result.commitMessage = commitMatch[1].trim();
+  }
+  if (titleMatch?.[1]) {
+    result.prTitle = titleMatch[1].trim();
+  }
+  if (descMatch?.[1]) {
+    result.prDescription = descMatch[1].trim();
+  }
+  return result;
+}
+function formatOutputFile(parsed) {
+  const sections = [
+    `# Commit Agent Output`,
+    ``,
+    `## Commit Message`,
+    ``,
+    parsed.commitMessage,
+    ``,
+    `## PR Title`,
+    ``,
+    parsed.prTitle,
+    ``,
+    `## PR Description`,
+    ``,
+    parsed.prDescription,
+    ``
+  ];
+  return sections.join("\n");
+}
+
+// src/orchestrator/dispatch-pipeline.ts
+init_logger();
+init_cleanup();
+
+// src/helpers/worktree.ts
+import { join as join8, basename } from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+init_logger();
+var exec7 = promisify7(execFile7);
+var WORKTREE_DIR = ".dispatch/worktrees";
+async function git2(args, cwd) {
+  const { stdout } = await exec7("git", args, { cwd });
+  return stdout;
+}
+function worktreeName(issueFilename) {
+  const base = basename(issueFilename);
+  const withoutExt = base.replace(/\.md$/i, "");
+  return slugify(withoutExt);
+}
+async function createWorktree(repoRoot, issueFilename, branchName) {
+  const name = worktreeName(issueFilename);
+  const worktreePath = join8(repoRoot, WORKTREE_DIR, name);
+  try {
+    await git2(["worktree", "add", worktreePath, "-b", branchName], repoRoot);
+    log.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
+  } catch (err) {
+    const message = log.extractMessage(err);
+    if (message.includes("already exists")) {
+      await git2(["worktree", "add", worktreePath, branchName], repoRoot);
+      log.debug(`Created worktree at ${worktreePath} using existing branch ${branchName}`);
+    } else {
+      throw err;
+    }
+  }
+  return worktreePath;
+}
+async function removeWorktree(repoRoot, issueFilename) {
+  const name = worktreeName(issueFilename);
+  const worktreePath = join8(repoRoot, WORKTREE_DIR, name);
+  try {
+    await git2(["worktree", "remove", worktreePath], repoRoot);
+  } catch {
+    try {
+      await git2(["worktree", "remove", "--force", worktreePath], repoRoot);
+    } catch (err) {
+      log.warn(`Could not remove worktree ${name}: ${log.formatErrorChain(err)}`);
+      return;
+    }
+  }
+  try {
+    await git2(["worktree", "prune"], repoRoot);
+  } catch (err) {
+    log.warn(`Could not prune worktrees: ${log.formatErrorChain(err)}`);
+  }
+}
+
+// src/tui.ts
+import chalk6 from "chalk";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var BAR_WIDTH = 30;
+var spinnerIndex = 0;
+var interval = null;
+var lastLineCount = 0;
+function spinner() {
+  return chalk6.cyan(SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length]);
+}
+function progressBar(done, total) {
+  if (total === 0) return chalk6.dim("\u2591".repeat(BAR_WIDTH));
+  const filled = Math.round(done / total * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const pct = Math.round(done / total * 100);
+  return chalk6.green("\u2588".repeat(filled)) + chalk6.dim("\u2591".repeat(empty)) + chalk6.white(` ${pct}%`);
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pending":
+      return chalk6.dim("\u25CB");
+    case "planning":
+      return spinner();
+    case "running":
+      return spinner();
+    case "done":
+      return chalk6.green("\u25CF");
+    case "failed":
+      return chalk6.red("\u2716");
+  }
+}
+function statusLabel(status) {
+  switch (status) {
+    case "pending":
+      return chalk6.dim("pending");
+    case "planning":
+      return chalk6.magenta("planning");
+    case "running":
+      return chalk6.cyan("executing");
+    case "done":
+      return chalk6.green("done");
+    case "failed":
+      return chalk6.red("failed");
+  }
+}
+function phaseLabel(phase, provider) {
+  switch (phase) {
+    case "discovering":
+      return `${spinner()} Discovering task files...`;
+    case "parsing":
+      return `${spinner()} Parsing tasks...`;
+    case "booting": {
+      const name = provider ?? "provider";
+      return `${spinner()} Connecting to ${name}...`;
+    }
+    case "dispatching":
+      return `${spinner()} Dispatching tasks...`;
+    case "done":
+      return chalk6.green("\u2714") + " Complete";
+  }
+}
+function countVisualRows(text, cols) {
+  const stripped = text.replace(/\x1B\[[0-9;]*m/g, "");
+  const safeCols = Math.max(1, cols);
+  return stripped.split("\n").reduce((sum, line) => {
+    return sum + Math.max(1, Math.ceil(line.length / safeCols));
+  }, 0);
+}
+function render(state) {
+  const lines = [];
+  const now = Date.now();
+  const totalElapsed = elapsed(now - state.startTime);
+  const done = state.tasks.filter((t) => t.status === "done").length;
+  const failed = state.tasks.filter((t) => t.status === "failed").length;
+  const total = state.tasks.length;
+  lines.push("");
+  lines.push(
+    ...renderHeaderLines({
+      provider: state.provider,
+      model: state.model,
+      source: state.source
+    })
+  );
+  if (state.currentIssue) {
+    lines.push(
+      chalk6.dim(`  issue: `) + chalk6.white(`#${state.currentIssue.number}`) + chalk6.dim(` \u2014 ${state.currentIssue.title}`)
+    );
+  }
+  lines.push(chalk6.dim("  \u2500".repeat(24)));
+  lines.push(`  ${phaseLabel(state.phase, state.provider)}` + chalk6.dim(`  ${totalElapsed}`));
+  if (state.phase === "dispatching" || state.phase === "done") {
+    lines.push("");
+    lines.push(`  ${progressBar(done + failed, total)}  ${chalk6.dim(`${done + failed}/${total} tasks`)}`);
+    lines.push("");
+    const activeWorktrees = new Set(
+      state.tasks.map((t) => t.worktree).filter(Boolean)
+    );
+    const showWorktree = activeWorktrees.size > 1;
+    const cols = process.stdout.columns || 80;
+    const maxTextLen = cols - 30;
+    const running = state.tasks.filter((t) => t.status === "running" || t.status === "planning");
+    const completed = state.tasks.filter(
+      (t) => t.status === "done" || t.status === "failed"
+    );
+    const pending = state.tasks.filter((t) => t.status === "pending");
+    if (showWorktree) {
+      const groups = /* @__PURE__ */ new Map();
+      const ungrouped = [];
+      for (const ts of state.tasks) {
+        if (ts.worktree) {
+          const arr = groups.get(ts.worktree) ?? [];
+          arr.push(ts);
+          groups.set(ts.worktree, arr);
+        } else {
+          ungrouped.push(ts);
+        }
+      }
+      const doneGroups = [];
+      const activeGroups = [];
+      for (const [wt, tasks] of groups) {
+        const allDone = tasks.every((t) => t.status === "done" || t.status === "failed");
+        if (allDone) {
+          doneGroups.push([wt, tasks]);
+        } else {
+          activeGroups.push([wt, tasks]);
+        }
+      }
+      if (doneGroups.length > 3) {
+        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${doneGroups.length - 3} earlier issue(s) completed`));
+      }
+      for (const [wt, tasks] of doneGroups.slice(-3)) {
+        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
+        const anyFailed = tasks.some((t) => t.status === "failed");
+        const icon = anyFailed ? chalk6.red("\u2716") : chalk6.green("\u25CF");
+        const doneCount = tasks.filter((t) => t.status === "done").length;
+        const maxElapsed = Math.max(...tasks.map((t) => t.elapsed ?? 0));
+        lines.push(`  ${icon} ${chalk6.dim(`#${issueNum}`)}  ${chalk6.dim(`${doneCount}/${tasks.length} tasks`)}  ${chalk6.dim(elapsed(maxElapsed))}`);
+      }
+      for (const [wt, tasks] of activeGroups) {
+        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
+        const activeTasks = tasks.filter((t) => t.status === "running" || t.status === "planning");
+        const activeCount = activeTasks.length;
+        const firstActive = activeTasks[0];
+        const truncLen = Math.min(cols - 26, 60);
+        let text = firstActive?.task.text ?? "";
+        if (text.length > truncLen) {
+          text = text.slice(0, truncLen - 1) + "\u2026";
+        }
+        const earliest = Math.min(...activeTasks.map((t) => t.elapsed ?? now));
+        const elapsedStr = elapsed(now - earliest);
+        lines.push(`  ${spinner()} ${chalk6.white(`#${issueNum}`)}  ${activeCount} active  ${text}  ${chalk6.dim(elapsedStr)}`);
+      }
+      for (const ts of ungrouped) {
+        if (ts.status !== "running" && ts.status !== "planning") continue;
+        const icon = statusIcon(ts.status);
+        const idx = chalk6.dim(`#${state.tasks.indexOf(ts) + 1}`);
+        let text = ts.task.text;
+        if (text.length > maxTextLen) {
+          text = text.slice(0, maxTextLen - 1) + "\u2026";
+        }
+        const elapsedStr = chalk6.dim(` ${elapsed(now - (ts.elapsed || now))}`);
+        const label = statusLabel(ts.status);
+        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
+        if (ts.error) {
+          lines.push(chalk6.red(`       \u2514\u2500 ${ts.error}`));
+        }
+      }
+    } else {
+      const visibleRunning = running.slice(0, 8);
+      const visible = [
+        ...completed.slice(-3),
+        ...visibleRunning,
+        ...pending.slice(0, 3)
+      ];
+      if (completed.length > 3) {
+        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${completed.length - 3} earlier task(s) completed`));
+      }
+      for (const ts of visible) {
+        const icon = statusIcon(ts.status);
+        const idx = chalk6.dim(`#${state.tasks.indexOf(ts) + 1}`);
+        let text = ts.task.text;
+        if (text.length > maxTextLen) {
+          text = text.slice(0, maxTextLen - 1) + "\u2026";
+        }
+        const elapsedStr = ts.status === "running" || ts.status === "planning" ? chalk6.dim(` ${elapsed(now - (ts.elapsed || now))}`) : ts.status === "done" && ts.elapsed ? chalk6.dim(` ${elapsed(ts.elapsed)}`) : "";
+        const label = statusLabel(ts.status);
+        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
+        if (ts.error) {
+          lines.push(chalk6.red(`       \u2514\u2500 ${ts.error}`));
+        }
+      }
+      if (running.length > 8) {
+        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${running.length - 8} more running`));
+      }
+      if (pending.length > 3) {
+        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${pending.length - 3} more task(s) pending`));
+      }
+    }
+    lines.push("");
+    const parts = [];
+    if (done > 0) parts.push(chalk6.green(`${done} passed`));
+    if (failed > 0) parts.push(chalk6.red(`${failed} failed`));
+    if (total - done - failed > 0)
+      parts.push(chalk6.dim(`${total - done - failed} remaining`));
+    lines.push(`  ${parts.join(chalk6.dim(" \xB7 "))}`);
+  } else if (state.filesFound > 0) {
+    lines.push(chalk6.dim(`  Found ${state.filesFound} file(s)`));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function draw(state) {
+  if (lastLineCount > 0) {
+    process.stdout.write(`\x1B[${lastLineCount}A\x1B[0J`);
+  }
+  const output = render(state);
+  process.stdout.write(output);
+  const cols = process.stdout.columns || 80;
+  lastLineCount = countVisualRows(output, cols);
+}
+function createTui() {
+  const state = {
+    tasks: [],
+    phase: "discovering",
+    startTime: Date.now(),
+    filesFound: 0
+  };
+  interval = setInterval(() => {
+    spinnerIndex++;
+    draw(state);
+  }, 80);
+  const update = () => draw(state);
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    draw(state);
+  };
+  draw(state);
+  return { state, update, stop };
+}
+
+// src/orchestrator/dispatch-pipeline.ts
+init_providers();
+
+// src/orchestrator/datasource-helpers.ts
+init_logger();
+import { basename as basename2, join as join9 } from "path";
+import { mkdtemp, writeFile as writeFile7 } from "fs/promises";
+import { tmpdir } from "os";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
+var exec8 = promisify8(execFile8);
+function parseIssueFilename(filePath) {
+  const filename = basename2(filePath);
+  const match = /^(\d+)-(.+)\.md$/.exec(filename);
+  if (!match) return null;
+  return { issueId: match[1], slug: match[2] };
+}
+async function fetchItemsById(issueIds, datasource4, fetchOpts) {
+  const ids = issueIds.flatMap(
+    (id) => id.split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  const items = [];
+  for (const id of ids) {
+    try {
+      const item = await datasource4.fetch(id, fetchOpts);
+      items.push(item);
+    } catch (err) {
+      log.warn(`Could not fetch issue #${id}: ${log.formatErrorChain(err)}`);
+    }
+  }
+  return items;
+}
+async function writeItemsToTempDir(items) {
+  const tempDir = await mkdtemp(join9(tmpdir(), "dispatch-"));
+  const files = [];
+  const issueDetailsByFile = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const slug = slugify(item.title, MAX_SLUG_LENGTH);
+    const filename = `${item.number}-${slug}.md`;
+    const filepath = join9(tempDir, filename);
+    await writeFile7(filepath, item.body, "utf-8");
+    files.push(filepath);
+    issueDetailsByFile.set(filepath, item);
+  }
+  files.sort((a, b) => {
+    const numA = parseInt(basename2(a).match(/^(\d+)/)?.[1] ?? "0", 10);
+    const numB = parseInt(basename2(b).match(/^(\d+)/)?.[1] ?? "0", 10);
+    if (numA !== numB) return numA - numB;
+    return a.localeCompare(b);
+  });
+  return { files, issueDetailsByFile };
+}
+async function closeCompletedSpecIssues(taskFiles, results, cwd, source, org, project, workItemType) {
+  let datasourceName = source;
+  if (!datasourceName) {
+    datasourceName = await detectDatasource(cwd) ?? void 0;
+  }
+  if (!datasourceName) return;
+  const datasource4 = getDatasource(datasourceName);
+  const succeededTasks = new Set(
+    results.filter((r) => r.success).map((r) => r.task)
+  );
+  const fetchOpts = { cwd, org, project, workItemType };
+  for (const taskFile of taskFiles) {
+    const fileTasks = taskFile.tasks;
+    if (fileTasks.length === 0) continue;
+    const allSucceeded = fileTasks.every((t) => succeededTasks.has(t));
+    if (!allSucceeded) continue;
+    const parsed = parseIssueFilename(taskFile.path);
+    if (!parsed) continue;
+    const { issueId } = parsed;
+    const filename = basename2(taskFile.path);
+    try {
+      await datasource4.close(issueId, fetchOpts);
+      log.success(`Closed issue #${issueId} (all tasks in ${filename} completed)`);
+    } catch (err) {
+      log.warn(`Could not close issue #${issueId}: ${log.formatErrorChain(err)}`);
+    }
+  }
+}
+async function getCommitSummaries(defaultBranch, cwd) {
+  try {
+    const { stdout } = await exec8(
+      "git",
+      ["log", `${defaultBranch}..HEAD`, "--pretty=format:%s"],
+      { cwd }
+    );
+    return stdout.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getBranchDiff(defaultBranch, cwd) {
+  try {
+    const { stdout } = await exec8(
+      "git",
+      ["diff", `${defaultBranch}..HEAD`],
+      { cwd, maxBuffer: 10 * 1024 * 1024 }
+    );
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+async function squashBranchCommits(defaultBranch, message, cwd) {
+  const { stdout } = await exec8(
+    "git",
+    ["merge-base", defaultBranch, "HEAD"],
+    { cwd }
+  );
+  const mergeBase = stdout.trim();
+  await exec8("git", ["reset", "--soft", mergeBase], { cwd });
+  await exec8("git", ["commit", "-m", message], { cwd });
+}
+async function buildPrBody(details, tasks, results, defaultBranch, datasourceName, cwd) {
+  const sections = [];
+  const commits = await getCommitSummaries(defaultBranch, cwd);
+  if (commits.length > 0) {
+    sections.push("## Summary\n");
+    for (const commit of commits) {
+      sections.push(`- ${commit}`);
+    }
+    sections.push("");
+  }
+  const taskResults = new Map(
+    results.filter((r) => tasks.includes(r.task)).map((r) => [r.task, r])
+  );
+  const completedTasks = tasks.filter((t) => taskResults.get(t)?.success);
+  const failedTasks = tasks.filter((t) => {
+    const r = taskResults.get(t);
+    return r && !r.success;
+  });
+  if (completedTasks.length > 0 || failedTasks.length > 0) {
+    sections.push("## Tasks\n");
+    for (const task of completedTasks) {
+      sections.push(`- [x] ${task.text}`);
+    }
+    for (const task of failedTasks) {
+      sections.push(`- [ ] ${task.text}`);
+    }
+    sections.push("");
+  }
+  if (details.labels.length > 0) {
+    sections.push(`**Labels:** ${details.labels.join(", ")}
+`);
+  }
+  if (datasourceName === "github") {
+    sections.push(`Closes #${details.number}`);
+  } else if (datasourceName === "azdevops") {
+    sections.push(`Resolves AB#${details.number}`);
+  }
+  return sections.join("\n");
+}
+async function buildPrTitle(issueTitle, defaultBranch, cwd) {
+  const commits = await getCommitSummaries(defaultBranch, cwd);
+  if (commits.length === 0) {
+    return issueTitle;
+  }
+  if (commits.length === 1) {
+    return commits[0];
+  }
+  return `${commits[commits.length - 1]} (+${commits.length - 1} more)`;
+}
+
+// src/helpers/timeout.ts
+var TimeoutError = class extends Error {
+  /** Optional label identifying the operation that timed out. */
+  label;
+  constructor(ms, label) {
+    const suffix = label ? ` [${label}]` : "";
+    super(`Timed out after ${ms}ms${suffix}`);
+    this.name = "TimeoutError";
+    this.label = label;
+  }
+};
+function withTimeout(promise, ms, label) {
+  const p = new Promise((resolve2, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(new TimeoutError(ms, label));
+    }, ms);
+    promise.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+  p.catch(() => {
+  });
+  return p;
+}
+
+// src/orchestrator/dispatch-pipeline.ts
+import chalk7 from "chalk";
+var DEFAULT_PLAN_TIMEOUT_MIN = 10;
+var DEFAULT_PLAN_RETRIES = 1;
+async function runDispatchPipeline(opts, cwd) {
+  const {
+    issueIds,
+    concurrency,
+    dryRun,
+    serverUrl,
+    noPlan,
+    noBranch,
+    noWorktree,
+    provider = "opencode",
+    model,
+    source,
+    org,
+    project,
+    workItemType,
+    planTimeout,
+    planRetries,
+    retries
+  } = opts;
+  const planTimeoutMs = (planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN) * 6e4;
+  const maxPlanAttempts = (planRetries ?? retries ?? DEFAULT_PLAN_RETRIES) + 1;
+  log.debug(`Plan timeout: ${planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN}m (${planTimeoutMs}ms), max attempts: ${maxPlanAttempts}`);
+  if (dryRun) {
+    return dryRunMode(issueIds, cwd, source, org, project, workItemType);
+  }
+  const verbose = log.verbose;
+  let tui;
+  if (verbose) {
+    const headerLines = renderHeaderLines({ provider, source });
+    console.log("");
+    for (const line of headerLines) console.log(line);
+    console.log(chalk7.dim("  \u2500".repeat(24)));
+    console.log("");
+    log.info("Discovering task files...");
+    const state = {
+      tasks: [],
+      phase: "discovering",
+      startTime: Date.now(),
+      filesFound: 0,
+      provider,
+      source
+    };
+    tui = { state, update: () => {
+    }, stop: () => {
+    } };
+  } else {
+    tui = createTui();
+    tui.state.provider = provider;
+    tui.state.source = source;
+  }
+  try {
+    tui.state.phase = "discovering";
+    if (!source) {
+      tui.state.phase = "done";
+      tui.stop();
+      log.error("No datasource configured. Use --source or run 'dispatch config' to set up defaults.");
+      return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+    }
+    const datasource4 = getDatasource(source);
+    const fetchOpts = { cwd, org, project, workItemType };
+    const items = issueIds.length > 0 ? await fetchItemsById(issueIds, datasource4, fetchOpts) : await datasource4.list(fetchOpts);
+    if (items.length === 0) {
+      tui.state.phase = "done";
+      tui.stop();
+      const label = issueIds.length > 0 ? `issue(s) ${issueIds.join(", ")}` : `datasource: ${source}`;
+      log.warn("No work items found from " + label);
+      return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+    }
+    const { files, issueDetailsByFile } = await writeItemsToTempDir(items);
+    tui.state.filesFound = files.length;
+    if (verbose) log.debug(`Found ${files.length} task file(s)`);
+    tui.state.phase = "parsing";
+    if (verbose) log.info("Parsing tasks...");
+    const taskFiles = [];
+    for (const file of files) {
+      const tf = await parseTaskFile(file);
+      if (tf.tasks.length > 0) {
+        taskFiles.push(tf);
+      }
+    }
+    const allTasks = taskFiles.flatMap((tf) => tf.tasks);
+    const fileContentMap = /* @__PURE__ */ new Map();
+    for (const tf of taskFiles) {
+      fileContentMap.set(tf.path, tf.content);
+    }
+    if (allTasks.length === 0) {
+      tui.state.phase = "done";
+      tui.stop();
+      log.warn("No unchecked tasks found");
+      return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+    }
+    tui.state.tasks = allTasks.map((task) => ({
+      task,
+      status: "pending"
+    }));
+    const tasksByFile = /* @__PURE__ */ new Map();
+    for (const task of allTasks) {
+      const list = tasksByFile.get(task.file) ?? [];
+      list.push(task);
+      tasksByFile.set(task.file, list);
+    }
+    const useWorktrees = !noWorktree && !noBranch && tasksByFile.size > 1;
+    tui.state.phase = "booting";
+    if (verbose) log.info(`Booting ${provider} provider...`);
+    if (serverUrl) {
+      tui.state.serverUrl = serverUrl;
+    }
+    if (verbose && serverUrl) log.debug(`Server URL: ${serverUrl}`);
+    let instance;
+    let planner = null;
+    let executor;
+    let commitAgent;
+    if (!useWorktrees) {
+      instance = await bootProvider(provider, { url: serverUrl, cwd, model });
+      registerCleanup(() => instance.cleanup());
+      if (instance.model) {
+        tui.state.model = instance.model;
+      }
+      if (verbose && instance.model) log.debug(`Model: ${instance.model}`);
+      planner = noPlan ? null : await boot6({ provider: instance, cwd });
+      executor = await boot7({ provider: instance, cwd });
+      commitAgent = await boot8({ provider: instance, cwd });
+    }
+    tui.state.phase = "dispatching";
+    if (verbose) log.info(`Dispatching ${allTasks.length} task(s)...`);
+    const results = [];
+    let completed = 0;
+    let failed = 0;
+    const lifecycleOpts = { cwd };
+    let username = "";
+    try {
+      username = await datasource4.getUsername(lifecycleOpts);
+    } catch (err) {
+      log.warn(`Could not resolve git username for branch naming: ${log.formatErrorChain(err)}`);
+    }
+    const processIssueFile = async (file, fileTasks) => {
+      const details = issueDetailsByFile.get(file);
+      let defaultBranch;
+      let branchName;
+      let worktreePath;
+      let issueCwd = cwd;
+      if (!noBranch && details) {
+        try {
+          defaultBranch = await datasource4.getDefaultBranch(lifecycleOpts);
+          branchName = datasource4.buildBranchName(details.number, details.title, username);
+          if (useWorktrees) {
+            worktreePath = await createWorktree(cwd, file, branchName);
+            registerCleanup(async () => {
+              await removeWorktree(cwd, file);
+            });
+            issueCwd = worktreePath;
+            log.debug(`Created worktree for issue #${details.number} at ${worktreePath}`);
+            const wtName = worktreeName(file);
+            for (const task of fileTasks) {
+              const tuiTask = tui.state.tasks.find((t) => t.task === task);
+              if (tuiTask) tuiTask.worktree = wtName;
+            }
+          } else {
+            await datasource4.createAndSwitchBranch(branchName, lifecycleOpts);
+            log.debug(`Switched to branch ${branchName}`);
+          }
+        } catch (err) {
+          const errorMsg = `Branch creation failed for issue #${details.number}: ${log.extractMessage(err)}`;
+          log.error(errorMsg);
+          for (const task of fileTasks) {
+            const tuiTask = tui.state.tasks.find((t) => t.task === task);
+            if (tuiTask) {
+              tuiTask.status = "failed";
+              tuiTask.error = errorMsg;
+            }
+            results.push({ task, success: false, error: errorMsg });
+          }
+          failed += fileTasks.length;
+          return;
+        }
+      }
+      const issueLifecycleOpts = { cwd: issueCwd };
+      let localInstance;
+      let localPlanner;
+      let localExecutor;
+      let localCommitAgent;
+      if (useWorktrees) {
+        localInstance = await bootProvider(provider, { url: serverUrl, cwd: issueCwd, model });
+        registerCleanup(() => localInstance.cleanup());
+        if (localInstance.model && !tui.state.model) {
+          tui.state.model = localInstance.model;
+        }
+        if (verbose && localInstance.model) log.debug(`Model: ${localInstance.model}`);
+        localPlanner = noPlan ? null : await boot6({ provider: localInstance, cwd: issueCwd });
+        localExecutor = await boot7({ provider: localInstance, cwd: issueCwd });
+        localCommitAgent = await boot8({ provider: localInstance, cwd: issueCwd });
+      } else {
+        localInstance = instance;
+        localPlanner = planner;
+        localExecutor = executor;
+        localCommitAgent = commitAgent;
+      }
+      const groups = groupTasksByMode(fileTasks);
+      const issueResults = [];
+      for (const group of groups) {
+        const groupQueue = [...group];
+        while (groupQueue.length > 0) {
+          const batch = groupQueue.splice(0, concurrency);
+          const batchResults = await Promise.all(
+            batch.map(async (task) => {
+              const tuiTask = tui.state.tasks.find((t) => t.task === task);
+              const startTime = Date.now();
+              tuiTask.elapsed = startTime;
+              let plan;
+              if (localPlanner) {
+                tuiTask.status = "planning";
+                if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: planning \u2014 "${task.text}"`);
+                const rawContent = fileContentMap.get(task.file);
+                const fileContext = rawContent ? buildTaskContext(rawContent, task) : void 0;
+                let planResult;
+                for (let attempt = 1; attempt <= maxPlanAttempts; attempt++) {
+                  try {
+                    planResult = await withTimeout(
+                      localPlanner.plan(task, fileContext, issueCwd),
+                      planTimeoutMs,
+                      "planner.plan()"
+                    );
+                    break;
+                  } catch (err) {
+                    if (err instanceof TimeoutError) {
+                      log.warn(
+                        `Planning timed out for task "${task.text}" (attempt ${attempt}/${maxPlanAttempts})`
+                      );
+                      if (attempt < maxPlanAttempts) {
+                        log.debug(`Retrying planning (attempt ${attempt + 1}/${maxPlanAttempts})`);
+                      }
+                    } else {
+                      planResult = {
+                        prompt: "",
+                        success: false,
+                        error: log.extractMessage(err)
+                      };
+                      break;
+                    }
+                  }
+                }
+                if (!planResult) {
+                  const timeoutMin = planTimeout ?? 10;
+                  planResult = {
+                    prompt: "",
+                    success: false,
+                    error: `Planning timed out after ${timeoutMin}m (${maxPlanAttempts} attempts)`
+                  };
+                }
+                if (!planResult.success) {
+                  tuiTask.status = "failed";
+                  tuiTask.error = `Planning failed: ${planResult.error}`;
+                  tuiTask.elapsed = Date.now() - startTime;
+                  if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 ${tuiTask.error} (${elapsed(tuiTask.elapsed)})`);
+                  failed++;
+                  return { task, success: false, error: tuiTask.error };
+                }
+                plan = planResult.prompt;
+              }
+              tuiTask.status = "running";
+              if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: executing \u2014 "${task.text}"`);
+              const execRetries = 2;
+              const execResult = await withRetry(
+                async () => {
+                  const result = await localExecutor.execute({
+                    task,
+                    cwd: issueCwd,
+                    plan: plan ?? null
+                  });
+                  if (!result.success) {
+                    throw new Error(result.error ?? "Execution failed");
+                  }
+                  return result;
+                },
+                execRetries,
+                { label: `executor "${task.text}"` }
+              ).catch((err) => ({
+                dispatchResult: { task, success: false, error: log.extractMessage(err) },
+                success: false,
+                error: log.extractMessage(err),
+                elapsedMs: 0
+              }));
+              if (execResult.success) {
+                try {
+                  const parsed = parseIssueFilename(task.file);
+                  if (parsed) {
+                    const updatedContent = await readFile7(task.file, "utf-8");
+                    const issueDetails = issueDetailsByFile.get(task.file);
+                    const title = issueDetails?.title ?? parsed.slug;
+                    await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
+                    log.success(`Synced task completion to issue #${parsed.issueId}`);
+                  }
+                } catch (err) {
+                  log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
+                }
+                tuiTask.status = "done";
+                tuiTask.elapsed = Date.now() - startTime;
+                if (verbose) log.success(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: done \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})`);
+                completed++;
+              } else {
+                tuiTask.status = "failed";
+                tuiTask.error = execResult.error;
+                tuiTask.elapsed = Date.now() - startTime;
+                if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})${tuiTask.error ? `: ${tuiTask.error}` : ""}`);
+                failed++;
+              }
+              return execResult.dispatchResult;
+            })
+          );
+          issueResults.push(...batchResults);
+          if (!tui.state.model && localInstance.model) {
+            tui.state.model = localInstance.model;
+          }
+        }
+      }
+      results.push(...issueResults);
+      if (!noBranch && branchName && defaultBranch && details) {
+        try {
+          await datasource4.commitAllChanges(
+            `chore: stage uncommitted changes for issue #${details.number}`,
+            issueLifecycleOpts
+          );
+          log.debug(`Staged uncommitted changes for issue #${details.number}`);
+        } catch (err) {
+          log.warn(`Could not commit uncommitted changes for issue #${details.number}: ${log.formatErrorChain(err)}`);
+        }
+      }
+      let commitAgentResult;
+      if (!noBranch && branchName && defaultBranch && details) {
+        try {
+          const branchDiff = await getBranchDiff(defaultBranch, issueCwd);
+          if (branchDiff) {
+            const result = await localCommitAgent.generate({
+              branchDiff,
+              issue: details,
+              taskResults: issueResults,
+              cwd: issueCwd
+            });
+            if (result.success) {
+              commitAgentResult = result;
+              try {
+                await squashBranchCommits(defaultBranch, result.commitMessage, issueCwd);
+                log.debug(`Rewrote commit message for issue #${details.number}`);
+              } catch (err) {
+                log.warn(`Could not rewrite commit message for issue #${details.number}: ${log.formatErrorChain(err)}`);
+              }
+            } else {
+              log.warn(`Commit agent failed for issue #${details.number}: ${result.error}`);
+            }
+          }
+        } catch (err) {
+          log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
+        }
+      }
+      if (!noBranch && branchName && defaultBranch && details) {
+        try {
+          await datasource4.pushBranch(branchName, issueLifecycleOpts);
+          log.debug(`Pushed branch ${branchName}`);
+        } catch (err) {
+          log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
+        }
+        try {
+          const prTitle = commitAgentResult?.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
+          const prBody = commitAgentResult?.prDescription || await buildPrBody(
+            details,
+            fileTasks,
+            issueResults,
+            defaultBranch,
+            datasource4.name,
+            issueLifecycleOpts.cwd
+          );
+          const prUrl = await datasource4.createPullRequest(
+            branchName,
+            details.number,
+            prTitle,
+            prBody,
+            issueLifecycleOpts
+          );
+          if (prUrl) {
+            log.success(`Created PR for issue #${details.number}: ${prUrl}`);
+          }
+        } catch (err) {
+          log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
+        }
+        if (useWorktrees && worktreePath) {
+          try {
+            await removeWorktree(cwd, file);
+          } catch (err) {
+            log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
+          }
+        } else if (!useWorktrees) {
+          try {
+            await datasource4.switchBranch(defaultBranch, lifecycleOpts);
+            log.debug(`Switched back to ${defaultBranch}`);
+          } catch (err) {
+            log.warn(`Could not switch back to ${defaultBranch}: ${log.formatErrorChain(err)}`);
+          }
+        }
+      }
+      if (useWorktrees) {
+        await localExecutor.cleanup();
+        await localPlanner?.cleanup();
+        await localInstance.cleanup();
+      }
+    };
+    if (useWorktrees) {
+      await Promise.all(
+        Array.from(tasksByFile).map(
+          ([file, fileTasks]) => processIssueFile(file, fileTasks)
+        )
+      );
+    } else {
+      for (const [file, fileTasks] of tasksByFile) {
+        await processIssueFile(file, fileTasks);
+      }
+    }
+    try {
+      await closeCompletedSpecIssues(taskFiles, results, cwd, source, org, project, workItemType);
+    } catch (err) {
+      log.warn(`Could not close completed spec issues: ${log.formatErrorChain(err)}`);
+    }
+    await commitAgent?.cleanup();
+    await executor?.cleanup();
+    await planner?.cleanup();
+    await instance?.cleanup();
+    tui.state.phase = "done";
+    tui.stop();
+    if (verbose) log.success(`Done \u2014 ${completed} completed, ${failed} failed (${elapsed(Date.now() - tui.state.startTime)})`);
+    return { total: allTasks.length, completed, failed, skipped: 0, results };
+  } catch (err) {
+    tui.stop();
+    throw err;
+  }
+}
+async function dryRunMode(issueIds, cwd, source, org, project, workItemType) {
+  if (!source) {
+    log.error("No datasource configured. Use --source or run 'dispatch config' to set up defaults.");
+    return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+  }
+  const datasource4 = getDatasource(source);
+  const fetchOpts = { cwd, org, project, workItemType };
+  const lifecycleOpts = { cwd };
+  let username = "";
+  try {
+    username = await datasource4.getUsername(lifecycleOpts);
+  } catch {
+  }
+  const items = issueIds.length > 0 ? await fetchItemsById(issueIds, datasource4, fetchOpts) : await datasource4.list(fetchOpts);
+  if (items.length === 0) {
+    const label = issueIds.length > 0 ? `issue(s) ${issueIds.join(", ")}` : `datasource: ${source}`;
+    log.warn("No work items found from " + label);
+    return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+  }
+  const { files } = await writeItemsToTempDir(items);
+  const taskFiles = [];
+  for (const file of files) {
+    const tf = await parseTaskFile(file);
+    if (tf.tasks.length > 0) {
+      taskFiles.push(tf);
+    }
+  }
+  const allTasks = taskFiles.flatMap((tf) => tf.tasks);
+  if (allTasks.length === 0) {
+    log.warn("No unchecked tasks found");
+    return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
+  }
+  log.info(`Dry run \u2014 ${allTasks.length} task(s) across ${taskFiles.length} file(s):
+`);
+  for (const task of allTasks) {
+    const parsed = parseIssueFilename(task.file);
+    const details = parsed ? items.find((item) => item.number === parsed.issueId) : void 0;
+    const branchInfo = details ? ` [branch: ${datasource4.buildBranchName(details.number, details.title, username)}]` : "";
+    log.task(allTasks.indexOf(task), allTasks.length, `${task.file}:${task.line} \u2014 ${task.text}${branchInfo}`);
+  }
+  return {
+    total: allTasks.length,
+    completed: 0,
+    failed: 0,
+    skipped: allTasks.length,
+    results: []
+  };
+}
+
+// src/orchestrator/runner.ts
+async function boot9(opts) {
+  const { cwd } = opts;
+  const runner = {
+    orchestrate: (runOpts) => runDispatchPipeline(runOpts, cwd),
+    generateSpecs: (specOpts) => runSpecPipeline(specOpts),
+    async run(opts2) {
+      if (opts2.mode === "spec") {
+        const { mode: _2, ...rest2 } = opts2;
+        return runner.generateSpecs({ ...rest2, cwd });
+      }
+      if (opts2.mode === "fix-tests") {
+        const { runFixTestsPipeline: runFixTestsPipeline2 } = await Promise.resolve().then(() => (init_fix_tests_pipeline(), fix_tests_pipeline_exports));
+        return runFixTestsPipeline2({ cwd, provider: "opencode", serverUrl: void 0, verbose: false, testTimeout: opts2.testTimeout });
+      }
+      const { mode: _, ...rest } = opts2;
+      return runner.orchestrate(rest);
+    },
+    async runFromCli(args) {
+      const m = await resolveCliConfig(args);
+      const prereqFailures = await checkPrereqs({ datasource: m.issueSource });
+      if (prereqFailures.length > 0) {
+        for (const msg of prereqFailures) {
+          log.error(msg);
+        }
+        process.exit(1);
+      }
+      await ensureGitignoreEntry(m.cwd, ".dispatch/worktrees/");
+      const modeFlags = [
+        m.spec !== void 0 && "--spec",
+        m.respec !== void 0 && "--respec",
+        m.fixTests && "--fix-tests"
+      ].filter(Boolean);
+      if (modeFlags.length > 1) {
+        log.error(`${modeFlags.join(" and ")} are mutually exclusive`);
+        process.exit(1);
+      }
+      if (m.fixTests && m.issueIds.length > 0) {
+        log.error("--fix-tests cannot be combined with issue IDs");
+        process.exit(1);
+      }
+      if (m.fixTests) {
+        const { runFixTestsPipeline: runFixTestsPipeline2 } = await Promise.resolve().then(() => (init_fix_tests_pipeline(), fix_tests_pipeline_exports));
+        return runFixTestsPipeline2({ cwd: m.cwd, provider: m.provider, serverUrl: m.serverUrl, verbose: m.verbose, testTimeout: m.testTimeout });
+      }
+      if (m.spec) {
+        return this.generateSpecs({
+          issues: m.spec,
+          issueSource: m.issueSource,
+          provider: m.provider,
+          model: m.model,
+          serverUrl: m.serverUrl,
+          cwd: m.cwd,
+          outputDir: m.outputDir,
+          org: m.org,
+          project: m.project,
+          workItemType: m.workItemType,
+          concurrency: m.concurrency,
+          dryRun: m.dryRun
+        });
+      }
+      if (m.respec) {
+        const respecArgs = m.respec;
+        const isEmpty = Array.isArray(respecArgs) && respecArgs.length === 0;
+        let issues;
+        if (isEmpty) {
+          const source = await resolveSource(respecArgs, m.issueSource, m.cwd);
+          if (!source) {
+            process.exit(1);
+          }
+          const datasource4 = getDatasource(source);
+          const existing = await datasource4.list({ cwd: m.cwd, org: m.org, project: m.project, workItemType: m.workItemType });
+          if (existing.length === 0) {
+            log.error("No existing specs found to regenerate");
+            process.exit(1);
+          }
+          const identifiers = existing.map((item) => item.number);
+          const allNumeric = identifiers.every((id) => /^\d+$/.test(id));
+          issues = allNumeric ? identifiers.join(",") : identifiers;
+          const confirmed = await confirmLargeBatch(existing.length);
+          if (!confirmed) {
+            process.exit(0);
+          }
+        } else {
+          issues = respecArgs;
+        }
+        return this.generateSpecs({
+          issues,
+          issueSource: m.issueSource,
+          provider: m.provider,
+          model: m.model,
+          serverUrl: m.serverUrl,
+          cwd: m.cwd,
+          outputDir: m.outputDir,
+          org: m.org,
+          project: m.project,
+          workItemType: m.workItemType,
+          concurrency: m.concurrency,
+          dryRun: m.dryRun
+        });
+      }
+      return this.orchestrate({
+        issueIds: m.issueIds,
+        concurrency: m.concurrency ?? defaultConcurrency(),
+        dryRun: m.dryRun,
+        noPlan: m.noPlan,
+        noBranch: m.noBranch,
+        noWorktree: m.noWorktree,
+        provider: m.provider,
+        model: m.model,
+        serverUrl: m.serverUrl,
+        source: m.issueSource,
+        org: m.org,
+        project: m.project,
+        workItemType: m.workItemType,
+        planTimeout: m.planTimeout,
+        planRetries: m.planRetries,
+        retries: m.retries,
+        force: m.force
+      });
+    }
+  };
+  return runner;
+}
+
+// src/cli.ts
+init_logger();
+init_cleanup();
+init_providers();
+var MAX_CONCURRENCY = 64;
+var HELP = `
+  dispatch \u2014 AI agent orchestration CLI
+
+  Usage:
+    dispatch [issue-id...]           Dispatch specific issues (or all open issues if none given)
+    dispatch --spec <ids>            Generate spec files from issues
+    dispatch --spec <glob>           Generate specs from local markdown files in the configured datasource
+    dispatch --respec                Regenerate all existing specs
+    dispatch --respec <ids>          Regenerate specs for specific issues
+    dispatch --respec <glob>         Regenerate specs matching a glob pattern
+    dispatch --spec "description"    Generate a spec from an inline text description
+    dispatch --fix-tests             Run tests and fix failures via AI agent
+
+  Dispatch options:
+    --dry-run              List tasks without dispatching (also works with --spec)
+    --no-plan              Skip the planner agent, dispatch directly
+    --no-branch            Skip branch creation, push, and PR lifecycle
+    --no-worktree          Skip git worktree isolation for parallel issues
+    --force              Ignore prior run state and re-run all tasks
+    --concurrency <n>      Max parallel dispatches (default: min(cpus, freeMB/500), max: 64)
+    --provider <name>      Agent backend: ${PROVIDER_NAMES.join(", ")} (default: opencode)
+    --server-url <url>     URL of a running provider server
+    --plan-timeout <min>   Planning timeout in minutes (default: 10)
+    --retries <n>          Retry attempts for all agents (default: 2)
+    --plan-retries <n>     Retry attempts after planning timeout (overrides --retries for planner)
+    --test-timeout <min>   Test timeout in minutes (default: 5)
+    --cwd <dir>            Working directory (default: cwd)
+
+  Spec options:
+    --spec <value>         Comma-separated issue numbers or glob pattern for .md files (creates specs in configured datasource)
+    --respec [value]       Regenerate specs: issue numbers, glob, or omit to regenerate all existing specs
+    --spec <value>         Comma-separated issue numbers, glob pattern for .md files, or inline text description
+    --source <name>        Issue source: ${DATASOURCE_NAMES.join(", ")} (optional; auto-detected from git remote, falls back to md)
+    --org <url>            Azure DevOps organization URL
+    --project <name>       Azure DevOps project name
+    --output-dir <dir>     Output directory for specs (default: .dispatch/specs)
+
+  General:
+    --verbose              Show detailed debug output for troubleshooting
+    -h, --help             Show this help
+    -v, --version          Show version
+
+  Config:
+    dispatch config                     Launch interactive configuration wizard
+
+  Examples:
+    dispatch 14
+    dispatch 14,15,16
+    dispatch 14 15 16
+    dispatch
+    dispatch 14 --dry-run
+    dispatch 14 --provider copilot
+    dispatch --spec 42,43,44
+    dispatch --spec 42,43 --source github --provider copilot
+    dispatch --spec 100,200 --source azdevops --org https://dev.azure.com/myorg --project MyProject
+    dispatch --spec "drafts/*.md"
+    dispatch --spec "drafts/*.md" --source github
+    dispatch --spec "./my-feature.md" --provider copilot
+    dispatch --respec
+    dispatch --respec 42,43,44
+    dispatch --respec "specs/*.md"
+    dispatch --spec "add dark mode toggle to settings page"
+    dispatch --spec "feature A should do x" --provider copilot
+    dispatch config
+`.trimStart();
+function parseArgs(argv) {
+  const args = {
+    issueIds: [],
+    dryRun: false,
+    noPlan: false,
+    noBranch: false,
+    noWorktree: false,
+    force: false,
+    provider: "opencode",
+    cwd: process.cwd(),
+    help: false,
+    version: false,
+    verbose: false
+  };
+  const explicitFlags = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+      explicitFlags.add("help");
+    } else if (arg === "--version" || arg === "-v") {
+      args.version = true;
+      explicitFlags.add("version");
+    } else if (arg === "--dry-run") {
+      args.dryRun = true;
+      explicitFlags.add("dryRun");
+    } else if (arg === "--no-plan") {
+      args.noPlan = true;
+      explicitFlags.add("noPlan");
+    } else if (arg === "--no-branch") {
+      args.noBranch = true;
+      explicitFlags.add("noBranch");
+    } else if (arg === "--no-worktree") {
+      args.noWorktree = true;
+      explicitFlags.add("noWorktree");
+    } else if (arg === "--force") {
+      args.force = true;
+      explicitFlags.add("force");
+    } else if (arg === "--verbose") {
+      args.verbose = true;
+      explicitFlags.add("verbose");
+    } else if (arg === "--spec") {
+      i++;
+      const specs = [];
+      while (i < argv.length && !argv[i].startsWith("--")) {
+        specs.push(argv[i]);
+        i++;
+      }
+      i--;
+      args.spec = specs.length === 1 ? specs[0] : specs;
+      explicitFlags.add("spec");
+    } else if (arg === "--respec") {
+      i++;
+      const respecs = [];
+      while (i < argv.length && !argv[i].startsWith("--")) {
+        respecs.push(argv[i]);
+        i++;
+      }
+      i--;
+      args.respec = respecs.length === 1 ? respecs[0] : respecs;
+      explicitFlags.add("respec");
+    } else if (arg === "--fix-tests") {
+      args.fixTests = true;
+      explicitFlags.add("fixTests");
+    } else if (arg === "--source") {
+      i++;
+      const val = argv[i];
+      if (!DATASOURCE_NAMES.includes(val)) {
+        log.error(
+          `Unknown source "${val}". Available: ${DATASOURCE_NAMES.join(", ")}`
+        );
+        process.exit(1);
+      }
+      args.issueSource = val;
+      explicitFlags.add("issueSource");
+    } else if (arg === "--org") {
+      i++;
+      args.org = argv[i];
+      explicitFlags.add("org");
+    } else if (arg === "--project") {
+      i++;
+      args.project = argv[i];
+      explicitFlags.add("project");
+    } else if (arg === "--output-dir") {
+      i++;
+      args.outputDir = resolve(argv[i]);
+      explicitFlags.add("outputDir");
+    } else if (arg === "--concurrency") {
+      i++;
+      const val = parseInt(argv[i], 10);
+      if (isNaN(val) || val < 1) {
+        log.error("--concurrency must be a positive integer");
+        process.exit(1);
+      }
+      if (val > MAX_CONCURRENCY) {
+        log.error(`--concurrency must not exceed ${MAX_CONCURRENCY}`);
+        process.exit(1);
+      }
+      args.concurrency = val;
+      explicitFlags.add("concurrency");
+    } else if (arg === "--provider") {
+      i++;
+      const val = argv[i];
+      if (!PROVIDER_NAMES.includes(val)) {
+        log.error(`Unknown provider "${val}". Available: ${PROVIDER_NAMES.join(", ")}`);
+        process.exit(1);
+      }
+      args.provider = val;
+      explicitFlags.add("provider");
+    } else if (arg === "--server-url") {
+      i++;
+      args.serverUrl = argv[i];
+      explicitFlags.add("serverUrl");
+    } else if (arg === "--plan-timeout") {
+      i++;
+      const val = parseFloat(argv[i]);
+      if (isNaN(val) || val <= 0) {
+        log.error("--plan-timeout must be a positive number (minutes)");
+        process.exit(1);
+      }
+      args.planTimeout = val;
+      explicitFlags.add("planTimeout");
+    } else if (arg === "--retries") {
+      i++;
+      const val = parseInt(argv[i], 10);
+      if (isNaN(val) || val < 0) {
+        log.error("--retries must be a non-negative integer");
+        process.exit(1);
+      }
+      args.retries = val;
+      explicitFlags.add("retries");
+    } else if (arg === "--plan-retries") {
+      i++;
+      const val = parseInt(argv[i], 10);
+      if (isNaN(val) || val < 0) {
+        log.error("--plan-retries must be a non-negative integer");
+        process.exit(1);
+      }
+      args.planRetries = val;
+      explicitFlags.add("planRetries");
+    } else if (arg === "--test-timeout") {
+      i++;
+      const val = parseFloat(argv[i]);
+      if (isNaN(val) || val <= 0) {
+        log.error("--test-timeout must be a positive number (minutes)");
+        process.exit(1);
+      }
+      args.testTimeout = val;
+      explicitFlags.add("testTimeout");
+    } else if (arg === "--cwd") {
+      i++;
+      args.cwd = resolve(argv[i]);
+      explicitFlags.add("cwd");
+    } else if (!arg.startsWith("-")) {
+      args.issueIds.push(arg);
+    } else {
+      log.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    }
+    i++;
+  }
+  return [args, explicitFlags];
+}
+async function main() {
+  const rawArgv = process.argv.slice(2);
+  if (rawArgv[0] === "config") {
+    let cwd = process.cwd();
+    for (let i = 1; i < rawArgv.length; i++) {
+      if (rawArgv[i] === "--cwd" && i + 1 < rawArgv.length) {
+        cwd = resolve(rawArgv[i + 1]);
+        break;
+      }
+    }
+    const configDir = join11(cwd, ".dispatch");
+    await handleConfigCommand(rawArgv.slice(1), configDir);
+    process.exit(0);
+  }
+  const [args, explicitFlags] = parseArgs(rawArgv);
+  log.verbose = args.verbose;
+  process.on("SIGINT", async () => {
+    log.debug("Received SIGINT, cleaning up...");
+    await runCleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", async () => {
+    log.debug("Received SIGTERM, cleaning up...");
+    await runCleanup();
+    process.exit(143);
+  });
+  if (args.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log(`dispatch v${"0.0.1"}`);
+    process.exit(0);
+  }
+  const orchestrator = await boot9({ cwd: args.cwd });
+  const { help: _, version: __, ...rawArgs } = args;
+  const summary = await orchestrator.runFromCli({ ...rawArgs, explicitFlags });
+  const failed = "failed" in summary ? summary.failed : "success" in summary && !summary.success ? 1 : 0;
+  process.exit(failed > 0 ? 1 : 0);
+}
+main().catch(async (err) => {
+  log.error(log.formatErrorChain(err));
+  await runCleanup();
+  process.exit(1);
+});
+export {
+  MAX_CONCURRENCY,
+  parseArgs
+};
+//# sourceMappingURL=cli.js.map