@pruddiman/dispatch 1.5.0-beta.82cfb11 → 1.5.0-beta.9b425f0-beta.9b425f0

package/dist/mcp/dispatch-worker.js

@@ -1,26 +1,946 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+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/spec-generator.ts
-import { cpus, freemem } from "os";
+// src/helpers/format.ts
+import chalk2 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(chalk2.bold.white("  \u26A1 dispatch") + chalk2.dim(` \u2014 AI task orchestration`));
+  if (info.provider) {
+    lines.push(chalk2.dim(`  provider: ${info.provider}`));
+  }
+  if (info.model) {
+    lines.push(chalk2.dim(`  model: ${info.model}`));
+  }
+  if (info.source) {
+    lines.push(chalk2.dim(`  source: ${info.source}`));
+  }
+  return lines;
+}
+var PALETTE;
+var init_format = __esm({
+  "src/helpers/format.ts"() {
+    "use strict";
+    PALETTE = {
+      brand: "#58A6FF",
+      subtitle: "#484F58",
+      chrome: "#30363D",
+      text: "#C9D1D9",
+      muted: "#484F58",
+      success: "#56D364",
+      error: "#F85149",
+      warn: "#D29922",
+      accent: "#79C0FF",
+      planning: "#D2A8FF"
+    };
+  }
+});
 
-// src/datasources/index.ts
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
+// src/helpers/ink-prompts.tsx
+var ink_prompts_exports = {};
+__export(ink_prompts_exports, {
+  confirm: () => confirm,
+  input: () => input,
+  multiSelect: () => multiSelect,
+  multiSelectWithActions: () => multiSelectWithActions,
+  select: () => select
+});
+import { useState, useRef, useEffect } from "react";
+import { render, Box, Text, useInput, useApp } from "ink";
+import SelectInput from "ink-select-input";
+import TextInput from "ink-text-input";
+import { jsx, jsxs } from "react/jsx-runtime";
+function select(opts) {
+  return new Promise((resolve3) => {
+    function SelectPrompt() {
+      const { exit } = useApp();
+      const items = opts.choices.map((c) => ({ label: c.name, value: c.value }));
+      const initialIndex = opts.default !== void 0 ? opts.choices.findIndex((c) => c.value === opts.default) : 0;
+      const visibleLimit = opts.limit ?? Math.max(5, (process.stdout.rows ?? 24) - 4);
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: opts.message }) }),
+        /* @__PURE__ */ jsx(
+          SelectInput,
+          {
+            items,
+            initialIndex: Math.max(0, initialIndex),
+            limit: visibleLimit,
+            onSelect: (item) => {
+              resolve3(item.value);
+              exit();
+            }
+          }
+        )
+      ] });
+    }
+    const instance = render(/* @__PURE__ */ jsx(SelectPrompt, {}));
+    instance.waitUntilExit().catch(() => {
+    });
+  });
+}
+function confirm(opts) {
+  const defaultVal = opts.default ?? true;
+  return new Promise((resolve3) => {
+    function ConfirmPrompt() {
+      const { exit } = useApp();
+      const hint = defaultVal ? "(Y/n)" : "(y/N)";
+      useInput((input2) => {
+        const lower = input2.toLowerCase();
+        if (lower === "y") {
+          resolve3(true);
+          exit();
+        } else if (lower === "n") {
+          resolve3(false);
+          exit();
+        } else if (input2 === "\r" || input2 === "\n" || input2 === "") {
+          resolve3(defaultVal);
+          exit();
+        }
+      });
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: "? " }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          opts.message,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: PALETTE.muted, children: [
+          hint,
+          " "
+        ] })
+      ] });
+    }
+    const instance = render(/* @__PURE__ */ jsx(ConfirmPrompt, {}));
+    instance.waitUntilExit().catch(() => {
+    });
+  });
+}
+function multiSelect(opts) {
+  return new Promise((resolve3) => {
+    function MultiSelectPrompt() {
+      const { exit } = useApp();
+      const [cursor, setCursor] = useState(0);
+      const [selected, setSelected] = useState(() => {
+        const initial = /* @__PURE__ */ new Set();
+        opts.choices.forEach((c, i) => {
+          if (c.default) initial.add(i);
+        });
+        return initial;
+      });
+      const selectedRef = useRef(selected);
+      useEffect(() => {
+        selectedRef.current = selected;
+      }, [selected]);
+      useInput((input2, key) => {
+        if (key.upArrow) {
+          setCursor((prev) => prev > 0 ? prev - 1 : opts.choices.length - 1);
+        } else if (key.downArrow) {
+          setCursor((prev) => prev < opts.choices.length - 1 ? prev + 1 : 0);
+        } else if (input2 === " ") {
+          setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(cursor)) next.delete(cursor);
+            else next.add(cursor);
+            return next;
+          });
+        } else if (key.return) {
+          const result = opts.choices.filter((_, i) => selectedRef.current.has(i)).map((c) => c.value);
+          resolve3(result);
+          exit();
+        }
+      });
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: "? " }),
+          /* @__PURE__ */ jsx(Text, { children: opts.message }),
+          /* @__PURE__ */ jsx(Text, { color: PALETTE.muted, children: " (space to toggle, enter to confirm)" })
+        ] }),
+        opts.choices.map((choice, i) => {
+          const isSelected = selected.has(i);
+          const isCursor = i === cursor;
+          const checkbox = isSelected ? "\u25C9" : "\u25EF";
+          const pointer = isCursor ? "\u276F" : " ";
+          return /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: isCursor ? PALETTE.accent : void 0, children: [
+              pointer,
+              " ",
+              checkbox,
+              " ",
+              choice.name
+            ] }),
+            choice.description && isCursor && /* @__PURE__ */ jsxs(Text, { color: PALETTE.muted, children: [
+              " \u2014 ",
+              choice.description
+            ] })
+          ] }, choice.name);
+        })
+      ] });
+    }
+    const instance = render(/* @__PURE__ */ jsx(MultiSelectPrompt, {}));
+    instance.waitUntilExit().catch(() => {
+    });
+  });
+}
+function multiSelectWithActions(opts) {
+  return new Promise((resolve3) => {
+    function MultiSelectActionsPrompt() {
+      const { exit } = useApp();
+      const [cursor, setCursor] = useState(0);
+      const [selected, setSelected] = useState(() => {
+        const initial = /* @__PURE__ */ new Set();
+        opts.choices.forEach((c, i) => {
+          if (c.default) initial.add(i);
+        });
+        return initial;
+      });
+      const [marked, setMarked] = useState(/* @__PURE__ */ new Set());
+      const selectedRef = useRef(selected);
+      const markedRef = useRef(marked);
+      useEffect(() => {
+        selectedRef.current = selected;
+      }, [selected]);
+      useEffect(() => {
+        markedRef.current = marked;
+      }, [marked]);
+      useInput((input2, key) => {
+        if (key.upArrow) {
+          setCursor((prev) => prev > 0 ? prev - 1 : opts.choices.length - 1);
+        } else if (key.downArrow) {
+          setCursor((prev) => prev < opts.choices.length - 1 ? prev + 1 : 0);
+        } else if (input2 === " ") {
+          setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(cursor)) next.delete(cursor);
+            else next.add(cursor);
+            return next;
+          });
+        } else if (key.return) {
+          const values = opts.choices.filter((_, i) => selectedRef.current.has(i)).map((c) => c.value);
+          const markedValues = opts.choices.filter((_, i) => markedRef.current.has(i)).map((c) => c.value);
+          resolve3({ values, marked: markedValues });
+          exit();
+        } else {
+          const action = opts.actions.find((a) => a.key === input2.toLowerCase());
+          if (action) {
+            setMarked((prev) => {
+              const next = new Set(prev);
+              if (next.has(cursor)) next.delete(cursor);
+              else next.add(cursor);
+              return next;
+            });
+          }
+        }
+      });
+      const actionHints = opts.actions.map((a) => `${a.key} to ${a.label}`).join(", ");
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: "? " }),
+          /* @__PURE__ */ jsx(Text, { children: opts.message }),
+          /* @__PURE__ */ jsxs(Text, { color: PALETTE.muted, children: [
+            " (space to toggle, ",
+            actionHints,
+            ", enter to confirm)"
+          ] })
+        ] }),
+        opts.choices.map((choice, i) => {
+          const isSelected = selected.has(i);
+          const isMarked = marked.has(i);
+          const isCursor = i === cursor;
+          const checkbox = isSelected ? "\u25C9" : "\u25EF";
+          const pointer = isCursor ? "\u276F" : " ";
+          const markIndicator = isMarked ? " \u27F3" : "";
+          return /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: isCursor ? PALETTE.accent : void 0, children: [
+              pointer,
+              " ",
+              checkbox,
+              " ",
+              choice.name
+            ] }),
+            isMarked && /* @__PURE__ */ jsx(Text, { color: PALETTE.warn, children: markIndicator }),
+            choice.description && isCursor && /* @__PURE__ */ jsxs(Text, { color: PALETTE.muted, children: [
+              " \u2014 ",
+              choice.description
+            ] })
+          ] }, choice.name);
+        })
+      ] });
+    }
+    const instance = render(/* @__PURE__ */ jsx(MultiSelectActionsPrompt, {}));
+    instance.waitUntilExit().catch(() => {
+    });
+  });
+}
+function input(opts) {
+  return new Promise((resolve3) => {
+    function InputPrompt() {
+      const { exit } = useApp();
+      const [value, setValue] = useState(opts.default ?? "");
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: "? " }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          opts.message,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            value,
+            onChange: setValue,
+            onSubmit: (val) => {
+              resolve3(val);
+              exit();
+            }
+          }
+        )
+      ] });
+    }
+    const instance = render(/* @__PURE__ */ jsx(InputPrompt, {}));
+    instance.waitUntilExit().catch(() => {
+    });
+  });
+}
+var init_ink_prompts = __esm({
+  "src/helpers/ink-prompts.tsx"() {
+    "use strict";
+    init_format();
+  }
+});
 
-// src/datasources/interface.ts
-var DATASOURCE_NAMES = ["github", "azdevops", "md"];
+// src/mcp/state/database.ts
+import Database from "better-sqlite3";
+import { join as join8 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+function createSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER NOT NULL
+    );
 
