@inteeka/task-cli 0.2.4 → 0.2.6

package/dist/cli.js

@@ -191,6 +191,9 @@ var CLI_AUDIT_ACTIONS = Object.freeze([
   "cli.run.tests_failed",
   "cli.run.pr_opened",
   "cli.run.pr_failed",
+  "cli.run.push_failed",
+  "cli.run.resumed",
+  "cli.work.pr_recovered",
   "cli.schedule.created",
   "cli.schedule.paused",
   "cli.schedule.resumed",
@@ -224,6 +227,13 @@ var c = {
 var CliError = class extends Error {
   code;
   hint;
+  /**
+   * Discriminator for the multi-work loop's between-iteration cleanup.
+   * `post_push` means the per-ticket branch is on origin (with a commit)
+   * and should be preserved for `task resume`. Pre-push failures (or
+   * unset / 'pre_push') let the loop purge the branch as usual.
+   */
+  phase;
   constructor(code, message, hint) {
     super(message);
     this.code = code;
@@ -988,9 +998,243 @@ function printTable(headers, rows) {
 }
 
 // src/commands/status.ts
+import { execFileSync as execFileSync3 } from "child_process";
+
+// src/git/branch.ts
+import { execFileSync as execFileSync2 } from "child_process";
+
+// src/git/commit.ts
 import { execFileSync } from "child_process";
+function commitOnly(args) {
+  execFileSync("git", ["add", "-A"], { cwd: args.cwd });
+  const statusRaw = execFileSync("git", ["status", "--porcelain"], {
+    cwd: args.cwd,
+    encoding: "utf8"
+  });
+  if (!statusRaw.trim()) {
+    throw new Error("No changes to commit (empty diff)");
+  }
+  execFileSync("git", ["commit", "-m", args.message], { cwd: args.cwd });
+  const sha = execFileSync("git", ["rev-parse", "HEAD"], {
+    cwd: args.cwd,
+    encoding: "utf8"
+  }).trim();
+  return { sha };
+}
+function currentBranch(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf8"
+    }).trim();
+  } catch {
+    return "HEAD";
+  }
+}
+
+// src/git/branch.ts
+var VALID_BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
+var TICKET_BRANCH = /^task\/[a-z0-9-]{1,80}$/;
+function assertValidBranchName(branch) {
+  if (!VALID_BRANCH.test(branch) || branch.includes("..") || branch.startsWith("/") || branch.endsWith("/")) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `Invalid branch name: ${branch}`,
+      'Branch names must contain only [A-Za-z0-9._/-], no "..", and no leading/trailing slash.'
+    );
+  }
+}
+function isWorkingTreeClean(cwd) {
+  const out = execFileSync2("git", ["status", "--porcelain"], {
+    cwd,
+    encoding: "utf8"
+  });
+  return out.trim().length === 0;
+}
+function assertBaseBranch(cwd, expected) {
+  assertValidBranchName(expected);
+  const current = currentBranch(cwd);
+  if (current !== expected) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `task work requires branch "${expected}" but you're on "${current}"`,
+      `Run "git checkout ${expected}" first. The base branch is configured per project; ask an admin if it should be different.`
+    );
+  }
+  if (!isWorkingTreeClean(cwd)) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      "Working tree is dirty",
+      "Commit, stash, or discard your local changes before running task work."
+    );
+  }
+}
+function createTicketBranch(cwd, branchName, baseBranch) {
+  assertValidBranchName(branchName);
+  assertValidBranchName(baseBranch);
+  if (!TICKET_BRANCH.test(branchName)) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `Per-ticket branch must match ^task/[a-z0-9-]{1,80}$ \u2014 got "${branchName}"`
+    );
+  }
+  try {
+    execFileSync2("git", ["checkout", "-b", branchName, baseBranch], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const stderr = err.stderr?.toString("utf8") ?? "";
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Could not create branch ${branchName}: ${stderr.slice(0, 400) || err.message}`
+    );
+  }
+}
+function deleteLocalBranch(cwd, branchName) {
+  if (!VALID_BRANCH.test(branchName)) return;
+  try {
+    execFileSync2("git", ["branch", "-D", branchName], {
+      cwd,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+  } catch {
+  }
+}
+function checkoutBranch(cwd, branchName) {
+  assertValidBranchName(branchName);
+  try {
+    execFileSync2("git", ["checkout", branchName], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const stderr = err.stderr?.toString("utf8") ?? "";
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Could not check out branch ${branchName}: ${stderr.slice(0, 400) || err.message}`
+    );
+  }
+}
+function pushBranch(cwd, branchName) {
+  assertValidBranchName(branchName);
+  try {
+    execFileSync2("git", ["push", "-u", "origin", branchName], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { remote: "origin" };
+  } catch (err) {
+    const stderr = err.stderr?.toString("utf8") ?? "";
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Push failed: ${stderr.slice(0, 600) || err.message}`
+    );
+  }
+}
+function enforceBaseBranchClean(cwd, baseBranch, opts = {}) {
+  assertValidBranchName(baseBranch);
+  try {
+    execFileSync2("git", ["restore", "--staged", "--worktree", "."], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+    try {
+      execFileSync2("git", ["reset", "--hard", "HEAD"], {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+    }
+  }
+  try {
+    execFileSync2("git", ["clean", "-fd"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  checkoutBranch(cwd, baseBranch);
+  const current = currentBranch(cwd);
+  if (current !== baseBranch) {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Branch enforcement failed: expected "${baseBranch}", on "${current}"`,
+      `Run "git checkout ${baseBranch}" manually, then re-run task multi-work.`
+    );
+  }
+  if (!isWorkingTreeClean(cwd)) {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      "Branch enforcement failed: working tree is dirty after returning to base",
+      'Inspect with "git status" and clean up before re-running task multi-work.'
+    );
+  }
+  if (opts.deleteBranch && opts.deleteBranch !== baseBranch) {
+    deleteLocalBranch(cwd, opts.deleteBranch);
+  }
+}
+function remoteBranchExists(cwd, branchName, opts = {}) {
+  assertValidBranchName(branchName);
+  const remote = opts.remote ?? "origin";
+  if (!/^[A-Za-z0-9._-]{1,100}$/.test(remote)) {
+    throw new CliError(CLI_EXIT_CODES.MISCONFIGURATION, `Invalid remote name: ${remote}`);
+  }
+  let stdout;
+  try {
+    stdout = execFileSync2("git", ["ls-remote", "--heads", remote, branchName], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const stderr = err.stderr?.toString("utf8") ?? "";
+    throw new CliError(
+      CLI_EXIT_CODES.NETWORK_UNREACHABLE,
+      `Could not reach remote "${remote}": ${stderr.slice(0, 400) || err.message}`,
+      "Check that the remote exists (`git remote -v`) and that you have credentials to talk to it."
+    );
+  }
+  return stdout.trim().length > 0;
+}
+function listLocalTicketBranches(cwd) {
+  let stdout;
+  try {
+    stdout = execFileSync2(
+      "git",
+      ["for-each-ref", "--format=%(refname:short)	%(upstream:short)", "refs/heads/task/"],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
+    );
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const [name, upstream = ""] = line.split("	");
+    if (!name || !TICKET_BRANCH.test(name)) continue;
+    const seqMatch = name.match(/^task\/(\d+)/);
+    out.push({
+      name,
+      sequenceNumber: seqMatch && seqMatch[1] ? parseInt(seqMatch[1], 10) : null,
+      hasUpstream: upstream.trim().length > 0
+    });
+  }
+  return out;
+}
+function branchSlug(sequenceNumber, title) {
+  const safeTitle = title.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  const slugBudget = 70;
+  const truncatedSlug = safeTitle.slice(0, slugBudget);
+  const tail = truncatedSlug.length > 0 ? `-${truncatedSlug}` : "";
+  return `task/${sequenceNumber}${tail}`.replace(/-+$/, "");
+}
+
+// src/commands/status.ts
 function registerStatus(program2) {
-  program2.command("status").description("Show CLI auth, link, and git state").option("--remote", "Also fetch /cli/access for live state").action(async (_opts) => {
+  program2.command("status").alias("s").description("Show CLI auth, link, git state, in-flight tickets, and orphan branches").option("--remote", "Also fetch /cli/access for live state").action(async (_opts) => {
     const creds = await readCredentials();
     const root = findRepoRoot();
     const project = await readProjectConfig(root);
@@ -1026,12 +1270,13 @@ ${c.bold("Project link")}
     process.stdout.write(`
 ${c.bold("Repo")}
 `);
+    let inGitRepo = false;
     try {
-      const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      const branch = execFileSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
         cwd: root,
         encoding: "utf8"
       }).trim();
-      const dirty = execFileSync("git", ["status", "--porcelain"], {
+      const dirty = execFileSync3("git", ["status", "--porcelain"], {
         cwd: root,
         encoding: "utf8"
       });
@@ -1041,10 +1286,58 @@ ${c.bold("Repo")}
         `  ${dirty.trim().length > 0 ? c.warn("working tree dirty") : c.ok("clean")}
 `
       );
+      inGitRepo = true;
     } catch {
       process.stdout.write(`  ${c.warn("!")} not inside a git repo
 `);
     }
+    if (creds && project && inGitRepo) {
+      const inFlight = await apiCall("GET", "/api/v1/cli/me/tickets", {
+        query: {
+          project_id: project.project_id,
+          ai_fix_status: "building",
+          limit: 100
+        }
+      });
+      const inFlightTickets = inFlight.ok && inFlight.data ? inFlight.data : [];
+      const localBranches = listLocalTicketBranches(root);
+      const inFlightBranchNames = new Set(
+        inFlightTickets.map((t) => branchSlug(t.sequence_number, t.title))
+      );
+      process.stdout.write(`
+${c.bold("In-flight tickets")}
+`);
+      if (inFlightTickets.length === 0) {
+        process.stdout.write(c.dim("  none\n"));
+      } else {
+        for (const t of inFlightTickets) {
+          const expectedBranch = branchSlug(t.sequence_number, t.title);
+          const branchPresent = localBranches.some((b) => b.name === expectedBranch);
+          const tag = branchPresent ? c.ok("local branch present") : c.warn("local branch missing");
+          process.stdout.write(
+            `  ${c.dim("\xB7")} #${t.sequence_number} "${t.title}" \u2014 ${tag} \u2192 ${c.cyan(`task resume #${t.sequence_number}`)}
+`
+          );
+        }
+      }
+      const orphans = localBranches.filter((b) => !inFlightBranchNames.has(b.name));
+      process.stdout.write(`
+${c.bold("Orphan task/* branches")}
+`);
+      if (orphans.length === 0) {
+        process.stdout.write(c.dim("  none\n"));
+      } else {
+        for (const b of orphans) {
+          const upstream = b.hasUpstream ? c.dim(" (has upstream)") : c.dim(" (no upstream)");
+          process.stdout.write(`  ${c.dim("\xB7")} ${b.name}${upstream}
+`);
+        }
+        process.stdout.write(
+          `  ${c.dim("\u2192 run")} ${c.cyan("task reset")} ${c.dim("to clean up")}
+`
+        );
+      }
+    }
   });
 }
 
@@ -1277,7 +1570,7 @@ async function runAgent(args) {
 }
 
 // src/guardrail/diff-check.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 
 // src/guardrail/protected-paths.ts
 import picomatch from "picomatch";
@@ -1336,7 +1629,7 @@ function checkDiff(args) {
 }
 function safeGitOutput(args, cwd) {
   try {
-    return execFileSync2("git", args, { cwd, encoding: "utf8" });
+    return execFileSync4("git", args, { cwd, encoding: "utf8" });
   } catch {
     return "";
   }
@@ -1345,186 +1638,8 @@ function splitLines(text) {
   return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
 }
 
-// src/git/commit.ts
-import { execFileSync as execFileSync3 } from "child_process";
-function commitOnly(args) {
-  execFileSync3("git", ["add", "-A"], { cwd: args.cwd });
-  const statusRaw = execFileSync3("git", ["status", "--porcelain"], {
-    cwd: args.cwd,
-    encoding: "utf8"
-  });
-  if (!statusRaw.trim()) {
-    throw new Error("No changes to commit (empty diff)");
-  }
-  execFileSync3("git", ["commit", "-m", args.message], { cwd: args.cwd });
-  const sha = execFileSync3("git", ["rev-parse", "HEAD"], {
-    cwd: args.cwd,
-    encoding: "utf8"
-  }).trim();
-  return { sha };
-}
-function currentBranch(cwd) {
-  try {
-    return execFileSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      encoding: "utf8"
-    }).trim();
-  } catch {
-    return "HEAD";
-  }
-}
-
-// src/git/branch.ts
-import { execFileSync as execFileSync4 } from "child_process";
-var VALID_BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
-var TICKET_BRANCH = /^task\/[a-z0-9-]{1,80}$/;
-function assertValidBranchName(branch) {
-  if (!VALID_BRANCH.test(branch) || branch.includes("..") || branch.startsWith("/") || branch.endsWith("/")) {
-    throw new CliError(
-      CLI_EXIT_CODES.MISCONFIGURATION,
-      `Invalid branch name: ${branch}`,
-      'Branch names must contain only [A-Za-z0-9._/-], no "..", and no leading/trailing slash.'
-    );
-  }
-}
-function isWorkingTreeClean(cwd) {
-  const out = execFileSync4("git", ["status", "--porcelain"], {
-    cwd,
-    encoding: "utf8"
-  });
-  return out.trim().length === 0;
-}
-function assertBaseBranch(cwd, expected) {
-  assertValidBranchName(expected);
-  const current = currentBranch(cwd);
-  if (current !== expected) {
-    throw new CliError(
-      CLI_EXIT_CODES.MISCONFIGURATION,
-      `task work requires branch "${expected}" but you're on "${current}"`,
-      `Run "git checkout ${expected}" first. The base branch is configured per project; ask an admin if it should be different.`
-    );
-  }
-  if (!isWorkingTreeClean(cwd)) {
-    throw new CliError(
-      CLI_EXIT_CODES.MISCONFIGURATION,
-      "Working tree is dirty",
-      "Commit, stash, or discard your local changes before running task work."
-    );
-  }
-}
-function createTicketBranch(cwd, branchName, baseBranch) {
-  assertValidBranchName(branchName);
-  assertValidBranchName(baseBranch);
-  if (!TICKET_BRANCH.test(branchName)) {
-    throw new CliError(
-      CLI_EXIT_CODES.MISCONFIGURATION,
-      `Per-ticket branch must match ^task/[a-z0-9-]{1,80}$ \u2014 got "${branchName}"`
-    );
-  }
-  try {
-    execFileSync4("git", ["checkout", "-b", branchName, baseBranch], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (err) {
-    const stderr = err.stderr?.toString("utf8") ?? "";
-    throw new CliError(
-      CLI_EXIT_CODES.GENERIC_ERROR,
-      `Could not create branch ${branchName}: ${stderr.slice(0, 400) || err.message}`
-    );
-  }
-}
-function deleteLocalBranch(cwd, branchName) {
-  if (!VALID_BRANCH.test(branchName)) return;
-  try {
-    execFileSync4("git", ["branch", "-D", branchName], {
-      cwd,
-      stdio: ["ignore", "ignore", "ignore"]
-    });
-  } catch {
-  }
-}
-function checkoutBranch(cwd, branchName) {
-  assertValidBranchName(branchName);
-  try {
-    execFileSync4("git", ["checkout", branchName], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (err) {
-    const stderr = err.stderr?.toString("utf8") ?? "";
-    throw new CliError(
-      CLI_EXIT_CODES.GENERIC_ERROR,
-      `Could not check out branch ${branchName}: ${stderr.slice(0, 400) || err.message}`
-    );
-  }
-}
-function pushBranch(cwd, branchName) {
-  assertValidBranchName(branchName);
-  try {
-    execFileSync4("git", ["push", "-u", "origin", branchName], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return { remote: "origin" };
-  } catch (err) {
-    const stderr = err.stderr?.toString("utf8") ?? "";
-    throw new CliError(
-      CLI_EXIT_CODES.GENERIC_ERROR,
-      `Push failed: ${stderr.slice(0, 600) || err.message}`
-    );
-  }
-}
-function enforceBaseBranchClean(cwd, baseBranch, opts = {}) {
-  assertValidBranchName(baseBranch);
-  try {
-    execFileSync4("git", ["restore", "--staged", "--worktree", "."], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch {
-    try {
-      execFileSync4("git", ["reset", "--hard", "HEAD"], {
-        cwd,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch {
-    }
-  }
-  try {
-    execFileSync4("git", ["clean", "-fd"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch {
-  }
-  checkoutBranch(cwd, baseBranch);
-  const current = currentBranch(cwd);
-  if (current !== baseBranch) {
-    throw new CliError(
-      CLI_EXIT_CODES.GENERIC_ERROR,
-      `Branch enforcement failed: expected "${baseBranch}", on "${current}"`,
-      `Run "git checkout ${baseBranch}" manually, then re-run task multi-work.`
-    );
-  }
-  if (!isWorkingTreeClean(cwd)) {
-    throw new CliError(
-      CLI_EXIT_CODES.GENERIC_ERROR,
-      "Branch enforcement failed: working tree is dirty after returning to base",
-      'Inspect with "git status" and clean up before re-running task multi-work.'
-    );
-  }
-  if (opts.deleteBranch && opts.deleteBranch !== baseBranch) {
-    deleteLocalBranch(cwd, opts.deleteBranch);
-  }
-}
-function branchSlug(sequenceNumber, title) {
-  const safeTitle = title.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-  const slugBudget = 70;
-  const truncatedSlug = safeTitle.slice(0, slugBudget);
-  const tail = truncatedSlug.length > 0 ? `-${truncatedSlug}` : "";
-  return `task/${sequenceNumber}${tail}`.replace(/-+$/, "");
-}
+// src/commands/work.ts
+import { execFileSync as execFileSync6 } from "child_process";
 
 // src/git/restore.ts
 import { execFileSync as execFileSync5 } from "child_process";
@@ -1636,7 +1751,13 @@ async function buildWorkContext(opts) {
   };
 }
 function registerWork(program2) {
-  program2.command("work [ticketId]").description("Run the agent on a CLI-approved ticket \u2014 cuts a per-ticket branch and opens a PR").option("--auto", "Pick the next eligible ticket without prompting").option("--next", "Alias for --auto --max 1").option("--dry-run", "Run the agent + tests but do not commit, push, or open a PR").option("--no-push", "[deprecated in Phase 2 \u2014 task work always pushes via per-ticket branch]").option("--max <n>", "Process up to N tickets in this invocation", "1").option("--silent", "Suppress TTY output (used by scheduled tasks)").option("--schedule-id <id>", "Internal: schedule id when invoked from a scheduled task").action(async (ticketId, opts) => {
+  program2.command("work [ticketId]").description("Run the agent on a CLI-approved ticket \u2014 cuts a per-ticket branch and opens a PR").option("--auto", "Pick the next eligible ticket without prompting").option("--next", "Alias for --auto --max 1").option("--dry-run", "Run the agent + tests but do not commit, push, or open a PR").option("--no-push", "[deprecated in Phase 2 \u2014 task work always pushes via per-ticket branch]").option("--max <n>", "Process up to N tickets in this invocation", "1").option("--silent", "Suppress TTY output (used by scheduled tasks)").option(
+    "--reset",
+    "DESTRUCTIVE: discard all local working-tree changes before running. Requires interactive y/n; pair with --confirm in non-TTY contexts."
+  ).option(
+    "--confirm",
+    "Confirm --reset in non-TTY (silent / scheduled-task) contexts. Has no effect without --reset."
+  ).option("--schedule-id <id>", "Internal: schedule id when invoked from a scheduled task").action(async (ticketId, opts) => {
     await runWork(ticketId, opts);
   });
 }
@@ -1668,6 +1789,9 @@ async function runWork(ticketId, opts) {
 }
 async function processOneTicket(ctx, opts, ticketIdHint) {
   const { cwd, baseBranch, silent } = ctx;
+  if (opts.reset) {
+    await purgeWorkingTreeWithConsent(ctx, opts);
+  }
   try {
     assertBaseBranch(cwd, baseBranch);
   } catch (err) {
@@ -1695,15 +1819,36 @@ async function processOneTicket(ctx, opts, ticketIdHint) {
   }
   const branchName = branchSlug(detail.sequence_number, detail.title);
   const testCommand = detail.project_cli_test_command ?? null;
+  const ticketBaseBranch = detail.project_cli_base_branch || baseBranch;
   if (!silent) {
     process.stdout.write(`
 ${c.bold(`#${detail.sequence_number}: ${detail.title}`)}
 `);
-    process.stdout.write(c.dim(`  base branch: ${baseBranch}
+    process.stdout.write(c.dim(`  base branch: ${ticketBaseBranch}
 `));
     process.stdout.write(c.dim(`  ticket branch: ${branchName}
 `));
   }
+  try {
+    if (!remoteBranchExists(cwd, ticketBaseBranch)) {
+      await apiCall("POST", "/api/v1/cli/me/runs", {
+        body: {
+          ticket_id: detail.id,
+          schedule_id: opts.scheduleId,
+          event: "branch_check_failed",
+          output_excerpt: `base branch "${ticketBaseBranch}" missing on origin`
+        }
+      });
+      throw new CliError(
+        CLI_EXIT_CODES.MISCONFIGURATION,
+        `Base branch "${ticketBaseBranch}" does not exist on origin`,
+        `Push it (\`git push origin ${ticketBaseBranch}\`) or update the project's cli_base_branch via the dashboard / PATCH /api/v1/projects/<id>.`
+      );
+    }
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    throw err;
+  }
   const runId = randomUUID();
   await apiCall("POST", "/api/v1/cli/me/runs", {
     body: {
@@ -1714,18 +1859,44 @@ ${c.bold(`#${detail.sequence_number}: ${detail.title}`)}
     }
   });
   try {
-    createTicketBranch(cwd, branchName, baseBranch);
+    createTicketBranch(cwd, branchName, ticketBaseBranch);
   } catch (err) {
-    await apiCall("POST", "/api/v1/cli/me/runs", {
-      body: {
-        ticket_id: detail.id,
-        schedule_id: opts.scheduleId,
-        event: "branch_check_failed",
-        claude_session_id: runId,
-        output_excerpt: err.message.slice(0, 4e3)
+    const stderr = err instanceof Error ? err.message : String(err);
+    const looksLikeAlreadyExists = /already exists/i.test(stderr);
+    if (looksLikeAlreadyExists) {
+      const recovered = await tryAutoCleanOrphanBranch(
+        ctx,
+        detail,
+        branchName,
+        ticketBaseBranch,
+        runId,
+        opts.scheduleId
+      );
+      if (recovered === "recreated") {
+      } else {
+        await apiCall("POST", "/api/v1/cli/me/runs", {
+          body: {
+            ticket_id: detail.id,
+            schedule_id: opts.scheduleId,
+            event: "branch_check_failed",
+            claude_session_id: runId,
+            output_excerpt: stderr.slice(0, 4e3)
+          }
+        });
+        throw err;
       }
-    });
-    throw err;
+    } else {
+      await apiCall("POST", "/api/v1/cli/me/runs", {
+        body: {
+          ticket_id: detail.id,
+          schedule_id: opts.scheduleId,
+          event: "branch_check_failed",
+          claude_session_id: runId,
+          output_excerpt: stderr.slice(0, 4e3)
+        }
+      });
+      throw err;
+    }
   }
   await apiCall("POST", "/api/v1/cli/me/runs", {
     body: {
@@ -1973,25 +2144,33 @@ Claude session: ${runId}
       body: {
         ticket_id: detail.id,
         schedule_id: opts.scheduleId,
-        event: "pr_failed",
+        event: "push_failed",
         claude_session_id: runId,
         output_excerpt: err.message.slice(0, 4e3)
       }
     });
+    if (err instanceof CliError) err.phase = "post_push";
     throw err;
   }
   if (!silent)
     process.stdout.write(`${c.ok("\u2713 Pushed")} ${branchName} (${commitSha.slice(0, 12)})
 `);
   const prTitle = `task #${detail.sequence_number}: ${detail.title}`.slice(0, 200);
-  const prBody = buildPrBody({ detail, runId, commitSha, branchName, baseBranch, testResult });
+  const prBody = buildPrBody({
+    detail,
+    runId,
+    commitSha,
+    branchName,
+    baseBranch: ticketBaseBranch,
+    testResult
+  });
   let prNumber;
   let prUrl;
   try {
     const prResp = await apiCallOrThrow("POST", `/api/v1/cli/me/tickets/${detail.id}/pull-requests`, {
       body: {
         source_branch: branchName,
-        base_branch: baseBranch,
+        base_branch: ticketBaseBranch,
         title: prTitle,
         body: prBody
       }
@@ -2009,7 +2188,7 @@ Claude session: ${runId}
     });
     if (!silent) {
       process.stdout.write(
-        `${c.ok("\u2713 PR opened")} ${c.cyan(prResp.pr_url)} \u2192 ${baseBranch}
+        `${c.ok("\u2713 PR opened")} ${c.cyan(prResp.pr_url)} \u2192 ${ticketBaseBranch}
 ` + (prResp.ticket_status_advanced ? c.dim(`  Ticket status auto-advanced to 'git_review'.
 `) : "")
       );
@@ -2024,6 +2203,7 @@ Claude session: ${runId}
         output_excerpt: err.message.slice(0, 4e3)
       }
     });
+    if (err instanceof CliError) err.phase = "post_push";
     throw err;
   }
   try {
@@ -2063,6 +2243,127 @@ function buildPrBody(args) {
     "Please review carefully \u2014 this is an AI-generated change."
   ].filter(Boolean).join("\n");
 }
+async function purgeWorkingTreeWithConsent(ctx, opts) {
+  const { cwd, baseBranch, silent } = ctx;
+  const isTty = !silent && process.stdin.isTTY === true;
+  const status = (() => {
+    try {
+      return execFileSync6("git", ["status", "--short"], { cwd, encoding: "utf8" }).trim();
+    } catch {
+      return "";
+    }
+  })();
+  const onBranch = (() => {
+    try {
+      return currentBranch(cwd);
+    } catch {
+      return "(unknown)";
+    }
+  })();
+  const willSwitchBranch = onBranch !== baseBranch && onBranch !== "(unknown)";
+  if (!isTty) {
+    if (!opts.confirm) {
+      throw new CliError(
+        CLI_EXIT_CODES.MISCONFIGURATION,
+        "--reset requires --confirm in non-interactive (silent / scheduled-task) contexts",
+        "Re-run with both flags only after confirming the destructive purge is intentional."
+      );
+    }
+    if (!silent) {
+      process.stdout.write(c.dim("  --reset --confirm: discarding working-tree changes\n"));
+      if (willSwitchBranch) {
+        process.stdout.write(
+          c.dim(`  --reset --confirm: also switching from "${onBranch}" to "${baseBranch}"
+`)
+        );
+      }
+    }
+  } else {
+    if (!silent) {
+      process.stdout.write(`${c.bold("Current branch:")} ${c.cyan(onBranch)}
+`);
+      process.stdout.write(`${c.bold("Working tree changes:")}
+`);
+      process.stdout.write(status.length > 0 ? `${c.dim(status)}
+` : c.dim("  (none)\n"));
+      process.stdout.write(`
+${c.bold("--reset will:")}
+`);
+      process.stdout.write(
+        c.dim("  \u2022 discard ALL working-tree changes above (git restore --staged --worktree .)\n")
+      );
+      process.stdout.write(c.dim("  \u2022 delete untracked files + directories (git clean -fd)\n"));
+      if (willSwitchBranch) {
+        process.stdout.write(
+          c.dim(`  \u2022 switch from ${c.cyan(onBranch)} ${c.dim("to")} ${c.cyan(baseBranch)}
+`)
+        );
+      } else {
+        process.stdout.write(
+          c.dim(`  \u2022 stay on ${c.cyan(baseBranch)} ${c.dim("(already on base)")}
+`)
+        );
+      }
+      process.stdout.write("\n");
+    }
+    const answer = await inquirer2.prompt([
+      { type: "confirm", name: "confirm", message: "Proceed?", default: false }
+    ]);
+    if (!answer.confirm) {
+      if (!silent) process.stdout.write(c.dim("Aborted \u2014 working tree untouched.\n"));
+      process.exit(CLI_EXIT_CODES.SUCCESS);
+    }
+  }
+  enforceBaseBranchClean(cwd, baseBranch);
+}
+async function tryAutoCleanOrphanBranch(ctx, detail, branchName, ticketBaseBranch, runId, scheduleId) {
+  const inFlight = await apiCall(
+    "GET",
+    "/api/v1/cli/me/tickets",
+    {
+      query: {
+        project_id: ctx.project.project_id,
+        ai_fix_status: "building",
+        limit: 100
+      }
+    }
+  );
+  const claimedByMe = inFlight.ok && inFlight.data ? inFlight.data.some((t) => t.sequence_number === detail.sequence_number) : false;
+  if (claimedByMe) {
+    if (!ctx.silent) {
+      process.stderr.write(
+        `${c.dim("  Local branch matches an in-flight ticket; refusing to auto-delete.")}
+${c.dim(`  Run \`task resume #${detail.sequence_number}\` to retry the PR for the existing branch.`)}
+`
+      );
+    }
+    return "in_flight";
+  }
+  try {
+    deleteLocalBranch(ctx.cwd, branchName);
+    createTicketBranch(ctx.cwd, branchName, ticketBaseBranch);
+  } catch {
+    return "failed";
+  }
+  await apiCall("POST", "/api/v1/cli/me/runs", {
+    body: {
+      ticket_id: detail.id,
+      schedule_id: scheduleId,
+      event: "branch_check_failed",
+      claude_session_id: runId,
+      output_excerpt: "auto-cleaned-orphan-and-recreated"
+    }
+  });
+  if (!ctx.silent) {
+    process.stdout.write(
+      c.dim(
+        `  Auto-cleaned orphan local branch '${branchName}' and re-cut from ${ticketBaseBranch}.
+`
+      )
+    );
+  }
+  return "recreated";
+}
 async function pickNextEligible(projectId) {
   const result = await apiCall("GET", "/api/v1/cli/me/tickets", {
     query: { project_id: projectId, limit: 1 }
@@ -2109,20 +2410,26 @@ function registerMultiWork(program2) {
   ).option("--max <n>", "Process up to N tickets in this batch", "10").option("--dry-run", "Run the agent + tests but do not commit, push, or open PRs").option("--silent", "Suppress TTY output (used by scheduled tasks)").option(
     "--abort-on-failure",
     "Stop the batch on the first per-ticket failure (default: skip and continue)"
-  ).option("--schedule-id <id>", "Internal: schedule id when invoked from a scheduled task").action(async (opts) => {
+  ).option(
+    "--reset",
+    "DESTRUCTIVE: discard local working-tree changes before the first ticket. Requires --confirm in non-TTY contexts."
+  ).option("--confirm", "Confirm --reset in non-TTY (silent / scheduled-task) contexts.").option("--schedule-id <id>", "Internal: schedule id when invoked from a scheduled task").action(async (opts) => {
     await runMultiWork(opts);
   });
 }
 async function runMultiWork(opts) {
   const ctx = await buildWorkContext({ max: opts.max, silent: opts.silent });
   const max = Math.max(1, parseInt(opts.max, 10) || 10);
+  let firstIteration = true;
   const innerOpts = {
     auto: true,
     next: false,
     dryRun: opts.dryRun,
     max: "1",
     silent: opts.silent,
-    scheduleId: opts.scheduleId
+    scheduleId: opts.scheduleId,
+    reset: opts.reset,
+    confirm: opts.confirm
   };
   const results = [];
   let processed = 0;
@@ -2137,11 +2444,28 @@ async function runMultiWork(opts) {
     let caughtError = null;
     try {
       outcome = await processOneTicket(ctx, innerOpts, null);
+      if (firstIteration) {
+        firstIteration = false;
+        innerOpts.reset = false;
+        innerOpts.confirm = false;
+      }
     } catch (err) {
+      if (firstIteration) {
+        firstIteration = false;
+        innerOpts.reset = false;
+        innerOpts.confirm = false;
+      }
       caughtError = err instanceof Error ? err.message : String(err);
+      const phaseTag = err instanceof CliError && err.phase === "post_push" ? "post_push" : "pre_push";
       if (!ctx.silent) {
         process.stderr.write(`${c.err("\u2717 Ticket failed")}: ${caughtError}
 `);
+        if (phaseTag === "post_push") {
+          process.stderr.write(
+            `${c.dim("  Branch kept on disk + remote \u2014 run `task resume` to retry the PR.")}
+`
+          );
+        }
       }
       if (opts.abortOnFailure) {
         try {
@@ -2224,6 +2548,356 @@ ${c.bold("Batch summary")}
   );
 }
 
+// src/commands/resume.ts
+import { execFileSync as execFileSync7 } from "child_process";
+import inquirer3 from "inquirer";
+function registerResume(program2) {
+  program2.command("resume [ticketRef]").description(
+    "Resume a ticket whose previous `task work` run failed after the per-ticket branch was pushed (i.e. ai_fix_status='building'). Re-pushes the branch and re-attempts the PR \u2014 idempotent end-to-end."
+  ).option("--silent", "Suppress TTY output").action(async (ticketRef, opts) => {
+    await runResume(ticketRef, opts);
+  });
+}
+async function runResume(ticketRef, opts) {
+  const cwd = findRepoRoot();
+  const project = await readProjectConfig(cwd);
+  if (!project) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      "No project link in this repo",
+      "Run 'task link' first."
+    );
+  }
+  const baseBranch = project.cli_base_branch ?? "development";
+  const silent = !!opts.silent;
+  assertBaseBranch(cwd, baseBranch);
+  const access2 = await apiCallOrThrow("GET", "/api/v1/cli/access");
+  const ticketId = await resolveTicketId(project, ticketRef, silent);
+  if (!ticketId) {
+    if (!silent) {
+      process.stdout.write(c.dim("No in-flight tickets to resume.\n"));
+    }
+    return;
+  }
+  const detail = await apiCallOrThrow(
+    "GET",
+    `/api/v1/cli/me/tickets/${ticketId}`
+  );
+  if (detail.project_id !== project.project_id) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `Ticket #${detail.sequence_number} belongs to a different project than this repo's link`,
+      "cd to the project repo this ticket belongs to (or re-link with `task link`) and retry."
+    );
+  }
+  if (detail.ai_fix_status !== "building") {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Ticket #${detail.sequence_number} is in ai_fix_status='${detail.ai_fix_status}', not 'building' \u2014 nothing to resume`,
+      "A previous resume attempt may already have succeeded. Check the dashboard for the ticket's PR."
+    );
+  }
+  if (detail.claimed_by_user_id && detail.claimed_by_user_id !== access2.user_id) {
+    throw new CliError(
+      CLI_EXIT_CODES.UNAUTHORISED,
+      `Ticket #${detail.sequence_number} is claimed by another user`,
+      'Ask that user to resume it, or have an admin reset ai_fix_status to "approved" so the ticket can be re-claimed fresh.'
+    );
+  }
+  const branchName = branchSlug(detail.sequence_number, detail.title);
+  const ticketBaseBranch = detail.project_cli_base_branch || baseBranch;
+  if (!localBranchExists(cwd, branchName)) {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Local branch '${branchName}' is missing \u2014 cannot resume`,
+      'The branch was deleted (or never existed locally). Ask an admin to set ai_fix_status back to "approved" so `task work` can produce a fresh fix.'
+    );
+  }
+  if (!isAncestor(cwd, ticketBaseBranch, branchName)) {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Base branch '${ticketBaseBranch}' is no longer an ancestor of '${branchName}' \u2014 cannot resume`,
+      'The base branch has moved (rebase/force-push). Have an admin reset ai_fix_status to "approved" and re-run `task work` for a fresh branch.'
+    );
+  }
+  if (!silent) {
+    process.stdout.write(`
+${c.bold(`Resuming #${detail.sequence_number}: ${detail.title}`)}
+`);
+    process.stdout.write(c.dim(`  branch: ${branchName} \u2192 ${ticketBaseBranch}
+`));
+  }
+  checkoutBranch(cwd, branchName);
+  try {
+    pushBranch(cwd, branchName);
+    if (!silent) process.stdout.write(c.dim("  \u2713 pushed (idempotent)\n"));
+  } catch (err) {
+    try {
+      checkoutBranch(cwd, baseBranch);
+    } catch {
+    }
+    await apiCall("POST", "/api/v1/cli/me/runs", {
+      body: {
+        ticket_id: detail.id,
+        event: "push_failed",
+        output_excerpt: err.message.slice(0, 4e3)
+      }
+    });
+    throw err;
+  }
+  const prTitle = `task #${detail.sequence_number}: ${detail.title}`.slice(0, 200);
+  const prBody = buildResumePrBody(detail, branchName, ticketBaseBranch);
+  let prResp;
+  try {
+    prResp = await apiCallOrThrow("POST", `/api/v1/cli/me/tickets/${detail.id}/pull-requests`, {
+      body: {
+        source_branch: branchName,
+        base_branch: ticketBaseBranch,
+        title: prTitle,
+        body: prBody
+      }
+    });
+  } catch (err) {
+    try {
+      checkoutBranch(cwd, baseBranch);
+    } catch {
+    }
+    await apiCall("POST", "/api/v1/cli/me/runs", {
+      body: {
+        ticket_id: detail.id,
+        event: "pr_failed",
+        output_excerpt: err.message.slice(0, 4e3)
+      }
+    });
+    throw err;
+  }
+  await apiCall("POST", "/api/v1/cli/me/runs", {
+    body: {
+      ticket_id: detail.id,
+      event: "resumed",
+      output_excerpt: `${prResp.recovered ? "recovered" : "opened"} PR #${prResp.pr_number}: ${prResp.pr_url}`
+    }
+  });
+  if (!silent) {
+    const tag = prResp.recovered ? c.ok("\u2713 Recovered PR") : c.ok("\u2713 PR opened");
+    process.stdout.write(`${tag} ${c.cyan(prResp.pr_url)}
+`);
+  }
+  try {
+    checkoutBranch(cwd, baseBranch);
+  } catch {
+  }
+}
+async function resolveTicketId(project, ticketRef, silent) {
+  if (ticketRef && ticketRef.length > 0) {
+    if (/^[0-9a-f-]{36}$/i.test(ticketRef)) return ticketRef;
+    const seqMatch = ticketRef.match(/^#?(\d+)$/);
+    if (seqMatch) {
+      const result2 = await apiCall("GET", "/api/v1/cli/me/tickets", {
+        query: { project_id: project.project_id, ai_fix_status: "building", limit: 100 }
+      });
+      if (!result2.ok || !result2.data) {
+        throw new CliError(
+          CLI_EXIT_CODES.GENERIC_ERROR,
+          `Could not list in-flight tickets (HTTP ${result2.status})${result2.error?.message ? `: ${result2.error.message}` : ""}`
+        );
+      }
+      const seq = parseInt(seqMatch[1] ?? "", 10);
+      const match = result2.data.find((t) => t.sequence_number === seq);
+      if (!match) {
+        throw new CliError(
+          CLI_EXIT_CODES.GENERIC_ERROR,
+          `No in-flight ticket #${seq} claimed by you on this project`,
+          "Run `task doctor` to list your in-flight tickets, or pass the UUID directly."
+        );
+      }
+      return match.id;
+    }
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `Invalid ticket reference: ${ticketRef}`,
+      "Pass either a UUID or a sequence number like #42."
+    );
+  }
+  const result = await apiCall("GET", "/api/v1/cli/me/tickets", {
+    query: { project_id: project.project_id, ai_fix_status: "building", limit: 100 }
+  });
+  if (!result.ok) {
+    throw new CliError(
+      CLI_EXIT_CODES.GENERIC_ERROR,
+      `Could not list in-flight tickets (HTTP ${result.status})${result.error?.message ? `: ${result.error.message}` : ""}`
+    );
+  }
+  if (!result.data || result.data.length === 0) return null;
+  if (result.data.length === 1) {
+    const only = result.data[0];
+    return only ? only.id : null;
+  }
+  if (silent) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      `${result.data.length} in-flight tickets \u2014 pass a specific reference in silent mode`,
+      "Run `task doctor` to see the list, then `task resume #N` for the one you want."
+    );
+  }
+  const answer = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "ticketId",
+      message: "Pick an in-flight ticket to resume:",
+      choices: result.data.map((t) => ({
+        name: `#${t.sequence_number} \u2014 ${t.title}`,
+        value: t.id
+      }))
+    }
+  ]);
+  return answer.ticketId;
+}
+function localBranchExists(cwd, branchName) {
+  try {
+    execFileSync7("git", ["rev-parse", "--verify", `refs/heads/${branchName}`], {
+      cwd,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAncestor(cwd, ancestor, descendant) {
+  try {
+    execFileSync7("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+      cwd,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildResumePrBody(detail, branchName, baseBranch) {
+  return [
+    `Resolves ticket #${detail.sequence_number}: ${detail.title}`,
+    "",
+    detail.description ? `> ${detail.description.slice(0, 1500)}` : "",
+    "",
+    "---",
+    "",
+    `**Generated by:** \`task resume\` (recovery of a previous \`task work\` run)`,
+    `**Branch:** \`${branchName}\` \u2190 \`${baseBranch}\``,
+    "",
+    "Please review carefully \u2014 this is an AI-generated change."
+  ].filter(Boolean).join("\n");
+}
+
+// src/commands/reset.ts
+import inquirer4 from "inquirer";
+function registerReset(program2) {
+  program2.command("reset").alias("r").description(
+    "Delete orphan local task/* branches \u2014 branches the CLI created locally but that are no longer in your in-flight (`ai_fix_status='building'`) list. Interactive y/n in TTY; pair with --confirm in non-TTY contexts."
+  ).option("--silent", "Suppress TTY output").option("--confirm", "Confirm deletion in non-TTY (silent / scheduled-task) contexts").action(async (opts) => {
+    await runReset(opts);
+  });
+}
+async function runReset(opts) {
+  const cwd = findRepoRoot();
+  const project = await readProjectConfig(cwd);
+  if (!project) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      "No project link in this repo",
+      "Run 'task link' first."
+    );
+  }
+  const silent = !!opts.silent;
+  const localBranches = listLocalTicketBranches(cwd);
+  if (localBranches.length === 0) {
+    if (!silent) process.stdout.write(c.dim("No local task/* branches \u2014 nothing to clean up.\n"));
+    return;
+  }
+  const inFlight = await apiCall("GET", "/api/v1/cli/me/tickets", {
+    query: { project_id: project.project_id, ai_fix_status: "building", limit: 100 }
+  });
+  const inFlightBranchNames = /* @__PURE__ */ new Set();
+  if (inFlight.ok && inFlight.data) {
+    for (const t of inFlight.data) {
+      inFlightBranchNames.add(branchSlug(t.sequence_number, t.title));
+    }
+  }
+  const orphans = localBranches.filter((b) => !inFlightBranchNames.has(b.name));
+  const kept = localBranches.filter((b) => inFlightBranchNames.has(b.name));
+  if (orphans.length === 0) {
+    if (!silent) {
+      process.stdout.write(c.dim("No orphan task/* branches.\n"));
+      if (kept.length > 0) {
+        process.stdout.write(
+          c.dim(
+            `  ${kept.length} in-flight branch(es) preserved: ${kept.map((b) => b.name).join(", ")}
+`
+          )
+        );
+      }
+    }
+    return;
+  }
+  if (!silent) {
+    process.stdout.write(`${c.bold("Orphan task/* branches:")}
+`);
+    for (const b of orphans) {
+      const upstream = b.hasUpstream ? c.dim(" (has upstream)") : c.dim(" (no upstream)");
+      process.stdout.write(`  ${c.dim("\xB7")} ${b.name}${upstream}
+`);
+    }
+    if (kept.length > 0) {
+      process.stdout.write(`
+${c.dim("In-flight branch(es) preserved (use `task resume`):")}
+`);
+      for (const b of kept) {
+        process.stdout.write(`  ${c.dim("\xB7")} ${b.name}
+`);
+      }
+    }
+    process.stdout.write("\n");
+  }
+  const isTty = !silent && process.stdin.isTTY === true;
+  if (!isTty) {
+    if (!opts.confirm) {
+      throw new CliError(
+        CLI_EXIT_CODES.MISCONFIGURATION,
+        "`task reset` requires --confirm in non-interactive (silent / scheduled-task) contexts",
+        "Re-run with --confirm only after verifying the orphan list is what you expect."
+      );
+    }
+  } else {
+    const answer = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Delete ${orphans.length} orphan branch(es)?`,
+        default: false
+      }
+    ]);
+    if (!answer.confirm) {
+      if (!silent) process.stdout.write(c.dim("Aborted \u2014 no branches deleted.\n"));
+      process.exit(CLI_EXIT_CODES.SUCCESS);
+    }
+  }
+  let deleted = 0;
+  for (const b of orphans) {
+    deleteLocalBranch(cwd, b.name);
+    deleted += 1;
+    if (!silent) process.stdout.write(`${c.ok("\u2713")} deleted ${b.name}
+`);
+  }
+  if (!silent) {
+    process.stdout.write(
+      `
+${c.bold(`Cleaned up ${deleted} branch(es).`)} ${c.dim("Run `task work` to start fresh.")}
+`
+    );
+  }
+}
+
 // src/commands/scan.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import ora2 from "ora";
@@ -2931,7 +3605,7 @@ function clampInt(raw, min, max, fallback) {
 }
 
 // src/commands/pr-test.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 function registerPrTest(program2) {
   program2.command("pr-test").description(
     "Dry-run the full PR pipeline \u2014 cuts a throwaway branch, opens a real PR via the dashboard, then cleans up. Use this to verify your git integration before running task work on real tickets."
@@ -2974,7 +3648,7 @@ async function runPrTest(opts) {
   try {
     if (!silent) process.stdout.write(`${c.dim("Step 3/6: empty commit\u2026")}
 `);
-    execFileSync6(
+    execFileSync8(
       "git",
       ["commit", "--allow-empty", "-m", `task pr-test: connectivity probe ${timestamp}`],
       { cwd, stdio: ["ignore", "pipe", "pipe"] }
@@ -3077,7 +3751,7 @@ import { platform as platform2 } from "os";
 import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile8, unlink as unlink3, readdir } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join8 } from "path";
-import { execFileSync as execFileSync7, spawn as spawn4 } from "child_process";
+import { execFileSync as execFileSync9, spawn as spawn4 } from "child_process";
 
 // src/scheduler/cron-translate.ts
 function translateToLaunchd(cron) {
@@ -3245,17 +3919,17 @@ var launchdAdapter = {
     const path = plistPath(entry.id);
     await writeFile8(path, buildPlist(entry));
     try {
-      execFileSync7("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
+      execFileSync9("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
     } catch {
     }
     if (entry.enabled) {
-      execFileSync7("launchctl", ["bootstrap", bootstrapDomain(), path]);
+      execFileSync9("launchctl", ["bootstrap", bootstrapDomain(), path]);
     }
   },
   async remove(id) {
     const path = plistPath(id);
     try {
-      execFileSync7("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
+      execFileSync9("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
     } catch {
     }
     try {
@@ -3320,10 +3994,10 @@ var launchdAdapter = {
       xml = xml.replace(/\s*<key>Disabled<\/key>\s*<true\/>/, "");
       await writeFile8(path, xml);
       try {
-        execFileSync7("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
+        execFileSync9("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
       } catch {
       }
-      execFileSync7("launchctl", ["bootstrap", bootstrapDomain(), path]);
+      execFileSync9("launchctl", ["bootstrap", bootstrapDomain(), path]);
     } else {
       if (!/<key>Disabled<\/key>/.test(xml)) {
         xml = xml.replace(
@@ -3333,7 +4007,7 @@ var launchdAdapter = {
         await writeFile8(path, xml);
       }
       try {
-        execFileSync7("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
+        execFileSync9("launchctl", ["bootout", bootstrapDomain(), path], { stdio: "ignore" });
       } catch {
       }
     }
@@ -3341,7 +4015,7 @@ var launchdAdapter = {
 };
 
 // src/scheduler/cron.ts
-import { execFileSync as execFileSync8, spawn as spawn5 } from "child_process";
+import { execFileSync as execFileSync10, spawn as spawn5 } from "child_process";
 
 // src/scheduler/safe-command.ts
 var FORBIDDEN = /[;&|`$()<>\\]/;
@@ -3396,7 +4070,7 @@ var MARK_OPEN = (id) => `# task-cli:${id}:start`;
 var MARK_CLOSE = (id) => `# task-cli:${id}:end`;
 function readCrontab() {
   try {
-    return execFileSync8("crontab", ["-l"], { encoding: "utf8" });
+    return execFileSync10("crontab", ["-l"], { encoding: "utf8" });
   } catch {
     return "";
   }
@@ -3511,7 +4185,7 @@ var cronAdapter = {
 };
 
 // src/scheduler/windows.ts
-import { execFileSync as execFileSync9, spawn as spawn6 } from "child_process";
+import { execFileSync as execFileSync11, spawn as spawn6 } from "child_process";
 var TASK_PREFIX = "TaskCLI_";
 function taskName(id) {
   return `${TASK_PREFIX}${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
@@ -3576,22 +4250,22 @@ function pad(v) {
 var windowsAdapter = {
   async upsert(entry) {
     const args = buildSchtasksArgs(entry, entry.command);
-    execFileSync9("schtasks.exe", args, { stdio: "ignore" });
+    execFileSync11("schtasks.exe", args, { stdio: "ignore" });
     if (!entry.enabled) {
-      execFileSync9("schtasks.exe", ["/Change", "/TN", taskName(entry.id), "/DISABLE"], {
+      execFileSync11("schtasks.exe", ["/Change", "/TN", taskName(entry.id), "/DISABLE"], {
         stdio: "ignore"
       });
     }
   },
   async remove(id) {
     try {
-      execFileSync9("schtasks.exe", ["/Delete", "/TN", taskName(id), "/F"], { stdio: "ignore" });
+      execFileSync11("schtasks.exe", ["/Delete", "/TN", taskName(id), "/F"], { stdio: "ignore" });
     } catch {
     }
   },
   async list() {
     try {
-      const csv = execFileSync9("schtasks.exe", ["/Query", "/FO", "CSV", "/V"], {
+      const csv = execFileSync11("schtasks.exe", ["/Query", "/FO", "CSV", "/V"], {
         encoding: "utf8"
       });
       const lines = csv.split(/\r?\n/);
@@ -3641,7 +4315,7 @@ var windowsAdapter = {
   },
   async setEnabled(id, enabled) {
     try {
-      execFileSync9(
+      execFileSync11(
         "schtasks.exe",
         ["/Change", "/TN", taskName(id), enabled ? "/ENABLE" : "/DISABLE"],
         { stdio: "ignore" }
@@ -4049,7 +4723,7 @@ function registerConfig(program2) {
 }
 
 // src/commands/doctor.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 import { readFile as readFile8, writeFile as writeFile10 } from "fs/promises";
 import { join as join11 } from "path";
 import { request as request5 } from "undici";
@@ -4100,8 +4774,27 @@ function registerDoctor(program2) {
         detail: `${apiUrl}: ${err.message}`
       });
     }
+    if (project) {
+      const baseBranch = project.cli_base_branch ?? "development";
+      try {
+        const exists = remoteBranchExists(root, baseBranch);
+        checks.push({
+          name: "base branch on origin",
+          ok: exists,
+          detail: exists ? `origin/${baseBranch} reachable` : `origin has no branch "${baseBranch}"`,
+          remediation: exists ? void 0 : `push it (\`git push origin ${baseBranch}\`) or update the project's cli_base_branch via PATCH /api/v1/projects/${project.project_id}`
+        });
+      } catch (err) {
+        checks.push({
+          name: "base branch on origin",
+          ok: false,
+          detail: err instanceof CliError ? err.message : `could not check origin: ${err.message}`,
+          remediation: err instanceof CliError && err.hint ? err.hint : "Verify that `origin` is configured (`git remote -v`)."
+        });
+      }
+    }
     try {
-      const dirty = execFileSync10("git", ["status", "--porcelain"], {
+      const dirty = execFileSync12("git", ["status", "--porcelain"], {
         cwd: root,
         encoding: "utf8"
       }).trim();
@@ -4119,10 +4812,19 @@ function registerDoctor(program2) {
       opts.fix === true
     );
     checks.push(testCheck);
+    let inFlight = [];
+    if (creds && project) {
+      inFlight = await listInFlightTickets(project.project_id, root);
+      checks.push({
+        name: "in-flight tickets",
+        ok: true,
+        detail: inFlight.length === 0 ? "none" : `${inFlight.length} ticket(s) waiting to be resumed`
+      });
+    }
     let allOk = true;
     for (const check of checks) {
       const sym = check.ok ? c.ok("\u2713") : c.err("\u2717");
-      process.stdout.write(`${sym} ${check.name.padEnd(16)} ${c.dim(check.detail)}
+      process.stdout.write(`${sym} ${check.name.padEnd(20)} ${c.dim(check.detail)}
 `);
       if (!check.ok) {
         allOk = false;
@@ -4132,9 +4834,42 @@ function registerDoctor(program2) {
         }
       }
     }
+    for (const t of inFlight) {
+      const status = t.branchPresent ? c.ok("local branch present") : c.err("local branch missing");
+      process.stdout.write(
+        `  ${c.dim("\u2192")} #${t.sequenceNumber} "${t.title}" \u2014 ${status} \u2014 ${c.cyan(`task resume #${t.sequenceNumber}`)}
+`
+      );
+    }
     if (!allOk) process.exit(1);
   });
 }
+async function listInFlightTickets(projectId, cwd) {
+  const result = await apiCall(
+    "GET",
+    "/api/v1/cli/me/tickets",
+    {
+      query: { project_id: projectId, ai_fix_status: "building", limit: 100 }
+    }
+  );
+  if (!result.ok || !result.data) return [];
+  return result.data.map((t) => ({
+    sequenceNumber: t.sequence_number,
+    title: t.title,
+    branchPresent: localBranchExists2(cwd, branchSlug(t.sequence_number, t.title))
+  }));
+}
+function localBranchExists2(cwd, branchName) {
+  try {
+    execFileSync12("git", ["rev-parse", "--verify", `refs/heads/${branchName}`], {
+      cwd,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function checkPrePushTest(root, configuredCommand, fix) {
   const command = configuredCommand && configuredCommand.trim().length > 0 ? configuredCommand.trim() : DEFAULT_TEST_COMMAND;
   const argv = command.split(/\s+/).filter((s) => s.length > 0);
@@ -4209,11 +4944,12 @@ async function checkPrePushTest(root, configuredCommand, fix) {
 function resolveScriptName(argv) {
   const [exe, ...rest] = argv;
   if (!exe || rest.length === 0) return null;
+  const hasAnyFlag = rest.some((tok) => tok.startsWith("-"));
+  if (hasAnyFlag) return null;
   if (exe === "pnpm" || exe === "yarn" || exe === "bun") {
     const next = rest[0];
     if (!next) return null;
     if (next === "run") return rest[1] ?? null;
-    if (next.startsWith("-")) return null;
     return next;
   }
   if (exe === "npm") {
@@ -4231,7 +4967,7 @@ function detectIndent(raw) {
 }
 function checkBinary(name, command) {
   try {
-    const out = execFileSync10(command, ["--version"], { encoding: "utf8" }).trim();
+    const out = execFileSync12(command, ["--version"], { encoding: "utf8" }).trim();
     return { name, ok: true, detail: out.split("\n")[0] ?? out };
   } catch {
     return { name, ok: false, detail: `'${command}' not found on PATH` };
@@ -4239,7 +4975,7 @@ function checkBinary(name, command) {
 }
 
 // src/commands/version.ts
-var CLI_VERSION = true ? "0.2.4" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.2.6" : "0.0.0-dev";
 function registerVersion(program2) {
   program2.command("version").description("Print the CLI version").action(() => {
     process.stdout.write(CLI_VERSION + "\n");
@@ -4263,6 +4999,8 @@ registerTickets(program);
 registerTicket(program);
 registerWork(program);
 registerMultiWork(program);
+registerResume(program);
+registerReset(program);
 registerScan(program);
 registerPrTest(program);
 registerScheduledTask(program);