@pruddiman/dispatch 0.0.1 → 1.3.0

package/dist/cli.js

@@ -9,42 +9,156 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/helpers/file-logger.ts
+import { mkdirSync, writeFileSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+import { AsyncLocalStorage } from "async_hooks";
+var fileLoggerStorage, FileLogger;
+var init_file_logger = __esm({
+  "src/helpers/file-logger.ts"() {
+    "use strict";
+    fileLoggerStorage = new AsyncLocalStorage();
+    FileLogger = class _FileLogger {
+      filePath;
+      static sanitizeIssueId(issueId) {
+        const raw = String(issueId);
+        return raw.replace(/[^a-zA-Z0-9._-]/g, "_");
+      }
+      constructor(issueId, cwd) {
+        const safeIssueId = _FileLogger.sanitizeIssueId(issueId);
+        this.filePath = join(cwd, ".dispatch", "logs", `issue-${safeIssueId}.log`);
+        mkdirSync(dirname(this.filePath), { recursive: true });
+        writeFileSync(this.filePath, "", "utf-8");
+      }
+      write(level, message) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const line = `[${timestamp}] [${level}] ${message}
+`;
+        appendFileSync(this.filePath, line, "utf-8");
+      }
+      info(message) {
+        this.write("INFO", message);
+      }
+      debug(message) {
+        this.write("DEBUG", message);
+      }
+      warn(message) {
+        this.write("WARN", message);
+      }
+      error(message) {
+        this.write("ERROR", message);
+      }
+      success(message) {
+        this.write("SUCCESS", message);
+      }
+      task(message) {
+        this.write("TASK", message);
+      }
+      dim(message) {
+        this.write("DIM", message);
+      }
+      prompt(label, content) {
+        const separator = "\u2500".repeat(40);
+        this.write("PROMPT", `${label}
+${separator}
+${content}
+${separator}`);
+      }
+      response(label, content) {
+        const separator = "\u2500".repeat(40);
+        this.write("RESPONSE", `${label}
+${separator}
+${content}
+${separator}`);
+      }
+      phase(name) {
+        const banner = "\u2550".repeat(40);
+        this.write("PHASE", `${banner}
+${name}
+${banner}`);
+      }
+      agentEvent(agent, event, detail) {
+        const msg = detail ? `[${agent}] ${event}: ${detail}` : `[${agent}] ${event}`;
+        this.write("AGENT", msg);
+      }
+      close() {
+      }
+    };
+  }
+});
+
 // src/helpers/logger.ts
 import chalk from "chalk";
-var MAX_CAUSE_CHAIN_DEPTH, log;
+function resolveLogLevel() {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+  if (envLevel && Object.hasOwn(LOG_LEVEL_SEVERITY, envLevel)) {
+    return envLevel;
+  }
+  if (process.env.DEBUG) {
+    return "debug";
+  }
+  return "info";
+}
+function shouldLog(level) {
+  return LOG_LEVEL_SEVERITY[level] >= LOG_LEVEL_SEVERITY[currentLevel];
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+var LOG_LEVEL_SEVERITY, currentLevel, MAX_CAUSE_CHAIN_DEPTH, log;
 var init_logger = __esm({
   "src/helpers/logger.ts"() {
     "use strict";
+    init_file_logger();
+    LOG_LEVEL_SEVERITY = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    currentLevel = resolveLogLevel();
     MAX_CAUSE_CHAIN_DEPTH = 5;
     log = {
-      /** When true, `debug()` messages are printed. Set by `--verbose`. */
       verbose: false,
       info(msg) {
+        if (!shouldLog("info")) return;
         console.log(chalk.blue("\u2139"), msg);
+        fileLoggerStorage.getStore()?.info(stripAnsi(msg));
       },
       success(msg) {
+        if (!shouldLog("info")) return;
         console.log(chalk.green("\u2714"), msg);
+        fileLoggerStorage.getStore()?.success(stripAnsi(msg));
       },
       warn(msg) {
-        console.log(chalk.yellow("\u26A0"), msg);
+        if (!shouldLog("warn")) return;
+        console.error(chalk.yellow("\u26A0"), msg);
+        fileLoggerStorage.getStore()?.warn(stripAnsi(msg));
       },
       error(msg) {
+        if (!shouldLog("error")) return;
         console.error(chalk.red("\u2716"), msg);
+        fileLoggerStorage.getStore()?.error(stripAnsi(msg));
       },
       task(index, total, msg) {
+        if (!shouldLog("info")) return;
         console.log(chalk.cyan(`[${index + 1}/${total}]`), msg);
+        fileLoggerStorage.getStore()?.task(stripAnsi(`[${index + 1}/${total}] ${msg}`));
       },
       dim(msg) {
+        if (!shouldLog("info")) return;
         console.log(chalk.dim(msg));
+        fileLoggerStorage.getStore()?.dim(stripAnsi(msg));
       },
       /**
-       * Print a debug/verbose message. Only visible when `log.verbose` is true.
-       * Messages are prefixed with a dim arrow to visually nest them under the
-       * preceding info/error line.
+       * Print a debug/verbose message. Only visible when the log level is
+       * `"debug"`. Messages are prefixed with a dim arrow to visually nest
+       * them under the preceding info/error line.
        */
       debug(msg) {
-        if (!this.verbose) return;
+        if (!shouldLog("debug")) return;
         console.log(chalk.dim(`  \u2937 ${msg}`));
+        fileLoggerStorage.getStore()?.debug(stripAnsi(msg));
       },
       /**
        * Extract and format the full error cause chain. Node.js network errors
@@ -83,6 +197,26 @@ var init_logger = __esm({
         return "";
       }
     };
+    Object.defineProperty(log, "verbose", {
+      get() {
+        return currentLevel === "debug";
+      },
+      set(value) {
+        currentLevel = value ? "debug" : "info";
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+});
+
+// src/helpers/guards.ts
+function hasProperty(value, key) {
+  return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, key);
+}
+var init_guards = __esm({
+  "src/helpers/guards.ts"() {
+    "use strict";
   }
 });
 
@@ -183,6 +317,7 @@ async function boot(opts) {
     },
     async prompt(sessionId, text) {
       log.debug(`Sending async prompt to session ${sessionId} (${text.length} chars)...`);
+      let controller;
       try {
         const { error: promptError } = await client.session.promptAsync({
           path: { id: sessionId },
@@ -195,11 +330,11 @@ async function boot(opts) {
           throw new Error(`OpenCode promptAsync failed: ${JSON.stringify(promptError)}`);
         }
         log.debug("Async prompt accepted, subscribing to events...");
-        const controller = new AbortController();
-        const { stream } = await client.event.subscribe({
-          signal: controller.signal
-        });
+        controller = new AbortController();
         try {
+          const { stream } = await client.event.subscribe({
+            signal: controller.signal
+          });
           for await (const event of stream) {
             if (!isSessionEvent(event, sessionId)) continue;
             if (event.type === "message.part.updated" && event.properties.part.type === "text") {
@@ -221,7 +356,7 @@ async function boot(opts) {
             }
           }
         } finally {
-          controller.abort();
+          if (controller && !controller.signal.aborted) controller.abort();
         }
         const { data: messages } = await client.session.messages({
           path: { id: sessionId }
@@ -235,7 +370,7 @@ async function boot(opts) {
           log.debug("No assistant message found in session");
           return null;
         }
-        if (lastAssistant.info.role === "assistant" && "error" in lastAssistant.info && lastAssistant.info.error) {
+        if (hasProperty(lastAssistant.info, "error") && lastAssistant.info.error) {
           throw new Error(
             `OpenCode assistant error: ${JSON.stringify(lastAssistant.info.error)}`
           );
@@ -265,11 +400,14 @@ async function boot(opts) {
 }
 function isSessionEvent(event, sessionId) {
   const props = event.properties;
-  if (props.sessionID === sessionId) return true;
-  if (props.info && typeof props.info === "object" && props.info.sessionID === sessionId) {
+  if (!hasProperty(props, "sessionID") && !hasProperty(props, "info") && !hasProperty(props, "part")) {
+    return false;
+  }
+  if (hasProperty(props, "sessionID") && props.sessionID === sessionId) return true;
+  if (hasProperty(props, "info") && hasProperty(props.info, "sessionID") && props.info.sessionID === sessionId) {
     return true;
   }
-  if (props.part && typeof props.part === "object" && props.part.sessionID === sessionId) {
+  if (hasProperty(props, "part") && hasProperty(props.part, "sessionID") && props.part.sessionID === sessionId) {
     return true;
   }
   return false;
@@ -278,6 +416,52 @@ var init_opencode = __esm({
   "src/providers/opencode.ts"() {
     "use strict";
     init_logger();
+    init_guards();
+  }
+});
+
+// src/helpers/timeout.ts
+function withTimeout(promise, ms, label) {
+  const p = new Promise((resolve4, 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);
+        resolve4(value);
+      },
+      (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+  p.catch(() => {
+  });
+  return p;
+}
+var TimeoutError;
+var init_timeout = __esm({
+  "src/helpers/timeout.ts"() {
+    "use strict";
+    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;
+      }
+    };
   }
 });
 
@@ -354,18 +538,25 @@ async function boot2(opts) {
       try {
         await session.send({ prompt: text });
         log.debug("Async prompt accepted, waiting for session to become idle...");
-        await new Promise((resolve2, reject) => {
-          const unsubIdle = session.on("session.idle", () => {
-            unsubIdle();
-            unsubErr();
-            resolve2();
-          });
-          const unsubErr = session.on("session.error", (event) => {
-            unsubIdle();
-            unsubErr();
-            reject(new Error(`Copilot session error: ${event.data.message}`));
-          });
-        });
+        let unsubIdle;
+        let unsubErr;
+        try {
+          await withTimeout(
+            new Promise((resolve4, reject) => {
+              unsubIdle = session.on("session.idle", () => {
+                resolve4();
+              });
+              unsubErr = session.on("session.error", (event) => {
+                reject(new Error(`Copilot session error: ${event.data.message}`));
+              });
+            }),
+            3e5,
+            "copilot session ready"
+          );
+        } finally {
+          unsubIdle?.();
+          unsubErr?.();
+        }
         log.debug("Session went idle, fetching result...");
         const events = await session.getMessages();
         const last = [...events].reverse().find((e) => e.type === "assistant.message");
@@ -396,6 +587,7 @@ var init_copilot = __esm({
   "src/providers/copilot.ts"() {
     "use strict";
     init_logger();
+    init_timeout();
   }
 });
 
@@ -502,7 +694,8 @@ async function boot4(opts) {
           model,
           config: { model, instructions: "" },
           approvalPolicy: "full-auto",
-          additionalWritableRoots: opts?.cwd ? [opts.cwd] : [],
+          ...opts?.cwd ? { rootDir: opts.cwd } : {},
+          additionalWritableRoots: [],
           getCommandConfirmation: async () => ({ approved: true }),
           onItem: () => {
           },
@@ -567,7 +760,9 @@ import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
 async function checkProviderInstalled(name) {
   try {
-    await exec6(PROVIDER_BINARIES[name], ["--version"]);
+    await exec6(PROVIDER_BINARIES[name], ["--version"], {
+      shell: process.platform === "win32"
+    });
     return true;
   } catch {
     return false;
@@ -661,11 +856,11 @@ __export(fix_tests_pipeline_exports, {
   runTestCommand: () => runTestCommand
 });
 import { readFile as readFile8 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { execFile as execFileCb } from "child_process";
 async function detectTestCommand(cwd) {
   try {
-    const raw = await readFile8(join10(cwd, "package.json"), "utf-8");
+    const raw = await readFile8(join11(cwd, "package.json"), "utf-8");
     let pkg;
     try {
       pkg = JSON.parse(raw);
@@ -685,7 +880,7 @@ async function detectTestCommand(cwd) {
   }
 }
 function runTestCommand(command, cwd) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const [cmd, ...args] = command.split(" ");
     execFileCb(
       cmd,
@@ -693,7 +888,7 @@ function runTestCommand(command, cwd) {
       { cwd, maxBuffer: 10 * 1024 * 1024 },
       (error, stdout, stderr) => {
         const exitCode = error && "code" in error ? error.code ?? 1 : error ? 1 : 0;
-        resolve2({ exitCode, stdout, stderr, command });
+        resolve4({ exitCode, stdout, stderr, command });
       }
     );
   });
@@ -740,46 +935,66 @@ async function runFixTestsPipeline(opts) {
     log.dim(`  Working directory: ${cwd}`);
     return { mode: "fix-tests", success: false };
   }
-  try {
-    log.info("Running test suite...");
-    const testResult = await runTestCommand(testCommand, cwd);
-    if (testResult.exitCode === 0) {
-      log.success("All tests pass \u2014 nothing to fix.");
-      return { mode: "fix-tests", success: true };
-    }
-    log.warn(
-      `Tests failed (exit code ${testResult.exitCode}). Dispatching AI to fix...`
-    );
-    const provider = opts.provider ?? "opencode";
-    const instance = await bootProvider(provider, { url: opts.serverUrl, cwd });
-    registerCleanup(() => instance.cleanup());
-    const prompt = buildFixTestsPrompt(testResult, cwd);
-    log.debug(`Prompt built (${prompt.length} chars)`);
-    const sessionId = await instance.createSession();
-    const response = await instance.prompt(sessionId, prompt);
-    if (response === null) {
-      log.error("No response from AI agent.");
+  const fileLogger = opts.verbose ? new FileLogger("fix-tests", cwd) : null;
+  const pipelineBody = async () => {
+    try {
+      log.info("Running test suite...");
+      const testResult = await runTestCommand(testCommand, cwd);
+      fileLoggerStorage.getStore()?.info(`Test run complete (exit code: ${testResult.exitCode})`);
+      if (testResult.exitCode === 0) {
+        log.success("All tests pass \u2014 nothing to fix.");
+        return { mode: "fix-tests", success: true };
+      }
+      log.warn(
+        `Tests failed (exit code ${testResult.exitCode}). Dispatching AI to fix...`
+      );
+      const provider = opts.provider ?? "opencode";
+      const instance = await bootProvider(provider, { url: opts.serverUrl, cwd });
+      registerCleanup(() => instance.cleanup());
+      const prompt = buildFixTestsPrompt(testResult, cwd);
+      log.debug(`Prompt built (${prompt.length} chars)`);
+      fileLoggerStorage.getStore()?.prompt("fix-tests", prompt);
+      const sessionId = await instance.createSession();
+      const response = await instance.prompt(sessionId, prompt);
+      if (response === null) {
+        fileLoggerStorage.getStore()?.error("No response from AI agent.");
+        log.error("No response from AI agent.");
+        await instance.cleanup();
+        return { mode: "fix-tests", success: false, error: "No response from agent" };
+      }
+      if (response) fileLoggerStorage.getStore()?.response("fix-tests", response);
+      log.success("AI agent completed fixes.");
+      fileLoggerStorage.getStore()?.phase("Verification");
+      log.info("Re-running tests to verify fixes...");
+      const verifyResult = await runTestCommand(testCommand, cwd);
       await instance.cleanup();
-      return { mode: "fix-tests", success: false, error: "No response from agent" };
-    }
-    log.success("AI agent completed fixes.");
-    log.info("Re-running tests to verify fixes...");
-    const verifyResult = await runTestCommand(testCommand, cwd);
-    await instance.cleanup();
-    if (verifyResult.exitCode === 0) {
-      log.success("All tests pass after fixes!");
-      return { mode: "fix-tests", success: true };
+      fileLoggerStorage.getStore()?.info(`Verification result: exit code ${verifyResult.exitCode}`);
+      if (verifyResult.exitCode === 0) {
+        log.success("All tests pass after fixes!");
+        return { mode: "fix-tests", success: true };
+      }
+      log.warn(
+        `Tests still failing after fix attempt (exit code ${verifyResult.exitCode}).`
+      );
+      return { mode: "fix-tests", success: false, error: "Tests still failing after fix attempt" };
+    } catch (err) {
+      const message = log.extractMessage(err);
+      fileLoggerStorage.getStore()?.error(`Fix-tests pipeline failed: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
+      log.error(`Fix-tests pipeline failed: ${log.formatErrorChain(err)}`);
+      return { mode: "fix-tests", success: false, error: message };
     }
-    log.warn(
-      `Tests still failing after fix attempt (exit code ${verifyResult.exitCode}).`
-    );
-    return { mode: "fix-tests", success: false, error: "Tests still failing after fix attempt" };
-  } catch (err) {
-    const message = log.extractMessage(err);
-    log.error(`Fix-tests pipeline failed: ${log.formatErrorChain(err)}`);
-    log.debug(log.formatErrorChain(err));
-    return { mode: "fix-tests", success: false, error: message };
+  };
+  if (fileLogger) {
+    return fileLoggerStorage.run(fileLogger, async () => {
+      try {
+        return await pipelineBody();
+      } finally {
+        fileLogger.close();
+      }
+    });
   }
+  return pipelineBody();
 }
 var init_fix_tests_pipeline = __esm({
   "src/orchestrator/fix-tests-pipeline.ts"() {
@@ -787,11 +1002,13 @@ var init_fix_tests_pipeline = __esm({
     init_providers();
     init_cleanup();
     init_logger();
+    init_file_logger();
   }
 });
 
 // src/cli.ts
-import { resolve, join as join11 } from "path";
+import { resolve as resolve3, join as join12 } from "path";
+import { Command, Option, CommanderError } from "commander";
 
 // src/spec-generator.ts
 import { cpus, freemem } from "os";
@@ -806,14 +1023,21 @@ import { promisify } from "util";
 
 // src/helpers/slugify.ts
 var MAX_SLUG_LENGTH = 60;
-function slugify(input2, maxLength) {
-  const slug = input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function slugify(input3, maxLength) {
+  const slug = input3.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   return maxLength != null ? slug.slice(0, maxLength) : slug;
 }
 
 // src/datasources/github.ts
 init_logger();
 var exec = promisify(execFile);
+var InvalidBranchNameError = class extends Error {
+  constructor(branch, reason) {
+    const detail = reason ? ` (${reason})` : "";
+    super(`Invalid branch name: "${branch}"${detail}`);
+    this.name = "InvalidBranchNameError";
+  }
+};
 async function git(args, cwd) {
   const { stdout } = await exec("git", args, { cwd });
   return stdout;
@@ -822,16 +1046,35 @@ async function gh(args, cwd) {
   const { stdout } = await exec("gh", args, { cwd });
   return stdout;
 }
+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;
+}
 function buildBranchName(issueNumber, title, username = "unknown") {
   const slug = slugify(title, 50);
   return `${username}/dispatch/${issueNumber}-${slug}`;
 }
 async function getDefaultBranch(cwd) {
+  const PREFIX = "refs/remotes/origin/";
   try {
     const ref = await git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
-    const parts = ref.trim().split("/");
-    return parts[parts.length - 1];
-  } catch {
+    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";
@@ -842,6 +1085,9 @@ async function getDefaultBranch(cwd) {
 }
 var datasource = {
   name: "github",
+  supportsGit() {
+    return true;
+  },
   async list(opts = {}) {
     const cwd = opts.cwd || process.cwd();
     const { stdout } = await exec(
@@ -1043,8 +1289,30 @@ async function detectWorkItemType(opts = {}) {
 }
 var datasource2 = {
   name: "azdevops",
+  supportsGit() {
+    return true;
+  },
   async list(opts = {}) {
-    const wiql = "SELECT [System.Id] FROM workitems WHERE [System.State] <> 'Closed' AND [System.State] <> 'Removed' ORDER BY [System.CreatedDate] DESC";
+    const conditions = [
+      "[System.State] <> 'Closed'",
+      "[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 args = ["boards", "query", "--wiql", wiql, "--output", "json"];
     if (opts.org) args.push("--org", opts.org);
     if (opts.project) args.push("--project", opts.project);
@@ -1104,7 +1372,13 @@ var datasource2 = {
       state: fields["System.State"] ?? "",
       url: item._links?.html?.href ?? item.url ?? "",
       comments,
-      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
+      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"] || void 0
     };
   },
   async update(issueId, title, body, opts = {}) {
@@ -1177,7 +1451,13 @@ var datasource2 = {
       state: fields["System.State"] ?? "New",
       url: item._links?.html?.href ?? item.url ?? "",
       comments: [],
-      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
+      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"] || workItemType
     };
   },
   async getDefaultBranch(opts) {
@@ -1197,12 +1477,25 @@ var datasource2 = {
   async getUsername(opts) {
     try {
       const { stdout } = await exec2("git", ["config", "user.name"], { cwd: opts.cwd });
-      const name = stdout.trim();
-      if (!name) return "unknown";
-      return slugify(name);
+      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 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 principal = stdout.trim();
+      const prefix = principal.split("@")[0];
+      const name = slugify(prefix);
+      if (name) return name;
     } catch {
-      return "unknown";
     }
+    return "unknown";
   },
   buildBranchName(issueNumber, title, username) {
     const slug = slugify(title, 50);
@@ -1334,13 +1627,27 @@ 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, parse as parsePath } from "path";
+import { join as join2, parse as parsePath } from "path";
 import { promisify as promisify3 } from "util";
+
+// src/helpers/errors.ts
+var UnsupportedOperationError = class extends Error {
+  /** The name of the operation that is not supported. */
+  operation;
+  constructor(operation, message) {
+    const msg = message ?? `Operation not supported: ${operation}`;
+    super(msg);
+    this.name = "UnsupportedOperationError";
+    this.operation = operation;
+  }
+};
+
+// src/datasources/md.ts
 var exec3 = promisify3(execFile3);
 var DEFAULT_DIR = ".dispatch/specs";
 function resolveDir(opts) {
   const cwd = opts?.cwd ?? process.cwd();
-  return join(cwd, DEFAULT_DIR);
+  return join2(cwd, DEFAULT_DIR);
 }
 function extractTitle(content, filename) {
   const match = content.match(/^#\s+(.+)$/m);
@@ -1365,13 +1672,16 @@ function toIssueDetails(filename, content, dir) {
     body: content,
     labels: [],
     state: "open",
-    url: join(dir, filename),
+    url: join2(dir, filename),
     comments: [],
     acceptanceCriteria: ""
   };
 }
 var datasource3 = {
   name: "md",
+  supportsGit() {
+    return false;
+  },
   async list(opts) {
     const dir = resolveDir(opts);
     let entries;
@@ -1383,7 +1693,7 @@ var datasource3 = {
     const mdFiles = entries.filter((f) => f.endsWith(".md")).sort();
     const results = [];
     for (const filename of mdFiles) {
-      const filePath = join(dir, filename);
+      const filePath = join2(dir, filename);
       const content = await readFile(filePath, "utf-8");
       results.push(toIssueDetails(filename, content, dir));
     }
@@ -1392,29 +1702,29 @@ var datasource3 = {
   async fetch(issueId, opts) {
     const dir = resolveDir(opts);
     const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join(dir, filename);
+    const filePath = join2(dir, filename);
     const content = await readFile(filePath, "utf-8");
     return toIssueDetails(filename, content, dir);
   },
   async update(issueId, _title, body, opts) {
     const dir = resolveDir(opts);
     const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join(dir, filename);
+    const filePath = join2(dir, filename);
     await writeFile(filePath, body, "utf-8");
   },
   async close(issueId, opts) {
     const dir = resolveDir(opts);
     const filename = issueId.endsWith(".md") ? issueId : `${issueId}.md`;
-    const filePath = join(dir, filename);
-    const archiveDir = join(dir, "archive");
+    const filePath = join2(dir, filename);
+    const archiveDir = join2(dir, "archive");
     await mkdir(archiveDir, { recursive: true });
-    await rename(filePath, join(archiveDir, filename));
+    await rename(filePath, join2(archiveDir, filename));
   },
   async create(title, body, opts) {
     const dir = resolveDir(opts);
     await mkdir(dir, { recursive: true });
     const filename = `${slugify(title)}.md`;
-    const filePath = join(dir, filename);
+    const filePath = join2(dir, filename);
     await writeFile(filePath, body, "utf-8");
     return toIssueDetails(filename, body, dir);
   },
@@ -1436,15 +1746,19 @@ var datasource3 = {
     return `${username}/dispatch/${issueNumber}-${slug}`;
   },
   async createAndSwitchBranch(_branchName, _opts) {
+    throw new UnsupportedOperationError("createAndSwitchBranch");
   },
   async switchBranch(_branchName, _opts) {
+    throw new UnsupportedOperationError("switchBranch");
   },
   async pushBranch(_branchName, _opts) {
+    throw new UnsupportedOperationError("pushBranch");
   },
   async commitAllChanges(_message, _opts) {
+    throw new UnsupportedOperationError("commitAllChanges");
   },
   async createPullRequest(_branchName, _issueNumber, _title, _body, _opts) {
-    return "";
+    throw new UnsupportedOperationError("createPullRequest");
   }
 };
 
@@ -1490,6 +1804,36 @@ async function detectDatasource(cwd) {
   }
   return null;
 }
+function parseAzDevOpsRemoteUrl(url) {
+  const httpsMatch = url.match(
+    /^https?:\/\/(?:[^@]+@)?dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\//i
+  );
+  if (httpsMatch) {
+    return {
+      orgUrl: `https://dev.azure.com/${decodeURIComponent(httpsMatch[1])}`,
+      project: decodeURIComponent(httpsMatch[2])
+    };
+  }
+  const sshMatch = url.match(
+    /^git@ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\//i
+  );
+  if (sshMatch) {
+    return {
+      orgUrl: `https://dev.azure.com/${decodeURIComponent(sshMatch[1])}`,
+      project: decodeURIComponent(sshMatch[2])
+    };
+  }
+  const legacyMatch = url.match(
+    /^https?:\/\/([^.]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\//i
+  );
+  if (legacyMatch) {
+    return {
+      orgUrl: `https://dev.azure.com/${decodeURIComponent(legacyMatch[1])}`,
+      project: decodeURIComponent(legacyMatch[2])
+    };
+  }
+  return null;
+}
 
 // src/spec-generator.ts
 init_logger();
@@ -1506,16 +1850,16 @@ var RECOGNIZED_H2 = /* @__PURE__ */ new Set([
 function defaultConcurrency() {
   return Math.max(1, Math.min(cpus().length, Math.floor(freemem() / 1024 / 1024 / MB_PER_CONCURRENT_TASK)));
 }
-function isIssueNumbers(input2) {
-  if (Array.isArray(input2)) return false;
-  return /^\d+(,\s*\d+)*$/.test(input2);
+function isIssueNumbers(input3) {
+  if (Array.isArray(input3)) return false;
+  return /^\d+(,\s*\d+)*$/.test(input3);
 }
-function isGlobOrFilePath(input2) {
-  if (Array.isArray(input2)) return true;
-  if (/[*?\[{]/.test(input2)) return true;
-  if (/[/\\]/.test(input2)) return true;
-  if (/^\.\.?\//.test(input2)) return true;
-  if (/\.(md|txt|yaml|yml|json|ts|js|tsx|jsx)$/i.test(input2)) return true;
+function isGlobOrFilePath(input3) {
+  if (Array.isArray(input3)) return true;
+  if (/[*?\[{]/.test(input3)) return true;
+  if (/[/\\]/.test(input3)) return true;
+  if (/^\.\.?[\/\\]/.test(input3)) return true;
+  if (/\.(md|txt|yaml|yml|json|ts|js|tsx|jsx)$/i.test(input3)) return true;
   return false;
 }
 function extractSpecContent(raw) {
@@ -1641,7 +1985,7 @@ function semverGte(current, minimum) {
 async function checkPrereqs(context) {
   const failures = [];
   try {
-    await exec5("git", ["--version"]);
+    await exec5("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");
   }
@@ -1653,7 +1997,7 @@ async function checkPrereqs(context) {
   }
   if (context?.datasource === "github") {
     try {
-      await exec5("gh", ["--version"]);
+      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/"
@@ -1662,7 +2006,7 @@ async function checkPrereqs(context) {
   }
   if (context?.datasource === "azdevops") {
     try {
-      await exec5("az", ["--version"]);
+      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/"
@@ -1675,17 +2019,23 @@ async function checkPrereqs(context) {
 // src/helpers/gitignore.ts
 init_logger();
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 async function ensureGitignoreEntry(repoRoot, entry) {
-  const gitignorePath = join2(repoRoot, ".gitignore");
+  const gitignorePath = join3(repoRoot, ".gitignore");
   let contents = "";
   try {
     contents = await readFile2(gitignorePath, "utf8");
-  } catch {
+  } 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("\n").map((l) => l.trim());
+  const lines = contents.split(/\r?\n/);
   const bare = entry.replace(/\/$/, "");
-  if (lines.includes(entry) || lines.includes(bare)) {
+  const withSlash = bare + "/";
+  if (lines.includes(entry) || lines.includes(bare) || lines.includes(withSlash)) {
     return;
   }
   try {
@@ -1700,18 +2050,18 @@ async function ensureGitignoreEntry(repoRoot, entry) {
 
 // src/orchestrator/cli-config.ts
 init_logger();
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { access } from "fs/promises";
 import { constants } from "fs";
 
 // src/config.ts
 init_providers();
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { join as join3, dirname } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 
 // src/config-prompts.ts
 init_logger();
-import { select, confirm } from "@inquirer/prompts";
+import { select, confirm, input as input2 } from "@inquirer/prompts";
 import chalk3 from "chalk";
 init_providers();
 async function runInteractiveConfigWizard(configDir) {
@@ -1791,6 +2141,54 @@ async function runInteractiveConfigWizard(configDir) {
     default: datasourceDefault
   });
   const source = selectedSource === "auto" ? void 0 : selectedSource;
+  let org;
+  let project;
+  let workItemType;
+  let iteration;
+  let area;
+  const effectiveSource = source ?? detectedSource;
+  if (effectiveSource === "azdevops") {
+    let defaultOrg = existing.org ?? "";
+    let defaultProject = existing.project ?? "";
+    try {
+      const remoteUrl = await getGitRemoteUrl(process.cwd());
+      if (remoteUrl) {
+        const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
+        if (parsed) {
+          if (!defaultOrg) defaultOrg = parsed.orgUrl;
+          if (!defaultProject) defaultProject = parsed.project;
+        }
+      }
+    } catch {
+    }
+    console.log();
+    log.info(chalk3.bold("Azure DevOps settings") + chalk3.dim(" (leave empty to skip):"));
+    const orgInput = await input2({
+      message: "Organization URL:",
+      default: defaultOrg || void 0
+    });
+    if (orgInput.trim()) org = orgInput.trim();
+    const projectInput = await input2({
+      message: "Project name:",
+      default: defaultProject || void 0
+    });
+    if (projectInput.trim()) project = projectInput.trim();
+    const workItemTypeInput = await input2({
+      message: "Work item type (e.g. User Story, Bug):",
+      default: existing.workItemType ?? void 0
+    });
+    if (workItemTypeInput.trim()) workItemType = workItemTypeInput.trim();
+    const iterationInput = await input2({
+      message: "Iteration path (e.g. MyProject\\Sprint 1, or @CurrentIteration):",
+      default: existing.iteration ?? void 0
+    });
+    if (iterationInput.trim()) iteration = iterationInput.trim();
+    const areaInput = await input2({
+      message: "Area path (e.g. MyProject\\Team A):",
+      default: existing.area ?? void 0
+    });
+    if (areaInput.trim()) area = areaInput.trim();
+  }
   const newConfig = {
     provider,
     source
@@ -1798,6 +2196,11 @@ async function runInteractiveConfigWizard(configDir) {
   if (selectedModel !== void 0) {
     newConfig.model = selectedModel;
   }
+  if (org !== void 0) newConfig.org = org;
+  if (project !== void 0) newConfig.project = project;
+  if (workItemType !== void 0) newConfig.workItemType = workItemType;
+  if (iteration !== void 0) newConfig.iteration = iteration;
+  if (area !== void 0) newConfig.area = area;
   console.log();
   log.info(chalk3.bold("Configuration summary:"));
   for (const [key, value] of Object.entries(newConfig)) {
@@ -1824,10 +2227,15 @@ async function runInteractiveConfigWizard(configDir) {
 }
 
 // src/config.ts
-var CONFIG_KEYS = ["provider", "model", "source", "testTimeout"];
+var CONFIG_BOUNDS = {
+  testTimeout: { min: 1, max: 120 },
+  planTimeout: { min: 1, max: 120 },
+  concurrency: { min: 1, max: 64 }
+};
+var CONFIG_KEYS = ["provider", "model", "source", "testTimeout", "planTimeout", "concurrency", "org", "project", "workItemType", "iteration", "area"];
 function getConfigPath(configDir) {
-  const dir = configDir ?? join3(process.cwd(), ".dispatch");
-  return join3(dir, "config.json");
+  const dir = configDir ?? join4(process.cwd(), ".dispatch");
+  return join4(dir, "config.json");
 }
 async function loadConfig(configDir) {
   const configPath = getConfigPath(configDir);
@@ -1840,7 +2248,7 @@ async function loadConfig(configDir) {
 }
 async function saveConfig(config, configDir) {
   const configPath = getConfigPath(configDir);
-  await mkdir2(dirname(configPath), { recursive: true });
+  await mkdir2(dirname2(configPath), { recursive: true });
   await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 async function handleConfigCommand(_argv, configDir) {
@@ -1852,14 +2260,21 @@ var CONFIG_TO_CLI = {
   provider: "provider",
   model: "model",
   source: "issueSource",
-  testTimeout: "testTimeout"
+  testTimeout: "testTimeout",
+  planTimeout: "planTimeout",
+  concurrency: "concurrency",
+  org: "org",
+  project: "project",
+  workItemType: "workItemType",
+  iteration: "iteration",
+  area: "area"
 };
 function setCliField(target, key, value) {
   target[key] = value;
 }
 async function resolveCliConfig(args) {
   const { explicitFlags } = args;
-  const configDir = join4(args.cwd, ".dispatch");
+  const configDir = join5(args.cwd, ".dispatch");
   const config = await loadConfig(configDir);
   const merged = { ...args };
   for (const configKey of CONFIG_KEYS) {
@@ -1906,16 +2321,17 @@ async function resolveCliConfig(args) {
 }
 
 // src/orchestrator/spec-pipeline.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { mkdir as mkdir4, readFile as readFile5, rename as rename2, unlink as unlink2 } from "fs/promises";
 import { glob } from "glob";
 init_providers();
 
 // src/agents/spec.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4, unlink } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6, resolve, sep } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 init_logger();
+init_file_logger();
 async function boot5(opts) {
   const { provider } = opts;
   if (!provider) {
@@ -1925,11 +2341,22 @@ async function boot5(opts) {
     name: "spec",
     async generate(genOpts) {
       const { issue, filePath, fileContent, inlineText, cwd: workingDir, outputPath } = genOpts;
+      const startTime = Date.now();
       try {
-        const tmpDir = join5(workingDir, ".dispatch", "tmp");
+        const resolvedCwd = resolve(workingDir);
+        const resolvedOutput = resolve(outputPath);
+        if (resolvedOutput !== resolvedCwd && !resolvedOutput.startsWith(resolvedCwd + sep)) {
+          return {
+            data: null,
+            success: false,
+            error: `Output path "${outputPath}" escapes the working directory "${workingDir}"`,
+            durationMs: Date.now() - startTime
+          };
+        }
+        const tmpDir = join6(resolvedCwd, ".dispatch", "tmp");
         await mkdir3(tmpDir, { recursive: true });
         const tmpFilename = `spec-${randomUUID3()}.md`;
-        const tmpPath = join5(tmpDir, tmpFilename);
+        const tmpPath = join6(tmpDir, tmpFilename);
         let prompt;
         if (issue) {
           prompt = buildSpecPrompt(issue, workingDir, tmpPath);
@@ -1939,33 +2366,35 @@ async function boot5(opts) {
           prompt = buildFileSpecPrompt(filePath, fileContent, workingDir, tmpPath);
         } else {
           return {
-            content: "",
+            data: null,
             success: false,
             error: "Either issue, inlineText, or filePath+fileContent must be provided",
-            valid: false
+            durationMs: Date.now() - startTime
           };
         }
+        fileLoggerStorage.getStore()?.prompt("spec", prompt);
         const sessionId = await provider.createSession();
         log.debug(`Spec prompt built (${prompt.length} chars)`);
         const response = await provider.prompt(sessionId, prompt);
         if (response === null) {
           return {
-            content: "",
+            data: null,
             success: false,
             error: "AI agent returned no response",
-            valid: false
+            durationMs: Date.now() - startTime
           };
         }
         log.debug(`Spec agent response (${response.length} chars)`);
+        fileLoggerStorage.getStore()?.response("spec", response);
         let rawContent;
         try {
           rawContent = await readFile4(tmpPath, "utf-8");
         } catch {
           return {
-            content: "",
+            data: null,
             success: false,
             error: `Spec agent did not write the file to ${tmpPath}. Agent response: ${response.slice(0, 300)}`,
-            valid: false
+            durationMs: Date.now() - startTime
           };
         }
         const cleanedContent = extractSpecContent(rawContent);
@@ -1974,25 +2403,31 @@ async function boot5(opts) {
         if (!validation.valid) {
           log.warn(`Spec validation warning for ${outputPath}: ${validation.reason}`);
         }
-        await writeFile4(outputPath, cleanedContent, "utf-8");
-        log.debug(`Wrote cleaned spec to ${outputPath}`);
+        await writeFile4(resolvedOutput, cleanedContent, "utf-8");
+        log.debug(`Wrote cleaned spec to ${resolvedOutput}`);
         try {
           await unlink(tmpPath);
         } catch {
         }
+        fileLoggerStorage.getStore()?.agentEvent("spec", "completed", `${Date.now() - startTime}ms`);
         return {
-          content: cleanedContent,
+          data: {
+            content: cleanedContent,
+            valid: validation.valid,
+            validationReason: validation.reason
+          },
           success: true,
-          valid: validation.valid,
-          validationReason: validation.reason
+          durationMs: Date.now() - startTime
         };
       } catch (err) {
         const message = log.extractMessage(err);
+        fileLoggerStorage.getStore()?.error(`spec error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
         return {
-          content: "",
+          data: null,
           success: false,
           error: message,
-          valid: false
+          durationMs: Date.now() - startTime
         };
       }
     },
@@ -2000,24 +2435,8 @@ async function boot5(opts) {
     }
   };
 }
-function buildSpecPrompt(issue, cwd, outputPath) {
-  const sections = [
-    `You are a **spec agent**. Your job is to explore the codebase, understand the issue below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
-    ``,
-    `**Important:** This file will be consumed by a two-stage pipeline:`,
-    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
-    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
-    ``,
-    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
-    ``,
-    `**CRITICAL \u2014 Output constraints (read carefully):**`,
-    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
-    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
-    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
-    `- **No summaries:** Do not append a summary or recap of what you wrote`,
-    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
-    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
-    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
+function buildIssueSourceSection(issue) {
+  const lines = [
     ``,
     `## Issue Details`,
     ``,
@@ -2027,21 +2446,76 @@ function buildSpecPrompt(issue, cwd, outputPath) {
     `- **URL:** ${issue.url}`
   ];
   if (issue.labels.length > 0) {
-    sections.push(`- **Labels:** ${issue.labels.join(", ")}`);
+    lines.push(`- **Labels:** ${issue.labels.join(", ")}`);
   }
   if (issue.body) {
-    sections.push(``, `### Description`, ``, issue.body);
+    lines.push(``, `### Description`, ``, issue.body);
   }
   if (issue.acceptanceCriteria) {
-    sections.push(``, `### Acceptance Criteria`, ``, issue.acceptanceCriteria);
+    lines.push(``, `### Acceptance Criteria`, ``, issue.acceptanceCriteria);
   }
   if (issue.comments.length > 0) {
-    sections.push(``, `### Discussion`, ``);
+    lines.push(``, `### Discussion`, ``);
     for (const comment of issue.comments) {
-      sections.push(comment, ``);
+      lines.push(comment, ``);
     }
   }
-  sections.push(
+  return lines;
+}
+function buildFileSourceSection(filePath, content, title) {
+  const lines = [
+    ``,
+    `## File Details`,
+    ``,
+    `- **Title:** ${title}`,
+    `- **Source file:** ${filePath}`
+  ];
+  if (content) {
+    lines.push(``, `### Content`, ``, content);
+  }
+  return lines;
+}
+function buildInlineTextSourceSection(title, text) {
+  return [
+    ``,
+    `## Inline Text`,
+    ``,
+    `- **Title:** ${title}`,
+    ``,
+    `### Description`,
+    ``,
+    text
+  ];
+}
+function buildCommonSpecInstructions(params) {
+  const {
+    subject,
+    sourceSection,
+    cwd,
+    outputPath,
+    understandStep,
+    titleTemplate,
+    summaryTemplate,
+    whyLines
+  } = params;
+  return [
+    `You are a **spec agent**. Your job is to explore the codebase, understand ${subject}, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
+    ``,
+    `**Important:** This file will be consumed by a two-stage pipeline:`,
+    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
+    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
+    ``,
+    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
+    ``,
+    `**CRITICAL \u2014 Output constraints (read carefully):**`,
+    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
+    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
+    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
+    `- **No summaries:** Do not append a summary or recap of what you wrote`,
+    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
+    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
+    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
+    ...sourceSection,
     ``,
     `## Working Directory`,
     ``,
@@ -2051,7 +2525,7 @@ function buildSpecPrompt(issue, cwd, outputPath) {
     ``,
     `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
     ``,
-    `2. **Understand the issue** \u2014 analyze the issue description, acceptance criteria, and discussion comments to fully understand what needs to be done and why.`,
+    understandStep,
     ``,
     `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
     ``,
@@ -2067,9 +2541,9 @@ function buildSpecPrompt(issue, cwd, outputPath) {
     ``,
     `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
     ``,
-    `# <Issue title> (#<number>)`,
+    titleTemplate,
     ``,
-    `> <One-line summary: what this issue achieves and why it matters>`,
+    summaryTemplate,
     ``,
     `## Context`,
     ``,
@@ -2081,8 +2555,7 @@ function buildSpecPrompt(issue, cwd, outputPath) {
     `## Why`,
     ``,
     `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
-    `what user or system benefit it provides. Pull from the issue description,`,
-    `acceptance criteria, and discussion.>`,
+    ...whyLines,
     ``,
     `## Approach`,
     ``,
@@ -2133,258 +2606,59 @@ function buildSpecPrompt(issue, cwd, outputPath) {
     `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
     `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
     `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
-  );
-  return sections.join("\n");
+  ];
+}
+function buildSpecPrompt(issue, cwd, outputPath) {
+  return buildCommonSpecInstructions({
+    subject: "the issue below",
+    sourceSection: buildIssueSourceSection(issue),
+    cwd,
+    outputPath,
+    understandStep: `2. **Understand the issue** \u2014 analyze the issue description, acceptance criteria, and discussion comments to fully understand what needs to be done and why.`,
+    titleTemplate: `# <Issue title> (#<number>)`,
+    summaryTemplate: `> <One-line summary: what this issue achieves and why it matters>`,
+    whyLines: [
+      `what user or system benefit it provides. Pull from the issue description,`,
+      `acceptance criteria, and discussion.>`
+    ]
+  }).join("\n");
 }
 function buildFileSpecPrompt(filePath, content, cwd, outputPath) {
   const title = extractTitle(content, filePath);
   const writePath = outputPath ?? filePath;
-  const sections = [
-    `You are a **spec agent**. Your job is to explore the codebase, understand the content below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
-    ``,
-    `**Important:** This file will be consumed by a two-stage pipeline:`,
-    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
-    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
-    ``,
-    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
-    ``,
-    `**CRITICAL \u2014 Output constraints (read carefully):**`,
-    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
-    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
-    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
-    `- **No summaries:** Do not append a summary or recap of what you wrote`,
-    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
-    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
-    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
-    ``,
-    `## File Details`,
-    ``,
-    `- **Title:** ${title}`,
-    `- **Source file:** ${filePath}`
-  ];
-  if (content) {
-    sections.push(``, `### Content`, ``, content);
-  }
-  sections.push(
-    ``,
-    `## Working Directory`,
-    ``,
-    `\`${cwd}\``,
-    ``,
-    `## Instructions`,
-    ``,
-    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
-    ``,
-    `2. **Understand the content** \u2014 analyze the file content to fully understand what needs to be done and why.`,
-    ``,
-    `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
-    ``,
-    `4. **Identify integration points** \u2014 determine which existing modules, interfaces, patterns, and conventions the implementation must align with. Note the key files and modules involved, but do NOT prescribe exact code changes \u2014 the planner agent will handle that.`,
-    ``,
-    `5. **DO NOT make any code changes** \u2014 you are only producing a spec, not implementing.`,
-    ``,
-    `## Output`,
-    ``,
-    `Write the complete spec as a markdown file to this exact path:`,
-    ``,
-    `\`${writePath}\``,
-    ``,
-    `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
-    ``,
-    `# <Title>`,
-    ``,
-    `> <One-line summary: what this achieves and why it matters>`,
-    ``,
-    `## Context`,
-    ``,
-    `<Describe the relevant parts of the codebase: key modules, directory structure,`,
-    `language/framework, and architectural patterns. Name specific files and modules`,
-    `that are involved so the planner agent knows where to look, but do not include`,
-    `code snippets or line-level details.>`,
-    ``,
-    `## Why`,
-    ``,
-    `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
-    `what user or system benefit it provides. Pull from the file content.>`,
-    ``,
-    `## Approach`,
-    ``,
-    `<High-level description of the implementation strategy. Explain the overall`,
-    `approach, which patterns to follow, what to extend vs. create new, and how`,
-    `the change fits into the existing architecture. Mention relevant standards,`,
-    `technologies, and conventions the implementation MUST align with.>`,
-    ``,
-    `## Integration Points`,
-    ``,
-    `<List the specific modules, interfaces, configurations, and conventions that`,
-    `the implementation must integrate with. For example: existing provider`,
-    `interfaces to implement, CLI argument patterns to follow, test framework`,
-    `and conventions to match, build system requirements, etc.>`,
-    ``,
-    `## Tasks`,
-    ``,
-    `Each task MUST be prefixed with an execution-mode tag:`,
-    ``,
-    `- \`(P)\` \u2014 **Parallel-safe.** This task has no dependency on the output of a prior task and can run concurrently with other \`(P)\` tasks.`,
-    `- \`(S)\` \u2014 **Serial / dependent.** This task depends on a prior task's output or modifies shared state that conflicts with concurrent work. It acts as a barrier: all preceding tasks complete before it starts, and it completes before subsequent tasks begin.`,
-    `- \`(I)\` \u2014 **Isolated / barrier.** This task must run alone after all preceding tasks complete and before any subsequent tasks begin. Use for validation tasks like running tests, linting, or builds that read the output of prior tasks.`,
-    ``,
-    `**Default to \`(P)\`.** Most tasks are independent (e.g., adding a function in one module, writing tests in another). Only use \`(S)\` when a task genuinely depends on the result of a prior task (e.g., "refactor module X" followed by "update callers of module X"). Use \`(I)\` for validation or barrier tasks that must run alone after all prior work completes (e.g., "run tests", "run linting", "build the project").`,
-    ``,
-    `If a task has no \`(P)\`, \`(S)\`, or \`(I)\` prefix, the system treats it as serial, so always tag explicitly.`,
-    ``,
-    `Example:`,
-    ``,
-    `- [ ] (P) Add validation helper to the form utils module`,
-    `- [ ] (P) Add unit tests for the new validation helper`,
-    `- [ ] (S) Refactor the form component to use the new validation helper`,
-    `- [ ] (P) Update documentation for the form utils module`,
-    `- [ ] (I) Run the full test suite to verify all changes pass`,
-    ``,
-    ``,
-    `## References`,
-    ``,
-    `- <Links to relevant docs, related issues, or external resources>`,
-    ``,
-    `## Key Guidelines`,
-    ``,
-    `- **Stay high-level.** Do NOT include code snippets, exact line numbers, diffs, or step-by-step coding instructions. A dedicated planner agent will produce those details for each task at execution time.`,
-    `- **Respect the project's stack.** Your spec must align with the languages, frameworks, libraries, test tools, and conventions already in use. Never suggest technologies that conflict with the existing project.`,
-    `- **Explain WHAT, WHY, and HOW (strategically).** Each task should say what needs to happen, why it's needed, and which part of the codebase it touches \u2014 but leave the tactical "how" to the planner agent.`,
-    `- **Detail integration points.** The prose sections (Context, Approach, Integration Points) are critical \u2014 they tell the planner agent where to look and what constraints to respect.`,
-    `- **Keep tasks atomic and ordered.** Each \`- [ ]\` task must be a single, clear unit of work. Order them so dependencies come first.`,
-    `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
-    `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
-    `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
-  );
-  return sections.join("\n");
+  return buildCommonSpecInstructions({
+    subject: "the content below",
+    sourceSection: buildFileSourceSection(filePath, content, title),
+    cwd,
+    outputPath: writePath,
+    understandStep: `2. **Understand the content** \u2014 analyze the file content to fully understand what needs to be done and why.`,
+    titleTemplate: `# <Title>`,
+    summaryTemplate: `> <One-line summary: what this achieves and why it matters>`,
+    whyLines: [
+      `what user or system benefit it provides. Pull from the file content.>`
+    ]
+  }).join("\n");
 }
 function buildInlineTextSpecPrompt(text, cwd, outputPath) {
   const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
-  const sections = [
-    `You are a **spec agent**. Your job is to explore the codebase, understand the request below, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
-    ``,
-    `**Important:** This file will be consumed by a two-stage pipeline:`,
-    `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
-    `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
-    ``,
-    `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
-    ``,
-    `**CRITICAL \u2014 Output constraints (read carefully):**`,
-    `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
-    `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
-    `- **No postamble:** Do not add any text after the last spec section (e.g., "Let me know if you'd like changes", "Here's a summary of...")`,
-    `- **No summaries:** Do not append a summary or recap of what you wrote`,
-    `- **No code fences:** Do not wrap the spec content in \`\`\`markdown ... \`\`\` or any other code fence`,
-    `- **No conversational text:** Do not include any explanations, commentary, or dialogue \u2014 the file is consumed by an automated pipeline, not a human`,
-    `The file content must start with \`# \` (the H1 heading) and contain nothing before or after the structured spec sections.`,
-    ``,
-    `## Inline Text`,
-    ``,
-    `- **Title:** ${title}`,
-    ``,
-    `### Description`,
-    ``,
-    text
-  ];
-  sections.push(
-    ``,
-    `## Working Directory`,
-    ``,
-    `\`${cwd}\``,
-    ``,
-    `## Instructions`,
-    ``,
-    `1. **Explore the codebase** \u2014 read relevant files, search for symbols, understand the project structure, language, frameworks, conventions, and patterns. Identify the tech stack (languages, package managers, frameworks, test runners) so your spec aligns with the project's actual standards.`,
-    ``,
-    `2. **Understand the request** \u2014 analyze the inline text to fully understand what needs to be done and why. Since this is a brief description rather than a detailed issue or document, you may need to infer details from the codebase.`,
-    ``,
-    `3. **Research the approach** \u2014 look up relevant documentation, libraries, and patterns. Consider how the change integrates with the existing architecture, standards, and technologies already in use. For example, if the project is TypeScript, do not propose a Python solution; if it uses Vitest, do not suggest Jest.`,
-    ``,
-    `4. **Identify integration points** \u2014 determine which existing modules, interfaces, patterns, and conventions the implementation must align with. Note the key files and modules involved, but do NOT prescribe exact code changes \u2014 the planner agent will handle that.`,
-    ``,
-    `5. **DO NOT make any code changes** \u2014 you are only producing a spec, not implementing.`,
-    ``,
-    `## Output`,
-    ``,
-    `Write the complete spec as a markdown file to this exact path:`,
-    ``,
-    `\`${outputPath}\``,
-    ``,
-    `Use your Write tool to save the file. The file content MUST begin with the H1 heading \u2014 no preamble, no code fences, no conversational text before it. Do not add any text after the final spec section \u2014 no postamble, no summary, no commentary. The file must follow this structure exactly:`,
-    ``,
-    `# <Title>`,
-    ``,
-    `> <One-line summary: what this achieves and why it matters>`,
-    ``,
-    `## Context`,
-    ``,
-    `<Describe the relevant parts of the codebase: key modules, directory structure,`,
-    `language/framework, and architectural patterns. Name specific files and modules`,
-    `that are involved so the planner agent knows where to look, but do not include`,
-    `code snippets or line-level details.>`,
-    ``,
-    `## Why`,
-    ``,
-    `<Explain the motivation \u2014 why this change is needed, what problem it solves,`,
-    `what user or system benefit it provides. Pull from the inline text description.>`,
-    ``,
-    `## Approach`,
-    ``,
-    `<High-level description of the implementation strategy. Explain the overall`,
-    `approach, which patterns to follow, what to extend vs. create new, and how`,
-    `the change fits into the existing architecture. Mention relevant standards,`,
-    `technologies, and conventions the implementation MUST align with.>`,
-    ``,
-    `## Integration Points`,
-    ``,
-    `<List the specific modules, interfaces, configurations, and conventions that`,
-    `the implementation must integrate with. For example: existing provider`,
-    `interfaces to implement, CLI argument patterns to follow, test framework`,
-    `and conventions to match, build system requirements, etc.>`,
-    ``,
-    `## Tasks`,
-    ``,
-    `Each task MUST be prefixed with an execution-mode tag:`,
-    ``,
-    `- \`(P)\` \u2014 **Parallel-safe.** This task has no dependency on the output of a prior task and can run concurrently with other \`(P)\` tasks.`,
-    `- \`(S)\` \u2014 **Serial / dependent.** This task depends on a prior task's output or modifies shared state that conflicts with concurrent work. It acts as a barrier: all preceding tasks complete before it starts, and it completes before subsequent tasks begin.`,
-    `- \`(I)\` \u2014 **Isolated / barrier.** This task must run alone after all preceding tasks complete and before any subsequent tasks begin. Use for validation tasks like running tests, linting, or builds that read the output of prior tasks.`,
-    ``,
-    `**Default to \`(P)\`.** Most tasks are independent (e.g., adding a function in one module, writing tests in another). Only use \`(S)\` when a task genuinely depends on the result of a prior task (e.g., "refactor module X" followed by "update callers of module X"). Use \`(I)\` for validation or barrier tasks that must run alone after all prior work completes (e.g., "run tests", "run linting", "build the project").`,
-    ``,
-    `If a task has no \`(P)\`, \`(S)\`, or \`(I)\` prefix, the system treats it as serial, so always tag explicitly.`,
-    ``,
-    `Example:`,
-    ``,
-    `- [ ] (P) Add validation helper to the form utils module`,
-    `- [ ] (P) Add unit tests for the new validation helper`,
-    `- [ ] (S) Refactor the form component to use the new validation helper`,
-    `- [ ] (P) Update documentation for the form utils module`,
-    `- [ ] (I) Run the full test suite to verify all changes pass`,
-    ``,
-    ``,
-    `## References`,
-    ``,
-    `- <Links to relevant docs, related issues, or external resources>`,
-    ``,
-    `## Key Guidelines`,
-    ``,
-    `- **Stay high-level.** Do NOT include code snippets, exact line numbers, diffs, or step-by-step coding instructions. A dedicated planner agent will produce those details for each task at execution time.`,
-    `- **Respect the project's stack.** Your spec must align with the languages, frameworks, libraries, test tools, and conventions already in use. Never suggest technologies that conflict with the existing project.`,
-    `- **Explain WHAT, WHY, and HOW (strategically).** Each task should say what needs to happen, why it's needed, and which part of the codebase it touches \u2014 but leave the tactical "how" to the planner agent.`,
-    `- **Detail integration points.** The prose sections (Context, Approach, Integration Points) are critical \u2014 they tell the planner agent where to look and what constraints to respect.`,
-    `- **Keep tasks atomic and ordered.** Each \`- [ ]\` task must be a single, clear unit of work. Order them so dependencies come first.`,
-    `- **Tag every task with \`(P)\`, \`(S)\`, or \`(I)\`.** Default to \`(P)\` (parallel) unless the task depends on a prior task's output. Use \`(I)\` for validation/barrier tasks. Group related serial dependencies together and prefer parallelism to maximize throughput.`,
-    `- **Embed commit instructions within task descriptions.** You control when commits happen. Instead of creating standalone commit tasks (which would fail \u2014 each task runs in an isolated agent session), include commit instructions at the end of implementation task descriptions at logical boundaries. For example: "Implement the validation helper and commit with a conventional commit message." Group related changes into a single commit where it makes logical sense, and use the project's conventional commit types: \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`test\`, \`chore\`, \`style\`, \`perf\`, \`ci\`. Not every task needs a commit instruction \u2014 use your judgment to place them at logical boundaries.`,
-    `- **Keep the markdown clean** \u2014 it will be parsed by an automated tool.`
-  );
-  return sections.join("\n");
+  return buildCommonSpecInstructions({
+    subject: "the request below",
+    sourceSection: buildInlineTextSourceSection(title, text),
+    cwd,
+    outputPath,
+    understandStep: `2. **Understand the request** \u2014 analyze the inline text to fully understand what needs to be done and why. Since this is a brief description rather than a detailed issue or document, you may need to infer details from the codebase.`,
+    titleTemplate: `# <Title>`,
+    summaryTemplate: `> <One-line summary: what this achieves and why it matters>`,
+    whyLines: [
+      `what user or system benefit it provides. Pull from the inline text description.>`
+    ]
+  }).join("\n");
 }
 
 // src/orchestrator/spec-pipeline.ts
 init_cleanup();
 init_logger();
+init_file_logger();
 import chalk5 from "chalk";
 
 // src/helpers/format.ts
@@ -2435,146 +2709,134 @@ async function withRetry(fn, maxRetries, options) {
 }
 
 // src/orchestrator/spec-pipeline.ts
-async function runSpecPipeline(opts) {
-  const {
-    issues,
-    provider,
-    model,
-    serverUrl,
-    cwd: specCwd,
-    outputDir = join6(specCwd, ".dispatch", "specs"),
-    org,
-    project,
-    workItemType,
-    concurrency = defaultConcurrency(),
-    dryRun,
-    retries = 2
-  } = opts;
-  const pipelineStart = Date.now();
-  const source = await resolveSource(issues, opts.issueSource, specCwd);
-  if (!source) {
-    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
-  }
+init_timeout();
+var FETCH_TIMEOUT_MS = 3e4;
+async function resolveDatasource(issues, issueSource, specCwd, org, project, workItemType, iteration, area) {
+  const source = await resolveSource(issues, issueSource, specCwd);
+  if (!source) return null;
   const datasource4 = getDatasource(source);
-  const fetchOpts = { cwd: specCwd, org, project, workItemType };
-  const isTrackerMode = isIssueNumbers(issues);
-  const isInlineText = !isTrackerMode && !isGlobOrFilePath(issues);
-  let items;
-  if (isTrackerMode) {
-    const issueNumbers2 = issues.split(",").map((s) => s.trim()).filter(Boolean);
-    if (issueNumbers2.length === 0) {
-      log.error("No issue numbers provided. Use --spec 1,2,3");
-      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: 0, fileDurationsMs: {} };
-    }
-    const fetchStart = Date.now();
-    log.info(`Fetching ${issueNumbers2.length} issue(s) from ${source} (concurrency: ${concurrency})...`);
-    items = [];
-    const fetchQueue = [...issueNumbers2];
-    while (fetchQueue.length > 0) {
-      const batch = fetchQueue.splice(0, concurrency);
-      log.debug(`Fetching batch of ${batch.length}: #${batch.join(", #")}`);
-      const batchResults = await Promise.all(
-        batch.map(async (id) => {
-          try {
-            const details = await datasource4.fetch(id, fetchOpts);
-            log.success(`Fetched #${id}: ${details.title}`);
-            log.debug(`Body: ${details.body?.length ?? 0} chars, Labels: ${details.labels.length}, Comments: ${details.comments.length}`);
-            return { id, details };
-          } catch (err) {
-            const message = log.extractMessage(err);
-            log.error(`Failed to fetch #${id}: ${log.formatErrorChain(err)}`);
-            log.debug(log.formatErrorChain(err));
-            return { id, details: null, error: message };
-          }
-        })
-      );
-      items.push(...batchResults);
-    }
-    log.debug(`Issue fetching completed in ${elapsed(Date.now() - fetchStart)}`);
-  } else if (isInlineText) {
-    const text = Array.isArray(issues) ? issues.join(" ") : issues;
-    const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
-    const slug = slugify(text, MAX_SLUG_LENGTH);
-    const filename = `${slug}.md`;
-    const filepath = join6(outputDir, filename);
-    const details = {
-      number: filepath,
-      title,
-      body: text,
-      labels: [],
-      state: "open",
-      url: filepath,
-      comments: [],
-      acceptanceCriteria: ""
-    };
-    log.info(`Inline text spec: "${title}"`);
-    items = [{ id: filepath, details }];
-  } else {
-    const files = await glob(issues, { cwd: specCwd, absolute: true });
-    if (files.length === 0) {
-      log.error(`No files matched the pattern "${Array.isArray(issues) ? issues.join(", ") : issues}".`);
-      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: 0, fileDurationsMs: {} };
-    }
-    log.info(`Matched ${files.length} file(s) for spec generation (concurrency: ${concurrency})...`);
-    items = [];
-    for (const filePath of files) {
-      try {
-        const content = await readFile5(filePath, "utf-8");
-        const title = extractTitle(content, filePath);
-        const details = {
-          number: filePath,
-          title,
-          body: content,
-          labels: [],
-          state: "open",
-          url: filePath,
-          comments: [],
-          acceptanceCriteria: ""
-        };
-        items.push({ id: filePath, details });
-      } catch (err) {
-        items.push({ id: filePath, details: null, error: log.extractMessage(err) });
-      }
+  const fetchOpts = { cwd: specCwd, org, project, workItemType, iteration, area };
+  return { source, datasource: datasource4, fetchOpts };
+}
+async function fetchTrackerItems(issues, datasource4, fetchOpts, concurrency, source) {
+  const issueNumbers = issues.split(",").map((s) => s.trim()).filter(Boolean);
+  if (issueNumbers.length === 0) {
+    log.error("No issue numbers provided. Use --spec 1,2,3");
+    return [];
+  }
+  const fetchStart = Date.now();
+  log.info(`Fetching ${issueNumbers.length} issue(s) from ${source} (concurrency: ${concurrency})...`);
+  const items = [];
+  const fetchQueue = [...issueNumbers];
+  while (fetchQueue.length > 0) {
+    const batch = fetchQueue.splice(0, concurrency);
+    log.debug(`Fetching batch of ${batch.length}: #${batch.join(", #")}`);
+    const batchResults = await Promise.all(
+      batch.map(async (id) => {
+        try {
+          const details = await withTimeout(datasource4.fetch(id, fetchOpts), FETCH_TIMEOUT_MS, "datasource fetch");
+          log.success(`Fetched #${id}: ${details.title}`);
+          log.debug(`Body: ${details.body?.length ?? 0} chars, Labels: ${details.labels.length}, Comments: ${details.comments.length}`);
+          return { id, details };
+        } catch (err) {
+          const message = log.extractMessage(err);
+          log.error(`Failed to fetch #${id}: ${log.formatErrorChain(err)}`);
+          log.debug(log.formatErrorChain(err));
+          return { id, details: null, error: message };
+        }
+      })
+    );
+    items.push(...batchResults);
+  }
+  log.debug(`Issue fetching completed in ${elapsed(Date.now() - fetchStart)}`);
+  return items;
+}
+function buildInlineTextItem(issues, outputDir) {
+  const text = Array.isArray(issues) ? issues.join(" ") : issues;
+  const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
+  const slug = slugify(text, MAX_SLUG_LENGTH);
+  const filename = `${slug}.md`;
+  const filepath = join7(outputDir, filename);
+  const details = {
+    number: filepath,
+    title,
+    body: text,
+    labels: [],
+    state: "open",
+    url: filepath,
+    comments: [],
+    acceptanceCriteria: ""
+  };
+  log.info(`Inline text spec: "${title}"`);
+  return [{ id: filepath, details }];
+}
+async function resolveFileItems(issues, specCwd, concurrency) {
+  const files = await glob(issues, { cwd: specCwd, absolute: true });
+  if (files.length === 0) {
+    log.error(`No files matched the pattern "${Array.isArray(issues) ? issues.join(", ") : issues}".`);
+    return null;
+  }
+  log.info(`Matched ${files.length} file(s) for spec generation (concurrency: ${concurrency})...`);
+  const items = [];
+  for (const filePath of files) {
+    try {
+      const content = await readFile5(filePath, "utf-8");
+      const title = extractTitle(content, filePath);
+      const details = {
+        number: filePath,
+        title,
+        body: content,
+        labels: [],
+        state: "open",
+        url: filePath,
+        comments: [],
+        acceptanceCriteria: ""
+      };
+      items.push({ id: filePath, details });
+    } catch (err) {
+      items.push({ id: filePath, details: null, error: log.extractMessage(err) });
     }
   }
+  return items;
+}
+function filterValidItems(items, isTrackerMode, isInlineText) {
   const validItems = items.filter(
     (i) => i.details !== null
   );
   if (validItems.length === 0) {
     const noun = isTrackerMode ? "issues" : isInlineText ? "inline specs" : "files";
     log.error(`No ${noun} could be loaded. Aborting spec generation.`);
-    return { total: items.length, generated: 0, failed: items.length, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+    return null;
   }
-  if (dryRun) {
-    const mode = isTrackerMode ? "tracker" : isInlineText ? "inline" : "file";
-    log.info(`[DRY RUN] Would generate ${validItems.length} spec(s) (mode: ${mode}):
+  return validItems;
+}
+function previewDryRun(validItems, items, isTrackerMode, isInlineText, outputDir, pipelineStart) {
+  const mode = isTrackerMode ? "tracker" : isInlineText ? "inline" : "file";
+  log.info(`[DRY RUN] Would generate ${validItems.length} spec(s) (mode: ${mode}):
 `);
-    for (const { id, details } of validItems) {
-      let filepath;
-      if (isTrackerMode) {
-        const slug = slugify(details.title, 60);
-        filepath = join6(outputDir, `${id}-${slug}.md`);
-      } else {
-        filepath = id;
-      }
-      const label = isTrackerMode ? `#${id}` : filepath;
-      log.info(`[DRY RUN] Would generate spec for ${label}: "${details.title}"`);
-      log.dim(`    \u2192 ${filepath}`);
+  for (const { id, details } of validItems) {
+    let filepath;
+    if (isTrackerMode) {
+      const slug = slugify(details.title, 60);
+      filepath = join7(outputDir, `${id}-${slug}.md`);
+    } else {
+      filepath = id;
     }
-    return {
-      total: items.length,
-      generated: 0,
-      failed: items.filter((i) => i.details === null).length,
-      files: [],
-      issueNumbers: [],
-      durationMs: Date.now() - pipelineStart,
-      fileDurationsMs: {}
-    };
-  }
-  const confirmed = await confirmLargeBatch(validItems.length);
-  if (!confirmed) {
-    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+    const label = isTrackerMode ? `#${id}` : filepath;
+    log.info(`[DRY RUN] Would generate spec for ${label}: "${details.title}"`);
+    log.dim(`    \u2192 ${filepath}`);
   }
+  return {
+    total: items.length,
+    generated: 0,
+    failed: items.filter((i) => i.details === null).length,
+    files: [],
+    issueNumbers: [],
+    durationMs: Date.now() - pipelineStart,
+    fileDurationsMs: {}
+  };
+}
+async function bootPipeline(provider, serverUrl, specCwd, model, source) {
   const bootStart = Date.now();
   log.info(`Booting ${provider} provider...`);
   log.debug(serverUrl ? `Using server URL: ${serverUrl}` : "No --server-url, will spawn local server");
@@ -2593,6 +2855,9 @@ async function runSpecPipeline(opts) {
   console.log(chalk5.dim("  \u2500".repeat(24)));
   console.log("");
   const specAgent = await boot5({ provider: instance, cwd: specCwd });
+  return { specAgent, instance };
+}
+async function generateSpecsBatch(validItems, items, specAgent, instance, isTrackerMode, isInlineText, datasource4, fetchOpts, outputDir, specCwd, concurrency, retries) {
   await mkdir4(outputDir, { recursive: true });
   const generatedFiles = [];
   const issueNumbers = [];
@@ -2611,72 +2876,92 @@ async function runSpecPipeline(opts) {
           log.error(`Skipping item ${id}: missing issue details`);
           return null;
         }
-        let filepath;
-        if (isTrackerMode) {
-          const slug = slugify(details.title, MAX_SLUG_LENGTH);
-          const filename = `${id}-${slug}.md`;
-          filepath = join6(outputDir, filename);
-        } else if (isInlineText) {
-          filepath = id;
-        } else {
-          filepath = id;
-        }
-        try {
-          log.info(`Generating spec for ${isTrackerMode ? `#${id}` : filepath}: ${details.title}...`);
-          const result = await withRetry(
-            () => specAgent.generate({
-              issue: isTrackerMode ? details : void 0,
-              filePath: isTrackerMode ? void 0 : id,
-              fileContent: isTrackerMode ? void 0 : details.body,
-              cwd: specCwd,
-              outputPath: filepath
-            }),
-            retries,
-            { label: `specAgent.generate(${isTrackerMode ? `#${id}` : filepath})` }
-          );
-          if (!result.success) {
-            throw new Error(result.error ?? "Spec generation failed");
-          }
-          if (isTrackerMode || isInlineText) {
-            const h1Title = extractTitle(result.content, filepath);
-            const h1Slug = slugify(h1Title, MAX_SLUG_LENGTH);
-            const finalFilename = isTrackerMode ? `${id}-${h1Slug}.md` : `${h1Slug}.md`;
-            const finalFilepath = join6(outputDir, finalFilename);
-            if (finalFilepath !== filepath) {
-              await rename2(filepath, finalFilepath);
-              filepath = finalFilepath;
-            }
+        const itemBody = async () => {
+          let filepath;
+          if (isTrackerMode) {
+            const slug = slugify(details.title, MAX_SLUG_LENGTH);
+            const filename = `${id}-${slug}.md`;
+            filepath = join7(outputDir, filename);
+          } else if (isInlineText) {
+            filepath = id;
+          } else {
+            filepath = id;
           }
-          const specDuration = Date.now() - specStart;
-          fileDurationsMs[filepath] = specDuration;
-          log.success(`Spec written: ${filepath} (${elapsed(specDuration)})`);
-          let identifier = filepath;
+          fileLoggerStorage.getStore()?.info(`Output path: ${filepath}`);
           try {
-            if (isTrackerMode) {
-              await datasource4.update(id, details.title, result.content, fetchOpts);
-              log.success(`Updated issue #${id} with spec content`);
-              await unlink2(filepath);
-              log.success(`Deleted local spec ${filepath} (now tracked as issue #${id})`);
-              identifier = id;
-              issueNumbers.push(id);
-            } else if (datasource4.name !== "md") {
-              const created = await datasource4.create(details.title, result.content, fetchOpts);
-              log.success(`Created issue #${created.number} from ${filepath}`);
-              await unlink2(filepath);
-              log.success(`Deleted local spec ${filepath} (now tracked as issue #${created.number})`);
-              identifier = created.number;
-              issueNumbers.push(created.number);
+            fileLoggerStorage.getStore()?.info(`Starting spec generation for ${isTrackerMode ? `#${id}` : filepath}`);
+            log.info(`Generating spec for ${isTrackerMode ? `#${id}` : filepath}: ${details.title}...`);
+            const result = await withRetry(
+              () => specAgent.generate({
+                issue: isTrackerMode ? details : void 0,
+                filePath: isTrackerMode ? void 0 : id,
+                fileContent: isTrackerMode ? void 0 : details.body,
+                cwd: specCwd,
+                outputPath: filepath
+              }),
+              retries,
+              { label: `specAgent.generate(${isTrackerMode ? `#${id}` : filepath})` }
+            );
+            if (!result.success) {
+              throw new Error(result.error ?? "Spec generation failed");
+            }
+            fileLoggerStorage.getStore()?.info(`Spec generated successfully`);
+            if (isTrackerMode || isInlineText) {
+              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);
+              if (finalFilepath !== filepath) {
+                await rename2(filepath, finalFilepath);
+                filepath = finalFilepath;
+              }
+            }
+            const specDuration = Date.now() - specStart;
+            fileDurationsMs[filepath] = specDuration;
+            log.success(`Spec written: ${filepath} (${elapsed(specDuration)})`);
+            let identifier = filepath;
+            fileLoggerStorage.getStore()?.phase("Datasource sync");
+            try {
+              if (isTrackerMode) {
+                await datasource4.update(id, details.title, result.data.content, fetchOpts);
+                log.success(`Updated issue #${id} with spec content`);
+                await unlink2(filepath);
+                log.success(`Deleted local spec ${filepath} (now tracked as issue #${id})`);
+                identifier = id;
+                issueNumbers.push(id);
+              } else if (datasource4.name !== "md") {
+                const created = await datasource4.create(details.title, result.data.content, fetchOpts);
+                log.success(`Created issue #${created.number} from ${filepath}`);
+                await unlink2(filepath);
+                log.success(`Deleted local spec ${filepath} (now tracked as issue #${created.number})`);
+                identifier = created.number;
+                issueNumbers.push(created.number);
+              }
+            } catch (err) {
+              const label = isTrackerMode ? `issue #${id}` : filepath;
+              log.warn(`Could not sync ${label} to datasource: ${log.formatErrorChain(err)}`);
             }
+            return { filepath, identifier };
           } catch (err) {
-            const label = isTrackerMode ? `issue #${id}` : filepath;
-            log.warn(`Could not sync ${label} to datasource: ${log.formatErrorChain(err)}`);
+            fileLoggerStorage.getStore()?.error(`Spec generation failed for ${id}: ${log.extractMessage(err)}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
+            log.error(`Failed to generate spec for ${isTrackerMode ? `#${id}` : filepath}: ${log.formatErrorChain(err)}`);
+            log.debug(log.formatErrorChain(err));
+            return null;
           }
-          return { filepath, identifier };
-        } catch (err) {
-          log.error(`Failed to generate spec for ${isTrackerMode ? `#${id}` : filepath}: ${log.formatErrorChain(err)}`);
-          log.debug(log.formatErrorChain(err));
-          return null;
+        };
+        const fileLogger = log.verbose ? new FileLogger(id, specCwd) : null;
+        if (fileLogger) {
+          return fileLoggerStorage.run(fileLogger, async () => {
+            try {
+              fileLogger.phase(`Spec generation: ${id}`);
+              return await itemBody();
+            } finally {
+              fileLogger.close();
+            }
+          });
         }
+        return itemBody();
       })
     );
     for (const result of batchResults) {
@@ -2692,6 +2977,9 @@ async function runSpecPipeline(opts) {
       modelLoggedInBanner = true;
     }
   }
+  return { generatedFiles, issueNumbers, dispatchIdentifiers, failed, fileDurationsMs };
+}
+async function cleanupPipeline(specAgent, instance) {
   try {
     await specAgent.cleanup();
   } catch (err) {
@@ -2702,7 +2990,8 @@ async function runSpecPipeline(opts) {
   } catch (err) {
     log.warn(`Provider cleanup failed: ${log.formatErrorChain(err)}`);
   }
-  const totalDuration = Date.now() - pipelineStart;
+}
+function logSummary(generatedFiles, dispatchIdentifiers, failed, totalDuration) {
   log.info(
     `Spec generation complete: ${generatedFiles.length} generated, ${failed} failed in ${elapsed(totalDuration)}`
   );
@@ -2718,19 +3007,91 @@ async function runSpecPipeline(opts) {
 `);
     }
   }
+}
+async function runSpecPipeline(opts) {
+  const {
+    issues,
+    provider,
+    model,
+    serverUrl,
+    cwd: specCwd,
+    outputDir = join7(specCwd, ".dispatch", "specs"),
+    org,
+    project,
+    workItemType,
+    iteration,
+    area,
+    concurrency = defaultConcurrency(),
+    dryRun,
+    retries = 2
+  } = opts;
+  const pipelineStart = Date.now();
+  const resolved = await resolveDatasource(issues, opts.issueSource, specCwd, org, project, workItemType, iteration, area);
+  if (!resolved) {
+    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  const { source, datasource: datasource4, fetchOpts } = resolved;
+  const isTrackerMode = isIssueNumbers(issues);
+  const isInlineText = !isTrackerMode && !isGlobOrFilePath(issues);
+  let items;
+  if (isTrackerMode) {
+    items = await fetchTrackerItems(issues, datasource4, fetchOpts, concurrency, source);
+    if (items.length === 0) {
+      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+    }
+  } else if (isInlineText) {
+    items = buildInlineTextItem(issues, outputDir);
+  } else {
+    const fileItems = await resolveFileItems(issues, specCwd, concurrency);
+    if (!fileItems) {
+      return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+    }
+    items = fileItems;
+  }
+  const validItems = filterValidItems(items, isTrackerMode, isInlineText);
+  if (!validItems) {
+    return { total: items.length, generated: 0, failed: items.length, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  if (dryRun) {
+    return previewDryRun(validItems, items, isTrackerMode, isInlineText, outputDir, pipelineStart);
+  }
+  const confirmed = await confirmLargeBatch(validItems.length);
+  if (!confirmed) {
+    return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
+  }
+  const { specAgent, instance } = await bootPipeline(provider, serverUrl, specCwd, model, source);
+  const results = await generateSpecsBatch(
+    validItems,
+    items,
+    specAgent,
+    instance,
+    isTrackerMode,
+    isInlineText,
+    datasource4,
+    fetchOpts,
+    outputDir,
+    specCwd,
+    concurrency,
+    retries
+  );
+  await cleanupPipeline(specAgent, instance);
+  const totalDuration = Date.now() - pipelineStart;
+  logSummary(results.generatedFiles, results.dispatchIdentifiers, results.failed, totalDuration);
   return {
     total: items.length,
-    generated: generatedFiles.length,
-    failed,
-    files: generatedFiles,
-    issueNumbers,
-    identifiers: dispatchIdentifiers,
+    generated: results.generatedFiles.length,
+    failed: results.failed,
+    files: results.generatedFiles,
+    issueNumbers: results.issueNumbers,
+    identifiers: results.dispatchIdentifiers,
     durationMs: totalDuration,
-    fileDurationsMs
+    fileDurationsMs: results.fileDurationsMs
   };
 }
 
 // src/orchestrator/dispatch-pipeline.ts
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify9 } from "util";
 import { readFile as readFile7 } from "fs/promises";
 
 // src/parser.ts
@@ -2785,7 +3146,9 @@ async function parseTaskFile(filePath) {
 }
 async function markTaskComplete(task) {
   const content = await readFile6(task.file, "utf-8");
-  const lines = content.split("\n");
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
   const lineIndex = task.line - 1;
   if (lineIndex < 0 || lineIndex >= lines.length) {
     throw new Error(
@@ -2800,7 +3163,7 @@ async function markTaskComplete(task) {
     );
   }
   lines[lineIndex] = updated;
-  await writeFile5(task.file, lines.join("\n"), "utf-8");
+  await writeFile5(task.file, lines.join(eol), "utf-8");
 }
 function groupTasksByMode(tasks) {
   if (tasks.length === 0) return [];
@@ -2830,6 +3193,7 @@ function groupTasksByMode(tasks) {
 
 // src/agents/planner.ts
 init_logger();
+init_file_logger();
 async function boot6(opts) {
   const { provider, cwd } = opts;
   if (!provider) {
@@ -2837,25 +3201,31 @@ async function boot6(opts) {
   }
   return {
     name: "planner",
-    async plan(task, fileContext, cwdOverride) {
+    async plan(task, fileContext, cwdOverride, worktreeRoot) {
+      const startTime = Date.now();
       try {
         const sessionId = await provider.createSession();
-        const prompt = buildPlannerPrompt(task, cwdOverride ?? cwd, fileContext);
+        const prompt = buildPlannerPrompt(task, cwdOverride ?? cwd, fileContext, worktreeRoot);
+        fileLoggerStorage.getStore()?.prompt("planner", prompt);
         const plan = await provider.prompt(sessionId, prompt);
+        if (plan) fileLoggerStorage.getStore()?.response("planner", plan);
         if (!plan?.trim()) {
-          return { prompt: "", success: false, error: "Planner returned empty plan" };
+          return { data: null, success: false, error: "Planner returned empty plan", durationMs: Date.now() - startTime };
         }
-        return { prompt: plan, success: true };
+        fileLoggerStorage.getStore()?.agentEvent("planner", "completed", `${Date.now() - startTime}ms`);
+        return { data: { prompt: plan }, success: true, durationMs: Date.now() - startTime };
       } catch (err) {
         const message = log.extractMessage(err);
-        return { prompt: "", success: false, error: message };
+        fileLoggerStorage.getStore()?.error(`planner error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
+        return { data: null, success: false, error: message, durationMs: Date.now() - startTime };
       }
     },
     async cleanup() {
     }
   };
 }
-function buildPlannerPrompt(task, cwd, fileContext) {
+function buildPlannerPrompt(task, cwd, fileContext, worktreeRoot) {
   const sections = [
     `You are a **planning agent**. Your job is to explore the codebase, understand the task below, and produce a detailed execution prompt that another agent will follow to implement the changes.`,
     ``,
@@ -2879,6 +3249,21 @@ function buildPlannerPrompt(task, cwd, fileContext) {
       `\`\`\``
     );
   }
+  if (worktreeRoot) {
+    sections.push(
+      ``,
+      `## Worktree Isolation`,
+      ``,
+      `You are operating inside a git worktree. All file operations MUST be confined`,
+      `to the following directory tree:`,
+      ``,
+      `    ${worktreeRoot}`,
+      ``,
+      `- Do NOT read, write, or execute commands that access files outside this directory.`,
+      `- Do NOT reference or modify files in the main repository working tree or other worktrees.`,
+      `- All relative paths must resolve within the worktree root above.`
+    );
+  }
   sections.push(
     ``,
     `## Instructions`,
@@ -2914,26 +3299,32 @@ function buildPlannerPrompt(task, cwd, fileContext) {
 
 // src/dispatcher.ts
 init_logger();
-async function dispatchTask(instance, task, cwd, plan) {
+init_file_logger();
+async function dispatchTask(instance, task, cwd, plan, worktreeRoot) {
   try {
     log.debug(`Dispatching task: ${task.file}:${task.line} \u2014 ${task.text.slice(0, 80)}`);
     const sessionId = await instance.createSession();
-    const prompt = plan ? buildPlannedPrompt(task, cwd, plan) : buildPrompt(task, cwd);
+    const prompt = plan ? buildPlannedPrompt(task, cwd, plan, worktreeRoot) : buildPrompt(task, cwd, worktreeRoot);
     log.debug(`Prompt built (${prompt.length} chars, ${plan ? "with plan" : "no plan"})`);
+    fileLoggerStorage.getStore()?.prompt("dispatchTask", prompt);
     const response = await instance.prompt(sessionId, prompt);
     if (response === null) {
       log.debug("Task dispatch returned null response");
+      fileLoggerStorage.getStore()?.warn("dispatchTask: null response");
       return { task, success: false, error: "No response from agent" };
     }
     log.debug(`Task dispatch completed (${response.length} chars response)`);
+    fileLoggerStorage.getStore()?.response("dispatchTask", response);
     return { task, success: true };
   } catch (err) {
     const message = log.extractMessage(err);
     log.debug(`Task dispatch failed: ${log.formatErrorChain(err)}`);
+    fileLoggerStorage.getStore()?.error(`dispatchTask error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
     return { task, success: false, error: message };
   }
 }
-function buildPrompt(task, cwd) {
+function buildPrompt(task, cwd, worktreeRoot) {
   return [
     `You are completing a task from a markdown task file.`,
     ``,
@@ -2945,10 +3336,11 @@ function buildPrompt(task, cwd) {
     `- Complete ONLY this specific task \u2014 do not work on other tasks.`,
     `- Make the minimal, correct changes needed.`,
     buildCommitInstruction(task.text),
+    ...buildWorktreeIsolation(worktreeRoot),
     `- When finished, confirm by saying "Task complete."`
   ].join("\n");
 }
-function buildPlannedPrompt(task, cwd, plan) {
+function buildPlannedPrompt(task, cwd, plan, worktreeRoot) {
   return [
     `You are an **executor agent** completing a task that has been pre-planned by a planner agent.`,
     `The planner has already explored the codebase and produced detailed instructions below.`,
@@ -2973,6 +3365,7 @@ function buildPlannedPrompt(task, cwd, plan) {
     `- Do NOT re-plan, question, or revise the plan. Trust it as given and execute it faithfully.`,
     `- Do NOT search for additional context using grep, find, or similar tools unless the plan explicitly instructs you to.`,
     buildCommitInstruction(task.text),
+    ...buildWorktreeIsolation(worktreeRoot),
     `- When finished, confirm by saying "Task complete."`
   ].join("\n");
 }
@@ -2985,9 +3378,16 @@ function buildCommitInstruction(taskText) {
   }
   return `- Do NOT commit changes \u2014 the orchestrator handles commits.`;
 }
+function buildWorktreeIsolation(worktreeRoot) {
+  if (!worktreeRoot) return [];
+  return [
+    `- **Worktree isolation:** You are operating inside a git worktree at \`${worktreeRoot}\`. You MUST NOT read, write, or execute commands that access files outside this directory. All file paths must resolve within \`${worktreeRoot}\`.`
+  ];
+}
 
 // src/agents/executor.ts
 init_logger();
+init_file_logger();
 async function boot7(opts) {
   const { provider } = opts;
   if (!provider) {
@@ -2995,28 +3395,24 @@ async function boot7(opts) {
   }
   return {
     name: "executor",
-    async execute(input2) {
-      const { task, cwd, plan } = input2;
+    async execute(input3) {
+      const { task, cwd, plan, worktreeRoot } = input3;
       const startTime = Date.now();
       try {
-        const result = await dispatchTask(provider, task, cwd, plan ?? void 0);
+        fileLoggerStorage.getStore()?.agentEvent("executor", "started", task.text);
+        const result = await dispatchTask(provider, task, cwd, plan ?? void 0, worktreeRoot);
         if (result.success) {
           await markTaskComplete(task);
+          fileLoggerStorage.getStore()?.agentEvent("executor", "completed", `${Date.now() - startTime}ms`);
+          return { data: { dispatchResult: result }, success: true, durationMs: Date.now() - startTime };
         }
-        return {
-          dispatchResult: result,
-          success: result.success,
-          error: result.error,
-          elapsedMs: Date.now() - startTime
-        };
+        fileLoggerStorage.getStore()?.agentEvent("executor", "failed", result.error ?? "unknown error");
+        return { data: null, success: false, error: result.error, durationMs: Date.now() - startTime };
       } catch (err) {
         const message = log.extractMessage(err);
-        return {
-          dispatchResult: { task, success: false, error: message },
-          success: false,
-          error: message,
-          elapsedMs: Date.now() - startTime
-        };
+        fileLoggerStorage.getStore()?.error(`executor error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
+        return { data: null, success: false, error: message, durationMs: Date.now() - startTime };
       }
     },
     async cleanup() {
@@ -3026,8 +3422,9 @@ async function boot7(opts) {
 
 // src/agents/commit.ts
 init_logger();
+init_file_logger();
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8, resolve as resolve2 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 async function boot8(opts) {
   const { provider } = opts;
@@ -3040,14 +3437,17 @@ async function boot8(opts) {
     name: "commit",
     async generate(genOpts) {
       try {
-        const tmpDir = join7(genOpts.cwd, ".dispatch", "tmp");
+        const resolvedCwd = resolve2(genOpts.cwd);
+        const tmpDir = join8(resolvedCwd, ".dispatch", "tmp");
         await mkdir5(tmpDir, { recursive: true });
         const tmpFilename = `commit-${randomUUID4()}.md`;
-        const tmpPath = join7(tmpDir, tmpFilename);
+        const tmpPath = join8(tmpDir, tmpFilename);
         const prompt = buildCommitPrompt(genOpts);
+        fileLoggerStorage.getStore()?.prompt("commit", prompt);
         const sessionId = await provider.createSession();
         log.debug(`Commit prompt built (${prompt.length} chars)`);
         const response = await provider.prompt(sessionId, prompt);
+        if (response) fileLoggerStorage.getStore()?.response("commit", response);
         if (!response?.trim()) {
           return {
             commitMessage: "",
@@ -3071,12 +3471,15 @@ async function boot8(opts) {
         const outputContent = formatOutputFile(parsed);
         await writeFile6(tmpPath, outputContent, "utf-8");
         log.debug(`Wrote commit agent output to ${tmpPath}`);
+        fileLoggerStorage.getStore()?.agentEvent("commit", "completed", `message: ${parsed.commitMessage.slice(0, 80)}`);
         return {
           ...parsed,
           success: true,
           outputPath: tmpPath
         };
       } catch (err) {
+        fileLoggerStorage.getStore()?.error(`commit error: ${log.extractMessage(err)}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
         const message = log.extractMessage(err);
         return {
           commitMessage: "",
@@ -3217,9 +3620,10 @@ init_logger();
 init_cleanup();
 
 // src/helpers/worktree.ts
-import { join as join8, basename } from "path";
+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";
@@ -3230,13 +3634,16 @@ async function git2(args, cwd) {
 function worktreeName(issueFilename) {
   const base = basename(issueFilename);
   const withoutExt = base.replace(/\.md$/i, "");
-  return slugify(withoutExt);
+  const match = withoutExt.match(/^(\d+)/);
+  return match ? `issue-${match[1]}` : slugify(withoutExt);
 }
-async function createWorktree(repoRoot, issueFilename, branchName) {
+async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
   const name = worktreeName(issueFilename);
-  const worktreePath = join8(repoRoot, WORKTREE_DIR, name);
+  const worktreePath = join9(repoRoot, WORKTREE_DIR, name);
   try {
-    await git2(["worktree", "add", worktreePath, "-b", branchName], repoRoot);
+    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);
@@ -3251,7 +3658,7 @@ async function createWorktree(repoRoot, issueFilename, branchName) {
 }
 async function removeWorktree(repoRoot, issueFilename) {
   const name = worktreeName(issueFilename);
-  const worktreePath = join8(repoRoot, WORKTREE_DIR, name);
+  const worktreePath = join9(repoRoot, WORKTREE_DIR, name);
   try {
     await git2(["worktree", "remove", worktreePath], repoRoot);
   } catch {
@@ -3268,6 +3675,11 @@ async function removeWorktree(repoRoot, issueFilename) {
     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";
@@ -3481,13 +3893,24 @@ function render(state) {
   return lines.join("\n");
 }
 function draw(state) {
-  if (lastLineCount > 0) {
-    process.stdout.write(`\x1B[${lastLineCount}A\x1B[0J`);
-  }
   const output = render(state);
-  process.stdout.write(output);
   const cols = process.stdout.columns || 80;
-  lastLineCount = countVisualRows(output, cols);
+  const newLineCount = countVisualRows(output, cols);
+  let buffer = "";
+  if (lastLineCount > 0) {
+    buffer += `\x1B[${lastLineCount}A`;
+  }
+  const lines = output.split("\n");
+  buffer += lines.map((line) => line + "\x1B[K").join("\n");
+  const leftover = lastLineCount - newLineCount;
+  if (leftover > 0) {
+    for (let i = 0; i < leftover; i++) {
+      buffer += "\n\x1B[K";
+    }
+    buffer += `\x1B[${leftover}A`;
+  }
+  process.stdout.write(buffer);
+  lastLineCount = newLineCount;
 }
 function createTui() {
   const state = {
@@ -3517,7 +3940,7 @@ init_providers();
 
 // src/orchestrator/datasource-helpers.ts
 init_logger();
-import { basename as basename2, join as join9 } from "path";
+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";
@@ -3545,13 +3968,13 @@ async function fetchItemsById(issueIds, datasource4, fetchOpts) {
   return items;
 }
 async function writeItemsToTempDir(items) {
-  const tempDir = await mkdtemp(join9(tmpdir(), "dispatch-"));
+  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 = join9(tempDir, filename);
+    const filepath = join10(tempDir, filename);
     await writeFile7(filepath, item.body, "utf-8");
     files.push(filepath);
     issueDetailsByFile.set(filepath, item);
@@ -3564,34 +3987,6 @@ async function writeItemsToTempDir(items) {
   });
   return { files, issueDetailsByFile };
 }
-async function closeCompletedSpecIssues(taskFiles, results, cwd, source, org, project, workItemType) {
-  let datasourceName = source;
-  if (!datasourceName) {
-    datasourceName = await detectDatasource(cwd) ?? void 0;
-  }
-  if (!datasourceName) return;
-  const datasource4 = getDatasource(datasourceName);
-  const succeededTasks = new Set(
-    results.filter((r) => r.success).map((r) => r.task)
-  );
-  const fetchOpts = { cwd, org, project, workItemType };
-  for (const taskFile of taskFiles) {
-    const fileTasks = taskFile.tasks;
-    if (fileTasks.length === 0) continue;
-    const allSucceeded = fileTasks.every((t) => succeededTasks.has(t));
-    if (!allSucceeded) continue;
-    const parsed = parseIssueFilename(taskFile.path);
-    if (!parsed) continue;
-    const { issueId } = parsed;
-    const filename = basename2(taskFile.path);
-    try {
-      await datasource4.close(issueId, fetchOpts);
-      log.success(`Closed issue #${issueId} (all tasks in ${filename} completed)`);
-    } catch (err) {
-      log.warn(`Could not close issue #${issueId}: ${log.formatErrorChain(err)}`);
-    }
-  }
-}
 async function getCommitSummaries(defaultBranch, cwd) {
   try {
     const { stdout } = await exec8(
@@ -3675,48 +4070,51 @@ async function buildPrTitle(issueTitle, defaultBranch, cwd) {
   }
   return `${commits[commits.length - 1]} (+${commits.length - 1} more)`;
 }
-
-// src/helpers/timeout.ts
-var TimeoutError = class extends Error {
-  /** Optional label identifying the operation that timed out. */
-  label;
-  constructor(ms, label) {
-    const suffix = label ? ` [${label}]` : "";
-    super(`Timed out after ${ms}ms${suffix}`);
-    this.name = "TimeoutError";
-    this.label = label;
+function buildFeaturePrTitle(featureBranchName, issues) {
+  if (issues.length === 1) {
+    return issues[0].title;
   }
-};
-function withTimeout(promise, ms, label) {
-  const p = new Promise((resolve2, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      reject(new TimeoutError(ms, label));
-    }, ms);
-    promise.then(
-      (value) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        resolve2(value);
-      },
-      (err) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        reject(err);
-      }
-    );
-  });
-  p.catch(() => {
+  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;
   });
-  return p;
+  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) {
@@ -3728,12 +4126,15 @@ async function runDispatchPipeline(opts, cwd) {
     noPlan,
     noBranch,
     noWorktree,
+    feature,
     provider = "opencode",
     model,
     source,
     org,
     project,
     workItemType,
+    iteration,
+    area,
     planTimeout,
     planRetries,
     retries
@@ -3742,7 +4143,7 @@ async function runDispatchPipeline(opts, cwd) {
   const maxPlanAttempts = (planRetries ?? retries ?? DEFAULT_PLAN_RETRIES) + 1;
   log.debug(`Plan timeout: ${planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN}m (${planTimeoutMs}ms), max attempts: ${maxPlanAttempts}`);
   if (dryRun) {
-    return dryRunMode(issueIds, cwd, source, org, project, workItemType);
+    return dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area);
   }
   const verbose = log.verbose;
   let tui;
@@ -3778,7 +4179,7 @@ async function runDispatchPipeline(opts, cwd) {
       return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
     }
     const datasource4 = getDatasource(source);
-    const fetchOpts = { cwd, org, project, workItemType };
+    const fetchOpts = { cwd, org, project, workItemType, iteration, area };
     const items = issueIds.length > 0 ? await fetchItemsById(issueIds, datasource4, fetchOpts) : await datasource4.list(fetchOpts);
     if (items.length === 0) {
       tui.state.phase = "done";
@@ -3820,7 +4221,7 @@ async function runDispatchPipeline(opts, cwd) {
       list.push(task);
       tasksByFile.set(task.file, list);
     }
-    const useWorktrees = !noWorktree && !noBranch && tasksByFile.size > 1;
+    const useWorktrees = !noWorktree && (feature || !noBranch && tasksByFile.size > 1);
     tui.state.phase = "booting";
     if (verbose) log.info(`Booting ${provider} provider...`);
     if (serverUrl) {
@@ -3848,6 +4249,30 @@ async function runDispatchPipeline(opts, cwd) {
     let completed = 0;
     let failed = 0;
     const lifecycleOpts = { cwd };
+    let featureBranchName;
+    let featureDefaultBranch;
+    if (feature) {
+      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}`);
+        registerCleanup(async () => {
+          try {
+            await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+          } catch {
+          }
+        });
+        await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+        log.debug(`Switched back to ${featureDefaultBranch} for worktree creation`);
+      } catch (err) {
+        log.error(`Feature branch creation failed: ${log.extractMessage(err)}`);
+        tui.state.phase = "done";
+        tui.stop();
+        return { total: allTasks.length, completed: 0, failed: allTasks.length, skipped: 0, results: [] };
+      }
+    }
     let username = "";
     try {
       username = await datasource4.getUsername(lifecycleOpts);
@@ -3856,275 +4281,373 @@ async function runDispatchPipeline(opts, cwd) {
     }
     const processIssueFile = async (file, fileTasks) => {
       const details = issueDetailsByFile.get(file);
-      let defaultBranch;
-      let branchName;
-      let worktreePath;
-      let issueCwd = cwd;
-      if (!noBranch && details) {
-        try {
-          defaultBranch = await datasource4.getDefaultBranch(lifecycleOpts);
-          branchName = datasource4.buildBranchName(details.number, details.title, username);
-          if (useWorktrees) {
-            worktreePath = await createWorktree(cwd, file, branchName);
-            registerCleanup(async () => {
-              await removeWorktree(cwd, file);
-            });
-            issueCwd = worktreePath;
-            log.debug(`Created worktree for issue #${details.number} at ${worktreePath}`);
-            const wtName = worktreeName(file);
+      const fileLogger = verbose && details ? new FileLogger(details.number, cwd) : null;
+      const body = async () => {
+        let defaultBranch;
+        let branchName;
+        let worktreePath;
+        let issueCwd = cwd;
+        if (!noBranch && details) {
+          fileLogger?.phase("Branch/worktree setup");
+          try {
+            defaultBranch = feature ? featureBranchName : await datasource4.getDefaultBranch(lifecycleOpts);
+            branchName = datasource4.buildBranchName(details.number, details.title, username);
+            if (useWorktrees) {
+              worktreePath = await createWorktree(cwd, file, branchName, ...feature && featureBranchName ? [featureBranchName] : []);
+              registerCleanup(async () => {
+                await removeWorktree(cwd, file);
+              });
+              issueCwd = worktreePath;
+              log.debug(`Created worktree for issue #${details.number} at ${worktreePath}`);
+              fileLogger?.info(`Worktree created at ${worktreePath}`);
+              const wtName = worktreeName(file);
+              for (const task of fileTasks) {
+                const tuiTask = tui.state.tasks.find((t) => t.task === task);
+                if (tuiTask) tuiTask.worktree = wtName;
+              }
+            } else if (datasource4.supportsGit()) {
+              await datasource4.createAndSwitchBranch(branchName, lifecycleOpts);
+              log.debug(`Switched to branch ${branchName}`);
+              fileLogger?.info(`Switched to branch ${branchName}`);
+            }
+          } catch (err) {
+            const errorMsg = `Branch creation failed for issue #${details.number}: ${log.extractMessage(err)}`;
+            fileLogger?.error(`Branch creation failed: ${log.extractMessage(err)}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
+            log.error(errorMsg);
             for (const task of fileTasks) {
               const tuiTask = tui.state.tasks.find((t) => t.task === task);
-              if (tuiTask) tuiTask.worktree = wtName;
-            }
-          } else {
-            await datasource4.createAndSwitchBranch(branchName, lifecycleOpts);
-            log.debug(`Switched to branch ${branchName}`);
-          }
-        } catch (err) {
-          const errorMsg = `Branch creation failed for issue #${details.number}: ${log.extractMessage(err)}`;
-          log.error(errorMsg);
-          for (const task of fileTasks) {
-            const tuiTask = tui.state.tasks.find((t) => t.task === task);
-            if (tuiTask) {
-              tuiTask.status = "failed";
-              tuiTask.error = errorMsg;
+              if (tuiTask) {
+                tuiTask.status = "failed";
+                tuiTask.error = errorMsg;
+              }
+              results.push({ task, success: false, error: errorMsg });
             }
-            results.push({ task, success: false, error: errorMsg });
+            failed += fileTasks.length;
+            return;
           }
-          failed += fileTasks.length;
-          return;
         }
-      }
-      const issueLifecycleOpts = { cwd: issueCwd };
-      let localInstance;
-      let localPlanner;
-      let localExecutor;
-      let localCommitAgent;
-      if (useWorktrees) {
-        localInstance = await bootProvider(provider, { url: serverUrl, cwd: issueCwd, model });
-        registerCleanup(() => localInstance.cleanup());
-        if (localInstance.model && !tui.state.model) {
-          tui.state.model = localInstance.model;
+        const worktreeRoot = useWorktrees ? worktreePath : void 0;
+        const issueLifecycleOpts = { cwd: issueCwd };
+        fileLogger?.phase("Provider/agent boot");
+        let localInstance;
+        let localPlanner;
+        let localExecutor;
+        let localCommitAgent;
+        if (useWorktrees) {
+          localInstance = await bootProvider(provider, { url: serverUrl, cwd: issueCwd, model });
+          registerCleanup(() => localInstance.cleanup());
+          if (localInstance.model && !tui.state.model) {
+            tui.state.model = localInstance.model;
+          }
+          if (verbose && localInstance.model) log.debug(`Model: ${localInstance.model}`);
+          localPlanner = noPlan ? null : await boot6({ provider: localInstance, cwd: issueCwd });
+          localExecutor = await boot7({ provider: localInstance, cwd: issueCwd });
+          localCommitAgent = await boot8({ provider: localInstance, cwd: issueCwd });
+          fileLogger?.info(`Provider booted: ${localInstance.model ?? provider}`);
+        } else {
+          localInstance = instance;
+          localPlanner = planner;
+          localExecutor = executor;
+          localCommitAgent = commitAgent;
         }
-        if (verbose && localInstance.model) log.debug(`Model: ${localInstance.model}`);
-        localPlanner = noPlan ? null : await boot6({ provider: localInstance, cwd: issueCwd });
-        localExecutor = await boot7({ provider: localInstance, cwd: issueCwd });
-        localCommitAgent = await boot8({ provider: localInstance, cwd: issueCwd });
-      } else {
-        localInstance = instance;
-        localPlanner = planner;
-        localExecutor = executor;
-        localCommitAgent = commitAgent;
-      }
-      const groups = groupTasksByMode(fileTasks);
-      const issueResults = [];
-      for (const group of groups) {
-        const groupQueue = [...group];
-        while (groupQueue.length > 0) {
-          const batch = groupQueue.splice(0, concurrency);
-          const batchResults = await Promise.all(
-            batch.map(async (task) => {
-              const tuiTask = tui.state.tasks.find((t) => t.task === task);
-              const startTime = Date.now();
-              tuiTask.elapsed = startTime;
-              let plan;
-              if (localPlanner) {
-                tuiTask.status = "planning";
-                if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: planning \u2014 "${task.text}"`);
-                const rawContent = fileContentMap.get(task.file);
-                const fileContext = rawContent ? buildTaskContext(rawContent, task) : void 0;
-                let planResult;
-                for (let attempt = 1; attempt <= maxPlanAttempts; attempt++) {
-                  try {
-                    planResult = await withTimeout(
-                      localPlanner.plan(task, fileContext, issueCwd),
-                      planTimeoutMs,
-                      "planner.plan()"
-                    );
-                    break;
-                  } catch (err) {
-                    if (err instanceof TimeoutError) {
-                      log.warn(
-                        `Planning timed out for task "${task.text}" (attempt ${attempt}/${maxPlanAttempts})`
+        const groups = groupTasksByMode(fileTasks);
+        const issueResults = [];
+        for (const group of groups) {
+          const groupQueue = [...group];
+          while (groupQueue.length > 0) {
+            const batch = groupQueue.splice(0, concurrency);
+            const batchResults = await Promise.all(
+              batch.map(async (task) => {
+                const tuiTask = tui.state.tasks.find((t) => t.task === task);
+                const startTime = Date.now();
+                tuiTask.elapsed = startTime;
+                let plan;
+                if (localPlanner) {
+                  tuiTask.status = "planning";
+                  fileLogger?.phase(`Planning task: ${task.text}`);
+                  if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: planning \u2014 "${task.text}"`);
+                  const rawContent = fileContentMap.get(task.file);
+                  const fileContext = rawContent ? buildTaskContext(rawContent, task) : void 0;
+                  let planResult;
+                  for (let attempt = 1; attempt <= maxPlanAttempts; attempt++) {
+                    try {
+                      planResult = await withTimeout(
+                        localPlanner.plan(task, fileContext, issueCwd, worktreeRoot),
+                        planTimeoutMs,
+                        "planner.plan()"
                       );
-                      if (attempt < maxPlanAttempts) {
-                        log.debug(`Retrying planning (attempt ${attempt + 1}/${maxPlanAttempts})`);
-                      }
-                    } else {
-                      planResult = {
-                        prompt: "",
-                        success: false,
-                        error: log.extractMessage(err)
-                      };
                       break;
+                    } catch (err) {
+                      if (err instanceof TimeoutError) {
+                        log.warn(
+                          `Planning timed out for task "${task.text}" (attempt ${attempt}/${maxPlanAttempts})`
+                        );
+                        fileLogger?.warn(`Planning timeout (attempt ${attempt}/${maxPlanAttempts})`);
+                        if (attempt < maxPlanAttempts) {
+                          log.debug(`Retrying planning (attempt ${attempt + 1}/${maxPlanAttempts})`);
+                          fileLogger?.info(`Retrying planning (attempt ${attempt + 1}/${maxPlanAttempts})`);
+                        }
+                      } else {
+                        planResult = {
+                          data: null,
+                          success: false,
+                          error: log.extractMessage(err),
+                          durationMs: 0
+                        };
+                        break;
+                      }
                     }
                   }
+                  if (!planResult) {
+                    const timeoutMin = planTimeout ?? 10;
+                    planResult = {
+                      data: null,
+                      success: false,
+                      error: `Planning timed out after ${timeoutMin}m (${maxPlanAttempts} attempts)`,
+                      durationMs: 0
+                    };
+                  }
+                  if (!planResult.success) {
+                    tuiTask.status = "failed";
+                    tuiTask.error = `Planning failed: ${planResult.error}`;
+                    fileLogger?.error(`Planning failed: ${planResult.error}`);
+                    tuiTask.elapsed = Date.now() - startTime;
+                    if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 ${tuiTask.error} (${elapsed(tuiTask.elapsed)})`);
+                    failed++;
+                    return { task, success: false, error: tuiTask.error };
+                  }
+                  plan = planResult.data.prompt;
+                  fileLogger?.info(`Planning completed (${planResult.durationMs ?? 0}ms)`);
                 }
-                if (!planResult) {
-                  const timeoutMin = planTimeout ?? 10;
-                  planResult = {
-                    prompt: "",
-                    success: false,
-                    error: `Planning timed out after ${timeoutMin}m (${maxPlanAttempts} attempts)`
-                  };
-                }
-                if (!planResult.success) {
+                tuiTask.status = "running";
+                fileLogger?.phase(`Executing task: ${task.text}`);
+                if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: executing \u2014 "${task.text}"`);
+                const execRetries = 2;
+                const execResult = await withRetry(
+                  async () => {
+                    const result = await localExecutor.execute({
+                      task,
+                      cwd: issueCwd,
+                      plan: plan ?? null,
+                      worktreeRoot
+                    });
+                    if (!result.success) {
+                      throw new Error(result.error ?? "Execution failed");
+                    }
+                    return result;
+                  },
+                  execRetries,
+                  { label: `executor "${task.text}"` }
+                ).catch((err) => ({
+                  data: null,
+                  success: false,
+                  error: log.extractMessage(err),
+                  durationMs: 0
+                }));
+                if (execResult.success) {
+                  fileLogger?.info(`Execution completed successfully (${Date.now() - startTime}ms)`);
+                  try {
+                    const parsed = parseIssueFilename(task.file);
+                    if (parsed) {
+                      const updatedContent = await readFile7(task.file, "utf-8");
+                      const issueDetails = issueDetailsByFile.get(task.file);
+                      const title = issueDetails?.title ?? parsed.slug;
+                      await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
+                      log.success(`Synced task completion to issue #${parsed.issueId}`);
+                    }
+                  } catch (err) {
+                    log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
+                  }
+                  tuiTask.status = "done";
+                  tuiTask.elapsed = Date.now() - startTime;
+                  if (verbose) log.success(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: done \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})`);
+                  completed++;
+                } else {
+                  fileLogger?.error(`Execution failed: ${execResult.error}`);
                   tuiTask.status = "failed";
-                  tuiTask.error = `Planning failed: ${planResult.error}`;
+                  tuiTask.error = execResult.error;
                   tuiTask.elapsed = Date.now() - startTime;
-                  if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 ${tuiTask.error} (${elapsed(tuiTask.elapsed)})`);
+                  if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})${tuiTask.error ? `: ${tuiTask.error}` : ""}`);
                   failed++;
-                  return { task, success: false, error: tuiTask.error };
                 }
-                plan = planResult.prompt;
-              }
-              tuiTask.status = "running";
-              if (verbose) log.info(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: executing \u2014 "${task.text}"`);
-              const execRetries = 2;
-              const execResult = await withRetry(
-                async () => {
-                  const result = await localExecutor.execute({
-                    task,
-                    cwd: issueCwd,
-                    plan: plan ?? null
-                  });
-                  if (!result.success) {
-                    throw new Error(result.error ?? "Execution failed");
-                  }
-                  return result;
-                },
-                execRetries,
-                { label: `executor "${task.text}"` }
-              ).catch((err) => ({
-                dispatchResult: { task, success: false, error: log.extractMessage(err) },
-                success: false,
-                error: log.extractMessage(err),
-                elapsedMs: 0
-              }));
-              if (execResult.success) {
+                const dispatchResult = execResult.success ? execResult.data.dispatchResult : {
+                  task,
+                  success: false,
+                  error: execResult.error ?? "Executor failed without returning a dispatch result."
+                };
+                return dispatchResult;
+              })
+            );
+            issueResults.push(...batchResults);
+            if (!tui.state.model && localInstance.model) {
+              tui.state.model = localInstance.model;
+            }
+          }
+        }
+        results.push(...issueResults);
+        if (!noBranch && branchName && defaultBranch && details && datasource4.supportsGit()) {
+          try {
+            await datasource4.commitAllChanges(
+              `chore: stage uncommitted changes for issue #${details.number}`,
+              issueLifecycleOpts
+            );
+            log.debug(`Staged uncommitted changes for issue #${details.number}`);
+          } catch (err) {
+            log.warn(`Could not commit uncommitted changes for issue #${details.number}: ${log.formatErrorChain(err)}`);
+          }
+        }
+        fileLogger?.phase("Commit generation");
+        let commitAgentResult;
+        if (!noBranch && branchName && defaultBranch && details && datasource4.supportsGit()) {
+          try {
+            const branchDiff = await getBranchDiff(defaultBranch, issueCwd);
+            if (branchDiff) {
+              const result = await localCommitAgent.generate({
+                branchDiff,
+                issue: details,
+                taskResults: issueResults,
+                cwd: issueCwd,
+                worktreeRoot
+              });
+              if (result.success) {
+                commitAgentResult = result;
+                fileLogger?.info(`Commit message generated for issue #${details.number}`);
                 try {
-                  const parsed = parseIssueFilename(task.file);
-                  if (parsed) {
-                    const updatedContent = await readFile7(task.file, "utf-8");
-                    const issueDetails = issueDetailsByFile.get(task.file);
-                    const title = issueDetails?.title ?? parsed.slug;
-                    await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
-                    log.success(`Synced task completion to issue #${parsed.issueId}`);
-                  }
+                  await squashBranchCommits(defaultBranch, result.commitMessage, issueCwd);
+                  log.debug(`Rewrote commit message for issue #${details.number}`);
+                  fileLogger?.info(`Rewrote commit history for issue #${details.number}`);
                 } catch (err) {
-                  log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
+                  log.warn(`Could not rewrite commit message for issue #${details.number}: ${log.formatErrorChain(err)}`);
                 }
-                tuiTask.status = "done";
-                tuiTask.elapsed = Date.now() - startTime;
-                if (verbose) log.success(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: done \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})`);
-                completed++;
               } else {
-                tuiTask.status = "failed";
-                tuiTask.error = execResult.error;
-                tuiTask.elapsed = Date.now() - startTime;
-                if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: failed \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})${tuiTask.error ? `: ${tuiTask.error}` : ""}`);
-                failed++;
+                log.warn(`Commit agent failed for issue #${details.number}: ${result.error}`);
+                fileLogger?.warn(`Commit agent failed: ${result.error}`);
               }
-              return execResult.dispatchResult;
-            })
-          );
-          issueResults.push(...batchResults);
-          if (!tui.state.model && localInstance.model) {
-            tui.state.model = localInstance.model;
+            }
+          } catch (err) {
+            log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
           }
         }
-      }
-      results.push(...issueResults);
-      if (!noBranch && branchName && defaultBranch && details) {
-        try {
-          await datasource4.commitAllChanges(
-            `chore: stage uncommitted changes for issue #${details.number}`,
-            issueLifecycleOpts
-          );
-          log.debug(`Staged uncommitted changes for issue #${details.number}`);
-        } catch (err) {
-          log.warn(`Could not commit uncommitted changes for issue #${details.number}: ${log.formatErrorChain(err)}`);
-        }
-      }
-      let commitAgentResult;
-      if (!noBranch && branchName && defaultBranch && details) {
-        try {
-          const branchDiff = await getBranchDiff(defaultBranch, issueCwd);
-          if (branchDiff) {
-            const result = await localCommitAgent.generate({
-              branchDiff,
-              issue: details,
-              taskResults: issueResults,
-              cwd: issueCwd
-            });
-            if (result.success) {
-              commitAgentResult = result;
+        fileLogger?.phase("PR lifecycle");
+        if (!noBranch && branchName && defaultBranch && details) {
+          if (feature && featureBranchName) {
+            if (worktreePath) {
               try {
-                await squashBranchCommits(defaultBranch, result.commitMessage, issueCwd);
-                log.debug(`Rewrote commit message for issue #${details.number}`);
+                await removeWorktree(cwd, file);
               } catch (err) {
-                log.warn(`Could not rewrite commit message for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                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 });
+              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 });
+              } catch {
+              }
+              for (const task of fileTasks) {
+                const tuiTask = tui.state.tasks.find((t) => t.task === task);
+                if (tuiTask) {
+                  tuiTask.status = "failed";
+                  tuiTask.error = mergeError;
+                }
+                const existingResult = results.find((r) => r.task === task);
+                if (existingResult) {
+                  existingResult.success = false;
+                  existingResult.error = mergeError;
+                }
+              }
+              return;
+            }
+            try {
+              await exec9("git", ["branch", "-d", branchName], { cwd });
+              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 (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 = commitAgentResult?.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
+                const prBody = commitAgentResult?.prDescription || await buildPrBody(
+                  details,
+                  fileTasks,
+                  issueResults,
+                  defaultBranch,
+                  datasource4.name,
+                  issueLifecycleOpts.cwd
+                );
+                const prUrl = await datasource4.createPullRequest(
+                  branchName,
+                  details.number,
+                  prTitle,
+                  prBody,
+                  issueLifecycleOpts
+                );
+                if (prUrl) {
+                  log.success(`Created PR for issue #${details.number}: ${prUrl}`);
+                  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) {
+              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 {
-              log.warn(`Commit agent failed for issue #${details.number}: ${result.error}`);
             }
           }
-        } catch (err) {
-          log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
-        }
-      }
-      if (!noBranch && branchName && defaultBranch && details) {
-        try {
-          await datasource4.pushBranch(branchName, issueLifecycleOpts);
-          log.debug(`Pushed branch ${branchName}`);
-        } catch (err) {
-          log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
         }
-        try {
-          const prTitle = commitAgentResult?.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
-          const prBody = commitAgentResult?.prDescription || await buildPrBody(
-            details,
-            fileTasks,
-            issueResults,
-            defaultBranch,
-            datasource4.name,
-            issueLifecycleOpts.cwd
-          );
-          const prUrl = await datasource4.createPullRequest(
-            branchName,
-            details.number,
-            prTitle,
-            prBody,
-            issueLifecycleOpts
-          );
-          if (prUrl) {
-            log.success(`Created PR for issue #${details.number}: ${prUrl}`);
-          }
-        } catch (err) {
-          log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
+        fileLogger?.phase("Resource cleanup");
+        if (useWorktrees) {
+          await localExecutor.cleanup();
+          await localPlanner?.cleanup();
+          await localInstance.cleanup();
         }
-        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) {
+      };
+      if (fileLogger) {
+        await fileLoggerStorage.run(fileLogger, async () => {
           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)}`);
+            await body();
+          } finally {
+            fileLogger.close();
           }
-        }
-      }
-      if (useWorktrees) {
-        await localExecutor.cleanup();
-        await localPlanner?.cleanup();
-        await localInstance.cleanup();
+        });
+      } else {
+        await body();
       }
     };
-    if (useWorktrees) {
+    if (useWorktrees && !feature) {
       await Promise.all(
         Array.from(tasksByFile).map(
           ([file, fileTasks]) => processIssueFile(file, fileTasks)
@@ -4135,10 +4658,42 @@ async function runDispatchPipeline(opts, cwd) {
         await processIssueFile(file, fileTasks);
       }
     }
-    try {
-      await closeCompletedSpecIssues(taskFiles, results, cwd, source, org, project, workItemType);
-    } catch (err) {
-      log.warn(`Could not close completed spec issues: ${log.formatErrorChain(err)}`);
+    if (feature && featureBranchName && featureDefaultBranch) {
+      try {
+        await datasource4.switchBranch(featureBranchName, lifecycleOpts);
+        log.debug(`Switched to feature branch ${featureBranchName}`);
+      } catch (err) {
+        log.warn(`Could not switch to feature branch: ${log.formatErrorChain(err)}`);
+      }
+      try {
+        await datasource4.pushBranch(featureBranchName, lifecycleOpts);
+        log.debug(`Pushed feature branch ${featureBranchName}`);
+      } catch (err) {
+        log.warn(`Could not push feature branch: ${log.formatErrorChain(err)}`);
+      }
+      try {
+        const allIssueDetails = Array.from(issueDetailsByFile.values());
+        const prTitle = buildFeaturePrTitle(featureBranchName, allIssueDetails);
+        const prBody = buildFeaturePrBody(allIssueDetails, allTasks, results, source);
+        const primaryIssue = allIssueDetails[0]?.number ?? "";
+        const prUrl = await datasource4.createPullRequest(
+          featureBranchName,
+          primaryIssue,
+          prTitle,
+          prBody,
+          lifecycleOpts
+        );
+        if (prUrl) {
+          log.success(`Created feature PR: ${prUrl}`);
+        }
+      } catch (err) {
+        log.warn(`Could not create feature PR: ${log.formatErrorChain(err)}`);
+      }
+      try {
+        await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+      } catch (err) {
+        log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
+      }
     }
     await commitAgent?.cleanup();
     await executor?.cleanup();
@@ -4153,13 +4708,13 @@ async function runDispatchPipeline(opts, cwd) {
     throw err;
   }
 }
-async function dryRunMode(issueIds, cwd, source, org, project, workItemType) {
+async function dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area) {
   if (!source) {
     log.error("No datasource configured. Use --source or run 'dispatch config' to set up defaults.");
     return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
   }
   const datasource4 = getDatasource(source);
-  const fetchOpts = { cwd, org, project, workItemType };
+  const fetchOpts = { cwd, org, project, workItemType, iteration, area };
   const lifecycleOpts = { cwd };
   let username = "";
   try {
@@ -4233,12 +4788,17 @@ async function boot9(opts) {
       const modeFlags = [
         m.spec !== void 0 && "--spec",
         m.respec !== void 0 && "--respec",
-        m.fixTests && "--fix-tests"
+        m.fixTests && "--fix-tests",
+        m.feature && "--feature"
       ].filter(Boolean);
       if (modeFlags.length > 1) {
         log.error(`${modeFlags.join(" and ")} are mutually exclusive`);
         process.exit(1);
       }
+      if (m.feature && m.noBranch) {
+        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);
@@ -4259,6 +4819,8 @@ async function boot9(opts) {
           org: m.org,
           project: m.project,
           workItemType: m.workItemType,
+          iteration: m.iteration,
+          area: m.area,
           concurrency: m.concurrency,
           dryRun: m.dryRun
         });
@@ -4273,7 +4835,7 @@ async function boot9(opts) {
             process.exit(1);
           }
           const datasource4 = getDatasource(source);
-          const existing = await datasource4.list({ cwd: m.cwd, org: m.org, project: m.project, workItemType: m.workItemType });
+          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);
@@ -4299,6 +4861,8 @@ async function boot9(opts) {
           org: m.org,
           project: m.project,
           workItemType: m.workItemType,
+          iteration: m.iteration,
+          area: m.area,
           concurrency: m.concurrency,
           dryRun: m.dryRun
         });
@@ -4317,10 +4881,13 @@ async function boot9(opts) {
         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
+        force: m.force,
+        feature: m.feature
       });
     }
   };
@@ -4331,7 +4898,7 @@ async function boot9(opts) {
 init_logger();
 init_cleanup();
 init_providers();
-var MAX_CONCURRENCY = 64;
+var MAX_CONCURRENCY = CONFIG_BOUNDS.concurrency.max;
 var HELP = `
   dispatch \u2014 AI agent orchestration CLI
 
@@ -4350,8 +4917,9 @@ var HELP = `
     --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
     --force              Ignore prior run state and re-run all tasks
-    --concurrency <n>      Max parallel dispatches (default: min(cpus, freeMB/500), max: 64)
+    --concurrency <n>      Max parallel dispatches (default: min(cpus, freeMB/500), max: ${MAX_CONCURRENCY})
     --provider <name>      Agent backend: ${PROVIDER_NAMES.join(", ")} (default: opencode)
     --server-url <url>     URL of a running provider server
     --plan-timeout <min>   Planning timeout in minutes (default: 10)
@@ -4398,180 +4966,156 @@ var HELP = `
     dispatch config
 `.trimStart();
 function parseArgs(argv) {
+  const program = new Command();
+  program.exitOverride().configureOutput({
+    writeOut: () => {
+    },
+    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(
+    new Option("--provider <name>", "Agent backend").choices(PROVIDER_NAMES)
+  ).addOption(
+    new Option("--source <name>", "Issue source").choices(
+      DATASOURCE_NAMES
+    )
+  ).option(
+    "--concurrency <n>",
+    "Max parallel dispatches",
+    (val) => {
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n < 1) throw new CommanderError(1, "commander.invalidArgument", "--concurrency must be a positive integer");
+      if (n > MAX_CONCURRENCY) throw new CommanderError(1, "commander.invalidArgument", `--concurrency must not exceed ${MAX_CONCURRENCY}`);
+      return n;
+    }
+  ).option(
+    "--plan-timeout <min>",
+    "Planning timeout in minutes",
+    (val) => {
+      const n = parseFloat(val);
+      if (isNaN(n) || n < CONFIG_BOUNDS.planTimeout.min) throw new CommanderError(1, "commander.invalidArgument", "--plan-timeout must be a positive number (minutes)");
+      if (n > CONFIG_BOUNDS.planTimeout.max) throw new CommanderError(1, "commander.invalidArgument", `--plan-timeout must not exceed ${CONFIG_BOUNDS.planTimeout.max}`);
+      return n;
+    }
+  ).option(
+    "--retries <n>",
+    "Retry attempts",
+    (val) => {
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n < 0) throw new CommanderError(1, "commander.invalidArgument", "--retries must be a non-negative integer");
+      return n;
+    }
+  ).option(
+    "--plan-retries <n>",
+    "Planner retry attempts",
+    (val) => {
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n < 0) throw new CommanderError(1, "commander.invalidArgument", "--plan-retries must be a non-negative integer");
+      return n;
+    }
+  ).option(
+    "--test-timeout <min>",
+    "Test timeout in minutes",
+    (val) => {
+      const n = parseFloat(val);
+      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");
+  try {
+    program.parse(argv, { from: "user" });
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      log.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const opts = program.opts();
   const args = {
-    issueIds: [],
-    dryRun: false,
-    noPlan: false,
-    noBranch: false,
-    noWorktree: false,
-    force: false,
-    provider: "opencode",
-    cwd: process.cwd(),
-    help: false,
-    version: false,
-    verbose: false
+    issueIds: program.args,
+    dryRun: opts.dryRun ?? false,
+    noPlan: !opts.plan,
+    noBranch: !opts.branch,
+    noWorktree: !opts.worktree,
+    force: opts.force ?? false,
+    provider: opts.provider ?? "opencode",
+    cwd: opts.cwd ?? process.cwd(),
+    help: opts.help ?? false,
+    version: opts.version ?? false,
+    verbose: opts.verbose ?? false
   };
-  const explicitFlags = /* @__PURE__ */ new Set();
-  let i = 0;
-  while (i < argv.length) {
-    const arg = argv[i];
-    if (arg === "--help" || arg === "-h") {
-      args.help = true;
-      explicitFlags.add("help");
-    } else if (arg === "--version" || arg === "-v") {
-      args.version = true;
-      explicitFlags.add("version");
-    } else if (arg === "--dry-run") {
-      args.dryRun = true;
-      explicitFlags.add("dryRun");
-    } else if (arg === "--no-plan") {
-      args.noPlan = true;
-      explicitFlags.add("noPlan");
-    } else if (arg === "--no-branch") {
-      args.noBranch = true;
-      explicitFlags.add("noBranch");
-    } else if (arg === "--no-worktree") {
-      args.noWorktree = true;
-      explicitFlags.add("noWorktree");
-    } else if (arg === "--force") {
-      args.force = true;
-      explicitFlags.add("force");
-    } else if (arg === "--verbose") {
-      args.verbose = true;
-      explicitFlags.add("verbose");
-    } else if (arg === "--spec") {
-      i++;
-      const specs = [];
-      while (i < argv.length && !argv[i].startsWith("--")) {
-        specs.push(argv[i]);
-        i++;
-      }
-      i--;
-      args.spec = specs.length === 1 ? specs[0] : specs;
-      explicitFlags.add("spec");
-    } else if (arg === "--respec") {
-      i++;
-      const respecs = [];
-      while (i < argv.length && !argv[i].startsWith("--")) {
-        respecs.push(argv[i]);
-        i++;
-      }
-      i--;
-      args.respec = respecs.length === 1 ? respecs[0] : respecs;
-      explicitFlags.add("respec");
-    } else if (arg === "--fix-tests") {
-      args.fixTests = true;
-      explicitFlags.add("fixTests");
-    } else if (arg === "--source") {
-      i++;
-      const val = argv[i];
-      if (!DATASOURCE_NAMES.includes(val)) {
-        log.error(
-          `Unknown source "${val}". Available: ${DATASOURCE_NAMES.join(", ")}`
-        );
-        process.exit(1);
-      }
-      args.issueSource = val;
-      explicitFlags.add("issueSource");
-    } else if (arg === "--org") {
-      i++;
-      args.org = argv[i];
-      explicitFlags.add("org");
-    } else if (arg === "--project") {
-      i++;
-      args.project = argv[i];
-      explicitFlags.add("project");
-    } else if (arg === "--output-dir") {
-      i++;
-      args.outputDir = resolve(argv[i]);
-      explicitFlags.add("outputDir");
-    } else if (arg === "--concurrency") {
-      i++;
-      const val = parseInt(argv[i], 10);
-      if (isNaN(val) || val < 1) {
-        log.error("--concurrency must be a positive integer");
-        process.exit(1);
-      }
-      if (val > MAX_CONCURRENCY) {
-        log.error(`--concurrency must not exceed ${MAX_CONCURRENCY}`);
-        process.exit(1);
-      }
-      args.concurrency = val;
-      explicitFlags.add("concurrency");
-    } else if (arg === "--provider") {
-      i++;
-      const val = argv[i];
-      if (!PROVIDER_NAMES.includes(val)) {
-        log.error(`Unknown provider "${val}". Available: ${PROVIDER_NAMES.join(", ")}`);
-        process.exit(1);
-      }
-      args.provider = val;
-      explicitFlags.add("provider");
-    } else if (arg === "--server-url") {
-      i++;
-      args.serverUrl = argv[i];
-      explicitFlags.add("serverUrl");
-    } else if (arg === "--plan-timeout") {
-      i++;
-      const val = parseFloat(argv[i]);
-      if (isNaN(val) || val <= 0) {
-        log.error("--plan-timeout must be a positive number (minutes)");
-        process.exit(1);
-      }
-      args.planTimeout = val;
-      explicitFlags.add("planTimeout");
-    } else if (arg === "--retries") {
-      i++;
-      const val = parseInt(argv[i], 10);
-      if (isNaN(val) || val < 0) {
-        log.error("--retries must be a non-negative integer");
-        process.exit(1);
-      }
-      args.retries = val;
-      explicitFlags.add("retries");
-    } else if (arg === "--plan-retries") {
-      i++;
-      const val = parseInt(argv[i], 10);
-      if (isNaN(val) || val < 0) {
-        log.error("--plan-retries must be a non-negative integer");
-        process.exit(1);
-      }
-      args.planRetries = val;
-      explicitFlags.add("planRetries");
-    } else if (arg === "--test-timeout") {
-      i++;
-      const val = parseFloat(argv[i]);
-      if (isNaN(val) || val <= 0) {
-        log.error("--test-timeout must be a positive number (minutes)");
-        process.exit(1);
-      }
-      args.testTimeout = val;
-      explicitFlags.add("testTimeout");
-    } else if (arg === "--cwd") {
-      i++;
-      args.cwd = resolve(argv[i]);
-      explicitFlags.add("cwd");
-    } else if (!arg.startsWith("-")) {
-      args.issueIds.push(arg);
+  if (opts.spec !== void 0) {
+    args.spec = opts.spec.length === 1 ? opts.spec[0] : opts.spec;
+  }
+  if (opts.respec !== void 0) {
+    if (opts.respec === true) {
+      args.respec = [];
     } else {
-      log.error(`Unknown option: ${arg}`);
-      process.exit(1);
+      args.respec = opts.respec.length === 1 ? opts.respec[0] : opts.respec;
+    }
+  }
+  if (opts.fixTests) args.fixTests = true;
+  if (opts.feature) args.feature = true;
+  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;
+  if (opts.planTimeout !== void 0) args.planTimeout = opts.planTimeout;
+  if (opts.retries !== void 0) args.retries = opts.retries;
+  if (opts.planRetries !== void 0) args.planRetries = opts.planRetries;
+  if (opts.testTimeout !== void 0) args.testTimeout = opts.testTimeout;
+  if (opts.org !== void 0) args.org = opts.org;
+  if (opts.project !== void 0) args.project = opts.project;
+  if (opts.outputDir !== void 0) args.outputDir = opts.outputDir;
+  const explicitFlags = /* @__PURE__ */ new Set();
+  const SOURCE_MAP = {
+    help: "help",
+    version: "version",
+    dryRun: "dryRun",
+    plan: "noPlan",
+    branch: "noBranch",
+    worktree: "noWorktree",
+    force: "force",
+    verbose: "verbose",
+    spec: "spec",
+    respec: "respec",
+    fixTests: "fixTests",
+    feature: "feature",
+    source: "issueSource",
+    provider: "provider",
+    concurrency: "concurrency",
+    serverUrl: "serverUrl",
+    planTimeout: "planTimeout",
+    retries: "retries",
+    planRetries: "planRetries",
+    testTimeout: "testTimeout",
+    cwd: "cwd",
+    org: "org",
+    project: "project",
+    outputDir: "outputDir"
+  };
+  for (const [attr, flag] of Object.entries(SOURCE_MAP)) {
+    if (program.getOptionValueSource(attr) === "cli") {
+      explicitFlags.add(flag);
     }
-    i++;
   }
   return [args, explicitFlags];
 }
 async function main() {
   const rawArgv = process.argv.slice(2);
   if (rawArgv[0] === "config") {
-    let cwd = process.cwd();
-    for (let i = 1; i < rawArgv.length; i++) {
-      if (rawArgv[i] === "--cwd" && i + 1 < rawArgv.length) {
-        cwd = resolve(rawArgv[i + 1]);
-        break;
+    const configProgram = new Command("dispatch-config").exitOverride().configureOutput({ writeOut: () => {
+    }, writeErr: () => {
+    } }).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).option("--cwd <dir>", "Working directory", (v) => resolve3(v));
+    try {
+      configProgram.parse(rawArgv.slice(1), { from: "user" });
+    } catch (err) {
+      if (err instanceof CommanderError) {
+        log.error(err.message);
+        process.exit(1);
       }
+      throw err;
     }
-    const configDir = join11(cwd, ".dispatch");
+    const configDir = join12(configProgram.opts().cwd ?? process.cwd(), ".dispatch");
     await handleConfigCommand(rawArgv.slice(1), configDir);
     process.exit(0);
   }
@@ -4592,7 +5136,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"0.0.1"}`);
+    console.log(`dispatch v${"1.3.0"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });