@inteeka/task-cli 0.2.3 → 0.2.5

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;
@@ -1374,6 +1384,9 @@ function currentBranch(cwd) {
   }
 }
 
+// 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}$/;
@@ -1636,7 +1649,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 +1687,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) {
@@ -1973,11 +1995,12 @@ 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)
@@ -2024,6 +2047,7 @@ Claude session: ${runId}
         output_excerpt: err.message.slice(0, 4e3)
       }
     });
+    if (err instanceof CliError) err.phase = "post_push";
     throw err;
   }
   try {
@@ -2063,6 +2087,79 @@ 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 pickNextEligible(projectId) {
   const result = await apiCall("GET", "/api/v1/cli/me/tickets", {
     query: { project_id: projectId, limit: 1 }
@@ -2109,20 +2206,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 +2240,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 +2344,248 @@ ${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/scan.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import ora2 from "ora";
@@ -2931,7 +3293,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 +3336,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 +3439,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 +3607,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 +3682,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 +3695,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 +3703,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 +3758,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 +3873,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 +3938,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 +4003,7 @@ var windowsAdapter = {
   },
   async setEnabled(id, enabled) {
     try {
-      execFileSync9(
+      execFileSync11(
         "schtasks.exe",
         ["/Change", "/TN", taskName(id), enabled ? "/ENABLE" : "/DISABLE"],
         { stdio: "ignore" }
@@ -4049,10 +4411,14 @@ 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";
+var ALLOWED_TEST_EXECUTABLES = /* @__PURE__ */ new Set(["pnpm", "npm", "yarn", "bun", "node", "npx"]);
+var DEFAULT_TEST_COMMAND = "pnpm typecheck";
 function registerDoctor(program2) {
-  program2.command("doctor").description("Diagnose your CLI setup").action(async () => {
+  program2.command("doctor").description("Diagnose your CLI setup").option("--fix", "attempt to auto-remediate fixable problems (e.g. add a typecheck script)").action(async (opts) => {
     const checks = [];
     const creds = await readCredentials();
     checks.push({
@@ -4097,7 +4463,7 @@ function registerDoctor(program2) {
       });
     }
     try {
-      const dirty = execFileSync10("git", ["status", "--porcelain"], {
+      const dirty = execFileSync12("git", ["status", "--porcelain"], {
         cwd: root,
         encoding: "utf8"
       }).trim();
@@ -4109,19 +4475,167 @@ function registerDoctor(program2) {
     } catch {
       checks.push({ name: "working tree", ok: false, detail: "not in a git repo" });
     }
+    const testCheck = await checkPrePushTest(
+      root,
+      project?.cli_test_command ?? null,
+      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;
+      if (!check.ok) {
+        allOk = false;
+        if (check.remediation) {
+          process.stdout.write(`  ${c.dim("\u2192 " + check.remediation)}
+`);
+        }
+      }
+    }
+    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);
+  const exe = argv[0];
+  if (!exe || !ALLOWED_TEST_EXECUTABLES.has(exe)) {
+    return {
+      name: "pre-push test",
+      ok: false,
+      detail: `command "${command}" not allowlisted (allowed: ${[...ALLOWED_TEST_EXECUTABLES].join(", ")})`,
+      remediation: "update projects.cli_test_command via the dashboard"
+    };
+  }
+  const scriptName = resolveScriptName(argv);
+  if (!scriptName) {
+    return {
+      name: "pre-push test",
+      ok: true,
+      detail: `${command} (non-script executable, not statically verifiable)`
+    };
+  }
+  const pkgPath = join11(root, "package.json");
+  let pkgRaw;
+  try {
+    pkgRaw = await readFile8(pkgPath, "utf8");
+  } catch {
+    return {
+      name: "pre-push test",
+      ok: false,
+      detail: `no package.json at repo root for "${command}"`,
+      remediation: `add a package.json with a "${scriptName}" script, or set projects.cli_test_command in the dashboard`
+    };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(pkgRaw);
+  } catch (err) {
+    return {
+      name: "pre-push test",
+      ok: false,
+      detail: `package.json is invalid JSON: ${err.message}`
+    };
+  }
+  const scripts = pkg.scripts ?? {};
+  if (typeof scripts[scriptName] === "string" && scripts[scriptName].trim().length > 0) {
+    return {
+      name: "pre-push test",
+      ok: true,
+      detail: `${command} \u2192 "${scripts[scriptName]}"`
+    };
+  }
+  const isDefaultTypecheck = command === DEFAULT_TEST_COMMAND && scriptName === "typecheck";
+  const hasTypeScript = !!pkg.devDependencies?.typescript || !!pkg.dependencies?.typescript;
+  if (fix && isDefaultTypecheck && hasTypeScript) {
+    pkg.scripts = { ...scripts, typecheck: "tsc --noEmit" };
+    const indent = detectIndent(pkgRaw);
+    const trailingNewline = pkgRaw.endsWith("\n") ? "\n" : "";
+    await writeFile10(pkgPath, JSON.stringify(pkg, null, indent) + trailingNewline);
+    return {
+      name: "pre-push test",
+      ok: true,
+      detail: `added "typecheck": "tsc --noEmit" to ${pkgPath}`
+    };
+  }
+  const remediation = isDefaultTypecheck ? hasTypeScript ? 're-run with --fix to add "typecheck": "tsc --noEmit" to package.json' : 'add a "typecheck" script to package.json, or set a different cli_test_command in the dashboard' : `add a "${scriptName}" script to package.json, or update cli_test_command in the dashboard`;
+  return {
+    name: "pre-push test",
+    ok: false,
+    detail: `"${scriptName}" script missing \u2014 "${command}" will exit 254 (ERR_PNPM_RECURSIVE_EXEC_FIRST_FAIL)`,
+    remediation
+  };
+}
+function resolveScriptName(argv) {
+  const [exe, ...rest] = argv;
+  if (!exe || rest.length === 0) 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") {
+    if (rest[0] === "run" || rest[0] === "run-script") return rest[1] ?? null;
+    return null;
+  }
+  return null;
+}
+function detectIndent(raw) {
+  const match = raw.match(/^(\s+)"/m);
+  if (!match) return 2;
+  const ws = match[1] ?? "  ";
+  if (ws.startsWith("	")) return "	";
+  return ws.length;
+}
 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` };
@@ -4129,7 +4643,7 @@ function checkBinary(name, command) {
 }
 
 // src/commands/version.ts
-var CLI_VERSION = true ? "0.2.3" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.2.5" : "0.0.0-dev";
 function registerVersion(program2) {
   program2.command("version").description("Print the CLI version").action(() => {
     process.stdout.write(CLI_VERSION + "\n");
@@ -4153,6 +4667,7 @@ registerTickets(program);
 registerTicket(program);
 registerWork(program);
 registerMultiWork(program);
+registerResume(program);
 registerScan(program);
 registerPrTest(program);
 registerScheduledTask(program);