runcastle 1.0.21 → 1.0.22

package/index.js

@@ -106,6 +106,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")
   }));
@@ -149,6 +150,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)
@@ -215,7 +219,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"]);
@@ -490,7 +495,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(),
@@ -1706,7 +1712,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) {
@@ -1740,7 +1747,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, {
@@ -1812,6 +1820,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",
@@ -2198,6 +2208,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);
@@ -2260,8 +2284,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) };
     }
@@ -2292,8 +2317,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) };
     }
@@ -2810,13 +2836,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,
@@ -2850,6 +2879,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/)) {
@@ -3074,6 +3120,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);
@@ -3221,8 +3303,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);
@@ -3286,13 +3374,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);
@@ -3325,9 +3416,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;
@@ -3346,7 +3438,140 @@ 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;
+      return {
+        ok: false,
+        branch: await bestTip(),
+        error: ticketAbort.signal.aborted ? "stopped by user during conflict resolution" : errorHeadline(err instanceof Error ? err.message : String(err))
+      };
+    }
+    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,12 +3627,16 @@ ${retryNotes}` : basePrompt,
           };
         }
         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"}`
             }
           };
         }
@@ -3465,28 +3694,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();
@@ -3519,7 +3727,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", FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
@@ -3527,13 +3735,6 @@ 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",
@@ -3624,7 +3825,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;
@@ -3726,7 +3927,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();
@@ -3734,7 +3935,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))
@@ -4074,24 +4275,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);
@@ -6052,6 +6255,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/package.json

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

package/skills/burner/resolve-conflict.md

@@ -0,0 +1,69 @@
+<!-- Rendered by the ticket-burner when a ticket's branch fails to land on the feature branch. Placeholder tokens are filled in by the workflow. -->
+
+# Resolve a landing conflict — unattended
+
+You already implemented a ticket. Your commits are on your branch, but they could **not** be landed on the feature branch: while you were working, sibling tickets landed their own commits and you both touched the same files.
+
+Your one job now is to **merge the feature branch into your branch and resolve the conflicts**, so your work and theirs both survive. You are not re-implementing anything, and you are not starting new work.
+
+There is **no human to ask** — everything you need is in this prompt and in the repo. This is the last automated attempt before a human is pulled in, so be careful, not fast.
+
+## How you run
+
+You run **non-interactively** (`claude --print`), for up to a few fresh iterations against the same worktree:
+
+- **Ending your turn ends your process.** There are no background-task completion notifications in print mode — a "the notification will re-invoke me" plan never fires. Run long commands (test suites) in the foreground with a generous timeout.
+- **Signal completion.** When the merge commit is in, print exactly `<promise>COMPLETE</promise>` as the last line of your final message. Do the same after writing `BLOCKED.md` (see hard rules).
+
+## Where to work
+
+{{WORKSPACE_NOTES}}
+
+## The conflict
+
+Merging your branch into `{{FEATURE_BRANCH}}` conflicts on:
+
+{{CONFLICT_FILES}}
+
+These commits landed on `{{FEATURE_BRANCH}}` while you were working — this is the other side of the merge, the work you must preserve alongside your own:
+
+{{OTHER_SIDE}}
+
+## The ticket you implemented
+
+```json
+{{TICKET_JSON}}
+```
+
+## Feature context
+
+{{FEATURE_BRIEF}}
+
+## Feature docs (spec / decisions digest)
+
+{{DOCS_DIGEST}}
+
+## How to work
+
+1. **Orient before touching anything.** `git log --oneline -15` to see your own commits, then read the conflicting files. Understand what *your* commits were doing there (the ticket above is the intent) and what the *other* side's commits were doing (the log above, plus `git show` on them).
+
+2. **Start the merge:**
+
+   ```
+   {{MERGE_COMMAND}}
+   ```
+
+   It will stop with conflicts. `git status` lists the unmerged paths.
+
+3. **Resolve by intent, not by picking a side.** For every `<<<<<<< / ======= / >>>>>>>` hunk, keep *both* behaviours working. Reconcile the logic where the two sides genuinely overlap — the feature docs above are the tie-breaker on intent. Never delete one side's behaviour just to make the conflict go away, and never resolve by taking your whole side (`--ours`) or theirs (`--theirs`) wholesale unless one side is genuinely a strict superset.
+
+4. **Watch for semantic conflicts, not just textual ones.** Files that merged cleanly can still be broken by the other side's rename, signature change, or moved export. After resolving the marked hunks, run typecheck and the tests covering both sides' touched code, and fix what the merge broke.
+
+5. **Complete the merge.** Stage the resolved files and commit — keep it a merge commit (`git commit --no-verify`, do not `--squash`, do not rebase, do not amend your earlier commits). A merge commit whose message names what was reconciled is ideal.
+
+## Hard rules
+
+- **Never expand scope.** Resolving the conflict is the whole job. No refactors, no improvements, no adjacent fixes, not even tempting ones in the files you are already editing.
+- **Never lose committed work.** Not yours, not theirs. `git merge --abort` + "start over from one side" is not a resolution.
+- **Never push, and never touch the remote.** The orchestrator lands your branch itself once the merge commit exists.
+- **If the two sides genuinely cannot be reconciled without a product decision** (they implement contradictory behaviour, not merely overlapping code): `git merge --abort`, write `BLOCKED.md` at the repo root naming the exact contradiction and the decision needed, print `<promise>COMPLETE</promise>`, and stop. A human will decide. Do not guess.