runcastle 1.0.6 → 1.0.7

package/index.js

@@ -86,6 +86,7 @@ var init_config = __esm(() => {
     "qa",
     "waypoint",
     "converge",
+    "revisit",
     "research",
     "implement",
     "smoke"
@@ -97,7 +98,8 @@ var init_config = __esm(() => {
     stepModels: z.partialRecord(ModelStep, z.string()).default({ smoke: DEFAULT_SMOKE_MODEL }),
     sandbox: z.enum(["docker", "podman", "noSandbox"]).default("docker"),
     mainBranch: z.string().default("main"),
-    sandboxImage: z.string().optional()
+    sandboxImage: z.string().optional(),
+    burnConcurrency: z.number().int().min(1).max(8).default(3)
   }));
 });
 
@@ -130,6 +132,9 @@ function loadConfig(env = process.env) {
     overrides.mainBranch = env.RUNCASTLE_MAIN_BRANCH;
   if (env.RUNCASTLE_SANDBOX_IMAGE)
     overrides.sandboxImage = env.RUNCASTLE_SANDBOX_IMAGE;
+  if (env.RUNCASTLE_BURN_CONCURRENCY) {
+    overrides.burnConcurrency = Number(env.RUNCASTLE_BURN_CONCURRENCY);
+  }
   const base = typeof fileConfig === "object" && fileConfig !== null ? fileConfig : {};
   return RuncastleConfig.parse({ ...base, ...overrides });
 }
@@ -173,8 +178,8 @@ var init_schemas = __esm(() => {
     "shipped"
   ]);
   FeatureSize = z2.enum(["full", "collapsed"]);
-  TicketStatus = z2.enum(["pending", "burning", "done", "failed"]);
-  SessionKind = z2.enum(["ideation", "qa", "waypoint", "converge"]);
+  TicketStatus = z2.enum(["pending", "burning", "done", "failed", "cancelled"]);
+  SessionKind = z2.enum(["ideation", "qa", "waypoint", "converge", "revisit"]);
   RunStatus = z2.enum(["running", "succeeded", "failed", "cancelled"]);
   FeatureStatus = z2.enum(["active", "shipped"]);
   SessionStatus = z2.enum(["launching", "live", "ended"]);
@@ -1458,7 +1463,7 @@ var init_waypoints = __esm(() => {
 });
 
 // src/launcher/sessions.ts
