@inteeka/task-cli 0.2.5 → 0.2.7

package/dist/cli.js

@@ -998,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);
@@ -1036,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"
       });
@@ -1051,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")}
+`
+        );
+      }
+    }
   });
 }
 
@@ -1281,264 +1564,83 @@ async function runAgent(args) {
     child.on("close", (code) => {
       logHandle?.end();
       const exitCode = code ?? 0;
-      resolve2({ exitCode, ok: exitCode === 0, outputLogPath, stderrTail: stderrBuffer });
-    });
-  });
-}
-
-// src/guardrail/diff-check.ts
-import { execFileSync as execFileSync2 } from "child_process";
-
-// src/guardrail/protected-paths.ts
-import picomatch from "picomatch";
-function buildProtectedMatcher(projectExtensions = []) {
-  const merged = Array.from(
-    /* @__PURE__ */ new Set([
-      ...CLI_DEFAULT_PROTECTED_PATHS,
-      ...projectExtensions.map((p) => p.trim()).filter(Boolean)
-    ])
-  );
-  const matcher = picomatch(merged, {
-    dot: true,
-    nocase: false
-  });
-  function normalise(p) {
-    return p.replace(/\\/g, "/");
-  }
-  return {
-    patterns: merged,
-    isProtected(path) {
-      return matcher(normalise(path));
-    },
-    matchAll(paths) {
-      const offending = [];
-      for (const p of paths) {
-        if (matcher(normalise(p))) offending.push(p);
-      }
-      return offending;
-    }
-  };
-}
-
-// src/guardrail/diff-check.ts
-function checkDiff(args) {
-  const matcher = buildProtectedMatcher(args.projectProtectedPaths);
-  const stagedRaw = safeGitOutput(["diff", "--cached", "--name-only"], args.cwd);
-  const unstagedRaw = safeGitOutput(["diff", "--name-only"], args.cwd);
-  const untrackedRaw = safeGitOutput(["ls-files", "--others", "--exclude-standard"], args.cwd);
-  const allChanged = Array.from(
-    new Set(
-      [...splitLines(stagedRaw), ...splitLines(unstagedRaw), ...splitLines(untrackedRaw)].filter(
-        (l) => l.length > 0
-      )
-    )
-  );
-  const offending = matcher.matchAll(allChanged);
-  if (offending.length === 0) {
-    return { violation: false, changedPaths: allChanged, allowedPaths: allChanged };
-  }
-  return {
-    violation: true,
-    offendingPaths: offending,
-    changedPaths: allChanged,
-    patterns: matcher.patterns
-  };
-}
-function safeGitOutput(args, cwd) {
-  try {
-    return execFileSync2("git", args, { cwd, encoding: "utf8" });
-  } catch {
-    return "";
-  }
-}
-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/commands/work.ts
-import { execFileSync as execFileSync6 } from "child_process";
-
-// 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"]
+      resolve2({ exitCode, ok: exitCode === 0, outputLogPath, stderrTail: stderrBuffer });
     });
-    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 {
+
+// src/guardrail/diff-check.ts
+import { execFileSync as execFileSync4 } from "child_process";
+
+// src/guardrail/protected-paths.ts
+import picomatch from "picomatch";
+function buildProtectedMatcher(projectExtensions = []) {
+  const merged = Array.from(
+    /* @__PURE__ */ new Set([
+      ...CLI_DEFAULT_PROTECTED_PATHS,
+      ...projectExtensions.map((p) => p.trim()).filter(Boolean)
+    ])
+  );
+  const matcher = picomatch(merged, {
+    dot: true,
+    nocase: false
+  });
+  function normalise(p) {
+    return p.replace(/\\/g, "/");
+  }
+  return {
+    patterns: merged,
+    isProtected(path) {
+      return matcher(normalise(path));
+    },
+    matchAll(paths) {
+      const offending = [];
+      for (const p of paths) {
+        if (matcher(normalise(p))) offending.push(p);
+      }
+      return offending;
     }
+  };
+}
+
+// src/guardrail/diff-check.ts
+function checkDiff(args) {
+  const matcher = buildProtectedMatcher(args.projectProtectedPaths);
+  const stagedRaw = safeGitOutput(["diff", "--cached", "--name-only"], args.cwd);
+  const unstagedRaw = safeGitOutput(["diff", "--name-only"], args.cwd);
+  const untrackedRaw = safeGitOutput(["ls-files", "--others", "--exclude-standard"], args.cwd);
+  const allChanged = Array.from(
+    new Set(
+      [...splitLines(stagedRaw), ...splitLines(unstagedRaw), ...splitLines(untrackedRaw)].filter(
+        (l) => l.length > 0
+      )
+    )
+  );
+  const offending = matcher.matchAll(allChanged);
+  if (offending.length === 0) {
+    return { violation: false, changedPaths: allChanged, allowedPaths: allChanged };
   }
+  return {
+    violation: true,
+    offendingPaths: offending,
+    changedPaths: allChanged,
+    patterns: matcher.patterns
+  };
+}
+function safeGitOutput(args, cwd) {
   try {
-    execFileSync4("git", ["clean", "-fd"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
+    return execFileSync4("git", args, { cwd, encoding: "utf8" });
   } 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);
+    return "";
   }
 }
-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(/-+$/, "");
+function splitLines(text) {
+  return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
 }
 
+// src/commands/work.ts
+import { execFileSync as execFileSync6 } from "child_process";
+
 // src/git/restore.ts
 import { execFileSync as execFileSync5 } from "child_process";
 function discardWorkingTreeChanges(cwd) {
@@ -1717,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: {
@@ -1736,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: {
@@ -2007,14 +2156,21 @@ Claude session: ${runId}
     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
       }
@@ -2032,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'.
 `) : "")
       );
@@ -2160,6 +2316,54 @@ ${c.bold("--reset will:")}
   }
   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 }
@@ -2586,6 +2790,114 @@ function buildResumePrBody(detail, branchName, baseBranch) {
   ].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";
@@ -4462,6 +4774,25 @@ 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 = execFileSync12("git", ["status", "--porcelain"], {
         cwd: root,
@@ -4613,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") {
@@ -4643,7 +4975,7 @@ function checkBinary(name, command) {
 }
 
 // src/commands/version.ts
-var CLI_VERSION = true ? "0.2.5" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.2.7" : "0.0.0-dev";
 function registerVersion(program2) {
   program2.command("version").description("Print the CLI version").action(() => {
     process.stdout.write(CLI_VERSION + "\n");
@@ -4668,6 +5000,7 @@ registerTicket(program);
 registerWork(program);
 registerMultiWork(program);
 registerResume(program);
+registerReset(program);
 registerScan(program);
 registerPrTest(program);
 registerScheduledTask(program);