runcastle 1.0.20 → 1.0.22

package/bin/runcastle.js

@@ -72,7 +72,7 @@ function resolveSandboxImage(config) {
 function resolveModel(step, config, project, runOverride) {
   return runOverride ?? config.stepModels[step] ?? project?.model ?? config.model;
 }
-var MODEL_STEPS, ModelStep, DEFAULT_SMOKE_MODEL = "claude-haiku-4-5-20251001", foldLegacyModelConfig = (raw) => {
+var MODEL_STEPS, ModelStep, DEFAULT_SMOKE_MODEL = "claude-haiku-4-5", foldLegacyModelConfig = (raw) => {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw))
     return raw;
   const obj = { ...raw };
@@ -99,7 +99,7 @@ var init_config = __esm(() => {
   ModelStep = z.enum(MODEL_STEPS);
   RuncastleConfig = z.preprocess(foldLegacyModelConfig, z.object({
     serverPort: z.number().default(4512),
-    model: z.string().default("claude-opus-4-8"),
+    model: z.string().default("claude-opus-5"),
     stepModels: z.partialRecord(ModelStep, z.string()).default({ smoke: DEFAULT_SMOKE_MODEL }),
     sandbox: z.enum(["docker", "podman", "noSandbox"]).default("docker"),
     mainBranch: z.string().default("main"),
@@ -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(),
@@ -1127,6 +1133,27 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/services/bus.ts
+function subscribeLive(fn) {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+function publishLive(signal) {
+  for (const fn of [...subscribers]) {
+    try {
+      fn(signal);
+    } catch (err) {
+      console.error("live bus subscriber threw", err);
+    }
+  }
+}
+var subscribers;
+var init_bus = __esm(() => {
+  subscribers = new Set;
+});
+
 // src/services/events.ts
 import { and, asc, eq, gt } from "drizzle-orm";
 function rowToEvent(row) {
@@ -1165,7 +1192,14 @@ function insertEvent(ctx, projectId, featureId, e) {
     message: e.message,
     data: e.data ?? null
   }).returning().get();
-  return rowToEvent(row);
+  const event = rowToEvent(row);
+  publishLive({
+    kind: "event",
+    projectId: event.projectId,
+    featureId: event.featureId,
+    eventId: event.id
+  });
+  return event;
 }
 function listAfter(ctx, featureId, afterId = 0) {
   const rows = ctx.db.select().from(events).where(and(eq(events.featureId, featureId), gt(events.id, afterId))).orderBy(asc(events.id)).all();
@@ -1178,6 +1212,7 @@ function listByProject(ctx, projectId, afterId = 0) {
 var init_events = __esm(() => {
   init_schema();
   init_errors();
+  init_bus();
 });
 
 // src/services/repo.ts
@@ -1678,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) {
@@ -1712,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, {
@@ -1784,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",
@@ -2170,6 +2209,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);
@@ -2232,8 +2285,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) };
     }
@@ -2264,8 +2318,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) };
     }
@@ -2690,6 +2745,7 @@ var init_skills_root = __esm(() => {
 // src/services/agent-stream.ts
 function beginTranscript(ticketId) {
   transcripts.set(ticketId, { live: true, chunks: [], nextIndex: 0, bytes: 0 });
+  publishLive({ kind: "transcript", ticketId });
 }
 function appendTranscript(ticketId, chunk) {
   const t = transcripts.get(ticketId);
@@ -2705,11 +2761,13 @@ function appendTranscript(ticketId, chunk) {
       break;
     t.bytes -= dropped.text.length;
   }
+  publishLive({ kind: "transcript", ticketId });
 }
 function endTranscript(ticketId) {
   const t = transcripts.get(ticketId);
   if (t)
     t.live = false;
+  publishLive({ kind: "transcript", ticketId });
 }
 function readTranscript(ticketId, after = -1) {
   const t = transcripts.get(ticketId);
@@ -2724,6 +2782,7 @@ function readTranscript(ticketId, after = -1) {
 }
 var MAX_CHUNKS = 4000, MAX_BYTES = 1500000, transcripts;
 var init_agent_stream = __esm(() => {
+  init_bus();
   transcripts = new Map;
 });
 
@@ -2778,13 +2837,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,
@@ -2818,6 +2880,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/)) {
@@ -3042,6 +3121,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);
@@ -3189,8 +3304,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);
@@ -3254,13 +3375,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);
@@ -3293,9 +3417,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;
@@ -3314,7 +3439,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++) {
@@ -3370,12 +3628,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"}`
             }
           };
         }