-import { and as and4, desc as desc2, eq as eq4, inArray, sql as sql2 } from "drizzle-orm";
+import { and as and4, desc as desc2, eq as eq4, inArray, isNotNull, sql as sql2 } from "drizzle-orm";
 function createSessionRow(ctx, input) {
   const row = ctx.db.insert(sessions).values({
     id: newId("sess"),
@@ -1537,6 +1542,10 @@ function markSessionEnded(ctx, id) {
   ctx.db.update(sessions).set({ status: "ended" }).where(eq4(sessions.id, id)).run();
   return getSessionRow(ctx, id);
 }
+function mostRecentResumableSession(ctx, featureId) {
+  const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.featureId, featureId), eq4(sessions.status, "ended"), isNotNull(sessions.ccSessionId))).orderBy(desc2(sql2`rowid`)).limit(1).get();
+  return row ? rowToSession(row) : null;
+}
 function mostRecentLiveSession(ctx) {
   const row = ctx.db.select().from(sessions).where(eq4(sessions.status, "live")).orderBy(desc2(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
@@ -1677,6 +1686,55 @@ function storeTickets(ctx, featureId, inputs) {
   });
   return rows.map(rowToTicket);
 }
+function getTicket(ctx, id) {
+  const row = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`ticket ${id} not found`);
+  return rowToTicket(row);
+}
+function assertMutable(t, verb) {
+  if (!MUTABLE_STATUSES.has(t.status)) {
+    throw new InvalidInputError(`cannot ${verb} ticket ${t.seq} \u2014 it is ${t.status}; only pending or failed tickets can be ${verb}${verb.endsWith("l") ? "led" : "ed"}`);
+  }
+}
+function editTicket(ctx, id, patch) {
+  const current2 = getTicket(ctx, id);
+  assertMutable(current2, "edit");
+  const set = {};
+  if (patch.title !== undefined)
+    set.title = patch.title;
+  if (patch.goal !== undefined)
+    set.goal = patch.goal;
+  if (patch.context !== undefined)
+    set.context = patch.context;
+  if (patch.acceptanceCriteria !== undefined)
+    set.acceptanceCriteria = patch.acceptanceCriteria;
+  if (patch.seams !== undefined)
+    set.seams = patch.seams;
+  if (Object.keys(set).length === 0) {
+    throw new InvalidInputError("nothing to edit \u2014 pass at least one content field");
+  }
+  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  emit(ctx, current2.featureId, {
+    type: "ticket.edited",
+    message: `ticket ${current2.seq} content edited (${Object.keys(set).join(", ")})`,
+    ticketId: id,
+    data: { fields: Object.keys(set) }
+  });
+  return getTicket(ctx, id);
+}
+function cancelTicket(ctx, id, reason) {
+  const current2 = getTicket(ctx, id);
+  assertMutable(current2, "cancel");
+  ctx.db.update(tickets).set({ status: "cancelled", error: reason?.trim() ? reason.trim() : null }).where(eq5(tickets.id, id)).run();
+  emit(ctx, current2.featureId, {
+    type: "ticket.cancelled",
+    message: `ticket ${current2.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
+    ticketId: id,
+    data: { reason: reason ?? null }
+  });
+  return getTicket(ctx, id);
+}
 function updateTicket(ctx, id, patch) {
   const current2 = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
   if (!current2)
@@ -1698,11 +1756,13 @@ function updateTicket(ctx, id, patch) {
   const updated = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
   return rowToTicket(updated);
 }
+var MUTABLE_STATUSES;
 var init_tickets = __esm(() => {
   init_src();
   init_schema();
   init_errors();
   init_events();
+  MUTABLE_STATUSES = new Set(["pending", "failed"]);
 });
 
 // src/services/gates.ts
@@ -1727,14 +1787,14 @@ function checkGate(ctx, check, feature) {
         return { satisfied: true };
       return fileGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
     case "tickets-approved": {
-      const count = listByFeature2(ctx, feature.id).length;
+      const count = listByFeature2(ctx, feature.id).filter((t) => t.status !== "cancelled").length;
       return count >= 1 ? { satisfied: true } : { satisfied: false, reason: "no tickets to burn" };
     }
     case "all-tickets-terminal": {
       const tickets2 = listByFeature2(ctx, feature.id);
       if (tickets2.length === 0)
         return { satisfied: false, reason: "no tickets have run yet" };
-      const open = tickets2.filter((t) => t.status !== "done" && t.status !== "failed");
+      const open = tickets2.filter((t) => t.status !== "done" && t.status !== "failed" && t.status !== "cancelled");
       return open.length === 0 ? { satisfied: true } : {
         satisfied: false,
         reason: notYetTerminal("ticket", open.map((t) => t.status), ["pending", "burning"])
@@ -2058,7 +2118,10 @@ async function reattachWorktree(path, branch) {
 function researchBranchName(slug, waypointSeq, unique) {
   return `${RESEARCH_BRANCH_PREFIX}${slug}/${waypointSeq}-${unique}`;
 }
-async function mergeResearchBranch(repoPath, featureBranchName, tempBranch) {
+function ticketBranchName(slug, ticketSeq, unique) {
+  return `${TICKET_BRANCH_PREFIX}${slug}/${ticketSeq}-${unique}`;
+}
+async function mergeTempBranch(repoPath, featureBranchName, tempBranch) {
   const g = git(repoPath);
   let branches;
   try {
@@ -2107,7 +2170,10 @@ async function deleteBranchDetachingWorktrees(g, repoPath, branch) {
     return false;
   }
 }
-async function cleanupResearchBranches(repoPath) {
+function tempBranchPrefix(name) {
+  return TEMP_BRANCH_PREFIXES.find((p) => name.startsWith(p));
+}
+async function cleanupTempBranches(repoPath) {
   const deleted = [];
   const kept = [];
   const g = git(repoPath);
@@ -2118,9 +2184,10 @@ async function cleanupResearchBranches(repoPath) {
     return { deleted, kept };
   }
   for (const name of all) {
-    if (!name.startsWith(RESEARCH_BRANCH_PREFIX))
+    const prefix = tempBranchPrefix(name);
+    if (!prefix)
       continue;
-    const slug = name.slice(RESEARCH_BRANCH_PREFIX.length).split("/")[0];
+    const slug = name.slice(prefix.length).split("/")[0];
     const target = featureBranch(slug);
     let merged = false;
     if (slug && all.includes(target)) {
@@ -2277,13 +2344,14 @@ async function mergeInProgress(g) {
     return false;
   }
 }
-var DOCS_PATHSPEC = "docs/features", DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", RESEARCH_BRANCH_PREFIX = "runcastle/research/", testDriveState;
+var DOCS_PATHSPEC = "docs/features", DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", RESEARCH_BRANCH_PREFIX = "runcastle/research/", TICKET_BRANCH_PREFIX = "runcastle/ticket/", TEMP_BRANCH_PREFIXES, testDriveState;
 var init_git = __esm(() => {
   init_paths();
   init_errors();
   init_dev_pane();
   init_events();
   init_repo();
+  TEMP_BRANCH_PREFIXES = [RESEARCH_BRANCH_PREFIX, TICKET_BRANCH_PREFIX];
 });
 
 // src/services/knowledge.ts
@@ -2574,16 +2642,28 @@ 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 createSerialQueue() {
+  let tail = Promise.resolve();
+  return (task) => {
+    const next = tail.then(task);
+    tail = next.catch(() => {
+      return;
+    });
+    return next;
+  };
+}
 function firstLine(s) {
   const i = s.indexOf(`
 `);
   return (i === -1 ? s : s.slice(0, i)).trim();
 }
-async function burnTickets(ctx, tickets2, execute) {
+async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
+  const width = Math.max(1, Math.floor(concurrency));
   const bySeq = indexBySeq(tickets2);
   const status = new Map(tickets2.map((t) => [t.seq, t.status]));
   const pending = new Set(tickets2.filter((t) => t.status === "pending").map((t) => t.seq));
   const inFlight = new Map;
+  const satisfied = (s) => s === "done" || s === "cancelled";
   const readyState = (seq) => {
     const t = bySeq.get(seq);
     if (!t)
@@ -2594,7 +2674,7 @@ async function burnTickets(ctx, tickets2, execute) {
       if (!present || bs === "failed")
         return { blockedBy: b, present };
     }
-    return t.blockedBy.every((b) => status.get(b) === "done") ? "ready" : "wait";
+    return t.blockedBy.every((b) => satisfied(status.get(b))) ? "ready" : "wait";
   };
   const failTicket = (seq, error, extra) => {
     const t = bySeq.get(seq);
@@ -2655,7 +2735,7 @@ async function burnTickets(ctx, tickets2, execute) {
         }
       }
     }
-    while (inFlight.size < CONCURRENCY) {
+    while (inFlight.size < width) {
       const readySeq = [...pending].find((seq) => readyState(seq) === "ready");
       if (readySeq === undefined)
         break;
@@ -2666,7 +2746,12 @@ async function burnTickets(ctx, tickets2, execute) {
       inFlight.set(readySeq, p);
     }
     if (inFlight.size > 0) {
-      await Promise.race(inFlight.values());
+      try {
+        await Promise.race(inFlight.values());
+      } catch (err) {
+        await Promise.allSettled([...inFlight.values()]);
+        throw err;
+      }
     } else if (pending.size > 0) {
       for (const seq of [...pending]) {
         pending.delete(seq);
@@ -2690,12 +2775,14 @@ async function burnTickets(ctx, tickets2, execute) {
 }
 async function burnRun(ctx, deps) {
   const tickets2 = ctx.tickets;
-  const total = tickets2.length;
+  const burnable = tickets2.filter((t) => t.status !== "cancelled");
+  const cancelled = tickets2.length - burnable.length;
+  const total = burnable.length;
   if (deps.config.sandbox !== "noSandbox" && !deps.hasAuthToken) {
     ctx.emitEvent({ type: AUTH_MISSING_EVENT, message: AUTH_MISSING_MESSAGE });
     return { status: "failed", summary: "burn aborted: auth token missing" };
   }
-  const cycle = detectCycle(tickets2);
+  const cycle = detectCycle(burnable);
   if (cycle) {
     const path = cycle.join(" \u2192 ");
     ctx.emitEvent({
@@ -2705,9 +2792,9 @@ async function burnRun(ctx, deps) {
     });
     return { status: "failed", summary: `dependency cycle: ${path}` };
   }
-  const done = await burnTickets(ctx, tickets2, deps.executeTicketRun);
-  const summary = `${done}/${total} tickets done`;
-  ctx.emitEvent({ type: "burn.summary", message: summary, data: { done, total } });
+  const done = await burnTickets(ctx, tickets2, deps.executeTicketRun, deps.concurrency);
+  const summary = cancelled > 0 ? `${done}/${total} tickets done (${cancelled} cancelled)` : `${done}/${total} tickets done`;
+  ctx.emitEvent({ type: "burn.summary", message: summary, data: { done, total, cancelled } });
   return { status: done === total ? "succeeded" : "failed", summary };
 }
 function burnerTemplatePath() {
@@ -2768,8 +2855,9 @@ function selectSandbox(config2) {
       return noSandbox();
   }
 }
-async function realExecuteTicketRun(ctx, ticket, config2, token, model) {
+async function realExecuteTicketRun(ctx, ticket, config2, token, model, land) {
   const { project, feature } = ctx;
+  const tempBranch = ticketBranchName(feature.slug, ticket.seq, newId("b").slice(2, 10));
   const template = readFileSync4(burnerTemplatePath(), "utf8");
   const prompt = renderTicketPrompt(template, {
     TICKET_JSON: buildTicketJson(ticket),
@@ -2785,7 +2873,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model) {
     sandbox: selectSandbox(config2),
     cwd: project.repoPath,
     prompt,
-    branchStrategy: { type: "branch", branch: feature.branch, baseBranch: project.mainBranch },
+    branchStrategy: { type: "branch", branch: tempBranch, baseBranch: feature.branch },
     signal: ctx.signal,
     name: `ticket-${ticket.seq}`,
     logging: { type: "file", path: logFilePath, onAgentStreamEvent: throttle.onEvent }
@@ -2812,16 +2900,39 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model) {
   }
   throttle.flush();
   const blocked = readBlockedFile([result.preservedWorktreePath, project.repoPath]);
-  return interpretRunResult(result, blocked);
+  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) {
+      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`
+        }
+      };
+    }
+    return {
+      status: "failed",
+      error: `ticket ${ticket.seq} committed to ${tempBranch} but landing on ${feature.branch} failed: ${firstLine(detail)} \u2014 the branch is preserved for manual recovery`
+    };
+  }
+  return outcome;
 }
 function resolveBurnDeps(ctx) {
   const config2 = loadConfig();
   const token = readTokenFromEnvFile(envPath());
   const model = resolveModel("implement", config2, ctx.project, ctx.modelOverride);
+  const land = createSerialQueue();
   return {
     config: config2,
     hasAuthToken: token !== undefined,
-    executeTicketRun: (c, ticket) => realExecuteTicketRun(c, ticket, config2, token, model)
+    concurrency: config2.burnConcurrency,
+    executeTicketRun: (c, ticket) => realExecuteTicketRun(c, ticket, config2, token, model, land)
   };
 }
 function readTokenFromEnvFile(path) {
@@ -2836,12 +2947,13 @@ function readTokenFromEnvFile(path) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
   return token && token.length > 0 ? token : undefined;
 }
-var CONCURRENCY = 1, AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, ticketBurner;
+var AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
   init_paths();
   init_skills_root();
+  init_git();
   PLACEHOLDERS = ["TICKET_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "COMMIT_CONVENTION"];
   ticketBurner = {
     id: "ticket-burner",
@@ -2971,7 +3083,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   const outcome = interpretResearchResult(result, docRelPath);
   if (outcome.status !== "done")
     return outcome;
-  const merge = await mergeResearchBranch(project.repoPath, feature.branch, tempBranch);
+  const merge = await mergeTempBranch(project.repoPath, feature.branch, tempBranch);
   if (!merge.ok) {
     const detail = merge.error ?? "merge failed";
     ctx.emitEvent({
@@ -3249,7 +3361,8 @@ function list(ctx, projectId) {
       pending: tickets2.filter((t) => t.status === "pending").length,
       burning: tickets2.filter((t) => t.status === "burning").length,
       done: tickets2.filter((t) => t.status === "done").length,
-      failed: tickets2.filter((t) => t.status === "failed").length
+      failed: tickets2.filter((t) => t.status === "failed").length,
+      cancelled: tickets2.filter((t) => t.status === "cancelled").length
     };
     return { ...feature, ticketCounts: counts, activeRun: hasActiveRun(ctx, feature.id) };
   });
@@ -3278,13 +3391,19 @@ async function burn(ctx, featureId, opts = {}) {
     const why = feature.phase === "implementation" ? "a run is already burning this feature" : `feature must be in the tickets phase to burn (currently ${feature.phase})`;
     throw new GateError(why);
   }
-  if (listByFeature2(ctx, featureId).length < 1) {
-    throw new GateError("no tickets to burn");
+  const tickets2 = listByFeature2(ctx, featureId);
+  if (tickets2.filter((t) => t.status !== "cancelled").length < 1) {
+    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");
+    for (const t of failed) {
+      updateTicket(ctx, t.id, { status: "pending", error: null });
+    }
     emit(ctx, featureId, {
       type: "burn.restarted",
-      message: "restarting burn (previous run cancelled or crashed)"
+      message: failed.length > 0 ? `restarting burn \u2014 retrying ${failed.length} failed ticket(s)` : "restarting burn (previous run cancelled or crashed)",
+      data: { retried: failed.map((t) => t.seq) }
     });
   } else {
     setPhase(ctx, featureId, "implementation", "burn.started", "burning tickets");
@@ -3396,6 +3515,22 @@ function toolEmitTickets(ctx, session, input) {
   const stored = storeTickets(ctx, feature.id, input.tickets);
   return { stored: stored.length, ids: stored.map((t) => t.id) };
 }
+function requireOwnTicket(ctx, session, ticketId) {
+  const ticket = getTicket(ctx, ticketId);
+  if (ticket.featureId !== session.featureId) {
+    throw new GateError(`ticket ${ticketId} does not belong to this session's feature`);
+  }
+  return ticket;
+}
+function toolUpdateTicket(ctx, session, input) {
+  requireOwnTicket(ctx, session, input.id);
+  const { id, ...patch } = input;
+  return { ok: true, ticket: editTicket(ctx, id, patch) };
+}
+function toolCancelTicket(ctx, session, input) {
+  requireOwnTicket(ctx, session, input.id);
+  return { ok: true, ticket: cancelTicket(ctx, input.id, input.reason) };
+}
 function toolEscalateToMap(ctx, session, input) {
   return escalateToMap(ctx, session.featureId, input);
 }
@@ -3495,6 +3630,37 @@ function buildMcpServer() {
     await commitDocsCheckpoint(rs.ctx, rs.session, `runcastle: tickets emitted (${result.stored})`);
     return ok(result);
   });
+  server.registerTool("update_ticket", {
+    title: "Update ticket",
+    description: "Rewrite a stored ticket's content \u2014 title, goal, context, acceptanceCriteria, seams (any subset). Only pending or failed tickets can be edited; done/cancelled tickets are history and burning tickets are already running. Use during a revisit when a decision change makes a ticket stale. Get ids from get_feature_context.",
+    inputSchema: {
+      id: z3.string(),
+      title: z3.string().optional(),
+      goal: z3.string().optional(),
+      context: z3.string().optional(),
+      acceptanceCriteria: z3.array(z3.string()).optional(),
+      seams: z3.array(z3.string()).optional()
+    }
+  }, async (args, extra) => {
+    const rs = await resolveCtxSession(extra);
+    if (!rs)
+      return noSession();
+    const result = toolUpdateTicket(rs.ctx, rs.session, args);
+    await commitDocsCheckpoint(rs.ctx, rs.session, `runcastle: ticket ${result.ticket.seq} updated`);
+    return ok(result);
+  });
+  server.registerTool("cancel_ticket", {
+    title: "Cancel ticket",
+    description: "Cancel a ticket that is no longer needed (terminal state; only pending or failed tickets). The burner skips cancelled tickets, and tickets blocked by a cancelled one still burn \u2014 cancellation counts as satisfied. Pass a short reason so the timeline explains why.",
+    inputSchema: { id: z3.string(), reason: z3.string().optional() }
+  }, async (args, extra) => {
+    const rs = await resolveCtxSession(extra);
+    if (!rs)
+      return noSession();
+    const result = toolCancelTicket(rs.ctx, rs.session, args);
+    await commitDocsCheckpoint(rs.ctx, rs.session, `runcastle: ticket ${result.ticket.seq} cancelled`);
+    return ok(result);
+  });
   server.registerTool("escalate_to_map", {
     title: "Escalate to map",
     description: "Escalate this grilling session into a map when the feature outgrows one context window. Flips the feature to mapped and scaffolds docs/features/<slug>/map.md, seeding Destination + Notes from your arguments (Not-yet-specified and Out-of-scope start empty). Idempotent: calling it on an already-mapped feature warns and changes nothing.",
@@ -3892,6 +4058,8 @@ function renderSystemPrompt(feature, kind, waypoint) {
     return renderWaypointPrompt(feature, waypoint);
   if (kind === "converge")
     return renderConvergePrompt(feature);
+  if (kind === "revisit")
+    return renderRevisitPrompt(feature);
   const docs = featureDocsRel(feature.slug);
   const entry = kind === "ideation" ? "Begin by invoking the `/runcastle:ideate` skill and drive the ideation session to completion." : "This is a Q&A session: invoke `/runcastle:qa`. Answer questions from the docs + code. Do NOT advance phases or emit tickets.";
   return [
@@ -4017,6 +4185,49 @@ function renderConvergePrompt(feature) {
   ].join(`
 `);
 }
+function renderRevisitPrompt(feature) {
+  const docs = featureDocsRel(feature.slug);
+  return [
+    `# runcastle \u2014 ${feature.title} (revisit session)`,
+    "",
+    feature.oneLiner,
+    "",
+    "This is a **revisit session**: the human came back to a feature whose",
+    "earlier sessions are finished \u2014 they remembered something, or a decision",
+    "changed. Where possible this terminal RESUMES the previous conversation, so",
+    "you may already have its context above. Your job: fold the new information",
+    "into the record, then reconcile the tickets with it. The docs are the",
+    "artifact \u2014 later phases read them, never the transcripts.",
+    "",
+    "## Feature",
+    `- Slug: \`${feature.slug}\``,
+    `- Branch: \`${feature.branch}\``,
+    `- Current phase: **${feature.phase}** (size: ${feature.size})`,
+    "",
+    "## Knowledge (versioned in the target repo)",
+    `Feature docs live at \`${docs}/\`:`,
+    `- \`${docs}/decisions.md\` \u2014 append the new/changed decisions with a dated "revisited" note.`,
+    `- \`${docs}/spec.md\` \u2014 if it exists, amend the affected sections in place.`,
+    `- \`${docs}/map.md\` \u2014 if the feature is mapped, keep the map honest too.`,
+    "",
+    "## runcastle MCP tools",
+    "- `get_feature_context()` \u2014 feature + phase + docs + ALL tickets (with ids and statuses).",
+    "- `update_ticket({ id, ...fields })` \u2014 rewrite a stale pending/failed ticket's content.",
+    "- `cancel_ticket({ id, reason })` \u2014 cancel a pending/failed ticket that is now unnecessary.",
+    "- `emit_tickets({ tickets })` \u2014 add tickets for NEW work the change requires.",
+    "- `record_event({ type, message })` \u2014 drop a timeline note summarising the revisit.",
+    "",
+    "## Rules",
+    "- Do NOT call `complete_phase` \u2014 a revisit never moves the pipeline.",
+    "- Do NOT touch `done`/`burning` tickets; if done work is now wrong, emit a new ticket that fixes it.",
+    "- Docs first, tickets second: capture the decision prose before any ticket surgery.",
+    "",
+    "## Your task",
+    "Invoke the `/runcastle:revisit` skill and work through what the human brings up.",
+    ""
+  ].join(`
+`);
+}
 function renderSettings(hookClient) {
   const cmd = (event) => ({
     type: "command",
@@ -4062,6 +4273,8 @@ var init_artifacts = __esm(() => {
   RUNCASTLE_MCP_ALLOW_RULES = [
     "mcp__runcastle__get_feature_context",
     "mcp__runcastle__emit_tickets",
+    "mcp__runcastle__update_ticket",
+    "mcp__runcastle__cancel_ticket",
     "mcp__runcastle__record_event",
     "mcp__runcastle__complete_phase",
     "mcp__runcastle__escalate_to_map",
@@ -4228,11 +4441,32 @@ async function launchSession(ctx, input, opts = {}) {
       throw e;
     }
   }
+  if (input.kind === "revisit") {
+    try {
+      assertSpawnable(ctx, feature, session.id);
+    } catch (e) {
+      markSessionEnded(ctx, session.id);
+      throw e;
+    }
+    const prior = mostRecentResumableSession(ctx, feature.id);
+    if (prior?.ccSessionId) {
+      resumeSessionId = prior.ccSessionId;
+    } else {
+      resumeUnavailableFrom = "revisit";
+    }
+  }
   emit(ctx, feature.id, {
     type: "session.launching",
     message: `launching ${input.kind} session`,
     data: { sessionId: session.id, kind: input.kind, worktreePath, waypointId: waypoint?.id }
   });
+  if (input.kind === "revisit" && resumeUnavailableFrom) {
+    emit(ctx, feature.id, {
+      type: "session.resume_unavailable",
+      message: "no resumable conversation for this feature \u2014 revisiting fresh from the docs",
+      data: { sessionId: session.id }
+    });
+  }
   if (waypoint && resumeUnavailableFrom) {
     emit(ctx, feature.id, {
       type: "session.resume_unavailable",
@@ -4830,6 +5064,14 @@ var init_settings = __esm(() => {
       valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
+    {
+      key: "burnConcurrency",
+      configKey: "burnConcurrency",
+      envVar: "RUNCASTLE_BURN_CONCURRENCY",
+      restartRequired: false,
+      valueSchema: z9.number().int().min(1).max(8),
+      parseEnv: (raw) => Number(raw)
+    },
     {
       key: "mainBranch",
       configKey: "mainBranch",
@@ -5424,7 +5666,7 @@ async function reconcileStaleRuns(ctx) {
   }
   for (const project of allProjects(ctx)) {
     try {
-      await cleanupResearchBranches(project.repoPath);
+      await cleanupTempBranches(project.repoPath);
     } catch {}
   }
   return reconciled;

package/package.json

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

package/skills/packs/runcastle/skills/revisit/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: revisit
+description: Fold late-arriving information into a feature whose sessions are finished — amend the docs, then reconcile tickets (update/cancel/emit). Never advances phases. Entry skill for kind=revisit sessions.
+disable-model-invocation: false
+---
+
+# Revisit
+
+The human came back: they remembered a constraint, changed their mind, or learned something that the grilling/spec didn't capture. This session's job is to make the **record** and the **ticket queue** match the new reality — nothing more. The pipeline does not move; whatever phase the feature is in, it stays in.
+
+## Order of operations
+
+1. **Listen first.** The human opens with what changed. If this terminal resumed the previous conversation, use that context; do not re-grill what is already settled. Ask only the questions the NEW information raises.
+2. **Context.** Call `mcp__runcastle__get_feature_context` — it returns the feature, phase, all docs, and all tickets with their ids and statuses. You need the ticket list before any surgery.
+3. **Docs.** Capture the change as decision prose:
+   - Append to `docs/features/<slug>/decisions.md` under a dated `## Revisited <date>` heading — never rewrite old decisions, supersede them ("Supersedes: <old decision>").
+   - If `spec.md` exists and the change touches it, amend the affected sections in place.
+   - If the feature is mapped, keep `map.md` honest (destination/out-of-scope).
+4. **Ticket surgery.** Walk the ticket list against the new reality:
+   - Stale but still needed → `mcp__runcastle__update_ticket({ id, ...changed fields })` (pending/failed only).
+   - No longer needed → `mcp__runcastle__cancel_ticket({ id, reason })` (pending/failed only).
+   - New work required → `mcp__runcastle__emit_tickets({ tickets })` (batch, same shape as ideation).
+   - `done` work now wrong → emit a NEW ticket that corrects it. Never touch done/burning tickets.
+5. **Close.** `mcp__runcastle__record_event({ type: "feature.revisited", message: "<one-line gist of what changed>" })`, then tell the human what state you left things in — especially whether a re-Burn is needed (pending tickets exist and the feature is at `implementation`).
+
+## Do NOT
+
+- **Never call `complete_phase`.** A revisit has no gates to cross; the human drives the pipeline from the UI.
+- **Never resolve or reopen waypoints.** If a resolved waypoint's answer is now wrong, record the superseding decision in `decisions.md` — the map's history stays intact.
+- **Never implement changes.** Code changes ride tickets; the burner (or a human) implements them.
+
+## Scope check
+
+If what the human brings is not an amendment but a whole new capability, say so:
+
+> That reads like a new feature, not a revision of this one. Create it in the runcastle UI and grill it there — I can record a pointer note here.
+
+Then `record_event` a one-line note so the idea is not lost.