@pruddiman/dispatch 1.3.1 → 1.4.1

package/dist/cli.js

@@ -210,6 +210,27 @@ var init_logger = __esm({
   }
 });
 
+// src/helpers/cleanup.ts
+function registerCleanup(fn) {
+  cleanups.push(fn);
+}
+async function runCleanup() {
+  const fns = cleanups.splice(0);
+  for (const fn of fns) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+}
+var cleanups;
+var init_cleanup = __esm({
+  "src/helpers/cleanup.ts"() {
+    "use strict";
+    cleanups = [];
+  }
+});
+
 // src/helpers/guards.ts
 function hasProperty(value, key) {
   return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, key);
@@ -422,7 +443,7 @@ var init_opencode = __esm({
 
 // src/helpers/timeout.ts
 function withTimeout(promise, ms, label) {
-  const p = new Promise((resolve4, reject) => {
+  const p = new Promise((resolve5, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
@@ -434,7 +455,7 @@ function withTimeout(promise, ms, label) {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
-        resolve4(value);
+        resolve5(value);
       },
       (err) => {
         if (settled) return;
@@ -542,9 +563,9 @@ async function boot2(opts) {
         let unsubErr;
         try {
           await withTimeout(
-            new Promise((resolve4, reject) => {
+            new Promise((resolve5, reject) => {
               unsubIdle = session.on("session.idle", () => {
-                resolve4();
+                resolve5();
               });
               unsubErr = session.on("session.error", (event) => {
                 reject(new Error(`Copilot session error: ${event.data.message}`));
@@ -592,7 +613,7 @@ var init_copilot = __esm({
 });
 
 // src/providers/claude.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
 async function listModels3(_opts) {
   return [
@@ -615,7 +636,7 @@ async function boot3(opts) {
       try {
         const sessionOpts = { model, permissionMode: "acceptEdits", ...cwd ? { cwd } : {} };
         const session = unstable_v2_createSession(sessionOpts);
-        const sessionId = randomUUID();
+        const sessionId = randomUUID2();
         sessions.set(sessionId, session);
         log.debug(`Session created: ${sessionId}`);
         return sessionId;
@@ -667,7 +688,7 @@ var init_claude = __esm({
 });
 
 // src/providers/codex.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function loadAgentLoop() {
   return import("@openai/codex");
 }
@@ -689,7 +710,7 @@ async function boot4(opts) {
     async createSession() {
       log.debug("Creating Codex session...");
       try {
-        const sessionId = randomUUID2();
+        const sessionId = randomUUID3();
         const agent = new AgentLoop({
           model,
           config: { model, instructions: "" },
@@ -756,23 +777,25 @@ var init_codex = __esm({
 });
 
 // src/providers/detect.ts
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
 async function checkProviderInstalled(name) {
   try {
-    await exec6(PROVIDER_BINARIES[name], ["--version"], {
-      shell: process.platform === "win32"
+    await exec8(PROVIDER_BINARIES[name], ["--version"], {
+      shell: process.platform === "win32",
+      timeout: DETECTION_TIMEOUT_MS
     });
     return true;
   } catch {
     return false;
   }
 }
-var exec6, PROVIDER_BINARIES;
+var exec8, DETECTION_TIMEOUT_MS, PROVIDER_BINARIES;
 var init_detect = __esm({
   "src/providers/detect.ts"() {
     "use strict";
-    exec6 = promisify6(execFile6);
+    exec8 = promisify8(execFile8);
+    DETECTION_TIMEOUT_MS = 5e3;
     PROVIDER_BINARIES = {
       opencode: "opencode",
       copilot: "copilot",
@@ -826,24 +849,32 @@ var init_providers = __esm({
   }
 });
 
-// src/helpers/cleanup.ts
-function registerCleanup(fn) {
-  cleanups.push(fn);
-}
-async function runCleanup() {
-  const fns = cleanups.splice(0);
-  for (const fn of fns) {
-    try {
-      await fn();
-    } catch {
-    }
+// src/helpers/environment.ts
+function getEnvironmentInfo() {
+  const platform = process.platform;
+  switch (platform) {
+    case "win32":
+      return { platform, os: "Windows", shell: "cmd.exe/PowerShell" };
+    case "darwin":
+      return { platform, os: "macOS", shell: "zsh/bash" };
+    default:
+      return { platform, os: "Linux", shell: "bash" };
   }
 }
-var cleanups;
-var init_cleanup = __esm({
-  "src/helpers/cleanup.ts"() {
+function formatEnvironmentPrompt() {
+  const env = getEnvironmentInfo();
+  return [
+    `## Environment`,
+    `- **Operating System:** ${env.os}`,
+    `- **Default Shell:** ${env.shell}`,
+    `- Always run commands directly in the shell. Do NOT write intermediate scripts (e.g. .bat, .ps1, .py files) unless the task explicitly requires creating a script.`
+  ].join("\n");
+}
+var getEnvironmentBlock;
+var init_environment = __esm({
+  "src/helpers/environment.ts"() {
     "use strict";
-    cleanups = [];
+    getEnvironmentBlock = formatEnvironmentPrompt;
   }
 });
 
@@ -880,15 +911,15 @@ async function detectTestCommand(cwd) {
   }
 }
 function runTestCommand(command, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const [cmd, ...args] = command.split(" ");
     execFileCb(
       cmd,
       args,
-      { cwd, maxBuffer: 10 * 1024 * 1024 },
+      { cwd, maxBuffer: 10 * 1024 * 1024, shell: process.platform === "win32" },
       (error, stdout, stderr) => {
         const exitCode = error && "code" in error ? error.code ?? 1 : error ? 1 : 0;
-        resolve4({ exitCode, stdout, stderr, command });
+        resolve5({ exitCode, stdout, stderr, command });
       }
     );
   });
@@ -902,6 +933,8 @@ function buildFixTestsPrompt(testResult, cwd) {
     `**Test command:** ${testResult.command}`,
     `**Exit code:** ${testResult.exitCode}`,
     ``,
+    formatEnvironmentPrompt(),
+    ``,
     `## Test Output`,
     ``,
     "```",
@@ -1003,11 +1036,12 @@ var init_fix_tests_pipeline = __esm({
     init_cleanup();
     init_logger();
     init_file_logger();
+    init_environment();
   }
 });
 
 // src/cli.ts
-import { resolve as resolve3, join as join12 } from "path";
+import { resolve as resolve4, join as join12 } from "path";
 import { Command, Option, CommanderError } from "commander";
 
 // src/spec-generator.ts
@@ -1054,11 +1088,11 @@ function isValidBranchName(name) {
 // src/datasources/github.ts
 var exec = promisify(execFile);
 async function git(args, cwd) {
-  const { stdout } = await exec("git", args, { cwd });
+  const { stdout } = await exec("git", args, { cwd, shell: process.platform === "win32" });
   return stdout;
 }
 async function gh(args, cwd) {
-  const { stdout } = await exec("gh", args, { cwd });
+  const { stdout } = await exec("gh", args, { cwd, shell: process.platform === "win32" });
   return stdout;
 }
 function buildBranchName(issueNumber, title, username = "unknown") {
@@ -1104,7 +1138,7 @@ var datasource = {
         "--json",
         "number,title,body,labels,state,url"
       ],
-      { cwd }
+      { cwd, shell: process.platform === "win32" }
     );
     let issues;
     try {
@@ -1136,7 +1170,7 @@ var datasource = {
         "--json",
         "number,title,body,labels,state,url,comments"
       ],
-      { cwd }
+      { cwd, shell: process.platform === "win32" }
     );
     let issue;
     try {
@@ -1164,18 +1198,18 @@ var datasource = {
   },
   async update(issueId, title, body, opts = {}) {
     const cwd = opts.cwd || process.cwd();
-    await exec("gh", ["issue", "edit", issueId, "--title", title, "--body", body], { cwd });
+    await exec("gh", ["issue", "edit", issueId, "--title", title, "--body", body], { cwd, shell: process.platform === "win32" });
   },
   async close(issueId, opts = {}) {
     const cwd = opts.cwd || process.cwd();
-    await exec("gh", ["issue", "close", issueId], { cwd });
+    await exec("gh", ["issue", "close", issueId], { cwd, shell: process.platform === "win32" });
   },
   async create(title, body, opts = {}) {
     const cwd = opts.cwd || process.cwd();
     const { stdout } = await exec(
       "gh",
       ["issue", "create", "--title", title, "--body", body],
-      { cwd }
+      { cwd, shell: process.platform === "win32" }
     );
     const url = stdout.trim();
     const match = url.match(/\/issues\/(\d+)$/);
@@ -1271,6 +1305,7 @@ import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 init_logger();
 var exec2 = promisify2(execFile2);
+var doneStateCache = /* @__PURE__ */ new Map();
 function mapWorkItemToIssueDetails(item, id, comments, defaults) {
   const fields = item.fields ?? {};
   return {
@@ -1296,7 +1331,8 @@ async function detectWorkItemType(opts = {}) {
     if (opts.project) args.push("--project", opts.project);
     if (opts.org) args.push("--org", opts.org);
     const { stdout } = await exec2("az", args, {
-      cwd: opts.cwd || process.cwd()
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
     });
     const types = JSON.parse(stdout);
     if (!Array.isArray(types) || types.length === 0) return null;
@@ -1310,6 +1346,48 @@ async function detectWorkItemType(opts = {}) {
     return null;
   }
 }
+async function detectDoneState(workItemType, opts = {}) {
+  const cacheKey = `${opts.org ?? ""}|${opts.project ?? ""}|${workItemType}`;
+  const cached = doneStateCache.get(cacheKey);
+  if (cached) return cached;
+  try {
+    const args = [
+      "boards",
+      "work-item",
+      "type",
+      "state",
+      "list",
+      "--type",
+      workItemType,
+      "--output",
+      "json"
+    ];
+    if (opts.project) args.push("--project", opts.project);
+    if (opts.org) args.push("--org", opts.org);
+    const { stdout } = await exec2("az", args, {
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
+    });
+    const states = JSON.parse(stdout);
+    if (Array.isArray(states)) {
+      const completed = states.find((s) => s.category === "Completed");
+      if (completed) {
+        doneStateCache.set(cacheKey, completed.name);
+        return completed.name;
+      }
+      const names = states.map((s) => s.name);
+      const fallbacks = ["Done", "Closed", "Resolved", "Completed"];
+      for (const f of fallbacks) {
+        if (names.includes(f)) {
+          doneStateCache.set(cacheKey, f);
+          return f;
+        }
+      }
+    }
+  } catch {
+  }
+  return "Closed";
+}
 var datasource2 = {
   name: "azdevops",
   supportsGit() {
@@ -1318,6 +1396,7 @@ var datasource2 = {
   async list(opts = {}) {
     const conditions = [
       "[System.State] <> 'Closed'",
+      "[System.State] <> 'Done'",
       "[System.State] <> 'Removed'"
     ];
     if (opts.iteration) {
@@ -1340,7 +1419,8 @@ var datasource2 = {
     if (opts.org) args.push("--org", opts.org);
     if (opts.project) args.push("--project", opts.project);
     const { stdout } = await exec2("az", args, {
-      cwd: opts.cwd || process.cwd()
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
     });
     let data;
     try {
@@ -1362,9 +1442,9 @@ var datasource2 = {
         "json"
       ];
       if (opts.org) batchArgs.push("--org", opts.org);
-      if (opts.project) batchArgs.push("--project", opts.project);
       const { stdout: batchStdout } = await exec2("az", batchArgs, {
-        cwd: opts.cwd || process.cwd()
+        cwd: opts.cwd || process.cwd(),
+        shell: process.platform === "win32"
       });
       let batchItems;
       try {
@@ -1406,11 +1486,9 @@ var datasource2 = {
     if (opts.org) {
       args.push("--org", opts.org);
     }
-    if (opts.project) {
-      args.push("--project", opts.project);
-    }
     const { stdout } = await exec2("az", args, {
-      cwd: opts.cwd || process.cwd()
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
     });
     let item;
     try {
@@ -1434,10 +1512,33 @@ var datasource2 = {
       body
     ];
     if (opts.org) args.push("--org", opts.org);
-    if (opts.project) args.push("--project", opts.project);
-    await exec2("az", args, { cwd: opts.cwd || process.cwd() });
+    await exec2("az", args, { cwd: opts.cwd || process.cwd(), shell: process.platform === "win32" });
   },
   async close(issueId, opts = {}) {
+    let workItemType = opts.workItemType;
+    if (!workItemType) {
+      const showArgs = [
+        "boards",
+        "work-item",
+        "show",
+        "--id",
+        issueId,
+        "--output",
+        "json"
+      ];
+      if (opts.org) showArgs.push("--org", opts.org);
+      const { stdout } = await exec2("az", showArgs, {
+        cwd: opts.cwd || process.cwd(),
+        shell: process.platform === "win32"
+      });
+      try {
+        const item = JSON.parse(stdout);
+        workItemType = item.fields?.["System.WorkItemType"] ?? void 0;
+      } catch {
+        workItemType = void 0;
+      }
+    }
+    const state = workItemType ? await detectDoneState(workItemType, opts) : "Closed";
     const args = [
       "boards",
       "work-item",
@@ -1445,11 +1546,10 @@ var datasource2 = {
       "--id",
       issueId,
       "--state",
-      "Closed"
+      state
     ];
     if (opts.org) args.push("--org", opts.org);
-    if (opts.project) args.push("--project", opts.project);
-    await exec2("az", args, { cwd: opts.cwd || process.cwd() });
+    await exec2("az", args, { cwd: opts.cwd || process.cwd(), shell: process.platform === "win32" });
   },
   async create(title, body, opts = {}) {
     const workItemType = opts.workItemType ?? await detectWorkItemType(opts);
@@ -1474,7 +1574,8 @@ var datasource2 = {
     if (opts.org) args.push("--org", opts.org);
     if (opts.project) args.push("--project", opts.project);
     const { stdout } = await exec2("az", args, {
-      cwd: opts.cwd || process.cwd()
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
     });
     let item;
     try {
@@ -1491,7 +1592,7 @@ var datasource2 = {
   },
   async getDefaultBranch(opts) {
     try {
-      const { stdout } = await exec2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: opts.cwd });
+      const { stdout } = await exec2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: opts.cwd, shell: process.platform === "win32" });
       const parts = stdout.trim().split("/");
       const branch = parts[parts.length - 1];
       if (!isValidBranchName(branch)) {
@@ -1503,7 +1604,7 @@ var datasource2 = {
         throw err;
       }
       try {
-        await exec2("git", ["rev-parse", "--verify", "main"], { cwd: opts.cwd });
+        await exec2("git", ["rev-parse", "--verify", "main"], { cwd: opts.cwd, shell: process.platform === "win32" });
         return "main";
       } catch {
         return "master";
@@ -1512,19 +1613,19 @@ var datasource2 = {
   },
   async getUsername(opts) {
     try {
-      const { stdout } = await exec2("git", ["config", "user.name"], { cwd: opts.cwd });
+      const { stdout } = await exec2("git", ["config", "user.name"], { cwd: opts.cwd, shell: process.platform === "win32" });
       const name = slugify(stdout.trim());
       if (name) return name;
     } catch {
     }
     try {
-      const { stdout } = await exec2("az", ["account", "show", "--query", "user.name", "-o", "tsv"], { cwd: opts.cwd });
+      const { stdout } = await exec2("az", ["account", "show", "--query", "user.name", "-o", "tsv"], { cwd: opts.cwd, shell: process.platform === "win32" });
       const name = slugify(stdout.trim());
       if (name) return name;
     } catch {
     }
     try {
-      const { stdout } = await exec2("az", ["account", "show", "--query", "user.principalName", "-o", "tsv"], { cwd: opts.cwd });
+      const { stdout } = await exec2("az", ["account", "show", "--query", "user.principalName", "-o", "tsv"], { cwd: opts.cwd, shell: process.platform === "win32" });
       const principal = stdout.trim();
       const prefix = principal.split("@")[0];
       const name = slugify(prefix);
@@ -1546,29 +1647,29 @@ var datasource2 = {
       throw new InvalidBranchNameError(branchName);
     }
     try {
-      await exec2("git", ["checkout", "-b", branchName], { cwd: opts.cwd });
+      await exec2("git", ["checkout", "-b", branchName], { cwd: opts.cwd, shell: process.platform === "win32" });
     } catch (err) {
       const message = log.extractMessage(err);
       if (message.includes("already exists")) {
-        await exec2("git", ["checkout", branchName], { cwd: opts.cwd });
+        await exec2("git", ["checkout", branchName], { cwd: opts.cwd, shell: process.platform === "win32" });
       } else {
         throw err;
       }
     }
   },
   async switchBranch(branchName, opts) {
-    await exec2("git", ["checkout", branchName], { cwd: opts.cwd });
+    await exec2("git", ["checkout", branchName], { cwd: opts.cwd, shell: process.platform === "win32" });
   },
   async pushBranch(branchName, opts) {
-    await exec2("git", ["push", "--set-upstream", "origin", branchName], { cwd: opts.cwd });
+    await exec2("git", ["push", "--set-upstream", "origin", branchName], { cwd: opts.cwd, shell: process.platform === "win32" });
   },
   async commitAllChanges(message, opts) {
-    await exec2("git", ["add", "-A"], { cwd: opts.cwd });
-    const { stdout } = await exec2("git", ["diff", "--cached", "--stat"], { cwd: opts.cwd });
+    await exec2("git", ["add", "-A"], { cwd: opts.cwd, shell: process.platform === "win32" });
+    const { stdout } = await exec2("git", ["diff", "--cached", "--stat"], { cwd: opts.cwd, shell: process.platform === "win32" });
     if (!stdout.trim()) {
       return;
     }
-    await exec2("git", ["commit", "-m", message], { cwd: opts.cwd });
+    await exec2("git", ["commit", "-m", message], { cwd: opts.cwd, shell: process.platform === "win32" });
   },
   async createPullRequest(branchName, issueNumber, title, body, opts) {
     try {
@@ -1589,7 +1690,7 @@ var datasource2 = {
           "--output",
           "json"
         ],
-        { cwd: opts.cwd }
+        { cwd: opts.cwd, shell: process.platform === "win32" }
       );
       let pr;
       try {
@@ -1614,7 +1715,7 @@ var datasource2 = {
             "--output",
             "json"
           ],
-          { cwd: opts.cwd }
+          { cwd: opts.cwd, shell: process.platform === "win32" }
         );
         let prs;
         try {
@@ -1646,11 +1747,9 @@ async function fetchComments(workItemId, opts) {
     if (opts.org) {
       args.push("--org", opts.org);
     }
-    if (opts.project) {
-      args.push("--project", opts.project);
-    }
     const { stdout } = await exec2("az", args, {
-      cwd: opts.cwd || process.cwd()
+      cwd: opts.cwd || process.cwd(),
+      shell: process.platform === "win32"
     });
     const data = JSON.parse(stdout);
     if (data.comments && Array.isArray(data.comments)) {
@@ -1670,8 +1769,9 @@ async function fetchComments(workItemId, opts) {
 // src/datasources/md.ts
 import { execFile as execFile3 } from "child_process";
 import { readFile, writeFile, readdir, mkdir, rename } from "fs/promises";
-import { join as join2, parse as parsePath } from "path";
+import { basename, dirname as dirname2, isAbsolute, join as join2, parse as parsePath, resolve } from "path";
 import { promisify as promisify3 } from "util";
+import { glob } from "glob";
 
 // src/helpers/errors.ts
 var UnsupportedOperationError = class extends Error {
@@ -1692,6 +1792,15 @@ function resolveDir(opts) {
   const cwd = opts?.cwd ?? process.cwd();
   return join2(cwd, DEFAULT_DIR);
 }
+function resolveFilePath(issueId, opts) {
+  const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
+  if (isAbsolute(filename)) return filename;
+  if (/[/\\]/.test(filename)) {
+    const cwd = opts?.cwd ?? process.cwd();
+    return resolve(cwd, filename);
+  }
+  return join2(resolveDir(opts), filename);
+}
 function extractTitle(content, filename) {
   const match = content.match(/^#\s+(.+)$/m);
   if (match) return match[1].trim();
@@ -1726,6 +1835,19 @@ var datasource3 = {
     return false;
   },
   async list(opts) {
+    if (opts?.pattern) {
+      const cwd = opts.cwd ?? process.cwd();
+      const files = await glob(opts.pattern, { cwd, absolute: true });
+      const mdFiles2 = files.filter((f) => f.endsWith(".md")).sort();
+      const results2 = [];
+      for (const filePath of mdFiles2) {
+        const content = await readFile(filePath, "utf-8");
+        const filename = basename(filePath);
+        const dir2 = dirname2(filePath);
+        results2.push(toIssueDetails(filename, content, dir2));
+      }
+      return results2;
+    }
     const dir = resolveDir(opts);
     let entries;
     try {
@@ -1743,23 +1865,20 @@ var datasource3 = {
     return results;
   },
   async fetch(issueId, opts) {
-    const dir = resolveDir(opts);
-    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join2(dir, filename);
+    const filePath = resolveFilePath(issueId, opts);
     const content = await readFile(filePath, "utf-8");
+    const filename = basename(filePath);
+    const dir = dirname2(filePath);
     return toIssueDetails(filename, content, dir);
   },
   async update(issueId, _title, body, opts) {
-    const dir = resolveDir(opts);
-    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join2(dir, filename);
+    const filePath = resolveFilePath(issueId, opts);
     await writeFile(filePath, body, "utf-8");
   },
   async close(issueId, opts) {
-    const dir = resolveDir(opts);
-    const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join2(dir, filename);
-    const archiveDir = join2(dir, "archive");
+    const filePath = resolveFilePath(issueId, opts);
+    const filename = basename(filePath);
+    const archiveDir = join2(dirname2(filePath), "archive");
     await mkdir(archiveDir, { recursive: true });
     await rename(filePath, join2(archiveDir, filename));
   },
@@ -1776,7 +1895,7 @@ var datasource3 = {
   },
   async getUsername(opts) {
     try {
-      const { stdout } = await exec3("git", ["config", "user.name"], { cwd: opts.cwd });
+      const { stdout } = await exec3("git", ["config", "user.name"], { cwd: opts.cwd, shell: process.platform === "win32" });
       const name = stdout.trim();
       if (!name) return "local";
       return slugify(name);
@@ -1825,7 +1944,8 @@ function getDatasource(name) {
 async function getGitRemoteUrl(cwd) {
   try {
     const { stdout } = await exec4("git", ["remote", "get-url", "origin"], {
-      cwd
+      cwd,
+      shell: process.platform === "win32"
     });
     return stdout.trim() || null;
   } catch {
@@ -1990,100 +2110,336 @@ async function resolveSource(issues, issueSource, cwd) {
   return null;
 }
 
-// src/orchestrator/runner.ts
-init_logger();
-
-// src/helpers/confirm-large-batch.ts
+// src/orchestrator/datasource-helpers.ts
 init_logger();
-import { input } from "@inquirer/prompts";
-import chalk2 from "chalk";
-var LARGE_BATCH_THRESHOLD = 100;
-async function confirmLargeBatch(count, threshold = LARGE_BATCH_THRESHOLD) {
-  if (count <= threshold) return true;
-  log.warn(
-    `This operation will process ${chalk2.bold(String(count))} specs, which exceeds the safety threshold of ${threshold}.`
-  );
-  const answer = await input({
-    message: `Type ${chalk2.bold('"yes"')} to proceed:`
-  });
-  return answer.trim().toLowerCase() === "yes";
-}
-
-// src/helpers/prereqs.ts
+import { basename as basename2, join as join3 } from "path";
+import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 var exec5 = promisify5(execFile5);
-var MIN_NODE_VERSION = "20.12.0";
-function parseSemver(version) {
-  const [major, minor, patch] = version.split(".").map(Number);
-  return [major ?? 0, minor ?? 0, patch ?? 0];
+function parseIssueFilename(filePath) {
+  const filename = basename2(filePath);
+  const match = /^(\d+)-(.+)\.md$/.exec(filename);
+  if (!match) return null;
+  return { issueId: match[1], slug: match[2] };
 }
-function semverGte(current, minimum) {
-  const [cMaj, cMin, cPat] = parseSemver(current);
-  const [mMaj, mMin, mPat] = parseSemver(minimum);
-  if (cMaj !== mMaj) return cMaj > mMaj;
-  if (cMin !== mMin) return cMin > mMin;
-  return cPat >= mPat;
+async function fetchItemsById(issueIds, datasource4, fetchOpts) {
+  const ids = issueIds.flatMap(
+    (id) => id.split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  const items = [];
+  for (const id of ids) {
+    try {
+      const item = await datasource4.fetch(id, fetchOpts);
+      items.push(item);
+    } catch (err) {
+      const prefix = id.includes("/") || id.includes("\\") || id.endsWith(".md") ? "" : "#";
+      log.warn(`Could not fetch issue ${prefix}${id}: ${log.formatErrorChain(err)}`);
+    }
+  }
+  return items;
 }
-async function checkPrereqs(context) {
-  const failures = [];
+async function writeItemsToTempDir(items) {
+  const tempDir = await mkdtemp(join3(tmpdir(), "dispatch-"));
+  const files = [];
+  const issueDetailsByFile = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const slug = slugify(item.title, MAX_SLUG_LENGTH);
+    const filename = `${item.number}-${slug}.md`;
+    const filepath = join3(tempDir, filename);
+    await writeFile2(filepath, item.body, "utf-8");
+    files.push(filepath);
+    issueDetailsByFile.set(filepath, item);
+  }
+  files.sort((a, b) => {
+    const numA = parseInt(basename2(a).match(/^(\d+)/)?.[1] ?? "0", 10);
+    const numB = parseInt(basename2(b).match(/^(\d+)/)?.[1] ?? "0", 10);
+    if (numA !== numB) return numA - numB;
+    return a.localeCompare(b);
+  });
+  return { files, issueDetailsByFile };
+}
+async function getCommitSummaries(defaultBranch, cwd) {
   try {
-    await exec5("git", ["--version"], { shell: process.platform === "win32" });
+    const { stdout } = await exec5(
+      "git",
+      ["log", `${defaultBranch}..HEAD`, "--pretty=format:%s"],
+      { cwd, shell: process.platform === "win32" }
+    );
+    return stdout.trim().split("\n").filter(Boolean);
   } catch {
-    failures.push("git is required but was not found on PATH. Install it from https://git-scm.com");
+    return [];
   }
-  const nodeVersion = process.versions.node;
-  if (!semverGte(nodeVersion, MIN_NODE_VERSION)) {
-    failures.push(
-      `Node.js >= ${MIN_NODE_VERSION} is required but found ${nodeVersion}. Please upgrade Node.js`
+}
+async function getBranchDiff(defaultBranch, cwd) {
+  try {
+    const { stdout } = await exec5(
+      "git",
+      ["diff", `${defaultBranch}..HEAD`],
+      { cwd, maxBuffer: 10 * 1024 * 1024, shell: process.platform === "win32" }
     );
+    return stdout;
+  } catch {
+    return "";
   }
-  if (context?.datasource === "github") {
-    try {
-      await exec5("gh", ["--version"], { shell: process.platform === "win32" });
-    } catch {
-      failures.push(
-        "gh (GitHub CLI) is required for the github datasource but was not found on PATH. Install it from https://cli.github.com/"
-      );
+}
+async function squashBranchCommits(defaultBranch, message, cwd) {
+  const { stdout } = await exec5(
+    "git",
+    ["merge-base", defaultBranch, "HEAD"],
+    { cwd, shell: process.platform === "win32" }
+  );
+  const mergeBase = stdout.trim();
+  await exec5("git", ["reset", "--soft", mergeBase], { cwd, shell: process.platform === "win32" });
+  await exec5("git", ["commit", "-m", message], { cwd, shell: process.platform === "win32" });
+}
+async function buildPrBody(details, tasks, results, defaultBranch, datasourceName, cwd) {
+  const sections = [];
+  const commits = await getCommitSummaries(defaultBranch, cwd);
+  if (commits.length > 0) {
+    sections.push("## Summary\n");
+    for (const commit of commits) {
+      sections.push(`- ${commit}`);
     }
+    sections.push("");
   }
-  if (context?.datasource === "azdevops") {
-    try {
-      await exec5("az", ["--version"], { shell: process.platform === "win32" });
-    } catch {
-      failures.push(
-        "az (Azure CLI) is required for the azdevops datasource but was not found on PATH. Install it from https://learn.microsoft.com/en-us/cli/azure/"
-      );
+  const taskResults = new Map(
+    results.filter((r) => tasks.includes(r.task)).map((r) => [r.task, r])
+  );
+  const completedTasks = tasks.filter((t) => taskResults.get(t)?.success);
+  const failedTasks = tasks.filter((t) => {
+    const r = taskResults.get(t);
+    return r && !r.success;
+  });
+  if (completedTasks.length > 0 || failedTasks.length > 0) {
+    sections.push("## Tasks\n");
+    for (const task of completedTasks) {
+      sections.push(`- [x] ${task.text}`);
     }
-  }
-  return failures;
-}
-
-// src/helpers/gitignore.ts
-init_logger();
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
-async function ensureGitignoreEntry(repoRoot, entry) {
-  const gitignorePath = join3(repoRoot, ".gitignore");
-  let contents = "";
-  try {
-    contents = await readFile2(gitignorePath, "utf8");
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-    } else {
-      log.warn(`Could not read .gitignore: ${String(err)}`);
-      return;
+    for (const task of failedTasks) {
+      sections.push(`- [ ] ${task.text}`);
     }
+    sections.push("");
+  }
+  if (details.labels.length > 0) {
+    sections.push(`**Labels:** ${details.labels.join(", ")}
+`);
+  }
+  if (datasourceName === "github") {
+    sections.push(`Closes #${details.number}`);
+  } else if (datasourceName === "azdevops") {
+    sections.push(`Resolves AB#${details.number}`);
+  }
+  return sections.join("\n");
+}
+async function buildPrTitle(issueTitle, defaultBranch, cwd) {
+  const commits = await getCommitSummaries(defaultBranch, cwd);
+  if (commits.length === 0) {
+    return issueTitle;
+  }
+  if (commits.length === 1) {
+    return commits[0];
+  }
+  return `${commits[commits.length - 1]} (+${commits.length - 1} more)`;
+}
+function buildFeaturePrTitle(featureBranchName, issues) {
+  if (issues.length === 1) {
+    return issues[0].title;
+  }
+  const issueRefs = issues.map((d) => `#${d.number}`).join(", ");
+  return `feat: ${featureBranchName} (${issueRefs})`;
+}
+function buildFeaturePrBody(issues, tasks, results, datasourceName) {
+  const sections = [];
+  sections.push("## Issues\n");
+  for (const issue of issues) {
+    sections.push(`- #${issue.number}: ${issue.title}`);
+  }
+  sections.push("");
+  const taskResults = new Map(results.map((r) => [r.task, r]));
+  const completedTasks = tasks.filter((t) => taskResults.get(t)?.success);
+  const failedTasks = tasks.filter((t) => {
+    const r = taskResults.get(t);
+    return r && !r.success;
+  });
+  if (completedTasks.length > 0 || failedTasks.length > 0) {
+    sections.push("## Tasks\n");
+    for (const task of completedTasks) {
+      sections.push(`- [x] ${task.text}`);
+    }
+    for (const task of failedTasks) {
+      sections.push(`- [ ] ${task.text}`);
+    }
+    sections.push("");
+  }
+  for (const issue of issues) {
+    if (datasourceName === "github") {
+      sections.push(`Closes #${issue.number}`);
+    } else if (datasourceName === "azdevops") {
+      sections.push(`Resolves AB#${issue.number}`);
+    }
+  }
+  return sections.join("\n");
+}
+
+// src/helpers/worktree.ts
+import { join as join4, basename as basename3 } from "path";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+import { randomUUID } from "crypto";
+init_logger();
+var exec6 = promisify6(execFile6);
+var WORKTREE_DIR = ".dispatch/worktrees";
+async function git2(args, cwd) {
+  const { stdout } = await exec6("git", args, { cwd, shell: process.platform === "win32" });
+  return stdout;
+}
+function worktreeName(issueFilename) {
+  const base = basename3(issueFilename);
+  const withoutExt = base.replace(/\.md$/i, "");
+  const match = withoutExt.match(/^(\d+)/);
+  return match ? `issue-${match[1]}` : slugify(withoutExt);
+}
+async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
+  const name = worktreeName(issueFilename);
+  const worktreePath = join4(repoRoot, WORKTREE_DIR, name);
+  try {
+    const args = ["worktree", "add", worktreePath, "-b", branchName];
+    if (startPoint) args.push(startPoint);
+    await git2(args, repoRoot);
+    log.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
+  } catch (err) {
+    const message = log.extractMessage(err);
+    if (message.includes("already exists")) {
+      await git2(["worktree", "add", worktreePath, branchName], repoRoot);
+      log.debug(`Created worktree at ${worktreePath} using existing branch ${branchName}`);
+    } else {
+      throw err;
+    }
+  }
+  return worktreePath;
+}
+async function removeWorktree(repoRoot, issueFilename) {
+  const name = worktreeName(issueFilename);
+  const worktreePath = join4(repoRoot, WORKTREE_DIR, name);
+  try {
+    await git2(["worktree", "remove", worktreePath], repoRoot);
+  } catch {
+    try {
+      await git2(["worktree", "remove", "--force", worktreePath], repoRoot);
+    } catch (err) {
+      log.warn(`Could not remove worktree ${name}: ${log.formatErrorChain(err)}`);
+      return;
+    }
+  }
+  try {
+    await git2(["worktree", "prune"], repoRoot);
+  } catch (err) {
+    log.warn(`Could not prune worktrees: ${log.formatErrorChain(err)}`);
+  }
+}
+function generateFeatureBranchName() {
+  const uuid = randomUUID();
+  const octet = uuid.split("-")[0];
+  return `dispatch/feature-${octet}`;
+}
+
+// src/orchestrator/runner.ts
+init_cleanup();
+init_logger();
+
+// src/helpers/confirm-large-batch.ts
+init_logger();
+import { input } from "@inquirer/prompts";
+import chalk2 from "chalk";
+var LARGE_BATCH_THRESHOLD = 100;
+async function confirmLargeBatch(count, threshold = LARGE_BATCH_THRESHOLD) {
+  if (count <= threshold) return true;
+  log.warn(
+    `This operation will process ${chalk2.bold(String(count))} specs, which exceeds the safety threshold of ${threshold}.`
+  );
+  const answer = await input({
+    message: `Type ${chalk2.bold('"yes"')} to proceed:`
+  });
+  return answer.trim().toLowerCase() === "yes";
+}
+
+// src/helpers/prereqs.ts
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var exec7 = promisify7(execFile7);
+var MIN_NODE_VERSION = "20.12.0";
+function parseSemver(version) {
+  const [major, minor, patch] = version.split(".").map(Number);
+  return [major ?? 0, minor ?? 0, patch ?? 0];
+}
+function semverGte(current, minimum) {
+  const [cMaj, cMin, cPat] = parseSemver(current);
+  const [mMaj, mMin, mPat] = parseSemver(minimum);
+  if (cMaj !== mMaj) return cMaj > mMaj;
+  if (cMin !== mMin) return cMin > mMin;
+  return cPat >= mPat;
+}
+async function checkPrereqs(context) {
+  const failures = [];
+  try {
+    await exec7("git", ["--version"], { shell: process.platform === "win32" });
+  } catch {
+    failures.push("git is required but was not found on PATH. Install it from https://git-scm.com");
+  }
+  const nodeVersion = process.versions.node;
+  if (!semverGte(nodeVersion, MIN_NODE_VERSION)) {
+    failures.push(
+      `Node.js >= ${MIN_NODE_VERSION} is required but found ${nodeVersion}. Please upgrade Node.js`
+    );
+  }
+  if (context?.datasource === "github") {
+    try {
+      await exec7("gh", ["--version"], { shell: process.platform === "win32" });
+    } catch {
+      failures.push(
+        "gh (GitHub CLI) is required for the github datasource but was not found on PATH. Install it from https://cli.github.com/"
+      );
+    }
+  }
+  if (context?.datasource === "azdevops") {
+    try {
+      await exec7("az", ["--version"], { shell: process.platform === "win32" });
+    } catch {
+      failures.push(
+        "az (Azure CLI) is required for the azdevops datasource but was not found on PATH. Install it from https://learn.microsoft.com/en-us/cli/azure/"
+      );
+    }
+  }
+  return failures;
+}
+
+// src/helpers/gitignore.ts
+init_logger();
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join5 } from "path";
+async function ensureGitignoreEntry(repoRoot, entry) {
+  const gitignorePath = join5(repoRoot, ".gitignore");
+  let contents = "";
+  try {
+    contents = await readFile2(gitignorePath, "utf8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+    } else {
+      log.warn(`Could not read .gitignore: ${String(err)}`);
+      return;
+    }
+  }
+  const lines = contents.split(/\r?\n/);
+  const bare = entry.replace(/\/$/, "");
+  const withSlash = bare + "/";
+  if (lines.includes(entry) || lines.includes(bare) || lines.includes(withSlash)) {
+    return;
   }
-  const lines = contents.split(/\r?\n/);
-  const bare = entry.replace(/\/$/, "");
-  const withSlash = bare + "/";
-  if (lines.includes(entry) || lines.includes(bare) || lines.includes(withSlash)) {
-    return;
-  }
   try {
     const separator = contents.length > 0 && !contents.endsWith("\n") ? "\n" : "";
-    await writeFile2(gitignorePath, `${contents}${separator}${entry}
+    await writeFile3(gitignorePath, `${contents}${separator}${entry}
 `, "utf8");
     log.debug(`Added '${entry}' to .gitignore`);
   } catch (err) {
@@ -2093,14 +2449,14 @@ async function ensureGitignoreEntry(repoRoot, entry) {
 
 // src/orchestrator/cli-config.ts
 init_logger();
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { access } from "fs/promises";
 import { constants } from "fs";
 
 // src/config.ts
 init_providers();
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { join as join4, dirname as dirname2 } from "path";
+import { readFile as readFile3, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
+import { join as join6, dirname as dirname3 } from "path";
 
 // src/config-prompts.ts
 init_logger();
@@ -2277,8 +2633,8 @@ var CONFIG_BOUNDS = {
 };
 var CONFIG_KEYS = ["provider", "model", "source", "testTimeout", "planTimeout", "concurrency", "org", "project", "workItemType", "iteration", "area"];
 function getConfigPath(configDir) {
-  const dir = configDir ?? join4(process.cwd(), ".dispatch");
-  return join4(dir, "config.json");
+  const dir = configDir ?? join6(process.cwd(), ".dispatch");
+  return join6(dir, "config.json");
 }
 async function loadConfig(configDir) {
   const configPath = getConfigPath(configDir);
@@ -2291,8 +2647,8 @@ async function loadConfig(configDir) {
 }
 async function saveConfig(config, configDir) {
   const configPath = getConfigPath(configDir);
-  await mkdir2(dirname2(configPath), { recursive: true });
-  await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await mkdir2(dirname3(configPath), { recursive: true });
+  await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 async function handleConfigCommand(_argv, configDir) {
   await runInteractiveConfigWizard(configDir);
@@ -2317,7 +2673,7 @@ function setCliField(target, key, value) {
 }
 async function resolveCliConfig(args) {
   const { explicitFlags } = args;
-  const configDir = join5(args.cwd, ".dispatch");
+  const configDir = join7(args.cwd, ".dispatch");
   const config = await loadConfig(configDir);
   const merged = { ...args };
   for (const configKey of CONFIG_KEYS) {
@@ -2345,7 +2701,7 @@ async function resolveCliConfig(args) {
     }
   }
   const sourceConfigured = explicitFlags.has("issueSource") || config.source !== void 0;
-  const needsSource = !merged.fixTests && !merged.spec && !merged.respec;
+  const needsSource = !(merged.fixTests && merged.issueIds.length === 0) && !merged.spec && !merged.respec;
   if (needsSource && !sourceConfigured) {
     const detected = await detectDatasource(merged.cwd);
     if (detected) {
@@ -2364,17 +2720,18 @@ async function resolveCliConfig(args) {
 }
 
 // src/orchestrator/spec-pipeline.ts
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { mkdir as mkdir4, readFile as readFile5, rename as rename2, unlink as unlink2 } from "fs/promises";
-import { glob } from "glob";
+import { glob as glob2 } from "glob";
 init_providers();
 
 // src/agents/spec.ts
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4, unlink } from "fs/promises";
-import { join as join6, resolve, sep } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile5, unlink } from "fs/promises";
+import { join as join8, resolve as resolve2, sep } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
 init_logger();
 init_file_logger();
+init_environment();
 async function boot5(opts) {
   const { provider } = opts;
   if (!provider) {
@@ -2386,8 +2743,8 @@ async function boot5(opts) {
       const { issue, filePath, fileContent, inlineText, cwd: workingDir, outputPath } = genOpts;
       const startTime = Date.now();
       try {
-        const resolvedCwd = resolve(workingDir);
-        const resolvedOutput = resolve(outputPath);
+        const resolvedCwd = resolve2(workingDir);
+        const resolvedOutput = resolve2(outputPath);
         if (resolvedOutput !== resolvedCwd && !resolvedOutput.startsWith(resolvedCwd + sep)) {
           return {
             data: null,
@@ -2396,10 +2753,10 @@ async function boot5(opts) {
             durationMs: Date.now() - startTime
           };
         }
-        const tmpDir = join6(resolvedCwd, ".dispatch", "tmp");
+        const tmpDir = join8(resolvedCwd, ".dispatch", "tmp");
         await mkdir3(tmpDir, { recursive: true });
-        const tmpFilename = `spec-${randomUUID3()}.md`;
-        const tmpPath = join6(tmpDir, tmpFilename);
+        const tmpFilename = `spec-${randomUUID4()}.md`;
+        const tmpPath = join8(tmpDir, tmpFilename);
         let prompt;
         if (issue) {
           prompt = buildSpecPrompt(issue, workingDir, tmpPath);
@@ -2446,7 +2803,7 @@ async function boot5(opts) {
         if (!validation.valid) {
           log.warn(`Spec validation warning for ${outputPath}: ${validation.reason}`);
         }
-        await writeFile4(resolvedOutput, cleanedContent, "utf-8");
+        await writeFile5(resolvedOutput, cleanedContent, "utf-8");
         log.debug(`Wrote cleaned spec to ${resolvedOutput}`);
         try {
           await unlink(tmpPath);
@@ -2564,6 +2921,8 @@ function buildCommonSpecInstructions(params) {
     ``,
     `\`${cwd}\``,
     ``,
+    formatEnvironmentPrompt(),
+    ``,
     `## Instructions`,
     ``,
     `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
@@ -2799,7 +3158,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 = join7(outputDir, filename);
+  const filepath = join9(outputDir, filename);
   const details = {
     number: filepath,
     title,
@@ -2814,7 +3173,7 @@ function buildInlineTextItem(issues, outputDir) {
   return [{ id: filepath, details }];
 }
 async function resolveFileItems(issues, specCwd, concurrency) {
-  const files = await glob(issues, { cwd: specCwd, absolute: true });
+  const files = await glob2(issues, { cwd: specCwd, absolute: true });
   if (files.length === 0) {
     log.error(`No files matched the pattern "${Array.isArray(issues) ? issues.join(", ") : issues}".`);
     return null;
@@ -2861,7 +3220,7 @@ function previewDryRun(validItems, items, isTrackerMode, isInlineText, outputDir
     let filepath;
     if (isTrackerMode) {
       const slug = slugify(details.title, 60);
-      filepath = join7(outputDir, `${id}-${slug}.md`);
+      filepath = join9(outputDir, `${id}-${slug}.md`);
     } else {
       filepath = id;
     }
@@ -2924,7 +3283,7 @@ async function generateSpecsBatch(validItems, items, specAgent, instance, isTrac
           if (isTrackerMode) {
             const slug = slugify(details.title, MAX_SLUG_LENGTH);
             const filename = `${id}-${slug}.md`;
-            filepath = join7(outputDir, filename);
+            filepath = join9(outputDir, filename);
           } else if (isInlineText) {
             filepath = id;
           } else {
@@ -2953,7 +3312,7 @@ async function generateSpecsBatch(validItems, items, specAgent, instance, isTrac
               const h1Title = extractTitle(result.data.content, filepath);
               const h1Slug = slugify(h1Title, MAX_SLUG_LENGTH);
               const finalFilename = isTrackerMode ? `${id}-${h1Slug}.md` : `${h1Slug}.md`;
-              const finalFilepath = join7(outputDir, finalFilename);
+              const finalFilepath = join9(outputDir, finalFilename);
               if (finalFilepath !== filepath) {
                 await rename2(filepath, finalFilepath);
                 filepath = finalFilepath;
@@ -3058,7 +3417,7 @@ async function runSpecPipeline(opts) {
     model,
     serverUrl,
     cwd: specCwd,
-    outputDir = join7(specCwd, ".dispatch", "specs"),
+    outputDir = join9(specCwd, ".dispatch", "specs"),
     org,
     project,
     workItemType,
@@ -3136,9 +3495,10 @@ async function runSpecPipeline(opts) {
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify9 } from "util";
 import { readFile as readFile7 } from "fs/promises";
+import { glob as glob3 } from "glob";
 
 // src/parser.ts
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 var UNCHECKED_RE = /^(\s*[-*]\s)\[ \]\s+(.+)$/;
 var CHECKED_SUB = "$1[x] $2";
 var MODE_PREFIX_RE = /^\(([PSI])\)\s+/;
@@ -3206,7 +3566,7 @@ async function markTaskComplete(task) {
     );
   }
   lines[lineIndex] = updated;
-  await writeFile5(task.file, lines.join(eol), "utf-8");
+  await writeFile6(task.file, lines.join(eol), "utf-8");
 }
 function groupTasksByMode(tasks) {
   if (tasks.length === 0) return [];
@@ -3237,6 +3597,7 @@ function groupTasksByMode(tasks) {
 // src/agents/planner.ts
 init_logger();
 init_file_logger();
+init_environment();
 async function boot6(opts) {
   const { provider, cwd } = opts;
   if (!provider) {
@@ -3307,6 +3668,10 @@ function buildPlannerPrompt(task, cwd, fileContext, worktreeRoot) {
       `- All relative paths must resolve within the worktree root above.`
     );
   }
+  sections.push(
+    ``,
+    formatEnvironmentPrompt()
+  );
   sections.push(
     ``,
     `## Instructions`,
@@ -3343,6 +3708,7 @@ function buildPlannerPrompt(task, cwd, fileContext, worktreeRoot) {
 // src/dispatcher.ts
 init_logger();
 init_file_logger();
+init_environment();
 async function dispatchTask(instance, task, cwd, plan, worktreeRoot) {
   try {
     log.debug(`Dispatching task: ${task.file}:${task.line} \u2014 ${task.text.slice(0, 80)}`);
@@ -3375,6 +3741,8 @@ function buildPrompt(task, cwd, worktreeRoot) {
     `**Source file:** ${task.file}`,
     `**Task (line ${task.line}):** ${task.text}`,
     ``,
+    getEnvironmentBlock(),
+    ``,
     `Instructions:`,
     `- Complete ONLY this specific task \u2014 do not work on other tasks.`,
     `- Make the minimal, correct changes needed.`,
@@ -3392,6 +3760,8 @@ function buildPlannedPrompt(task, cwd, plan, worktreeRoot) {
     `**Source file:** ${task.file}`,
     `**Task (line ${task.line}):** ${task.text}`,
     ``,
+    getEnvironmentBlock(),
+    ``,
     `---`,
     ``,
     `## Execution Plan`,
@@ -3466,9 +3836,10 @@ ${err.stack}` : ""}`);
 // src/agents/commit.ts
 init_logger();
 init_file_logger();
-import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { join as join8, resolve as resolve2 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+init_environment();
+import { mkdir as mkdir5, writeFile as writeFile7 } from "fs/promises";
+import { join as join10, resolve as resolve3 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 async function boot8(opts) {
   const { provider } = opts;
   if (!provider) {
@@ -3480,11 +3851,11 @@ async function boot8(opts) {
     name: "commit",
     async generate(genOpts) {
       try {
-        const resolvedCwd = resolve2(genOpts.cwd);
-        const tmpDir = join8(resolvedCwd, ".dispatch", "tmp");
+        const resolvedCwd = resolve3(genOpts.cwd);
+        const tmpDir = join10(resolvedCwd, ".dispatch", "tmp");
         await mkdir5(tmpDir, { recursive: true });
-        const tmpFilename = `commit-${randomUUID4()}.md`;
-        const tmpPath = join8(tmpDir, tmpFilename);
+        const tmpFilename = `commit-${randomUUID5()}.md`;
+        const tmpPath = join10(tmpDir, tmpFilename);
         const prompt = buildCommitPrompt(genOpts);
         fileLoggerStorage.getStore()?.prompt("commit", prompt);
         const sessionId = await provider.createSession();
@@ -3512,7 +3883,7 @@ async function boot8(opts) {
           };
         }
         const outputContent = formatOutputFile(parsed);
-        await writeFile6(tmpPath, outputContent, "utf-8");
+        await writeFile7(tmpPath, outputContent, "utf-8");
         log.debug(`Wrote commit agent output to ${tmpPath}`);
         fileLoggerStorage.getStore()?.agentEvent("commit", "completed", `message: ${parsed.commitMessage.slice(0, 80)}`);
         return {
@@ -3542,6 +3913,8 @@ function buildCommitPrompt(opts) {
   const sections = [
     `You are a **commit message agent**. Your job is to analyze the git diff below and generate a meaningful, conventional-commit-compliant commit message, a PR title, and a PR description.`,
     ``,
+    formatEnvironmentPrompt(),
+    ``,
     `## Conventional Commit Guidelines`,
     ``,
     `Follow the Conventional Commits specification (https://www.conventionalcommits.org/):`,
@@ -3662,68 +4035,6 @@ function formatOutputFile(parsed) {
 init_logger();
 init_cleanup();
 
-// src/helpers/worktree.ts
-import { join as join9, basename } from "path";
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
-import { randomUUID as randomUUID5 } from "crypto";
-init_logger();
-var exec7 = promisify7(execFile7);
-var WORKTREE_DIR = ".dispatch/worktrees";
-async function git2(args, cwd) {
-  const { stdout } = await exec7("git", args, { cwd });
-  return stdout;
-}
-function worktreeName(issueFilename) {
-  const base = basename(issueFilename);
-  const withoutExt = base.replace(/\.md$/i, "");
-  const match = withoutExt.match(/^(\d+)/);
-  return match ? `issue-${match[1]}` : slugify(withoutExt);
-}
-async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
-  const name = worktreeName(issueFilename);
-  const worktreePath = join9(repoRoot, WORKTREE_DIR, name);
-  try {
-    const args = ["worktree", "add", worktreePath, "-b", branchName];
-    if (startPoint) args.push(startPoint);
-    await git2(args, repoRoot);
-    log.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
-  } catch (err) {
-    const message = log.extractMessage(err);
-    if (message.includes("already exists")) {
-      await git2(["worktree", "add", worktreePath, branchName], repoRoot);
-      log.debug(`Created worktree at ${worktreePath} using existing branch ${branchName}`);
-    } else {
-      throw err;
-    }
-  }
-  return worktreePath;
-}
-async function removeWorktree(repoRoot, issueFilename) {
-  const name = worktreeName(issueFilename);
-  const worktreePath = join9(repoRoot, WORKTREE_DIR, name);
-  try {
-    await git2(["worktree", "remove", worktreePath], repoRoot);
-  } catch {
-    try {
-      await git2(["worktree", "remove", "--force", worktreePath], repoRoot);
-    } catch (err) {
-      log.warn(`Could not remove worktree ${name}: ${log.formatErrorChain(err)}`);
-      return;
-    }
-  }
-  try {
-    await git2(["worktree", "prune"], repoRoot);
-  } catch (err) {
-    log.warn(`Could not prune worktrees: ${log.formatErrorChain(err)}`);
-  }
-}
-function generateFeatureBranchName() {
-  const uuid = randomUUID5();
-  const octet = uuid.split("-")[0];
-  return `dispatch/feature-${octet}`;
-}
-
 // src/tui.ts
 import chalk6 from "chalk";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -3980,184 +4291,38 @@ function createTui() {
 
 // src/orchestrator/dispatch-pipeline.ts
 init_providers();
-
-// src/orchestrator/datasource-helpers.ts
-init_logger();
-import { basename as basename2, join as join10 } from "path";
-import { mkdtemp, writeFile as writeFile7 } from "fs/promises";
-import { tmpdir } from "os";
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify8 } from "util";
-var exec8 = promisify8(execFile8);
-function parseIssueFilename(filePath) {
-  const filename = basename2(filePath);
-  const match = /^(\d+)-(.+)\.md$/.exec(filename);
-  if (!match) return null;
-  return { issueId: match[1], slug: match[2] };
-}
-async function fetchItemsById(issueIds, datasource4, fetchOpts) {
-  const ids = issueIds.flatMap(
-    (id) => id.split(",").map((s) => s.trim()).filter(Boolean)
-  );
+init_timeout();
+import chalk7 from "chalk";
+init_file_logger();
+var exec9 = promisify9(execFile9);
+async function resolveGlobItems(patterns, cwd) {
+  const files = await glob3(patterns, { cwd, absolute: true });
+  if (files.length === 0) {
+    log.warn(`No files matched the pattern(s): ${patterns.join(", ")}`);
+    return [];
+  }
+  log.info(`Matched ${files.length} file(s) from glob pattern(s)`);
   const items = [];
-  for (const id of ids) {
+  for (const filePath of files) {
     try {
-      const item = await datasource4.fetch(id, fetchOpts);
-      items.push(item);
+      const content = await readFile7(filePath, "utf-8");
+      const title = extractTitle(content, filePath);
+      items.push({
+        number: filePath,
+        title,
+        body: content,
+        labels: [],
+        state: "open",
+        url: filePath,
+        comments: [],
+        acceptanceCriteria: ""
+      });
     } catch (err) {
-      log.warn(`Could not fetch issue #${id}: ${log.formatErrorChain(err)}`);
+      log.warn(`Could not read file ${filePath}: ${log.formatErrorChain(err)}`);
     }
   }
   return items;
 }
-async function writeItemsToTempDir(items) {
-  const tempDir = await mkdtemp(join10(tmpdir(), "dispatch-"));
-  const files = [];
-  const issueDetailsByFile = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const slug = slugify(item.title, MAX_SLUG_LENGTH);
-    const filename = `${item.number}-${slug}.md`;
-    const filepath = join10(tempDir, filename);
-    await writeFile7(filepath, item.body, "utf-8");
-    files.push(filepath);
-    issueDetailsByFile.set(filepath, item);
-  }
-  files.sort((a, b) => {
-    const numA = parseInt(basename2(a).match(/^(\d+)/)?.[1] ?? "0", 10);
-    const numB = parseInt(basename2(b).match(/^(\d+)/)?.[1] ?? "0", 10);
-    if (numA !== numB) return numA - numB;
-    return a.localeCompare(b);
-  });
-  return { files, issueDetailsByFile };
-}
-async function getCommitSummaries(defaultBranch, cwd) {
-  try {
-    const { stdout } = await exec8(
-      "git",
-      ["log", `${defaultBranch}..HEAD`, "--pretty=format:%s"],
-      { cwd }
-    );
-    return stdout.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-async function getBranchDiff(defaultBranch, cwd) {
-  try {
-    const { stdout } = await exec8(
-      "git",
-      ["diff", `${defaultBranch}..HEAD`],
-      { cwd, maxBuffer: 10 * 1024 * 1024 }
-    );
-    return stdout;
-  } catch {
-    return "";
-  }
-}
-async function squashBranchCommits(defaultBranch, message, cwd) {
-  const { stdout } = await exec8(
-    "git",
-    ["merge-base", defaultBranch, "HEAD"],
-    { cwd }
-  );
-  const mergeBase = stdout.trim();
-  await exec8("git", ["reset", "--soft", mergeBase], { cwd });
-  await exec8("git", ["commit", "-m", message], { cwd });
-}
-async function buildPrBody(details, tasks, results, defaultBranch, datasourceName, cwd) {
-  const sections = [];
-  const commits = await getCommitSummaries(defaultBranch, cwd);
-  if (commits.length > 0) {
-    sections.push("## Summary\n");
-    for (const commit of commits) {
-      sections.push(`- ${commit}`);
-    }
-    sections.push("");
-  }
-  const taskResults = new Map(
-    results.filter((r) => tasks.includes(r.task)).map((r) => [r.task, r])
-  );
-  const completedTasks = tasks.filter((t) => taskResults.get(t)?.success);
-  const failedTasks = tasks.filter((t) => {
-    const r = taskResults.get(t);
-    return r && !r.success;
-  });
-  if (completedTasks.length > 0 || failedTasks.length > 0) {
-    sections.push("## Tasks\n");
-    for (const task of completedTasks) {
-      sections.push(`- [x] ${task.text}`);
-    }
-    for (const task of failedTasks) {
-      sections.push(`- [ ] ${task.text}`);
-    }
-    sections.push("");
-  }
-  if (details.labels.length > 0) {
-    sections.push(`**Labels:** ${details.labels.join(", ")}
-`);
-  }
-  if (datasourceName === "github") {
-    sections.push(`Closes #${details.number}`);
-  } else if (datasourceName === "azdevops") {
-    sections.push(`Resolves AB#${details.number}`);
-  }
-  return sections.join("\n");
-}
-async function buildPrTitle(issueTitle, defaultBranch, cwd) {
-  const commits = await getCommitSummaries(defaultBranch, cwd);
-  if (commits.length === 0) {
-    return issueTitle;
-  }
-  if (commits.length === 1) {
-    return commits[0];
-  }
-  return `${commits[commits.length - 1]} (+${commits.length - 1} more)`;
-}
-function buildFeaturePrTitle(featureBranchName, issues) {
-  if (issues.length === 1) {
-    return issues[0].title;
-  }
-  const issueRefs = issues.map((d) => `#${d.number}`).join(", ");
-  return `feat: ${featureBranchName} (${issueRefs})`;
-}
-function buildFeaturePrBody(issues, tasks, results, datasourceName) {
-  const sections = [];
-  sections.push("## Issues\n");
-  for (const issue of issues) {
-    sections.push(`- #${issue.number}: ${issue.title}`);
-  }
-  sections.push("");
-  const taskResults = new Map(results.map((r) => [r.task, r]));
-  const completedTasks = tasks.filter((t) => taskResults.get(t)?.success);
-  const failedTasks = tasks.filter((t) => {
-    const r = taskResults.get(t);
-    return r && !r.success;
-  });
-  if (completedTasks.length > 0 || failedTasks.length > 0) {
-    sections.push("## Tasks\n");
-    for (const task of completedTasks) {
-      sections.push(`- [x] ${task.text}`);
-    }
-    for (const task of failedTasks) {
-      sections.push(`- [ ] ${task.text}`);
-    }
-    sections.push("");
-  }
-  for (const issue of issues) {
-    if (datasourceName === "github") {
-      sections.push(`Closes #${issue.number}`);
-    } else if (datasourceName === "azdevops") {
-      sections.push(`Resolves AB#${issue.number}`);
-    }
-  }
-  return sections.join("\n");
-}
-
-// src/orchestrator/dispatch-pipeline.ts
-init_timeout();
-import chalk7 from "chalk";
-init_file_logger();
-var exec9 = promisify9(execFile9);
 var DEFAULT_PLAN_TIMEOUT_MIN = 10;
 var DEFAULT_PLAN_RETRIES = 1;
 async function runDispatchPipeline(opts, cwd) {
@@ -4223,7 +4388,14 @@ async function runDispatchPipeline(opts, cwd) {
     }
     const datasource4 = getDatasource(source);
     const fetchOpts = { cwd, org, project, workItemType, iteration, area };
-    const items = issueIds.length > 0 ? await fetchItemsById(issueIds, datasource4, fetchOpts) : await datasource4.list(fetchOpts);
+    let items;
+    if (issueIds.length > 0 && source === "md" && issueIds.some((id) => isGlobOrFilePath(id))) {
+      items = await resolveGlobItems(issueIds, cwd);
+    } else if (issueIds.length > 0) {
+      items = await fetchItemsById(issueIds, datasource4, fetchOpts);
+    } else {
+      items = await datasource4.list(fetchOpts);
+    }
     if (items.length === 0) {
       tui.state.phase = "done";
       tui.stop();
@@ -4295,12 +4467,32 @@ async function runDispatchPipeline(opts, cwd) {
     let featureBranchName;
     let featureDefaultBranch;
     if (feature) {
+      if (typeof feature === "string") {
+        if (!isValidBranchName(feature)) {
+          log.error(`Invalid feature branch name: "${feature}"`);
+          tui.state.phase = "done";
+          tui.stop();
+          return { total: allTasks.length, completed: 0, failed: allTasks.length, skipped: 0, results: [] };
+        }
+        featureBranchName = feature.includes("/") ? feature : `dispatch/${feature}`;
+      } else {
+        featureBranchName = generateFeatureBranchName();
+      }
       try {
         featureDefaultBranch = await datasource4.getDefaultBranch(lifecycleOpts);
         await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
-        featureBranchName = generateFeatureBranchName();
-        await datasource4.createAndSwitchBranch(featureBranchName, lifecycleOpts);
-        log.debug(`Created feature branch ${featureBranchName} from ${featureDefaultBranch}`);
+        try {
+          await datasource4.createAndSwitchBranch(featureBranchName, lifecycleOpts);
+          log.debug(`Created feature branch ${featureBranchName} from ${featureDefaultBranch}`);
+        } catch (createErr) {
+          const message = log.extractMessage(createErr);
+          if (message.includes("already exists")) {
+            await datasource4.switchBranch(featureBranchName, lifecycleOpts);
+            log.debug(`Switched to existing feature branch ${featureBranchName}`);
+          } else {
+            throw createErr;
+          }
+        }
         registerCleanup(async () => {
           try {
             await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
@@ -4492,12 +4684,18 @@ ${err.stack}` : ""}`);
                   fileLogger?.info(`Execution completed successfully (${Date.now() - startTime}ms)`);
                   try {
                     const parsed = parseIssueFilename(task.file);
+                    const updatedContent = await readFile7(task.file, "utf-8");
                     if (parsed) {
-                      const updatedContent = await readFile7(task.file, "utf-8");
                       const issueDetails = issueDetailsByFile.get(task.file);
                       const title = issueDetails?.title ?? parsed.slug;
                       await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
                       log.success(`Synced task completion to issue #${parsed.issueId}`);
+                    } else {
+                      const issueDetails = issueDetailsByFile.get(task.file);
+                      if (issueDetails) {
+                        await datasource4.update(issueDetails.number, issueDetails.title, updatedContent, fetchOpts);
+                        log.success(`Synced task completion to issue #${issueDetails.number}`);
+                      }
                     }
                   } catch (err) {
                     log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
@@ -4584,13 +4782,13 @@ ${err.stack}` : ""}`);
             }
             try {
               await datasource4.switchBranch(featureBranchName, lifecycleOpts);
-              await exec9("git", ["merge", branchName, "--no-ff", "-m", `merge: issue #${details.number}`], { cwd });
+              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", ["merge", "--abort"], { cwd });
+                await exec9("git", ["merge", "--abort"], { cwd, shell: process.platform === "win32" });
               } catch {
               }
               for (const task of fileTasks) {
@@ -4608,7 +4806,7 @@ ${err.stack}` : ""}`);
               return;
             }
             try {
-              await exec9("git", ["branch", "-d", branchName], { cwd });
+              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)}`);
@@ -4764,13 +4962,20 @@ async function dryRunMode(issueIds, cwd, source, org, project, workItemType, ite
     username = await datasource4.getUsername(lifecycleOpts);
   } catch {
   }
-  const items = issueIds.length > 0 ? await fetchItemsById(issueIds, datasource4, fetchOpts) : await datasource4.list(fetchOpts);
+  let items;
+  if (issueIds.length > 0 && source === "md" && issueIds.some((id) => isGlobOrFilePath(id))) {
+    items = await resolveGlobItems(issueIds, cwd);
+  } else if (issueIds.length > 0) {
+    items = await fetchItemsById(issueIds, datasource4, fetchOpts);
+  } else {
+    items = await datasource4.list(fetchOpts);
+  }
   if (items.length === 0) {
     const label = issueIds.length > 0 ? `issue(s) ${issueIds.join(", ")}` : `datasource: ${source}`;
     log.warn("No work items found from " + label);
     return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
   }
-  const { files } = await writeItemsToTempDir(items);
+  const { files, issueDetailsByFile } = await writeItemsToTempDir(items);
   const taskFiles = [];
   for (const file of files) {
     const tf = await parseTaskFile(file);
@@ -4787,7 +4992,7 @@ async function dryRunMode(issueIds, cwd, source, org, project, workItemType, ite
 `);
   for (const task of allTasks) {
     const parsed = parseIssueFilename(task.file);
-    const details = parsed ? items.find((item) => item.number === parsed.issueId) : void 0;
+    const details = parsed ? items.find((item) => item.number === parsed.issueId) : issueDetailsByFile.get(task.file);
     const branchInfo = details ? ` [branch: ${datasource4.buildBranchName(details.number, details.title, username)}]` : "";
     log.task(allTasks.indexOf(task), allTasks.length, `${task.file}:${task.line} \u2014 ${task.text}${branchInfo}`);
   }
@@ -4801,6 +5006,58 @@ async function dryRunMode(issueIds, cwd, source, org, project, workItemType, ite
 }
 
 // src/orchestrator/runner.ts
+async function runMultiIssueFixTests(opts) {
+  const { runFixTestsPipeline: runFixTestsPipeline2 } = await Promise.resolve().then(() => (init_fix_tests_pipeline(), fix_tests_pipeline_exports));
+  const datasource4 = getDatasource(opts.source);
+  const fetchOpts = { cwd: opts.cwd, org: opts.org, project: opts.project };
+  const items = await fetchItemsById(opts.issueIds, datasource4, fetchOpts);
+  if (items.length === 0) {
+    log.warn("No issues found for the given IDs");
+    return { mode: "fix-tests", success: false, error: "No issues found" };
+  }
+  let username = "";
+  try {
+    username = await datasource4.getUsername({ cwd: opts.cwd });
+  } catch (err) {
+    log.warn(`Could not resolve git username for branch naming: ${log.formatErrorChain(err)}`);
+  }
+  log.info(`Running fix-tests for ${items.length} issue(s) in worktrees`);
+  const issueResults = [];
+  for (const item of items) {
+    const branchName = datasource4.buildBranchName(item.number, item.title, username);
+    const issueFilename = `${item.number}-fix-tests.md`;
+    let worktreePath;
+    try {
+      worktreePath = await createWorktree(opts.cwd, issueFilename, branchName);
+      registerCleanup(async () => {
+        await removeWorktree(opts.cwd, issueFilename);
+      });
+      log.info(`Created worktree for issue #${item.number} at ${worktreePath}`);
+      const result = await runFixTestsPipeline2({
+        cwd: worktreePath,
+        provider: opts.provider,
+        serverUrl: opts.serverUrl,
+        verbose: opts.verbose,
+        testTimeout: opts.testTimeout
+      });
+      issueResults.push({ issueId: item.number, branch: branchName, success: result.success, error: result.error });
+    } catch (err) {
+      const message = log.extractMessage(err);
+      log.error(`Fix-tests failed for issue #${item.number}: ${message}`);
+      issueResults.push({ issueId: item.number, branch: branchName, success: false, error: message });
+    } finally {
+      if (worktreePath) {
+        try {
+          await removeWorktree(opts.cwd, issueFilename);
+        } catch (err) {
+          log.warn(`Could not remove worktree for issue #${item.number}: ${log.formatErrorChain(err)}`);
+        }
+      }
+    }
+  }
+  const allSuccess = issueResults.length > 0 && issueResults.every((r) => r.success);
+  return { mode: "fix-tests", success: allSuccess, issueResults };
+}
 async function boot9(opts) {
   const { cwd } = opts;
   const runner = {
@@ -4813,7 +5070,25 @@ async function boot9(opts) {
       }
       if (opts2.mode === "fix-tests") {
         const { runFixTestsPipeline: runFixTestsPipeline2 } = await Promise.resolve().then(() => (init_fix_tests_pipeline(), fix_tests_pipeline_exports));
-        return runFixTestsPipeline2({ cwd, provider: "opencode", serverUrl: void 0, verbose: false, testTimeout: opts2.testTimeout });
+        if (!opts2.issueIds || opts2.issueIds.length === 0) {
+          return runFixTestsPipeline2({ cwd, provider: opts2.provider ?? "opencode", serverUrl: opts2.serverUrl, verbose: opts2.verbose ?? false, testTimeout: opts2.testTimeout });
+        }
+        const source = opts2.source;
+        if (!source) {
+          log.error("No datasource configured for multi-issue fix-tests.");
+          return { mode: "fix-tests", success: false, error: "No datasource configured" };
+        }
+        return runMultiIssueFixTests({
+          cwd,
+          issueIds: opts2.issueIds,
+          source,
+          provider: opts2.provider ?? "opencode",
+          serverUrl: opts2.serverUrl,
+          verbose: opts2.verbose ?? false,
+          testTimeout: opts2.testTimeout,
+          org: opts2.org,
+          project: opts2.project
+        });
       }
       const { mode: _, ...rest } = opts2;
       return runner.orchestrate(rest);
@@ -4842,13 +5117,27 @@ async function boot9(opts) {
         log.error("--feature and --no-branch are mutually exclusive");
         process.exit(1);
       }
-      if (m.fixTests && m.issueIds.length > 0) {
-        log.error("--fix-tests cannot be combined with issue IDs");
-        process.exit(1);
-      }
       if (m.fixTests) {
         const { runFixTestsPipeline: runFixTestsPipeline2 } = await Promise.resolve().then(() => (init_fix_tests_pipeline(), fix_tests_pipeline_exports));
-        return runFixTestsPipeline2({ cwd: m.cwd, provider: m.provider, serverUrl: m.serverUrl, verbose: m.verbose, testTimeout: m.testTimeout });
+        if (m.issueIds.length === 0) {
+          return runFixTestsPipeline2({ cwd: m.cwd, provider: m.provider, serverUrl: m.serverUrl, verbose: m.verbose, testTimeout: m.testTimeout });
+        }
+        const source = m.issueSource;
+        if (!source) {
+          log.error("No datasource configured. Use --source or run 'dispatch config' to set up defaults.");
+          process.exit(1);
+        }
+        return runMultiIssueFixTests({
+          cwd: m.cwd,
+          issueIds: m.issueIds,
+          source,
+          provider: m.provider,
+          serverUrl: m.serverUrl,
+          verbose: m.verbose,
+          testTimeout: m.testTimeout,
+          org: m.org,
+          project: m.project
+        });
       }
       if (m.spec) {
         return this.generateSpecs({
@@ -4954,13 +5243,14 @@ var HELP = `
     dispatch --respec <glob>         Regenerate specs matching a glob pattern
     dispatch --spec "description"    Generate a spec from an inline text description
     dispatch --fix-tests             Run tests and fix failures via AI agent
+    dispatch --fix-tests <ids>       Fix tests on specific issue branches (in worktrees)
 
   Dispatch options:
     --dry-run              List tasks without dispatching (also works with --spec)
     --no-plan              Skip the planner agent, dispatch directly
     --no-branch            Skip branch creation, push, and PR lifecycle
     --no-worktree          Skip git worktree isolation for parallel issues
-    --feature              Group issues into a single feature branch and PR
+    --feature [name]       Group issues into a single feature branch and PR
     --force              Ignore prior run state and re-run all tasks
     --concurrency <n>      Max parallel dispatches (default: min(cpus, freeMB/500), max: ${MAX_CONCURRENCY})
     --provider <name>      Agent backend: ${PROVIDER_NAMES.join(", ")} (default: opencode)
@@ -5006,6 +5296,12 @@ var HELP = `
     dispatch --respec "specs/*.md"
     dispatch --spec "add dark mode toggle to settings page"
     dispatch --spec "feature A should do x" --provider copilot
+    dispatch --feature
+    dispatch --feature my-feature
+    dispatch --fix-tests
+    dispatch --fix-tests 14
+    dispatch --fix-tests 14 15 16
+    dispatch --fix-tests 14,15,16
     dispatch config
 `.trimStart();
 function parseArgs(argv) {
@@ -5015,7 +5311,7 @@ function parseArgs(argv) {
     },
     writeErr: () => {
     }
-  }).helpOption(false).argument("[issueIds...]").option("-h, --help", "Show help").option("-v, --version", "Show version").option("--dry-run", "List tasks without dispatching").option("--no-plan", "Skip the planner agent").option("--no-branch", "Skip branch creation").option("--no-worktree", "Skip git worktree isolation").option("--feature", "Group issues into a single feature branch").option("--force", "Ignore prior run state").option("--verbose", "Show detailed debug output").option("--fix-tests", "Run tests and fix failures").option("--spec <values...>", "Spec mode: issue numbers, glob, or text").option("--respec [values...]", "Regenerate specs").addOption(
+  }).helpOption(false).argument("[issueIds...]").option("-h, --help", "Show help").option("-v, --version", "Show version").option("--dry-run", "List tasks without dispatching").option("--no-plan", "Skip the planner agent").option("--no-branch", "Skip branch creation").option("--no-worktree", "Skip git worktree isolation").option("--feature [name]", "Group issues into a single feature branch").option("--force", "Ignore prior run state").option("--verbose", "Show detailed debug output").option("--fix-tests", "Run tests and fix failures (optionally pass issue IDs to target specific branches)").option("--spec <values...>", "Spec mode: issue numbers, glob, or text").option("--respec [values...]", "Regenerate specs").addOption(
     new Option("--provider <name>", "Agent backend").choices(PROVIDER_NAMES)
   ).addOption(
     new Option("--source <name>", "Issue source").choices(
@@ -5063,7 +5359,7 @@ function parseArgs(argv) {
       if (isNaN(n) || n <= 0) throw new CommanderError(1, "commander.invalidArgument", "--test-timeout must be a positive number (minutes)");
       return n;
     }
-  ).option("--cwd <dir>", "Working directory", (val) => resolve3(val)).option("--output-dir <dir>", "Output directory", (val) => resolve3(val)).option("--org <url>", "Azure DevOps organization URL").option("--project <name>", "Azure DevOps project name").option("--server-url <url>", "Provider server URL");
+  ).option("--cwd <dir>", "Working directory", (val) => resolve4(val)).option("--output-dir <dir>", "Output directory", (val) => resolve4(val)).option("--org <url>", "Azure DevOps organization URL").option("--project <name>", "Azure DevOps project name").option("--server-url <url>", "Provider server URL");
   try {
     program.parse(argv, { from: "user" });
   } catch (err) {
@@ -5098,7 +5394,7 @@ function parseArgs(argv) {
     }
   }
   if (opts.fixTests) args.fixTests = true;
-  if (opts.feature) args.feature = true;
+  if (opts.feature) args.feature = opts.feature;
   if (opts.source !== void 0) args.issueSource = opts.source;
   if (opts.concurrency !== void 0) args.concurrency = opts.concurrency;
   if (opts.serverUrl !== void 0) args.serverUrl = opts.serverUrl;
@@ -5148,7 +5444,7 @@ async function main() {
   if (rawArgv[0] === "config") {
     const configProgram = new Command("dispatch-config").exitOverride().configureOutput({ writeOut: () => {
     }, writeErr: () => {
-    } }).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).option("--cwd <dir>", "Working directory", (v) => resolve3(v));
+    } }).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).option("--cwd <dir>", "Working directory", (v) => resolve4(v));
     try {
       configProgram.parse(rawArgv.slice(1), { from: "user" });
     } catch (err) {
@@ -5179,7 +5475,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.3.1"}`);
+    console.log(`dispatch v${"1.4.1"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });