@pruddiman/dispatch 1.2.1 → 1.3.1

package/dist/cli.js

@@ -9,6 +9,84 @@ 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";
 function resolveLogLevel() {
@@ -24,10 +102,14 @@ function resolveLogLevel() {
 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,
@@ -41,26 +123,32 @@ var init_logger = __esm({
       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) {
         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 the log level is
@@ -70,6 +158,7 @@ var init_logger = __esm({
       debug(msg) {
         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
@@ -671,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;
@@ -765,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);
@@ -844,45 +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)}`);
-    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"() {
@@ -890,11 +1002,13 @@ var init_fix_tests_pipeline = __esm({
     init_providers();
     init_cleanup();
     init_logger();
+    init_file_logger();
   }
 });
 
 // src/cli.ts
-import { resolve as resolve3, 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";
@@ -909,14 +1023,15 @@ 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);
+
+// src/helpers/branch-validation.ts
 var InvalidBranchNameError = class extends Error {
   constructor(branch, reason) {
     const detail = reason ? ` (${reason})` : "";
@@ -924,14 +1039,6 @@ var InvalidBranchNameError = class extends Error {
     this.name = "InvalidBranchNameError";
   }
 };
-async function git(args, cwd) {
-  const { stdout } = await exec("git", args, { cwd });
-  return stdout;
-}
-async function gh(args, cwd) {
-  const { stdout } = await exec("gh", args, { cwd });
-  return stdout;
-}
 var VALID_BRANCH_NAME_RE = /^[a-zA-Z0-9._\-/]+$/;
 function isValidBranchName(name) {
   if (name.length === 0 || name.length > 255) return false;
@@ -943,6 +1050,17 @@ function isValidBranchName(name) {
   if (name.includes("//")) return false;
   return true;
 }
+
+// src/datasources/github.ts
+var exec = promisify(execFile);
+async function git(args, cwd) {
+  const { stdout } = await exec("git", args, { cwd });
+  return stdout;
+}
+async function gh(args, cwd) {
+  const { stdout } = await exec("gh", args, { cwd });
+  return stdout;
+}
 function buildBranchName(issueNumber, title, username = "unknown") {
   const slug = slugify(title, 50);
   return `${username}/dispatch/${issueNumber}-${slug}`;
@@ -1153,6 +1271,25 @@ import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 init_logger();
 var exec2 = promisify2(execFile2);
+function mapWorkItemToIssueDetails(item, id, comments, defaults) {
+  const fields = item.fields ?? {};
+  return {
+    number: String(item.id ?? id),
+    title: fields["System.Title"] ?? defaults?.title ?? "",
+    body: fields["System.Description"] ?? defaults?.body ?? "",
+    labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
+    state: fields["System.State"] ?? defaults?.state ?? "",
+    url: item._links?.html?.href ?? item.url ?? "",
+    comments,
+    acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? "",
+    iterationPath: fields["System.IterationPath"] || void 0,
+    areaPath: fields["System.AreaPath"] || void 0,
+    assignee: fields["System.AssignedTo"]?.displayName || void 0,
+    priority: fields["Microsoft.VSTS.Common.Priority"] ?? void 0,
+    storyPoints: fields["Microsoft.VSTS.Scheduling.StoryPoints"] ?? fields["Microsoft.VSTS.Scheduling.Effort"] ?? fields["Microsoft.VSTS.Scheduling.Size"] ?? void 0,
+    workItemType: fields["System.WorkItemType"] || defaults?.workItemType || void 0
+  };
+}
 async function detectWorkItemType(opts = {}) {
   try {
     const args = ["boards", "work-item", "type", "list", "--output", "json"];
@@ -1179,7 +1316,26 @@ var datasource2 = {
     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);
@@ -1192,17 +1348,50 @@ var datasource2 = {
     } catch {
       throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
     }
-    const items = [];
-    if (Array.isArray(data)) {
-      for (const row of data) {
-        const id = String(row.id ?? row.ID ?? "");
-        if (id) {
-          const detail = await datasource2.fetch(id, opts);
-          items.push(detail);
-        }
+    if (!Array.isArray(data)) return [];
+    const ids = data.map((row) => String(row.id ?? row.ID ?? "")).filter(Boolean);
+    if (ids.length === 0) return [];
+    try {
+      const batchArgs = [
+        "boards",
+        "work-item",
+        "show",
+        "--id",
+        ...ids,
+        "--output",
+        "json"
+      ];
+      if (opts.org) batchArgs.push("--org", opts.org);
+      if (opts.project) batchArgs.push("--project", opts.project);
+      const { stdout: batchStdout } = await exec2("az", batchArgs, {
+        cwd: opts.cwd || process.cwd()
+      });
+      let batchItems;
+      try {
+        batchItems = JSON.parse(batchStdout);
+      } catch {
+        throw new Error(`Failed to parse Azure CLI output: ${batchStdout.slice(0, 200)}`);
       }
+      const itemsArray = Array.isArray(batchItems) ? batchItems : [batchItems];
+      const commentsArray = [];
+      const CONCURRENCY = 5;
+      for (let i = 0; i < itemsArray.length; i += CONCURRENCY) {
+        const batch = itemsArray.slice(i, i + CONCURRENCY);
+        const batchResults = await Promise.all(
+          batch.map((item) => fetchComments(String(item.id), opts))
+        );
+        commentsArray.push(...batchResults);
+      }
+      return itemsArray.map(
+        (item, i) => mapWorkItemToIssueDetails(item, String(item.id), commentsArray[i])
+      );
+    } catch (err) {
+      log.debug(`Batch work-item show failed, falling back to individual fetches: ${log.extractMessage(err)}`);
+      const results = await Promise.all(
+        ids.map((id) => datasource2.fetch(id, opts))
+      );
+      return results;
     }
-    return items;
   },
   async fetch(issueId, opts = {}) {
     const args = [
@@ -1229,18 +1418,8 @@ var datasource2 = {
     } catch {
       throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
     }
-    const fields = item.fields ?? {};
     const comments = await fetchComments(issueId, opts);
-    return {
-      number: String(item.id ?? issueId),
-      title: fields["System.Title"] ?? "",
-      body: fields["System.Description"] ?? "",
-      labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
-      state: fields["System.State"] ?? "",
-      url: item._links?.html?.href ?? item.url ?? "",
-      comments,
-      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
-    };
+    return mapWorkItemToIssueDetails(item, issueId, comments);
   },
   async update(issueId, title, body, opts = {}) {
     const args = [
@@ -1303,24 +1482,26 @@ var datasource2 = {
     } catch {
       throw new Error(`Failed to parse Azure CLI output: ${stdout.slice(0, 200)}`);
     }
-    const fields = item.fields ?? {};
-    return {
-      number: String(item.id),
-      title: fields["System.Title"] ?? title,
-      body: fields["System.Description"] ?? body,
-      labels: (fields["System.Tags"] ?? "").split(";").map((t) => t.trim()).filter(Boolean),
-      state: fields["System.State"] ?? "New",
-      url: item._links?.html?.href ?? item.url ?? "",
-      comments: [],
-      acceptanceCriteria: fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""
-    };
+    return mapWorkItemToIssueDetails(item, String(item.id), [], {
+      title,
+      body,
+      state: "New",
+      workItemType
+    });
   },
   async getDefaultBranch(opts) {
     try {
       const { stdout } = await exec2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: opts.cwd });
       const parts = stdout.trim().split("/");
-      return parts[parts.length - 1];
-    } catch {
+      const branch = parts[parts.length - 1];
+      if (!isValidBranchName(branch)) {
+        throw new InvalidBranchNameError(branch, "from symbolic-ref output");
+      }
+      return branch;
+    } catch (err) {
+      if (err instanceof InvalidBranchNameError) {
+        throw err;
+      }
       try {
         await exec2("git", ["rev-parse", "--verify", "main"], { cwd: opts.cwd });
         return "main";
@@ -1332,18 +1513,38 @@ 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);
-    return `${username}/dispatch/${issueNumber}-${slug}`;
+    const branch = `${username}/dispatch/${issueNumber}-${slug}`;
+    if (!isValidBranchName(branch)) {
+      throw new InvalidBranchNameError(branch);
+    }
+    return branch;
   },
   async createAndSwitchBranch(branchName, opts) {
+    if (!isValidBranchName(branchName)) {
+      throw new InvalidBranchNameError(branchName);
+    }
     try {
       await exec2("git", ["checkout", "-b", branchName], { cwd: opts.cwd });
     } catch (err) {
@@ -1469,7 +1670,7 @@ 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
@@ -1489,7 +1690,7 @@ 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);
@@ -1514,7 +1715,7 @@ function toIssueDetails(filename, content, dir) {
     body: content,
     labels: [],
     state: "open",
-    url: join(dir, filename),
+    url: join2(dir, filename),
     comments: [],
     acceptanceCriteria: ""
   };
@@ -1535,7 +1736,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));
     }
@@ -1544,29 +1745,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);
   },
@@ -1646,6 +1847,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();
@@ -1662,16 +1893,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) {
@@ -1797,7 +2028,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");
   }
@@ -1809,7 +2040,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/"
@@ -1818,7 +2049,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/"
@@ -1831,17 +2062,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 {
@@ -1856,18 +2093,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) {
@@ -1947,6 +2184,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
@@ -1954,6 +2239,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)) {
@@ -1985,10 +2275,10 @@ var CONFIG_BOUNDS = {
   planTimeout: { min: 1, max: 120 },
   concurrency: { min: 1, max: 64 }
 };
-var CONFIG_KEYS = ["provider", "model", "source", "testTimeout", "planTimeout", "concurrency"];
+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);
@@ -2001,7 +2291,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) {
@@ -2015,14 +2305,19 @@ var CONFIG_TO_CLI = {
   source: "issueSource",
   testTimeout: "testTimeout",
   planTimeout: "planTimeout",
-  concurrency: "concurrency"
+  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) {
@@ -2069,16 +2364,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, resolve, sep } 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) {
@@ -2100,10 +2396,10 @@ async function boot5(opts) {
             durationMs: Date.now() - startTime
           };
         }
-        const tmpDir = join5(resolvedCwd, ".dispatch", "tmp");
+        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);
@@ -2119,6 +2415,7 @@ async function boot5(opts) {
             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);
@@ -2131,6 +2428,7 @@ async function boot5(opts) {
           };
         }
         log.debug(`Spec agent response (${response.length} chars)`);
+        fileLoggerStorage.getStore()?.response("spec", response);
         let rawContent;
         try {
           rawContent = await readFile4(tmpPath, "utf-8");
@@ -2154,6 +2452,7 @@ async function boot5(opts) {
           await unlink(tmpPath);
         } catch {
         }
+        fileLoggerStorage.getStore()?.agentEvent("spec", "completed", `${Date.now() - startTime}ms`);
         return {
           data: {
             content: cleanedContent,
@@ -2165,6 +2464,8 @@ async function boot5(opts) {
         };
       } catch (err) {
         const message = log.extractMessage(err);
+        fileLoggerStorage.getStore()?.error(`spec error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
         return {
           data: null,
           success: false,
@@ -2400,6 +2701,7 @@ function buildInlineTextSpecPrompt(text, cwd, outputPath) {
 // src/orchestrator/spec-pipeline.ts
 init_cleanup();
 init_logger();
+init_file_logger();
 import chalk5 from "chalk";
 
 // src/helpers/format.ts
@@ -2452,11 +2754,11 @@ async function withRetry(fn, maxRetries, options) {
 // src/orchestrator/spec-pipeline.ts
 init_timeout();
 var FETCH_TIMEOUT_MS = 3e4;
-async function resolveDatasource(issues, issueSource, specCwd, org, project, workItemType) {
+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 fetchOpts = { cwd: specCwd, org, project, workItemType, iteration, area };
   return { source, datasource: datasource4, fetchOpts };
 }
 async function fetchTrackerItems(issues, datasource4, fetchOpts, concurrency, source) {
@@ -2497,7 +2799,7 @@ function buildInlineTextItem(issues, outputDir) {
   const title = text.length > 80 ? text.slice(0, 80).trimEnd() + "\u2026" : text;
   const slug = slugify(text, MAX_SLUG_LENGTH);
   const filename = `${slug}.md`;
-  const filepath = join6(outputDir, filename);
+  const filepath = join7(outputDir, filename);
   const details = {
     number: filepath,
     title,
@@ -2559,7 +2861,7 @@ function previewDryRun(validItems, items, isTrackerMode, isInlineText, outputDir
     let filepath;
     if (isTrackerMode) {
       const slug = slugify(details.title, 60);
-      filepath = join6(outputDir, `${id}-${slug}.md`);
+      filepath = join7(outputDir, `${id}-${slug}.md`);
     } else {
       filepath = id;
     }
@@ -2617,72 +2919,92 @@ async function generateSpecsBatch(validItems, items, specAgent, instance, isTrac
           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.data.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.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);
+            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) {
@@ -2736,16 +3058,18 @@ async function runSpecPipeline(opts) {
     model,
     serverUrl,
     cwd: specCwd,
-    outputDir = join6(specCwd, ".dispatch", "specs"),
+    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);
+  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: {} };
   }
@@ -2865,7 +3189,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(
@@ -2880,7 +3206,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 [];
@@ -2910,6 +3236,7 @@ function groupTasksByMode(tasks) {
 
 // src/agents/planner.ts
 init_logger();
+init_file_logger();
 async function boot6(opts) {
   const { provider, cwd } = opts;
   if (!provider) {
@@ -2922,13 +3249,18 @@ async function boot6(opts) {
       try {
         const sessionId = await provider.createSession();
         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 { data: null, success: false, error: "Planner returned empty plan", durationMs: Date.now() - startTime };
         }
+        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);
+        fileLoggerStorage.getStore()?.error(`planner error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
         return { data: null, success: false, error: message, durationMs: Date.now() - startTime };
       }
     },
@@ -3010,22 +3342,28 @@ function buildPlannerPrompt(task, cwd, fileContext, worktreeRoot) {
 
 // src/dispatcher.ts
 init_logger();
+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, 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 };
   }
 }
@@ -3092,6 +3430,7 @@ function buildWorktreeIsolation(worktreeRoot) {
 
 // src/agents/executor.ts
 init_logger();
+init_file_logger();
 async function boot7(opts) {
   const { provider } = opts;
   if (!provider) {
@@ -3099,18 +3438,23 @@ async function boot7(opts) {
   }
   return {
     name: "executor",
-    async execute(input2) {
-      const { task, cwd, plan, worktreeRoot } = input2;
+    async execute(input3) {
+      const { task, cwd, plan, worktreeRoot } = input3;
       const startTime = Date.now();
       try {
+        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 };
         }
+        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);
+        fileLoggerStorage.getStore()?.error(`executor error: ${message}${err instanceof Error && err.stack ? `
+${err.stack}` : ""}`);
         return { data: null, success: false, error: message, durationMs: Date.now() - startTime };
       }
     },
@@ -3121,8 +3465,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, resolve as resolve2 } from "path";
+import { join as join8, resolve as resolve2 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 async function boot8(opts) {
   const { provider } = opts;
@@ -3136,14 +3481,16 @@ async function boot8(opts) {
     async generate(genOpts) {
       try {
         const resolvedCwd = resolve2(genOpts.cwd);
-        const tmpDir = join7(resolvedCwd, ".dispatch", "tmp");
+        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: "",
@@ -3167,12 +3514,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: "",
@@ -3313,7 +3663,7 @@ 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";
@@ -3332,7 +3682,7 @@ function worktreeName(issueFilename) {
 }
 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 {
     const args = ["worktree", "add", worktreePath, "-b", branchName];
     if (startPoint) args.push(startPoint);
@@ -3351,7 +3701,7 @@ async function createWorktree(repoRoot, issueFilename, branchName, startPoint) {
 }
 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 {
@@ -3586,13 +3936,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 = {
@@ -3622,7 +3983,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";
@@ -3650,13 +4011,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);
@@ -3669,34 +4030,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(
@@ -3823,6 +4156,7 @@ function buildFeaturePrBody(issues, tasks, results, datasourceName) {
 // 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;
@@ -3842,6 +4176,8 @@ async function runDispatchPipeline(opts, cwd) {
     org,
     project,
     workItemType,
+    iteration,
+    area,
     planTimeout,
     planRetries,
     retries
@@ -3850,7 +4186,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;
@@ -3886,7 +4222,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";
@@ -3988,332 +4324,370 @@ 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 = 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}`);
-            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 if (datasource4.supportsGit()) {
-            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 worktreeRoot = useWorktrees ? worktreePath : void 0;
-      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, worktreeRoot),
-                      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 = {
-                        data: null,
-                        success: false,
-                        error: log.extractMessage(err),
-                        durationMs: 0
-                      };
                       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 = {
-                    data: null,
-                    success: false,
-                    error: `Planning timed out after ${timeoutMin}m (${maxPlanAttempts} attempts)`,
-                    durationMs: 0
-                  };
-                }
-                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.data.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,
-                    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) {
+                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}`);
               }
-              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;
+            }
+          } catch (err) {
+            log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
           }
         }
-      }
-      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)}`);
-        }
-      }
-      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?.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)}`);
               }
-            } 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) {
-        if (feature && featureBranchName) {
-          if (worktreePath) {
             try {
-              await removeWorktree(cwd, file);
+              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) {
-              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 mergeError = `Could not merge ${branchName} into feature branch: ${log.formatErrorChain(err)}`;
+              log.warn(mergeError);
+              try {
+                await exec9("git", ["merge", "--abort"], { cwd });
+              } catch {
               }
-              const existingResult = results.find((r) => r.task === task);
-              if (existingResult) {
-                existingResult.success = false;
-                existingResult.error = mergeError;
+              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;
             }
-            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}`);
+              await exec9("git", ["branch", "-d", branchName], { cwd });
+              log.debug(`Deleted local branch ${branchName}`);
             } catch (err) {
-              log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
+              log.warn(`Could not delete local 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}`);
-              }
+              await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
             } catch (err) {
-              log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
+              log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
             }
-          }
-          if (useWorktrees && worktreePath) {
-            try {
-              await removeWorktree(cwd, file);
-            } catch (err) {
-              log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
+          } else {
+            if (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)}`);
+              }
             }
-          } 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)}`);
+            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)}`);
+              }
             }
           }
         }
-      }
-      if (useWorktrees) {
-        await localExecutor.cleanup();
-        await localPlanner?.cleanup();
-        await localInstance.cleanup();
+        fileLogger?.phase("Resource cleanup");
+        if (useWorktrees) {
+          await localExecutor.cleanup();
+          await localPlanner?.cleanup();
+          await localInstance.cleanup();
+        }
+      };
+      if (fileLogger) {
+        await fileLoggerStorage.run(fileLogger, async () => {
+          try {
+            await body();
+          } finally {
+            fileLogger.close();
+          }
+        });
+      } else {
+        await body();
       }
     };
     if (useWorktrees && !feature) {
@@ -4364,11 +4738,6 @@ async function runDispatchPipeline(opts, cwd) {
         log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
       }
     }
-    try {
-      await closeCompletedSpecIssues(taskFiles, results, cwd, source, org, project, workItemType);
-    } catch (err) {
-      log.warn(`Could not close completed spec issues: ${log.formatErrorChain(err)}`);
-    }
     await commitAgent?.cleanup();
     await executor?.cleanup();
     await planner?.cleanup();
@@ -4382,13 +4751,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 {
@@ -4493,6 +4862,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
         });
@@ -4507,7 +4878,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);
@@ -4533,6 +4904,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
         });
@@ -4551,6 +4924,8 @@ 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,
@@ -4634,187 +5009,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 === "--feature") {
-      args.feature = true;
-      explicitFlags.add("feature");
-    } 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 = resolve3(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 < CONFIG_BOUNDS.planTimeout.min) {
-        log.error("--plan-timeout must be a positive number (minutes)");
-        process.exit(1);
-      }
-      if (val > CONFIG_BOUNDS.planTimeout.max) {
-        log.error(`--plan-timeout must not exceed ${CONFIG_BOUNDS.planTimeout.max}`);
-        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 = resolve3(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 = resolve3(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);
   }
@@ -4835,7 +5179,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.2.1"}`);
+    console.log(`dispatch v${"1.3.1"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });