@pruddiman/dispatch 1.4.3 → 1.4.4

package/dist/cli.js

@@ -241,6 +241,41 @@ var init_logger = __esm({
   }
 });
 
+// src/providers/progress.ts
+function sanitizeProgressText(raw, maxLength = 120) {
+  const text = raw.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  if (maxLength <= 1) return maxLength <= 0 ? "" : "\u2026";
+  return `${text.slice(0, maxLength - 1).trimEnd()}\u2026`;
+}
+function createProgressReporter(onProgress) {
+  let last;
+  return {
+    emit(raw) {
+      if (!onProgress) return;
+      const text = sanitizeProgressText(raw ?? "");
+      if (!text || text === last) return;
+      last = text;
+      try {
+        onProgress({ text });
+      } catch {
+      }
+    },
+    reset() {
+      last = void 0;
+    }
+  };
+}
+var ANSI_PATTERN, CONTROL_PATTERN;
+var init_progress = __esm({
+  "src/providers/progress.ts"() {
+    "use strict";
+    ANSI_PATTERN = /(?:\u001B\[[0-?]*[ -/]*[@-~]|\u009B[0-?]*[ -/]*[@-~]|\u001B\][^\u0007]*(?:\u0007|\u001B\\))/g;
+    CONTROL_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+  }
+});
+
 // src/helpers/guards.ts
 function hasProperty(value, key) {
   return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, key);
@@ -251,6 +286,52 @@ var init_guards = __esm({
   }
 });
 
+// src/helpers/timeout.ts
+function withTimeout(promise, ms, label) {
+  const p = new Promise((resolve5, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(new TimeoutError(ms, label));
+    }, ms);
+    promise.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve5(value);
+      },
+      (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+  p.catch(() => {
+  });
+  return p;
+}
+var TimeoutError, DEFAULT_PLAN_TIMEOUT_MIN;
+var init_timeout = __esm({
+  "src/helpers/timeout.ts"() {
+    "use strict";
+    TimeoutError = class extends Error {
+      /** Optional label identifying the operation that timed out. */
+      label;
+      constructor(ms, label) {
+        const suffix = label ? ` [${label}]` : "";
+        super(`Timed out after ${ms}ms${suffix}`);
+        this.name = "TimeoutError";
+        this.label = label;
+      }
+    };
+    DEFAULT_PLAN_TIMEOUT_MIN = 30;
+  }
+});
+
 // src/providers/opencode.ts
 import {
   createOpencode,
@@ -346,9 +427,10 @@ async function boot(opts) {
         throw err;
       }
     },
-    async prompt(sessionId, text) {
+    async prompt(sessionId, text, options) {
       log.debug(`Sending async prompt to session ${sessionId} (${text.length} chars)...`);
       let controller;
+      const reporter = createProgressReporter(options?.onProgress);
       try {
         const { error: promptError } = await client.session.promptAsync({
           path: { id: sessionId },
@@ -366,29 +448,15 @@ async function boot(opts) {
           const { stream } = await client.event.subscribe({
             signal: controller.signal
           });
-          for await (const event of stream) {
-            if (!isSessionEvent(event, sessionId)) continue;
-            if (event.type === "message.part.updated" && event.properties.part.type === "text") {
-              const delta = event.properties.delta;
-              if (delta) {
-                log.debug(`Streaming text (+${delta.length} chars)...`);
-              }
-              continue;
-            }
-            if (event.type === "session.error") {
-              const err = event.properties.error;
-              throw new Error(
-                `OpenCode session error: ${err ? JSON.stringify(err) : "unknown error"}`
-              );
-            }
-            if (event.type === "session.idle") {
-              log.debug("Session went idle, fetching result...");
-              break;
-            }
-          }
+          await withTimeout(
+            waitForSessionReady(stream, sessionId, reporter),
+            SESSION_READY_TIMEOUT_MS,
+            "opencode session ready"
+          );
         } finally {
           if (controller && !controller.signal.aborted) controller.abort();
         }
+        log.debug("Session went idle, fetching result...");
         const { data: messages } = await client.session.messages({
           path: { id: sessionId }
         });
@@ -417,6 +485,20 @@ async function boot(opts) {
         throw err;
       }
     },
+    async send(sessionId, text) {
+      log.debug(`Sending follow-up message to session ${sessionId} (${text.length} chars)...`);
+      const { error } = await client.session.promptAsync({
+        path: { id: sessionId },
+        body: {
+          parts: [{ type: "text", text }],
+          ...modelOverride ? { model: modelOverride } : {}
+        }
+      });
+      if (error) {
+        throw new Error(`OpenCode send failed: ${JSON.stringify(error)}`);
+      }
+      log.debug("Follow-up message sent successfully");
+    },
     async cleanup() {
       if (cleaned) return;
       cleaned = true;
@@ -429,6 +511,29 @@ async function boot(opts) {
     }
   };
 }
+async function waitForSessionReady(stream, sessionId, reporter) {
+  for await (const event of stream) {
+    if (!isSessionEvent(event, sessionId)) continue;
+    if (event.type === "message.part.updated" && event.properties.part.type === "text") {
+      const delta = event.properties.delta;
+      if (delta) {
+        log.debug(`Streaming text (+${delta.length} chars)...`);
+        reporter?.emit(delta);
+      }
+      continue;
+    }
+    if (event.type === "session.error") {
+      const err = event.properties.error;
+      throw new Error(
+        `OpenCode session error: ${err ? JSON.stringify(err) : "unknown error"}`
+      );
+    }
+    if (event.type === "session.idle") {
+      return;
+    }
+  }
+  throw new Error("OpenCode event stream ended before session became idle");
+}
 function isSessionEvent(event, sessionId) {
   const props = event.properties;
   if (!hasProperty(props, "sessionID") && !hasProperty(props, "info") && !hasProperty(props, "part")) {
@@ -443,56 +548,15 @@ function isSessionEvent(event, sessionId) {
   }
   return false;
 }
+var SESSION_READY_TIMEOUT_MS;
 var init_opencode = __esm({
   "src/providers/opencode.ts"() {
     "use strict";
+    init_progress();
     init_logger();
     init_guards();
-  }
-});
-
-// src/helpers/timeout.ts
-function withTimeout(promise, ms, label) {
-  const p = new Promise((resolve5, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      reject(new TimeoutError(ms, label));
-    }, ms);
-    promise.then(
-      (value) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        resolve5(value);
-      },
-      (err) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        reject(err);
-      }
-    );
-  });
-  p.catch(() => {
-  });
-  return p;
-}
-var TimeoutError;
-var init_timeout = __esm({
-  "src/helpers/timeout.ts"() {
-    "use strict";
-    TimeoutError = class extends Error {
-      /** Optional label identifying the operation that timed out. */
-      label;
-      constructor(ms, label) {
-        const suffix = label ? ` [${label}]` : "";
-        super(`Timed out after ${ms}ms${suffix}`);
-        this.name = "TimeoutError";
-        this.label = label;
-      }
-    };
+    init_timeout();
+    SESSION_READY_TIMEOUT_MS = 6e5;
   }
 });
 
@@ -5603,35 +5667,33 @@ async function boot2(opts) {
         throw err;
       }
     },
-    async prompt(sessionId, text) {
+    async prompt(sessionId, text, options) {
       const session = sessions.get(sessionId);
       if (!session) {
         throw new Error(`Copilot session ${sessionId} not found`);
       }
       log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      const reporter = createProgressReporter(options?.onProgress);
+      let unsubIdle;
+      let unsubErr;
       try {
         await session.send({ prompt: text });
         log.debug("Async prompt accepted, waiting for session to become idle...");
-        let unsubIdle;
-        let unsubErr;
-        try {
-          await withTimeout(
-            new Promise((resolve5, reject) => {
-              unsubIdle = session.on("session.idle", () => {
-                resolve5();
-              });
-              unsubErr = session.on("session.error", (event) => {
-                reject(new Error(`Copilot session error: ${event.data.message}`));
-              });
-            }),
-            SESSION_READY_TIMEOUT_MS,
-            "copilot session ready"
-          );
-        } finally {
-          unsubIdle?.();
-          unsubErr?.();
-        }
+        reporter.emit("Waiting for Copilot response");
+        await withTimeout(
+          new Promise((resolve5, reject) => {
+            unsubIdle = session.on("session.idle", () => {
+              resolve5();
+            });
+            unsubErr = session.on("session.error", (event) => {
+              reject(new Error(`Copilot session error: ${event.data.message}`));
+            });
+          }),
+          SESSION_READY_TIMEOUT_MS2,
+          "copilot session ready"
+        );
         log.debug("Session went idle, fetching result...");
+        reporter.emit("Finalizing response");
         const events = await session.getMessages();
         const last = [...events].reverse().find((e) => e.type === "assistant.message");
         const result = last?.data?.content ?? null;
@@ -5640,6 +5702,23 @@ async function boot2(opts) {
       } catch (err) {
         log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
         throw err;
+      } finally {
+        unsubIdle?.();
+        unsubErr?.();
+      }
+    },
+    async send(sessionId, text) {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        throw new Error(`Copilot session ${sessionId} not found`);
+      }
+      log.debug(`Sending follow-up to session ${sessionId} (${text.length} chars)...`);
+      try {
+        await session.send({ prompt: text });
+        log.debug("Follow-up message sent");
+      } catch (err) {
+        log.debug(`Follow-up send failed: ${log.formatErrorChain(err)}`);
+        throw err;
       }
     },
     async cleanup() {
@@ -5657,13 +5736,14 @@ async function boot2(opts) {
     }
   };
 }
-var SESSION_READY_TIMEOUT_MS;
+var SESSION_READY_TIMEOUT_MS2;
 var init_copilot = __esm({
   "src/providers/copilot.ts"() {
     "use strict";
+    init_progress();
     init_logger();
     init_timeout();
-    SESSION_READY_TIMEOUT_MS = 6e5;
+    SESSION_READY_TIMEOUT_MS2 = 6e5;
   }
 });
 