-// src/datasources/github.ts
+    CREATE TABLE IF NOT EXISTS runs (
+      run_id         TEXT    PRIMARY KEY,
+      cwd            TEXT    NOT NULL,
+      issue_ids      TEXT    NOT NULL DEFAULT '[]',
+      status         TEXT    NOT NULL DEFAULT 'running',
+      started_at     INTEGER NOT NULL,
+      finished_at    INTEGER,
+      total          INTEGER NOT NULL DEFAULT 0,
+      completed      INTEGER NOT NULL DEFAULT 0,
+      failed         INTEGER NOT NULL DEFAULT 0,
+      error          TEXT,
+      worker_message TEXT,
+      queued_at      INTEGER,
+      session_id     TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id      TEXT    NOT NULL,
+      task_id     TEXT    NOT NULL,
+      task_text   TEXT    NOT NULL DEFAULT '',
+      file        TEXT    NOT NULL DEFAULT '',
+      line        INTEGER NOT NULL DEFAULT 0,
+      status      TEXT    NOT NULL DEFAULT 'pending',
+      branch      TEXT,
+      error       TEXT,
+      started_at  INTEGER,
+      finished_at INTEGER,
+      FOREIGN KEY (run_id) REFERENCES runs(run_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS spec_runs (
+      run_id         TEXT    PRIMARY KEY,
+      cwd            TEXT    NOT NULL,
+      issues         TEXT    NOT NULL DEFAULT '',
+      status         TEXT    NOT NULL DEFAULT 'running',
+      started_at     INTEGER NOT NULL,
+      finished_at    INTEGER,
+      total          INTEGER NOT NULL DEFAULT 0,
+      generated      INTEGER NOT NULL DEFAULT 0,
+      failed         INTEGER NOT NULL DEFAULT 0,
+      error          TEXT,
+      worker_message TEXT,
+      queued_at      INTEGER,
+      session_id     TEXT
+    );
+  `);
+  const row = db.prepare("SELECT version FROM schema_version LIMIT 1").get();
+  if (!row) {
+    db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(CURRENT_SCHEMA_VERSION);
+  } else {
+    if (row.version < 2) migrateToV2(db);
+    if (row.version < 3) migrateToV3(db);
+    if (row.version < CURRENT_SCHEMA_VERSION) {
+      db.prepare("UPDATE schema_version SET version = ?").run(CURRENT_SCHEMA_VERSION);
+    }
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_runs_session_id ON runs(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_run_id ON tasks(run_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_task_id ON tasks(task_id);
+    CREATE INDEX IF NOT EXISTS idx_spec_runs_session_id ON spec_runs(session_id);
+  `);
+}
+function migrateToV2(db) {
+  const runCols = db.prepare("PRAGMA table_info(runs)").all();
+  const runColNames = new Set(runCols.map((c) => c.name));
+  if (!runColNames.has("worker_message")) {
+    db.exec("ALTER TABLE runs ADD COLUMN worker_message TEXT");
+  }
+  if (!runColNames.has("queued_at")) {
+    db.exec("ALTER TABLE runs ADD COLUMN queued_at INTEGER");
+  }
+  const specCols = db.prepare("PRAGMA table_info(spec_runs)").all();
+  const specColNames = new Set(specCols.map((c) => c.name));
+  if (!specColNames.has("worker_message")) {
+    db.exec("ALTER TABLE spec_runs ADD COLUMN worker_message TEXT");
+  }
+  if (!specColNames.has("queued_at")) {
+    db.exec("ALTER TABLE spec_runs ADD COLUMN queued_at INTEGER");
+  }
+}
+function migrateToV3(db) {
+  const runCols = db.prepare("PRAGMA table_info(runs)").all();
+  if (!runCols.some((c) => c.name === "session_id")) {
+    db.exec("ALTER TABLE runs ADD COLUMN session_id TEXT");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_runs_session_id ON runs(session_id)");
+  }
+  const specCols = db.prepare("PRAGMA table_info(spec_runs)").all();
+  if (!specCols.some((c) => c.name === "session_id")) {
+    db.exec("ALTER TABLE spec_runs ADD COLUMN session_id TEXT");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_spec_runs_session_id ON spec_runs(session_id)");
+  }
+}
+function openDatabase(cwd) {
+  if (_db) return _db;
+  const dispatchDir = join8(cwd, ".dispatch");
+  mkdirSync2(dispatchDir, { recursive: true });
+  const dbPath = join8(dispatchDir, "dispatch.db");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("foreign_keys = ON");
+  createSchema(db);
+  _db = db;
+  return db;
+}
+function getDb() {
+  if (!_db) {
+    throw new Error("Database not open. Call openDatabase(cwd) first.");
+  }
+  return _db;
+}
+var RUN_STATUSES, TASK_STATUSES, SPEC_STATUSES, _db, CURRENT_SCHEMA_VERSION;
+var init_database = __esm({
+  "src/mcp/state/database.ts"() {
+    "use strict";
+    RUN_STATUSES = ["queued", "running", "completed", "failed", "cancelled"];
+    TASK_STATUSES = ["pending", "running", "success", "failed", "skipped"];
+    SPEC_STATUSES = ["queued", "running", "completed", "failed"];
+    _db = null;
+    CURRENT_SCHEMA_VERSION = 3;
+  }
+});
+
+// src/mcp/state/manager.ts
+var manager_exports = {};
+__export(manager_exports, {
+  addCompletionCallback: () => addCompletionCallback,
+  addLogCallback: () => addLogCallback,
+  countActiveRuns: () => countActiveRuns,
+  createRun: () => createRun,
+  createSpecRun: () => createSpecRun,
+  createTask: () => createTask,
+  emitLog: () => emitLog,
+  failAllQueuedRuns: () => failAllQueuedRuns,
+  finishRun: () => finishRun,
+  finishSpecRun: () => finishSpecRun,
+  getNextQueued: () => getNextQueued,
+  getQueuePosition: () => getQueuePosition,
+  getRun: () => getRun,
+  getSpecRun: () => getSpecRun,
+  getTasksForRun: () => getTasksForRun,
+  isLiveRun: () => isLiveRun,
+  listResumableSessions: () => listResumableSessions,
+  listRuns: () => listRuns,
+  listRunsByStatus: () => listRunsByStatus,
+  listSpecRuns: () => listSpecRuns,
+  markOrphanedRunsFailed: () => markOrphanedRunsFailed,
+  markRunStarted: () => markRunStarted,
+  markSpecRunStarted: () => markSpecRunStarted,
+  registerLiveRun: () => registerLiveRun,
+  requeueSessionRuns: () => requeueSessionRuns,
+  unregisterLiveRun: () => unregisterLiveRun,
+  updateRunCounters: () => updateRunCounters,
+  updateTaskStatus: () => updateTaskStatus,
+  waitForRunCompletion: () => waitForRunCompletion
+});
+import { randomUUID as randomUUID3 } from "crypto";
+function registerLiveRun(runId) {
+  liveRuns.set(runId, { runId, callbacks: [], completionCallbacks: [] });
+}
+function unregisterLiveRun(runId) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    for (const cb of run.completionCallbacks) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+  liveRuns.delete(runId);
+}
+function addLogCallback(runId, cb) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    run.callbacks.push(cb);
+  }
+}
+function emitLog(runId, message, level = "info") {
+  const run = liveRuns.get(runId);
+  if (run) {
+    for (const cb of run.callbacks) {
+      try {
+        cb(message, level);
+      } catch (err) {
+        if (process.env["DEBUG"]) console.error("[dispatch-mcp] log callback error:", err);
+      }
+    }
+  }
+}
+function isLiveRun(runId) {
+  return liveRuns.has(runId);
+}
+function addCompletionCallback(runId, cb) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    run.completionCallbacks.push(cb);
+  }
+}
+function waitForRunCompletion(runId, waitMs, getStatus) {
+  const effectiveWait = Math.min(Math.max(waitMs, 0), 12e4);
+  if (effectiveWait <= 0) return Promise.resolve(false);
+  const currentStatus = getStatus();
+  if (currentStatus !== null && currentStatus !== "running" && currentStatus !== "queued") {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve3) => {
+    let settled = false;
+    let pollTimer;
+    let timeoutTimer;
+    const cleanup = () => {
+      if (pollTimer) clearInterval(pollTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+    };
+    const settle = (completed) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve3(completed);
+    };
+    if (isLiveRun(runId)) {
+      addCompletionCallback(runId, () => settle(true));
+    }
+    pollTimer = setInterval(() => {
+      const s = getStatus();
+      if (s !== null && s !== "running" && s !== "queued") {
+        settle(true);
+      }
+    }, 2e3);
+    timeoutTimer = setTimeout(() => settle(false), effectiveWait);
+  });
+}
+function assertRunStatus(value) {
+  if (RUN_STATUSES.includes(value)) return value;
+  throw new Error(`Invalid RunStatus from database: "${value}"`);
+}
+function assertTaskStatus(value) {
+  if (TASK_STATUSES.includes(value)) return value;
+  throw new Error(`Invalid TaskStatus from database: "${value}"`);
+}
+function assertSpecStatus(value) {
+  if (SPEC_STATUSES.includes(value)) return value;
+  throw new Error(`Invalid SpecStatus from database: "${value}"`);
+}
+function rowToRun(row) {
+  return {
+    runId: row.run_id,
+    cwd: row.cwd,
+    issueIds: row.issue_ids,
+    status: assertRunStatus(row.status),
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    total: row.total,
+    completed: row.completed,
+    failed: row.failed,
+    error: row.error,
+    workerMessage: row.worker_message,
+    queuedAt: row.queued_at,
+    sessionId: row.session_id
+  };
+}
+function rowToTask(row) {
+  return {
+    rowId: row.id,
+    runId: row.run_id,
+    taskId: row.task_id,
+    taskText: row.task_text,
+    file: row.file,
+    line: row.line,
+    status: assertTaskStatus(row.status),
+    branch: row.branch,
+    error: row.error,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at
+  };
+}
+function rowToSpecRun(row) {
+  return {
+    runId: row.run_id,
+    cwd: row.cwd,
+    issues: row.issues,
+    status: assertSpecStatus(row.status),
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    total: row.total,
+    generated: row.generated,
+    failed: row.failed,
+    error: row.error,
+    workerMessage: row.worker_message,
+    queuedAt: row.queued_at,
+    sessionId: row.session_id
+  };
+}
+function createRun(opts) {
+  const runId = randomUUID3();
+  const db = getDb();
+  const now = Date.now();
+  const status = opts.status ?? "running";
+  db.prepare(`
+    INSERT INTO runs (run_id, cwd, issue_ids, status, started_at, worker_message, queued_at, session_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(runId, opts.cwd, JSON.stringify(opts.issueIds), status, now, opts.workerMessage ?? null, status === "queued" ? now : null, opts.sessionId ?? null);
+  registerLiveRun(runId);
+  return runId;
+}
+function updateRunCounters(runId, total, completed, failed) {
+  getDb().prepare(`
+    UPDATE runs SET total = ?, completed = ?, failed = ? WHERE run_id = ?
+  `).run(total, completed, failed, runId);
+}
+function finishRun(runId, status, error) {
+  getDb().prepare(`
+    UPDATE runs SET status = ?, finished_at = ?, error = ? WHERE run_id = ?
+  `).run(status, Date.now(), error ?? null, runId);
+  unregisterLiveRun(runId);
+}
+function getRun(runId) {
+  const row = getDb().prepare("SELECT * FROM runs WHERE run_id = ?").get(runId);
+  return row ? rowToRun(row) : null;
+}
+function listRuns(limit = 50) {
+  const rows = getDb().prepare(
+    "SELECT * FROM runs ORDER BY started_at DESC LIMIT ?"
+  ).all(limit);
+  return rows.map(rowToRun);
+}
+function listRunsByStatus(status, limit = 20) {
+  const rows = getDb().prepare(
+    "SELECT * FROM runs WHERE status = ? ORDER BY started_at DESC LIMIT ?"
+  ).all(status, limit);
+  return rows.map(rowToRun);
+}
+function createTask(opts) {
+  getDb().prepare(`
+    INSERT INTO tasks (run_id, task_id, task_text, file, line, status)
+    VALUES (?, ?, ?, ?, ?, 'pending')
+  `).run(opts.runId, opts.taskId, opts.taskText, opts.file, opts.line);
+}
+function updateTaskStatus(runId, taskId, status, opts) {
+  const now = Date.now();
+  const isTerminal = status === "success" || status === "failed" || status === "skipped";
+  const isStart = status === "running";
+  if (isStart) {
+    getDb().prepare(`
+      UPDATE tasks SET status = ?, started_at = ?, error = NULL
+      WHERE run_id = ? AND task_id = ?
+    `).run(status, now, runId, taskId);
+  } else if (isTerminal) {
+    getDb().prepare(`
+      UPDATE tasks SET status = ?, finished_at = ?, error = ?, branch = ?
+      WHERE run_id = ? AND task_id = ?
+    `).run(status, now, opts?.error ?? null, opts?.branch ?? null, runId, taskId);
+  } else {
+    getDb().prepare(`
+      UPDATE tasks SET status = ?, error = ?
+      WHERE run_id = ? AND task_id = ?
+    `).run(status, opts?.error ?? null, runId, taskId);
+  }
+}
+function getTasksForRun(runId) {
+  const rows = getDb().prepare(
+    "SELECT * FROM tasks WHERE run_id = ? ORDER BY id ASC"
+  ).all(runId);
+  return rows.map(rowToTask);
+}
+function createSpecRun(opts) {
+  const runId = randomUUID3();
+  const db = getDb();
+  const now = Date.now();
+  const status = opts.status ?? "running";
+  db.prepare(`
+    INSERT INTO spec_runs (run_id, cwd, issues, status, started_at, worker_message, queued_at, session_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(runId, opts.cwd, JSON.stringify(opts.issues), status, now, opts.workerMessage ?? null, status === "queued" ? now : null, opts.sessionId ?? null);
+  registerLiveRun(runId);
+  return runId;
+}
+function finishSpecRun(runId, status, counters, error) {
+  getDb().prepare(`
+    UPDATE spec_runs
+    SET status = ?, finished_at = ?, total = ?, generated = ?, failed = ?, error = ?
+    WHERE run_id = ?
+  `).run(status, Date.now(), counters.total, counters.generated, counters.failed, error ?? null, runId);
+  unregisterLiveRun(runId);
+}
+function listSpecRuns(limit = 50) {
+  const rows = getDb().prepare(
+    "SELECT * FROM spec_runs ORDER BY started_at DESC LIMIT ?"
+  ).all(limit);
+  return rows.map(rowToSpecRun);
+}
+function getSpecRun(runId) {
+  const row = getDb().prepare("SELECT * FROM spec_runs WHERE run_id = ?").get(runId);
+  return row ? rowToSpecRun(row) : null;
+}
+function markRunStarted(runId) {
+  getDb().prepare(`
+    UPDATE runs SET status = 'running', started_at = ? WHERE run_id = ? AND status = 'queued'
+  `).run(Date.now(), runId);
+}
+function markSpecRunStarted(runId) {
+  getDb().prepare(`
+    UPDATE spec_runs SET status = 'running', started_at = ? WHERE run_id = ? AND status = 'queued'
+  `).run(Date.now(), runId);
+}
+function getNextQueued() {
+  const db = getDb();
+  const runRow = db.prepare(
+    "SELECT run_id, worker_message FROM runs WHERE status = 'queued' AND worker_message IS NOT NULL ORDER BY queued_at ASC LIMIT 1"
+  ).get();
+  const specRow = db.prepare(
+    "SELECT run_id, worker_message FROM spec_runs WHERE status = 'queued' AND worker_message IS NOT NULL ORDER BY queued_at ASC LIMIT 1"
+  ).get();
+  if (!runRow && !specRow) return null;
+  if (runRow && specRow) {
+    const runQueuedAt = db.prepare("SELECT queued_at FROM runs WHERE run_id = ?").get(runRow.run_id).queued_at;
+    const specQueuedAt = db.prepare("SELECT queued_at FROM spec_runs WHERE run_id = ?").get(specRow.run_id).queued_at;
+    if (specQueuedAt < runQueuedAt) {
+      return { runId: specRow.run_id, workerMessage: specRow.worker_message, table: "spec_runs" };
+    }
+    return { runId: runRow.run_id, workerMessage: runRow.worker_message, table: "runs" };
+  }
+  if (runRow) return { runId: runRow.run_id, workerMessage: runRow.worker_message, table: "runs" };
+  return { runId: specRow.run_id, workerMessage: specRow.worker_message, table: "spec_runs" };
+}
+function countActiveRuns() {
+  const db = getDb();
+  const r1 = db.prepare("SELECT COUNT(*) as cnt FROM runs WHERE status = 'running'").get();
+  const r2 = db.prepare("SELECT COUNT(*) as cnt FROM spec_runs WHERE status = 'running'").get();
+  return r1.cnt + r2.cnt;
+}
+function getQueuePosition(runId) {
+  const db = getDb();
+  const runRow = db.prepare("SELECT queued_at FROM runs WHERE run_id = ? AND status = 'queued'").get(runId);
+  if (runRow) {
+    const pos = db.prepare(
+      "SELECT COUNT(*) as cnt FROM runs WHERE status = 'queued' AND queued_at <= ?"
+    ).get(runRow.queued_at);
+    const specBefore = db.prepare(
+      "SELECT COUNT(*) as cnt FROM spec_runs WHERE status = 'queued' AND queued_at < ?"
+    ).get(runRow.queued_at);
+    return pos.cnt + specBefore.cnt;
+  }
+  const specRow = db.prepare("SELECT queued_at FROM spec_runs WHERE run_id = ? AND status = 'queued'").get(runId);
+  if (specRow) {
+    const pos = db.prepare(
+      "SELECT COUNT(*) as cnt FROM spec_runs WHERE status = 'queued' AND queued_at <= ?"
+    ).get(specRow.queued_at);
+    const runsBefore = db.prepare(
+      "SELECT COUNT(*) as cnt FROM runs WHERE status = 'queued' AND queued_at < ?"
+    ).get(specRow.queued_at);
+    return pos.cnt + runsBefore.cnt;
+  }
+  return null;
+}
+function markOrphanedRunsFailed(opts) {
+  const db = getDb();
+  const now = Date.now();
+  if (opts?.exceptSessionId) {
+    db.prepare(`
+      UPDATE runs SET status = 'failed', finished_at = ?, error = 'Server restarted'
+      WHERE status IN ('queued', 'running') AND (session_id IS NULL OR session_id != ?)
+    `).run(now, opts.exceptSessionId);
+    db.prepare(`
+      UPDATE spec_runs SET status = 'failed', finished_at = ?, error = 'Server restarted'
+      WHERE status IN ('queued', 'running') AND (session_id IS NULL OR session_id != ?)
+    `).run(now, opts.exceptSessionId);
+  } else {
+    db.prepare(`
+      UPDATE runs SET status = 'failed', finished_at = ?, error = 'Server restarted'
+      WHERE status IN ('queued', 'running')
+    `).run(now);
+    db.prepare(`
+      UPDATE spec_runs SET status = 'failed', finished_at = ?, error = 'Server restarted'
+      WHERE status IN ('queued', 'running')
+    `).run(now);
+  }
+}
+function failAllQueuedRuns() {
+  const db = getDb();
+  const now = Date.now();
+  db.prepare(`
+    UPDATE runs SET status = 'failed', finished_at = ?, error = 'Server shutting down'
+    WHERE status = 'queued'
+  `).run(now);
+  db.prepare(`
+    UPDATE spec_runs SET status = 'failed', finished_at = ?, error = 'Server shutting down'
+    WHERE status = 'queued'
+  `).run(now);
+}
+function listResumableSessions(cwd) {
+  const db = getDb();
+  const rows = db.prepare(`
+    SELECT session_id, MIN(started_at) as started_at,
+           COUNT(*) as total_runs,
+           SUM(CASE WHEN status IN ('queued', 'failed') THEN 1 ELSE 0 END) as incomplete,
+           (SELECT issue_ids FROM runs r2 WHERE r2.session_id = runs.session_id ORDER BY started_at ASC LIMIT 1) as issue_ids
+    FROM runs
+    WHERE session_id IS NOT NULL AND cwd = ?
+      AND session_id IN (
+        SELECT DISTINCT session_id FROM runs
+        WHERE status IN ('queued', 'failed') AND session_id IS NOT NULL AND cwd = ?
+      )
+    GROUP BY session_id
+    ORDER BY MIN(started_at) DESC
+  `).all(cwd, cwd);
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    startedAt: r.started_at,
+    totalRuns: r.total_runs,
+    incompleteRuns: r.incomplete,
+    issueIds: r.issue_ids
+  }));
+}
+function requeueSessionRuns(sessionId) {
+  const db = getDb();
+  const now = Date.now();
+  const runRows = db.prepare(`
+    SELECT run_id FROM runs
+    WHERE session_id = ? AND status IN ('failed', 'queued')
+      AND worker_message IS NOT NULL
+  `).all(sessionId);
+  const specRows = db.prepare(`
+    SELECT run_id FROM spec_runs
+    WHERE session_id = ? AND status IN ('failed', 'queued')
+      AND worker_message IS NOT NULL
+  `).all(sessionId);
+  if (runRows.length > 0) {
+    db.prepare(`
+      UPDATE runs SET status = 'queued', queued_at = ?, finished_at = NULL, error = NULL
+      WHERE session_id = ? AND status IN ('failed', 'queued') AND worker_message IS NOT NULL
+    `).run(now, sessionId);
+  }
+  if (specRows.length > 0) {
+    db.prepare(`
+      UPDATE spec_runs SET status = 'queued', queued_at = ?, finished_at = NULL, error = NULL
+      WHERE session_id = ? AND status IN ('failed', 'queued') AND worker_message IS NOT NULL
+    `).run(now, sessionId);
+  }
+  const runIds = [...runRows.map((r) => r.run_id), ...specRows.map((r) => r.run_id)];
+  for (const runId of runIds) {
+    registerLiveRun(runId);
+  }
+  return runIds;
+}
+var liveRuns;
+var init_manager = __esm({
+  "src/mcp/state/manager.ts"() {
+    "use strict";
+    init_database();
+    liveRuns = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/orchestrator/runner.ts
+import { randomUUID as randomUUID6 } from "crypto";
+
+// src/config.ts
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join6, dirname as dirname4 } from "path";
+
+// src/providers/interface.ts
+var PROVIDER_NAMES = ["opencode", "copilot", "claude", "codex"];
+
+// src/providers/opencode.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
+import {
+  createOpencode,
+  createOpencodeClient
+} from "@opencode-ai/sdk";
+
+// src/providers/progress.ts
+var ANSI_PATTERN = /(?:\u001B\[[0-?]*[ -/]*[@-~]|\u009B[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\))/g;
+var CONTROL_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+function sanitizeProgressText(raw, maxLength = 120) {
+  const text = raw.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  if (maxLength <= 1) return maxLength <= 0 ? "" : "\u2026";
+  return `${text.slice(0, maxLength - 1).trimEnd()}\u2026`;
+}
+function createProgressReporter(onProgress) {
+  let last;
+  return {
+    emit(raw) {
+      if (!onProgress) return;
+      const text = sanitizeProgressText(raw ?? "");
+      if (!text || text === last) return;
+      last = text;
+      try {
+        onProgress({ text });
+      } catch {
+      }
+    },
+    reset() {
+      last = void 0;
+    }
+  };
+}
 
 // src/helpers/logger.ts
 import chalk from "chalk";
@@ -215,956 +1135,98 @@ Object.defineProperty(log, "verbose", {
   configurable: true
 });
 
-// src/helpers/branch-validation.ts
-var InvalidBranchNameError = class extends Error {
-  constructor(branch, reason) {
-    const detail = reason ? ` (${reason})` : "";
-    super(`Invalid branch name: "${branch}"${detail}`);
-    this.name = "InvalidBranchNameError";
-  }
-};
-var VALID_BRANCH_NAME_RE = /^[a-zA-Z0-9._\-/]+$/;
-function isValidBranchName(name) {
-  if (name.length === 0 || name.length > 255) return false;
-  if (!VALID_BRANCH_NAME_RE.test(name)) return false;
-  if (name.startsWith("/") || name.endsWith("/")) return false;
-  if (name.includes("..")) return false;
-  if (name.endsWith(".lock")) return false;
-  if (name.includes("@{")) return false;
-  if (name.includes("//")) return false;
-  return true;
+// src/helpers/guards.ts
+function hasProperty(value, key) {
+  return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, key);
 }
 
-// src/helpers/auth.ts
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { join as join2, dirname as dirname2 } from "path";
-import { homedir } from "os";
-import { Octokit } from "@octokit/rest";
-import { createOAuthDeviceAuth } from "@octokit/auth-oauth-device";
-import { DeviceCodeCredential } from "@azure/identity";
-import * as azdev from "azure-devops-node-api";
-import open from "open";
-
-// src/constants.ts
-var GITHUB_CLIENT_ID = "Ov23liUMP1Oyg811IF58";
-var AZURE_CLIENT_ID = "150a3098-01dd-4126-8b10-5e7f77492e5c";
-var AZURE_TENANT_ID = "organizations";
-var AZURE_DEVOPS_SCOPE = "499b84ac-1321-427f-aa17-267ca6975798/.default";
-
-// src/helpers/auth.ts
-var AUTH_PATH = join2(homedir(), ".dispatch", "auth.json");
-var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
-var authPromptHandler = null;
-function setAuthPromptHandler(handler) {
-  authPromptHandler = handler;
-}
-async function loadAuthCache() {
-  try {
-    const raw = await readFile(AUTH_PATH, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-async function saveAuthCache(cache) {
-  await mkdir(dirname2(AUTH_PATH), { recursive: true });
-  await writeFile(AUTH_PATH, JSON.stringify(cache, null, 2) + "\n", "utf-8");
-  if (process.platform !== "win32") {
-    try {
-      await chmod(AUTH_PATH, 384);
-    } catch {
-    }
-  }
-}
-async function getGithubOctokit() {
-  const cache = await loadAuthCache();
-  if (cache.github?.token) {
-    return new Octokit({ auth: cache.github.token });
+// 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;
   }
-  const auth = createOAuthDeviceAuth({
-    clientId: GITHUB_CLIENT_ID,
-    clientType: "oauth-app",
-    scopes: ["repo"],
-    onVerification(verification) {
-      const msg = `Enter code ${verification.user_code} at ${verification.verification_uri}`;
-      if (authPromptHandler) {
-        authPromptHandler(msg);
-      } else {
-        log.info(msg);
+};
+var DEFAULT_PLAN_TIMEOUT_MIN = 30;
+function withTimeout(promise, ms, label) {
+  const p = new Promise((resolve3, 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);
+        resolve3(value);
+      },
+      (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        reject(err);
       }
-      open(verification.verification_uri).catch(() => {
-      });
-    }
+    );
   });
-  const authentication = await auth({ type: "oauth" });
-  cache.github = { token: authentication.token };
-  await saveAuthCache(cache);
-  return new Octokit({ auth: authentication.token });
+  p.catch(() => {
+  });
+  return p;
 }
-async function getAzureConnection(orgUrl) {
-  const cache = await loadAuthCache();
-  if (cache.azure?.token && cache.azure.expiresAt) {
-    const expiresAt = new Date(cache.azure.expiresAt).getTime();
-    if (expiresAt - Date.now() > EXPIRY_BUFFER_MS) {
-      return new azdev.WebApi(
-        orgUrl,
-        azdev.getBearerHandler(cache.azure.token)
-      );
+
+// src/providers/opencode.ts
+var SESSION_READY_TIMEOUT_MS = 6e5;
+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`);
     }
-  }
-  const credential = new DeviceCodeCredential({
-    tenantId: AZURE_TENANT_ID,
-    clientId: AZURE_CLIENT_ID,
-    userPromptCallback(deviceCodeInfo) {
-      const note = "Azure DevOps requires a work or school account (personal Microsoft accounts are not supported).";
-      const msg = `${note}
-${deviceCodeInfo.message}`;
-      if (authPromptHandler) {
-        authPromptHandler(msg);
-      } else {
-        log.info(msg);
-      }
-      open(deviceCodeInfo.verificationUri).catch(() => {
-      });
+    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;
     }
-  });
-  const accessToken = await credential.getToken(AZURE_DEVOPS_SCOPE);
-  if (!accessToken) {
-    throw new Error(
-      "Azure device-code authentication did not return a token. Please try again."
-    );
   }
-  cache.azure = {
-    token: accessToken.token,
-    expiresAt: new Date(accessToken.expiresOnTimestamp).toISOString()
-  };
-  await saveAuthCache(cache);
-  return new azdev.WebApi(
-    orgUrl,
-    azdev.getBearerHandler(accessToken.token)
-  );
-}
-async function ensureAuthReady(source, cwd, org) {
-  if (source === "github") {
-    const remoteUrl = await getGitRemoteUrl(cwd);
-    if (remoteUrl && parseGitHubRemoteUrl(remoteUrl)) {
-      await getGithubOctokit();
-    } else if (!remoteUrl) {
-      log.warn("No git remote found \u2014 skipping GitHub pre-authentication");
+  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.warn("Remote URL is not a GitHub repository \u2014 skipping GitHub pre-authentication");
-    }
-  } else if (source === "azdevops") {
-    let orgUrl = org;
-    if (!orgUrl) {
-      const remoteUrl = await getGitRemoteUrl(cwd);
-      if (remoteUrl) {
-        const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
-        if (parsed) orgUrl = parsed.orgUrl;
-        else log.warn("Remote URL is not an Azure DevOps repository \u2014 skipping Azure pre-authentication");
-      } else {
-        log.warn("No git remote found \u2014 skipping Azure DevOps pre-authentication");
-      }
+      log.debug(`Ignoring model override "${opts.model}": must be in "provider/model" format`);
     }
-    if (orgUrl) await getAzureConnection(orgUrl);
   }
-}
-
-// node_modules/@octokit/request-error/dist-src/index.js
-var RequestError = class extends Error {
-  name;
-  /**
-   * http status code
-   */
-  status;
-  /**
-   * Request options that lead to the error.
-   */
-  request;
-  /**
-   * Response object if a response was received
-   */
-  response;
-  constructor(message, statusCode, options) {
-    super(message);
-    this.name = "HttpError";
-    this.status = Number.parseInt(statusCode);
-    if (Number.isNaN(this.status)) {
-      this.status = 0;
-    }
-    if ("response" in options) {
-      this.response = options.response;
-    }
-    const requestCopy = Object.assign({}, options.request);
-    if (options.request.headers.authorization) {
-      requestCopy.headers = Object.assign({}, options.request.headers, {
-        authorization: options.request.headers.authorization.replace(
-          /(?<! ) .*$/,
-          " [REDACTED]"
-        )
-      });
-    }
-    requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
-    this.request = requestCopy;
-  }
-};
-
-// src/datasources/github.ts
-var exec = promisify(execFile);
-async function git(args, cwd) {
-  const { stdout } = await exec("git", args, { cwd, shell: process.platform === "win32" });
-  return stdout;
-}
-function redactUrl(url) {
-  return url.replace(/\/\/[^@/]+@/, "//***@");
-}
-var ownerRepoCache = /* @__PURE__ */ new Map();
-async function getOwnerRepo(cwd) {
-  const cached = ownerRepoCache.get(cwd);
-  if (cached) return cached;
-  const remoteUrl = await getGitRemoteUrl(cwd);
-  if (!remoteUrl) {
-    throw new Error("Could not determine git remote URL. Is this a git repository with an origin remote?");
-  }
-  const parsed = parseGitHubRemoteUrl(remoteUrl);
-  if (!parsed) {
-    throw new Error(`Could not parse GitHub owner/repo from remote URL: ${redactUrl(remoteUrl)}`);
-  }
-  ownerRepoCache.set(cwd, parsed);
-  return parsed;
-}
-function buildBranchName(issueNumber, _title, username = "unknown") {
-  return `${username}/dispatch/issue-${issueNumber}`;
-}
-async function getDefaultBranch(cwd) {
-  const PREFIX = "refs/remotes/origin/";
-  try {
-    const ref = await git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
-    const trimmed = ref.trim();
-    const branch = trimmed.startsWith(PREFIX) ? trimmed.slice(PREFIX.length) : trimmed;
-    if (!isValidBranchName(branch)) {
-      throw new InvalidBranchNameError(branch, "from symbolic-ref output");
-    }
-    return branch;
-  } catch (err) {
-    if (err instanceof InvalidBranchNameError) {
-      throw err;
-    }
-    try {
-      await git(["rev-parse", "--verify", "main"], cwd);
-      return "main";
-    } catch {
-      return "master";
-    }
-  }
-}
-var datasource = {
-  name: "github",
-  supportsGit() {
-    return true;
-  },
-  async list(opts = {}) {
-    const cwd = opts.cwd || process.cwd();
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    const issues = await octokit.paginate(
-      octokit.rest.issues.listForRepo,
-      {
-        owner,
-        repo,
-        state: "open"
-      }
-    );
-    return issues.filter((issue) => !issue.pull_request).map((issue) => ({
-      number: String(issue.number),
-      title: issue.title ?? "",
-      body: issue.body ?? "",
-      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
-      state: issue.state ?? "open",
-      url: issue.html_url ?? "",
-      comments: [],
-      acceptanceCriteria: ""
-    }));
-  },
-  async fetch(issueId, opts = {}) {
-    const cwd = opts.cwd || process.cwd();
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    const { data: issue } = await octokit.rest.issues.get({
-      owner,
-      repo,
-      issue_number: Number(issueId)
-    });
-    const issueComments = await octokit.paginate(
-      octokit.rest.issues.listComments,
-      {
-        owner,
-        repo,
-        issue_number: Number(issueId)
-      }
-    );
-    const comments = issueComments.map(
-      (c) => `**${c.user?.login ?? "unknown"}:** ${c.body ?? ""}`
-    );
-    return {
-      number: String(issue.number),
-      title: issue.title ?? "",
-      body: issue.body ?? "",
-      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
-      state: issue.state ?? "open",
-      url: issue.html_url ?? "",
-      comments,
-      acceptanceCriteria: ""
-    };
-  },
-  async update(issueId, title, body, opts = {}) {
-    const cwd = opts.cwd || process.cwd();
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    await octokit.rest.issues.update({
-      owner,
-      repo,
-      issue_number: Number(issueId),
-      title,
-      body
-    });
-  },
-  async close(issueId, opts = {}) {
-    const cwd = opts.cwd || process.cwd();
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    await octokit.rest.issues.update({
-      owner,
-      repo,
-      issue_number: Number(issueId),
-      state: "closed"
-    });
-  },
-  async create(title, body, opts = {}) {
-    const cwd = opts.cwd || process.cwd();
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    const { data: issue } = await octokit.rest.issues.create({
-      owner,
-      repo,
-      title,
-      body
-    });
-    return {
-      number: String(issue.number),
-      title: issue.title ?? "",
-      body: issue.body ?? "",
-      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
-      state: issue.state ?? "open",
-      url: issue.html_url ?? "",
-      comments: [],
-      acceptanceCriteria: ""
-    };
-  },
-  async getUsername(opts) {
-    if (opts.username) return opts.username;
-    return deriveShortUsername(opts.cwd, "unknown");
-  },
-  getDefaultBranch(opts) {
-    return getDefaultBranch(opts.cwd);
-  },
-  async getCurrentBranch(opts) {
-    try {
-      const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd)).trim();
-      if (branch && branch !== "HEAD") return branch;
-    } catch {
-    }
-    return this.getDefaultBranch(opts);
-  },
-  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")) {
-        try {
-          await git(["checkout", branchName], cwd);
-        } catch (checkoutErr) {
-          const checkoutMessage = log.extractMessage(checkoutErr);
-          if (checkoutMessage.includes("already used by worktree")) {
-            await git(["worktree", "prune"], cwd);
-            await git(["checkout", branchName], cwd);
-          } else {
-            throw checkoutErr;
-          }
-        }
-      } 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, baseBranch) {
-    const cwd = opts.cwd;
-    const { owner, repo } = await getOwnerRepo(cwd);
-    const octokit = await getGithubOctokit();
-    const prBody = body || `Closes #${issueNumber}`;
-    try {
-      const target = baseBranch ?? await getDefaultBranch(cwd);
-      const { data: pr } = await octokit.rest.pulls.create({
-        owner,
-        repo,
-        title,
-        body: prBody,
-        head: branchName,
-        base: target
-      });
-      return pr.html_url;
-    } catch (err) {
-      const isValidationError = err instanceof RequestError && err.status === 422;
-      if (isValidationError) {
-        const { data: prs } = await octokit.rest.pulls.list({
-          owner,
-          repo,
-          head: `${owner}:${branchName}`,
-          state: "open"
-        });
-        if (prs.length > 0) {
-          return prs[0].html_url;
-        }
-      }
-      throw err;
-    }
-  }
-};
-
-// src/datasources/azdevops.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import { PullRequestStatus } from "azure-devops-node-api/interfaces/GitInterfaces.js";
-var exec2 = promisify2(execFile2);
-var doneStateCache = /* @__PURE__ */ new Map();
-async function git2(args, cwd) {
-  const { stdout } = await exec2("git", args, { cwd, shell: process.platform === "win32" });
-  return stdout;
-}
-function redactUrl2(url) {
-  return url.replace(/\/\/[^@/]+@/, "//***@");
-}
-async function getOrgAndProject(opts = {}) {
-  let orgUrl = opts.org;
-  let project = opts.project;
-  if (!orgUrl || !project) {
-    const cwd = opts.cwd || process.cwd();
-    const remoteUrl = await getGitRemoteUrl(cwd);
-    if (!remoteUrl) {
-      throw new Error(
-        "Could not determine git remote URL. Is this a git repository with an origin remote?"
-      );
-    }
-    const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
-    if (!parsed) {
-      throw new Error(
-        `Could not parse Azure DevOps org/project from remote URL: ${redactUrl2(remoteUrl)}`
-      );
-    }
-    orgUrl = orgUrl || parsed.orgUrl;
-    project = project || parsed.project;
-  }
-  const connection = await getAzureConnection(orgUrl);
-  return { orgUrl, project, connection };
-}
-function mapWorkItemToIssueDetails(item, id, comments, defaults) {
-  const fields = item.fields ?? {};
-  return {
-    number: String(item.id ?? id),
-    title: fields["System.Title"] ?? defaults?.title ?? "",
-    body: fields["System.Description"] ?? defaults?.body ?? "",
-    labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
-    state: fields["System.State"] ?? defaults?.state ?? "",
-    url: item._links?.html?.href ?? item.url ?? "",
-    comments,
-    acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? "",
-    iterationPath: fields["System.IterationPath"] || void 0,
-    areaPath: fields["System.AreaPath"] || void 0,
-    assignee: fields["System.AssignedTo"]?.displayName || void 0,
-    priority: fields["Microsoft.VSTS.Common.Priority"] ?? void 0,
-    storyPoints: fields["Microsoft.VSTS.Scheduling.StoryPoints"] ?? fields["Microsoft.VSTS.Scheduling.Effort"] ?? fields["Microsoft.VSTS.Scheduling.Size"] ?? void 0,
-    workItemType: fields["System.WorkItemType"] || defaults?.workItemType || void 0
-  };
-}
-async function detectWorkItemType(opts = {}) {
-  try {
-    const { project, connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    const types = await witApi.getWorkItemTypes(project);
-    if (!Array.isArray(types) || types.length === 0) return null;
-    const names = types.map((t) => t.name).filter((n) => !!n);
-    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;
-  }
-}
-async function detectDoneState(workItemType, opts = {}) {
-  const { orgUrl, project, connection } = await getOrgAndProject(opts);
-  const cacheKey = `${orgUrl}|${project}|${workItemType}`;
-  const cached = doneStateCache.get(cacheKey);
-  if (cached) return cached;
-  try {
-    const witApi = await connection.getWorkItemTrackingApi();
-    const states = await witApi.getWorkItemTypeStates(project, workItemType);
-    if (Array.isArray(states)) {
-      const completed = states.find((s) => s.category === "Completed");
-      if (completed?.name) {
-        doneStateCache.set(cacheKey, completed.name);
-        return completed.name;
-      }
-      const names = states.map((s) => s.name).filter((n) => !!n);
-      const fallbacks = ["Done", "Closed", "Resolved", "Completed"];
-      for (const f of fallbacks) {
-        if (names.includes(f)) {
-          doneStateCache.set(cacheKey, f);
-          return f;
-        }
-      }
-    }
-  } catch {
-  }
-  return "Closed";
-}
-async function fetchComments(workItemId, project, connection) {
-  try {
-    const witApi = await connection.getWorkItemTrackingApi();
-    const commentList = await witApi.getComments(project, workItemId);
-    if (commentList.comments && Array.isArray(commentList.comments)) {
-      return commentList.comments.map((c) => {
-        const author = c.createdBy?.displayName ?? "unknown";
-        return `**${author}:** ${c.text ?? ""}`;
-      });
-    }
-    return [];
-  } catch {
-    return [];
-  }
-}
-var datasource2 = {
-  name: "azdevops",
-  supportsGit() {
-    return true;
-  },
-  async list(opts = {}) {
-    const { project, connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    const conditions = [
-      "[System.State] <> 'Closed'",
-      "[System.State] <> 'Done'",
-      "[System.State] <> 'Removed'"
-    ];
-    if (opts.iteration) {
-      const iterValue = String(opts.iteration).trim();
-      if (iterValue === "@CurrentIteration") {
-        conditions.push(`[System.IterationPath] UNDER @CurrentIteration`);
-      } else {
-        const escaped = iterValue.replace(/'/g, "''");
-        if (escaped) conditions.push(`[System.IterationPath] UNDER '${escaped}'`);
-      }
-    }
-    if (opts.area) {
-      const area = String(opts.area).trim().replace(/'/g, "''");
-      if (area) {
-        conditions.push(`[System.AreaPath] UNDER '${area}'`);
-      }
-    }
-    const wiql = `SELECT [System.Id] FROM workitems WHERE ${conditions.join(" AND ")} ORDER BY [System.CreatedDate] DESC`;
-    const queryResult = await witApi.queryByWiql({ query: wiql }, { project });
-    const workItemRefs = queryResult.workItems ?? [];
-    if (workItemRefs.length === 0) return [];
-    const ids = workItemRefs.map((ref) => ref.id).filter((id) => id != null);
-    if (ids.length === 0) return [];
-    try {
-      const items = await witApi.getWorkItems(ids);
-      const itemsArray = Array.isArray(items) ? items : [items];
-      const commentsArray = [];
-      const CONCURRENCY = 5;
-      for (let i = 0; i < itemsArray.length; i += CONCURRENCY) {
-        const batch = itemsArray.slice(i, i + CONCURRENCY);
-        const batchResults = await Promise.all(
-          // item.id is guaranteed non-null here: the ids array was built by filtering
-          // out null ids from workItemRefs, and itemsArray came from getWorkItems(ids).
-          batch.map((item) => fetchComments(item.id, project, connection))
-        );
-        commentsArray.push(...batchResults);
-      }
-      return itemsArray.map(
-        (item, i) => mapWorkItemToIssueDetails(item, String(item.id), commentsArray[i])
-      );
-    } catch (err) {
-      log.debug(`Batch getWorkItems failed, falling back to individual fetches: ${log.extractMessage(err)}`);
-      const results = await Promise.all(
-        ids.map((id) => datasource2.fetch(String(id), opts))
-      );
-      return results;
-    }
-  },
-  async fetch(issueId, opts = {}) {
-    const { project, connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    const item = await witApi.getWorkItem(Number(issueId));
-    const comments = await fetchComments(Number(issueId), project, connection);
-    return mapWorkItemToIssueDetails(item, issueId, comments);
-  },
-  async update(issueId, title, body, opts = {}) {
-    const { connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    const document = [
-      { op: "add", path: "/fields/System.Title", value: title },
-      { op: "add", path: "/fields/System.Description", value: body }
-    ];
-    await witApi.updateWorkItem(null, document, Number(issueId));
-  },
-  async close(issueId, opts = {}) {
-    const { connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    let workItemType = opts.workItemType;
-    if (!workItemType) {
-      const item = await witApi.getWorkItem(Number(issueId));
-      workItemType = item.fields?.["System.WorkItemType"] ?? void 0;
-    }
-    const state = workItemType ? await detectDoneState(workItemType, opts) : "Closed";
-    const document = [
-      { op: "add", path: "/fields/System.State", value: state }
-    ];
-    await witApi.updateWorkItem(null, document, Number(issueId));
-  },
-  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 { project, connection } = await getOrgAndProject(opts);
-    const witApi = await connection.getWorkItemTrackingApi();
-    const document = [
-      { op: "add", path: "/fields/System.Title", value: title },
-      { op: "add", path: "/fields/System.Description", value: body }
-    ];
-    const item = await witApi.createWorkItem(
-      // null as any: SDK customHeaders param — passing null is the documented way to omit it.
-      null,
-      document,
-      project,
-      workItemType
-    );
-    return mapWorkItemToIssueDetails(item, String(item.id), [], {
-      title,
-      body,
-      state: "New",
-      workItemType
-    });
-  },
-  async getDefaultBranch(opts) {
-    const PREFIX = "refs/remotes/origin/";
-    try {
-      const ref = await git2(["symbolic-ref", "refs/remotes/origin/HEAD"], opts.cwd);
-      const trimmed = ref.trim();
-      const branch = trimmed.startsWith(PREFIX) ? trimmed.slice(PREFIX.length) : trimmed;
-      if (!isValidBranchName(branch)) {
-        throw new InvalidBranchNameError(branch, "from symbolic-ref output");
-      }
-      return branch;
-    } catch (err) {
-      if (err instanceof InvalidBranchNameError) {
-        throw err;
-      }
-      try {
-        await git2(["rev-parse", "--verify", "main"], opts.cwd);
-        return "main";
-      } catch {
-        return "master";
-      }
-    }
-  },
-  async getCurrentBranch(opts) {
-    try {
-      const branch = (await git2(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd)).trim();
-      if (branch && branch !== "HEAD") return branch;
-    } catch {
-    }
-    return this.getDefaultBranch(opts);
-  },
-  async getUsername(opts) {
-    if (opts.username) return opts.username;
-    return deriveShortUsername(opts.cwd, "unknown");
-  },
-  buildBranchName(issueNumber, _title, username) {
-    const branch = `${username}/dispatch/issue-${issueNumber}`;
-    if (!isValidBranchName(branch)) {
-      throw new InvalidBranchNameError(branch);
-    }
-    return branch;
-  },
-  async createAndSwitchBranch(branchName, opts) {
-    if (!isValidBranchName(branchName)) {
-      throw new InvalidBranchNameError(branchName);
-    }
-    try {
-      await git2(["checkout", "-b", branchName], opts.cwd);
-    } catch (err) {
-      const message = log.extractMessage(err);
-      if (message.includes("already exists")) {
-        try {
-          await git2(["checkout", branchName], opts.cwd);
-        } catch (checkoutErr) {
-          const checkoutMessage = log.extractMessage(checkoutErr);
-          if (checkoutMessage.includes("already used by worktree")) {
-            await git2(["worktree", "prune"], opts.cwd);
-            await git2(["checkout", branchName], opts.cwd);
-          } else {
-            throw checkoutErr;
-          }
-        }
-      } else {
-        throw err;
-      }
-    }
-  },
-  async switchBranch(branchName, opts) {
-    await git2(["checkout", branchName], opts.cwd);
-  },
-  async pushBranch(branchName, opts) {
-    await git2(["push", "--set-upstream", "origin", branchName], opts.cwd);
-  },
-  async commitAllChanges(message, opts) {
-    await git2(["add", "-A"], opts.cwd);
-    const status = await git2(["diff", "--cached", "--stat"], opts.cwd);
-    if (!status.trim()) {
-      return;
-    }
-    await git2(["commit", "-m", message], opts.cwd);
-  },
-  async createPullRequest(branchName, issueNumber, title, body, opts, baseBranch) {
-    const cwd = opts.cwd;
-    const { orgUrl, project, connection } = await getOrgAndProject(opts);
-    const gitApi = await connection.getGitApi();
-    const remoteUrl = await getGitRemoteUrl(cwd);
-    if (!remoteUrl) {
-      throw new Error("Could not determine git remote URL.");
-    }
-    const repos = await gitApi.getRepositories(project);
-    const normalizeUrl = (u) => u.replace(/\/\/[^@/]+@/, "//").replace(/\.git$/, "").replace(/\/$/, "").toLowerCase();
-    const normalizedRemote = normalizeUrl(remoteUrl);
-    const repo = repos.find(
-      (r) => r.remoteUrl && normalizeUrl(r.remoteUrl) === normalizedRemote || r.sshUrl && normalizeUrl(r.sshUrl) === normalizedRemote || r.webUrl && normalizeUrl(r.webUrl) === normalizedRemote
-    );
-    if (!repo || !repo.id) {
-      throw new Error(`Could not find Azure DevOps repository matching remote URL: ${redactUrl2(remoteUrl)}`);
-    }
-    const target = baseBranch ?? await this.getDefaultBranch(opts);
-    try {
-      const pr = await gitApi.createPullRequest(
-        {
-          sourceRefName: `refs/heads/${branchName}`,
-          targetRefName: `refs/heads/${target}`,
-          title,
-          description: body || `Resolves AB#${issueNumber}`,
-          workItemRefs: [{ id: issueNumber }]
-        },
-        repo.id,
-        project
-      );
-      const webUrl = repo.webUrl ? `${repo.webUrl}/pullrequest/${pr.pullRequestId}` : pr.url ?? "";
-      return webUrl;
-    } catch (err) {
-      const message = log.extractMessage(err);
-      if (message.includes("already exists")) {
-        const prs = await gitApi.getPullRequests(
-          repo.id,
-          {
-            sourceRefName: `refs/heads/${branchName}`,
-            status: PullRequestStatus.Active
-          },
-          project
-        );
-        if (Array.isArray(prs) && prs.length > 0) {
-          const existingPr = prs[0];
-          const webUrl = repo.webUrl ? `${repo.webUrl}/pullrequest/${existingPr.pullRequestId}` : existingPr.url ?? "";
-          return webUrl;
-        }
-        return "";
-      }
-      throw err;
-    }
-  }
-};
-
-// src/datasources/md.ts
-import { execFile as execFile5 } from "child_process";
-import { readFile as readFile5, writeFile as writeFile3, readdir, mkdir as mkdir3, rename } from "fs/promises";
-import { basename, dirname as dirname4, isAbsolute, join as join6, parse as parsePath, resolve } from "path";
-import { promisify as promisify5 } from "util";
-import { glob } from "glob";
-
-// 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/config.ts
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join5, dirname as dirname3 } from "path";
-
-// src/providers/interface.ts
-var PROVIDER_NAMES = ["opencode", "copilot", "claude", "codex"];
-
-// src/providers/opencode.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import {
-  createOpencode,
-  createOpencodeClient
-} from "@opencode-ai/sdk";
-
-// src/providers/progress.ts
-var ANSI_PATTERN = /(?:\u001B\[[0-?]*[ -/]*[@-~]|\u009B[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\))/g;
-var CONTROL_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
-function sanitizeProgressText(raw, maxLength = 120) {
-  const text = raw.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "").replace(/\s+/g, " ").trim();
-  if (!text) return "";
-  if (text.length <= maxLength) return text;
-  if (maxLength <= 1) return maxLength <= 0 ? "" : "\u2026";
-  return `${text.slice(0, maxLength - 1).trimEnd()}\u2026`;
-}
-function createProgressReporter(onProgress) {
-  let last;
-  return {
-    emit(raw) {
-      if (!onProgress) return;
-      const text = sanitizeProgressText(raw ?? "");
-      if (!text || text === last) return;
-      last = text;
-      try {
-        onProgress({ text });
-      } catch {
-      }
-    },
-    reset() {
-      last = void 0;
-    }
-  };
-}
-
-// src/helpers/guards.ts
-function hasProperty(value, key) {
-  return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, key);
-}
-
-// 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;
-  }
-};
-var DEFAULT_PLAN_TIMEOUT_MIN = 30;
-function withTimeout(promise, ms, label) {
-  const p = new Promise((resolve3, 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);
-        resolve3(value);
-      },
-      (err) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        reject(err);
-      }
-    );
-  });
-  p.catch(() => {
-  });
-  return p;
-}
-
-// src/providers/opencode.ts
-var SESSION_READY_TIMEOUT_MS = 6e5;
-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)}`);
+  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 {
@@ -1440,9 +1502,9 @@ async function boot2(opts) {
 
 // src/providers/claude.ts
 import { randomUUID } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
 import { unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
 var SESSION_READY_TIMEOUT_MS3 = 6e5;
 async function boot3(opts) {
@@ -1495,14 +1557,130 @@ async function boot3(opts) {
                 }
               }
             }
-          })(),
-          SESSION_READY_TIMEOUT_MS3,
-          "claude session stream"
+          })(),
+          SESSION_READY_TIMEOUT_MS3,
+          "claude session stream"
+        );
+        if (!receivedAssistant) {
+          throw new Error("Claude stream ended before receiving an assistant message");
+        }
+        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 send(sessionId, text) {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        throw new Error(`Claude session ${sessionId} not found`);
+      }
+      log.debug(`Sending follow-up to session ${sessionId} (${text.length} chars)...`);
+      try {
+        await session.send(text);
+      } catch (err) {
+        log.debug(`Follow-up send failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async cleanup() {
+      log.debug("Cleaning up Claude provider...");
+      for (const session of sessions.values()) {
+        try {
+          await Promise.resolve(session.close());
+        } catch (err) {
+          log.debug(`Failed to close Claude session: ${log.formatErrorChain(err)}`);
+        }
+      }
+      sessions.clear();
+    }
+  };
+}
+
+// src/providers/codex.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var SESSION_READY_TIMEOUT_MS4 = 6e5;
+async function loadCodexSdk() {
+  return import("@openai/codex-sdk");
+}
+async function boot4(opts) {
+  const model = opts?.model ?? "o4-mini";
+  log.debug(`Booting Codex provider with model ${model}`);
+  const { Codex, Thread } = await loadCodexSdk();
+  const codex = new Codex();
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    name: "codex",
+    model,
+    async createSession() {
+      log.debug("Creating Codex session...");
+      try {
+        const sessionId = randomUUID2();
+        const thread = codex.startThread({
+          model,
+          approvalPolicy: "never",
+          sandboxMode: "workspace-write",
+          ...opts?.cwd ? { workingDirectory: opts.cwd } : {}
+        });
+        sessions.set(sessionId, thread);
+        log.debug(`Session created: ${sessionId}`);
+        return sessionId;
+      } catch (err) {
+        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
+    async prompt(sessionId, text, options) {
+      const thread = sessions.get(sessionId);
+      if (!thread) {
+        throw new Error(`Codex session ${sessionId} not found`);
+      }
+      log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      const reporter = createProgressReporter(options?.onProgress);
+      try {
+        reporter.emit("Waiting for Codex response");
+        if (options?.onProgress) {
+          const { events } = await withTimeout(
+            thread.runStreamed(text),
+            SESSION_READY_TIMEOUT_MS4,
+            "codex thread runStreamed"
+          );
+          let lastAgentMessage = null;
+          for await (const event of events) {
+            if (event.type === "item.updated" || event.type === "item.completed") {
+              if (event.item.type === "agent_message") {
+                lastAgentMessage = event.item.text;
+                reporter.emit(event.item.text);
+              }
+            }
+            if (event.type === "turn.failed") {
+              throw new Error(`Codex turn failed: ${event.error.message}`);
+            }
+            if (event.type === "item.completed" && event.item.type === "error") {
+              throw new Error(`Codex error: ${event.item.message}`);
+            }
+          }
+          reporter.emit("Finalizing response");
+          log.debug(`Prompt response received (${lastAgentMessage?.length ?? 0} chars, streaming)`);
+          return lastAgentMessage;
+        }
+        const turn = await withTimeout(
+          thread.run(text),
+          SESSION_READY_TIMEOUT_MS4,
+          "codex thread run"
         );
-        if (!receivedAssistant) {
-          throw new Error("Claude stream ended before receiving an assistant message");
+        for (const item of turn.items) {
+          if (item.type === "error") {
+            throw new Error(`Codex error: ${item.message}`);
+          }
         }
-        const result = parts.join("") || null;
+        reporter.emit("Finalizing response");
+        const result = turn.finalResponse || null;
         log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
         return result;
       } catch (err) {
@@ -1511,444 +1689,988 @@ async function boot3(opts) {
       }
     },
     async send(sessionId, text) {
-      const session = sessions.get(sessionId);
-      if (!session) {
-        throw new Error(`Claude session ${sessionId} not found`);
+      const thread = sessions.get(sessionId);
+      if (!thread) {
+        throw new Error(`Codex session ${sessionId} not found`);
       }
       log.debug(`Sending follow-up to session ${sessionId} (${text.length} chars)...`);
-      try {
-        await session.send(text);
-      } catch (err) {
-        log.debug(`Follow-up send failed: ${log.formatErrorChain(err)}`);
-        throw err;
-      }
+      thread.run(text).catch((err) => {
+        log.debug(`Follow-up turn failed: ${log.formatErrorChain(err)}`);
+      });
     },
     async cleanup() {
-      log.debug("Cleaning up Claude provider...");
-      for (const session of sessions.values()) {
-        try {
-          await Promise.resolve(session.close());
-        } catch (err) {
-          log.debug(`Failed to close Claude session: ${log.formatErrorChain(err)}`);
-        }
+      log.debug("Cleaning up Codex provider...");
+      sessions.clear();
+    }
+  };
+}
+
+// src/providers/registry.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec = promisify2(execFile2);
+var AUTH_PROBE_TIMEOUT_MS = 1e4;
+async function checkCopilotAuth() {
+  if (process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN) {
+    return { status: "authenticated" };
+  }
+  try {
+    await exec("copilot", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+    return { status: "authenticated" };
+  } catch {
+    try {
+      await exec("gh", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+      return { status: "authenticated" };
+    } catch {
+      return {
+        status: "not-configured",
+        hint: "Run 'copilot login' or set GITHUB_TOKEN"
+      };
+    }
+  }
+}
+async function checkClaudeAuth() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { status: "authenticated" };
+  }
+  try {
+    await exec("claude", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+    return { status: "authenticated" };
+  } catch {
+    return {
+      status: "not-configured",
+      hint: "Run 'claude auth login' or set ANTHROPIC_API_KEY"
+    };
+  }
+}
+async function checkCodexAuth() {
+  if (process.env.OPENAI_API_KEY) {
+    return { status: "authenticated" };
+  }
+  try {
+    await exec("codex", ["login", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+    return { status: "authenticated" };
+  } catch {
+    return {
+      status: "not-configured",
+      hint: "Run 'codex login --device-auth' or set OPENAI_API_KEY"
+    };
+  }
+}
+async function checkOpencodeAuth() {
+  try {
+    await exec("opencode", ["--version"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+  } catch {
+    return {
+      status: "not-configured",
+      hint: "Install OpenCode (https://opencode.ai)"
+    };
+  }
+  try {
+    await exec("opencode", ["auth", "list"], { timeout: AUTH_PROBE_TIMEOUT_MS });
+    return { status: "authenticated" };
+  } catch {
+    return {
+      status: "not-configured",
+      hint: "OpenCode is installed but no credentials configured. Run 'opencode auth login' or set provider API keys"
+    };
+  }
+}
+var PROVIDER_REGISTRY = {
+  copilot: {
+    name: "copilot",
+    displayName: "GitHub Copilot",
+    tier: "free",
+    defaultStrongModel: "claude-sonnet-4-5",
+    defaultFastModel: "claude-haiku-4",
+    costScore: { strong: 1, fast: 1 },
+    checkAuth: checkCopilotAuth
+  },
+  claude: {
+    name: "claude",
+    displayName: "Claude Code",
+    tier: "api-key",
+    defaultStrongModel: "claude-sonnet-4",
+    defaultFastModel: "claude-haiku-3-5",
+    costScore: { strong: 5, fast: 2 },
+    checkAuth: checkClaudeAuth
+  },
+  codex: {
+    name: "codex",
+    displayName: "OpenAI Codex",
+    tier: "api-key",
+    defaultStrongModel: "o4-mini",
+    defaultFastModel: "codex-mini-latest",
+    costScore: { strong: 4, fast: 1 },
+    checkAuth: checkCodexAuth
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    tier: "api-key",
+    defaultStrongModel: "anthropic/claude-sonnet-4",
+    defaultFastModel: "anthropic/claude-haiku-3-5",
+    costScore: { strong: 5, fast: 3 },
+    checkAuth: checkOpencodeAuth
+  }
+};
+
+// src/providers/detect.ts
+async function checkProviderAuthenticated(name) {
+  const meta = PROVIDER_REGISTRY[name];
+  const status = await meta.checkAuth();
+  return status.status === "authenticated";
+}
+async function getAuthenticatedProviders(providers) {
+  const results = await Promise.all(
+    providers.map(async (name) => ({
+      name,
+      authenticated: await checkProviderAuthenticated(name)
+    }))
+  );
+  return results.filter((r) => r.authenticated).map((r) => r.name);
+}
+
+// src/providers/index.ts
+var PROVIDERS = {
+  opencode: boot,
+  copilot: boot2,
+  claude: boot3,
+  codex: boot4
+};
+async function bootProvider(name, opts) {
+  const bootFn = PROVIDERS[name];
+  if (!bootFn) {
+    throw new Error(
+      `Unknown provider "${name}". Available: ${PROVIDER_NAMES.join(", ")}`
+    );
+  }
+  return bootFn(opts);
+}
+
+// src/datasources/index.ts
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+
+// src/datasources/interface.ts
+var DATASOURCE_NAMES = ["github", "azdevops", "md"];
+
+// src/datasources/github.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+
+// src/helpers/branch-validation.ts
+var InvalidBranchNameError = class extends Error {
+  constructor(branch, reason) {
+    const detail = reason ? ` (${reason})` : "";
+    super(`Invalid branch name: "${branch}"${detail}`);
+    this.name = "InvalidBranchNameError";
+  }
+};
+var VALID_BRANCH_NAME_RE = /^[a-zA-Z0-9._\-/]+$/;
+function isValidBranchName(name) {
+  if (name.length === 0 || name.length > 255) return false;
+  if (!VALID_BRANCH_NAME_RE.test(name)) return false;
+  if (name.startsWith("/") || name.endsWith("/")) return false;
+  if (name.includes("..")) return false;
+  if (name.endsWith(".lock")) return false;
+  if (name.includes("@{")) return false;
+  if (name.includes("//")) return false;
+  return true;
+}
+
+// src/helpers/auth.ts
+import { readFile as readFile3, writeFile, mkdir, chmod } from "fs/promises";
+import { join as join4, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
+import { Octokit } from "@octokit/rest";
+import { createOAuthDeviceAuth } from "@octokit/auth-oauth-device";
+import { DeviceCodeCredential } from "@azure/identity";
+import * as azdev from "azure-devops-node-api";
+import open from "open";
+
+// src/constants.ts
+var GITHUB_CLIENT_ID = "Ov23liUMP1Oyg811IF58";
+var AZURE_CLIENT_ID = "150a3098-01dd-4126-8b10-5e7f77492e5c";
+var AZURE_TENANT_ID = "organizations";
+var AZURE_DEVOPS_SCOPE = "499b84ac-1321-427f-aa17-267ca6975798/.default";
+
+// src/helpers/auth.ts
+var AUTH_PATH = join4(homedir3(), ".dispatch", "auth.json");
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+var authPromptHandler = null;
+function setAuthPromptHandler(handler) {
+  authPromptHandler = handler;
+}
+async function loadAuthCache() {
+  try {
+    const raw = await readFile3(AUTH_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveAuthCache(cache) {
+  await mkdir(dirname2(AUTH_PATH), { recursive: true });
+  await writeFile(AUTH_PATH, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  if (process.platform !== "win32") {
+    try {
+      await chmod(AUTH_PATH, 384);
+    } catch {
+    }
+  }
+}
+async function getGithubOctokit() {
+  const cache = await loadAuthCache();
+  if (cache.github?.token) {
+    return new Octokit({ auth: cache.github.token });
+  }
+  const auth = createOAuthDeviceAuth({
+    clientId: GITHUB_CLIENT_ID,
+    clientType: "oauth-app",
+    scopes: ["repo"],
+    onVerification(verification) {
+      const msg = `Enter code ${verification.user_code} at ${verification.verification_uri}`;
+      if (authPromptHandler) {
+        authPromptHandler(msg);
+      } else {
+        log.info(msg);
       }
-      sessions.clear();
+      open(verification.verification_uri).catch(() => {
+      });
     }
-  };
-}
-
-// src/providers/codex.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-var SESSION_READY_TIMEOUT_MS4 = 6e5;
-async function loadCodexSdk() {
-  return import("@openai/codex-sdk");
+  });
+  const authentication = await auth({ type: "oauth" });
+  cache.github = { token: authentication.token };
+  await saveAuthCache(cache);
+  return new Octokit({ auth: authentication.token });
 }
-async function boot4(opts) {
-  const model = opts?.model ?? "o4-mini";
-  log.debug(`Booting Codex provider with model ${model}`);
-  const { Codex, Thread } = await loadCodexSdk();
-  const codex = new Codex();
-  const sessions = /* @__PURE__ */ new Map();
-  return {
-    name: "codex",
-    model,
-    async createSession() {
-      log.debug("Creating Codex session...");
-      try {
-        const sessionId = randomUUID2();
-        const thread = codex.startThread({
-          model,
-          approvalPolicy: "never",
-          sandboxMode: "workspace-write",
-          ...opts?.cwd ? { workingDirectory: opts.cwd } : {}
-        });
-        sessions.set(sessionId, thread);
-        log.debug(`Session created: ${sessionId}`);
-        return sessionId;
-      } catch (err) {
-        log.debug(`Session creation failed: ${log.formatErrorChain(err)}`);
-        throw err;
-      }
-    },
-    async prompt(sessionId, text, options) {
-      const thread = sessions.get(sessionId);
-      if (!thread) {
-        throw new Error(`Codex session ${sessionId} not found`);
-      }
-      log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
-      const reporter = createProgressReporter(options?.onProgress);
-      try {
-        reporter.emit("Waiting for Codex response");
-        if (options?.onProgress) {
-          const { events } = await withTimeout(
-            thread.runStreamed(text),
-            SESSION_READY_TIMEOUT_MS4,
-            "codex thread runStreamed"
-          );
-          let lastAgentMessage = null;
-          for await (const event of events) {
-            if (event.type === "item.updated" || event.type === "item.completed") {
-              if (event.item.type === "agent_message") {
-                lastAgentMessage = event.item.text;
-                reporter.emit(event.item.text);
-              }
-            }
-            if (event.type === "turn.failed") {
-              throw new Error(`Codex turn failed: ${event.error.message}`);
-            }
-            if (event.type === "item.completed" && event.item.type === "error") {
-              throw new Error(`Codex error: ${event.item.message}`);
-            }
-          }
-          reporter.emit("Finalizing response");
-          log.debug(`Prompt response received (${lastAgentMessage?.length ?? 0} chars, streaming)`);
-          return lastAgentMessage;
-        }
-        const turn = await withTimeout(
-          thread.run(text),
-          SESSION_READY_TIMEOUT_MS4,
-          "codex thread run"
-        );
-        for (const item of turn.items) {
-          if (item.type === "error") {
-            throw new Error(`Codex error: ${item.message}`);
-          }
-        }
-        reporter.emit("Finalizing response");
-        const result = turn.finalResponse || null;
-        log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
-        return result;
-      } catch (err) {
-        log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
-        throw err;
-      }
-    },
-    async send(sessionId, text) {
-      const thread = sessions.get(sessionId);
-      if (!thread) {
-        throw new Error(`Codex session ${sessionId} not found`);
+async function getAzureConnection(orgUrl) {
+  const cache = await loadAuthCache();
+  if (cache.azure?.token && cache.azure.expiresAt) {
+    const expiresAt = new Date(cache.azure.expiresAt).getTime();
+    if (expiresAt - Date.now() > EXPIRY_BUFFER_MS) {
+      return new azdev.WebApi(
+        orgUrl,
+        azdev.getBearerHandler(cache.azure.token)
+      );
+    }
+  }
+  const credential = new DeviceCodeCredential({
+    tenantId: AZURE_TENANT_ID,
+    clientId: AZURE_CLIENT_ID,
+    userPromptCallback(deviceCodeInfo) {
+      const note = "Azure DevOps requires a work or school account (personal Microsoft accounts are not supported).";
+      const msg = `${note}
+${deviceCodeInfo.message}`;
+      if (authPromptHandler) {
+        authPromptHandler(msg);
+      } else {
+        log.info(msg);
       }
-      log.debug(`Sending follow-up to session ${sessionId} (${text.length} chars)...`);
-      thread.run(text).catch((err) => {
-        log.debug(`Follow-up turn failed: ${log.formatErrorChain(err)}`);
+      open(deviceCodeInfo.verificationUri).catch(() => {
       });
-    },
-    async cleanup() {
-      log.debug("Cleaning up Codex provider...");
-      sessions.clear();
     }
+  });
+  const accessToken = await credential.getToken(AZURE_DEVOPS_SCOPE);
+  if (!accessToken) {
+    throw new Error(
+      "Azure device-code authentication did not return a token. Please try again."
+    );
+  }
+  cache.azure = {
+    token: accessToken.token,
+    expiresAt: new Date(accessToken.expiresOnTimestamp).toISOString()
   };
+  await saveAuthCache(cache);
+  return new azdev.WebApi(
+    orgUrl,
+    azdev.getBearerHandler(accessToken.token)
+  );
 }
-
-// src/providers/registry.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var exec3 = promisify4(execFile4);
-var AUTH_PROBE_TIMEOUT_MS = 1e4;
-async function checkCopilotAuth() {
-  if (process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN) {
-    return { status: "authenticated" };
+async function ensureAuthReady(source, cwd, org) {
+  if (source === "github") {
+    const remoteUrl = await getGitRemoteUrl(cwd);
+    if (remoteUrl && parseGitHubRemoteUrl(remoteUrl)) {
+      await getGithubOctokit();
+    } else if (!remoteUrl) {
+      log.warn("No git remote found \u2014 skipping GitHub pre-authentication");
+    } else {
+      log.warn("Remote URL is not a GitHub repository \u2014 skipping GitHub pre-authentication");
+    }
+  } else if (source === "azdevops") {
+    let orgUrl = org;
+    if (!orgUrl) {
+      const remoteUrl = await getGitRemoteUrl(cwd);
+      if (remoteUrl) {
+        const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
+        if (parsed) orgUrl = parsed.orgUrl;
+        else log.warn("Remote URL is not an Azure DevOps repository \u2014 skipping Azure pre-authentication");
+      } else {
+        log.warn("No git remote found \u2014 skipping Azure DevOps pre-authentication");
+      }
+    }
+    if (orgUrl) await getAzureConnection(orgUrl);
   }
-  try {
-    await exec3("copilot", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-    return { status: "authenticated" };
-  } catch {
-    try {
-      await exec3("gh", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-      return { status: "authenticated" };
-    } catch {
-      return {
-        status: "not-configured",
-        hint: "Run 'copilot login' or set GITHUB_TOKEN"
-      };
+}
+
+// node_modules/@octokit/request-error/dist-src/index.js
+var RequestError = class extends Error {
+  name;
+  /**
+   * http status code
+   */
+  status;
+  /**
+   * Request options that lead to the error.
+   */
+  request;
+  /**
+   * Response object if a response was received
+   */
+  response;
+  constructor(message, statusCode, options) {
+    super(message);
+    this.name = "HttpError";
+    this.status = Number.parseInt(statusCode);
+    if (Number.isNaN(this.status)) {
+      this.status = 0;
+    }
+    if ("response" in options) {
+      this.response = options.response;
+    }
+    const requestCopy = Object.assign({}, options.request);
+    if (options.request.headers.authorization) {
+      requestCopy.headers = Object.assign({}, options.request.headers, {
+        authorization: options.request.headers.authorization.replace(
+          /(?<! ) .*$/,
+          " [REDACTED]"
+        )
+      });
     }
+    requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
+    this.request = requestCopy;
   }
+};
+
+// src/datasources/github.ts
+var exec2 = promisify3(execFile3);
+async function git(args, cwd) {
+  const { stdout } = await exec2("git", args, { cwd, shell: process.platform === "win32" });
+  return stdout;
 }
-async function checkClaudeAuth() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return { status: "authenticated" };
+function redactUrl(url) {
+  return url.replace(/\/\/[^@/]+@/, "//***@");
+}
+var ownerRepoCache = /* @__PURE__ */ new Map();
+async function getOwnerRepo(cwd) {
+  const cached = ownerRepoCache.get(cwd);
+  if (cached) return cached;
+  const remoteUrl = await getGitRemoteUrl(cwd);
+  if (!remoteUrl) {
+    throw new Error("Could not determine git remote URL. Is this a git repository with an origin remote?");
   }
-  try {
-    await exec3("claude", ["auth", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-    return { status: "authenticated" };
-  } catch {
-    return {
-      status: "not-configured",
-      hint: "Run 'claude auth login' or set ANTHROPIC_API_KEY"
-    };
+  const parsed = parseGitHubRemoteUrl(remoteUrl);
+  if (!parsed) {
+    throw new Error(`Could not parse GitHub owner/repo from remote URL: ${redactUrl(remoteUrl)}`);
   }
+  ownerRepoCache.set(cwd, parsed);
+  return parsed;
 }
-async function checkCodexAuth() {
-  if (process.env.OPENAI_API_KEY) {
-    return { status: "authenticated" };
-  }
+function buildBranchName(issueNumber, _title, username = "unknown") {
+  return `${username}/dispatch/issue-${issueNumber}`;
+}
+async function getDefaultBranch(cwd) {
+  const PREFIX = "refs/remotes/origin/";
   try {
-    await exec3("codex", ["login", "status"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-    return { status: "authenticated" };
-  } catch {
-    return {
-      status: "not-configured",
-      hint: "Run 'codex login --device-auth' or set OPENAI_API_KEY"
-    };
+    const ref = await git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+    const trimmed = ref.trim();
+    const branch = trimmed.startsWith(PREFIX) ? trimmed.slice(PREFIX.length) : trimmed;
+    if (!isValidBranchName(branch)) {
+      throw new InvalidBranchNameError(branch, "from symbolic-ref output");
+    }
+    return branch;
+  } catch (err) {
+    if (err instanceof InvalidBranchNameError) {
+      throw err;
+    }
+    try {
+      await git(["rev-parse", "--verify", "main"], cwd);
+      return "main";
+    } catch {
+      return "master";
+    }
   }
 }
-async function checkOpencodeAuth() {
-  try {
-    await exec3("opencode", ["--version"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-  } catch {
+var datasource = {
+  name: "github",
+  supportsGit() {
+    return true;
+  },
+  async list(opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    const issues = await octokit.paginate(
+      octokit.rest.issues.listForRepo,
+      {
+        owner,
+        repo,
+        state: "open"
+      }
+    );
+    return issues.filter((issue) => !issue.pull_request).map((issue) => ({
+      number: String(issue.number),
+      title: issue.title ?? "",
+      body: issue.body ?? "",
+      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
+      state: issue.state ?? "open",
+      url: issue.html_url ?? "",
+      comments: [],
+      acceptanceCriteria: ""
+    }));
+  },
+  async fetch(issueId, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    const { data: issue } = await octokit.rest.issues.get({
+      owner,
+      repo,
+      issue_number: Number(issueId)
+    });
+    const issueComments = await octokit.paginate(
+      octokit.rest.issues.listComments,
+      {
+        owner,
+        repo,
+        issue_number: Number(issueId)
+      }
+    );
+    const comments = issueComments.map(
+      (c) => `**${c.user?.login ?? "unknown"}:** ${c.body ?? ""}`
+    );
     return {
-      status: "not-configured",
-      hint: "Install OpenCode (https://opencode.ai)"
+      number: String(issue.number),
+      title: issue.title ?? "",
+      body: issue.body ?? "",
+      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
+      state: issue.state ?? "open",
+      url: issue.html_url ?? "",
+      comments,
+      acceptanceCriteria: ""
     };
-  }
-  try {
-    await exec3("opencode", ["auth", "list"], { timeout: AUTH_PROBE_TIMEOUT_MS });
-    return { status: "authenticated" };
-  } catch {
+  },
+  async update(issueId, title, body, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    await octokit.rest.issues.update({
+      owner,
+      repo,
+      issue_number: Number(issueId),
+      title,
+      body
+    });
+  },
+  async close(issueId, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    await octokit.rest.issues.update({
+      owner,
+      repo,
+      issue_number: Number(issueId),
+      state: "closed"
+    });
+  },
+  async create(title, body, opts = {}) {
+    const cwd = opts.cwd || process.cwd();
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    const { data: issue } = await octokit.rest.issues.create({
+      owner,
+      repo,
+      title,
+      body
+    });
     return {
-      status: "not-configured",
-      hint: "OpenCode is installed but no credentials configured. Run 'opencode auth login' or set provider API keys"
+      number: String(issue.number),
+      title: issue.title ?? "",
+      body: issue.body ?? "",
+      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean),
+      state: issue.state ?? "open",
+      url: issue.html_url ?? "",
+      comments: [],
+      acceptanceCriteria: ""
     };
-  }
-}
-var PROVIDER_REGISTRY = {
-  copilot: {
-    name: "copilot",
-    displayName: "GitHub Copilot",
-    tier: "free",
-    defaultStrongModel: "claude-sonnet-4-5",
-    defaultFastModel: "claude-haiku-4",
-    costScore: { strong: 1, fast: 1 },
-    checkAuth: checkCopilotAuth
   },
-  claude: {
-    name: "claude",
-    displayName: "Claude Code",
-    tier: "api-key",
-    defaultStrongModel: "claude-sonnet-4",
-    defaultFastModel: "claude-haiku-3-5",
-    costScore: { strong: 5, fast: 2 },
-    checkAuth: checkClaudeAuth
+  async getUsername(opts) {
+    if (opts.username) return opts.username;
+    return deriveShortUsername(opts.cwd, "unknown");
   },
-  codex: {
-    name: "codex",
-    displayName: "OpenAI Codex",
-    tier: "api-key",
-    defaultStrongModel: "o4-mini",
-    defaultFastModel: "codex-mini-latest",
-    costScore: { strong: 4, fast: 1 },
-    checkAuth: checkCodexAuth
+  getDefaultBranch(opts) {
+    return getDefaultBranch(opts.cwd);
   },
-  opencode: {
-    name: "opencode",
-    displayName: "OpenCode",
-    tier: "api-key",
-    defaultStrongModel: "anthropic/claude-sonnet-4",
-    defaultFastModel: "anthropic/claude-haiku-3-5",
-    costScore: { strong: 5, fast: 3 },
-    checkAuth: checkOpencodeAuth
+  async getCurrentBranch(opts) {
+    try {
+      const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd)).trim();
+      if (branch && branch !== "HEAD") return branch;
+    } catch {
+    }
+    return this.getDefaultBranch(opts);
+  },
+  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")) {
+        try {
+          await git(["checkout", branchName], cwd);
+        } catch (checkoutErr) {
+          const checkoutMessage = log.extractMessage(checkoutErr);
+          if (checkoutMessage.includes("already used by worktree")) {
+            await git(["worktree", "prune"], cwd);
+            await git(["checkout", branchName], cwd);
+          } else {
+            throw checkoutErr;
+          }
+        }
+      } 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, baseBranch) {
+    const cwd = opts.cwd;
+    const { owner, repo } = await getOwnerRepo(cwd);
+    const octokit = await getGithubOctokit();
+    const prBody = body || `Closes #${issueNumber}`;
+    try {
+      const target = baseBranch ?? await getDefaultBranch(cwd);
+      const { data: pr } = await octokit.rest.pulls.create({
+        owner,
+        repo,
+        title,
+        body: prBody,
+        head: branchName,
+        base: target
+      });
+      return pr.html_url;
+    } catch (err) {
+      const isValidationError = err instanceof RequestError && err.status === 422;
+      if (isValidationError) {
+        const { data: prs } = await octokit.rest.pulls.list({
+          owner,
+          repo,
+          head: `${owner}:${branchName}`,
+          state: "open"
+        });
+        if (prs.length > 0) {
+          return prs[0].html_url;
+        }
+      }
+      throw err;
+    }
   }
 };
 
-// src/providers/detect.ts
-async function checkProviderAuthenticated(name) {
-  const meta = PROVIDER_REGISTRY[name];
-  const status = await meta.checkAuth();
-  return status.status === "authenticated";
+// src/datasources/azdevops.ts
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { PullRequestStatus } from "azure-devops-node-api/interfaces/GitInterfaces.js";
+var exec3 = promisify4(execFile4);
+var doneStateCache = /* @__PURE__ */ new Map();
+async function git2(args, cwd) {
+  const { stdout } = await exec3("git", args, { cwd, shell: process.platform === "win32" });
+  return stdout;
 }
-async function getAuthenticatedProviders(providers) {
-  const results = await Promise.all(
-    providers.map(async (name) => ({
-      name,
-      authenticated: await checkProviderAuthenticated(name)
-    }))
-  );
-  return results.filter((r) => r.authenticated).map((r) => r.name);
+function redactUrl2(url) {
+  return url.replace(/\/\/[^@/]+@/, "//***@");
 }
-
-// src/providers/index.ts
-var PROVIDERS = {
-  opencode: boot,
-  copilot: boot2,
-  claude: boot3,
-  codex: boot4
-};
-async function bootProvider(name, opts) {
-  const bootFn = PROVIDERS[name];
-  if (!bootFn) {
-    throw new Error(
-      `Unknown provider "${name}". Available: ${PROVIDER_NAMES.join(", ")}`
-    );
+async function getOrgAndProject(opts = {}) {
+  let orgUrl = opts.org;
+  let project = opts.project;
+  if (!orgUrl || !project) {
+    const cwd = opts.cwd || process.cwd();
+    const remoteUrl = await getGitRemoteUrl(cwd);
+    if (!remoteUrl) {
+      throw new Error(
+        "Could not determine git remote URL. Is this a git repository with an origin remote?"
+      );
+    }
+    const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
+    if (!parsed) {
+      throw new Error(
+        `Could not parse Azure DevOps org/project from remote URL: ${redactUrl2(remoteUrl)}`
+      );
+    }
+    orgUrl = orgUrl || parsed.orgUrl;
+    project = project || parsed.project;
   }
-  return bootFn(opts);
+  const connection = await getAzureConnection(orgUrl);
+  return { orgUrl, project, connection };
 }
-
-// src/config-prompts.tsx
-import chalk3 from "chalk";
-
-// src/helpers/ink-prompts.tsx
-import { useState, useRef, useEffect } from "react";
-import { render, Box, Text, useInput, useApp } from "ink";
-import SelectInput from "ink-select-input";
-import TextInput from "ink-text-input";
-
-// src/helpers/format.ts
-import chalk2 from "chalk";
-var PALETTE = {
-  brand: "#58A6FF",
-  subtitle: "#484F58",
-  chrome: "#30363D",
-  text: "#C9D1D9",
-  muted: "#484F58",
-  success: "#56D364",
-  error: "#F85149",
-  warn: "#D29922",
-  accent: "#79C0FF",
-  planning: "#D2A8FF"
-};
-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 mapWorkItemToIssueDetails(item, id, comments, defaults) {
+  const fields = item.fields ?? {};
+  return {
+    number: String(item.id ?? id),
+    title: fields["System.Title"] ?? defaults?.title ?? "",
+    body: fields["System.Description"] ?? defaults?.body ?? "",
+    labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
+    state: fields["System.State"] ?? defaults?.state ?? "",
+    url: item._links?.html?.href ?? item.url ?? "",
+    comments,
+    acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? "",
+    iterationPath: fields["System.IterationPath"] || void 0,
+    areaPath: fields["System.AreaPath"] || void 0,
+    assignee: fields["System.AssignedTo"]?.displayName || void 0,
+    priority: fields["Microsoft.VSTS.Common.Priority"] ?? void 0,
+    storyPoints: fields["Microsoft.VSTS.Scheduling.StoryPoints"] ?? fields["Microsoft.VSTS.Scheduling.Effort"] ?? fields["Microsoft.VSTS.Scheduling.Size"] ?? void 0,
+    workItemType: fields["System.WorkItemType"] || defaults?.workItemType || void 0
+  };
 }
-function renderHeaderLines(info) {
-  const lines = [];
-  lines.push(chalk2.bold.white("  \u26A1 dispatch") + chalk2.dim(` \u2014 AI task orchestration`));
-  if (info.provider) {
-    lines.push(chalk2.dim(`  provider: ${info.provider}`));
-  }
-  if (info.model) {
-    lines.push(chalk2.dim(`  model: ${info.model}`));
-  }
-  if (info.source) {
-    lines.push(chalk2.dim(`  source: ${info.source}`));
+async function detectWorkItemType(opts = {}) {
+  try {
+    const { project, connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const types = await witApi.getWorkItemTypes(project);
+    if (!Array.isArray(types) || types.length === 0) return null;
+    const names = types.map((t) => t.name).filter((n) => !!n);
+    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;
   }
-  return lines;
 }
-
-// src/helpers/ink-prompts.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-function input(opts) {
-  return new Promise((resolve3) => {
-    function InputPrompt() {
-      const { exit } = useApp();
-      const [value, setValue] = useState(opts.default ?? "");
-      return /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Text, { color: PALETTE.accent, bold: true, children: "? " }),
-        /* @__PURE__ */ jsxs(Text, { children: [
-          opts.message,
-          " "
-        ] }),
-        /* @__PURE__ */ jsx(
-          TextInput,
-          {
-            value,
-            onChange: setValue,
-            onSubmit: (val) => {
-              resolve3(val);
-              exit();
-            }
-          }
-        )
-      ] });
+async function detectDoneState(workItemType, opts = {}) {
+  const { orgUrl, project, connection } = await getOrgAndProject(opts);
+  const cacheKey = `${orgUrl}|${project}|${workItemType}`;
+  const cached = doneStateCache.get(cacheKey);
+  if (cached) return cached;
+  try {
+    const witApi = await connection.getWorkItemTrackingApi();
+    const states = await witApi.getWorkItemTypeStates(project, workItemType);
+    if (Array.isArray(states)) {
+      const completed = states.find((s) => s.category === "Completed");
+      if (completed?.name) {
+        doneStateCache.set(cacheKey, completed.name);
+        return completed.name;
+      }
+      const names = states.map((s) => s.name).filter((n) => !!n);
+      const fallbacks = ["Done", "Closed", "Resolved", "Completed"];
+      for (const f of fallbacks) {
+        if (names.includes(f)) {
+          doneStateCache.set(cacheKey, f);
+          return f;
+        }
+      }
     }
-    const instance = render(/* @__PURE__ */ jsx(InputPrompt, {}));
-    instance.waitUntilExit().catch(() => {
-    });
-  });
-}
-
-// src/providers/auth-setup.tsx
-import { spawn } from "child_process";
-
-// src/config.ts
-var CONFIG_KEYS = ["enabledProviders", "providerModels", "source", "planTimeout", "specTimeout", "specWarnTimeout", "specKillTimeout", "concurrency", "org", "project", "workItemType", "iteration", "area", "username"];
-function getConfigPath(configDir) {
-  const dir = configDir ?? join5(process.cwd(), ".dispatch");
-  return join5(dir, "config.json");
+  } catch {
+  }
+  return "Closed";
 }
-async function loadConfig(configDir) {
-  const configPath = getConfigPath(configDir);
+async function fetchComments(workItemId, project, connection) {
   try {
-    const raw = await readFile4(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return migrateConfig(parsed);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const commentList = await witApi.getComments(project, workItemId);
+    if (commentList.comments && Array.isArray(commentList.comments)) {
+      return commentList.comments.map((c) => {
+        const author = c.createdBy?.displayName ?? "unknown";
+        return `**${author}:** ${c.text ?? ""}`;
+      });
+    }
+    return [];
   } catch {
-    return {};
+    return [];
   }
 }
-function migrateConfig(raw) {
-  const config = {};
-  if (!raw.enabledProviders && raw.provider) {
-    const providers = /* @__PURE__ */ new Set();
-    const legacyProvider = raw.provider;
-    if (PROVIDER_NAMES.includes(legacyProvider)) {
-      providers.add(legacyProvider);
+var datasource2 = {
+  name: "azdevops",
+  supportsGit() {
+    return true;
+  },
+  async list(opts = {}) {
+    const { project, connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const conditions = [
+      "[System.State] <> 'Closed'",
+      "[System.State] <> 'Done'",
+      "[System.State] <> 'Removed'"
+    ];
+    if (opts.iteration) {
+      const iterValue = String(opts.iteration).trim();
+      if (iterValue === "@CurrentIteration") {
+        conditions.push(`[System.IterationPath] UNDER @CurrentIteration`);
+      } else {
+        const escaped = iterValue.replace(/'/g, "''");
+        if (escaped) conditions.push(`[System.IterationPath] UNDER '${escaped}'`);
+      }
     }
-    if (raw.fastProvider) {
-      const fastProvider = raw.fastProvider;
-      if (PROVIDER_NAMES.includes(fastProvider)) {
-        providers.add(fastProvider);
+    if (opts.area) {
+      const area = String(opts.area).trim().replace(/'/g, "''");
+      if (area) {
+        conditions.push(`[System.AreaPath] UNDER '${area}'`);
       }
     }
-    if (raw.agents && typeof raw.agents === "object") {
-      for (const agentCfg of Object.values(raw.agents)) {
-        if (agentCfg?.provider && PROVIDER_NAMES.includes(agentCfg.provider)) {
-          providers.add(agentCfg.provider);
-        }
+    const wiql = `SELECT [System.Id] FROM workitems WHERE ${conditions.join(" AND ")} ORDER BY [System.CreatedDate] DESC`;
+    const queryResult = await witApi.queryByWiql({ query: wiql }, { project });
+    const workItemRefs = queryResult.workItems ?? [];
+    if (workItemRefs.length === 0) return [];
+    const ids = workItemRefs.map((ref) => ref.id).filter((id) => id != null);
+    if (ids.length === 0) return [];
+    try {
+      const items = await witApi.getWorkItems(ids);
+      const itemsArray = Array.isArray(items) ? items : [items];
+      const commentsArray = [];
+      const CONCURRENCY = 5;
+      for (let i = 0; i < itemsArray.length; i += CONCURRENCY) {
+        const batch = itemsArray.slice(i, i + CONCURRENCY);
+        const batchResults = await Promise.all(
+          // item.id is guaranteed non-null here: the ids array was built by filtering
+          // out null ids from workItemRefs, and itemsArray came from getWorkItems(ids).
+          batch.map((item) => fetchComments(item.id, project, connection))
+        );
+        commentsArray.push(...batchResults);
       }
+      return itemsArray.map(
+        (item, i) => mapWorkItemToIssueDetails(item, String(item.id), commentsArray[i])
+      );
+    } catch (err) {
+      log.debug(`Batch getWorkItems failed, falling back to individual fetches: ${log.extractMessage(err)}`);
+      const results = await Promise.all(
+        ids.map((id) => datasource2.fetch(String(id), opts))
+      );
+      return results;
     }
-    if (providers.size > 0) {
-      config.enabledProviders = [...providers];
+  },
+  async fetch(issueId, opts = {}) {
+    const { project, connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const item = await witApi.getWorkItem(Number(issueId));
+    const comments = await fetchComments(Number(issueId), project, connection);
+    return mapWorkItemToIssueDetails(item, issueId, comments);
+  },
+  async update(issueId, title, body, opts = {}) {
+    const { connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const document = [
+      { op: "add", path: "/fields/System.Title", value: title },
+      { op: "add", path: "/fields/System.Description", value: body }
+    ];
+    await witApi.updateWorkItem(null, document, Number(issueId));
+  },
+  async close(issueId, opts = {}) {
+    const { connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    let workItemType = opts.workItemType;
+    if (!workItemType) {
+      const item = await witApi.getWorkItem(Number(issueId));
+      workItemType = item.fields?.["System.WorkItemType"] ?? void 0;
     }
-  } else if (Array.isArray(raw.enabledProviders)) {
-    config.enabledProviders = raw.enabledProviders.filter(
-      (p) => PROVIDER_NAMES.includes(p)
+    const state = workItemType ? await detectDoneState(workItemType, opts) : "Closed";
+    const document = [
+      { op: "add", path: "/fields/System.State", value: state }
+    ];
+    await witApi.updateWorkItem(null, document, Number(issueId));
+  },
+  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 { project, connection } = await getOrgAndProject(opts);
+    const witApi = await connection.getWorkItemTrackingApi();
+    const document = [
+      { op: "add", path: "/fields/System.Title", value: title },
+      { op: "add", path: "/fields/System.Description", value: body }
+    ];
+    const item = await witApi.createWorkItem(
+      // null as any: SDK customHeaders param — passing null is the documented way to omit it.
+      null,
+      document,
+      project,
+      workItemType
     );
-  }
-  if (raw.providerModels !== void 0 && typeof raw.providerModels === "object" && raw.providerModels !== null) {
-    const validated = {};
-    for (const [providerName, modelCfg] of Object.entries(raw.providerModels)) {
-      if (!PROVIDER_NAMES.includes(providerName)) continue;
-      if (typeof modelCfg !== "object" || modelCfg === null) continue;
-      const cfg = modelCfg;
-      const entry = {};
-      if (typeof cfg.strong === "string") entry.strong = cfg.strong;
-      if (typeof cfg.fast === "string") entry.fast = cfg.fast;
-      if (entry.strong !== void 0 || entry.fast !== void 0) {
-        validated[providerName] = entry;
+    return mapWorkItemToIssueDetails(item, String(item.id), [], {
+      title,
+      body,
+      state: "New",
+      workItemType
+    });
+  },
+  async getDefaultBranch(opts) {
+    const PREFIX = "refs/remotes/origin/";
+    try {
+      const ref = await git2(["symbolic-ref", "refs/remotes/origin/HEAD"], opts.cwd);
+      const trimmed = ref.trim();
+      const branch = trimmed.startsWith(PREFIX) ? trimmed.slice(PREFIX.length) : trimmed;
+      if (!isValidBranchName(branch)) {
+        throw new InvalidBranchNameError(branch, "from symbolic-ref output");
+      }
+      return branch;
+    } catch (err) {
+      if (err instanceof InvalidBranchNameError) {
+        throw err;
+      }
+      try {
+        await git2(["rev-parse", "--verify", "main"], opts.cwd);
+        return "main";
+      } catch {
+        return "master";
       }
     }
-    if (Object.keys(validated).length > 0) {
-      config.providerModels = validated;
+  },
+  async getCurrentBranch(opts) {
+    try {
+      const branch = (await git2(["rev-parse", "--abbrev-ref", "HEAD"], opts.cwd)).trim();
+      if (branch && branch !== "HEAD") return branch;
+    } catch {
     }
-  }
-  if (typeof raw.source === "string" && DATASOURCE_NAMES.includes(raw.source)) {
-    config.source = raw.source;
-  }
-  if (typeof raw.planTimeout === "number") config.planTimeout = raw.planTimeout;
-  if (typeof raw.specTimeout === "number") config.specTimeout = raw.specTimeout;
-  if (typeof raw.specWarnTimeout === "number") config.specWarnTimeout = raw.specWarnTimeout;
-  if (typeof raw.specKillTimeout === "number") config.specKillTimeout = raw.specKillTimeout;
-  if (typeof raw.concurrency === "number") config.concurrency = raw.concurrency;
-  if (typeof raw.org === "string") config.org = raw.org;
-  if (typeof raw.project === "string") config.project = raw.project;
-  if (typeof raw.workItemType === "string") config.workItemType = raw.workItemType;
-  if (typeof raw.iteration === "string") config.iteration = raw.iteration;
-  if (typeof raw.area === "string") config.area = raw.area;
-  if (typeof raw.username === "string") config.username = raw.username;
-  if (typeof raw.nextIssueId === "number") config.nextIssueId = raw.nextIssueId;
-  return config;
-}
-async function saveConfig(config, configDir) {
-  const configPath = getConfigPath(configDir);
-  await mkdir2(dirname3(configPath), { recursive: true });
-  await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return this.getDefaultBranch(opts);
+  },
+  async getUsername(opts) {
+    if (opts.username) return opts.username;
+    return deriveShortUsername(opts.cwd, "unknown");
+  },
+  buildBranchName(issueNumber, _title, username) {
+    const branch = `${username}/dispatch/issue-${issueNumber}`;
+    if (!isValidBranchName(branch)) {
+      throw new InvalidBranchNameError(branch);
+    }
+    return branch;
+  },
+  async createAndSwitchBranch(branchName, opts) {
+    if (!isValidBranchName(branchName)) {
+      throw new InvalidBranchNameError(branchName);
+    }
+    try {
+      await git2(["checkout", "-b", branchName], opts.cwd);
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        try {
+          await git2(["checkout", branchName], opts.cwd);
+        } catch (checkoutErr) {
+          const checkoutMessage = log.extractMessage(checkoutErr);
+          if (checkoutMessage.includes("already used by worktree")) {
+            await git2(["worktree", "prune"], opts.cwd);
+            await git2(["checkout", branchName], opts.cwd);
+          } else {
+            throw checkoutErr;
+          }
+        }
+      } else {
+        throw err;
+      }
+    }
+  },
+  async switchBranch(branchName, opts) {
+    await git2(["checkout", branchName], opts.cwd);
+  },
+  async pushBranch(branchName, opts) {
+    await git2(["push", "--set-upstream", "origin", branchName], opts.cwd);
+  },
+  async commitAllChanges(message, opts) {
+    await git2(["add", "-A"], opts.cwd);
+    const status = await git2(["diff", "--cached", "--stat"], opts.cwd);
+    if (!status.trim()) {
+      return;
+    }
+    await git2(["commit", "-m", message], opts.cwd);
+  },
+  async createPullRequest(branchName, issueNumber, title, body, opts, baseBranch) {
+    const cwd = opts.cwd;
+    const { orgUrl, project, connection } = await getOrgAndProject(opts);
+    const gitApi = await connection.getGitApi();
+    const remoteUrl = await getGitRemoteUrl(cwd);
+    if (!remoteUrl) {
+      throw new Error("Could not determine git remote URL.");
+    }
+    const repos = await gitApi.getRepositories(project);
+    const normalizeUrl = (u) => u.replace(/\/\/[^@/]+@/, "//").replace(/\.git$/, "").replace(/\/$/, "").toLowerCase();
+    const normalizedRemote = normalizeUrl(remoteUrl);
+    const repo = repos.find(
+      (r) => r.remoteUrl && normalizeUrl(r.remoteUrl) === normalizedRemote || r.sshUrl && normalizeUrl(r.sshUrl) === normalizedRemote || r.webUrl && normalizeUrl(r.webUrl) === normalizedRemote
+    );
+    if (!repo || !repo.id) {
+      throw new Error(`Could not find Azure DevOps repository matching remote URL: ${redactUrl2(remoteUrl)}`);
+    }
+    const target = baseBranch ?? await this.getDefaultBranch(opts);
+    try {
+      const pr = await gitApi.createPullRequest(
+        {
+          sourceRefName: `refs/heads/${branchName}`,
+          targetRefName: `refs/heads/${target}`,
+          title,
+          description: body || `Resolves AB#${issueNumber}`,
+          workItemRefs: [{ id: issueNumber }]
+        },
+        repo.id,
+        project
+      );
+      const webUrl = repo.webUrl ? `${repo.webUrl}/pullrequest/${pr.pullRequestId}` : pr.url ?? "";
+      return webUrl;
+    } catch (err) {
+      const message = log.extractMessage(err);
+      if (message.includes("already exists")) {
+        const prs = await gitApi.getPullRequests(
+          repo.id,
+          {
+            sourceRefName: `refs/heads/${branchName}`,
+            status: PullRequestStatus.Active
+          },
+          project
+        );
+        if (Array.isArray(prs) && prs.length > 0) {
+          const existingPr = prs[0];
+          const webUrl = repo.webUrl ? `${repo.webUrl}/pullrequest/${existingPr.pullRequestId}` : existingPr.url ?? "";
+          return webUrl;
+        }
+        return "";
+      }
+      throw err;
+    }
+  }
+};
+
+// src/datasources/md.ts
+import { execFile as execFile5 } from "child_process";
+import { readFile as readFile4, writeFile as writeFile2, readdir, mkdir as mkdir2, rename } from "fs/promises";
+import { basename, dirname as dirname3, isAbsolute, join as join5, parse as parsePath, resolve } from "path";
+import { promisify as promisify5 } from "util";
+import { glob } from "glob";
+
+// 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/md.ts
@@ -1969,7 +2691,7 @@ async function git3(args, cwd) {
 var DEFAULT_DIR = ".dispatch/specs";
 function resolveDir(opts) {
   const cwd = opts?.cwd ?? process.cwd();
-  return join6(cwd, DEFAULT_DIR);
+  return join5(cwd, DEFAULT_DIR);
 }
 function resolveFilePath(issueId, opts) {
   const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
@@ -1978,7 +2700,7 @@ function resolveFilePath(issueId, opts) {
     const cwd = opts?.cwd ?? process.cwd();
     return resolve(cwd, filename);
   }
-  return join6(resolveDir(opts), filename);
+  return join5(resolveDir(opts), filename);
 }
 async function resolveNumericFilePath(issueId, opts) {
   if (/^\d+$/.test(issueId)) {
@@ -1986,7 +2708,7 @@ async function resolveNumericFilePath(issueId, opts) {
     const entries = await readdir(dir);
     const match = entries.find((f) => f.startsWith(`${issueId}-`) && f.endsWith(".md"));
     if (match) {
-      return join6(dir, match);
+      return join5(dir, match);
     }
   }
   return resolveFilePath(issueId, opts);
@@ -2015,7 +2737,7 @@ function toIssueDetails(filename, content, dir) {
     body: content,
     labels: [],
     state: "open",
-    url: join6(dir, filename),
+    url: join5(dir, filename),
     comments: [],
     acceptanceCriteria: ""
   };
@@ -2032,9 +2754,9 @@ var datasource3 = {
       const mdFiles2 = files.filter((f) => f.endsWith(".md")).sort();
       const results2 = [];
       for (const filePath of mdFiles2) {
-        const content = await readFile5(filePath, "utf-8");
+        const content = await readFile4(filePath, "utf-8");
         const filename = basename(filePath);
-        const dir2 = dirname4(filePath);
+        const dir2 = dirname3(filePath);
         results2.push(toIssueDetails(filename, content, dir2));
       }
       return results2;
@@ -2049,8 +2771,8 @@ var datasource3 = {
     const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
     const results = [];
     for (const filename of mdFiles) {
-      const filePath = join6(dir, filename);
-      const content = await readFile5(filePath, "utf-8");
+      const filePath = join5(dir, filename);
+      const content = await readFile4(filePath, "utf-8");
       results.push(toIssueDetails(filename, content, dir));
     }
     return results;
@@ -2061,38 +2783,38 @@ var datasource3 = {
       const entries = await readdir(dir2);
       const match = entries.find((f) => f.startsWith(`${issueId}-`) && f.endsWith(".md"));
       if (match) {
-        const content2 = await readFile5(join6(dir2, match), "utf-8");
+        const content2 = await readFile4(join5(dir2, match), "utf-8");
         return toIssueDetails(match, content2, dir2);
       }
     }
     const filePath = resolveFilePath(issueId, opts);
-    const content = await readFile5(filePath, "utf-8");
+    const content = await readFile4(filePath, "utf-8");
     const filename = basename(filePath);
-    const dir = dirname4(filePath);
+    const dir = dirname3(filePath);
     return toIssueDetails(filename, content, dir);
   },
   async update(issueId, _title, body, opts) {
     const filePath = await resolveNumericFilePath(issueId, opts);
-    await writeFile3(filePath, body, "utf-8");
+    await writeFile2(filePath, body, "utf-8");
   },
   async close(issueId, opts) {
     const filePath = await resolveNumericFilePath(issueId, opts);
     const filename = basename(filePath);
-    const archiveDir = join6(dirname4(filePath), "archive");
-    await mkdir3(archiveDir, { recursive: true });
-    await rename(filePath, join6(archiveDir, filename));
+    const archiveDir = join5(dirname3(filePath), "archive");
+    await mkdir2(archiveDir, { recursive: true });
+    await rename(filePath, join5(archiveDir, filename));
   },
   async create(title, body, opts) {
     return withCreateLock(async () => {
       const cwd = opts?.cwd ?? process.cwd();
-      const configDir = join6(cwd, ".dispatch");
+      const configDir = join5(cwd, ".dispatch");
       const config = await loadConfig(configDir);
       const id = config.nextIssueId ?? 1;
       const dir = resolveDir(opts);
-      await mkdir3(dir, { recursive: true });
+      await mkdir2(dir, { recursive: true });
       const filename = `${id}-${slugify(title)}.md`;
-      const filePath = join6(dir, filename);
-      await writeFile3(filePath, body, "utf-8");
+      const filePath = join5(dir, filename);
+      await writeFile2(filePath, body, "utf-8");
       config.nextIssueId = id + 1;
       await saveConfig(config, configDir);
       return {
@@ -2322,7 +3044,111 @@ function parseGitHubRemoteUrl(url) {
   return null;
 }
 
+// src/config-prompts.tsx
+init_ink_prompts();
+import chalk3 from "chalk";
+init_format();
+
+// src/providers/auth-setup.tsx
+init_ink_prompts();
+import { spawn } from "child_process";
+
+// src/config.ts
+var CONFIG_BOUNDS = {
+  planTimeout: { min: 1, max: 120 },
+  specTimeout: { min: 1, max: 120 },
+  specWarnTimeout: { min: 1, max: 120 },
+  specKillTimeout: { min: 1, max: 120 },
+  concurrency: { min: 1, max: 64 },
+  maxRuns: { min: 1, max: 32 }
+};
+var CONFIG_KEYS = ["enabledProviders", "providerModels", "source", "planTimeout", "specTimeout", "specWarnTimeout", "specKillTimeout", "concurrency", "maxRuns", "org", "project", "workItemType", "iteration", "area", "username", "orchestratorProvider"];
+function getConfigPath(configDir) {
+  const dir = configDir ?? join6(process.cwd(), ".dispatch");
+  return join6(dir, "config.json");
+}
+async function loadConfig(configDir) {
+  const configPath = getConfigPath(configDir);
+  try {
+    const raw = await readFile5(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return migrateConfig(parsed);
+  } catch {
+    return {};
+  }
+}
+function migrateConfig(raw) {
+  const config = {};
+  if (!raw.enabledProviders && raw.provider) {
+    const providers = /* @__PURE__ */ new Set();
+    const legacyProvider = raw.provider;
+    if (PROVIDER_NAMES.includes(legacyProvider)) {
+      providers.add(legacyProvider);
+    }
+    if (raw.fastProvider) {
+      const fastProvider = raw.fastProvider;
+      if (PROVIDER_NAMES.includes(fastProvider)) {
+        providers.add(fastProvider);
+      }
+    }
+    if (raw.agents && typeof raw.agents === "object") {
+      for (const agentCfg of Object.values(raw.agents)) {
+        if (agentCfg?.provider && PROVIDER_NAMES.includes(agentCfg.provider)) {
+          providers.add(agentCfg.provider);
+        }
+      }
+    }
+    if (providers.size > 0) {
+      config.enabledProviders = [...providers];
+    }
+  } else if (Array.isArray(raw.enabledProviders)) {
+    config.enabledProviders = raw.enabledProviders.filter(
+      (p) => PROVIDER_NAMES.includes(p)
+    );
+  }
+  if (raw.providerModels !== void 0 && typeof raw.providerModels === "object" && raw.providerModels !== null) {
+    const validated = {};
+    for (const [providerName, modelCfg] of Object.entries(raw.providerModels)) {
+      if (!PROVIDER_NAMES.includes(providerName)) continue;
+      if (typeof modelCfg !== "object" || modelCfg === null) continue;
+      const cfg = modelCfg;
+      const entry = {};
+      if (typeof cfg.strong === "string") entry.strong = cfg.strong;
+      if (typeof cfg.fast === "string") entry.fast = cfg.fast;
+      if (entry.strong !== void 0 || entry.fast !== void 0) {
+        validated[providerName] = entry;
+      }
+    }
+    if (Object.keys(validated).length > 0) {
+      config.providerModels = validated;
+    }
+  }
+  if (typeof raw.source === "string" && DATASOURCE_NAMES.includes(raw.source)) {
+    config.source = raw.source;
+  }
+  if (typeof raw.planTimeout === "number") config.planTimeout = raw.planTimeout;
+  if (typeof raw.specTimeout === "number") config.specTimeout = raw.specTimeout;
+  if (typeof raw.specWarnTimeout === "number") config.specWarnTimeout = raw.specWarnTimeout;
+  if (typeof raw.specKillTimeout === "number") config.specKillTimeout = raw.specKillTimeout;
+  if (typeof raw.concurrency === "number") config.concurrency = raw.concurrency;
+  if (typeof raw.maxRuns === "number") config.maxRuns = raw.maxRuns;
+  if (typeof raw.org === "string") config.org = raw.org;
+  if (typeof raw.project === "string") config.project = raw.project;
+  if (typeof raw.workItemType === "string") config.workItemType = raw.workItemType;
+  if (typeof raw.iteration === "string") config.iteration = raw.iteration;
+  if (typeof raw.area === "string") config.area = raw.area;
+  if (typeof raw.username === "string") config.username = raw.username;
+  if (typeof raw.nextIssueId === "number") config.nextIssueId = raw.nextIssueId;
+  return config;
+}
+async function saveConfig(config, configDir) {
+  const configPath = getConfigPath(configDir);
+  await mkdir3(dirname4(configPath), { recursive: true });
+  await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
 // src/spec-generator.ts
+import { cpus, freemem } from "os";
 var MB_PER_CONCURRENT_TASK = 500;
 var DEFAULT_SPEC_TIMEOUT_MIN = 10;
 var DEFAULT_SPEC_WARN_MIN = 10;
@@ -2437,6 +3263,7 @@ async function resolveSource(issues, issueSource, cwd) {
 }
 
 // src/helpers/confirm-large-batch.tsx
+init_ink_prompts();
 var LARGE_BATCH_THRESHOLD = 100;
 async function confirmLargeBatch(count, threshold = LARGE_BATCH_THRESHOLD) {
   if (count <= threshold) return true;
@@ -2512,8 +3339,224 @@ async function ensureGitignoreEntry(repoRoot, entry) {
   }
 }
 
+// src/orchestrator/runner.ts
+init_database();
+init_manager();
+
+// src/queue/fork-run.ts
+init_manager();
+import { fork } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname5, join as join9 } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname5(__filename);
+var WORKER_PATH = [
+  join9(__dirname, "mcp", "dispatch-worker.js"),
+  // bundled: __dirname = dist/
+  join9(__dirname, "..", "mcp", "dispatch-worker.js"),
+  // unbundled: __dirname = dist/queue/
+  join9(__dirname, "..", "dispatch-worker.js")
+  // legacy unbundled: __dirname = dist/mcp/tools/
+].find((p) => existsSync(p)) ?? join9(__dirname, "mcp", "dispatch-worker.js");
+var HEARTBEAT_INTERVAL_MS = 3e4;
+function forkDispatchRun(runId, workerMessage, options) {
+  if (!existsSync(WORKER_PATH)) {
+    throw new Error(
+      `Dispatch worker not found at ${WORKER_PATH}. Run 'npm run build' to compile the project before using MCP tools.`
+    );
+  }
+  const worker = fork(WORKER_PATH, [], { stdio: ["pipe", "pipe", "pipe", "ipc"] });
+  worker.send(workerMessage);
+  const heartbeat = setInterval(() => {
+    emitLog(runId, `Run ${runId} still in progress...`);
+  }, HEARTBEAT_INTERVAL_MS);
+  worker.on("message", (msg) => {
+    const msgType = msg["type"];
+    switch (msgType) {
+      case "progress": {
+        const event = msg["event"];
+        const eventType = event["type"];
+        switch (eventType) {
+          case "task_start":
+            createTask({
+              runId,
+              taskId: event["taskId"],
+              taskText: event["taskText"],
+              file: event["file"] ?? event["taskId"].split(":")[0] ?? "",
+              line: event["line"] ?? parseInt(event["taskId"].split(":")[1] ?? "0", 10)
+            });
+            updateTaskStatus(runId, event["taskId"], "running");
+            emitLog(runId, `Task started: ${event["taskText"]}`);
+            break;
+          case "task_done":
+            updateTaskStatus(runId, event["taskId"], "success");
+            emitLog(runId, `Task done: ${event["taskText"]}`);
+            break;
+          case "task_failed":
+            updateTaskStatus(runId, event["taskId"], "failed", { error: event["error"] });
+            emitLog(runId, `Task failed: ${event["taskText"]} \u2014 ${event["error"]}`, "error");
+            break;
+          case "phase_change":
+            emitLog(runId, event["message"] ?? `Phase: ${event["phase"]}`);
+            break;
+          case "log":
+            emitLog(runId, event["message"]);
+            break;
+        }
+        break;
+      }
+      case "spec_progress": {
+        const event = msg["event"];
+        const eventType = event["type"];
+        switch (eventType) {
+          case "item_start":
+            emitLog(runId, `Generating spec for: ${event["itemTitle"] ?? event["itemId"]}`);
+            break;
+          case "item_done":
+            emitLog(runId, `Spec done: ${event["itemTitle"] ?? event["itemId"]}`);
+            break;
+          case "item_failed":
+            emitLog(runId, `Spec failed: ${event["itemTitle"] ?? event["itemId"]} \u2014 ${event["error"]}`, "error");
+            break;
+          case "log":
+            emitLog(runId, event["message"]);
+            break;
+        }
+        break;
+      }
+      case "done": {
+        const result = msg["result"];
+        if (options?.onDone) {
+          options.onDone(result);
+        } else if ("completed" in result) {
+          updateRunCounters(runId, result["total"], result["completed"], result["failed"]);
+          finishRun(runId, result["failed"] > 0 ? "failed" : "completed");
+          emitLog(runId, `Dispatch complete: ${result["completed"]}/${result["total"]} tasks succeeded`);
+        } else if ("generated" in result) {
+          const total = result["total"];
+          const generated = result["generated"];
+          const failed = result["failed"];
+          finishSpecRun(runId, failed > 0 ? "failed" : "completed", { total, generated, failed });
+          emitLog(runId, `Spec complete: ${generated}/${total} specs generated`);
+        }
+        break;
+      }
+      case "error": {
+        const errorMsg = msg["message"];
+        if (options?.runType === "spec_runs") {
+          finishSpecRun(runId, "failed", { total: 0, generated: 0, failed: 0 }, errorMsg);
+        } else {
+          finishRun(runId, "failed", errorMsg);
+        }
+        emitLog(runId, `Run error: ${errorMsg}`, "error");
+        break;
+      }
+    }
+  });
+  worker.on("exit", (code) => {
+    clearInterval(heartbeat);
+    if (code !== 0 && code !== null) {
+      const exitError = `Worker process exited with code ${code}`;
+      if (options?.runType === "spec_runs") {
+        finishSpecRun(runId, "failed", { total: 0, generated: 0, failed: 0 }, exitError);
+      } else {
+        finishRun(runId, "failed", exitError);
+      }
+      emitLog(runId, `Worker process exited unexpectedly (code ${code})`, "error");
+    }
+    options?.onExit?.(code);
+  });
+  return worker;
+}
+
+// src/queue/run-queue.ts
+init_manager();
+var RunQueue = class {
+  limit;
+  /** In-memory map of runId → context needed to fork (callbacks). */
+  contexts = /* @__PURE__ */ new Map();
+  constructor(limit) {
+    this.limit = Math.max(1, limit);
+  }
+  /**
+   * Enqueue a run for execution. The run must already exist in the DB with
+   * status "queued" and a serialized workerMessage.
+   *
+   * If a slot is available the run is forked immediately; otherwise it waits
+   * in the DB queue until a running child exits.
+   */
+  enqueue(runId, logCallback, options) {
+    this.contexts.set(runId, { logCallback, options });
+    if (logCallback) {
+      addLogCallback(runId, logCallback);
+    }
+    this.drain();
+  }
+  /**
+   * Drain the queue: fork queued runs while slots are available.
+   * Called on enqueue and whenever a child process exits.
+   */
+  drain() {
+    let active = countActiveRuns();
+    while (active < this.limit) {
+      const next = getNextQueued();
+      if (!next) break;
+      const { runId, workerMessage, table } = next;
+      if (table === "runs") {
+        markRunStarted(runId);
+      } else {
+        markSpecRunStarted(runId);
+      }
+      let parsedMessage;
+      try {
+        parsedMessage = JSON.parse(workerMessage);
+      } catch {
+        emitLog(runId, `Failed to parse queued worker message`, "error");
+        continue;
+      }
+      const ctx = this.contexts.get(runId);
+      if (!ctx) {
+        continue;
+      }
+      this.contexts.delete(runId);
+      emitLog(runId, `Run started (${active + 1}/${this.limit} slots used)`);
+      const userOnExit = ctx.options?.onExit;
+      forkDispatchRun(runId, parsedMessage, {
+        ...ctx.options,
+        runType: table,
+        logCallback: ctx.logCallback,
+        onExit: (code) => {
+          userOnExit?.(code);
+          this.drain();
+        }
+      });
+      active++;
+    }
+  }
+  /** Mark all queued runs as failed (for graceful shutdown). */
+  abort() {
+    failAllQueuedRuns();
+    this.contexts.clear();
+  }
+  /** Current concurrency limit. */
+  get maxRuns() {
+    return this.limit;
+  }
+};
+var _queue = null;
+function initRunQueue(limit) {
+  _queue = new RunQueue(limit);
+}
+function getRunQueue() {
+  if (!_queue) {
+    throw new Error("RunQueue not initialized. Call initRunQueue(limit) first.");
+  }
+  return _queue;
+}
+
 // src/orchestrator/cli-config.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 import { access } from "fs/promises";
 import { constants } from "fs";
 var CONFIG_TO_CLI = {
@@ -2537,11 +3580,12 @@ function setCliField(target, key, value) {
 }
 async function resolveCliConfig(args) {
   const { explicitFlags } = args;
-  const configDir = join8(args.cwd, ".dispatch");
+  const configDir = join10(args.cwd, ".dispatch");
   const config = await loadConfig(configDir);
   const merged = { ...args };
   for (const configKey of CONFIG_KEYS) {
     const cliField = CONFIG_TO_CLI[configKey];
+    if (!cliField) continue;
     const configValue = config[configKey];
     if (configValue !== void 0 && !explicitFlags.has(cliField)) {
       setCliField(merged, cliField, configValue);
@@ -2583,9 +3627,9 @@ async function resolveCliConfig(args) {
 }
 
 // src/orchestrator/spec-pipeline.ts
-import { join as join10, resolve as resolve2 } from "path";
+import { join as join12, resolve as resolve2 } from "path";
 import { mkdir as mkdir4, readFile as readFile8, rename as rename2, unlink as unlink2 } from "fs/promises";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { glob as glob2 } from "glob";
 
 // src/providers/router.ts
@@ -3023,6 +4067,7 @@ function registerCleanup(fn) {
 import chalk4 from "chalk";
 
 // src/tui.tsx
+init_format();
 import { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render2, Box as Box2, Text as Text2, Spacer, useInput as useInput2 } from "ink";
 import Spinner from "ink-spinner";
@@ -3806,6 +4851,9 @@ function createTui(options) {
   return { state, update, stop, waitForRecoveryAction };
 }
 
+// src/orchestrator/spec-pipeline.ts
+init_format();
+
 // src/helpers/retry.ts
 var DEFAULT_RETRY_COUNT = 3;
 async function withRetry(fn, maxRetries, options) {
@@ -3874,7 +4922,7 @@ async function runWithConcurrency(options) {
 }
 
 // src/orchestrator/datasource-helpers.ts
-import { basename as basename2, join as join9 } from "path";
+import { basename as basename2, join as join11 } from "path";
 import { mkdtemp, writeFile as writeFile6 } from "fs/promises";
 import { tmpdir } from "os";
 import { execFile as execFile8 } from "child_process";
@@ -3903,14 +4951,14 @@ async function fetchItemsById(issueIds, datasource4, fetchOpts) {
   return items;
 }
 async function writeItemsToTempDir(items) {
-  const tempDir = await mkdtemp(join9(tmpdir(), "dispatch-"));
+  const tempDir = await mkdtemp(join11(tmpdir(), "dispatch-"));
   const files = [];
   const issueDetailsByFile = /* @__PURE__ */ new Map();
   for (const item of items) {
     const slug = slugify(item.title, MAX_SLUG_LENGTH);
     const id = item.number.includes("/") || item.number.includes("\\") ? basename2(item.number, ".md") : item.number;
     const filename = `${id}-${slug}.md`;
-    const filepath = join9(tempDir, filename);
+    const filepath = join11(tempDir, filename);
     await writeFile6(filepath, item.body, "utf-8");
     files.push(filepath);
     issueDetailsByFile.set(filepath, item);
@@ -4093,7 +5141,7 @@ function buildInlineTextItem(issues, outputDir) {
   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 = join10(outputDir, filename);
+  const filepath = join12(outputDir, filename);
   const details = {
     number: filepath,
     title,
@@ -4155,7 +5203,7 @@ function previewDryRun(validItems, items, isTrackerMode, isInlineText, outputDir
     let filepath;
     if (isTrackerMode) {
       const slug = slugify(details.title, 60);
-      filepath = join10(outputDir, `${id}-${slug}.md`);
+      filepath = join12(outputDir, `${id}-${slug}.md`);
     } else {
       filepath = id;
     }
@@ -4222,7 +5270,7 @@ async function generateSpecsBatch(validItems, items, provider, isTrackerMode, is
       if (isTrackerMode) {
         const slug = slugify(details.title, MAX_SLUG_LENGTH);
         const filename = `${id}-${slug}.md`;
-        filepath = join10(outputDir, filename);
+        filepath = join12(outputDir, filename);
       } else if (isInlineText) {
         filepath = id;
       } else {
@@ -4233,9 +5281,9 @@ async function generateSpecsBatch(validItems, items, provider, isTrackerMode, is
         fileLoggerStorage.getStore()?.info(`Starting spec generation for ${isTrackerMode ? `#${id}` : filepath}`);
         if (!quiet) log.info(`Generating spec for ${isTrackerMode ? `#${id}` : filepath}: ${details.title}...`);
         const generateLabel = `dispatch(spec, ${isTrackerMode ? `#${id}` : filepath})`;
-        const tmpDir = join10(resolve2(specCwd), ".dispatch", "tmp");
+        const tmpDir = join12(resolve2(specCwd), ".dispatch", "tmp");
         await mkdir4(tmpDir, { recursive: true });
-        const tmpPath = join10(tmpDir, `spec-${randomUUID3()}.md`);
+        const tmpPath = join12(tmpDir, `spec-${randomUUID4()}.md`);
         const specInput = {
           issue: isTrackerMode ? details : void 0,
           filePath: isTrackerMode ? void 0 : id,
@@ -4270,7 +5318,7 @@ async function generateSpecsBatch(validItems, items, provider, isTrackerMode, is
           const h1Title = extractTitle(result.data.content, filepath);
           const h1Slug = slugify(h1Title, MAX_SLUG_LENGTH);
           const finalFilename = isTrackerMode ? `${id}-${h1Slug}.md` : `${h1Slug}.md`;
-          const finalFilepath = join10(outputDir, finalFilename);
+          const finalFilepath = join12(outputDir, finalFilename);
           if (finalFilepath !== filepath) {
             await rename2(filepath, finalFilepath);
             filepath = finalFilepath;
@@ -4418,7 +5466,7 @@ async function runSpecPipeline(opts) {
     providerModels,
     serverUrl,
     cwd: specCwd,
-    outputDir = join10(specCwd, ".dispatch", "specs"),
+    outputDir = join12(specCwd, ".dispatch", "specs"),
     org,
     project,
     workItemType,
@@ -4955,11 +6003,11 @@ function parseCommitResponse(response) {
 }
 
 // src/helpers/worktree.ts
-import { join as join11, basename as basename3 } from "path";
+import { join as join13, basename as basename3 } from "path";
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify9 } from "util";
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync2 } from "fs";
 import { rm } from "fs/promises";
 var exec8 = promisify9(execFile9);
 var WORKTREE_DIR = ".dispatch/worktrees";
@@ -4975,8 +6023,8 @@ function worktreeName(issueFilename) {
 }
 async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
   const name = worktreeName(issueFilename);
-  const worktreePath = join11(repoRoot, WORKTREE_DIR, name);
-  if (existsSync(worktreePath)) {
+  const worktreePath = join13(repoRoot, WORKTREE_DIR, name);
+  if (existsSync2(worktreePath)) {
     try {
       const listOutput = await git4(["worktree", "list", "--porcelain"], repoRoot);
       const isRegistered = listOutput.includes(`worktree ${worktreePath}
@@ -5057,7 +6105,7 @@ async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
 }
 async function removeWorktree(repoRoot, issueFilename) {
   const name = worktreeName(issueFilename);
-  const worktreePath = join11(repoRoot, WORKTREE_DIR, name);
+  const worktreePath = join13(repoRoot, WORKTREE_DIR, name);
   try {
     await git4(["worktree", "remove", worktreePath], repoRoot);
   } catch {
@@ -5075,7 +6123,7 @@ async function removeWorktree(repoRoot, issueFilename) {
   }
 }
 function generateFeatureBranchName() {
-  const uuid = randomUUID4();
+  const uuid = randomUUID5();
   const octet = uuid.split("-")[0];
   return `dispatch/feature-${octet}`;
 }
@@ -5180,11 +6228,12 @@ var ProviderPool = class {
 };
 
 // src/orchestrator/dispatch-pipeline.ts
+init_format();
 import chalk5 from "chalk";
 
 // src/helpers/run-state.ts
 import { readFile as readFile10, mkdir as mkdir5 } from "fs/promises";
-import { join as join12, basename as basename4 } from "path";
+import { join as join14, basename as basename4 } from "path";
 import { z } from "zod";
 var RunStateTaskStatusSchema = z.enum(["pending", "running", "success", "failed"]);
 var RunStateTaskSchema = z.object({
@@ -5766,6 +6815,7 @@ ${err.stack}` : ""}`);
           }
           if (stopAfterIssue) break;
         }
+        let commitSkillResult;
         if (!preserveContext) {
           if (!noBranch && branchName && defaultBranch && details && datasource4.supportsGit()) {
             try {
@@ -5779,7 +6829,6 @@ ${err.stack}` : ""}`);
             }
           }
           fileLogger?.phase("Commit generation");
-          let commitSkillResult;
           if (!noBranch && branchName && defaultBranch && details && datasource4.supportsGit()) {
             try {
               const branchDiff = await getBranchDiff(defaultBranch, issueCwd);
@@ -5810,99 +6859,99 @@ ${err.stack}` : ""}`);
               log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
             }
           }
-          fileLogger?.phase("PR lifecycle");
-          if (!noBranch && branchName && defaultBranch && details) {
-            if (feature && featureBranchName) {
-              if (worktreePath) {
-                try {
-                  await removeWorktree(cwd, file);
-                } catch (err) {
-                  log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
-                }
-              }
+        }
+        fileLogger?.phase("PR lifecycle");
+        if (!noBranch && branchName && defaultBranch && details) {
+          if (feature && featureBranchName && !preserveContext) {
+            if (worktreePath) {
               try {
-                await datasource4.switchBranch(featureBranchName, lifecycleOpts);
-                await exec9("git", ["merge", branchName, "--no-ff", "-m", `merge: issue #${details.number}`], { cwd, shell: process.platform === "win32" });
-                log.debug(`Merged ${branchName} into ${featureBranchName}`);
+                await removeWorktree(cwd, file);
               } catch (err) {
-                const mergeError = `Could not merge ${branchName} into feature branch: ${log.formatErrorChain(err)}`;
-                log.warn(mergeError);
-                try {
-                  await exec9("git", ["merge", "--abort"], { cwd, shell: process.platform === "win32" });
-                } catch {
-                }
-                for (const task of fileTasks) {
-                  const tuiTask = tui.state.tasks.find((t) => t.task === task);
-                  if (tuiTask) {
-                    tuiTask.status = "failed";
-                    tuiTask.error = mergeError;
-                  }
-                  upsertResult(results, { task, success: false, error: mergeError });
-                }
-                return { halted: false };
+                log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
               }
+            }
+            try {
+              await datasource4.switchBranch(featureBranchName, lifecycleOpts);
+              await exec9("git", ["merge", branchName, "--no-ff", "-m", `merge: issue #${details.number}`], { cwd, shell: process.platform === "win32" });
+              log.debug(`Merged ${branchName} into ${featureBranchName}`);
+            } catch (err) {
+              const mergeError = `Could not merge ${branchName} into feature branch: ${log.formatErrorChain(err)}`;
+              log.warn(mergeError);
               try {
-                await exec9("git", ["branch", "-d", branchName], { cwd, shell: process.platform === "win32" });
-                log.debug(`Deleted local branch ${branchName}`);
-              } catch (err) {
-                log.warn(`Could not delete local branch ${branchName}: ${log.formatErrorChain(err)}`);
+                await exec9("git", ["merge", "--abort"], { cwd, shell: process.platform === "win32" });
+              } catch {
+              }
+              for (const task of fileTasks) {
+                const tuiTask = tui.state.tasks.find((t) => t.task === task);
+                if (tuiTask) {
+                  tuiTask.status = "failed";
+                  tuiTask.error = mergeError;
+                }
+                upsertResult(results, { task, success: false, error: mergeError });
               }
+              return { halted: false };
+            }
+            try {
+              await exec9("git", ["branch", "-d", branchName], { cwd, shell: process.platform === "win32" });
+              log.debug(`Deleted local branch ${branchName}`);
+            } catch (err) {
+              log.warn(`Could not delete local branch ${branchName}: ${log.formatErrorChain(err)}`);
+            }
+            try {
+              await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+            } catch (err) {
+              log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
+            }
+          } else if (!feature) {
+            if (datasource4.supportsGit()) {
               try {
-                await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+                await datasource4.pushBranch(branchName, issueLifecycleOpts);
+                log.debug(`Pushed branch ${branchName}`);
+                fileLogger?.info(`Pushed branch ${branchName}`);
               } catch (err) {
-                log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
+                log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
               }
-            } else {
-              if (datasource4.supportsGit()) {
-                try {
-                  await datasource4.pushBranch(branchName, issueLifecycleOpts);
-                  log.debug(`Pushed branch ${branchName}`);
-                  fileLogger?.info(`Pushed branch ${branchName}`);
-                } catch (err) {
-                  log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
+            }
+            if (datasource4.supportsGit()) {
+              try {
+                const prTitle = commitSkillResult?.success && commitSkillResult.data.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
+                const prBody = commitSkillResult?.success && commitSkillResult.data.prDescription || await buildPrBody(
+                  details,
+                  fileTasks,
+                  issueResults,
+                  defaultBranch,
+                  datasource4.name,
+                  issueLifecycleOpts.cwd
+                );
+                const prUrl = await datasource4.createPullRequest(
+                  branchName,
+                  details.number,
+                  prTitle,
+                  prBody,
+                  issueLifecycleOpts,
+                  startingBranch
+                );
+                if (prUrl) {
+                  log.success(`Created PR for issue #${details.number}: ${prUrl}`);
+                  fileLogger?.info(`Created PR: ${prUrl}`);
                 }
+              } catch (err) {
+                log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                fileLogger?.warn(`PR creation failed: ${log.extractMessage(err)}`);
               }
-              if (datasource4.supportsGit()) {
-                try {
-                  const prTitle = commitSkillResult?.success && commitSkillResult.data.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
-                  const prBody = commitSkillResult?.success && commitSkillResult.data.prDescription || await buildPrBody(
-                    details,
-                    fileTasks,
-                    issueResults,
-                    defaultBranch,
-                    datasource4.name,
-                    issueLifecycleOpts.cwd
-                  );
-                  const prUrl = await datasource4.createPullRequest(
-                    branchName,
-                    details.number,
-                    prTitle,
-                    prBody,
-                    issueLifecycleOpts,
-                    startingBranch
-                  );
-                  if (prUrl) {
-                    log.success(`Created PR for issue #${details.number}: ${prUrl}`);
-                    fileLogger?.info(`Created PR: ${prUrl}`);
-                  }
-                } catch (err) {
-                  log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
-                  fileLogger?.warn(`PR creation failed: ${log.extractMessage(err)}`);
-                }
+            }
+            if (useWorktrees && worktreePath && !preserveContext) {
+              try {
+                await removeWorktree(cwd, file);
+              } catch (err) {
+                log.warn(`Could not remove worktree 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 && datasource4.supportsGit()) {
-                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)}`);
-                }
+            } else if (!useWorktrees && datasource4.supportsGit()) {
+              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)}`);
               }
             }
           }
@@ -6095,109 +7144,294 @@ async function boot5(opts) {
         log.error("--feature and --no-branch are mutually exclusive");
         process.exit(1);
       }
-      if (m.spec) {
-        return this.generateSpecs({
-          issues: m.spec,
-          issueSource: m.issueSource,
+      if (m.dryRun) {
+        if (m.spec || m.respec) {
+          let issues;
+          if (m.spec) {
+            issues = m.spec;
+          } else {
+            const respecArgs = m.respec;
+            const isEmpty = Array.isArray(respecArgs) && respecArgs.length === 0;
+            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, iteration: m.iteration, area: m.area });
+              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,
+            enabledProviders: m.enabledProviders,
+            providerModels: m.providerModels,
+            serverUrl: m.serverUrl,
+            cwd: m.cwd,
+            outputDir: m.outputDir,
+            org: m.org,
+            project: m.project,
+            workItemType: m.workItemType,
+            iteration: m.iteration,
+            area: m.area,
+            concurrency: m.concurrency,
+            dryRun: true,
+            retries: m.retries,
+            specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
+            specWarnTimeout: m.specWarnTimeout,
+            specKillTimeout: m.specKillTimeout
+          });
+        }
+        return this.orchestrate({
+          issueIds: m.issueIds,
+          concurrency: m.concurrency ?? defaultConcurrency(),
+          dryRun: true,
+          noPlan: m.noPlan,
+          noBranch: m.noBranch,
+          noWorktree: m.noWorktree,
           provider: m.provider,
           enabledProviders: m.enabledProviders,
           providerModels: m.providerModels,
           serverUrl: m.serverUrl,
-          cwd: m.cwd,
-          outputDir: m.outputDir,
+          source: m.issueSource,
           org: m.org,
           project: m.project,
           workItemType: m.workItemType,
           iteration: m.iteration,
           area: m.area,
-          concurrency: m.concurrency,
-          dryRun: m.dryRun,
+          planTimeout: m.planTimeout,
+          planRetries: m.planRetries,
           retries: m.retries,
-          specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
-          specWarnTimeout: m.specWarnTimeout,
-          specKillTimeout: m.specKillTimeout
+          force: m.force,
+          feature: m.feature,
+          username: m.username
         });
       }
-      if (m.respec) {
-        const respecArgs = m.respec;
-        const isEmpty = Array.isArray(respecArgs) && respecArgs.length === 0;
+      openDatabase(cwd);
+      const concurrency = m.concurrency ?? defaultConcurrency();
+      const maxRuns = Math.min(Math.max(4, defaultConcurrency() * 2), CONFIG_BOUNDS.maxRuns.max);
+      if (m.resume !== void 0) {
+        return runResumeFlow(m.resume, cwd, maxRuns);
+      }
+      const sessionId = randomUUID6();
+      markOrphanedRunsFailed({ exceptSessionId: sessionId });
+      initRunQueue(maxRuns);
+      if (m.spec || m.respec) {
         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, iteration: m.iteration, area: m.area });
-          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);
-          }
+        if (m.spec) {
+          issues = m.spec;
         } else {
-          issues = respecArgs;
+          const respecArgs = m.respec;
+          const isEmpty = Array.isArray(respecArgs) && respecArgs.length === 0;
+          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, iteration: m.iteration, area: m.area });
+            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({
+        const workerMessage2 = {
+          type: "spec",
+          cwd,
+          opts: {
+            issues,
+            enabledProviders: m.enabledProviders,
+            providerModels: m.providerModels,
+            issueSource: m.issueSource,
+            org: m.org,
+            project: m.project,
+            workItemType: m.workItemType,
+            iteration: m.iteration,
+            area: m.area,
+            concurrency,
+            specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
+            specWarnTimeout: m.specWarnTimeout,
+            specKillTimeout: m.specKillTimeout,
+            dryRun: false,
+            cwd
+          }
+        };
+        const runId2 = createSpecRun({
+          cwd,
           issues,
-          issueSource: m.issueSource,
+          sessionId,
+          status: "queued",
+          workerMessage: JSON.stringify(workerMessage2)
+        });
+        return awaitQueuedRuns([runId2], sessionId, cwd, "spec");
+      }
+      const workerMessage = {
+        type: "dispatch",
+        cwd,
+        opts: {
+          issueIds: m.issueIds,
+          dryRun: false,
           provider: m.provider,
           enabledProviders: m.enabledProviders,
           providerModels: m.providerModels,
-          serverUrl: m.serverUrl,
-          cwd: m.cwd,
-          outputDir: m.outputDir,
+          source: m.issueSource,
           org: m.org,
           project: m.project,
           workItemType: m.workItemType,
           iteration: m.iteration,
           area: m.area,
-          concurrency: m.concurrency,
-          dryRun: m.dryRun,
+          username: m.username,
+          planTimeout: m.planTimeout,
+          concurrency,
+          noPlan: m.noPlan,
+          noBranch: m.noBranch,
+          noWorktree: m.noWorktree,
           retries: m.retries,
-          specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
-          specWarnTimeout: m.specWarnTimeout,
-          specKillTimeout: m.specKillTimeout
-        });
-      }
-      return this.orchestrate({
+          feature: m.feature,
+          planRetries: m.planRetries,
+          force: m.force
+        }
+      };
+      const runId = createRun({
+        cwd,
         issueIds: m.issueIds,
-        concurrency: m.concurrency ?? defaultConcurrency(),
-        dryRun: m.dryRun,
-        noPlan: m.noPlan,
-        noBranch: m.noBranch,
-        noWorktree: m.noWorktree,
-        provider: m.provider,
-        enabledProviders: m.enabledProviders,
-        providerModels: m.providerModels,
-        serverUrl: m.serverUrl,
-        source: m.issueSource,
-        org: m.org,
-        project: m.project,
-        workItemType: m.workItemType,
-        iteration: m.iteration,
-        area: m.area,
-        planTimeout: m.planTimeout,
-        planRetries: m.planRetries,
-        retries: m.retries,
-        force: m.force,
-        feature: m.feature,
-        username: m.username
+        sessionId,
+        status: "queued",
+        workerMessage: JSON.stringify(workerMessage)
       });
+      return awaitQueuedRuns([runId], sessionId, cwd, "dispatch");
     }
   };
   return runner;
 }
+function cliLogCallback(message, level) {
+  if (level === "error") log.error(message);
+  else if (level === "warn") log.warn(message);
+  else log.info(message);
+}
+async function awaitQueuedRuns(runIds, sessionId, cwd, mode) {
+  const queue = getRunQueue();
+  for (const runId of runIds) {
+    queue.enqueue(runId, cliLogCallback);
+  }
+  const getStatus = mode === "spec" ? (runId) => getSpecRun(runId)?.status ?? null : (runId) => getRun(runId)?.status ?? null;
+  await Promise.all(runIds.map(
+    (runId) => waitForRunCompletion(runId, 6e5, () => getStatus(runId))
+  ));
+  if (mode === "spec") {
+    let total2 = 0, generated = 0, failed2 = 0;
+    for (const runId of runIds) {
+      const { getSpecRun: getSpecRun2 } = await Promise.resolve().then(() => (init_manager(), manager_exports));
+      const run = getSpecRun2(runId);
+      if (run) {
+        total2 += run.total;
+        generated += run.generated;
+        failed2 += run.failed;
+      }
+    }
+    return { total: total2, generated, failed: failed2 };
+  }
+  let total = 0, completed = 0, failed = 0;
+  const results = [];
+  for (const runId of runIds) {
+    const run = getRun(runId);
+    if (run) {
+      total += run.total;
+      completed += run.completed;
+      failed += run.failed;
+    }
+    const tasks = getTasksForRun(runId);
+    for (const task of tasks) {
+      results.push({
+        task: { file: task.file, line: task.line, text: task.taskText },
+        success: task.status === "success",
+        error: task.error ?? void 0
+      });
+    }
+  }
+  return { total, completed, failed, skipped: 0, results };
+}
+async function runResumeFlow(resumeArg, cwd, maxRuns) {
+  const sessions = listResumableSessions(cwd);
+  if (sessions.length === 0) {
+    log.info("No incomplete sessions found to resume.");
+    process.exit(0);
+  }
+  let sessionId;
+  if (typeof resumeArg === "string") {
+    const match = sessions.find((s) => s.sessionId === resumeArg);
+    if (!match) {
+      log.error(`Session ${resumeArg} not found or has no incomplete runs.`);
+      log.info("Available sessions:");
+      for (const s of sessions) {
+        const date = new Date(s.startedAt).toLocaleString();
+        log.info(`  ${s.sessionId}  (${date}, ${s.incompleteRuns} incomplete)`);
+      }
+      process.exit(1);
+    }
+    sessionId = resumeArg;
+  } else if (sessions.length === 1) {
+    sessionId = sessions[0].sessionId;
+    log.info(`Resuming session ${sessionId} (${sessions[0].incompleteRuns} incomplete run(s))`);
+  } else {
+    const { select: select2 } = await Promise.resolve().then(() => (init_ink_prompts(), ink_prompts_exports));
+    sessionId = await select2({
+      message: "Multiple incomplete sessions found. Which one would you like to resume?",
+      choices: sessions.map((s) => {
+        const date = new Date(s.startedAt).toLocaleString();
+        let issueLabel = "";
+        try {
+          const ids = JSON.parse(s.issueIds);
+          issueLabel = ids.length > 3 ? `issues ${ids.slice(0, 3).join(", ")}...` : `issues ${ids.join(", ")}`;
+        } catch {
+          issueLabel = "unknown issues";
+        }
+        return {
+          name: `${s.sessionId.slice(0, 8)}  ${date}  ${issueLabel}  (${s.incompleteRuns} incomplete)`,
+          value: s.sessionId
+        };
+      })
+    });
+  }
+  markOrphanedRunsFailed({ exceptSessionId: sessionId });
+  initRunQueue(maxRuns);
+  const runIds = requeueSessionRuns(sessionId);
+  if (runIds.length === 0) {
+    log.info("No runs to resume in this session.");
+    process.exit(0);
+  }
+  log.info(`Resuming ${runIds.length} run(s) from session ${sessionId.slice(0, 8)}...`);
+  return awaitQueuedRuns(runIds, sessionId, cwd, "dispatch");
+}
 
 // src/mcp/dispatch-worker.ts
 process.on("message", (msg) => {
   void handleMessage(msg);
 });
+function sendAndFlush(msg) {
+  return new Promise((resolve3, reject) => {
+    process.send(msg, (err) => {
+      if (err) reject(err);
+      else resolve3();
+    });
+  });
+}
 async function handleMessage(msg) {
   try {
     if (msg.type === "dispatch") {
@@ -6208,7 +7442,7 @@ async function handleMessage(msg) {
           process.send({ type: "progress", event });
         }
       });
-      process.send({ type: "done", result });
+      await sendAndFlush({ type: "done", result });
     } else if (msg.type === "spec") {
       const result = await runSpecPipeline({
         ...msg.opts,
@@ -6216,10 +7450,11 @@ async function handleMessage(msg) {
           process.send({ type: "spec_progress", event });
         }
       });
-      process.send({ type: "done", result });
+      await sendAndFlush({ type: "done", result });
     }
   } catch (err) {
-    process.send({ type: "error", message: err instanceof Error ? err.message : String(err) });
+    await sendAndFlush({ type: "error", message: err instanceof Error ? err.message : String(err) }).catch(() => {
+    });
   }
   process.exit(0);
 }