runcastle 1.0.13 → 1.0.14

package/index.js

@@ -105,6 +105,7 @@ var init_config = __esm(() => {
     sandboxImage: z.string().optional(),
     burnConcurrency: z.number().int().min(1).max(8).default(3),
     burnMaxIterations: z.number().int().min(1).max(10).default(3),
+    burnAttempts: z.number().int().min(1).max(5).default(3),
     setupCommand: z.string().optional(),
     burnWorkspace: z.enum(["auto", "mounted", "isolated"]).default("auto")
   }));
@@ -145,6 +146,9 @@ function loadConfig(env = process.env) {
   if (env.RUNCASTLE_BURN_MAX_ITERATIONS) {
     overrides.burnMaxIterations = Number(env.RUNCASTLE_BURN_MAX_ITERATIONS);
   }
+  if (env.RUNCASTLE_BURN_ATTEMPTS) {
+    overrides.burnAttempts = Number(env.RUNCASTLE_BURN_ATTEMPTS);
+  }
   if (env.RUNCASTLE_SETUP_COMMAND)
     overrides.setupCommand = env.RUNCASTLE_SETUP_COMMAND;
   if (env.RUNCASTLE_BURN_WORKSPACE)
@@ -211,7 +215,8 @@ var init_schemas = __esm(() => {
     seq: z2.number(),
     status: TicketStatus,
     commits: z2.array(z2.string()),
-    error: z2.string().optional()
+    error: z2.string().optional(),
+    attemptBranch: z2.string().optional()
   });
   WaypointType = z2.enum(["grilling", "research", "prototype", "task"]);
   WaypointStatus = z2.enum(["open", "claimed", "resolved", "dropped"]);
@@ -490,7 +495,8 @@ var init_db_schema = __esm(() => {
     blockedBy: text("blocked_by", { mode: "json" }).notNull().$type(),
     status: text("status").notNull().$type(),
     commits: text("commits", { mode: "json" }).notNull().$type(),
-    error: text("error")
+    error: text("error"),
+    attemptBranch: text("attempt_branch")
   });
   waypoints = sqliteTable("waypoints", {
     id: text("id").primaryKey(),
@@ -1657,7 +1663,8 @@ function rowToTicket(row) {
     blockedBy: row.blockedBy,
     status: row.status,
     commits: row.commits,
-    error: row.error ?? undefined
+    error: row.error ?? undefined,
+    attemptBranch: row.attemptBranch ?? undefined
   };
 }
 function resolveBlocking(inputs, startSeq) {
@@ -1690,7 +1697,8 @@ function storeTickets(ctx, featureId, inputs) {
     blockedBy: resolved[i].blockedBy,
     status: "pending",
     commits: [],
-    error: null
+    error: null,
+    attemptBranch: null
   }));
   ctx.db.insert(tickets).values(rows).run();
   emit(ctx, featureId, {
@@ -1760,6 +1768,8 @@ function updateTicket(ctx, id, patch) {
     set.commits = patch.commits;
   if (patch.error !== undefined)
     set.error = patch.error;
+  if (patch.attemptBranch !== undefined)
+    set.attemptBranch = patch.attemptBranch;
   ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.updated",
@@ -2139,6 +2149,53 @@ function researchBranchName(slug, waypointSeq, unique) {
 function ticketBranchName(slug, ticketSeq, unique) {
   return `${TICKET_BRANCH_PREFIX}${tempBranchSlugSegment(slug)}/${ticketSeq}-${unique}`;
 }
+async function branchCommitsAhead(repoPath, base, branch) {
+  try {
+    const out = await git(repoPath).raw(["rev-list", "--reverse", `${base}..${branch}`]);
+    return out.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function deleteTempBranch(repoPath, branch) {
+  try {
+    return await deleteBranchDetachingWorktrees(git(repoPath), repoPath, branch);
+  } catch {
+    return false;
+  }
+}
+function ticketBranchPrefix(slug, ticketSeq) {
+  return `${TICKET_BRANCH_PREFIX}${tempBranchSlugSegment(slug)}/${ticketSeq}-`;
+}
+async function listTicketAttemptBranches(repoPath, slug, ticketSeq) {
+  const prefix = ticketBranchPrefix(slug, ticketSeq);
+  try {
+    return (await git(repoPath).branchLocal()).all.filter((b) => b.startsWith(prefix));
+  } catch {
+    return [];
+  }
+}
+async function findPreservedTicketBranch(repoPath, featureBranch2, slug, ticketSeq) {
+  try {
+    const g = git(repoPath);
+    let best;
+    for (const branch of await listTicketAttemptBranches(repoPath, slug, ticketSeq)) {
+      const commits = await branchCommitsAhead(repoPath, featureBranch2, branch);
+      if (commits.length === 0)
+        continue;
+      let tipTime = 0;
+      try {
+        tipTime = Number((await g.raw(["log", "-1", "--format=%ct", branch])).trim()) || 0;
+      } catch {}
+      if (!best || tipTime > best.tipTime)
+        best = { branch, commits, tipTime };
+    }
+    return best ? { branch: best.branch, commits: best.commits } : undefined;
+  } catch {
+    return;
+  }
+}
 async function allowPushToCheckedOutBranches(repoPath) {
   await git(repoPath).addConfig("receive.denyCurrentBranch", "ignore");
 }
@@ -2839,6 +2896,55 @@ function isMergeConflictError(err) {
   const msg = err instanceof Error ? err.message : typeof err === "string" ? err : "";
   return /conflict/i.test(msg) || /git branch -D/i.test(msg) || /automatic merge failed/i.test(msg);
 }
+function classifyTicketRunError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+  if (FATAL_ERROR_PATTERNS.some((p) => p.test(msg)))
+    return "fatal";
+  if (RETRYABLE_ERROR_PATTERNS.some((p) => p.test(msg)))
+    return "retryable";
+  return "fatal";
+}
+function retryDelayMs(attempt) {
+  return Math.min(30000, 5000 * 2 ** (attempt - 1));
+}
+function buildRetryNotes(input) {
+  const cause = input.error ? ` (${input.error})` : "";
+  const commits = input.commitCount > 0 ? `${input.commitCount} commit(s) from the previous attempt(s) are already on your branch \u2014 completed work, not noise.` : "The previous attempt had not committed anything yet, so you are effectively starting clean.";
+  return [
+    "## Recovery context \u2014 a previous attempt was interrupted",
+    "",
+    `A previous agent working THIS SAME ticket was killed by a transient infrastructure error${cause} \u2014 not by anything it did wrong, and not by a human decision. You are picking up where it left off.`,
+    "",
+    commits,
+    "",
+    "Before doing anything else, run `git log --oneline -15` and `git status` to see what was already completed. Build on that work \u2014 do NOT revert or redo existing commits. Uncommitted changes from the previous attempt were lost; only commits survived. If the ticket turns out to be fully implemented already, verify the acceptance criteria and finish normally."
+  ].join(`
+`);
+}
+function delayUnlessAborted(ms, signal) {
+  return new Promise((resolve6) => {
+    if (signal.aborted) {
+      resolve6();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve6();
+    };
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve6();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function stopTicketRun(ticketId) {
+  const controller = activeTicketAborts.get(ticketId);
+  if (!controller)
+    return false;
+  controller.abort(new Error("ticket stopped by user"));
+  return true;
+}
 function createSerialQueue() {
   let tail = Promise.resolve();
   return (task) => {
@@ -3058,12 +3164,11 @@ function selectSandbox(config2, mounts = []) {
 }
 async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget) {
   const { project, feature } = ctx;
-  const tempBranch = ticketBranchName(feature.slug, ticket.seq, newId("b").slice(2, 10));
   const workspaceMode = resolveBurnWorkspaceMode(config2);
   if (workspaceMode === "isolated")
     await ensureIsolatedPushTarget();
   const template = readFileSync4(burnerTemplatePath(), "utf8");
-  const prompt = renderTicketPrompt(template, {
+  const basePrompt = renderTicketPrompt(template, {
     TICKET_JSON: buildTicketJson(ticket),
     FEATURE_BRIEF: buildFeatureBrief(feature),
     DOCS_DIGEST: readDocsDigestFromDisk(project.id, feature.slug),
@@ -3081,14 +3186,6 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
       mounts.push(mount);
     }
   }
-  const hookCommand = workspaceMode === "isolated" ? buildIsolatedSetupCommand(tempBranch, setupCommand, pm) : setupCommand;
-  if (hookCommand) {
-    ctx.emitEvent({
-      type: "burn.setup",
-      message: workspaceMode === "isolated" ? `preparing isolated workspace (native-FS clone)${setupCommand ? ` + deps install: ${setupCommand}` : ""}` : `installing deps before agent start: ${setupCommand}`,
-      ticketId: ticket.id
-    });
-  }
   mkdirSync4(logsDir(), { recursive: true });
   const logFilePath = join9(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
@@ -3105,70 +3202,177 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
       });
     }
   };
-  const runOptions = {
-    agent: buildBurnAgent(config2, token, model),
-    sandbox: selectSandbox(config2, mounts),
-    cwd: project.repoPath,
-    prompt,
-    branchStrategy: { type: "branch", branch: tempBranch, baseBranch: feature.branch },
-    signal: ctx.signal,
-    name: `ticket-${ticket.seq}`,
-    maxIterations: config2.burnMaxIterations,
-    ...hookCommand ? {
-      hooks: {
-        sandbox: {
-          onSandboxReady: [{ command: hookCommand, timeoutMs: SETUP_HOOK_TIMEOUT_MS }]
-        }
-      }
-    } : {},
-    logging: { type: "file", path: logFilePath, onAgentStreamEvent: onStreamEvent }
+  const ticketAbort = new AbortController;
+  activeTicketAborts.set(ticket.id, ticketAbort);
+  const signal = AbortSignal.any([ctx.signal, ticketAbort.signal]);
+  const maxAttempts = Math.max(1, config2.burnAttempts);
+  let baseBranch = feature.branch;
+  let retryNotes;
+  if (ticket.attemptBranch) {
+    const preserved = await branchCommitsAhead(project.repoPath, feature.branch, ticket.attemptBranch);
+    if (preserved.length > 0) {
+      baseBranch = ticket.attemptBranch;
+      retryNotes = buildRetryNotes({
+        ...ticket.error ? { error: errorHeadline(ticket.error) } : {},
+        commitCount: preserved.length
+      });
+      ctx.emitEvent({
+        type: "ticket.resuming",
+        message: `ticket ${ticket.seq}: resuming from ${preserved.length} preserved commit(s) of a previous attempt`,
+        ticketId: ticket.id,
+        data: { attemptBranch: ticket.attemptBranch, preservedCommits: preserved.length }
+      });
+    }
+  }
+  const preserveChain = (branch) => {
+    ctx.updateTicket(ticket.id, { attemptBranch: branch });
   };
-  let result;
   try {
-    result = await run(runOptions);
-  } catch (err) {
-    throttle.flush();
-    endTranscript(ticket.id);
-    if (ctx.signal.aborted)
-      throw err;
-    const msg = err instanceof Error ? err.message : String(err);
-    if (isMergeConflictError(err)) {
-      return {
-        status: "failed",
-        error: `merge conflict landing ticket ${ticket.seq} on ${feature.branch}: ${msg}`,
-        event: {
-          type: "merge.conflict.needs-human",
-          message: `ticket ${ticket.seq}: merge conflict on ${feature.branch} \u2014 resolve manually per the error, then re-burn`
-        }
+    let result;
+    let tempBranch = "";
+    for (let attempt = 1;; attempt++) {
+      tempBranch = ticketBranchName(feature.slug, ticket.seq, newId("b").slice(2, 10));
+      const hookCommand = workspaceMode === "isolated" ? buildIsolatedSetupCommand(tempBranch, setupCommand, pm) : setupCommand;
+      if (hookCommand && attempt === 1) {
+        ctx.emitEvent({
+          type: "burn.setup",
+          message: workspaceMode === "isolated" ? `preparing isolated workspace (native-FS clone)${setupCommand ? ` + deps install: ${setupCommand}` : ""}` : `installing deps before agent start: ${setupCommand}`,
+          ticketId: ticket.id
+        });
+      }
+      const runOptions = {
+        agent: buildBurnAgent(config2, token, model),
+        sandbox: selectSandbox(config2, mounts),
+        cwd: project.repoPath,
+        prompt: retryNotes ? `${basePrompt}
+
+${retryNotes}` : basePrompt,
+        branchStrategy: { type: "branch", branch: tempBranch, baseBranch },
+        signal,
+        name: `ticket-${ticket.seq}`,
+        maxIterations: config2.burnMaxIterations,
+        ...hookCommand ? {
+          hooks: {
+            sandbox: {
+              onSandboxReady: [{ command: hookCommand, timeoutMs: SETUP_HOOK_TIMEOUT_MS }]
+            }
+          }
+        } : {},
+        logging: { type: "file", path: logFilePath, onAgentStreamEvent: onStreamEvent }
       };
+      try {
+        result = await run(runOptions);
+        break;
+      } catch (err) {
+        if (ctx.signal.aborted)
+          throw err;
+        const msg = err instanceof Error ? err.message : String(err);
+        const salvaged = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
+        if (salvaged.length > 0)
+          baseBranch = tempBranch;
+        if (ticketAbort.signal.aborted) {
+          if (salvaged.length > 0)
+            preserveChain(tempBranch);
+          return {
+            status: "failed",
+            error: `stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved; retry to continue from them` : ""}`,
+            event: {
+              type: "ticket.stopped",
+              message: `ticket ${ticket.seq} stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved for retry` : ""}`
+            }
+          };
+        }
+        if (isMergeConflictError(err)) {
+          return {
+            status: "failed",
+            error: `merge conflict landing ticket ${ticket.seq} on ${feature.branch}: ${msg}`,
+            event: {
+              type: "merge.conflict.needs-human",
+              message: `ticket ${ticket.seq}: merge conflict on ${feature.branch} \u2014 resolve manually per the error, then re-burn`
+            }
+          };
+        }
+        if (classifyTicketRunError(err) === "retryable" && attempt < maxAttempts) {
+          const headline = errorHeadline(msg);
+          retryNotes = buildRetryNotes({ error: headline, commitCount: salvaged.length });
+          ctx.emitEvent({
+            type: "ticket.retrying",
+            message: `ticket ${ticket.seq} attempt ${attempt}/${maxAttempts} died (${headline}) \u2014 retrying${salvaged.length > 0 ? ` from ${salvaged.length} preserved commit(s)` : ""}`,
+            ticketId: ticket.id,
+            data: { attempt, maxAttempts, error: msg, preservedCommits: salvaged.length }
+          });
+          appendTranscript(ticket.id, {
+            kind: "text",
+            text: `
+\u2014 attempt ${attempt} interrupted (${headline}); starting attempt ${attempt + 1}${salvaged.length > 0 ? " with committed work preserved" : ""} \u2014
+`
+          });
+          await delayUnlessAborted(retryDelayMs(attempt), signal);
+          ctx.signal.throwIfAborted();
+          if (ticketAbort.signal.aborted) {
+            if (salvaged.length > 0)
+              preserveChain(tempBranch);
+            return {
+              status: "failed",
+              error: `stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved; retry to continue from them` : ""}`,
+              event: {
+                type: "ticket.stopped",
+                message: `ticket ${ticket.seq} stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved for retry` : ""}`
+              }
+            };
+          }
+          continue;
+        }
+        if (salvaged.length > 0)
+          preserveChain(tempBranch);
+        return { status: "failed", error: msg };
+      }
     }
-    return { status: "failed", error: msg };
-  }
-  throttle.flush();
-  endTranscript(ticket.id);
-  const blocked = readBlockedFile([result.preservedWorktreePath, project.repoPath]);
-  const outcome = interpretRunResult(result, blocked);
-  if (outcome.status !== "done")
-    return outcome;
-  const merge = await land(() => mergeTempBranch(project.repoPath, feature.branch, tempBranch));
-  if (!merge.ok) {
-    const detail = merge.error ?? "merge failed";
-    if (merge.conflict) {
+    if (!result)
+      return { status: "failed", error: "internal: run loop produced no result" };
+    const blocked = readBlockedFile([result.preservedWorktreePath, project.repoPath]);
+    const chain = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
+    let outcome;
+    if (result.commits.length === 0 && blocked !== undefined && blocked.trim().length > 0) {
+      outcome = { status: "failed", error: `agent reported BLOCKED:
+${blocked.trim()}` };
+    } else if (chain.length > 0) {
+      outcome = { status: "done", commits: chain };
+    } else {
+      outcome = interpretRunResult(result, blocked);
+    }
+    if (outcome.status !== "done") {
+      if (chain.length > 0)
+        preserveChain(tempBranch);
+      return outcome;
+    }
+    const merge = await land(() => mergeTempBranch(project.repoPath, feature.branch, tempBranch));
+    if (!merge.ok) {
+      const detail = merge.error ?? "merge failed";
+      if (merge.conflict) {
+        return {
+          status: "failed",
+          error: `ticket ${ticket.seq} committed to ${tempBranch} but landing on ${feature.branch} hit a conflict: ${detail}`,
+          event: {
+            type: "merge.conflict.needs-human",
+            message: `ticket ${ticket.seq}: ${tempBranch} conflicts with ${feature.branch} \u2014 merge it manually (git merge ${tempBranch}; resolve; git branch -D ${tempBranch}), then re-burn`
+          }
+        };
+      }
+      preserveChain(tempBranch);
       return {
         status: "failed",
-        error: `ticket ${ticket.seq} committed to ${tempBranch} but landing on ${feature.branch} hit a conflict: ${detail}`,
-        event: {
-          type: "merge.conflict.needs-human",
-          message: `ticket ${ticket.seq}: ${tempBranch} conflicts with ${feature.branch} \u2014 merge it manually (git merge ${tempBranch}; resolve; git branch -D ${tempBranch}), then re-burn`
-        }
+        error: `ticket ${ticket.seq} committed to ${tempBranch} but landing on ${feature.branch} failed: ${errorHeadline(detail)} \u2014 the branch is preserved for manual recovery`
       };
     }
-    return {
-      status: "failed",
-      error: `ticket ${ticket.seq} committed to ${tempBranch} but landing on ${feature.branch} failed: ${errorHeadline(detail)} \u2014 the branch is preserved for manual recovery`
-    };
+    if (ticket.attemptBranch)
+      ctx.updateTicket(ticket.id, { attemptBranch: null });
+    return outcome;
+  } finally {
+    activeTicketAborts.delete(ticket.id);
+    throttle.flush();
+    endTranscript(ticket.id);
   }
-  return outcome;
 }
 function resolveBurnDeps(ctx) {
   const config2 = loadConfig();
@@ -3196,7 +3400,7 @@ function readTokenFromEnvFile(path) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
   return token && token.length > 0 ? token : undefined;
 }
-var AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", SETUP_HOOK_TIMEOUT_MS, ticketBurner;
+var AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
@@ -3217,6 +3421,25 @@ var init_ticket_burner = __esm(() => {
     yarn: "~/.cache/yarn",
     npm: "~/.npm"
   };
+  FATAL_ERROR_PATTERNS = [
+    /invalid (api key|x-api-key)/i,
+    /authentication|unauthorized|permission denied/i,
+    /credit balance|billing/i,
+    /oauth token|setup-token/i,
+    /issue with the selected model|model not found|unknown model/i,
+    /does not support resumeSession|resumeSession .* not found/i
+  ];
+  RETRYABLE_ERROR_PATTERNS = [
+    /exited with code \d+/i,
+    /idle timeout|AgentIdleTimeout/i,
+    /connection (closed|error|refused|reset)|socket hang up|fetch failed/i,
+    /econnreset|etimedout|econnrefused|epipe|eai_again/i,
+    /overloaded|rate.?limit|too many requests/i,
+    /internal server error|service unavailable|bad gateway|gateway timeout/i,
+    /\bapi error\b/i,
+    /session capture failed/i
+  ];
+  activeTicketAborts = new Map;
   SETUP_HOOK_TIMEOUT_MS = 15 * 60000;
   ticketBurner = {
     id: "ticket-burner",
@@ -3660,7 +3883,7 @@ async function burn(ctx, featureId, opts = {}) {
     throw new GateError(tickets2.length > 0 ? "no burnable tickets \u2014 every ticket is cancelled" : "no tickets to burn");
   }
   if (restarting) {
-    const failed = tickets2.filter((t) => t.status === "failed");
+    const failed = opts.resetFailed === false ? [] : tickets2.filter((t) => t.status === "failed");
     for (const t of failed) {
       updateTicket(ctx, t.id, { status: "pending", error: null });
     }
@@ -3677,6 +3900,69 @@ async function burn(ctx, featureId, opts = {}) {
   });
   return { runId };
 }
+async function retryTicket(ctx, ticketId, opts = {}) {
+  const ticket = getTicket(ctx, ticketId);
+  const feature = getFeatureRow(ctx, ticket.featureId);
+  if (ticket.status !== "failed") {
+    throw new GateError(`only failed tickets can be retried \u2014 ticket ${ticket.seq} is ${ticket.status}`);
+  }
+  if (hasActiveRun(ctx, feature.id)) {
+    throw new GateError("a run is live for this feature \u2014 retry after it finishes, or cancel it first");
+  }
+  const project = projectForFeature(ctx, feature);
+  const all = listByFeature2(ctx, feature.id);
+  const bySeq = new Map(all.map((t) => [t.seq, t]));
+  const toReset = new Map([[ticket.seq, ticket]]);
+  const queue = [ticket.seq];
+  while (queue.length > 0) {
+    const t = bySeq.get(queue.shift());
+    if (!t)
+      continue;
+    for (const b of t.blockedBy) {
+      const blocker = bySeq.get(b);
+      if (blocker && blocker.status === "failed" && !toReset.has(blocker.seq)) {
+        toReset.set(blocker.seq, blocker);
+        queue.push(blocker.seq);
+      }
+    }
+  }
+  let resumedFrom = ticket.attemptBranch ?? null;
+  let preservedCommits = 0;
+  if (opts.fresh) {
+    const discard = new Set(await listTicketAttemptBranches(project.repoPath, feature.slug, ticket.seq));
+    if (ticket.attemptBranch)
+      discard.add(ticket.attemptBranch);
+    for (const b of discard)
+      await deleteTempBranch(project.repoPath, b);
+    resumedFrom = null;
+  } else if (resumedFrom) {
+    preservedCommits = (await branchCommitsAhead(project.repoPath, feature.branch, resumedFrom)).length;
+  } else {
+    const found = await findPreservedTicketBranch(project.repoPath, feature.branch, feature.slug, ticket.seq);
+    if (found) {
+      resumedFrom = found.branch;
+      preservedCommits = found.commits.length;
+    }
+  }
+  for (const t of toReset.values()) {
+    const isTarget = t.id === ticket.id;
+    updateTicket(ctx, t.id, {
+      status: "pending",
+      error: null,
+      ...isTarget ? { attemptBranch: resumedFrom } : {}
+    });
+  }
+  const seqs = [...toReset.keys()].sort((a, b) => a - b);
+  const how = opts.fresh ? " from scratch" : resumedFrom ? ` from ${preservedCommits} preserved commit(s) on ${resumedFrom}` : "";
+  emit(ctx, feature.id, {
+    type: "ticket.retry",
+    message: seqs.length > 1 ? `retrying ticket ${ticket.seq}${how} (+ failed blocker${seqs.length > 2 ? "s" : ""} ${seqs.filter((s) => s !== ticket.seq).join(", ")})` : `retrying ticket ${ticket.seq}${how}`,
+    ticketId: ticket.id,
+    data: { retried: seqs, fresh: !!opts.fresh, resumedFrom, preservedCommits }
+  });
+  const { runId } = await burn(ctx, feature.id, { resetFailed: false });
+  return { runId, retried: seqs, resumedFrom, preservedCommits };
+}
 function escalateToMap(ctx, featureId, input) {
   const feature = getFeatureRow(ctx, featureId);
   if (feature.mapped) {
@@ -5359,6 +5645,14 @@ var init_settings = __esm(() => {
       valueSchema: z9.number().int().min(1).max(10),
       parseEnv: (raw) => Number(raw)
     },
+    {
+      key: "burnAttempts",
+      configKey: "burnAttempts",
+      envVar: "RUNCASTLE_BURN_ATTEMPTS",
+      restartRequired: false,
+      valueSchema: z9.number().int().min(1).max(5),
+      parseEnv: (raw) => Number(raw)
+    },
     {
       key: "setupCommand",
       configKey: "setupCommand",
@@ -5904,6 +6198,21 @@ var init_system = __esm(() => {
   });
 });
 
+// src/trpc/routers/ticket.ts
+import * as z12 from "zod";
+var ticketRouter;
+var init_ticket = __esm(() => {
+  init_features();
+  init_tickets();
+  init_ticket_burner();
+  init_context();
+  ticketRouter = router({
+    retry: publicProcedure.input(z12.object({ ticketId: z12.string(), fresh: z12.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
+    stop: publicProcedure.input(z12.object({ ticketId: z12.string() })).mutation(({ input }) => ({ stopped: stopTicketRun(input.ticketId) })),
+    cancel: publicProcedure.input(z12.object({ ticketId: z12.string(), reason: z12.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason))
+  });
+});
+
 // src/trpc/router.ts
 var appRouter;
 var init_router = __esm(() => {
@@ -5916,10 +6225,12 @@ var init_router = __esm(() => {
   init_settings2();
   init_setup2();
   init_system();
+  init_ticket();
   appRouter = router({
     project: projectRouter,
     feature: featureRouter,
     run: runRouter,
+    ticket: ticketRouter,
     events: eventsRouter,
     docs: docsRouter,
     settings: settingsRouter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcastle",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Burn tickets into shipped features with Claude Code.",
   "license": "MIT",
   "type": "module",