@@ -5689,7 +5769,12 @@ async function boot3(opts) {
     async createSession() {
       log.debug("Creating Claude session...");
       try {
-        const sessionOpts = { model, permissionMode: "acceptEdits", ...cwd ? { cwd } : {} };
+        const sessionOpts = {
+          model,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+          ...cwd ? { cwd } : {}
+        };
         const session = unstable_v2_createSession(sessionOpts);
         const sessionId = randomUUID();
         sessions.set(sessionId, session);
@@ -5700,19 +5785,23 @@ async function boot3(opts) {
         throw err;
       }
     },
-    async prompt(sessionId, text) {
+    async prompt(sessionId, text, options) {
       const session = sessions.get(sessionId);
       if (!session) {
         throw new Error(`Claude session ${sessionId} not found`);
       }
       log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      const reporter = createProgressReporter(options?.onProgress);
       try {
         await session.send(text);
         const parts = [];
         for await (const msg of session.stream()) {
           if (msg.type === "assistant") {
             const msgText = msg.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-            if (msgText) parts.push(msgText);
+            if (msgText) {
+              reporter.emit(msgText);
+              parts.push(msgText);
+            }
           }
         }
         const result = parts.join("") || null;
@@ -5723,6 +5812,19 @@ async function boot3(opts) {
         throw err;
       }
     },
+    async send(sessionId, text) {
+      const session = sessions.get(sessionId);
+      if (!session) {
+        throw new Error(`Claude session ${sessionId} not found`);
+      }
+      log.debug(`Sending follow-up to session ${sessionId} (${text.length} chars)...`);
+      try {
+        await session.send(text);
+      } catch (err) {
+        log.debug(`Follow-up send failed: ${log.formatErrorChain(err)}`);
+        throw err;
+      }
+    },
     async cleanup() {
       log.debug("Cleaning up Claude provider...");
       for (const session of sessions.values()) {
@@ -5738,6 +5840,7 @@ async function boot3(opts) {
 var init_claude = __esm({
   "src/providers/claude.ts"() {
     "use strict";
+    init_progress();
     init_logger();
   }
 });
@@ -5766,6 +5869,11 @@ async function boot4(opts) {
       log.debug("Creating Codex session...");
       try {
         const sessionId = randomUUID2();
+        const state = {
+          agent: void 0,
+          reporter: createProgressReporter(),
+          loadingReported: false
+        };
         const agent = new AgentLoop({
           model,
           config: { model, instructions: "" },
@@ -5773,14 +5881,26 @@ async function boot4(opts) {
           ...opts?.cwd ? { rootDir: opts.cwd } : {},
           additionalWritableRoots: [],
           getCommandConfirmation: async () => ({ approved: true }),
-          onItem: () => {
+          onItem: (item) => {
+            if (item && typeof item === "object" && "type" in item && item.type === "message" && "content" in item && Array.isArray(item.content)) {
+              const itemText = item.content.filter(
+                (block) => Boolean(block) && typeof block === "object" && "type" in block && block.type === "output_text"
+              ).map((block) => block.text ?? "").join("");
+              if (itemText) {
+                state.reporter.emit(itemText);
+              }
+            }
           },
           onLoading: () => {
+            if (state.loadingReported) return;
+            state.loadingReported = true;
+            state.reporter.emit("thinking");
           },
           onLastResponseId: () => {
           }
         });
-        sessions.set(sessionId, agent);
+        state.agent = agent;
+        sessions.set(sessionId, state);
         log.debug(`Session created: ${sessionId}`);
         return sessionId;
       } catch (err) {
@@ -5788,35 +5908,55 @@ async function boot4(opts) {
         throw err;
       }
     },
-    async prompt(sessionId, text) {
-      const agent = sessions.get(sessionId);
-      if (!agent) {
+    async prompt(sessionId, text, options) {
+      const state = sessions.get(sessionId);
+      if (!state) {
         throw new Error(`Codex session ${sessionId} not found`);
       }
       log.debug(`Sending prompt to session ${sessionId} (${text.length} chars)...`);
+      state.onProgress = options?.onProgress;
+      state.reporter = createProgressReporter(state.onProgress);
+      state.loadingReported = false;
       try {
-        const items = await agent.run([text]);
+        state.reporter.emit("Waiting for Codex response");
+        const items = await state.agent.run([text]);
         const parts = [];
         for (const item of items) {
           if (item.type === "message" && "content" in item) {
             const content = item.content;
             const itemText = content.filter((block) => block.type === "output_text").map((block) => block.text ?? "").join("");
-            if (itemText) parts.push(itemText);
+            if (itemText) {
+              parts.push(itemText);
+            }
           }
         }
+        state.reporter.emit("Finalizing response");
         const result = parts.join("") || null;
         log.debug(`Prompt response received (${result?.length ?? 0} chars)`);
         return result;
       } catch (err) {
         log.debug(`Prompt failed: ${log.formatErrorChain(err)}`);
         throw err;
+      } finally {
+        state.onProgress = void 0;
+        state.reporter = createProgressReporter();
+        state.loadingReported = false;
+      }
+    },
+    async send(sessionId, text) {
+      const state = sessions.get(sessionId);
+      if (!state) {
+        throw new Error(`Codex session ${sessionId} not found`);
       }
+      log.debug(
+        `Codex provider does not support non-blocking send \u2014 agent.run() is blocking. Ignoring follow-up for session ${sessionId} (${text.length} chars).`
+      );
     },
     async cleanup() {
       log.debug("Cleaning up Codex provider...");
-      for (const agent of sessions.values()) {
+      for (const state of sessions.values()) {
         try {
-          agent.terminate();
+          state.agent.terminate();
         } catch {
         }
       }
@@ -5827,6 +5967,7 @@ async function boot4(opts) {
 var init_codex = __esm({
   "src/providers/codex.ts"() {
     "use strict";
+    init_progress();
     init_logger();
   }
 });
@@ -6128,19 +6269,10 @@ import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 
 // src/datasources/github.ts
+init_logger();
 import { execFile } from "child_process";
 import { promisify } from "util";
 
-// src/helpers/slugify.ts
-var MAX_SLUG_LENGTH = 60;
-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();
-
 // src/helpers/branch-validation.ts
 var InvalidBranchNameError = class extends Error {
   constructor(branch, reason) {
@@ -6271,6 +6403,31 @@ ${deviceCodeInfo.message}`;
     azdev.getBearerHandler(accessToken.token)
   );
 }
+async function ensureAuthReady(source, cwd, org) {
+  if (source === "github") {
+    const remoteUrl = await getGitRemoteUrl(cwd);
+    if (remoteUrl && parseGitHubRemoteUrl(remoteUrl)) {
+      await getGithubOctokit();
+    } else if (!remoteUrl) {
+      log.warn("No git remote found \u2014 skipping GitHub pre-authentication");
+    } else {
+      log.warn("Remote URL is not a GitHub repository \u2014 skipping GitHub pre-authentication");
+    }
+  } else if (source === "azdevops") {
+    let orgUrl = org;
+    if (!orgUrl) {
+      const remoteUrl = await getGitRemoteUrl(cwd);
+      if (remoteUrl) {
+        const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
+        if (parsed) orgUrl = parsed.orgUrl;
+        else log.warn("Remote URL is not an Azure DevOps repository \u2014 skipping Azure pre-authentication");
+      } else {
+        log.warn("No git remote found \u2014 skipping Azure DevOps pre-authentication");
+      }
+    }
+    if (orgUrl) await getAzureConnection(orgUrl);
+  }
+}
 
 // src/datasources/github.ts
 var exec = promisify(execFile);
@@ -6292,9 +6449,31 @@ async function getOwnerRepo(cwd) {
   }
   return parsed;
 }
-function buildBranchName(issueNumber, title, username = "unknown") {
-  const slug = slugify(title, 50);
-  return `${username}/dispatch/${issueNumber}-${slug}`;
+function buildBranchName(issueNumber, _title, username = "unknown") {
+  return `${username}/dispatch/issue-${issueNumber}`;
+}
+async function deriveShortUsername(cwd, fallback) {
+  try {
+    const raw = (await git(["config", "user.name"], cwd)).trim();
+    if (raw) {
+      const parts = raw.toLowerCase().replace(/[^a-z\s]/g, "").trim().split(/\s+/);
+      if (parts.length >= 2) {
+        return parts[0].slice(0, 2) + parts[parts.length - 1].slice(0, 6) || fallback;
+      }
+    }
+  } catch {
+  }
+  try {
+    const raw = (await git(["config", "user.email"], cwd)).trim();
+    if (raw) {
+      const localPart = raw.split("@")[0].toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (localPart) {
+        return localPart.slice(0, 8);
+      }
+    }
+  } catch {
+  }
+  return fallback;
 }
 async function getDefaultBranch(cwd) {
   const PREFIX = "refs/remotes/origin/";
@@ -6422,13 +6601,8 @@ var datasource = {
     };
   },
   async getUsername(opts) {
-    try {
-      const name = await git(["config", "user.name"], opts.cwd);
-      const slug = slugify(name.trim());
-      return slug || "unknown";
-    } catch {
-      return "unknown";
-    }
+    if (opts.username) return opts.username;
+    return deriveShortUsername(opts.cwd, "unknown");
   },
   getDefaultBranch(opts) {
     return getDefaultBranch(opts.cwd);
@@ -6517,9 +6691,9 @@ var datasource = {
 };
 
 // src/datasources/azdevops.ts
+init_logger();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-init_logger();
 import { PullRequestStatus } from "azure-devops-node-api/interfaces/GitInterfaces.js";
 var exec2 = promisify2(execFile2);
 var doneStateCache = /* @__PURE__ */ new Map();
@@ -6630,6 +6804,29 @@ async function fetchComments(workItemId, project, connection) {
     return [];
   }
 }
+async function deriveShortUsername2(cwd, fallback) {
+  try {
+    const raw = (await git2(["config", "user.name"], cwd)).trim();
+    if (raw) {
+      const parts = raw.toLowerCase().replace(/[^a-z\s]/g, "").trim().split(/\s+/);
+      if (parts.length >= 2) {
+        return parts[0].slice(0, 2) + parts[parts.length - 1].slice(0, 6) || fallback;
+      }
+    }
+  } catch {
+  }
+  try {
+    const raw = (await git2(["config", "user.email"], cwd)).trim();
+    if (raw) {
+      const localPart = raw.split("@")[0].toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (localPart) {
+        return localPart.slice(0, 8);
+      }
+    }
+  } catch {
+  }
+  return fallback;
+}
 var datasource2 = {
   name: "azdevops",
   supportsGit() {
@@ -6774,17 +6971,11 @@ var datasource2 = {
     return this.getDefaultBranch(opts);
   },
   async getUsername(opts) {
-    try {
-      const name = await git2(["config", "user.name"], opts.cwd);
-      const slug = slugify(name.trim());
-      if (slug) return slug;
-    } catch {
-    }
-    return "unknown";
+    if (opts.username) return opts.username;
+    return deriveShortUsername2(opts.cwd, "unknown");
   },
-  buildBranchName(issueNumber, title, username) {
-    const slug = slugify(title, 50);
-    const branch = `${username}/dispatch/${issueNumber}-${slug}`;
+  buildBranchName(issueNumber, _title, username) {
+    const branch = `${username}/dispatch/issue-${issueNumber}`;
     if (!isValidBranchName(branch)) {
       throw new InvalidBranchNameError(branch);
     }
@@ -6891,6 +7082,13 @@ import { basename, dirname as dirname5, isAbsolute, join as join5, parse as pars
 import { promisify as promisify4 } from "util";
 import { glob } from "glob";
 
+// src/helpers/slugify.ts
+var MAX_SLUG_LENGTH = 60;
+function slugify(input3, maxLength) {
+  const slug = input3.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return maxLength != null ? slug.slice(0, maxLength) : slug;
+}
+
 // src/config.ts
 init_providers();
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
@@ -7026,6 +7224,12 @@ async function runInteractiveConfigWizard(configDir) {
     });
     if (areaInput.trim()) area = areaInput.trim();
   }
+  try {
+    await ensureAuthReady(effectiveSource ?? void 0, process.cwd(), org);
+  } catch (err) {
+    log.warn(`Authentication failed: ${err instanceof Error ? err.message : String(err)}`);
+    log.warn("You can re-run 'dispatch config' or authenticate later at runtime.");
+  }
   const newConfig = {
     provider,
     source
@@ -7067,9 +7271,12 @@ async function runInteractiveConfigWizard(configDir) {
 var CONFIG_BOUNDS = {
   testTimeout: { min: 1, max: 120 },
   planTimeout: { min: 1, max: 120 },
+  specTimeout: { min: 1, max: 120 },
+  specWarnTimeout: { min: 1, max: 120 },
+  specKillTimeout: { min: 1, max: 120 },
   concurrency: { min: 1, max: 64 }
 };
-var CONFIG_KEYS = ["provider", "model", "source", "testTimeout", "planTimeout", "concurrency", "org", "project", "workItemType", "iteration", "area"];
+var CONFIG_KEYS = ["provider", "model", "source", "testTimeout", "planTimeout", "specTimeout", "specWarnTimeout", "specKillTimeout", "concurrency", "org", "project", "workItemType", "iteration", "area", "username"];
 function getConfigPath(configDir) {
   const dir = configDir ?? join4(process.cwd(), ".dispatch");
   return join4(dir, "config.json");
@@ -7153,10 +7360,33 @@ function toIssueDetails(filename, content, dir) {
     acceptanceCriteria: ""
   };
 }
-var datasource3 = {
-  name: "md",
-  supportsGit() {
-    return true;
+async function deriveShortUsername3(cwd, fallback) {
+  try {
+    const raw = (await git3(["config", "user.name"], cwd)).trim();
+    if (raw) {
+      const parts = raw.toLowerCase().replace(/[^a-z\s]/g, "").trim().split(/\s+/);
+      if (parts.length >= 2) {
+        return parts[0].slice(0, 2) + parts[parts.length - 1].slice(0, 6) || fallback;
+      }
+    }
+  } catch {
+  }
+  try {
+    const raw = (await git3(["config", "user.email"], cwd)).trim();
+    if (raw) {
+      const localPart = raw.split("@")[0].toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (localPart) {
+        return localPart.slice(0, 8);
+      }
+    }
+  } catch {
+  }
+  return fallback;
+}
+var datasource3 = {
+  name: "md",
+  supportsGit() {
+    return true;
   },
   async list(opts) {
     if (opts?.pattern) {
@@ -7267,29 +7497,22 @@ var datasource3 = {
     return this.getDefaultBranch(opts);
   },
   async getUsername(opts) {
-    try {
-      const { stdout } = await exec4("git", ["config", "user.name"], { cwd: opts.cwd, shell: process.platform === "win32" });
-      const name = stdout.trim();
-      if (!name) return "local";
-      return slugify(name);
-    } catch {
-      return "local";
-    }
+    if (opts.username) return opts.username;
+    return deriveShortUsername3(opts.cwd, "local");
   },
-  buildBranchName(issueNumber, title, username) {
-    const slug = slugify(title, 50);
+  buildBranchName(issueNumber, _title, username) {
     if (issueNumber.includes("/") || issueNumber.includes("\\")) {
       const normalized = issueNumber.replaceAll("\\", "/");
       const filename = basename(normalized);
       const idMatch = /^(\d+)-(.+)\.md$/.exec(filename);
       if (idMatch) {
-        return `${username}/dispatch/file-${idMatch[1]}-${slug}`;
+        return `${username}/dispatch/issue-${idMatch[1]}`;
       }
       const nameWithoutExt = parsePath(filename).name;
       const slugifiedName = slugify(nameWithoutExt, 50);
-      return `${username}/dispatch/file-${slugifiedName}-${slug}`;
+      return `${username}/dispatch/file-${slugifiedName}`;
     }
-    return `${username}/dispatch/${issueNumber}-${slug}`;
+    return `${username}/dispatch/issue-${issueNumber}`;
   },
   async createAndSwitchBranch(branchName, opts) {
     try {
@@ -7439,6 +7662,9 @@ function parseGitHubRemoteUrl(url) {
 // src/spec-generator.ts
 init_logger();
 var MB_PER_CONCURRENT_TASK = 500;
+var DEFAULT_SPEC_TIMEOUT_MIN = 10;
+var DEFAULT_SPEC_WARN_MIN = 10;
+var DEFAULT_SPEC_KILL_MIN = 10;
 var RECOGNIZED_H2 = /* @__PURE__ */ new Set([
   "## Context",
   "## Why",
@@ -7900,12 +8126,16 @@ var CONFIG_TO_CLI = {
   source: "issueSource",
   testTimeout: "testTimeout",
   planTimeout: "planTimeout",
+  specTimeout: "specTimeout",
+  specWarnTimeout: "specWarnTimeout",
+  specKillTimeout: "specKillTimeout",
   concurrency: "concurrency",
   org: "org",
   project: "project",
   workItemType: "workItemType",
   iteration: "iteration",
-  area: "area"
+  area: "area",
+  username: "username"
 };
 function setCliField(target, key, value) {
   target[key] = value;
@@ -7968,6 +8198,7 @@ init_providers();
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile6, unlink } from "fs/promises";
 import { join as join10, resolve as resolve2, sep } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
+init_timeout();
 init_logger();
 init_file_logger();
 init_environment();
@@ -7979,7 +8210,7 @@ async function boot5(opts) {
   return {
     name: "spec",
     async generate(genOpts) {
-      const { issue, filePath, fileContent, inlineText, cwd: workingDir, outputPath } = genOpts;
+      const { issue, filePath, fileContent, inlineText, cwd: workingDir, outputPath, onProgress } = genOpts;
       const startTime = Date.now();
       try {
         const resolvedCwd = resolve2(workingDir);
@@ -8014,7 +8245,50 @@ async function boot5(opts) {
         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);
+        const warnMs = genOpts.timeboxWarnMs ?? DEFAULT_SPEC_WARN_MIN * 6e4;
+        const killMs = genOpts.timeboxKillMs ?? DEFAULT_SPEC_KILL_MIN * 6e4;
+        const response = await new Promise((resolve5, reject) => {
+          let settled = false;
+          let warnTimer;
+          let killTimer;
+          const cleanup = () => {
+            if (warnTimer) clearTimeout(warnTimer);
+            if (killTimer) clearTimeout(killTimer);
+          };
+          warnTimer = setTimeout(() => {
+            if (settled) return;
+            const remainingSec = Math.round(killMs / 1e3);
+            const warnMessage = `Your spec generation time is done. You have exceeded the ${Math.round(warnMs / 6e4)}-minute limit. You MUST write the spec file to "${outputPath}" immediately. If you do not comply within ${remainingSec} seconds, you will be terminated.`;
+            log.warn(`Timebox warn fired for session ${sessionId} \u2014 sending wrap-up message`);
+            if (provider.send) {
+              provider.send(sessionId, warnMessage).catch((err) => {
+                log.warn(`Failed to send timebox warning: ${log.extractMessage(err)}`);
+              });
+            } else {
+              log.warn(`Provider does not support send() \u2014 cannot deliver timebox warning`);
+            }
+            killTimer = setTimeout(() => {
+              if (settled) return;
+              settled = true;
+              cleanup();
+              reject(new TimeoutError(warnMs + killMs, "spec timebox"));
+            }, killMs);
+          }, warnMs);
+          provider.prompt(sessionId, prompt, { onProgress }).then(
+            (value) => {
+              if (settled) return;
+              settled = true;
+              cleanup();
+              resolve5(value);
+            },
+            (err) => {
+              if (settled) return;
+              settled = true;
+              cleanup();
+              reject(err);
+            }
+          );
+        });
         if (response === null) {
           return {
             data: null,
@@ -8140,12 +8414,18 @@ function buildCommonSpecInstructions(params) {
   return [
     `You are a **spec agent**. Your job is to explore the codebase, understand ${subject}, and write a high-level **markdown spec file** to disk that will drive an automated implementation pipeline.`,
     ``,
+    `**Time limit:** You have ${DEFAULT_SPEC_WARN_MIN} minutes to complete this spec. Work efficiently and focus on delivering a complete, well-structured spec within this window.`,
+    ``,
     `**Important:** This file will be consumed by a two-stage pipeline:`,
     `1. A **planner agent** reads each task together with the prose context in this file, then explores the codebase to produce a detailed, line-level implementation plan.`,
     `2. A **coder agent** follows that detailed plan to make the actual code changes.`,
     ``,
     `Because the planner agent handles low-level details, your spec must stay **high-level and strategic**. Focus on the WHAT, WHY, and HOW \u2014 not exact code or line numbers.`,
     ``,
+    `**Scope:** Each invocation is scoped to exactly one source item. The source item for this invocation is the single passed issue, file, or inline request shown below.`,
+    `Treat other repository materials \u2014 including existing spec files, sibling issues, and future work \u2014 as context only unless the passed source explicitly references them as required context.`,
+    `Do not merge unrelated specs, issues, files, or requests into the generated output.`,
+    ``,
     `**CRITICAL \u2014 Output constraints (read carefully):**`,
     `The file you write must contain ONLY the structured spec content described below. You MUST NOT include:`,
     `- **No preamble:** Do not add any text before the H1 heading (e.g., "Here's the spec:", "I've written the spec file to...")`,
@@ -8300,7 +8580,11 @@ function buildInlineTextSpecPrompt(text, cwd, outputPath) {
 init_cleanup();
 init_logger();
 init_file_logger();
+import chalk6 from "chalk";
+
+// src/tui.ts
 import chalk5 from "chalk";
+import { emitKeypressEvents } from "readline";
 
 // src/helpers/format.ts
 import chalk4 from "chalk";
@@ -8326,8 +8610,402 @@ function renderHeaderLines(info) {
   return lines;
 }
 
+// src/tui.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var BAR_WIDTH = 30;
+var spinnerIndex = 0;
+var interval = null;
+var lastLineCount = 0;
+function spinner() {
+  return chalk5.cyan(SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length]);
+}
+function progressBar(done, total) {
+  if (total === 0) return chalk5.dim("\u2591".repeat(BAR_WIDTH));
+  const filled = Math.round(done / total * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const pct = Math.round(done / total * 100);
+  return chalk5.green("\u2588".repeat(filled)) + chalk5.dim("\u2591".repeat(empty)) + chalk5.white(` ${pct}%`);
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pending":
+      return chalk5.dim("\u25CB");
+    case "planning":
+      return spinner();
+    case "running":
+    case "generating":
+    case "syncing":
+      return spinner();
+    case "paused":
+      return chalk5.yellow("\u25D0");
+    case "done":
+      return chalk5.green("\u25CF");
+    case "failed":
+      return chalk5.red("\u2716");
+  }
+}
+function statusLabel(status) {
+  switch (status) {
+    case "pending":
+      return chalk5.dim("pending");
+    case "planning":
+      return chalk5.magenta("planning");
+    case "running":
+      return chalk5.cyan("executing");
+    case "generating":
+      return chalk5.cyan("generating");
+    case "syncing":
+      return chalk5.cyan("syncing");
+    case "paused":
+      return chalk5.yellow("paused");
+    case "done":
+      return chalk5.green("done");
+    case "failed":
+      return chalk5.red("failed");
+  }
+}
+function phaseLabel(phase, provider, mode = "dispatch") {
+  switch (phase) {
+    case "discovering":
+      return `${spinner()} Discovering task files...`;
+    case "parsing":
+      return `${spinner()} Parsing tasks...`;
+    case "booting": {
+      const name = provider ?? "provider";
+      return `${spinner()} Connecting to ${name}...`;
+    }
+    case "dispatching":
+      return mode === "spec" ? `${spinner()} Generating specs...` : `${spinner()} Dispatching tasks...`;
+    case "paused":
+      return chalk5.yellow("\u25D0") + " Waiting for rerun...";
+    case "done":
+      return chalk5.green("\u2714") + " Complete";
+  }
+}
+function isActiveStatus(status) {
+  return status === "planning" || status === "running" || status === "generating" || status === "syncing";
+}
+function sanitizeSubordinateText(text) {
+  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\r\n]+/g, " ").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]+/g, "").replace(/\s+/g, " ").trim();
+}
+function truncateText(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, Math.max(0, maxLen - 1)) + "\u2026";
+}
+function renderTaskError(error) {
+  if (!error) return null;
+  return chalk5.red(`       \u2514\u2500 ${error}`);
+}
+function renderTaskFeedback(feedback, cols) {
+  if (!feedback) return null;
+  const sanitized = sanitizeSubordinateText(feedback);
+  if (!sanitized) return null;
+  const maxLen = Math.max(16, cols - 10);
+  return chalk5.dim(`       \u2514\u2500 ${truncateText(sanitized, maxLen)}`);
+}
+function countVisualRows(text, cols) {
+  const stripped = text.replace(/\x1B\[[0-9;]*m/g, "");
+  const safeCols = Math.max(1, cols);
+  return stripped.split("\n").reduce((sum, line) => {
+    return sum + Math.max(1, Math.ceil(line.length / safeCols));
+  }, 0);
+}
+function toggleRecoveryAction(action) {
+  return action === "rerun" ? "quit" : "rerun";
+}
+function renderRecoveryAction(action, selectedAction) {
+  const selected = action === selectedAction;
+  if (action === "rerun") {
+    return selected ? chalk5.greenBright(`[\u25B6 rerun]`) : chalk5.dim("\u25B6 rerun");
+  }
+  return selected ? chalk5.redBright("[q quit]") : chalk5.dim("q quit");
+}
+function render(state, cols) {
+  const lines = [];
+  const now = Date.now();
+  const totalElapsed = elapsed(now - state.startTime);
+  const done = state.tasks.filter((t) => t.status === "done").length;
+  const failed = state.tasks.filter((t) => t.status === "failed").length;
+  const total = state.tasks.length;
+  lines.push("");
+  lines.push(
+    ...renderHeaderLines({
+      provider: state.provider,
+      model: state.model,
+      source: state.source
+    })
+  );
+  if (state.currentIssue) {
+    lines.push(
+      chalk5.dim(`  issue: `) + chalk5.white(`#${state.currentIssue.number}`) + chalk5.dim(` \u2014 ${state.currentIssue.title}`)
+    );
+  }
+  lines.push(chalk5.dim("  \u2500".repeat(24)));
+  if (state.notification) {
+    lines.push("");
+    for (const notifLine of state.notification.split("\n")) {
+      lines.push("  " + chalk5.yellowBright("\u26A0 ") + chalk5.yellow(notifLine));
+    }
+  }
+  lines.push(`  ${phaseLabel(state.phase, state.provider, state.mode)}` + chalk5.dim(`  ${totalElapsed}`));
+  if (state.phase === "dispatching" || state.phase === "paused" || state.phase === "done") {
+    lines.push("");
+    lines.push(`  ${progressBar(done + failed, total)}  ${chalk5.dim(`${done + failed}/${total} tasks`)}`);
+    lines.push("");
+    const activeWorktrees = new Set(
+      state.tasks.map((t) => t.worktree).filter(Boolean)
+    );
+    const showWorktree = activeWorktrees.size > 1;
+    const maxTextLen = cols - 30;
+    const paused = state.tasks.filter((t) => t.status === "paused");
+    const running = state.tasks.filter((t) => isActiveStatus(t.status));
+    const completed = state.tasks.filter(
+      (t) => t.status === "done" || t.status === "failed"
+    );
+    const pending = state.tasks.filter((t) => t.status === "pending");
+    if (showWorktree) {
+      const groups = /* @__PURE__ */ new Map();
+      const ungrouped = [];
+      for (const ts of state.tasks) {
+        if (ts.worktree) {
+          const arr = groups.get(ts.worktree) ?? [];
+          arr.push(ts);
+          groups.set(ts.worktree, arr);
+        } else {
+          ungrouped.push(ts);
+        }
+      }
+      const doneGroups = [];
+      const activeGroups = [];
+      for (const [wt, tasks] of groups) {
+        const allDone = tasks.every((t) => t.status === "done" || t.status === "failed");
+        if (allDone) {
+          doneGroups.push([wt, tasks]);
+        } else {
+          activeGroups.push([wt, tasks]);
+        }
+      }
+      if (doneGroups.length > 3) {
+        lines.push(chalk5.dim(`  \xB7\xB7\xB7 ${doneGroups.length - 3} earlier issue(s) completed`));
+      }
+      for (const [wt, tasks] of doneGroups.slice(-3)) {
+        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
+        const anyFailed = tasks.some((t) => t.status === "failed");
+        const icon = anyFailed ? chalk5.red("\u2716") : chalk5.green("\u25CF");
+        const doneCount = tasks.filter((t) => t.status === "done").length;
+        const maxElapsed = Math.max(...tasks.map((t) => t.elapsed ?? 0));
+        lines.push(`  ${icon} ${chalk5.dim(`#${issueNum}`)}  ${chalk5.dim(`${doneCount}/${tasks.length} tasks`)}  ${chalk5.dim(elapsed(maxElapsed))}`);
+      }
+      for (const [wt, tasks] of activeGroups) {
+        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
+        const activeTasks = tasks.filter((t) => isActiveStatus(t.status) || t.status === "paused");
+        const firstActive = activeTasks[0];
+        const displayStatus = firstActive?.status ?? "pending";
+        const truncLen = Math.min(cols - 26, 60);
+        let text = firstActive?.task.text ?? tasks[0]?.task.text ?? "";
+        if (text.length > truncLen) {
+          text = text.slice(0, truncLen - 1) + "\u2026";
+        }
+        const earliest = activeTasks.length > 0 ? Math.min(...activeTasks.map((t) => t.elapsed ?? now)) : now;
+        const elapsedStr = elapsed(now - earliest);
+        const countLabel = activeTasks.length > 0 ? `${activeTasks.length} active` : `${tasks.length} pending`;
+        lines.push(`  ${statusIcon(displayStatus)} ${chalk5.white(`#${issueNum}`)}  ${countLabel}  ${text}  ${chalk5.dim(elapsedStr)}`);
+      }
+      for (const ts of ungrouped) {
+        if (!isActiveStatus(ts.status) && ts.status !== "paused") continue;
+        const icon = statusIcon(ts.status);
+        const idx = chalk5.dim(`#${state.tasks.indexOf(ts) + 1}`);
+        const text = truncateText(ts.task.text, maxTextLen);
+        const elapsedStr = chalk5.dim(` ${elapsed(now - (ts.elapsed || now))}`);
+        const label = statusLabel(ts.status);
+        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
+        const feedbackLine = ts.status === "generating" ? renderTaskFeedback(ts.feedback, cols) : null;
+        if (feedbackLine) {
+          lines.push(feedbackLine);
+        }
+        const errorLine = renderTaskError(ts.error);
+        if (errorLine) {
+          lines.push(errorLine);
+        }
+      }
+    } else {
+      const visibleRunning = running.slice(0, 8);
+      const visible = [
+        ...completed.slice(-3),
+        ...paused.slice(0, 3),
+        ...visibleRunning,
+        ...pending.slice(0, 3)
+      ];
+      if (completed.length > 3) {
+        lines.push(chalk5.dim(`  \xB7\xB7\xB7 ${completed.length - 3} earlier task(s) completed`));
+      }
+      for (const ts of visible) {
+        const icon = statusIcon(ts.status);
+        const idx = chalk5.dim(`#${state.tasks.indexOf(ts) + 1}`);
+        const text = truncateText(ts.task.text, maxTextLen);
+        const elapsedStr = isActiveStatus(ts.status) ? chalk5.dim(` ${elapsed(now - (ts.elapsed || now))}`) : ts.status === "done" && ts.elapsed ? chalk5.dim(` ${elapsed(ts.elapsed)}`) : "";
+        const label = statusLabel(ts.status);
+        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
+        const feedbackLine = ts.status === "generating" ? renderTaskFeedback(ts.feedback, cols) : null;
+        if (feedbackLine) {
+          lines.push(feedbackLine);
+        }
+        const errorLine = renderTaskError(ts.error);
+        if (errorLine) {
+          lines.push(errorLine);
+        }
+      }
+      if (running.length > 8) {
+        lines.push(chalk5.dim(`  \xB7\xB7\xB7 ${running.length - 8} more running`));
+      }
+      if (pending.length > 3) {
+        lines.push(chalk5.dim(`  \xB7\xB7\xB7 ${pending.length - 3} more task(s) pending`));
+      }
+    }
+    if (state.phase === "paused" && state.recovery) {
+      const selectedAction = state.recovery.selectedAction ?? "rerun";
+      lines.push("");
+      lines.push(`  ${chalk5.yellow("Recovery")}: ${chalk5.white(`#${state.recovery.taskIndex + 1}`)} ${state.recovery.taskText}`);
+      lines.push(`  ${chalk5.red(state.recovery.error)}`);
+      if (state.recovery.issue) {
+        lines.push(`  ${chalk5.dim(`Issue #${state.recovery.issue.number} - ${state.recovery.issue.title}`)}`);
+      }
+      if (state.recovery.worktree) {
+        lines.push(`  ${chalk5.dim(`Worktree: ${state.recovery.worktree}`)}`);
+      }
+      lines.push(`  ${chalk5.red("\u2716")} ${renderRecoveryAction("rerun", selectedAction)}  ${renderRecoveryAction("quit", selectedAction)}`);
+      lines.push(`  ${chalk5.dim("Tab/\u2190/\u2192 switch \xB7 Enter/Space runs selection \xB7 r reruns \xB7 q quits")}`);
+    }
+    lines.push("");
+    const parts = [];
+    if (done > 0) parts.push(chalk5.green(`${done} passed`));
+    if (failed > 0) parts.push(chalk5.red(`${failed} failed`));
+    if (total - done - failed > 0)
+      parts.push(chalk5.dim(`${total - done - failed} remaining`));
+    lines.push(`  ${parts.join(chalk5.dim(" \xB7 "))}`);
+  } else if (state.filesFound > 0) {
+    lines.push(chalk5.dim(`  Found ${state.filesFound} file(s)`));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function drawToOutput(state, output) {
+  const cols = output.columns || 80;
+  const rendered = render(state, cols);
+  const newLineCount = countVisualRows(rendered, cols);
+  let buffer = "";
+  if (lastLineCount > 0) {
+    buffer += `\x1B[${lastLineCount}A`;
+  }
+  const lines = rendered.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`;
+  }
+  output.write(buffer);
+  lastLineCount = newLineCount;
+}
+function createTui(options) {
+  const input3 = options?.input ?? process.stdin;
+  const output = options?.output ?? process.stdout;
+  const state = {
+    tasks: [],
+    phase: "discovering",
+    mode: "dispatch",
+    startTime: Date.now(),
+    filesFound: 0
+  };
+  lastLineCount = 0;
+  spinnerIndex = 0;
+  let activeRecoveryPromise = null;
+  let cleanupRecoveryPrompt = null;
+  interval = setInterval(() => {
+    spinnerIndex++;
+    drawToOutput(state, output);
+  }, 80);
+  const update = () => drawToOutput(state, output);
+  const waitForRecoveryAction = () => {
+    if (activeRecoveryPromise) {
+      return activeRecoveryPromise;
+    }
+    activeRecoveryPromise = new Promise((resolve5) => {
+      const ttyInput = input3;
+      const wasRaw = ttyInput.isRaw ?? false;
+      const canToggleRawMode = ttyInput.isTTY === true && typeof ttyInput.setRawMode === "function";
+      if (state.recovery) {
+        state.recovery.selectedAction = state.recovery.selectedAction ?? "rerun";
+        drawToOutput(state, output);
+      }
+      emitKeypressEvents(input3);
+      if (canToggleRawMode) {
+        ttyInput.setRawMode(true);
+      }
+      const finish = (action) => {
+        cleanupRecoveryPrompt?.();
+        resolve5(action);
+      };
+      const updateSelection = (nextAction) => {
+        if (!state.recovery || state.recovery.selectedAction === nextAction) {
+          return;
+        }
+        state.recovery.selectedAction = nextAction;
+        drawToOutput(state, output);
+      };
+      const onKeypress = (str, key) => {
+        const name = key?.name ?? str;
+        if (key?.ctrl && name === "c") {
+          finish("quit");
+          return;
+        }
+        if (name === "r" || name === "R") {
+          finish("rerun");
+          return;
+        }
+        if (name === "q" || name === "Q") {
+          finish("quit");
+          return;
+        }
+        if (name === "tab" || name === "left" || name === "right") {
+          updateSelection(toggleRecoveryAction(state.recovery?.selectedAction ?? "rerun"));
+          return;
+        }
+        if (name === "return" || name === "enter" || name === "space" || str === " ") {
+          finish(state.recovery?.selectedAction ?? "rerun");
+        }
+      };
+      cleanupRecoveryPrompt = () => {
+        input3.off("keypress", onKeypress);
+        if (canToggleRawMode) {
+          ttyInput.setRawMode(wasRaw);
+        }
+        cleanupRecoveryPrompt = null;
+        activeRecoveryPromise = null;
+      };
+      input3.on("keypress", onKeypress);
+    });
+    return activeRecoveryPromise;
+  };
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    if (activeRecoveryPromise) {
+      cleanupRecoveryPrompt?.();
+    }
+    drawToOutput(state, output);
+  };
+  drawToOutput(state, output);
+  return { state, update, stop, waitForRecoveryAction };
+}
+
 // src/helpers/retry.ts
 init_logger();
+var DEFAULT_RETRY_COUNT = 3;
 async function withRetry(fn, maxRetries, options) {
   const maxAttempts = maxRetries + 1;
   const label = options?.label;
@@ -8351,6 +9029,48 @@ async function withRetry(fn, maxRetries, options) {
 
 // src/orchestrator/spec-pipeline.ts
 init_timeout();
+
+// src/helpers/concurrency.ts
+async function runWithConcurrency(options) {
+  const { items, concurrency, worker, shouldStop } = options;
+  if (items.length === 0) return [];
+  const limit = Math.max(1, concurrency);
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  return new Promise((resolve5) => {
+    let active = 0;
+    const launch = () => {
+      while (active < limit && nextIndex < items.length) {
+        if (shouldStop?.()) break;
+        const idx = nextIndex++;
+        active++;
+        worker(items[idx], idx).then(
+          (value) => {
+            results[idx] = { status: "fulfilled", value };
+            active--;
+            launch();
+          },
+          (reason) => {
+            results[idx] = { status: "rejected", reason };
+            active--;
+            launch();
+          }
+        );
+      }
+      if (active === 0) {
+        for (let i = 0; i < results.length; i++) {
+          if (!(i in results)) {
+            results[i] = { status: "skipped" };
+          }
+        }
+        resolve5(results);
+      }
+    };
+    launch();
+  });
+}
+
+// src/orchestrator/spec-pipeline.ts
 var FETCH_TIMEOUT_MS = 3e4;
 async function resolveDatasource(issues, issueSource, specCwd, org, project, workItemType, iteration, area) {
   const source = await resolveSource(issues, issueSource, specCwd);
@@ -8493,13 +9213,14 @@ async function bootPipeline(provider, serverUrl, specCwd, model, source) {
   for (const line of headerLines) {
     console.log(line);
   }
-  console.log(chalk5.dim("  \u2500".repeat(24)));
+  console.log(chalk6.dim("  \u2500".repeat(24)));
   console.log("");
   const specAgent = await boot5({ provider: instance, cwd: specCwd });
   return { specAgent, instance };
 }
-async function generateSpecsBatch(validItems, items, specAgent, instance, isTrackerMode, isInlineText, datasource4, fetchOpts, outputDir, specCwd, concurrency, retries) {
+async function generateSpecsBatch(validItems, items, specAgent, instance, isTrackerMode, isInlineText, datasource4, fetchOpts, outputDir, specCwd, concurrency, retries, specWarnMs, specKillMs, tuiState, tuiUpdate) {
   await mkdir5(outputDir, { recursive: true });
+  const quiet = !!tuiState && !log.verbose;
   const generatedFiles = [];
   const issueNumbers = [];
   const dispatchIdentifiers = [];
@@ -8507,140 +9228,175 @@ async function generateSpecsBatch(validItems, items, specAgent, instance, isTrac
   const fileDurationsMs = {};
   const genQueue = [...validItems];
   let modelLoggedInBanner = !!instance.model;
-  while (genQueue.length > 0) {
-    const batch = genQueue.splice(0, concurrency);
-    log.info(`Generating specs for batch of ${batch.length} (${generatedFiles.length + failed}/${items.length} done)...`);
-    const batchResults = await Promise.all(
-      batch.map(async ({ id, details }) => {
-        const specStart = Date.now();
-        if (!details) {
-          log.error(`Skipping item ${id}: missing issue details`);
-          return null;
+  async function processItem({ id, details }) {
+    const specStart = Date.now();
+    const tuiTask = tuiState?.tasks.find((t) => t.task.file === id);
+    if (tuiTask) {
+      tuiTask.status = "generating";
+      tuiTask.elapsed = specStart;
+      tuiUpdate?.();
+    }
+    if (!details) {
+      log.error(`Skipping item ${id}: missing issue details`);
+      failed++;
+      return;
+    }
+    const itemBody = async () => {
+      let filepath;
+      if (isTrackerMode) {
+        const slug = slugify(details.title, MAX_SLUG_LENGTH);
+        const filename = `${id}-${slug}.md`;
+        filepath = join11(outputDir, filename);
+      } else if (isInlineText) {
+        filepath = id;
+      } else {
+        filepath = id;
+      }
+      fileLoggerStorage.getStore()?.info(`Output path: ${filepath}`);
+      try {
+        fileLoggerStorage.getStore()?.info(`Starting spec generation for ${isTrackerMode ? `#${id}` : filepath}`);
+        if (!quiet) log.info(`Generating spec for ${isTrackerMode ? `#${id}` : filepath}: ${details.title}...`);
+        const generateLabel = `specAgent.generate(${isTrackerMode ? `#${id}` : filepath})`;
+        const result = await withRetry(
+          () => withTimeout(
+            specAgent.generate({
+              issue: isTrackerMode ? details : void 0,
+              filePath: isTrackerMode ? void 0 : id,
+              fileContent: isTrackerMode ? void 0 : details.body,
+              cwd: specCwd,
+              outputPath: filepath,
+              timeboxWarnMs: specWarnMs,
+              timeboxKillMs: specKillMs,
+              onProgress: tuiTask ? (snapshot) => {
+                tuiTask.feedback = snapshot.text;
+                tuiUpdate?.();
+              } : void 0
+            }),
+            specWarnMs + specKillMs,
+            generateLabel
+          ),
+          retries,
+          { label: generateLabel }
+        );
+        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 = join11(outputDir, finalFilename);
+          if (finalFilepath !== filepath) {
+            await rename2(filepath, finalFilepath);
+            filepath = finalFilepath;
+          }
+        }
+        const specDuration = Date.now() - specStart;
+        fileDurationsMs[filepath] = specDuration;
+        if (!quiet) log.success(`Spec written: ${filepath} (${elapsed(specDuration)})`);
+        if (tuiTask) {
+          tuiTask.status = "done";
+          tuiTask.elapsed = specDuration;
+          tuiTask.feedback = void 0;
+          tuiUpdate?.();
+        }
+        let identifier = filepath;
+        fileLoggerStorage.getStore()?.phase("Datasource sync");
+        if (tuiTask) {
+          tuiTask.status = "syncing";
+          tuiTask.feedback = void 0;
+          tuiUpdate?.();
         }
-        const itemBody = async () => {
-          let filepath;
+        try {
           if (isTrackerMode) {
-            const slug = slugify(details.title, MAX_SLUG_LENGTH);
-            const filename = `${id}-${slug}.md`;
-            filepath = join11(outputDir, filename);
-          } else if (isInlineText) {
-            filepath = id;
-          } else {
-            filepath = id;
-          }
-          fileLoggerStorage.getStore()?.info(`Output path: ${filepath}`);
-          try {
-            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 = join11(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 parsed = parseIssueFilename(filepath);
-                if (parsed) {
-                  await datasource4.update(parsed.issueId, details.title, result.data.content, fetchOpts);
-                  log.success(`Updated spec #${parsed.issueId} in-place`);
-                  identifier = parsed.issueId;
-                  issueNumbers.push(parsed.issueId);
-                } else {
-                  const created = await datasource4.create(details.title, result.data.content, fetchOpts);
-                  log.success(`Created spec #${created.number} from ${filepath}`);
-                  identifier = created.number;
-                  issueNumbers.push(created.number);
-                  try {
-                    await unlink2(filepath);
-                    log.success(`Deleted local spec ${filepath} (now tracked as spec #${created.number})`);
-                  } catch (unlinkErr) {
-                    log.warn(`Could not delete local spec ${filepath}: ${log.formatErrorChain(unlinkErr)}`);
-                  }
-                  const oldDuration = fileDurationsMs[filepath];
-                  delete fileDurationsMs[filepath];
-                  filepath = created.url;
-                  fileDurationsMs[filepath] = oldDuration;
-                }
-              } else {
-                const created = await datasource4.create(details.title, result.data.content, fetchOpts);
-                log.success(`Created issue #${created.number} from ${filepath}`);
+            await datasource4.update(id, details.title, result.data.content, fetchOpts);
+            if (!quiet) log.success(`Updated issue #${id} with spec content`);
+            await unlink2(filepath);
+            if (!quiet) log.success(`Deleted local spec ${filepath} (now tracked as issue #${id})`);
+            identifier = id;
+            issueNumbers.push(id);
+          } else if (datasource4.name === "md") {
+            const parsed = parseIssueFilename(filepath);
+            if (parsed) {
+              await datasource4.update(parsed.issueId, details.title, result.data.content, fetchOpts);
+              if (!quiet) log.success(`Updated spec #${parsed.issueId} in-place`);
+              identifier = parsed.issueId;
+              issueNumbers.push(parsed.issueId);
+            } else {
+              const created = await datasource4.create(details.title, result.data.content, fetchOpts);
+              if (!quiet) log.success(`Created spec #${created.number} from ${filepath}`);
+              identifier = created.number;
+              issueNumbers.push(created.number);
+              try {
                 await unlink2(filepath);
-                log.success(`Deleted local spec ${filepath} (now tracked as issue #${created.number})`);
-                identifier = created.number;
-                issueNumbers.push(created.number);
+                if (!quiet) log.success(`Deleted local spec ${filepath} (now tracked as spec #${created.number})`);
+              } catch (unlinkErr) {
+                log.warn(`Could not delete local spec ${filepath}: ${log.formatErrorChain(unlinkErr)}`);
               }
-            } catch (err) {
-              const label = isTrackerMode ? `issue #${id}` : filepath;
-              log.warn(`Could not sync ${label} to datasource: ${log.formatErrorChain(err)}`);
+              const oldDuration = fileDurationsMs[filepath];
+              delete fileDurationsMs[filepath];
+              filepath = created.url;
+              fileDurationsMs[filepath] = oldDuration;
             }
-            return { filepath, identifier };
-          } catch (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;
+          } else {
+            const created = await datasource4.create(details.title, result.data.content, fetchOpts);
+            if (!quiet) log.success(`Created issue #${created.number} from ${filepath}`);
+            await unlink2(filepath);
+            if (!quiet) log.success(`Deleted local spec ${filepath} (now tracked as issue #${created.number})`);
+            identifier = created.number;
+            issueNumbers.push(created.number);
           }
-        };
-        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();
-            }
-          });
+        } catch (err) {
+          const label = isTrackerMode ? `issue #${id}` : filepath;
+          log.warn(`Could not sync ${label} to datasource: ${log.formatErrorChain(err)}`);
         }
-        return itemBody();
-      })
-    );
-    for (const result of batchResults) {
-      if (result !== null) {
-        generatedFiles.push(result.filepath);
-        dispatchIdentifiers.push(result.identifier);
-      } else {
-        failed++;
+        return { filepath, identifier };
+      } catch (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));
+        if (tuiTask) {
+          tuiTask.status = "failed";
+          tuiTask.elapsed = Date.now() - specStart;
+          tuiTask.error = log.extractMessage(err);
+          tuiTask.feedback = void 0;
+          tuiUpdate?.();
+        }
+        return null;
       }
+    };
+    let itemResult;
+    const fileLogger = log.verbose ? new FileLogger(id, specCwd) : null;
+    if (fileLogger) {
+      itemResult = await fileLoggerStorage.run(fileLogger, async () => {
+        try {
+          fileLogger.phase(`Spec generation: ${id}`);
+          return await itemBody();
+        } finally {
+          fileLogger.close();
+        }
+      });
+    } else {
+      itemResult = await itemBody();
+    }
+    if (itemResult !== null) {
+      generatedFiles.push(itemResult.filepath);
+      dispatchIdentifiers.push(itemResult.identifier);
+    } else {
+      failed++;
     }
     if (!modelLoggedInBanner && instance.model) {
-      log.info(`Detected model: ${instance.model}`);
+      if (!quiet) log.info(`Detected model: ${instance.model}`);
       modelLoggedInBanner = true;
     }
   }
+  await runWithConcurrency({
+    items: genQueue,
+    concurrency,
+    worker: async (item) => processItem(item)
+  });
   return { generatedFiles, issueNumbers, dispatchIdentifiers, failed, fileDurationsMs };
 }
 async function cleanupPipeline(specAgent, instance) {
@@ -8687,14 +9443,18 @@ async function runSpecPipeline(opts) {
     area,
     concurrency = defaultConcurrency(),
     dryRun,
-    retries = 2
+    retries = DEFAULT_RETRY_COUNT
   } = opts;
   const pipelineStart = Date.now();
+  const specWarnMs = (opts.specWarnTimeout ?? DEFAULT_SPEC_WARN_MIN) * 6e4;
+  const specKillMs = (opts.specKillTimeout ?? DEFAULT_SPEC_KILL_MIN) * 6e4;
+  log.debug(`Spec timebox: warn=${opts.specWarnTimeout ?? DEFAULT_SPEC_WARN_MIN}m, kill=${opts.specKillTimeout ?? DEFAULT_SPEC_KILL_MIN}m, total=${specWarnMs + specKillMs}ms`);
   const resolved = await resolveDatasource(issues, opts.issueSource, specCwd, org, project, workItemType, iteration, area);
   if (!resolved) {
     return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
   }
   const { source, datasource: datasource4, fetchOpts } = resolved;
+  await ensureAuthReady(source, specCwd, org);
   const isTrackerMode = isIssueNumbers(issues);
   const isInlineText = !isTrackerMode && !isGlobOrFilePath(issues);
   let items;
@@ -8724,33 +9484,85 @@ async function runSpecPipeline(opts) {
     return { total: 0, generated: 0, failed: 0, files: [], issueNumbers: [], durationMs: Date.now() - pipelineStart, fileDurationsMs: {} };
   }
   const { specAgent, instance } = await bootPipeline(provider, serverUrl, specCwd, model, source);
-  const results = await generateSpecsBatch(
-    validItems,
-    items,
-    specAgent,
-    instance,
-    isTrackerMode,
-    isInlineText,
-    datasource4,
-    fetchOpts,
-    outputDir,
-    specCwd,
-    concurrency,
-    retries
-  );
-  await cleanupPipeline(specAgent, instance);
-  const totalDuration = Date.now() - pipelineStart;
-  logSummary(results.generatedFiles, results.dispatchIdentifiers, results.failed, totalDuration);
-  return {
-    total: items.length,
-    generated: results.generatedFiles.length,
-    failed: results.failed,
-    files: results.generatedFiles,
-    issueNumbers: results.issueNumbers,
-    identifiers: results.dispatchIdentifiers,
-    durationMs: totalDuration,
-    fileDurationsMs: results.fileDurationsMs
-  };
+  const verbose = log.verbose;
+  let tui;
+  if (verbose) {
+    const state = {
+      tasks: [],
+      phase: "booting",
+      mode: "spec",
+      startTime: Date.now(),
+      filesFound: 0,
+      provider,
+      model: instance.model,
+      source
+    };
+    tui = {
+      state,
+      update: () => {
+      },
+      stop: () => {
+      },
+      waitForRecoveryAction: async () => "quit"
+    };
+  } else {
+    tui = createTui();
+    tui.state.mode = "spec";
+    tui.state.provider = provider;
+    tui.state.model = instance.model;
+    tui.state.source = source;
+  }
+  tui.state.tasks = validItems.map((item, index) => ({
+    task: {
+      index,
+      text: item.details?.title ?? `Item ${item.id}`,
+      line: 0,
+      raw: item.details?.title ?? item.id,
+      file: item.id
+    },
+    status: "pending"
+  }));
+  tui.state.phase = "dispatching";
+  tui.update();
+  try {
+    const results = await generateSpecsBatch(
+      validItems,
+      items,
+      specAgent,
+      instance,
+      isTrackerMode,
+      isInlineText,
+      datasource4,
+      fetchOpts,
+      outputDir,
+      specCwd,
+      concurrency,
+      retries,
+      specWarnMs,
+      specKillMs,
+      tui.state,
+      tui.update
+    );
+    await cleanupPipeline(specAgent, instance);
+    tui.state.phase = "done";
+    tui.stop();
+    const totalDuration = Date.now() - pipelineStart;
+    logSummary(results.generatedFiles, results.dispatchIdentifiers, results.failed, totalDuration);
+    return {
+      total: items.length,
+      generated: results.generatedFiles.length,
+      failed: results.failed,
+      files: results.generatedFiles,
+      issueNumbers: results.issueNumbers,
+      identifiers: results.dispatchIdentifiers,
+      durationMs: totalDuration,
+      fileDurationsMs: results.fileDurationsMs
+    };
+  } catch (err) {
+    tui.state.phase = "done";
+    tui.stop();
+    throw err;
+  }
 }
 
 // src/orchestrator/dispatch-pipeline.ts
@@ -9296,268 +10108,6 @@ function formatOutputFile(parsed) {
 // src/orchestrator/dispatch-pipeline.ts
 init_logger();
 init_cleanup();
-
-// src/tui.ts
-import chalk6 from "chalk";
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var BAR_WIDTH = 30;
-var spinnerIndex = 0;
-var interval = null;
-var lastLineCount = 0;
-function spinner() {
-  return chalk6.cyan(SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length]);
-}
-function progressBar(done, total) {
-  if (total === 0) return chalk6.dim("\u2591".repeat(BAR_WIDTH));
-  const filled = Math.round(done / total * BAR_WIDTH);
-  const empty = BAR_WIDTH - filled;
-  const pct = Math.round(done / total * 100);
-  return chalk6.green("\u2588".repeat(filled)) + chalk6.dim("\u2591".repeat(empty)) + chalk6.white(` ${pct}%`);
-}
-function statusIcon(status) {
-  switch (status) {
-    case "pending":
-      return chalk6.dim("\u25CB");
-    case "planning":
-      return spinner();
-    case "running":
-      return spinner();
-    case "done":
-      return chalk6.green("\u25CF");
-    case "failed":
-      return chalk6.red("\u2716");
-  }
-}
-function statusLabel(status) {
-  switch (status) {
-    case "pending":
-      return chalk6.dim("pending");
-    case "planning":
-      return chalk6.magenta("planning");
-    case "running":
-      return chalk6.cyan("executing");
-    case "done":
-      return chalk6.green("done");
-    case "failed":
-      return chalk6.red("failed");
-  }
-}
-function phaseLabel(phase, provider) {
-  switch (phase) {
-    case "discovering":
-      return `${spinner()} Discovering task files...`;
-    case "parsing":
-      return `${spinner()} Parsing tasks...`;
-    case "booting": {
-      const name = provider ?? "provider";
-      return `${spinner()} Connecting to ${name}...`;
-    }
-    case "dispatching":
-      return `${spinner()} Dispatching tasks...`;
-    case "done":
-      return chalk6.green("\u2714") + " Complete";
-  }
-}
-function countVisualRows(text, cols) {
-  const stripped = text.replace(/\x1B\[[0-9;]*m/g, "");
-  const safeCols = Math.max(1, cols);
-  return stripped.split("\n").reduce((sum, line) => {
-    return sum + Math.max(1, Math.ceil(line.length / safeCols));
-  }, 0);
-}
-function render(state) {
-  const lines = [];
-  const now = Date.now();
-  const totalElapsed = elapsed(now - state.startTime);
-  const done = state.tasks.filter((t) => t.status === "done").length;
-  const failed = state.tasks.filter((t) => t.status === "failed").length;
-  const total = state.tasks.length;
-  lines.push("");
-  lines.push(
-    ...renderHeaderLines({
-      provider: state.provider,
-      model: state.model,
-      source: state.source
-    })
-  );
-  if (state.currentIssue) {
-    lines.push(
-      chalk6.dim(`  issue: `) + chalk6.white(`#${state.currentIssue.number}`) + chalk6.dim(` \u2014 ${state.currentIssue.title}`)
-    );
-  }
-  lines.push(chalk6.dim("  \u2500".repeat(24)));
-  if (state.notification) {
-    lines.push("");
-    for (const notifLine of state.notification.split("\n")) {
-      lines.push("  " + chalk6.yellowBright("\u26A0 ") + chalk6.yellow(notifLine));
-    }
-  }
-  lines.push(`  ${phaseLabel(state.phase, state.provider)}` + chalk6.dim(`  ${totalElapsed}`));
-  if (state.phase === "dispatching" || state.phase === "done") {
-    lines.push("");
-    lines.push(`  ${progressBar(done + failed, total)}  ${chalk6.dim(`${done + failed}/${total} tasks`)}`);
-    lines.push("");
-    const activeWorktrees = new Set(
-      state.tasks.map((t) => t.worktree).filter(Boolean)
-    );
-    const showWorktree = activeWorktrees.size > 1;
-    const cols = process.stdout.columns || 80;
-    const maxTextLen = cols - 30;
-    const running = state.tasks.filter((t) => t.status === "running" || t.status === "planning");
-    const completed = state.tasks.filter(
-      (t) => t.status === "done" || t.status === "failed"
-    );
-    const pending = state.tasks.filter((t) => t.status === "pending");
-    if (showWorktree) {
-      const groups = /* @__PURE__ */ new Map();
-      const ungrouped = [];
-      for (const ts of state.tasks) {
-        if (ts.worktree) {
-          const arr = groups.get(ts.worktree) ?? [];
-          arr.push(ts);
-          groups.set(ts.worktree, arr);
-        } else {
-          ungrouped.push(ts);
-        }
-      }
-      const doneGroups = [];
-      const activeGroups = [];
-      for (const [wt, tasks] of groups) {
-        const allDone = tasks.every((t) => t.status === "done" || t.status === "failed");
-        if (allDone) {
-          doneGroups.push([wt, tasks]);
-        } else {
-          activeGroups.push([wt, tasks]);
-        }
-      }
-      if (doneGroups.length > 3) {
-        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${doneGroups.length - 3} earlier issue(s) completed`));
-      }
-      for (const [wt, tasks] of doneGroups.slice(-3)) {
-        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
-        const anyFailed = tasks.some((t) => t.status === "failed");
-        const icon = anyFailed ? chalk6.red("\u2716") : chalk6.green("\u25CF");
-        const doneCount = tasks.filter((t) => t.status === "done").length;
-        const maxElapsed = Math.max(...tasks.map((t) => t.elapsed ?? 0));
-        lines.push(`  ${icon} ${chalk6.dim(`#${issueNum}`)}  ${chalk6.dim(`${doneCount}/${tasks.length} tasks`)}  ${chalk6.dim(elapsed(maxElapsed))}`);
-      }
-      for (const [wt, tasks] of activeGroups) {
-        const issueNum = wt.match(/^(\d+)/)?.[1] ?? wt.slice(0, 12);
-        const activeTasks = tasks.filter((t) => t.status === "running" || t.status === "planning");
-        const activeCount = activeTasks.length;
-        const firstActive = activeTasks[0];
-        const truncLen = Math.min(cols - 26, 60);
-        let text = firstActive?.task.text ?? "";
-        if (text.length > truncLen) {
-          text = text.slice(0, truncLen - 1) + "\u2026";
-        }
-        const earliest = Math.min(...activeTasks.map((t) => t.elapsed ?? now));
-        const elapsedStr = elapsed(now - earliest);
-        lines.push(`  ${spinner()} ${chalk6.white(`#${issueNum}`)}  ${activeCount} active  ${text}  ${chalk6.dim(elapsedStr)}`);
-      }
-      for (const ts of ungrouped) {
-        if (ts.status !== "running" && ts.status !== "planning") continue;
-        const icon = statusIcon(ts.status);
-        const idx = chalk6.dim(`#${state.tasks.indexOf(ts) + 1}`);
-        let text = ts.task.text;
-        if (text.length > maxTextLen) {
-          text = text.slice(0, maxTextLen - 1) + "\u2026";
-        }
-        const elapsedStr = chalk6.dim(` ${elapsed(now - (ts.elapsed || now))}`);
-        const label = statusLabel(ts.status);
-        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
-        if (ts.error) {
-          lines.push(chalk6.red(`       \u2514\u2500 ${ts.error}`));
-        }
-      }
-    } else {
-      const visibleRunning = running.slice(0, 8);
-      const visible = [
-        ...completed.slice(-3),
-        ...visibleRunning,
-        ...pending.slice(0, 3)
-      ];
-      if (completed.length > 3) {
-        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${completed.length - 3} earlier task(s) completed`));
-      }
-      for (const ts of visible) {
-        const icon = statusIcon(ts.status);
-        const idx = chalk6.dim(`#${state.tasks.indexOf(ts) + 1}`);
-        let text = ts.task.text;
-        if (text.length > maxTextLen) {
-          text = text.slice(0, maxTextLen - 1) + "\u2026";
-        }
-        const elapsedStr = ts.status === "running" || ts.status === "planning" ? chalk6.dim(` ${elapsed(now - (ts.elapsed || now))}`) : ts.status === "done" && ts.elapsed ? chalk6.dim(` ${elapsed(ts.elapsed)}`) : "";
-        const label = statusLabel(ts.status);
-        lines.push(`  ${icon} ${idx} ${text} ${label}${elapsedStr}`);
-        if (ts.error) {
-          lines.push(chalk6.red(`       \u2514\u2500 ${ts.error}`));
-        }
-      }
-      if (running.length > 8) {
-        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${running.length - 8} more running`));
-      }
-      if (pending.length > 3) {
-        lines.push(chalk6.dim(`  \xB7\xB7\xB7 ${pending.length - 3} more task(s) pending`));
-      }
-    }
-    lines.push("");
-    const parts = [];
-    if (done > 0) parts.push(chalk6.green(`${done} passed`));
-    if (failed > 0) parts.push(chalk6.red(`${failed} failed`));
-    if (total - done - failed > 0)
-      parts.push(chalk6.dim(`${total - done - failed} remaining`));
-    lines.push(`  ${parts.join(chalk6.dim(" \xB7 "))}`);
-  } else if (state.filesFound > 0) {
-    lines.push(chalk6.dim(`  Found ${state.filesFound} file(s)`));
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function draw(state) {
-  const output = render(state);
-  const cols = process.stdout.columns || 80;
-  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 = {
-    tasks: [],
-    phase: "discovering",
-    startTime: Date.now(),
-    filesFound: 0
-  };
-  interval = setInterval(() => {
-    spinnerIndex++;
-    draw(state);
-  }, 80);
-  const update = () => draw(state);
-  const stop = () => {
-    if (interval) {
-      clearInterval(interval);
-      interval = null;
-    }
-    draw(state);
-  };
-  draw(state);
-  return { state, update, stop };
-}
-
-// src/orchestrator/dispatch-pipeline.ts
 init_providers();
 init_timeout();
 import chalk7 from "chalk";
@@ -9591,12 +10141,10 @@ async function resolveGlobItems(patterns, cwd) {
   }
   return items;
 }
-var DEFAULT_PLAN_TIMEOUT_MIN = 10;
-var DEFAULT_PLAN_RETRIES = 1;
 async function runDispatchPipeline(opts, cwd) {
   const {
     issueIds,
-    concurrency,
+    concurrency = 1,
     dryRun,
     serverUrl,
     noPlan,
@@ -9613,36 +10161,22 @@ async function runDispatchPipeline(opts, cwd) {
     area,
     planTimeout,
     planRetries,
-    retries
+    retries,
+    username: usernameOverride
   } = opts;
   let noBranch = noBranchOpt;
-  const planTimeoutMs = (planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN) * 6e4;
-  const maxPlanAttempts = (planRetries ?? retries ?? DEFAULT_PLAN_RETRIES) + 1;
-  log.debug(`Plan timeout: ${planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN}m (${planTimeoutMs}ms), max attempts: ${maxPlanAttempts}`);
+  const resolvedRetries = retries ?? DEFAULT_RETRY_COUNT;
+  const resolvedPlanTimeoutMin = planTimeout ?? DEFAULT_PLAN_TIMEOUT_MIN;
+  const planTimeoutMs = resolvedPlanTimeoutMin * 6e4;
+  const resolvedPlanRetries = planRetries ?? resolvedRetries;
+  const maxPlanAttempts = resolvedPlanRetries + 1;
+  log.debug(`Plan timeout: ${resolvedPlanTimeoutMin}m (${planTimeoutMs}ms), max attempts: ${maxPlanAttempts}`);
   if (dryRun) {
-    return dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area);
-  }
-  if (source === "github") {
-    const remoteUrl = await getGitRemoteUrl(cwd);
-    if (remoteUrl && parseGitHubRemoteUrl(remoteUrl)) {
-      await getGithubOctokit();
-    } else if (!remoteUrl) {
-      log.warn("No git remote found \u2014 skipping GitHub pre-authentication");
-    } else {
-      log.warn("Remote URL is not a GitHub repository \u2014 skipping GitHub pre-authentication");
-    }
-  } else if (source === "azdevops") {
-    let orgUrl = org;
-    if (!orgUrl) {
-      const remoteUrl = await getGitRemoteUrl(cwd);
-      if (remoteUrl) {
-        const parsed = parseAzDevOpsRemoteUrl(remoteUrl);
-        if (parsed) orgUrl = parsed.orgUrl;
-      }
-    }
-    if (orgUrl) await getAzureConnection(orgUrl);
+    return dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area, usernameOverride);
   }
+  await ensureAuthReady(source, cwd, org);
   const verbose = log.verbose;
+  const canRecoverInteractively = !verbose && process.stdin.isTTY === true && process.stdout.isTTY === true;
   let tui;
   if (verbose) {
     const headerLines = renderHeaderLines({ provider, source });
@@ -9659,9 +10193,14 @@ async function runDispatchPipeline(opts, cwd) {
       provider,
       source
     };
-    tui = { state, update: () => {
-    }, stop: () => {
-    } };
+    tui = {
+      state,
+      update: () => {
+      },
+      stop: () => {
+      },
+      waitForRecoveryAction: async () => "quit"
+    };
   } else {
     tui = createTui();
     tui.state.provider = provider;
@@ -9702,7 +10241,6 @@ async function runDispatchPipeline(opts, cwd) {
     setAuthPromptHandler(null);
     if (items.length === 0) {
       tui.state.phase = "done";
-      setAuthPromptHandler(null);
       tui.stop();
       const label = issueIds.length > 0 ? `issue(s) ${issueIds.join(", ")}` : `datasource: ${source}`;
       log.warn("No work items found from " + label);
@@ -9727,7 +10265,6 @@ async function runDispatchPipeline(opts, cwd) {
     }
     if (allTasks.length === 0) {
       tui.state.phase = "done";
-      setAuthPromptHandler(null);
       tui.stop();
       log.warn("No unchecked tasks found");
       return { total: 0, completed: 0, failed: 0, skipped: 0, results: [] };
@@ -9767,9 +10304,8 @@ async function runDispatchPipeline(opts, cwd) {
     tui.state.phase = "dispatching";
     if (verbose) log.info(`Dispatching ${allTasks.length} task(s)...`);
     const results = [];
-    let completed = 0;
-    let failed = 0;
-    const lifecycleOpts = { cwd };
+    let halted = false;
+    const lifecycleOpts = { cwd, username: usernameOverride };
     const startingBranch = await datasource4.getCurrentBranch(lifecycleOpts);
     let featureBranchName;
     let featureDefaultBranch;
@@ -9829,6 +10365,15 @@ async function runDispatchPipeline(opts, cwd) {
         let branchName;
         let worktreePath;
         let issueCwd = cwd;
+        let preserveContext = false;
+        const upsertResult = (collection, result) => {
+          const index = collection.findIndex((entry) => entry.task === result.task);
+          if (index >= 0) {
+            collection[index] = result;
+          } else {
+            collection.push(result);
+          }
+        };
         if (!noBranch && details) {
           fileLogger?.phase("Branch/worktree setup");
           try {
@@ -9863,14 +10408,13 @@ ${err.stack}` : ""}`);
                 tuiTask.status = "failed";
                 tuiTask.error = errorMsg;
               }
-              results.push({ task, success: false, error: errorMsg });
+              upsertResult(results, { task, success: false, error: errorMsg });
             }
-            failed += fileTasks.length;
-            return;
+            return { halted: false };
           }
         }
         const worktreeRoot = useWorktrees ? worktreePath : void 0;
-        const issueLifecycleOpts = { cwd: issueCwd };
+        const issueLifecycleOpts = { cwd: issueCwd, username: usernameOverride };
         fileLogger?.phase("Provider/agent boot");
         let localInstance;
         let localPlanner;
@@ -9893,286 +10437,345 @@ ${err.stack}` : ""}`);
           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";
-                  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()"
-                      );
-                      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)`);
-                }
-                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);
-                    const updatedContent = await readFile8(task.file, "utf-8");
-                    if (parsed) {
-                      const issueDetails = issueDetailsByFile.get(task.file);
-                      const title = issueDetails?.title ?? parsed.slug;
-                      await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
-                      log.success(`Synced task completion to issue #${parsed.issueId}`);
-                    } else {
-                      const issueDetails = issueDetailsByFile.get(task.file);
-                      if (issueDetails) {
-                        await datasource4.update(issueDetails.number, issueDetails.title, updatedContent, fetchOpts);
-                        log.success(`Synced task completion to issue #${issueDetails.number}`);
-                      }
-                    }
-                  } catch (err) {
-                    log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
+        const pauseTask = (task, error) => {
+          const tuiTask = tui.state.tasks.find((entry) => entry.task === task);
+          tuiTask.status = "paused";
+          tuiTask.error = error;
+          tui.state.phase = "paused";
+          tui.state.recovery = {
+            taskIndex: tui.state.tasks.indexOf(tuiTask),
+            taskText: task.text,
+            error,
+            issue: details ? { number: details.number, title: details.title } : void 0,
+            worktree: tuiTask.worktree ?? worktreeRoot,
+            selectedAction: "rerun"
+          };
+          tui.update();
+          return tuiTask;
+        };
+        const clearRecovery = () => {
+          tui.state.recovery = void 0;
+          tui.state.phase = "dispatching";
+          tui.update();
+        };
+        const runTaskLifecycle = async (task) => {
+          const tuiTask = tui.state.tasks.find((entry) => entry.task === task);
+          const startTime = Date.now();
+          let plan;
+          tuiTask.elapsed = startTime;
+          tuiTask.error = void 0;
+          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()"
+                );
+                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})`);
                   }
-                  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 = 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++;
+                  planResult = {
+                    data: null,
+                    success: false,
+                    error: log.extractMessage(err),
+                    durationMs: 0
+                  };
+                  break;
                 }
-                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;
+              }
             }
+            if (!planResult) {
+              planResult = {
+                data: null,
+                success: false,
+                error: `Planning timed out after ${resolvedPlanTimeoutMin}m (${maxPlanAttempts} attempts)`,
+                durationMs: 0
+              };
+            }
+            if (!planResult.success) {
+              const error = `Planning failed: ${planResult.error}`;
+              fileLogger?.error(error);
+              tuiTask.elapsed = Date.now() - startTime;
+              pauseTask(task, error);
+              if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: paused \u2014 ${error} (${elapsed(tuiTask.elapsed)})`);
+              return { kind: "paused", error };
+            }
+            plan = planResult.data.prompt;
+            fileLogger?.info(`Planning completed (${planResult.durationMs ?? 0}ms)`);
           }
-        }
-        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,
+          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 execResult = await withRetry(
+            async () => {
+              const result = await localExecutor.execute({
+                task,
                 cwd: issueCwd,
+                plan: plan ?? null,
                 worktreeRoot
               });
-              if (result.success) {
-                commitAgentResult = result;
-                fileLogger?.info(`Commit message generated for issue #${details.number}`);
-                try {
-                  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 rewrite commit message for issue #${details.number}: ${log.formatErrorChain(err)}`);
-                }
-              } else {
-                log.warn(`Commit agent failed for issue #${details.number}: ${result.error}`);
-                fileLogger?.warn(`Commit agent failed: ${result.error}`);
+              if (!result.success) {
+                throw new Error(result.error ?? "Execution failed");
+              }
+              return result;
+            },
+            resolvedRetries,
+            { label: `executor "${task.text}"` }
+          ).catch((err) => ({
+            data: null,
+            success: false,
+            error: log.extractMessage(err),
+            durationMs: 0
+          }));
+          if (!execResult.success) {
+            const error = execResult.error ?? "Executor failed without returning a dispatch result.";
+            fileLogger?.error(`Execution failed: ${error}`);
+            tuiTask.elapsed = Date.now() - startTime;
+            pauseTask(task, error);
+            if (verbose) log.error(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: paused \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})${error ? `: ${error}` : ""}`);
+            return { kind: "paused", error };
+          }
+          fileLogger?.info(`Execution completed successfully (${Date.now() - startTime}ms)`);
+          try {
+            const parsed = parseIssueFilename(task.file);
+            const updatedContent = await readFile8(task.file, "utf-8");
+            if (parsed) {
+              const issueDetails = issueDetailsByFile.get(task.file);
+              const title = issueDetails?.title ?? parsed.slug;
+              await datasource4.update(parsed.issueId, title, updatedContent, fetchOpts);
+              log.success(`Synced task completion to issue #${parsed.issueId}`);
+            } else {
+              const issueDetails = issueDetailsByFile.get(task.file);
+              if (issueDetails) {
+                await datasource4.update(issueDetails.number, issueDetails.title, updatedContent, fetchOpts);
+                log.success(`Synced task completion to issue #${issueDetails.number}`);
               }
             }
           } catch (err) {
-            log.warn(`Commit agent error for issue #${details.number}: ${log.formatErrorChain(err)}`);
+            log.warn(`Could not sync task completion to datasource: ${log.formatErrorChain(err)}`);
           }
-        }
-        fileLogger?.phase("PR lifecycle");
-        if (!noBranch && branchName && defaultBranch && details) {
-          if (feature && featureBranchName) {
-            if (worktreePath) {
-              try {
-                await removeWorktree(cwd, file);
-              } catch (err) {
-                log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
-              }
+          tuiTask.status = "done";
+          tuiTask.error = void 0;
+          tuiTask.elapsed = Date.now() - startTime;
+          if (verbose) log.success(`Task #${tui.state.tasks.indexOf(tuiTask) + 1}: done \u2014 "${task.text}" (${elapsed(tuiTask.elapsed)})`);
+          return { kind: "success", result: execResult.data.dispatchResult };
+        };
+        const recoverPausedTask = async (task, error) => {
+          while (true) {
+            const tuiTask = pauseTask(task, error);
+            if (!canRecoverInteractively) {
+              log.warn("Manual rerun requires an interactive terminal; verbose or non-TTY runs will not wait for input, and the current branch/worktree will be left intact.");
+              tuiTask.status = "failed";
+              clearRecovery();
+              return { halted: true, result: { task, success: false, error } };
             }
-            try {
-              await datasource4.switchBranch(featureBranchName, lifecycleOpts);
-              await exec9("git", ["merge", branchName, "--no-ff", "-m", `merge: issue #${details.number}`], { cwd, shell: process.platform === "win32" });
-              log.debug(`Merged ${branchName} into ${featureBranchName}`);
-            } catch (err) {
-              const mergeError = `Could not merge ${branchName} into feature branch: ${log.formatErrorChain(err)}`;
-              log.warn(mergeError);
-              try {
-                await exec9("git", ["merge", "--abort"], { cwd, shell: process.platform === "win32" });
-              } catch {
-              }
-              for (const task of fileTasks) {
-                const tuiTask = tui.state.tasks.find((t) => t.task === task);
-                if (tuiTask) {
-                  tuiTask.status = "failed";
-                  tuiTask.error = mergeError;
-                }
-                const existingResult = results.find((r) => r.task === task);
-                if (existingResult) {
-                  existingResult.success = false;
-                  existingResult.error = mergeError;
-                }
-              }
-              return;
+            const action = await tui.waitForRecoveryAction();
+            if (action === "quit") {
+              tuiTask.status = "failed";
+              clearRecovery();
+              return { halted: true, result: { task, success: false, error } };
+            }
+            clearRecovery();
+            const rerun = await runTaskLifecycle(task);
+            if (rerun.kind === "success") {
+              return { halted: false, result: rerun.result };
+            }
+            error = rerun.error;
+          }
+        };
+        const groups = groupTasksByMode(fileTasks);
+        let stopAfterIssue = false;
+        for (const group of groups) {
+          const groupResults = await runWithConcurrency({
+            items: group,
+            concurrency,
+            worker: async (task) => runTaskLifecycle(task),
+            shouldStop: () => stopAfterIssue
+          });
+          const pausedTasks = [];
+          for (let i = 0; i < group.length; i++) {
+            const result = groupResults[i];
+            if (result.status === "skipped") continue;
+            if (result.status === "rejected") {
+              pausedTasks.push({ task: group[i], error: String(result.reason) });
+              continue;
             }
+            const outcome = result.value;
+            if (outcome.kind === "success") {
+              upsertResult(issueResults, outcome.result);
+              upsertResult(results, outcome.result);
+            } else {
+              pausedTasks.push({ task: group[i], error: outcome.error });
+            }
+          }
+          for (const pausedTask of pausedTasks) {
+            const resolution = await recoverPausedTask(pausedTask.task, pausedTask.error);
+            upsertResult(issueResults, resolution.result);
+            upsertResult(results, resolution.result);
+            if (resolution.halted) {
+              preserveContext = true;
+              stopAfterIssue = true;
+              halted = true;
+              break;
+            }
+          }
+          if (!tui.state.model && localInstance.model) {
+            tui.state.model = localInstance.model;
+          }
+          if (stopAfterIssue) break;
+        }
+        if (!preserveContext) {
+          if (!noBranch && branchName && defaultBranch && details && datasource4.supportsGit()) {
             try {
-              await exec9("git", ["branch", "-d", branchName], { cwd, shell: process.platform === "win32" });
-              log.debug(`Deleted local branch ${branchName}`);
+              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 delete local branch ${branchName}: ${log.formatErrorChain(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 {
-              await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
+              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 {
+                    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 rewrite commit message for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                  }
+                } else {
+                  log.warn(`Commit agent failed for issue #${details.number}: ${result.error}`);
+                  fileLogger?.warn(`Commit agent failed: ${result.error}`);
+                }
+              }
             } catch (err) {
-              log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
+              log.warn(`Commit agent error 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)}`);
+          }
+          fileLogger?.phase("PR lifecycle");
+          if (!noBranch && branchName && defaultBranch && details) {
+            if (feature && featureBranchName) {
+              if (worktreePath) {
+                try {
+                  await removeWorktree(cwd, file);
+                } catch (err) {
+                  log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                }
               }
-            }
-            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,
-                  startingBranch
-                );
-                if (prUrl) {
-                  log.success(`Created PR for issue #${details.number}: ${prUrl}`);
-                  fileLogger?.info(`Created PR: ${prUrl}`);
-                }
+                await datasource4.switchBranch(featureBranchName, lifecycleOpts);
+                await exec9("git", ["merge", branchName, "--no-ff", "-m", `merge: issue #${details.number}`], { cwd, shell: process.platform === "win32" });
+                log.debug(`Merged ${branchName} into ${featureBranchName}`);
               } catch (err) {
-                log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
-                fileLogger?.warn(`PR creation failed: ${log.extractMessage(err)}`);
+                const mergeError = `Could not merge ${branchName} into feature branch: ${log.formatErrorChain(err)}`;
+                log.warn(mergeError);
+                try {
+                  await exec9("git", ["merge", "--abort"], { cwd, shell: process.platform === "win32" });
+                } catch {
+                }
+                for (const task of fileTasks) {
+                  const tuiTask = tui.state.tasks.find((t) => t.task === task);
+                  if (tuiTask) {
+                    tuiTask.status = "failed";
+                    tuiTask.error = mergeError;
+                  }
+                  upsertResult(results, { task, success: false, error: mergeError });
+                }
+                return { halted: false };
               }
-            }
-            if (useWorktrees && worktreePath) {
               try {
-                await removeWorktree(cwd, file);
+                await exec9("git", ["branch", "-d", branchName], { cwd, shell: process.platform === "win32" });
+                log.debug(`Deleted local branch ${branchName}`);
               } catch (err) {
-                log.warn(`Could not remove worktree for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                log.warn(`Could not delete local branch ${branchName}: ${log.formatErrorChain(err)}`);
               }
-            } else if (!useWorktrees && datasource4.supportsGit()) {
               try {
-                await datasource4.switchBranch(defaultBranch, lifecycleOpts);
-                log.debug(`Switched back to ${defaultBranch}`);
+                await datasource4.switchBranch(featureDefaultBranch, lifecycleOpts);
               } catch (err) {
-                log.warn(`Could not switch back to ${defaultBranch}: ${log.formatErrorChain(err)}`);
+                log.warn(`Could not switch back to ${featureDefaultBranch}: ${log.formatErrorChain(err)}`);
+              }
+            } else {
+              if (datasource4.supportsGit()) {
+                try {
+                  await datasource4.pushBranch(branchName, issueLifecycleOpts);
+                  log.debug(`Pushed branch ${branchName}`);
+                  fileLogger?.info(`Pushed branch ${branchName}`);
+                } catch (err) {
+                  log.warn(`Could not push branch ${branchName}: ${log.formatErrorChain(err)}`);
+                }
+              }
+              if (datasource4.supportsGit()) {
+                try {
+                  const prTitle = commitAgentResult?.prTitle || await buildPrTitle(details.title, defaultBranch, issueLifecycleOpts.cwd);
+                  const prBody = commitAgentResult?.prDescription || await buildPrBody(
+                    details,
+                    fileTasks,
+                    issueResults,
+                    defaultBranch,
+                    datasource4.name,
+                    issueLifecycleOpts.cwd
+                  );
+                  const prUrl = await datasource4.createPullRequest(
+                    branchName,
+                    details.number,
+                    prTitle,
+                    prBody,
+                    issueLifecycleOpts,
+                    startingBranch
+                  );
+                  if (prUrl) {
+                    log.success(`Created PR for issue #${details.number}: ${prUrl}`);
+                    fileLogger?.info(`Created PR: ${prUrl}`);
+                  }
+                } catch (err) {
+                  log.warn(`Could not create PR for issue #${details.number}: ${log.formatErrorChain(err)}`);
+                  fileLogger?.warn(`PR creation failed: ${log.extractMessage(err)}`);
+                }
+              }
+              if (useWorktrees && worktreePath) {
+                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)}`);
+                }
               }
             }
           }
@@ -10183,31 +10786,42 @@ ${err.stack}` : ""}`);
           await localPlanner?.cleanup();
           await localInstance.cleanup();
         }
+        return { halted: stopAfterIssue };
       };
       if (fileLogger) {
-        await fileLoggerStorage.run(fileLogger, async () => {
+        return fileLoggerStorage.run(fileLogger, async () => {
           try {
-            await body();
+            return await body();
           } finally {
             fileLogger.close();
           }
         });
-      } else {
-        await body();
       }
+      return body();
     };
     if (useWorktrees && !feature) {
-      await Promise.all(
-        Array.from(tasksByFile).map(
-          ([file, fileTasks]) => processIssueFile(file, fileTasks)
-        )
-      );
+      const issueEntries = Array.from(tasksByFile.entries());
+      const concurrencyResults = await runWithConcurrency({
+        items: issueEntries,
+        concurrency,
+        worker: async ([file, fileTasks]) => processIssueFile(file, fileTasks),
+        shouldStop: () => halted
+      });
+      for (const result of concurrencyResults) {
+        if (result.status === "fulfilled" && result.value?.halted) {
+          halted = true;
+        }
+      }
     } else {
       for (const [file, fileTasks] of tasksByFile) {
-        await processIssueFile(file, fileTasks);
+        const issueResult = await processIssueFile(file, fileTasks);
+        if (issueResult?.halted) {
+          halted = true;
+          break;
+        }
       }
     }
-    if (feature && featureBranchName && featureDefaultBranch) {
+    if (!halted && feature && featureBranchName && featureDefaultBranch) {
       try {
         await datasource4.switchBranch(featureBranchName, lifecycleOpts);
         log.debug(`Switched to feature branch ${featureBranchName}`);
@@ -10249,7 +10863,10 @@ ${err.stack}` : ""}`);
     await executor?.cleanup();
     await planner?.cleanup();
     await instance?.cleanup();
+    const completed = results.filter((result) => result.success).length;
+    const failed = results.filter((result) => !result.success).length;
     tui.state.phase = "done";
+    setAuthPromptHandler(null);
     tui.stop();
     if (verbose) log.success(`Done \u2014 ${completed} completed, ${failed} failed (${elapsed(Date.now() - tui.state.startTime)})`);
     return { total: allTasks.length, completed, failed, skipped: 0, results };
@@ -10259,17 +10876,17 @@ ${err.stack}` : ""}`);
     throw err;
   }
 }
-async function dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area) {
+async function dryRunMode(issueIds, cwd, source, org, project, workItemType, iteration, area, username) {
   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, iteration, area };
-  const lifecycleOpts = { cwd };
-  let username = "";
+  const lifecycleOpts = { cwd, username };
+  let resolvedUsername = "";
   try {
-    username = await datasource4.getUsername(lifecycleOpts);
+    resolvedUsername = await datasource4.getUsername(lifecycleOpts);
   } catch {
   }
   let items;
@@ -10303,7 +10920,7 @@ async function dryRunMode(issueIds, cwd, source, org, project, workItemType, ite
   for (const task of allTasks) {
     const parsed = parseIssueFilename(task.file);
     const details = parsed ? items.find((item) => item.number === parsed.issueId) : issueDetailsByFile.get(task.file);
-    const branchInfo = details ? ` [branch: ${datasource4.buildBranchName(details.number, details.title, username)}]` : "";
+    const branchInfo = details ? ` [branch: ${datasource4.buildBranchName(details.number, details.title, resolvedUsername)}]` : "";
     log.task(allTasks.indexOf(task), allTasks.length, `${task.file}:${task.line} \u2014 ${task.text}${branchInfo}`);
   }
   return {
@@ -10327,7 +10944,7 @@ async function runMultiIssueFixTests(opts) {
   }
   let username = "";
   try {
-    username = await datasource4.getUsername({ cwd: opts.cwd });
+    username = await datasource4.getUsername({ cwd: opts.cwd, username: opts.username });
   } catch (err) {
     log.warn(`Could not resolve git username for branch naming: ${log.formatErrorChain(err)}`);
   }
@@ -10446,7 +11063,8 @@ async function boot9(opts) {
           verbose: m.verbose,
           testTimeout: m.testTimeout,
           org: m.org,
-          project: m.project
+          project: m.project,
+          username: m.username
         });
       }
       if (m.spec) {
@@ -10464,7 +11082,11 @@ async function boot9(opts) {
           iteration: m.iteration,
           area: m.area,
           concurrency: m.concurrency,
-          dryRun: m.dryRun
+          dryRun: m.dryRun,
+          retries: m.retries,
+          specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
+          specWarnTimeout: m.specWarnTimeout,
+          specKillTimeout: m.specKillTimeout
         });
       }
       if (m.respec) {
@@ -10506,7 +11128,11 @@ async function boot9(opts) {
           iteration: m.iteration,
           area: m.area,
           concurrency: m.concurrency,
-          dryRun: m.dryRun
+          dryRun: m.dryRun,
+          retries: m.retries,
+          specTimeout: m.specTimeout ?? DEFAULT_SPEC_TIMEOUT_MIN,
+          specWarnTimeout: m.specWarnTimeout,
+          specKillTimeout: m.specKillTimeout
         });
       }
       return this.orchestrate({
@@ -10529,7 +11155,8 @@ async function boot9(opts) {
         planRetries: m.planRetries,
         retries: m.retries,
         force: m.force,
-        feature: m.feature
+        feature: m.feature,
+        username: m.username
       });
     }
   };
@@ -10565,8 +11192,8 @@ var HELP = `
     --provider <name>      Agent backend: ${PROVIDER_NAMES.join(", ")} (default: opencode)
     --source <name>        Issue source: ${DATASOURCE_NAMES.join(", ")} (optional; auto-detected from git remote)
     --server-url <url>     URL of a running provider server
-    --plan-timeout <min>   Planning timeout in minutes (default: 10)
-    --retries <n>          Retry attempts for all agents (default: 2)
+    --plan-timeout <min>   Planning timeout in minutes (default: 30)
+    --retries <n>          Retry attempts for all agents (default: 3)
     --plan-retries <n>     Retry attempts after planning timeout (overrides --retries for planner)
     --test-timeout <min>   Test timeout in minutes (default: 5)
     --cwd <dir>            Working directory (default: cwd)
@@ -10574,6 +11201,9 @@ var HELP = `
   Spec options:
     --spec <value>         Comma-separated issue numbers, glob pattern for .md files, or inline text description
     --respec [value]       Regenerate specs: issue numbers, glob, or omit to regenerate all existing specs
+    --spec-timeout <min>   Spec generation timeout in minutes (default: 10)
+    --spec-warn-timeout <min>  Spec warn-phase timeout in minutes (default: 10)
+    --spec-kill-timeout <min>  Spec kill-phase timeout in minutes (default: 10)
     --output-dir <dir>     Output directory for specs (default: .dispatch/specs)
 
   Azure DevOps options:
@@ -10585,6 +11215,9 @@ var HELP = `
     -h, --help             Show this help
     -v, --version          Show version
 
+  Interactive dispatch runs pause exhausted failed tasks so you can rerun them
+  in place; verbose or non-TTY runs do not wait for input.
+
   Config:
     dispatch config                     Launch interactive configuration wizard
 