@@ -3433,28 +3695,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();
@@ -3487,7 +3728,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();
@@ -3495,13 +3736,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",
@@ -3592,7 +3826,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;
@@ -3694,7 +3928,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();
@@ -3702,7 +3936,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))
@@ -4042,24 +4276,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);
@@ -4636,6 +4872,57 @@ var init_hooks = __esm(() => {
   hooks_default = hooks;
 });
 
+// src/routes/stream.ts
+import { Hono as Hono3 } from "hono";
+import { streamSSE } from "hono/streaming";
+function dedupeKey(s) {
+  return s.kind === "transcript" ? `transcript:${s.ticketId}` : "event";
+}
+var stream, FLUSH_MS = 120, HEARTBEAT_MS = 25000, stream_default;
+var init_stream = __esm(() => {
+  init_bus();
+  stream = new Hono3;
+  stream.get("/", (c) => streamSSE(c, async (sse) => {
+    const pending = new Map;
+    let done = false;
+    const stop = () => {
+      done = true;
+    };
+    const unsubscribe = subscribeLive((signal) => {
+      pending.set(dedupeKey(signal), signal);
+    });
+    sse.onAbort(stop);
+    c.req.raw.signal.addEventListener("abort", stop);
+    try {
+      await sse.writeSSE({ event: "ready", data: "{}" });
+      let idleMs = 0;
+      while (!done && !sse.aborted && !sse.closed) {
+        await sse.sleep(FLUSH_MS);
+        if (done || sse.aborted || sse.closed)
+          break;
+        if (pending.size === 0) {
+          idleMs += FLUSH_MS;
+          if (idleMs >= HEARTBEAT_MS) {
+            idleMs = 0;
+            await sse.writeSSE({ event: "ping", data: "{}" });
+          }
+          continue;
+        }
+        idleMs = 0;
+        const batch = [...pending.values()];
+        pending.clear();
+        for (const signal of batch) {
+          await sse.writeSSE({ event: "live", data: JSON.stringify(signal) });
+        }
+      }
+    } finally {
+      unsubscribe();
+      c.req.raw.signal.removeEventListener("abort", stop);
+    }
+  }));
+  stream_default = stream;
+});
+
 // src/routes/web.ts
 import { existsSync as existsSync12, statSync } from "fs";
 import { readFile } from "fs/promises";
@@ -5969,6 +6256,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",
@@ -6610,9 +6905,9 @@ __export(exports_src, {
   buildApp: () => buildApp
 });
 import { trpcServer } from "@hono/trpc-server";
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono4 } from "hono";
 function buildApp(ctx) {
-  const app = new Hono3;
+  const app = new Hono4;
   setRuntimeCtx(ctx);
   app.get("/health", (c) => c.json({ ok: true }));
   app.use("/api/trpc/*", async (c, next) => {
@@ -6626,6 +6921,7 @@ function buildApp(ctx) {
     createContext: () => ctx
   }));
   app.route("/api/hooks", hooks_default);
+  app.route("/api/stream", stream_default);
   app.route("/mcp", server_default);
   mountWebAppIfBuilt(app);
   return app;
@@ -6678,6 +6974,7 @@ var init_src2 = __esm(() => {
   init_registry();
   init_ws();
   init_hooks();
+  init_stream();
   init_web();
   init_router();
   init_reconcile_runs();