runcastle 1.0.21 → 1.0.23

package/bin/runcastle.js

@@ -107,6 +107,7 @@ var init_config = __esm(() => {
     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),
+    burnConflictAttempts: z.number().int().min(0).max(3).default(2),
     setupCommand: z.string().optional(),
     burnWorkspace: z.enum(["auto", "mounted", "isolated"]).default("auto")
   }));
@@ -150,6 +151,9 @@ function loadConfig(env = process.env) {
   if (env.RUNCASTLE_BURN_ATTEMPTS) {
     overrides.burnAttempts = Number(env.RUNCASTLE_BURN_ATTEMPTS);
   }
+  if (env.RUNCASTLE_BURN_CONFLICT_ATTEMPTS !== undefined) {
+    overrides.burnConflictAttempts = Number(env.RUNCASTLE_BURN_CONFLICT_ATTEMPTS);
+  }
   if (env.RUNCASTLE_SETUP_COMMAND)
     overrides.setupCommand = env.RUNCASTLE_SETUP_COMMAND;
   if (env.RUNCASTLE_BURN_WORKSPACE)
@@ -216,7 +220,8 @@ var init_schemas = __esm(() => {
     status: TicketStatus,
     commits: z2.array(z2.string()),
     error: z2.string().optional(),
-    attemptBranch: z2.string().optional()
+    attemptBranch: z2.string().optional(),
+    conflictFiles: z2.array(z2.string()).optional()
   });
   WaypointType = z2.enum(["grilling", "research", "prototype", "task"]);
   WaypointStatus = z2.enum(["open", "claimed", "resolved", "dropped"]);
@@ -491,7 +496,8 @@ var init_db_schema = __esm(() => {
     status: text("status").notNull().$type(),
     commits: text("commits", { mode: "json" }).notNull().$type(),
     error: text("error"),
-    attemptBranch: text("attempt_branch")
+    attemptBranch: text("attempt_branch"),
+    conflictFiles: text("conflict_files", { mode: "json" }).$type()
   });
   waypoints = sqliteTable("waypoints", {
     id: text("id").primaryKey(),
@@ -1707,7 +1713,8 @@ function rowToTicket(row) {
     status: row.status,
     commits: row.commits,
     error: row.error ?? undefined,
-    attemptBranch: row.attemptBranch ?? undefined
+    attemptBranch: row.attemptBranch ?? undefined,
+    conflictFiles: row.conflictFiles ?? undefined
   };
 }
 function resolveBlocking(inputs, startSeq) {
@@ -1741,7 +1748,8 @@ function storeTickets(ctx, featureId, inputs) {
     status: "pending",
     commits: [],
     error: null,
-    attemptBranch: null
+    attemptBranch: null,
+    conflictFiles: null
   }));
   ctx.db.insert(tickets).values(rows).run();
   emit(ctx, featureId, {
@@ -1813,6 +1821,8 @@ function updateTicket(ctx, id, patch) {
     set.error = patch.error;
   if (patch.attemptBranch !== undefined)
     set.attemptBranch = patch.attemptBranch;
+  if (patch.conflictFiles !== undefined)
+    set.conflictFiles = patch.conflictFiles;
   ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.updated",
@@ -2190,6 +2200,34 @@ function researchBranchName(slug, waypointSeq, unique) {
 function ticketBranchName(slug, ticketSeq, unique) {
   return `${TICKET_BRANCH_PREFIX}${tempBranchSlugSegment(slug)}/${ticketSeq}-${unique}`;
 }
+function burnWorktreePath(repoPath, branch) {
+  return join6(repoPath, ".sandcastle", "worktrees", branch.replace(/\//g, "-"));
+}
+async function cleanupBurnWorktree(repoPath, branch, opts = {}) {
+  const path = burnWorktreePath(repoPath, branch);
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const delayMs = opts.delayMs ?? 750;
+  const g = git(repoPath);
+  for (let attempt = 1;attempt <= attempts && existsSync7(path); attempt++) {
+    try {
+      await g.raw(["worktree", "remove", "--force", path]);
+    } catch {}
+    if (existsSync7(path) && attempt < attempts)
+      await sleep(delayMs);
+  }
+  if (existsSync7(path)) {
+    try {
+      rmSync(path, { recursive: true, force: true });
+    } catch {}
+  }
+  try {
+    await g.raw(["worktree", "prune"]);
+  } catch {}
+  return !existsSync7(path);
+}
+function sleep(ms) {
+  return new Promise((done) => setTimeout(done, ms));
+}
 async function branchCommitsAhead(repoPath, base, branch) {
   try {
     const out = await git(repoPath).raw(["rev-list", "--reverse", `${base}..${branch}`]);
@@ -2199,6 +2237,20 @@ async function branchCommitsAhead(repoPath, base, branch) {
     return [];
   }
 }
+async function commitSummaries(repoPath, base, branch, limit = 20) {
+  try {
+    const out = await git(repoPath).raw([
+      "log",
+      `--max-count=${limit}`,
+      "--format=%h %s",
+      `${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);
@@ -2261,8 +2313,9 @@ async function mergeTempBranch(repoPath, featureBranchName, tempBranch) {
       await gw.merge([tempBranch]);
     } catch (e) {
       if (await mergeInProgress(gw)) {
+        const files = await conflictedFiles(gw);
         await gw.raw(["merge", "--abort"]);
-        return { ok: false, conflict: true, error: errMsg(e) };
+        return { ok: false, conflict: true, files, error: errMsg(e) };
       }
       return { ok: false, error: errMsg(e) };
     }
@@ -2293,8 +2346,9 @@ async function mergeInDisposableWorktree(g, featureBranchName, tempBranch) {
       await gw.merge([tempBranch]);
     } catch (e) {
       if (await mergeInProgress(gw)) {
+        const files = await conflictedFiles(gw);
         await gw.raw(["merge", "--abort"]);
-        return { ok: false, conflict: true, error: errMsg(e) };
+        return { ok: false, conflict: true, files, error: errMsg(e) };
       }
       return { ok: false, error: errMsg(e) };
     }
@@ -2811,13 +2865,16 @@ function detectCycle(tickets2) {
   }
   return null;
 }
-function renderTicketPrompt(template, values) {
+function renderTemplate(template, values) {
   let out = template;
-  for (const key of PLACEHOLDERS) {
-    out = out.split(`{{${key}}}`).join(values[key]);
+  for (const [key, value] of Object.entries(values)) {
+    out = out.split(`{{${key}}}`).join(value);
   }
   return out;
 }
+function renderTicketPrompt(template, values) {
+  return renderTemplate(template, values);
+}
 function buildTicketJson(ticket) {
   return JSON.stringify({
     seq: ticket.seq,
@@ -2851,6 +2908,23 @@ ${f.content.trim()}`).join(`
 
 `);
 }
+function buildConflictFilesBlock(files) {
+  if (files.length === 0) {
+    return "_git did not report the paths \u2014 run `git status` after starting the merge to see them._";
+  }
+  return files.map((f) => `- \`${f}\``).join(`
+`);
+}
+function buildOtherSideBlock(summaries) {
+  if (summaries.length === 0) {
+    return "_No commit summaries available \u2014 inspect `git log` on the feature branch._";
+  }
+  return summaries.map((s) => `- ${s}`).join(`
+`);
+}
+function resolveMergeCommand(mode, featureBranch2) {
+  return mode === "mounted" ? `git merge --no-edit ${featureBranch2}` : `git fetch origin ${featureBranch2} && git merge --no-edit FETCH_HEAD`;
+}
 function parseEnvFile(content) {
   const out = {};
   for (const rawLine of content.split(/\r?\n/)) {
@@ -3012,6 +3086,12 @@ ${blockedContent.trim()}` };
   }
   return { status: "failed", error: "agent made no commits" };
 }
+function isWorktreeTeardownError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+  if (!BURN_WORKTREE_PATH.test(msg))
+    return false;
+  return WORKTREE_REMOVAL_FAILURES.some((p) => p.test(msg));
+}
 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);
@@ -3075,6 +3155,42 @@ function createSerialQueue() {
     return next;
   };
 }
+async function landWithResolve(branch, deps) {
+  let current2 = branch;
+  for (let attempt = 1;; attempt++) {
+    const merge = await deps.merge(current2);
+    if (merge.ok)
+      return { status: "landed", branch: current2 };
+    const detail = merge.error ?? "merge failed";
+    if (!merge.conflict)
+      return { status: "failed", branch: current2, error: detail };
+    const files = merge.files ?? [];
+    if (attempt > deps.maxResolveAttempts) {
+      return { status: "conflict", branch: current2, files, error: detail };
+    }
+    const where = files.length > 0 ? `${files.length} file(s)` : "the merge";
+    deps.emit({
+      type: "merge.conflict.resolving",
+      message: `${deps.label}: conflicts with ${deps.featureBranch} on ${where} \u2014 resolving with an agent (pass ${attempt}/${deps.maxResolveAttempts})`,
+      data: { branch: current2, files, attempt, maxAttempts: deps.maxResolveAttempts }
+    });
+    const resolved = await deps.resolve({
+      branch: current2,
+      files,
+      attempt,
+      maxAttempts: deps.maxResolveAttempts
+    });
+    current2 = resolved.branch;
+    if (!resolved.ok) {
+      return { status: "conflict", branch: current2, files, error: resolved.error ?? detail };
+    }
+    deps.emit({
+      type: "merge.conflict.resolved",
+      message: `${deps.label}: conflict resolved on ${current2} \u2014 landing`,
+      data: { branch: current2, files, attempt }
+    });
+  }
+}
 function errorHeadline(s) {
   const lines = s.split(`
 `).map((l) => l.trim()).filter(Boolean);
@@ -3222,8 +3338,14 @@ async function burnRun(ctx, deps) {
   return { status: done === total ? "succeeded" : "failed", summary };
 }
 function burnerTemplatePath() {
+  return burnerAssetPath("implement-ticket.md");
+}
+function resolverTemplatePath() {
+  return burnerAssetPath("resolve-conflict.md");
+}
+function burnerAssetPath(file) {
   const here = dirname3(fileURLToPath2(import.meta.url));
-  return join9(resolveSkillsRoot(here), "burner", "implement-ticket.md");
+  return join9(resolveSkillsRoot(here), "burner", file);
 }
 function readDocsDigestFromDisk(projectId, slug) {
   const worktree = worktreeDir(projectId, slug);
@@ -3287,13 +3409,16 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const workspaceMode = resolveBurnWorkspaceMode(config2);
   if (workspaceMode === "isolated")
     await ensureIsolatedPushTarget();
-  const template = readFileSync4(burnerTemplatePath(), "utf8");
-  const basePrompt = renderTicketPrompt(template, {
-    TICKET_JSON: buildTicketJson(ticket),
-    FEATURE_BRIEF: buildFeatureBrief(feature),
-    DOCS_DIGEST: readDocsDigestFromDisk(project.id, feature.slug),
+  const ticketJson = buildTicketJson(ticket);
+  const featureBrief = buildFeatureBrief(feature);
+  const docsDigest = readDocsDigestFromDisk(project.id, feature.slug);
+  const workspaceNotes = buildWorkspaceNotes(workspaceMode);
+  const basePrompt = renderTicketPrompt(readFileSync4(burnerTemplatePath(), "utf8"), {
+    TICKET_JSON: ticketJson,
+    FEATURE_BRIEF: featureBrief,
+    DOCS_DIGEST: docsDigest,
     COMMIT_CONVENTION: `ticket(${ticket.seq}): <summary>`,
-    WORKSPACE_NOTES: buildWorkspaceNotes(workspaceMode)
+    WORKSPACE_NOTES: workspaceNotes
   });
   const toolchain = readRepoToolchain(project.repoPath);
   const pm = detectPackageManager(toolchain);
@@ -3326,9 +3451,10 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   activeTicketAborts.set(ticket.id, ticketAbort);
   const signal = AbortSignal.any([ctx.signal, ticketAbort.signal]);
   const maxAttempts = Math.max(1, config2.burnAttempts);
+  const conflictResume = ticket.conflictFiles !== undefined && !!ticket.attemptBranch;
   let baseBranch = feature.branch;
   let retryNotes;
-  if (ticket.attemptBranch) {
+  if (ticket.attemptBranch && !conflictResume) {
     const preserved = await branchCommitsAhead(project.repoPath, feature.branch, ticket.attemptBranch);
     if (preserved.length > 0) {
       baseBranch = ticket.attemptBranch;
@@ -3347,7 +3473,145 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const preserveChain = (branch) => {
     ctx.updateTicket(ticket.id, { attemptBranch: branch });
   };
+  const runResolver = async (input) => {
+    const resolveBranch = ticketBranchName(feature.slug, ticket.seq, newId("r").slice(2, 10));
+    const otherSide = await commitSummaries(project.repoPath, input.branch, feature.branch);
+    const prompt = renderTemplate(readFileSync4(resolverTemplatePath(), "utf8"), {
+      TICKET_JSON: ticketJson,
+      FEATURE_BRIEF: featureBrief,
+      DOCS_DIGEST: docsDigest,
+      WORKSPACE_NOTES: workspaceNotes,
+      FEATURE_BRANCH: feature.branch,
+      CONFLICT_FILES: buildConflictFilesBlock(input.files),
+      OTHER_SIDE: buildOtherSideBlock(otherSide),
+      MERGE_COMMAND: resolveMergeCommand(workspaceMode, feature.branch)
+    });
+    const hookCommand = workspaceMode === "isolated" ? buildIsolatedSetupCommand(resolveBranch, setupCommand, pm) : setupCommand;
+    appendTranscript(ticket.id, {
+      kind: "text",
+      text: `
+\u2014 landing conflict on ${feature.branch}; resolver pass ${input.attempt}/${input.maxAttempts} \u2014
+`
+    });
+    const bestTip = async () => {
+      const made = await branchCommitsAhead(project.repoPath, input.branch, resolveBranch);
+      return made.length > 0 ? resolveBranch : input.branch;
+    };
+    let result;
+    try {
+      result = await run({
+        agent: buildBurnAgent(config2, token, model),
+        sandbox: selectSandbox(config2, mounts),
+        cwd: project.repoPath,
+        prompt,
+        branchStrategy: { type: "branch", branch: resolveBranch, baseBranch: input.branch },
+        signal,
+        name: `ticket-${ticket.seq}-resolve`,
+        maxIterations: config2.burnMaxIterations,
+        ...hookCommand ? {
+          hooks: {
+            sandbox: {
+              onSandboxReady: [{ command: hookCommand, timeoutMs: SETUP_HOOK_TIMEOUT_MS }]
+            }
+          }
+        } : {},
+        logging: { type: "file", path: logFilePath, onAgentStreamEvent: onStreamEvent }
+      });
+    } catch (err) {
+      if (ctx.signal.aborted)
+        throw err;
+      const tip = await bestTip();
+      const teardownOnly = !ticketAbort.signal.aborted && isWorktreeTeardownError(err) && tip === resolveBranch;
+      if (!teardownOnly) {
+        return {
+          ok: false,
+          branch: tip,
+          error: ticketAbort.signal.aborted ? "stopped by user during conflict resolution" : errorHeadline(err instanceof Error ? err.message : String(err))
+        };
+      }
+      await cleanupBurnWorktree(project.repoPath, resolveBranch);
+    }
+    const blocked = readBlockedFile([result?.preservedWorktreePath, project.repoPath]);
+    if (blocked !== undefined && blocked.trim().length > 0) {
+      return {
+        ok: false,
+        branch: await bestTip(),
+        error: `resolver reported BLOCKED:
+${blocked.trim()}`
+      };
+    }
+    const missing = await branchCommitsAhead(project.repoPath, resolveBranch, feature.branch);
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        branch: await bestTip(),
+        error: `resolver did not complete the merge \u2014 ${missing.length} commit(s) of ${feature.branch} are still missing from the branch`
+      };
+    }
+    return { ok: true, branch: resolveBranch };
+  };
+  let landedCommits = [];
+  const landDeps = {
+    merge: (branch) => land(async () => {
+      const ahead = await branchCommitsAhead(project.repoPath, feature.branch, branch);
+      const res = await mergeTempBranch(project.repoPath, feature.branch, branch);
+      if (res.ok)
+        landedCommits = ahead;
+      return res;
+    }),
+    resolve: runResolver,
+    maxResolveAttempts: Math.max(0, config2.burnConflictAttempts),
+    emit: (e) => ctx.emitEvent({ ...e, ticketId: ticket.id }),
+    label: `ticket ${ticket.seq}`,
+    featureBranch: feature.branch
+  };
+  const landChain = async (branch, commits) => {
+    const landing = await landWithResolve(branch, landDeps);
+    if (landing.status === "landed") {
+      ctx.updateTicket(ticket.id, { attemptBranch: null, conflictFiles: null });
+      return { status: "done", commits: landedCommits.length > 0 ? landedCommits : commits };
+    }
+    preserveChain(landing.branch);
+    if (landing.status === "conflict") {
+      ctx.updateTicket(ticket.id, { conflictFiles: landing.files });
+      const where = landing.files.length > 0 ? ` on ${landing.files.length} file(s): ${landing.files.join(", ")}` : "";
+      const why = landDeps.maxResolveAttempts === 0 ? `Automatic resolution is off (burnConflictAttempts = 0): ${errorHeadline(landing.error)}` : `The automatic resolver could not finish: ${errorHeadline(landing.error)}`;
+      return {
+        status: "failed",
+        error: `ticket ${ticket.seq} is implemented on ${landing.branch} but conflicts with ${feature.branch}${where}. ${why}`,
+        event: {
+          type: "merge.conflict.needs-human",
+          message: `ticket ${ticket.seq}: could not auto-resolve the conflict with ${feature.branch} \u2014 resolve it from the run lane`
+        }
+      };
+    }
+    return {
+      status: "failed",
+      error: `ticket ${ticket.seq} committed to ${landing.branch} but landing on ${feature.branch} failed: ${errorHeadline(landing.error)} \u2014 the branch is preserved for manual recovery`
+    };
+  };
   try {
+    if (conflictResume) {
+      const branch = ticket.attemptBranch;
+      const pending = await branchCommitsAhead(project.repoPath, feature.branch, branch);
+      if (pending.length === 0) {
+        ctx.updateTicket(ticket.id, { attemptBranch: null, conflictFiles: null });
+        ctx.emitEvent({
+          type: "merge.conflict.resolved",
+          message: `ticket ${ticket.seq}: ${branch} is already merged into ${feature.branch} \u2014 nothing left to land`,
+          ticketId: ticket.id,
+          data: { branch }
+        });
+        return { status: "done", commits: ticket.commits };
+      }
+      ctx.emitEvent({
+        type: "ticket.resuming",
+        message: `ticket ${ticket.seq}: implemented on ${branch} \u2014 retrying the landing (${pending.length} commit(s))`,
+        ticketId: ticket.id,
+        data: { attemptBranch: branch, preservedCommits: pending.length, conflict: true }
+      });
+      return await landChain(branch, pending);
+    }
     let result;
     let tempBranch = "";
     for (let attempt = 1;; attempt++) {
@@ -3402,13 +3666,29 @@ ${retryNotes}` : basePrompt,
             }
           };
         }
+        if (isWorktreeTeardownError(err)) {
+          const removed = await cleanupBurnWorktree(project.repoPath, tempBranch);
+          if (salvaged.length > 0) {
+            ctx.emitEvent({
+              type: "burn.worktree.teardown-failed",
+              message: `ticket ${ticket.seq}: agent finished but sandcastle could not remove its worktree (${errorHeadline(msg)})${removed ? " \u2014 cleaned up" : " \u2014 left on disk"}; landing the ${salvaged.length} commit(s) anyway`,
+              ticketId: ticket.id,
+              data: { branch: tempBranch, error: msg, cleanedUp: removed }
+            });
+            return await landChain(tempBranch, salvaged);
+          }
+        }
         if (isMergeConflictError(err)) {
+          if (salvaged.length > 0) {
+            preserveChain(tempBranch);
+            ctx.updateTicket(ticket.id, { conflictFiles: [] });
+          }
           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`
+              message: `ticket ${ticket.seq}: merge conflict on ${feature.branch}${salvaged.length > 0 ? " \u2014 resolve it from the run lane" : " \u2014 resolve manually per the error, then re-burn"}`
             }
           };
         }
@@ -3466,28 +3746,7 @@ ${blocked.trim()}` };
         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} failed: ${errorHeadline(detail)} \u2014 the branch is preserved for manual recovery`
-      };
-    }
-    if (ticket.attemptBranch)
-      ctx.updateTicket(ticket.id, { attemptBranch: null });
-    return outcome;
+    return await landChain(tempBranch, outcome.commits);
   } finally {
     activeTicketAborts.delete(ticket.id);
     throttle.flush();
@@ -3520,7 +3779,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", FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, 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", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
@@ -3528,19 +3787,20 @@ var init_ticket_burner = __esm(() => {
   init_skills_root();
   init_agent_stream();
   init_git();
-  PLACEHOLDERS = [
-    "TICKET_JSON",
-    "FEATURE_BRIEF",
-    "DOCS_DIGEST",
-    "COMMIT_CONVENTION",
-    "WORKSPACE_NOTES"
-  ];
   PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
   PM_CACHE_SANDBOX_PATHS = {
     bun: "~/.bun/install/cache",
     yarn: "~/.cache/yarn",
     npm: "~/.npm"
   };
+  BURN_WORKTREE_PATH = /[\\/]\.sandcastle[\\/]worktrees[\\/]/i;
+  WORKTREE_REMOVAL_FAILURES = [
+    /failed to delete/i,
+    /directory not empty|enotempty/i,
+    /unable to (unlink|delete)/i,
+    /is not a working tree/i,
+    /resource busy|ebusy|eperm|eacces/i
+  ];
   FATAL_ERROR_PATTERNS = [
     /invalid (api key|x-api-key)/i,
     /authentication|unauthorized|permission denied/i,
@@ -3625,7 +3885,7 @@ function createResearchStreamThrottle(emit2, opts = {}) {
 }
 function renderResearchPrompt(template, values) {
   let out = template;
-  for (const key of PLACEHOLDERS2) {
+  for (const key of PLACEHOLDERS) {
     out = out.split(`{{${key}}}`).join(values[key]);
   }
   return out;
@@ -3678,16 +3938,26 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
     logging: { type: "file", path: logFilePath, onAgentStreamEvent: throttle.onEvent }
   };
   let result;
+  let salvaged = [];
   try {
     result = await run2(runOptions);
   } catch (err) {
     throttle.flush();
     if (ctx.signal.aborted)
       throw err;
-    return { status: "failed", error: err instanceof Error ? err.message : String(err) };
+    const msg = err instanceof Error ? err.message : String(err);
+    salvaged = isWorktreeTeardownError(err) ? await branchCommitsAhead(project.repoPath, feature.branch, tempBranch) : [];
+    if (salvaged.length === 0)
+      return { status: "failed", error: msg };
+    const removed = await cleanupBurnWorktree(project.repoPath, tempBranch);
+    ctx.emitEvent({
+      type: "burn.worktree.teardown-failed",
+      message: `waypoint ${waypoint.seq}: agent finished but sandcastle could not remove its worktree (${errorHeadline2(msg)})${removed ? " \u2014 cleaned up" : " \u2014 left on disk"}; landing the ${salvaged.length} commit(s) anyway`,
+      data: { tempBranch, error: msg, cleanedUp: removed }
+    });
   }
   throttle.flush();
-  const outcome = interpretResearchResult(result, docRelPath);
+  const outcome = result ? interpretResearchResult(result, docRelPath) : { status: "done", commits: salvaged, docRelPath };
   if (outcome.status !== "done")
     return outcome;
   const merge = await mergeTempBranch(project.repoPath, feature.branch, tempBranch);
@@ -3727,7 +3997,7 @@ function readTokenFromEnvFile2(path) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
   return token && token.length > 0 ? token : undefined;
 }
-var AUTH_MISSING_EVENT2 = "auth.missing", AUTH_MISSING_MESSAGE2 = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS2, research;
+var AUTH_MISSING_EVENT2 = "auth.missing", AUTH_MISSING_MESSAGE2 = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, research;
 var init_research = __esm(() => {
   init_src();
   init_config_load();
@@ -3735,7 +4005,7 @@ var init_research = __esm(() => {
   init_skills_root();
   init_git();
   init_ticket_burner();
-  PLACEHOLDERS2 = ["WAYPOINT_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "RESEARCH_DOC_PATH"];
+  PLACEHOLDERS = ["WAYPOINT_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "RESEARCH_DOC_PATH"];
   research = {
     id: "research",
     run: (ctx) => researchRun(ctx, resolveResearchDeps(ctx))
@@ -4075,24 +4345,26 @@ async function retryTicket(ctx, ticketId, opts = {}) {
       preservedCommits = found.commits.length;
     }
   }
+  const resolvingConflict = !opts.fresh && ticket.conflictFiles !== undefined && !!resumedFrom;
   for (const t of toReset.values()) {
     const isTarget = t.id === ticket.id;
     updateTicket(ctx, t.id, {
       status: "pending",
       error: null,
-      ...isTarget ? { attemptBranch: resumedFrom } : {}
+      ...isTarget ? { attemptBranch: resumedFrom } : {},
+      ...isTarget && !resolvingConflict ? { conflictFiles: null } : {}
     });
   }
   const seqs = [...toReset.keys()].sort((a, b) => a - b);
-  const how = opts.fresh ? " from scratch" : resumedFrom ? ` from ${preservedCommits} preserved commit(s) on ${resumedFrom}` : "";
+  const how = opts.fresh ? " from scratch" : resolvingConflict ? ` \u2014 resolving its conflict with ${feature.branch} (${preservedCommits} commit(s) preserved on ${resumedFrom})` : 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 }
+    data: { retried: seqs, fresh: !!opts.fresh, resumedFrom, preservedCommits, resolvingConflict }
   });
   const { runId } = await burn(ctx, feature.id, { resetFailed: false });
-  return { runId, retried: seqs, resumedFrom, preservedCommits };
+  return { runId, retried: seqs, resumedFrom, preservedCommits, resolvingConflict };
 }
 function escalateToMap(ctx, featureId, input) {
   const feature = getFeatureRow(ctx, featureId);
@@ -6053,6 +6325,14 @@ var init_settings = __esm(() => {
       valueSchema: z9.number().int().min(1).max(5),
       parseEnv: (raw) => Number(raw)
     },
+    {
+      key: "burnConflictAttempts",
+      configKey: "burnConflictAttempts",
+      envVar: "RUNCASTLE_BURN_CONFLICT_ATTEMPTS",
+      restartRequired: false,
+      valueSchema: z9.number().int().min(0).max(3),
+      parseEnv: (raw) => Number(raw)
+    },
     {
       key: "setupCommand",
       configKey: "setupCommand",

package/drizzle/0009_pale_agent_zero.sql

@@ -0,0 +1 @@
+ALTER TABLE `tickets` ADD `conflict_files` text;