@@ -10632,6 +11265,9 @@ var CLI_OPTIONS_MAP = {
   concurrency: "concurrency",
   serverUrl: "serverUrl",
   planTimeout: "planTimeout",
+  specTimeout: "specTimeout",
+  specWarnTimeout: "specWarnTimeout",
+  specKillTimeout: "specKillTimeout",
   retries: "retries",
   planRetries: "planRetries",
   testTimeout: "testTimeout",
@@ -10671,6 +11307,45 @@ function parseArgs(argv) {
       if (n > CONFIG_BOUNDS.planTimeout.max) throw new CommanderError(1, "commander.invalidArgument", `--plan-timeout must not exceed ${CONFIG_BOUNDS.planTimeout.max}`);
       return n;
     }
+  ).option(
+    "--spec-timeout <min>",
+    "Spec generation timeout in minutes",
+    (val) => {
+      const n = parseFloat(val);
+      if (isNaN(n) || n < CONFIG_BOUNDS.specTimeout.min) {
+        throw new CommanderError(1, "commander.invalidArgument", "--spec-timeout must be a positive number (minutes)");
+      }
+      if (n > CONFIG_BOUNDS.specTimeout.max) {
+        throw new CommanderError(1, "commander.invalidArgument", `--spec-timeout must not exceed ${CONFIG_BOUNDS.specTimeout.max}`);
+      }
+      return n;
+    }
+  ).option(
+    "--spec-warn-timeout <min>",
+    "Spec warn-phase timeout in minutes",
+    (val) => {
+      const n = parseFloat(val);
+      if (isNaN(n) || n < CONFIG_BOUNDS.specWarnTimeout.min) {
+        throw new CommanderError(1, "commander.invalidArgument", "--spec-warn-timeout must be a positive number (minutes)");
+      }
+      if (n > CONFIG_BOUNDS.specWarnTimeout.max) {
+        throw new CommanderError(1, "commander.invalidArgument", `--spec-warn-timeout must not exceed ${CONFIG_BOUNDS.specWarnTimeout.max}`);
+      }
+      return n;
+    }
+  ).option(
+    "--spec-kill-timeout <min>",
+    "Spec kill-phase timeout in minutes",
+    (val) => {
+      const n = parseFloat(val);
+      if (isNaN(n) || n < CONFIG_BOUNDS.specKillTimeout.min) {
+        throw new CommanderError(1, "commander.invalidArgument", "--spec-kill-timeout must be a positive number (minutes)");
+      }
+      if (n > CONFIG_BOUNDS.specKillTimeout.max) {
+        throw new CommanderError(1, "commander.invalidArgument", `--spec-kill-timeout must not exceed ${CONFIG_BOUNDS.specKillTimeout.max}`);
+      }
+      return n;
+    }
   ).option(
     "--retries <n>",
     "Retry attempts",
@@ -10735,6 +11410,9 @@ function parseArgs(argv) {
   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.specTimeout !== void 0) args.specTimeout = opts.specTimeout;
+  if (opts.specWarnTimeout !== void 0) args.specWarnTimeout = opts.specWarnTimeout;
+  if (opts.specKillTimeout !== void 0) args.specKillTimeout = opts.specKillTimeout;
   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;
@@ -10785,7 +11463,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.4.3"}`);
+    console.log(`dispatch v${"1.4.4"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });