runcastle 1.2.9 → 1.2.11

package/bin/runcastle.js

@@ -49,6 +49,12 @@ import * as z from "zod";
 function resolveSandboxImage(config) {
   return config.sandboxImage ?? DEFAULT_SANDBOX_IMAGE;
 }
+function resolveBurnCacheMode(config) {
+  return BURN_CACHE_SANDBOXES.includes(config.sandbox) ? config.burnCache : "off";
+}
+function resolveDefaultBurnConcurrency(logicalCpus) {
+  return Number.isFinite(logicalCpus) && logicalCpus > SMALL_HOST_LOGICAL_CPUS ? 3 : 1;
+}
 function resolvePreparedSettings(config, project) {
   const pick = (a, b) => {
     const own = a?.trim();
@@ -100,7 +106,7 @@ var MODEL_STEPS, ModelStep, AGENT_RUNTIMES, AgentRuntime, DEFAULT_RUNTIME = "cla
   }
   delete obj.smokeModel;
   return obj;
-}, RuncastleConfig, DEFAULT_SANDBOX_IMAGE = "sandcastle:runcastle";
+}, RuncastleConfig, DEFAULT_SANDBOX_IMAGE = "sandcastle:runcastle", BURN_CACHE_SANDBOXES, SMALL_HOST_LOGICAL_CPUS = 8;
 var init_config = __esm(() => {
   MODEL_STEPS = [
     "ideation",
@@ -110,6 +116,7 @@ var init_config = __esm(() => {
     "revisit",
     "research",
     "implement",
+    "review",
     "prepare",
     "project",
     "smoke"
@@ -147,7 +154,6 @@ var init_config = __esm(() => {
     models: z.array(ModelEntry).default([]),
     sandbox: z.enum(["docker", "podman", "noSandbox"]).default("docker"),
     sessionMcp: z.enum(["inherit", "runcastleOnly"]).default("inherit"),
-    mainBranch: z.string().default("main"),
     sandboxImage: z.string().optional(),
     burnConcurrency: z.number().int().min(1).max(8).default(3),
     burnCpus: z.number().positive().max(256).optional(),
@@ -158,8 +164,10 @@ var init_config = __esm(() => {
     setupCommand: z.string().optional(),
     verifyCommands: z.string().optional(),
     knownFailures: z.string().optional(),
-    burnWorkspace: z.enum(["auto", "mounted", "isolated"]).default("auto")
+    burnWorkspace: z.enum(["auto", "mounted", "isolated"]).default("auto"),
+    burnCache: z.enum(["volume", "off"]).default("volume")
   }));
+  BURN_CACHE_SANDBOXES = ["docker", "podman"];
 });
 
 // ../core/src/schemas.ts
@@ -167,7 +175,7 @@ import * as z2 from "zod";
 function isProjectSessionKind(kind) {
   return PROJECT_SESSION_KINDS.includes(kind);
 }
-var Phase, TicketStatus, SessionKind, PROJECT_SESSION_KINDS, SessionPurpose, MergeBranchPair, RunStatus, FeatureStatus, SessionStatus, TicketKind, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNoteAuthor, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+var Phase, TicketStatus, SessionKind, PROJECT_SESSION_KINDS, SessionPurpose, MergeBranchPair, RunStatus, FeatureStatus, SessionStatus, TicketKind, FindingKind, FindingSeverity, FindingStatus, FindingOpenReason, ReviewFindingInput, ReviewFinding, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNoteAuthor, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
 var init_schemas = __esm(() => {
   init_config();
   Phase = z2.enum([
@@ -199,6 +207,35 @@ var init_schemas = __esm(() => {
   FeatureStatus = z2.enum(["draft", "active", "shipped", "archived"]);
   SessionStatus = z2.enum(["launching", "live", "ended"]);
   TicketKind = z2.enum(["implementation", "review"]);
+  FindingKind = z2.enum(["defect", "observation"]);
+  FindingSeverity = z2.enum(["high", "medium", "low"]);
+  FindingStatus = z2.enum(["open", "fixing", "fixed", "failed", "dismissed"]);
+  FindingOpenReason = z2.enum(["over-cap", "fix-failed"]);
+  ReviewFindingInput = z2.object({
+    kind: FindingKind,
+    severity: FindingSeverity,
+    title: z2.string().min(1),
+    location: z2.string().min(1),
+    citation: z2.string().min(1),
+    detail: z2.string().min(1),
+    reproStep: z2.string().optional()
+  }).superRefine((finding, ctx) => {
+    if (finding.kind === "defect" && !finding.reproStep?.trim()) {
+      ctx.addIssue({ code: "custom", path: ["reproStep"], message: "defects require a repro step" });
+    }
+  });
+  ReviewFinding = ReviewFindingInput.safeExtend({
+    id: z2.string(),
+    featureId: z2.string(),
+    lap: z2.number(),
+    reviewTicketId: z2.string(),
+    reproStep: z2.string(),
+    status: FindingStatus,
+    openReason: FindingOpenReason.nullable(),
+    failureReason: z2.string().nullable(),
+    fixTicketId: z2.string().nullable(),
+    createdAt: z2.number()
+  });
   TicketInput = z2.object({
     title: z2.string(),
     goal: z2.string(),
@@ -207,7 +244,8 @@ var init_schemas = __esm(() => {
     seams: z2.array(z2.string()),
     blockedBy: z2.array(z2.number()),
     kind: TicketKind.default("implementation"),
-    model: z2.string().optional()
+    model: z2.string().optional(),
+    originFindingId: z2.string().optional()
   });
   Ticket = TicketInput.extend({
     id: z2.string(),
@@ -277,7 +315,7 @@ var init_schemas = __esm(() => {
     id: z2.string(),
     name: z2.string(),
     repoPath: z2.string(),
-    mainBranch: z2.string(),
+    sessionBranch: z2.string().optional(),
     devCommand: z2.string().optional(),
     model: z2.string().optional(),
     setupCommand: z2.string().optional(),
@@ -538,13 +576,13 @@ var init_pipeline = __esm(() => {
 
 // ../core/src/db-schema.ts
 import { index, integer, primaryKey, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var projects, projectFindings, features, sessions, tickets, testNotes, waypoints, runs, events, gateOverrides;
+var projects, projectFindings, features, sessions, tickets, reviewFindings, testNotes, waypoints, runs, events, gateOverrides;
 var init_db_schema = __esm(() => {
   projects = sqliteTable("projects", {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
     repoPath: text("repo_path").notNull(),
-    mainBranch: text("main_branch").notNull(),
+    sessionBranch: text("session_branch"),
     devCommand: text("dev_command"),
     model: text("model"),
     sandbox: text("sandbox"),
@@ -617,7 +655,26 @@ var init_db_schema = __esm(() => {
     error: text("error"),
     attemptBranch: text("attempt_branch"),
     conflictFiles: text("conflict_files", { mode: "json" }).$type(),
-    digest: text("digest")
+    digest: text("digest"),
+    originFindingId: text("origin_finding_id")
+  });
+  reviewFindings = sqliteTable("review_findings", {
+    id: text("id").primaryKey(),
+    featureId: text("feature_id").notNull(),
+    lap: integer("lap").notNull(),
+    reviewTicketId: text("review_ticket_id").notNull(),
+    kind: text("kind").notNull().$type(),
+    severity: text("severity").notNull().$type(),
+    title: text("title").notNull(),
+    location: text("location").notNull(),
+    citation: text("citation").notNull(),
+    detail: text("detail").notNull(),
+    reproStep: text("repro_step").notNull(),
+    status: text("status").notNull().$type(),
+    openReason: text("open_reason").$type(),
+    failureReason: text("failure_reason"),
+    fixTicketId: text("fix_ticket_id"),
+    createdAt: integer("created_at").notNull()
   });
   testNotes = sqliteTable("test_notes", {
     id: text("id").primaryKey(),
@@ -790,10 +847,12 @@ var init_paths = () => {};
 // ../core/src/config-load.ts
 var exports_config_load = {};
 __export(exports_config_load, {
-  loadConfig: () => loadConfig
+  loadConfig: () => loadConfig,
+  hostLogicalCpus: () => hostLogicalCpus
 });
 import { existsSync, readFileSync } from "fs";
-function loadConfig(env = process.env) {
+import { availableParallelism } from "os";
+function loadConfig(env = process.env, logicalCpus = hostLogicalCpus()) {
   let fileConfig = {};
   const path = configPath();
   if (existsSync(path)) {
@@ -817,8 +876,6 @@ function loadConfig(env = process.env) {
     overrides.sandbox = env.RUNCASTLE_SANDBOX;
   if (env.RUNCASTLE_SESSION_MCP)
     overrides.sessionMcp = env.RUNCASTLE_SESSION_MCP;
-  if (env.RUNCASTLE_MAIN_BRANCH)
-    overrides.mainBranch = env.RUNCASTLE_MAIN_BRANCH;
   if (env.RUNCASTLE_SANDBOX_IMAGE)
     overrides.sandboxImage = env.RUNCASTLE_SANDBOX_IMAGE;
   num("burnConcurrency", env.RUNCASTLE_BURN_CONCURRENCY);
@@ -837,8 +894,17 @@ function loadConfig(env = process.env) {
     overrides.knownFailures = env.RUNCASTLE_KNOWN_FAILURES;
   if (env.RUNCASTLE_BURN_WORKSPACE)
     overrides.burnWorkspace = env.RUNCASTLE_BURN_WORKSPACE;
+  if (env.RUNCASTLE_BURN_CACHE)
+    overrides.burnCache = env.RUNCASTLE_BURN_CACHE;
   const base = typeof fileConfig === "object" && fileConfig !== null ? fileConfig : {};
-  return RuncastleConfig.parse({ ...base, ...overrides });
+  const merged = { ...base, ...overrides };
+  if (merged.burnConcurrency === undefined) {
+    merged.burnConcurrency = resolveDefaultBurnConcurrency(logicalCpus);
+  }
+  return RuncastleConfig.parse(merged);
+}
+function hostLogicalCpus() {
+  return availableParallelism();
 }
 var init_config_load = __esm(() => {
   init_config();
@@ -867,6 +933,7 @@ var init_schema = __esm(() => {
   init_src();
   schema = {
     projects,
+    reviewFindings,
     features,
     sessions,
     tickets,
@@ -1575,6 +1642,198 @@ var init_registry = __esm(() => {
   REGISTRY_KEY = Symbol.for("runcastle.pty.registry");
 });
 
+// src/workflows/burn-cache.ts
+function burnCacheVolumeName(projectId) {
+  return `runcastle-${projectId}`;
+}
+function slotRepoPath(slot) {
+  return `${slotDirPath(slot)}/repo`;
+}
+function slotDirPath(slot) {
+  return `${BURN_CACHE_MOUNT}/slots/${slot}`;
+}
+function slotStampPath(slot) {
+  return `${slotDirPath(slot)}/.runcastle-stamp`;
+}
+function storePath(pm) {
+  return `${BURN_CACHE_MOUNT}/store/${pm}`;
+}
+function burnCacheEnv(pm) {
+  const store = storePath(pm);
+  return {
+    npm_config_store_dir: store,
+    pnpm_config_store_dir: store,
+    BUN_INSTALL_CACHE_DIR: store,
+    npm_config_cache: store,
+    YARN_GLOBAL_FOLDER: store,
+    TMPDIR: `${BURN_CACHE_MOUNT}/tmp`,
+    NODE_COMPILE_CACHE: `${BURN_CACHE_MOUNT}/node-compile`
+  };
+}
+async function execOrThrow(exec, engine, args) {
+  const out = await exec(engine, args);
+  if (!out.ok || out.code !== 0) {
+    throw new Error(`${engine} ${args.join(" ")} failed: ${out.stderr.trim() || `exit ${out.code}`}`);
+  }
+}
+async function ensureBurnCacheVolume(opts) {
+  const { engine, exec } = opts;
+  const name = burnCacheVolumeName(opts.projectId);
+  const inspect = await exec(engine, ["volume", "inspect", name]);
+  const existed = inspect.ok && inspect.code === 0;
+  await execOrThrow(exec, engine, ["volume", "create", name]);
+  if (existed)
+    return;
+  await execOrThrow(exec, engine, [
+    "run",
+    "--rm",
+    "--user",
+    "root",
+    "-v",
+    `${name}:${BURN_CACHE_MOUNT}`,
+    opts.imageName,
+    "chown",
+    "-R",
+    CONTAINER_USER,
+    BURN_CACHE_MOUNT
+  ]);
+}
+async function removeBurnCacheVolume(opts) {
+  if (opts.slots.length > 0)
+    throw new BurnCacheBusyError([...opts.slots].sort((a, b) => a - b));
+  await execOrThrow(opts.exec, opts.engine, ["volume", "rm", burnCacheVolumeName(opts.projectId)]);
+}
+async function burnCacheVolumeSize(opts) {
+  const out = await opts.exec(opts.engine, ["system", "df", "-v", "--format", "json"]);
+  if (!out.ok || out.code !== 0)
+    return null;
+  return findVolumeSize(out.stdout, burnCacheVolumeName(opts.projectId));
+}
+function parseJsonValues(stdout) {
+  const values = [];
+  const whole = tryParseJson(stdout);
+  if (whole !== undefined)
+    return [whole];
+  for (const line of stdout.split(`
+`)) {
+    const value = tryParseJson(line);
+    if (value !== undefined)
+      values.push(value);
+  }
+  return values;
+}
+function tryParseJson(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed)
+    return;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+}
+function findVolumeSize(stdout, name) {
+  const pending = parseJsonValues(stdout);
+  while (pending.length > 0) {
+    const node = pending.shift();
+    if (Array.isArray(node)) {
+      pending.push(...node);
+      continue;
+    }
+    if (typeof node !== "object" || node === null)
+      continue;
+    const record = node;
+    if (VOLUME_NAME_KEYS.some((key) => record[key] === name)) {
+      const size = readSize(record);
+      if (size !== null)
+        return size;
+    }
+    pending.push(...Object.values(record));
+  }
+  return null;
+}
+function readSize(record) {
+  const usage = record.UsageData;
+  const nested = typeof usage === "object" && usage !== null ? usage.Size : undefined;
+  return parseSize(record.Size) ?? parseSize(nested);
+}
+function parseSize(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string")
+    return null;
+  const match = /^\s*(-?[\d.]+)\s*([a-z]*)\s*$/i.exec(value);
+  if (!match)
+    return null;
+  const amount = Number(match[1]);
+  const unit = SIZE_UNITS[(match[2] || "b").toLowerCase()];
+  if (!Number.isFinite(amount) || unit === undefined)
+    return null;
+  return Math.round(amount * unit);
+}
+function createSlotAllocator(capacity) {
+  const heldSlots = new Set;
+  let width = capacity;
+  return {
+    claim() {
+      for (let slot = 1;slot <= width; slot++) {
+        if (!heldSlots.has(slot)) {
+          heldSlots.add(slot);
+          return slot;
+        }
+      }
+      throw new BurnSlotsExhaustedError(width);
+    },
+    release(slot) {
+      heldSlots.delete(slot);
+    },
+    held() {
+      return [...heldSlots].sort((a, b) => a - b);
+    },
+    resize(next) {
+      width = next;
+    }
+  };
+}
+function getBurnSlotAllocator(capacity) {
+  if (!sharedAllocator)
+    sharedAllocator = createSlotAllocator(capacity);
+  else
+    sharedAllocator.resize(capacity);
+  return sharedAllocator;
+}
+var BURN_CACHE_MOUNT = "/home/agent/cache", BurnCacheBusyError, CONTAINER_USER = "1000:1000", VOLUME_NAME_KEYS, SIZE_UNITS, BurnSlotsExhaustedError, sharedAllocator;
+var init_burn_cache = __esm(() => {
+  BurnCacheBusyError = class BurnCacheBusyError extends Error {
+    slots;
+    constructor(slots) {
+      super(`burn cache is in use \u2014 slots ${slots.join(", ")} are held; stop those burns before clearing it`);
+      this.name = "BurnCacheBusyError";
+      this.slots = slots;
+    }
+  };
+  VOLUME_NAME_KEYS = ["Name", "VolumeName"];
+  SIZE_UNITS = {
+    b: 1,
+    kb: 1000,
+    mb: 1e6,
+    gb: 1e9,
+    tb: 1000000000000,
+    pb: 1000000000000000,
+    kib: 1024,
+    mib: 1024 ** 2,
+    gib: 1024 ** 3,
+    tib: 1024 ** 4,
+    pib: 1024 ** 5
+  };
+  BurnSlotsExhaustedError = class BurnSlotsExhaustedError extends Error {
+    constructor(capacity) {
+      super(`all ${capacity} burn cache slots are in use`);
+      this.name = "BurnSlotsExhaustedError";
+    }
+  };
+});
+
 // src/errors.ts
 import { TRPCError } from "@trpc/server";
 function isNotImplemented(e) {
@@ -1589,6 +1848,8 @@ function toTRPCError(e) {
     return new TRPCError({ code: "NOT_FOUND", message: e.message, cause: e });
   if (e instanceof GateError)
     return new TRPCError({ code: "PRECONDITION_FAILED", message: e.message, cause: e });
+  if (e instanceof BurnCacheBusyError)
+    return new TRPCError({ code: "PRECONDITION_FAILED", message: e.message, cause: e });
   if (e instanceof InvalidInputError)
     return new TRPCError({ code: "BAD_REQUEST", message: e.message, cause: e });
   if (e instanceof Error)
@@ -1597,6 +1858,7 @@ function toTRPCError(e) {
 }
 var NotImplementedError, GateError, InvalidInputError, NotFoundError;
 var init_errors = __esm(() => {
+  init_burn_cache();
   NotImplementedError = class NotImplementedError extends Error {
     wave;
     constructor(wave) {
@@ -1760,7 +2022,7 @@ function rowToProject(row) {
     id: row.id,
     name: row.name,
     repoPath: row.repoPath,
-    mainBranch: row.mainBranch,
+    sessionBranch: row.sessionBranch ?? undefined,
     devCommand: row.devCommand ?? undefined,
     model: row.model ?? undefined,
     setupCommand: row.setupCommand ?? undefined,
@@ -2498,11 +2760,12 @@ function markVerified(ctx, projectId, keys, sha) {
 async function listFindings(ctx, project) {
   const rows = ctx.db.select().from(projectFindings).where(eq4(projectFindings.projectId, project.id)).all();
   const distances = new Map;
-  for (const row of rows) {
-    const sha = row.establishedSha;
-    if (!sha || distances.has(sha))
-      continue;
-    distances.set(sha, await commitsSince(project.repoPath, sha, project.mainBranch));
+  const shas = new Set(rows.flatMap((row) => row.establishedSha ? [row.establishedSha] : []));
+  if (shas.size > 0) {
+    const mainLine = await detectMainBranch(project.repoPath);
+    for (const sha of shas) {
+      distances.set(sha, await commitsSince(project.repoPath, sha, mainLine));
+    }
   }
   const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
   return rows.filter((row) => isPreparedKey(row.key)).sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0)).map((row) => {
@@ -2571,8 +2834,11 @@ function migrationPaths(paths) {
 function featureBranch(slug) {
   return `feature/${slug}`;
 }
-function mergeTarget(project, feature) {
-  return feature.baseBranch ?? project.mainBranch;
+function featureBase(feature) {
+  if (!feature.baseBranch) {
+    throw new GateError(`feature ${feature.slug} has no recorded base branch \u2014 it has not been cut from one yet`);
+  }
+  return feature.baseBranch;
 }
 function git(repoPath) {
   return simpleGit(repoPath);
@@ -2622,9 +2888,31 @@ async function detectMainBranch(repoPath) {
   } catch {}
   return "main";
 }
+async function resolveSessionBranch(project) {
+  const stored = project.sessionBranch?.trim();
+  if (!stored)
+    return detectMainBranch(project.repoPath);
+  const local = await git(project.repoPath).branchLocal();
+  if (!local.all.includes(stored)) {
+    throw new GateError(`the configured session landing branch \`${stored}\` no longer exists in ${project.repoPath} \u2014 pick where this chat's work should land`);
+  }
+  return stored;
+}
+async function sessionBranchView(project) {
+  const stored = project.sessionBranch?.trim() || null;
+  const detected = await detectMainBranch(project.repoPath);
+  return { stored, effective: stored ?? detected, detected };
+}
+async function currentCheckoutBranch(project) {
+  const local = await git(project.repoPath).branchLocal();
+  if (local.detached || !local.current) {
+    throw new InvalidInputError(`${project.repoPath} has no branch checked out (detached HEAD) \u2014 name the branch to fork from`);
+  }
+  return local.current;
+}
 async function createFeatureBranch(project, slug, base) {
   const branch = featureBranch(slug);
-  const from = base?.trim() || project.mainBranch;
+  const from = base.trim();
   const g = git(project.repoPath);
   const branches = await g.branchLocal();
   if (branches.all.includes(branch))
@@ -2638,7 +2926,9 @@ async function createFeatureBranch(project, slug, base) {
 async function listBranches(project) {
   const g = git(project.repoPath);
   const local = await g.branchLocal();
-  const branches = local.all.filter((name) => !name.startsWith("feature/"));
+  const detachedRef = local.detached ? local.current : null;
+  const current = local.detached ? "" : local.current;
+  const branches = local.all.filter((name) => !name.startsWith("feature/") && name !== detachedRef);
   const localSet = new Set(local.all);
   let remoteBranches = [];
   try {
@@ -2648,7 +2938,7 @@ async function listBranches(project) {
       return !short.startsWith("feature/") && !localSet.has(short);
     });
   } catch {}
-  return { current: local.current, mainBranch: project.mainBranch, branches, remoteBranches };
+  return { current, branches, remoteBranches };
 }
 async function resolveBaseBranch(project, base) {
   const g = git(project.repoPath);
@@ -2674,7 +2964,7 @@ async function ensureTalkWorktree(project, feature) {
   const worktreePath = worktreeDir(project.id, feature.slug);
   const branch = featureBranch(feature.slug);
   const g = git(project.repoPath);
-  await ensureBranchExists(g, branch, feature.baseBranch ?? project.mainBranch);
+  await ensureBranchExists(g, branch, featureBase(feature));
   if (await worktreeIsValid(g, worktreePath, branch))
     return worktreePath;
   if (existsSync6(worktreePath) && (await registeredWorktrees(g)).has(canon(worktreePath))) {
@@ -2756,8 +3046,8 @@ function slash(path) {
 async function ensureProjectWorktree(project, onLanded) {
   const worktreePath = worktreeDir(project.id, PROJECT_WORKTREE_SLUG);
   const g = git(project.repoPath);
-  const base = project.mainBranch;
-  const landed = await landProjectBranch(project);
+  const base = await resolveSessionBranch(project);
+  const landed = await landProjectBranch(project, base);
   if (landed)
     onLanded?.(landed);
   const stillAhead = await branchCommitsAhead(project.repoPath, base, PROJECT_BRANCH);
@@ -2766,12 +3056,13 @@ async function ensureProjectWorktree(project, onLanded) {
     await g.raw(["branch", PROJECT_BRANCH, base]);
   }
   if (await worktreeIsValid(g, worktreePath, PROJECT_BRANCH))
-    return worktreePath;
+    return { worktreePath, base };
   if (existsSync6(worktreePath) && (await registeredWorktrees(g)).has(canon(worktreePath))) {
     if (await checkoutInWorktree(worktreePath, PROJECT_BRANCH))
-      return worktreePath;
+      return { worktreePath, base };
   }
-  return addWorktree(g, worktreePath, PROJECT_BRANCH, "project worktree");
+  const added = await addWorktree(g, worktreePath, PROJECT_BRANCH, "project worktree");
+  return { worktreePath: added, base };
 }
 async function checkoutInWorktree(worktreePath, branch) {
   const gw = git(worktreePath);
@@ -2935,7 +3226,7 @@ async function branchCommitsAhead(repoPath, base, branch) {
   }
 }
 async function reviewCommitCount(project, feature) {
-  const base = mergeTarget(project, feature);
+  const base = featureBase(feature);
   const branch = featureBranch(feature.slug);
   try {
     const out = (await git(project.repoPath).raw(["rev-list", "--count", `${base}..${branch}`])).trim();
@@ -2946,7 +3237,7 @@ async function reviewCommitCount(project, feature) {
   }
 }
 async function featureBranchDelta(project, feature) {
-  const base = mergeTarget(project, feature);
+  const base = featureBase(feature);
   const branch = featureBranch(feature.slug);
   try {
     const out = await git(project.repoPath).raw(["diff", "--stat", `${base}...${branch}`]);
@@ -3121,12 +3412,13 @@ async function deleteBranchDetachingWorktrees(g, repoPath, branch) {
     return false;
   }
 }
-async function landProjectBranch(project) {
-  const ahead = await branchCommitsAhead(project.repoPath, project.mainBranch, PROJECT_BRANCH);
+async function landProjectBranch(project, base) {
+  const ahead = await branchCommitsAhead(project.repoPath, base, PROJECT_BRANCH);
   if (ahead.length === 0)
     return null;
-  const res = await mergeTempBranch(project.repoPath, project.mainBranch, PROJECT_BRANCH);
+  const res = await mergeTempBranch(project.repoPath, base, PROJECT_BRANCH);
   return {
+    base,
     commits: ahead.length,
     landed: res.ok,
     ...res.conflict ? { conflict: true } : {},
@@ -3227,6 +3519,11 @@ async function commitDocs(worktreePath, message) {
     return;
   await g.commit(message, [DOCS_PATHSPEC]);
 }
+async function commitPipelineDocs(repoPath) {
+  try {
+    await commitDocs(repoPath, "runcastle: docs the pipeline left uncommitted");
+  } catch {}
+}
 function activeTestDriveFeatureId() {
   return testDriveState?.kind === "feature" ? testDriveState.featureId : undefined;
 }
@@ -3326,6 +3623,7 @@ async function testDrive(ctx, project, feature, action, purpose = "human") {
       ...teardown?.failure ? { hookFailure: teardown.failure } : {}
     };
   }
+  await commitPipelineDocs(project.repoPath);
   const porcelain = (await g.raw(["status", "--porcelain"])).trim();
   if (porcelain !== "")
     return { ok: false, deniedReason: DENY_DIRTY };
@@ -3507,7 +3805,7 @@ async function stopDryRun(ctx, project, state) {
   });
   const { participating, failure } = dryRunVerdict(project, state);
   if (!failure && participating.length > 0) {
-    const sha = await headSha(project.repoPath, project.mainBranch) ?? null;
+    const sha = await headSha(project.repoPath, await detectMainBranch(project.repoPath)) ?? null;
     markVerified(ctx, project.id, participating, sha);
     emitProject(ctx, project.id, {
       type: "prep.dryrun.verified",
@@ -3669,7 +3967,7 @@ async function detectDbDrift(ctx, project, feature, previousBranch, driveBranch)
   return drift;
 }
 async function mergeFeature(project, feature) {
-  const target = mergeTarget(project, feature);
+  const target = featureBase(feature);
   if (testDriveState) {
     throw new GateError("Cannot merge while a test drive is active \u2014 stop it first");
   }
@@ -4273,7 +4571,7 @@ function renderDriveFixPrompt(brief) {
 `);
 }
 function renderProjectPrompt(brief, runtime = DEFAULT_RUNTIME) {
-  const { project, branch, worktreePath } = brief;
+  const { project, branch, worktreePath, base } = brief;
   return [
     `# runcastle \u2014 ${project.name} (project session)`,
     "",
@@ -4299,8 +4597,8 @@ function renderProjectPrompt(brief, runtime = DEFAULT_RUNTIME) {
     "## Where you are working \u2014 and where your writes go",
     `- Working directory: \`${worktreePath}\` \u2014 a runcastle-owned worktree, NOT the human's`,
     `  checkout at \`${project.repoPath}\`.`,
-    `- Branch: \`${branch}\`, cut from \`${project.mainBranch}\` when this session launched.`,
-    `- **Your commits land on \`${project.mainBranch}\` when this terminal closes**, arriving`,
+    `- Branch: \`${branch}\`, cut from \`${base}\` when this session launched.`,
+    `- **Your commits land on \`${base}\` when this terminal closes**, arriving`,
     "  in the human's checkout the way a `git pull` does. Write real code and real docs \u2014",
     "  there is no sandbox here \u2014 and commit everything you write before you finish.",
     "  A session that edits without committing leaves a dirty tree, which is exactly what",
@@ -4587,10 +4885,24 @@ var init_claude = __esm(() => {
   };
 });
 
-// src/doctor/doctor.ts
+// src/services/codex-auth.ts
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join9 } from "path";
+function codexHomeDir(env = process.env) {
+  return env.CODEX_HOME ?? join9(env.HOME ?? env.USERPROFILE ?? homedir2(), ".codex");
+}
+function codexAuthFile(env = process.env) {
+  return join9(codexHomeDir(env), "auth.json");
+}
+function codexLoggedIn(env = process.env, fileExists = existsSync8) {
+  return fileExists(codexAuthFile(env));
+}
+var init_codex_auth = () => {};
+
+// src/doctor/doctor.ts
+import { existsSync as existsSync9, statSync } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
 async function versionProbe(exec, id, label, bin, fix) {
   const out = await exec(bin, ["--version"]);
   if (out.ok && out.code === 0) {
@@ -4622,9 +4934,6 @@ async function nodeProbe(exec) {
 async function gitProbe(exec) {
   return versionProbe(exec, "git", "Git", "git", "Install Git: winget install Git.Git / brew install git / apt install git");
 }
-function codexAuthFile(env) {
-  return join9(env.CODEX_HOME ?? join9(env.HOME ?? env.USERPROFILE ?? homedir2(), ".codex"), "auth.json");
-}
 function statusUnsupported(out) {
   return /unknown command|unrecognized subcommand|unexpected argument|invalid subcommand/i.test(`${out.stderr} ${out.stdout}`);
 }
@@ -4656,23 +4965,38 @@ async function runtimeAuthProbe(spec, exec, env, fileExists, severity) {
       fix: spec.installFix
     };
   }
+  const authFile = spec.authFile?.(env);
+  if (authFile) {
+    const present = fileExists(authFile);
+    const statusCommand = `${spec.bin} ${spec.authStatusArgs.join(" ")}`;
+    let coda;
+    if (statusUnsupported(out)) {
+      coda = ` \u2014 this ${spec.bin} cannot report login state`;
+    } else if (out.code === 0 === present) {
+      coda = ` \u2014 \`${statusCommand}\` agrees`;
+    } else if (present) {
+      coda = `, but \`${statusCommand}\` reports logged out \u2014 burns borrow the file, so this host counts as signed in`;
+    } else {
+      coda = `, but \`${statusCommand}\` reports a login \u2014 a burn borrows the file, and it is not there`;
+    }
+    return present ? { ...base, status: "ok", detail: `credentials found at ${authFile}${coda}` } : { ...loggedOut, detail: `no credentials at ${authFile}${coda}` };
+  }
   if (out.code === 0)
     return { ...base, status: "ok", detail: `${spec.bin} reports a login` };
   if (!statusUnsupported(out))
     return loggedOut;
-  const authFile = spec.authFile?.(env);
-  if (!authFile) {
-    return {
-      ...base,
-      status: "ok",
-      detail: `this ${spec.bin} cannot report login state \u2014 it prompts at launch`
-    };
-  }
-  return fileExists(authFile) ? { ...base, status: "ok", detail: `credentials found at ${authFile}` } : { ...loggedOut, detail: `no credentials at ${authFile}` };
+  return {
+    ...base,
+    status: "ok",
+    detail: `this ${spec.bin} cannot report login state \u2014 it prompts at launch`
+  };
 }
 function runtimeAfkKeyProbe(spec, env, severity = "error") {
+  const id = spec.ids.afkKey;
+  if (!id)
+    return;
   const base = {
-    id: spec.ids.afkKey,
+    id,
     label: `${spec.label} AFK ${spec.afkNoun} (${spec.afkKey})`,
     tier: 2,
     severity,
@@ -4691,11 +5015,12 @@ function runtimeAfkKeyProbe(spec, env, severity = "error") {
   };
 }
 async function runtimeProbes(spec, deps) {
-  const fileExists = deps.fileExists ?? existsSync8;
+  const fileExists = deps.fileExists ?? existsSync9;
+  const afkKeyProbe = runtimeAfkKeyProbe(spec, deps.env, deps.severity);
   return [
     await runtimeBinaryProbe(spec, deps.exec, deps.severity),
     await runtimeAuthProbe(spec, deps.exec, deps.env, fileExists, deps.severity),
-    runtimeAfkKeyProbe(spec, deps.env, deps.severity)
+    ...afkKeyProbe ? [afkKeyProbe] : []
   ];
 }
 async function gitIdentityProbe(exec, cwd) {
@@ -4784,15 +5109,29 @@ async function containerRuntimeProbe(exec) {
     fix: "Install Docker Desktop or Podman (see docs/research/PREREQS-NOTES.md \xA74). Not needed for interactive-only use."
   };
 }
-async function sandcastleImageProbe(exec, imageName) {
+async function sandcastleImageProbe(exec, imageName, burnerDockerfile, fileMtime) {
   const id = "sandcastle-image";
   const label = "Sandcastle container image";
   for (const runtime of ["docker", "podman"]) {
     const present = await exec(runtime, ["--version"]);
     if (!(present.ok && present.code === 0))
       continue;
-    const inspect = await exec(runtime, ["image", "inspect", imageName]);
+    const inspect = await exec(runtime, ["image", "inspect", "--format", "{{.Created}}", imageName]);
     if (inspect.ok && inspect.code === 0) {
+      const created = new Date(inspect.stdout.trim());
+      const dockerfileChanged = fileMtime(burnerDockerfile);
+      if (dockerfileChanged > created) {
+        const date = (value) => value.toISOString().slice(0, 10);
+        return {
+          id,
+          label,
+          tier: 2,
+          status: "stale",
+          severity: "error",
+          detail: `${imageName} built ${date(created)}, burner Dockerfile changed ${date(dockerfileChanged)} \u2014 rebuild`,
+          fix: 'Open Settings \u2192 AFK burns and click "Rebuild image".'
+        };
+      }
       return { id, label, tier: 2, status: "ok", severity: "error", detail: `${imageName} present` };
     }
     return {
@@ -4819,6 +5158,8 @@ async function runDoctor(env) {
   const { exec } = env;
   const processEnv = env.env ?? process.env;
   const imageName = env.imageName ?? DEFAULT_SANDBOX_IMAGE;
+  const burnerDockerfile = env.burnerDockerfile ?? fileURLToPath4(new URL("../assets/sandcastle/Dockerfile", import.meta.url));
+  const fileMtime = env.fileMtime ?? ((path) => statSync(path).mtime);
   const required = new Set(env.runtimes ?? [DEFAULT_RUNTIME]);
   const results = [
     await bunProbe(exec),
@@ -4833,7 +5174,7 @@ async function runDoctor(env) {
       severity: required.has(runtime) ? "error" : "info"
     }));
   }
-  results.push(await gitIdentityProbe(exec, env.cwd), await containerRuntimeProbe(exec), await sandcastleImageProbe(exec, imageName));
+  results.push(await gitIdentityProbe(exec, env.cwd), await containerRuntimeProbe(exec), await sandcastleImageProbe(exec, imageName, burnerDockerfile, fileMtime));
   const counts = (r) => r.severity === "error";
   return {
     results,
@@ -4849,6 +5190,7 @@ function exitCodeFor(report, mode) {
 var RUNTIME_SPECS;
 var init_doctor = __esm(() => {
   init_src();
+  init_codex_auth();
   RUNTIME_SPECS = {
     "claude-code": {
       runtime: "claude-code",
@@ -4868,13 +5210,13 @@ var init_doctor = __esm(() => {
       runtime: "codex",
       label: "Codex",
       bin: "codex",
-      ids: { binary: "codex", auth: "codex-auth", afkKey: "codex-api-key" },
+      ids: { binary: "codex", auth: "codex-auth" },
       authStatusArgs: ["login", "status"],
       loginCommand: "codex login",
       loginArgs: ["login"],
       afkKey: "CODEX_API_KEY",
       afkNoun: "API key",
-      afkFix: "Create an OpenAI API key (platform.openai.com/api-keys) and put CODEX_API_KEY in ~/.runcastle/.env",
+      afkFix: "Set CODEX_API_KEY in ~/.runcastle/.env to bill an OpenAI API key instead of your ChatGPT login",
       installFix: "Install Codex: npm install -g @openai/codex (or: brew install codex)",
       binOverrideEnv: "RUNCASTLE_CODEX_BIN",
       authFile: codexAuthFile
@@ -4885,31 +5227,33 @@ var init_doctor = __esm(() => {
 // src/launcher/runtimes/codex.ts
 import {
   copyFileSync,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   readdirSync as readdirSync2,
-  statSync,
+  statSync as statSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir3 } from "os";
 import { basename, dirname as dirname3, join as join10, resolve as resolve7 } from "path";
-function codexHomeDir(sessionId) {
+function codexHomeDir2(sessionId) {
   return join10(sessionDir(sessionId), "codex-home");
 }
 function realCodexAuthFile(env = process.env) {
-  return CODEX.authFile?.(env) ?? join10(homedir3(), ".codex", "auth.json");
+  return codexAuthFile(env);
 }
 function toml(value) {
   return JSON.stringify(value);
 }
+function approvalPolicyFor(permissionMode) {
+  return permissionMode === undefined || permissionMode === "acceptEdits" ? "never" : "untrusted";
+}
 function renderCodexConfig(input) {
-  const { session, config: config2, model, worktreePath, inheritedMcpServers } = input;
+  const { session, config: config2, model, worktreePath, inheritedMcpServers, permissionMode } = input;
   return [
     `# Generated by runcastle for session ${session.id} \u2014 rewritten at every launch.`,
     `model = ${toml(model)}`,
     'sandbox_mode = "workspace-write"',
-    'approval_policy = "never"',
+    `approval_policy = ${toml(approvalPolicyFor(permissionMode))}`,
     "",
     `[projects.${toml(worktreePath)}]`,
     'trust_level = "trusted"',
@@ -4941,7 +5285,7 @@ function mcpServerTables(userConfigToml) {
 }
 function readInheritedMcpServers(env = process.env) {
   const path = join10(dirname3(realCodexAuthFile(env)), "config.toml");
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return "";
   try {
     return mcpServerTables(readFileSync4(path, "utf8"));
@@ -4965,15 +5309,15 @@ function renderCodexHooks(hookClient, kind, platform = process.platform) {
   };
 }
 function writeCodexSkills(worktreePath, packDir) {
-  if (!existsSync9(worktreePath))
+  if (!existsSync10(worktreePath))
     return [];
   const source = join10(packDir, "skills");
-  if (!existsSync9(source))
+  if (!existsSync10(source))
     return [];
   const written = [];
   for (const name of readdirSync2(source)) {
     const skill = join10(source, name, "SKILL.md");
-    if (!existsSync9(skill))
+    if (!existsSync10(skill))
       continue;
     const target = join10(worktreePath, CODEX_SKILLS_REL, name);
     mkdirSync4(target, { recursive: true });
@@ -4992,7 +5336,7 @@ function excludeFromGit(worktreePath, entry) {
       return;
     mkdirSync4(info, { recursive: true });
     const path = join10(info, "exclude");
-    const existing = existsSync9(path) ? readFileSync4(path, "utf8") : "";
+    const existing = existsSync10(path) ? readFileSync4(path, "utf8") : "";
     if (existing.split(/\r?\n/).some((line) => line.trim() === entry))
       return;
     const head = existing.length > 0 && !existing.endsWith(`
@@ -5004,9 +5348,9 @@ function excludeFromGit(worktreePath, entry) {
 }
 function gitInfoDir(worktreePath) {
   const dotGit = join10(worktreePath, ".git");
-  if (!existsSync9(dotGit))
+  if (!existsSync10(dotGit))
     return null;
-  if (statSync(dotGit).isDirectory())
+  if (statSync2(dotGit).isDirectory())
     return join10(dotGit, "info");
   const named = /^gitdir:\s*(.+)$/m.exec(readFileSync4(dotGit, "utf8"));
   if (!named)
@@ -5025,6 +5369,7 @@ var CODEX_BIN = "codex", CODEX, CODEX_SKILLS_REL, CODEX_SKILLS_IGNORE = ".agents
 var init_codex = __esm(() => {
   init_paths();
   init_doctor();
+  init_codex_auth();
   init_resolve_executable();
   init_artifacts();
   init_edit_guard();
@@ -5047,7 +5392,7 @@ var init_codex = __esm(() => {
           doctorHint: 'Run `runcastle doctor` and fix its "Codex CLI" probe, then restart runcastle from a ' + "terminal where `codex --version` works."
         };
       }
-      if (!existsSync9(realCodexAuthFile())) {
+      if (!existsSync10(realCodexAuthFile())) {
         return {
           ok: false,
           reason: "Codex is installed but not logged in \u2014 runcastle copies your own credentials into " + `each session's home, and there are none at ${realCodexAuthFile()}`,
@@ -5057,7 +5402,7 @@ var init_codex = __esm(() => {
       return { ok: true };
     },
     async writeArtifacts(input) {
-      const home = codexHomeDir(input.session.id);
+      const home = codexHomeDir2(input.session.id);
       mkdirSync4(home, { recursive: true });
       const configPath2 = join10(home, "config.toml");
       const hooksPath = join10(home, "hooks.json");
@@ -5067,13 +5412,14 @@ var init_codex = __esm(() => {
         config: input.config,
         model: input.model,
         worktreePath: input.worktreePath,
+        ...input.permissionMode ? { permissionMode: input.permissionMode } : {},
         ...input.config.sessionMcp === "inherit" ? { inheritedMcpServers: readInheritedMcpServers() } : {}
       }), "utf8");
       writeFileSync3(hooksPath, JSON.stringify(renderCodexHooks(hookClientPath(), input.session.kind), null, 2), "utf8");
       writeFileSync3(agentsPath, renderSessionPrompt({ ...input, runtime: this.id }), "utf8");
       const files = [configPath2, hooksPath, agentsPath];
       const auth = realCodexAuthFile();
-      if (existsSync9(auth)) {
+      if (existsSync10(auth)) {
         const copied = join10(home, "auth.json");
         copyFileSync(auth, copied);
         files.push(copied);
@@ -5116,7 +5462,7 @@ var init_runtimes = __esm(() => {
 });
 
 // src/launcher/sessions.ts
-import { statSync as statSync2 } from "fs";
+import { statSync as statSync3 } from "fs";
 import { and as and5, desc as desc3, eq as eq5, inArray, isNotNull, sql as sql2 } from "drizzle-orm";
 function createSessionRow(ctx, input) {
   const row = ctx.db.insert(sessions).values({
@@ -5375,20 +5721,18 @@ function landProjectSession(ctx, session) {
   const project = getProjectById(ctx, session.projectId);
   if (!project)
     return;
-  const landing = landProjectBranch(project).then((res) => {
-    if (res)
-      reportProjectLanding(ctx, project, res, { sessionId: session.id });
-  }).catch((e) => {
+  const landFailed = (base, e) => {
+    const error = e instanceof Error ? e.message : String(e);
     emitProject(ctx, project.id, {
       type: "project.land_failed",
-      message: `could not land the project session's work onto ${project.mainBranch}: ${e instanceof Error ? e.message : String(e)} \u2014 ${LANDING_KEPT}`,
-      data: {
-        sessionId: session.id,
-        branch: PROJECT_BRANCH,
-        error: e instanceof Error ? e.message : String(e)
-      }
+      message: `could not land the project session's work${base ? ` onto ${base}` : ""}: ${error} \u2014 ${LANDING_KEPT}`,
+      data: { sessionId: session.id, branch: PROJECT_BRANCH, error }
     });
-  });
+  };
+  const landing = resolveSessionBranch(project).then((base) => landProjectBranch(project, base).then((res) => {
+    if (res)
+      reportProjectLanding(ctx, project, res, { sessionId: session.id });
+  }, (e) => landFailed(base, e)), (e) => landFailed(null, e));
   inFlightLandings.add(landing);
   landing.finally(() => inFlightLandings.delete(landing));
 }
@@ -5401,11 +5745,11 @@ function reportProjectLanding(ctx, project, res, data = {}) {
     });
   };
   if (res.landed) {
-    report("project.landed", `landed ${res.commits} commit(s) from the project session onto ${project.mainBranch}`, { commits: res.commits });
+    report("project.landed", `landed ${res.commits} commit(s) from the project session onto ${res.base}`, { commits: res.commits });
   } else if (res.conflict) {
-    report("project.land_conflict", `the project session's ${res.commits} commit(s) conflict with ${project.mainBranch} \u2014 nothing was overwritten; ${LANDING_KEPT}`, { commits: res.commits, files: res.files ?? [] });
+    report("project.land_conflict", `the project session's ${res.commits} commit(s) conflict with ${res.base} \u2014 nothing was overwritten; ${LANDING_KEPT}`, { commits: res.commits, files: res.files ?? [] });
   } else {
-    report("project.land_failed", `could not land the project session's ${res.commits} commit(s) onto ${project.mainBranch}: ${res.error ?? "unknown error"} \u2014 ${LANDING_KEPT}`, { commits: res.commits, error: res.error ?? null });
+    report("project.land_failed", `could not land the project session's ${res.commits} commit(s) onto ${res.base}: ${res.error ?? "unknown error"} \u2014 ${LANDING_KEPT}`, { commits: res.commits, error: res.error ?? null });
   }
 }
 function markSessionEnded(ctx, id) {
@@ -5469,7 +5813,7 @@ function transcriptBytes(session) {
   if (!session?.transcriptPath)
     return;
   try {
-    return statSync2(session.transcriptPath).size;
+    return statSync3(session.transcriptPath).size;
   } catch {
     return;
   }
@@ -5584,7 +5928,8 @@ function rowToTicket(row) {
     error: row.error ?? undefined,
     attemptBranch: row.attemptBranch ?? undefined,
     conflictFiles: row.conflictFiles ?? undefined,
-    digest: row.digest ?? undefined
+    digest: row.digest ?? undefined,
+    originFindingId: row.originFindingId ?? undefined
   });
 }
 function resolveBlocking(inputs, startSeq) {
@@ -5609,13 +5954,13 @@ function normalizeModel(ctx, value) {
 function listByFeature2(ctx, featureId) {
   return ctx.db.select().from(tickets).where(eq6(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
 }
-function storeTickets(ctx, featureId, inputs) {
+function storeTickets(ctx, featureId, inputs, options = {}) {
   if (inputs.length === 0)
     return [];
   const { lap } = getFeatureRow(ctx, featureId);
   const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq6(tickets.featureId, featureId)).all();
   const startSeq = existing.reduce((max2, r) => Math.max(max2, r.seq), 0) + 1;
-  const resolved = resolveBlocking(inputs, startSeq);
+  const resolved = options.blockedByAreGlobal ? inputs.map((input, index2) => ({ seq: startSeq + index2, blockedBy: input.blockedBy })) : resolveBlocking(inputs, startSeq);
   const rows = inputs.map((t, i) => ({
     id: newId("tkt"),
     featureId,
@@ -5634,7 +5979,8 @@ function storeTickets(ctx, featureId, inputs) {
     error: null,
     attemptBranch: null,
     conflictFiles: null,
-    digest: null
+    digest: null,
+    originFindingId: t.originFindingId ?? null
   }));
   ctx.db.insert(tickets).values(rows).run();
   emit(ctx, featureId, {
@@ -5746,7 +6092,7 @@ var init_tickets = __esm(() => {
 });
 
 // src/services/gates.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { and as and7, desc as desc4, eq as eq7, inArray as inArray3 } from "drizzle-orm";
 function checkGate(ctx, check, feature) {
   switch (check) {
@@ -5796,7 +6142,7 @@ function notYetTerminal(noun, statuses, order) {
 }
 function fileGate(ctx, feature, fileName, reason) {
   const project = projectForFeature(ctx, feature);
-  return existsSync10(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
+  return existsSync11(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
 }
 function docGate(ctx, feature, fileName, reason) {
   const file = fileGate(ctx, feature, fileName, reason);
@@ -5860,14 +6206,14 @@ var init_gates = __esm(() => {
 });
 
 // src/services/knowledge.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
 import { join as join11, relative as relative2, resolve as resolve8, sep } from "path";
 function scaffoldDocs(ctx, feature, opts = {}) {
   const project = projectForFeature(ctx, feature);
   const dir = featureDocsDir(project, feature);
   mkdirSync5(dir, { recursive: true });
   const briefPath = featureDocPath(project, feature, "brief.md");
-  if (!existsSync11(briefPath)) {
+  if (!existsSync12(briefPath)) {
     const override = opts.brief?.trim();
     const created = new Date().toISOString();
     const brief = override ? `${override}
@@ -5894,7 +6240,7 @@ function scaffoldDocs(ctx, feature, opts = {}) {
 function scaffoldMapDoc(project, feature, seed) {
   mkdirSync5(featureDocsDir(project, feature), { recursive: true });
   const mapPath = featureDocPath(project, feature, "map.md");
-  if (existsSync11(mapPath))
+  if (existsSync12(mapPath))
     return;
   writeFileSync4(mapPath, mapDocBody(feature, seed), "utf8");
 }
@@ -5915,7 +6261,7 @@ function mapDocBody(feature, seed) {
 }
 function readCharter(repoRoot) {
   const path = join11(repoRoot, CHARTER_FILE);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return;
   try {
     return readFileSync5(path, "utf8");
@@ -5925,7 +6271,7 @@ function readCharter(repoRoot) {
 }
 function listLiveAdrs(repoRoot) {
   const dir = join11(repoRoot, ADR_DIR_REL);
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return [];
   const docs2 = [];
   for (const entry of readdirSync3(dir, { withFileTypes: true })) {
@@ -5946,7 +6292,7 @@ function listLiveAdrs(repoRoot) {
 function listDocs(ctx, feature) {
   const project = projectForFeature(ctx, feature);
   const dir = featureDocsDir(project, feature);
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return [];
   return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => ({ relPath: e.name, title: readTitle(join11(dir, e.name), e.name) })).sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
@@ -5959,7 +6305,7 @@ function readDoc(ctx, feature, relPath) {
   if (rel === "" || rel.startsWith("..") || rel.split(sep).includes("..")) {
     throw new InvalidInputError(`doc path escapes the feature docs dir: ${relPath}`);
   }
-  if (!existsSync11(target))
+  if (!existsSync12(target))
     throw new NotFoundError(`doc not found: ${relPath}`);
   return { content: readFileSync5(target, "utf8") };
 }
@@ -6016,13 +6362,197 @@ var init_end_session = __esm(() => {
   init_registry();
 });
 
+// src/services/review-findings.ts
+import { and as and8, asc as asc4, eq as eq8, isNotNull as isNotNull2 } from "drizzle-orm";
+function rowToFinding(row) {
+  return ReviewFinding.parse(row);
+}
+function getFinding(ctx, id) {
+  const row = ctx.db.select().from(reviewFindings).where(eq8(reviewFindings.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`review finding ${id} not found`);
+  return rowToFinding(row);
+}
+function listByFeature3(ctx, featureId) {
+  return ctx.db.select().from(reviewFindings).where(eq8(reviewFindings.featureId, featureId)).orderBy(asc4(reviewFindings.createdAt), asc4(reviewFindings.id)).all().map(rowToFinding);
+}
+function buildFixTicket(finding) {
+  return {
+    title: finding.title,
+    goal: `Fix: ${finding.title}`,
+    context: [
+      `Location: ${finding.location}`,
+      `Citation: ${finding.citation}`,
+      `Detail: ${finding.detail}`,
+      `Repro step: ${finding.reproStep}`
+    ].join(`
+
+`),
+    acceptanceCriteria: [
+      `The repro step no longer reproduces / the cited criterion holds: ${finding.reproStep}`
+    ],
+    seams: [],
+    blockedBy: [],
+    kind: "implementation",
+    originFindingId: finding.id
+  };
+}
+function reportFinding(ctx, args) {
+  const { featureId, reviewTicket, input } = args;
+  const feature = getFeatureRow(ctx, featureId);
+  const id = newId("finding");
+  const ticketCount = ctx.db.select({ id: reviewFindings.id }).from(reviewFindings).where(and8(eq8(reviewFindings.reviewTicketId, reviewTicket.id), isNotNull2(reviewFindings.fixTicketId))).all().length;
+  const overCap = input.kind === "defect" && ticketCount >= AUTO_FIX_CAP;
+  ctx.db.insert(reviewFindings).values({
+    id,
+    featureId,
+    lap: feature.lap,
+    reviewTicketId: reviewTicket.id,
+    ...input,
+    reproStep: input.reproStep ?? "",
+    status: "open",
+    openReason: overCap ? "over-cap" : null,
+    failureReason: null,
+    fixTicketId: null,
+    createdAt: Date.now()
+  }).run();
+  let fixTicket = null;
+  if (input.kind === "defect" && !overCap) {
+    const finding2 = getFinding(ctx, id);
+    fixTicket = storeTickets(ctx, featureId, [
+      { ...buildFixTicket(finding2), blockedBy: [reviewTicket.seq] }
+    ], { blockedByAreGlobal: true })[0];
+    ctx.db.update(reviewFindings).set({ fixTicketId: fixTicket.id }).where(eq8(reviewFindings.id, id)).run();
+  }
+  const finding = getFinding(ctx, id);
+  emit(ctx, featureId, {
+    type: "finding.reported",
+    message: `${input.kind} reported: ${input.title}`,
+    ticketId: fixTicket?.id,
+    data: { findingId: id, fixTicketId: fixTicket?.id, overCap }
+  });
+  return { finding, fixTicket, overCap };
+}
+function updateStatus(ctx, findingId, patch) {
+  const current2 = getFinding(ctx, findingId);
+  ctx.db.update(reviewFindings).set(patch).where(eq8(reviewFindings.id, findingId)).run();
+  emit(ctx, current2.featureId, {
+    type: "finding.updated",
+    message: `finding ${findingId} marked ${patch.status}`,
+    data: { findingId, status: patch.status, reason: patch.failureReason }
+  });
+  return getFinding(ctx, findingId);
+}
+function markFixing(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "fixing",
+    openReason: null,
+    failureReason: null
+  });
+}
+function markFixed(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "fixed",
+    openReason: null,
+    failureReason: null
+  });
+}
+function markFailed(ctx, findingId, reason) {
+  return updateStatus(ctx, findingId, {
+    status: "failed",
+    openReason: "fix-failed",
+    failureReason: reason ?? null
+  });
+}
+function markFixProgress(ctx, findingId, progress, reason) {
+  if (progress === "fixing")
+    return markFixing(ctx, findingId);
+  if (progress === "fixed")
+    return markFixed(ctx, findingId);
+  return markFailed(ctx, findingId, reason);
+}
+function dismiss(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "dismissed",
+    openReason: null,
+    failureReason: null
+  });
+}
+function defectState(finding, fixTicket) {
+  if (finding.status === "dismissed")
+    return "dismissed";
+  if (finding.status === "fixed" || fixTicket?.status === "done")
+    return "fixed";
+  if (fixTicket && fixTicket.status !== "failed" && fixTicket.status !== "cancelled") {
+    return "fixing";
+  }
+  return finding.status === "open" || finding.status === "failed" ? "open" : "fixing";
+}
+function viewByFeature(ctx, featureId) {
+  const findings = listByFeature3(ctx, featureId);
+  const tickets2 = listByFeature2(ctx, featureId);
+  const summary = { found: 0, fixed: 0, open: 0, observations: 0 };
+  const openDefects = [];
+  for (const finding of findings) {
+    if (finding.kind === "observation") {
+      summary.observations += 1;
+      continue;
+    }
+    summary.found += 1;
+    const state = defectState(finding, fixTicketOf(finding, tickets2));
+    if (state === "fixed")
+      summary.fixed += 1;
+    else if (state === "open") {
+      summary.open += 1;
+      openDefects.push(finding);
+    }
+  }
+  return { findings, openDefects, summary };
+}
+function fixTicketOf(finding, tickets2) {
+  return finding.fixTicketId ? tickets2.find((t) => t.id === finding.fixTicketId) : undefined;
+}
+function promoteOpenDefects(ctx, featureId) {
+  const defects = viewByFeature(ctx, featureId).openDefects;
+  if (defects.length === 0)
+    throw new InvalidInputError("no open defects to fix");
+  const tickets2 = storeTickets(ctx, featureId, defects.map(buildFixTicket));
+  const findings = defects.map((defect, index2) => {
+    ctx.db.update(reviewFindings).set({
+      status: "fixing",
+      openReason: null,
+      failureReason: null,
+      fixTicketId: tickets2[index2].id
+    }).where(eq8(reviewFindings.id, defect.id)).run();
+    return getFinding(ctx, defect.id);
+  });
+  emit(ctx, featureId, {
+    type: "finding.fixing",
+    message: `${findings.length} open defect${findings.length === 1 ? "" : "s"} promoted to fix ticket${tickets2.length === 1 ? ` ${tickets2[0].seq}` : `s ${tickets2.map((t) => t.seq).join(", ")}`}`,
+    data: { findingIds: findings.map((f) => f.id), seqs: tickets2.map((t) => t.seq) }
+  });
+  return { findings, tickets: tickets2 };
+}
+var AUTO_FIX_CAP = 8;
+var init_review_findings = __esm(() => {
+  init_src();
+  init_schema();
+  init_errors();
+  init_events();
+  init_repo();
+  init_tickets();
+});
+
 // src/services/settings.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname4 } from "path";
 import * as z3 from "zod";
-import { eq as eq8 } from "drizzle-orm";
+import { eq as eq9 } from "drizzle-orm";
+function hostDefaults(logicalCpus) {
+  return { ...DEFAULTS, burnConcurrency: resolveDefaultBurnConcurrency(logicalCpus) };
+}
 function readRawConfig(configFile) {
-  if (!existsSync12(configFile))
+  if (!existsSync13(configFile))
     return {};
   try {
     const parsed = JSON.parse(readFileSync6(configFile, "utf8"));
@@ -6052,6 +6582,7 @@ function projectOverrides(ctx, projectId) {
   const row = ctx.db.select({
     model: projects.model,
     sandbox: projects.sandbox,
+    sessionBranch: projects.sessionBranch,
     devCommand: projects.devCommand,
     setupCommand: projects.setupCommand,
     verifyCommands: projects.verifyCommands,
@@ -6059,10 +6590,11 @@ function projectOverrides(ctx, projectId) {
     dbResetCommand: projects.dbResetCommand,
     driveSetupCommand: projects.driveSetupCommand,
     driveStopCommand: projects.driveStopCommand
-  }).from(projects).where(eq8(projects.id, projectId)).get();
+  }).from(projects).where(eq9(projects.id, projectId)).get();
   return {
     model: row?.model ?? null,
     sandbox: row?.sandbox ?? null,
+    sessionBranch: row?.sessionBranch ?? null,
     devCommand: row?.devCommand ?? null,
     setupCommand: row?.setupCommand ?? null,
     verifyCommands: row?.verifyCommands ?? null,
@@ -6091,15 +6623,16 @@ function resolveField(desc5, layers) {
   if (desc5.configKey && Object.prototype.hasOwnProperty.call(layers.fileRaw, desc5.configKey)) {
     return { ...base, value: layers.fileRaw[desc5.configKey], source: "file", editable: true };
   }
-  const value = desc5.configKey ? DEFAULTS[desc5.configKey] ?? null : null;
+  const value = desc5.configKey ? layers.defaults[desc5.configKey] ?? null : null;
   return { ...base, value, source: "default", editable: true };
 }
 function getSettings(ctx, projectId, io = {}) {
   const env = io.env ?? process.env;
   const fileRaw = readRawConfig(io.configFile ?? configPath());
   const overrides = projectId !== undefined ? projectOverrides(ctx, projectId) : null;
+  const defaults = hostDefaults(io.logicalCpus ?? hostLogicalCpus());
   const visible = DESCRIPTORS.filter((d) => projectId !== undefined || d.configKey !== undefined);
-  const fields = visible.map((d) => resolveField(d, { env, fileRaw, overrides }));
+  const fields = visible.map((d) => resolveField(d, { env, fileRaw, overrides, defaults }));
   return { projectId, fields: [...fields, ...stepModelFields(fileRaw)] };
 }
 function updateSettings(ctx, input, io = {}) {
@@ -6122,7 +6655,7 @@ function updateSettings(ctx, input, io = {}) {
     if (!toProject)
       throw new InvalidInputError(`${desc5.key} cannot be cleared`);
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq8(projects.id, project.id)).run();
+    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq9(projects.id, project.id)).run();
     recordHuman(ctx, project.id, desc5.key, null);
     emitProject(ctx, project.id, {
       type: "settings.updated",
@@ -6138,7 +6671,7 @@ function updateSettings(ctx, input, io = {}) {
   const value = parsed.data;
   if (toProject) {
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq8(projects.id, project.id)).run();
+    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq9(projects.id, project.id)).run();
     recordHuman(ctx, project.id, desc5.key, String(value));
     emitProject(ctx, project.id, {
       type: "settings.updated",
@@ -6217,6 +6750,7 @@ function field(view, key) {
 var GLOBAL_EVENT_KEY = "global", idEnv = (raw) => raw, DESCRIPTORS, DEFAULTS, STEP_SET;
 var init_settings = __esm(() => {
   init_src();
+  init_config_load();
   init_paths();
   init_schema();
   init_errors();
@@ -6341,16 +6875,15 @@ var init_settings = __esm(() => {
       parseEnv: idEnv
     },
     {
-      key: "mainBranch",
-      configKey: "mainBranch",
-      envVar: "RUNCASTLE_MAIN_BRANCH",
+      key: "devCommand",
+      projectColumn: "devCommand",
       restartRequired: false,
       valueSchema: z3.string().min(1),
       parseEnv: idEnv
     },
     {
-      key: "devCommand",
-      projectColumn: "devCommand",
+      key: "sessionBranch",
+      projectColumn: "sessionBranch",
       restartRequired: false,
       valueSchema: z3.string().min(1),
       parseEnv: idEnv
@@ -6382,9 +6915,9 @@ var init_settings = __esm(() => {
 });
 
 // src/services/setup.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname5, join as join12 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 async function writeGitIdentity(exec, identity) {
   const name = identity.name.trim();
   const email = identity.email.trim();
@@ -6487,10 +7020,10 @@ async function resolveRuntime(exec, preferred) {
 function resolveSandcastleBin() {
   try {
     const mainUrl = import.meta.resolve("@ai-hero/sandcastle");
-    let dir = dirname5(fileURLToPath4(mainUrl));
+    let dir = dirname5(fileURLToPath5(mainUrl));
     for (let hops = 0;hops < 6; hops++) {
       const manifestPath = join12(dir, "package.json");
-      if (existsSync13(manifestPath)) {
+      if (existsSync14(manifestPath)) {
         const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
         if (manifest.name === "@ai-hero/sandcastle" && manifest.bin?.sandcastle) {
           return join12(dir, manifest.bin.sandcastle);
@@ -6522,22 +7055,19 @@ function terminalSpec(kind, opts) {
   };
 }
 function sandcastleTemplateDir() {
-  return resolveAsset(ASSET_ENV.sandcastleTemplate, fileURLToPath4(new URL("../assets/sandcastle", import.meta.url)));
+  return resolveAsset(ASSET_ENV.sandcastleTemplate, fileURLToPath5(new URL("../assets/sandcastle", import.meta.url)));
 }
-function scaffoldSandcastleConfig(templateDir, targetDir) {
+function refreshSandcastleConfig(templateDir, targetDir) {
   const dir = join12(targetDir, ".sandcastle");
-  if (existsSync13(dir))
-    return { scaffolded: false, dir };
   mkdirSync7(dir, { recursive: true });
   for (const name of readdirSync4(templateDir)) {
     copyFileSync2(join12(templateDir, name), join12(dir, name));
   }
-  return { scaffolded: true, dir };
+  return dir;
 }
-function prepareSandboxBuildContext() {
-  const target = sandboxBuildDir();
+function prepareSandboxBuildContext(templateDir = sandcastleTemplateDir(), target = sandboxBuildDir()) {
   mkdirSync7(target, { recursive: true });
-  scaffoldSandcastleConfig(sandcastleTemplateDir(), target);
+  refreshSandcastleConfig(templateDir, target);
   return target;
 }
 function createCredentialVerifier(exec, runtime = DEFAULT_RUNTIME) {
@@ -6573,7 +7103,7 @@ function createCredentialVerifier(exec, runtime = DEFAULT_RUNTIME) {
 function fileAfkTokenIo(exec, runtime = DEFAULT_RUNTIME) {
   const path = envPath();
   return {
-    read: () => existsSync13(path) ? readFileSync7(path, "utf8") : "",
+    read: () => existsSync14(path) ? readFileSync7(path, "utf8") : "",
     write: (content) => {
       mkdirSync7(dirname5(path), { recursive: true });
       writeFileSync6(path, content, "utf8");
@@ -6597,7 +7127,7 @@ var init_setup = __esm(() => {
   };
   RUNTIME_AUTH_SETUP_HINT = {
     "claude-code": RUNTIME_SPECS["claude-code"].afkFix,
-    codex: RUNTIME_SPECS.codex.afkFix
+    codex: `Run \`${RUNTIME_SPECS.codex.loginCommand}\` on this host, then burn again`
   };
   LOGIN_TERMINAL_KIND = {
     "claude-code": "claude-login",
@@ -6605,6 +7135,32 @@ var init_setup = __esm(() => {
   };
 });
 
+// src/doctor/system-exec.ts
+import { spawn as spawn4 } from "child_process";
+function createSystemExec(opts = {}) {
+  return (command, args) => new Promise((resolve9) => {
+    const { file, args: spawnArgs } = resolveSpawnTarget(command, args);
+    let stdout = "";
+    let stderr = "";
+    const child = spawn4(file, spawnArgs, { cwd: opts.cwd, windowsHide: true });
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      resolve9({ ok: false, code: null, stdout, stderr: stderr || String(err) });
+    });
+    child.on("close", (code) => {
+      resolve9({ ok: true, code: code ?? 0, stdout, stderr });
+    });
+  });
+}
+var init_system_exec = __esm(() => {
+  init_resolve_executable();
+});
+
 // src/services/agent-stream.ts
 function beginTranscript(ticketId) {
   transcripts.set(ticketId, { live: true, chunks: [], nextIndex: 0, bytes: 0 });
@@ -6660,13 +7216,15 @@ function renderGuardScript(rules = GUARD_RULES) {
     "command -v jq >/dev/null 2>&1 || exit 0",
     'tool=$(printf %s "$payload" | jq -r ".tool_name // empty" 2>/dev/null || true)',
     '[ "$tool" = "Bash" ] || exit 0',
-    'cmd=$(printf %s "$payload" | jq -r ".tool_input.command // empty" 2>/dev/null || true)',
-    '[ -n "$cmd" ] || exit 0',
+    'raw_cmd=$(printf %s "$payload" | jq -r ".tool_input.command // empty" 2>/dev/null || true)',
+    '[ -n "$raw_cmd" ] || exit 0',
     "",
     "# Match against the command with quoted spans blanked, so an argument is",
     '# never read as a command: `grep -rn "git stash" docs/` searches for a',
-    "# string, it does not run one.",
-    `cmd=$(printf %s "$cmd" | sed "s/'[^']*'/ /g; s/\\"[^\\"]*\\"/ /g")`,
+    "# string, it does not run one. Flatten newlines so one grep sees a whole",
+    "# multiline loop.",
+    "cmd=$raw_cmd",
+    `cmd=$(printf %s "$cmd" | sed "s/'[^']*'/ /g; s/\\"[^\\"]*\\"/ /g" | tr '\\n' ' ')`,
     "",
     "deny() {",
     `  printf %s "$1" | jq -R -s '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:.}}'`,
@@ -6675,7 +7233,8 @@ function renderGuardScript(rules = GUARD_RULES) {
     ""
   ];
   for (const rule of rules) {
-    lines.push(`# ${rule.id}`, `if printf %s "$cmd" | grep -Eq -- ${shSingleQuote(rule.pattern)}; then`, `  deny ${shSingleQuote(rule.reason)}`, "fi", "");
+    const commandVariable = rule.inspectQuotedArguments ? "$raw_cmd" : "$cmd";
+    lines.push(`# ${rule.id}`, `if printf %s "${commandVariable}" | grep -Eq -- ${shSingleQuote(rule.pattern)}; then`, `  deny ${shSingleQuote(rule.reason)}`, "fi", "");
   }
   lines.push("exit 0", "");
   return lines.join(`
@@ -6725,11 +7284,37 @@ var init_burn_guard = __esm(() => {
       pattern: "--maxWorkers|--runInBand|--pool=|--shard=|singleFork|--poolOptions",
       reason: `Do not override the test runner's concurrency. Measured in this sandbox, a suite that runs in ~55s at its configured concurrency takes 10-20 minutes serialised, so this "safe" flag is the single most expensive habit in a burn. Run the repo's test command as configured. If it is killed for memory, run only the test files your change touches and say so in your final message.`
     },
+    {
+      id: "no-long-sleep",
+      pattern: `${CMD_START}sleep[[:space:]]+((3[1-9]|[4-9][0-9]|[1-9][0-9]{2,})s?|[1-9][0-9]*(m|h|d))([^A-Za-z0-9_]|$)`,
+      reason: "Polling and long sleeps are never needed in a burn. Run the command directly and read its output."
+    },
+    {
+      id: "no-verification-polling-loop",
+      pattern: `${CMD_START}(until|while)[[:space:]].*(tsc|typecheck|vitest|jest|pytest|mocha|(npm|pnpm|yarn|bun)[[:space:]]+(run[[:space:]]+)?test|turbo[[:space:]]+run[[:space:]]+test).*[;[:space:]][[:space:]]*done`,
+      reason: "Polling and long sleeps are never needed in a burn. Run the command directly and read its output."
+    },
     {
       id: "no-interpreter-heredoc-edit",
       pattern: `${CMD_START}(python3?|node|bun|perl|ruby)[[:space:]]+-[[:space:]]*<<`,
       reason: "Do not rewrite files by piping a heredoc into an interpreter \u2014 individual such calls have been measured at 29s, 57s, 120s and 761s, and a half-written file survives if this process dies mid-command. Use the Edit tool, which is faster, atomic, and fails loudly when its target text is not found."
     },
+    {
+      id: "no-interpreter-inline-edit",
+      pattern: `${CMD_START}node[[:space:]]+-e([[:space:]]|$)`,
+      reason: "Do not rewrite files with a `node -e` program. Use the Edit tool, which is faster, atomic, and fails loudly when its target text is not found."
+    },
+    {
+      id: "no-perl-in-place-edit",
+      pattern: `${CMD_START}perl[[:space:]]+-[0-9p]*i[^[:space:]]*`,
+      reason: "Do not rewrite files with Perl in-place editing. Use the Edit tool, which is faster, atomic, and fails loudly when its target text is not found."
+    },
+    {
+      id: "no-sed-multi-range-edit",
+      pattern: `${CMD_START}sed[[:space:]]+-[^[:space:]]*i[^[:space:]]*[[:space:]]+[^;]*,[^;]*d;[^;]*,[^;]*d`,
+      inspectQuotedArguments: true,
+      reason: "Do not perform multi-range file surgery with `sed -i`. Use the Edit tool, which is atomic and fails loudly when its target text is not found."
+    },
     {
       id: "no-cat-heredoc-edit",
       pattern: `${CMD_START}cat[[:space:]]+>>?[[:space:]]*[^[:space:]|]+[[:space:]]*<<`,
@@ -6754,7 +7339,7 @@ var init_burn_guard = __esm(() => {
 });
 
 // src/workflows/review-ticket.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 import { delimiter, join as join13 } from "path";
 import { run } from "@ai-hero/sandcastle";
 import { noSandbox } from "@ai-hero/sandcastle/sandboxes/no-sandbox";
@@ -6770,12 +7355,43 @@ function findOnPath(bin, env = process.env, platform = process.platform) {
   for (const dir of dirs) {
     for (const suffix of suffixes) {
       const candidate = join13(dir, `${bin}${suffix}`);
-      if (existsSync14(candidate))
+      if (existsSync15(candidate))
         return candidate;
     }
   }
   return;
 }
+function buildDriveAvailability(browserPath, devCommand) {
+  const missing = [];
+  if (!browserPath) {
+    missing.push(`\`${AGENT_BROWSER_BIN}\` is not on this machine's PATH, so there is no browser to walk the app with`);
+  }
+  if (!devCommand?.trim()) {
+    missing.push("this project has no dev command configured, so a drive has no app to boot");
+  }
+  if (missing.length === 0) {
+    return `A drive **is** available: \`${AGENT_BROWSER_BIN}\` is on this machine's PATH and the ` + "project has a dev command, so `review_drive` can boot the app and you can walk it. Drive " + "mode is open to you \u2014 take it if, and only if, this lap has a surface a human could operate.";
+  }
+  return `A drive is **not** available: ${missing.join(", and ")}. So the mode is already decided \u2014 ` + "run Gates mode, whatever this lap touched, and do not call `review_drive`. This is not a " + "degraded review; it is the whole review this lap gets.";
+}
+function buildGateNotes(config2) {
+  const commands = config2.verifyCommands?.trim();
+  const failures = config2.knownFailures?.trim();
+  const out = [];
+  if (commands) {
+    out.push("Run exactly these, once each \u2014 they are this project's own verify commands, so do not go looking for alternatives, add concurrency flags, or re-run one to re-read its output (redirect to a file and read that instead):", "", "```", commands, "```");
+  } else {
+    out.push("This project has no verify commands configured, so there are no gates to run. Do not go hunting for them \u2014 say so in one line of your summary note and spend the whole mode on the diff.");
+  }
+  out.push("");
+  if (failures) {
+    out.push("These already fail on this repo without this lap's help:", "", "```", failures, "```", "", "Subtract that baseline: a failure inside it is not this lap's and is not a finding. A failure outside it is one this lap introduced, and it is the finding worth the human's attention above every other.");
+  } else {
+    out.push("No pre-existing-failure baseline is configured, so a red gate may well predate this lap. Run it once, then check whether the failure touches the diff before writing it up as this lap's \u2014 and never re-run a suite to establish what was already red.");
+  }
+  return out.join(`
+`);
+}
 function writeReviewArtifacts(ticket, runId, config2) {
   const dir = reviewDir(ticket.id);
   rmSync2(dir, { recursive: true, force: true });
@@ -6797,9 +7413,18 @@ async function releaseDriveQuietly() {
   } catch {}
 }
 async function executeReviewTicket(ctx, ticket, deps) {
+  const startedAt = Date.now();
+  const timer = createToolTimer();
+  try {
+    return await reviewTicketOutcome(ctx, ticket, deps, timer);
+  } finally {
+    emitTicketTiming(ctx, ticket, buildTicketTiming(timer.summary(), startedAt, Date.now()));
+  }
+}
+async function reviewTicketOutcome(ctx, ticket, deps, timer) {
   const { project, feature } = ctx;
-  if (!findOnPath(AGENT_BROWSER_BIN)) {
-    return couldNotReview(ticket, `\`${AGENT_BROWSER_BIN}\` is not on this machine's PATH, so there is no way to drive the app. Install it and re-burn this ticket.`);
+  if (!feature.baseBranch) {
+    return couldNotReview(ticket, `feature ${feature.slug} has no recorded base branch, so there is nothing to diff \`${feature.branch}\` against.`);
   }
   const artifacts = writeReviewArtifacts(ticket, ctx.runId, deps.config);
   const prompt = renderReviewPrompt(readFileSync8(reviewTemplatePath(), "utf8"), {
@@ -6808,7 +7433,9 @@ async function executeReviewTicket(ctx, ticket, deps) {
     DOCS_DIGEST: deps.docsDigest,
     LAP_DIGESTS: buildLapDigestsBlock(deps.lapDigests),
     FEATURE_BRANCH: feature.branch,
-    BASE_BRANCH: project.mainBranch,
+    BASE_BRANCH: feature.baseBranch,
+    DRIVE_AVAILABILITY: buildDriveAvailability(findOnPath(AGENT_BROWSER_BIN), project.devCommand),
+    GATE_NOTES: buildGateNotes(deps.config),
     DIGEST_PATH: artifacts.digestPath,
     BLOCKED_PATH: artifacts.blockedPath,
     WALKTHROUGH_PATH: artifacts.walkthroughPath
@@ -6818,6 +7445,7 @@ async function executeReviewTicket(ctx, ticket, deps) {
   beginTranscript(ticket.id);
   const onStreamEvent = (event) => {
     throttle.onEvent(event);
+    timer.onEvent(event);
     if (event.type === "text") {
       appendTranscript(ticket.id, { kind: "text", text: event.message });
     } else if (event.type === "toolCall") {
@@ -6890,13 +7518,22 @@ var init_review_ticket = __esm(() => {
 });
 
 // src/workflows/ticket-burner.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync5, rmSync as rmSync3 } from "fs";
 import { dirname as dirname6, join as join14, posix as posixPath, win32 as winPath } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { fileURLToPath as fileURLToPath6 } from "url";
 import { claudeCode, codex, run as run2 } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 import { podman } from "@ai-hero/sandcastle/sandboxes/podman";
 import { noSandbox as noSandbox2 } from "@ai-hero/sandcastle/sandboxes/no-sandbox";
+function missingImageRuntimeMessage(runtime, image) {
+  const binary = RUNTIME_BINARY[runtime];
+  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 AFK burns (Rebuild image).`;
+}
+function burnAuthReady(runtime, token, loggedIn = codexLoggedIn) {
+  if (token !== undefined)
+    return true;
+  return runtime === "codex" && loggedIn();
+}
 function isReviewTicket(ticket) {
   return ticket.kind === "review";
 }
@@ -7037,10 +7674,10 @@ _(The "${DROPPED_MAP_SECTIONS.join('" and "')}" sections are omitted here: they
 }
 function buildProjectStandards(repoPath) {
   const present = [];
-  if (existsSync15(join14(repoPath, AGENT_CONVENTIONS_FILE))) {
+  if (existsSync16(join14(repoPath, AGENT_CONVENTIONS_FILE))) {
     present.push("`CLAUDE.md` \u2014 this repo's agent-facing conventions, and the highest authority on them");
   }
-  if (existsSync15(join14(repoPath, CHARTER_FILE))) {
+  if (existsSync16(join14(repoPath, CHARTER_FILE))) {
     present.push(`\`${CHARTER_FILE}\` \u2014 the project charter: what this codebase is for`);
   }
   const adrs = listLiveAdrs(repoPath).map((a) => a.relPath);
@@ -7071,7 +7708,7 @@ function buildDriveNotes(settings) {
   add("stop", settings.driveStopCommand);
   add("dev server", settings.devCommand);
   add("db reset", settings.dbResetCommand);
-  const hasDir = existsSync15(join14(settings.repoPath, ".runcastle"));
+  const hasDir = existsSync16(join14(settings.repoPath, ".runcastle"));
   if (configured.length === 0 && !hasDir) {
     return [
       "This project has no test-drive machinery configured, so there is nothing here for you to keep in step \u2014 do not invent any.",
@@ -7094,7 +7731,9 @@ function buildDriveNotes(settings) {
 `);
 }
 function buildGuardNotes(guardInstalled) {
-  return guardInstalled ? "Three of the rules below are enforced by a tool hook, not merely stated: `git stash`, test-runner concurrency flags, and rewriting files through interpreter heredocs are **denied before they run**. A denial is policy, not a broken environment \u2014 read its reason, take the alternative it names, and carry on. Do not try to route around it." : "Nothing below is machine-enforced in this burn \u2014 the deny hook is not installed, so the rules hold on your discipline alone. They are not style preferences: each one is a measured way burns lose work.";
+  const introduction = guardInstalled ? "The following commands are **denied before they run** by a tool hook. Each denial and its prescribed alternative comes verbatim from the guard that enforces it. A denial is policy, not a broken environment \u2014 follow the alternative and do not try to route around it." : "The deny hook is not installed in this burn, so the following guard rules are not machine-enforced. Follow them on discipline alone; each denial and its prescribed alternative comes verbatim from the guard used in protected burns.";
+  return [introduction, "", ...GUARD_RULES.map((rule) => `- ${rule.reason}`)].join(`
+`);
 }
 function buildBlockersBlock(blockedBy, digests) {
   if (blockedBy.length === 0) {
@@ -7117,6 +7756,16 @@ ${d.digest.trim()}`;
   return [head, "", "In their own words:", "", ...bodies].join(`
 `);
 }
+function buildFixNotes(ticket) {
+  if (!ticket.originFindingId)
+    return "";
+  return [
+    "### This ticket fixes a review finding",
+    "",
+    "It was minted from a defect the review of this same lap reported, and its `context` carries the reviewer's repro step verbatim. **Before you declare done, re-run that repro step exactly, and say in your digest that you re-ran it and what happened.** Nothing reviews your change afterwards \u2014 that repro step is the check, and the verify commands run on top of it."
+  ].join(`
+`);
+}
 function buildLapDigestsBlock(digests) {
   if (digests.length === 0) {
     return "_No implementation ticket in this burn left a digest \u2014 the diff and the feature docs are all you have._";
@@ -7153,13 +7802,13 @@ function parseEnvFile2(content) {
     if (line.length === 0 || line.startsWith("#"))
       continue;
     const body = line.startsWith("export ") ? line.slice(7).trim() : line;
-    const eq9 = body.indexOf("=");
-    if (eq9 === -1)
+    const eq10 = body.indexOf("=");
+    if (eq10 === -1)
       continue;
-    const key = body.slice(0, eq9).trim();
+    const key = body.slice(0, eq10).trim();
     if (key.length === 0)
       continue;
-    let value = body.slice(eq9 + 1).trim();
+    let value = body.slice(eq10 + 1).trim();
     if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
       value = value.slice(1, -1);
     }
@@ -7207,7 +7856,31 @@ function cacheMountFor(pm, hostPath) {
   const sandboxPath = PM_CACHE_SANDBOX_PATHS[pm];
   return sandboxPath ? { hostPath, sandboxPath } : undefined;
 }
+function buildBurnCacheMounts(slot, projectId, sandbox, pm) {
+  if (slot !== undefined) {
+    return {
+      mounts: [{ volume: burnCacheVolumeName(projectId), sandboxPath: BURN_CACHE_MOUNT }],
+      env: pm ? burnCacheEnv(pm) : {}
+    };
+  }
+  const mount = sandbox !== "noSandbox" && pm ? cacheMountFor(pm, burnCacheDir(pm)) : undefined;
+  return { mounts: mount ? [mount] : [], env: {} };
+}
+function codexAuthMountFor(runtime, sandbox, env = process.env, loggedIn = codexLoggedIn) {
+  if (runtime !== "codex" || sandbox === "noSandbox" || !loggedIn(env))
+    return;
+  return { hostPath: codexHomeDir(env), sandboxPath: CODEX_HOST_MOUNT_PATH, readonly: true };
+}
+function buildCodexAuthCopyCommand() {
+  return `mkdir -p "$HOME/.codex" && cp "${CODEX_HOST_MOUNT_PATH}/auth.json" "$HOME/.codex/auth.json"`;
+}
+function chainSetupCommands(...steps) {
+  const present = steps.filter((step) => !!step);
+  return present.length > 0 ? present.join(" && ") : undefined;
+}
 function resolveBurnWorkspaceMode(config2, platform = process.platform) {
+  if (resolveBurnCacheMode(config2) === "volume")
+    return "slot";
   if (config2.sandbox === "noSandbox")
     return "mounted";
   if (config2.burnWorkspace === "auto")
@@ -7215,26 +7888,84 @@ function resolveBurnWorkspaceMode(config2, platform = process.platform) {
   return config2.burnWorkspace;
 }
 function buildIsolatedSetupCommand(tempBranch, setupCommand, pm) {
-  const hookFile = `${ISOLATED_REPO_PATH}/.git/hooks/post-commit`;
-  const attachmentsDir = `${SANDBOX_WORKSPACE_PATH}/${ATTACHMENTS_DIR}`;
-  const cloneAttachmentsDir = `${ISOLATED_REPO_PATH}/${ATTACHMENTS_DIR}`;
-  const parts = [
+  const steps = buildRepoSetupSteps(ISOLATED_REPO_PATH, tempBranch, setupCommand, pm);
+  return [
     `git config --global --add safe.directory '*'`,
     `git clone ${SANDBOX_WORKSPACE_PATH} ${ISOLATED_REPO_PATH}`,
-    `if [ -d "${attachmentsDir}" ]; then mkdir -p "${cloneAttachmentsDir}" && cp -r "${attachmentsDir}/." "${cloneAttachmentsDir}/" && mkdir -p "${ISOLATED_REPO_PATH}/.git/info" && printf '%s\\n' '${ATTACHMENTS_DIR}/' >> "${ISOLATED_REPO_PATH}/.git/info/exclude"; fi`,
-    `printf '#!/bin/sh\\nunset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE\\ngit push --quiet origin HEAD:%s && exec git -C ${SANDBOX_WORKSPACE_PATH} reset --hard --quiet %s\\n' '${tempBranch}' '${tempBranch}' > ${hookFile}`,
+    ...steps.pre,
+    ...steps.install,
+    ...steps.post
+  ].join(" && ");
+}
+function buildRepoSetupSteps(repoPath, tempBranch, setupCommand, pm) {
+  const hookFile = `${repoPath}/.git/hooks/post-commit`;
+  const attachmentsDir = `${SANDBOX_WORKSPACE_PATH}/${ATTACHMENTS_DIR}`;
+  const repoAttachmentsDir = `${repoPath}/${ATTACHMENTS_DIR}`;
+  const excludeFile = `${repoPath}/.git/info/exclude`;
+  const pre = [
+    `if [ -d "${attachmentsDir}" ]; then mkdir -p "${repoAttachmentsDir}" && cp -r "${attachmentsDir}/." "${repoAttachmentsDir}/" && mkdir -p "${repoPath}/.git/info" && { grep -qxF '${ATTACHMENTS_DIR}/' "${excludeFile}" 2>/dev/null || printf '%s\\n' '${ATTACHMENTS_DIR}/' >> "${excludeFile}"; }; fi`,
+    `printf '#!/bin/sh\\nunset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE\\ngit push --quiet origin HEAD:%s && exit 0\\nsleep 2\\ngit push --quiet origin HEAD:%s && exit 0\\necho "runcastle: commit sync failed (will retry on your next commit); do not re-commit" >&2\\nexit 0\\n' '${tempBranch}' '${tempBranch}' > ${hookFile}`,
     `chmod +x ${hookFile}`
   ];
   if (pm === "pnpm" || pm === "yarn") {
     const shim = `$HOME/.local/bin/${pm}`;
-    parts.push(`mkdir -p "$HOME/.local/bin"`, `printf '#!/bin/sh\\nexec corepack ${pm} "$@"\\n' > "${shim}"`, `chmod +x "${shim}"`);
+    pre.push(`mkdir -p "$HOME/.local/bin"`, `printf '#!/bin/sh\\nexec corepack ${pm} "$@"\\n' > "${shim}"`, `chmod +x "${shim}"`);
+  }
+  return {
+    pre,
+    install: setupCommand ? [`cd ${repoPath} && ${setupCommand}`] : [],
+    post: [`git -C ${repoPath} config core.hooksPath ${repoPath}/.git/hooks`]
+  };
+}
+function parseSetupMarker(text2) {
+  const m = new RegExp(String.raw`${SETUP_MARKER} cold=([01]) sync_ms=(\d+) install_ms=(\d+)`).exec(text2);
+  if (!m)
+    return;
+  return { cold: m[1] === "1", syncMs: Number(m[2]), installMs: Number(m[3]) };
+}
+function takeSetupMarker(worktreePath) {
+  const file = join14(worktreePath, SETUP_MARKER_FILE);
+  let text2;
+  try {
+    text2 = readFileSync9(file, "utf8");
+  } catch {
+    return;
   }
-  if (setupCommand)
-    parts.push(`cd ${ISOLATED_REPO_PATH} && ${setupCommand}`);
-  parts.push(`git -C ${ISOLATED_REPO_PATH} config core.hooksPath ${ISOLATED_REPO_PATH}/.git/hooks`);
-  return parts.join(" && ");
+  rmSync3(file, { force: true });
+  return parseSetupMarker(text2);
+}
+function fmtSeconds(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function buildSlotStamp(imageName, packageManagerField) {
+  const pm = packageManagerField?.split("@")[0] ?? "none";
+  const major = packageManagerField?.split("@")[1]?.split(".")[0] ?? "any";
+  return `${imageName} node=$(node --version 2>/dev/null) pm=${pm}@${major}`;
+}
+function buildSlotSetupCommand(slot, tempBranch, setupCommand, pm, stamp) {
+  const repo = slotRepoPath(slot);
+  const stampFile = slotStampPath(slot);
+  const steps = buildRepoSetupSteps(repo, tempBranch, setupCommand, pm);
+  return [
+    `git config --global --add safe.directory '*'`,
+    `RC_COLD=0`,
+    `RC_STAMP="${stamp}"`,
+    `RC_SYNC_START=$(date +%s%3N)`,
+    `mkdir -p ${slotDirPath(slot)}`,
+    `rm -f ${repo}/.git/*.lock`,
+    `if ! git -C ${repo} rev-parse --git-dir >/dev/null 2>&1; then rm -rf ${repo} && git clone ${SANDBOX_WORKSPACE_PATH} ${repo} && RC_COLD=1; else git -C ${repo} fetch ${SANDBOX_WORKSPACE_PATH} ${tempBranch} && git -C ${repo} reset --hard FETCH_HEAD && git -C ${repo} checkout -B ${tempBranch}; fi`,
+    `git -C ${repo} clean -fd`,
+    `if [ "$(cat ${stampFile} 2>/dev/null)" != "$RC_STAMP" ]; then rm -rf ${repo}/node_modules && git -C ${repo} clean -fdX && RC_COLD=1 && printf '%s\\n' "$RC_STAMP" > ${stampFile}; fi`,
+    ...steps.pre,
+    `RC_SYNC_MS=$(( $(date +%s%3N) - RC_SYNC_START ))`,
+    `RC_INSTALL_START=$(date +%s%3N)`,
+    ...steps.install,
+    `RC_INSTALL_MS=$(( $(date +%s%3N) - RC_INSTALL_START ))`,
+    ...steps.post,
+    `printf '${SETUP_MARKER} cold=%s sync_ms=%s install_ms=%s\\n' "$RC_COLD" "$RC_SYNC_MS" "$RC_INSTALL_MS" > ${SANDBOX_WORKSPACE_PATH}/${SETUP_MARKER_FILE}`
+  ].join(" && ");
 }
-function buildWorkspaceNotes(mode) {
+function buildWorkspaceNotes(mode, repoPath = ISOLATED_REPO_PATH) {
   if (mode === "mounted") {
     return [
       "Work in the current directory \u2014 it is the repo checkout on your branch.",
@@ -7246,13 +7977,13 @@ function buildWorkspaceNotes(mode) {
 `);
   }
   return [
-    `Your working repository is \`${ISOLATED_REPO_PATH}\` \u2014 a clone on the container's fast native filesystem, with dependencies already installed. Do ALL work there: \`cd ${ISOLATED_REPO_PATH}\` first; every file you read, edit, test, and commit lives under it.`,
+    `Your working repository is \`${repoPath}\` \u2014 a clone on the container's fast native filesystem, with dependencies already installed. Do ALL work there: \`cd ${repoPath}\` first; every file you read, edit, test, and commit lives under it.`,
     "",
-    `The directory you start in (\`${SANDBOX_WORKSPACE_PATH}\`) is a slow mounted mirror used only to collect your commits \u2014 never edit files, install, or run tests there. Your commits sync back automatically (a post-commit hook pushes them); just commit as normal. If you re-run the dependency install and it reconfigures git hooks (husky), run \`git -C ${ISOLATED_REPO_PATH} config core.hooksPath ${ISOLATED_REPO_PATH}/.git/hooks\` afterwards so the sync hook stays armed.`,
+    `The directory you start in (\`${SANDBOX_WORKSPACE_PATH}\`) is a slow mounted mirror used only to collect your commits \u2014 never edit files, install, or run tests there. Your commits sync back automatically (a post-commit hook pushes them); just commit as normal. If you re-run the dependency install and it reconfigures git hooks (husky), run \`git -C ${repoPath} config core.hooksPath ${repoPath}/.git/hooks\` afterwards so the sync hook stays armed.`,
     "",
-    `If you are blocked and write \`BLOCKED.md\`, write it at \`${ISOLATED_REPO_PATH}/BLOCKED.md\` AND copy it to \`${SANDBOX_WORKSPACE_PATH}/BLOCKED.md\` so the orchestrator can see it.`,
+    `If you are blocked and write \`BLOCKED.md\`, write it at \`${repoPath}/BLOCKED.md\` AND copy it to \`${SANDBOX_WORKSPACE_PATH}/BLOCKED.md\` so the orchestrator can see it.`,
     "",
-    `Write \`DIGEST.md\` at \`${SANDBOX_WORKSPACE_PATH}/DIGEST.md\` \u2014 the mounted mirror, so the host can see it \u2014 and NOT inside \`${ISOLATED_REPO_PATH}\`, where it would be committed with your work.`,
+    `Write \`DIGEST.md\` at \`${SANDBOX_WORKSPACE_PATH}/DIGEST.md\` \u2014 the mounted mirror, so the host can see it \u2014 and NOT inside \`${repoPath}\`, where it would be committed with your work.`,
     "",
     "**Those paths are the only authoritative ones** \u2014 nothing later in this prompt overrides them."
   ].join(`
@@ -7269,7 +8000,7 @@ function attachedNoteIds(context) {
   return ids2;
 }
 function attachmentSources(context) {
-  return attachedNoteIds(context).map(annotationPath).filter((p) => existsSync15(p));
+  return attachedNoteIds(context).map(annotationPath).filter((p) => existsSync16(p));
 }
 function buildAttachmentCopyCommands(sources, platform = process.platform) {
   if (sources.length === 0)
@@ -7312,7 +8043,7 @@ function buildVerifyNotes(config2) {
 }
 function readRepoToolchain(repoPath) {
   const pkgPath = join14(repoPath, "package.json");
-  const hasPackageJson = existsSync15(pkgPath);
+  const hasPackageJson = existsSync16(pkgPath);
   let packageManagerField;
   if (hasPackageJson) {
     try {
@@ -7325,10 +8056,10 @@ function readRepoToolchain(repoPath) {
     hasPackageJson,
     ...packageManagerField !== undefined ? { packageManagerField } : {},
     lockfiles: {
-      bun: existsSync15(join14(repoPath, "bun.lock")) || existsSync15(join14(repoPath, "bun.lockb")),
-      pnpm: existsSync15(join14(repoPath, "pnpm-lock.yaml")),
-      yarn: existsSync15(join14(repoPath, "yarn.lock")),
-      npm: existsSync15(join14(repoPath, "package-lock.json"))
+      bun: existsSync16(join14(repoPath, "bun.lock")) || existsSync16(join14(repoPath, "bun.lockb")),
+      pnpm: existsSync16(join14(repoPath, "pnpm-lock.yaml")),
+      yarn: existsSync16(join14(repoPath, "yarn.lock")),
+      npm: existsSync16(join14(repoPath, "package-lock.json"))
     }
   };
 }
@@ -7397,8 +8128,9 @@ function createToolTimer() {
     if (event.type === "raw")
       return;
     const at = event.timestamp.getTime();
-    if (iteration !== null && event.iteration !== iteration)
-      pending = null;
+    if (iteration !== null && event.iteration !== iteration && pending) {
+      pending = { category: "setup", at: pending.at };
+    }
     iteration = event.iteration;
     if (pending) {
       const gap = at - pending.at;
@@ -7415,7 +8147,11 @@ function createToolTimer() {
       pending = { category: "model", at };
     }
   };
-  return { onEvent, summary: () => ({ totalMs, calls, byCategory }) };
+  const beginSetup = (at = Date.now()) => {
+    pending = { category: "setup", at };
+    iteration = null;
+  };
+  return { onEvent, beginSetup, summary: () => ({ totalMs, calls, byCategory }) };
 }
 function formatTimingSummary(s) {
   if (s.totalMs === 0)
@@ -7423,6 +8159,22 @@ function formatTimingSummary(s) {
   const parts = Object.entries(s.byCategory).sort((a, b) => (b[1]?.ms ?? 0) - (a[1]?.ms ?? 0)).slice(0, 5).map(([c, t]) => `${c} ${Math.round((t?.ms ?? 0) / s.totalMs * 100)}%`);
   return `${Math.round(s.totalMs / 60000)}min across ${s.calls} tool call(s) \u2014 ${parts.join(", ")}`;
 }
+function buildTicketTiming(summary, startedAt, endedAt) {
+  return { ...summary, startedAt, endedAt, wallMs: Math.max(0, endedAt - startedAt) };
+}
+function formatTicketTiming(t) {
+  const clock = fmtClock(Math.round(t.wallMs / 1000));
+  const bare = t.calls === 0 && t.totalMs === 0;
+  return bare ? clock : `${clock} (${formatTimingSummary(t)})`;
+}
+function emitTicketTiming(ctx, ticket, timing) {
+  ctx.emitEvent({
+    type: "ticket.timing",
+    message: `ticket ${ticket.seq} spent ${formatTicketTiming(timing)}`,
+    ticketId: ticket.id,
+    data: timing
+  });
+}
 function interpretRunResult(result, blockedContent) {
   const commits = result.commits.map((c) => c.sha);
   if (commits.length > 0)
@@ -7443,10 +8195,20 @@ 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 missingAgentBinaryMessage(err, runtime, image) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+  const binary = AGENT_BINARY[runtime];
+  const missing = new RegExp(`\\b${binary}\\b[^\\n]*(?:exited with code 127|command not found|not found|no such file or directory)`, "i");
+  if (!missing.test(msg))
+    return;
+  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 AFK burns (Rebuild image).`;
+}
 function classifyTicketRunError(err, runtime) {
   const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
   const runtimes = runtime ? [runtime] : ["claude-code", "codex"];
   const forRuntimes = (table) => runtimes.flatMap((r) => table[r]);
+  if (runtimes.some((r) => missingAgentBinaryMessage(msg, r, "image")))
+    return "fatal";
   if ([...FATAL_ERROR_PATTERNS, ...forRuntimes(RUNTIME_FATAL_ERROR_PATTERNS)].some((p) => p.test(msg)))
     return "fatal";
   if ([...RETRYABLE_ERROR_PATTERNS, ...forRuntimes(RUNTIME_RETRYABLE_ERROR_PATTERNS)].some((p) => p.test(msg)))
@@ -7560,13 +8322,42 @@ function failedBlockerNote(seqs) {
 }
 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 scheduled = [...tickets2];
+  const bySeq = indexBySeq(scheduled);
+  const status = new Map(scheduled.map((t) => [t.seq, t.status]));
+  const pending = new Set(scheduled.filter((t) => t.status === "pending").map((t) => t.seq));
   const inFlight = new Map;
   const digests = [];
+  let admitted = 0;
   const satisfied = (t, s) => s === "done" || s === "cancelled" || isReviewTicket(t) && s === "failed";
-  const implementationsSettled = () => tickets2.every((t) => isReviewTicket(t) || !pending.has(t.seq) && !inFlight.has(t.seq));
+  const implementationsSettled = () => scheduled.every((t) => isReviewTicket(t) || !pending.has(t.seq) && !inFlight.has(t.seq));
+  const admitNewTickets = () => {
+    const added = [];
+    for (const t of ctx.listTickets?.() ?? []) {
+      if (bySeq.has(t.seq))
+        continue;
+      scheduled.push(t);
+      bySeq.set(t.seq, t);
+      status.set(t.seq, t.status);
+      if (t.status !== "pending")
+        continue;
+      pending.add(t.seq);
+      added.push(t.seq);
+    }
+    if (added.length === 0)
+      return;
+    admitted += added.length;
+    ctx.emitEvent({
+      type: "burn.admitted",
+      message: `${added.length} ticket(s) minted during this run joined it: ${added.join(", ")}`,
+      data: { seqs: added }
+    });
+  };
+  const mirrorFinding = (t, progress, reason) => {
+    if (!t.originFindingId)
+      return;
+    ctx.updateFinding?.(t.originFindingId, progress, reason);
+  };
   const readyState = (seq) => {
     const t = bySeq.get(seq);
     if (!t)
@@ -7582,7 +8373,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
     return t.blockedBy.every((b) => satisfied(t, status.get(b))) ? "ready" : "wait";
   };
   const harvestDigest2 = (t, digest) => {
-    const failed = isReviewTicket(t) ? tickets2.filter((x) => !isReviewTicket(x) && status.get(x.seq) === "failed").map((x) => x.seq) : [];
+    const failed = isReviewTicket(t) ? scheduled.filter((x) => !isReviewTicket(x) && status.get(x.seq) === "failed").map((x) => x.seq) : [];
     const body = [failed.length > 0 ? failedBlockerNote(failed) : undefined, digest].filter(Boolean).join(`
 
 `);
@@ -7595,6 +8386,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
     if (!t)
       return;
     ctx.updateTicket(t.id, { status: "failed", error, ...digest ? { digest } : {} });
+    mirrorFinding(t, "failed", error);
     harvestDigest2(t, digest);
     if (extra)
       ctx.emitEvent({ ...extra, ticketId: t.id });
@@ -7605,6 +8397,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
       return;
     status.set(seq, "burning");
     ctx.updateTicket(t.id, { status: "burning" });
+    mirrorFinding(t, "fixing");
     ctx.emitEvent({
       type: "ticket.burning",
       message: `burning ticket ${t.seq}: ${t.title}`,
@@ -7614,6 +8407,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
     if (outcome.status === "done") {
       status.set(seq, "done");
       ctx.updateTicket(t.id, { status: "done", commits: outcome.commits, digest: outcome.digest });
+      mirrorFinding(t, "fixed");
       ctx.emitEvent({
         type: "ticket.done",
         message: `ticket ${t.seq} done \u2014 ${outcome.commits.length} commit(s)`,
@@ -7637,6 +8431,8 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
         data: { error: outcome.error }
       });
     }
+    if (isReviewTicket(t))
+      admitNewTickets();
   };
   while (pending.size > 0 || inFlight.size > 0) {
     ctx.signal.throwIfAborted();
@@ -7693,7 +8489,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
   for (const s of status.values())
     if (s === "done")
       done += 1;
-  return { done, digests };
+  return { done, admitted, digests };
 }
 function composeRunDigest(entries) {
   if (entries.length === 0)
@@ -7704,15 +8500,44 @@ ${e.digest.trim()}`).join(`
 
 `);
 }
+function gateTicketAuth(deps) {
+  const authMissing = deps.ticketAuthMissing;
+  if (!authMissing || deps.config.sandbox === "noSandbox")
+    return deps.executeTicketRun;
+  return async (ctx, ticket, run3) => {
+    const runtime = authMissing(ticket);
+    if (!runtime)
+      return deps.executeTicketRun(ctx, ticket, run3);
+    const hint = `${runtime} is not authenticated \u2014 ${RUNTIME_AUTH_SETUP_HINT[runtime]}`;
+    ctx.emitEvent({ type: AUTH_MISSING_EVENT, message: hint, ticketId: ticket.id });
+    return { status: "failed", error: hint };
+  };
+}
 async function burnRun(ctx, deps) {
   const tickets2 = ctx.tickets;
   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: RUNTIME_AUTH_SETUP_HINT[deps.runtime] });
     return { status: "failed", summary: "burn aborted: auth token missing" };
   }
+  if (deps.config.sandbox !== "noSandbox" && deps.exec) {
+    const image = resolveSandboxImage(deps.config);
+    const binary = RUNTIME_BINARY[deps.runtime];
+    const probe = await deps.exec(deps.config.sandbox, [
+      "run",
+      "--rm",
+      "--entrypoint",
+      binary,
+      image,
+      "--version"
+    ]);
+    if (!probe.ok || probe.code !== 0) {
+      const message = missingImageRuntimeMessage(deps.runtime, image);
+      ctx.emitEvent({ type: IMAGE_RUNTIME_MISSING_EVENT, message });
+      return { status: "failed", summary: message };
+    }
+  }
   const cycle = detectCycle(burnable);
   if (cycle) {
     const path = cycle.join(" \u2192 ");
@@ -7723,7 +8548,8 @@ async function burnRun(ctx, deps) {
     });
     return { status: "failed", summary: `dependency cycle: ${path}` };
   }
-  const { done, digests } = await burnTickets(ctx, tickets2, deps.executeTicketRun, deps.concurrency);
+  const { done, admitted, digests } = await burnTickets(ctx, tickets2, gateTicketAuth(deps), deps.concurrency);
+  const total = burnable.length + admitted;
   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 } });
   const digest = composeRunDigest(digests);
@@ -7736,7 +8562,7 @@ function resolverTemplatePath() {
   return burnerAssetPath("resolve-conflict.md");
 }
 function burnerAssetPath(file) {
-  const here = dirname6(fileURLToPath5(import.meta.url));
+  const here = dirname6(fileURLToPath6(import.meta.url));
   return join14(resolveSkillsRoot(here), "burner", file);
 }
 function listFeatureDocs(docsDir, prefix = "") {
@@ -7760,11 +8586,11 @@ function readDocsDigest(projectId, slug) {
     ...missing ? { missing } : {}
   });
   const worktree = worktreeDir(projectId, slug);
-  if (!existsSync15(worktree)) {
+  if (!existsSync16(worktree)) {
     return done("_No talk worktree on disk \u2014 docs digest skipped._", "no-worktree");
   }
   const docsDir = join14(worktree, ...docsRel.split("/"));
-  if (!existsSync15(docsDir)) {
+  if (!existsSync16(docsDir)) {
     return done("_No docs/features dir in the talk worktree \u2014 docs digest skipped._", "no-docs-dir");
   }
   const names = listFeatureDocs(docsDir).sort((a, b) => agentDigestDocOrder(a) - agentDigestDocOrder(b) || a.localeCompare(b));
@@ -7827,7 +8653,7 @@ function readAgentFile(dirs, file) {
     if (!dir)
       continue;
     const p = join14(dir, file);
-    if (existsSync15(p)) {
+    if (existsSync16(p)) {
       try {
         return readFileSync9(p, "utf8");
       } catch {}
@@ -7897,8 +8723,8 @@ function buildAgentExtraArgs(runtime, options) {
 function quoteArg(value) {
   return `"${value}"`;
 }
-function selectSandbox(config2, mounts = []) {
-  const imageOpts = buildSandboxOptions(config2, mounts);
+function selectSandbox(config2, mounts = [], env = {}) {
+  const imageOpts = buildSandboxOptions(config2, mounts, env);
   switch (config2.sandbox) {
     case "docker":
       return docker(imageOpts);
@@ -7910,17 +8736,46 @@ function selectSandbox(config2, mounts = []) {
       throw new Error(`no sandbox provider for sandbox "${config2.sandbox}" \u2014 refusing to run the agent unsandboxed`);
   }
 }
-function buildSandboxOptions(config2, mounts = []) {
+function buildSandboxOptions(config2, mounts = [], env = {}) {
   return {
     imageName: resolveSandboxImage(config2),
     ...mounts.length > 0 ? { mounts } : {},
-    ...config2.burnCpus !== undefined ? { cpus: config2.burnCpus } : {}
+    ...config2.burnCpus !== undefined ? { cpus: config2.burnCpus } : {},
+    ...Object.keys(env).length > 0 ? { env } : {}
   };
 }
-async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget, blocks, runCtx) {
+async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget, ensureCacheVolume, blocks, runCtx) {
+  const allocator = resolveBurnCacheMode(config2) === "volume" ? getBurnSlotAllocator(config2.burnConcurrency) : undefined;
+  return withBurnCacheSlot(allocator, async (slot) => {
+    if (slot !== undefined)
+      await ensureCacheVolume();
+    return burnTicket(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget, blocks, runCtx, slot);
+  });
+}
+async function withBurnCacheSlot(allocator, body) {
+  if (!allocator)
+    return body(undefined);
+  let slot;
+  try {
+    slot = allocator.claim();
+  } catch (err) {
+    if (!(err instanceof BurnSlotsExhaustedError))
+      throw err;
+  }
+  if (slot === undefined)
+    return body(undefined);
+  try {
+    return await body(slot);
+  } finally {
+    allocator.release(slot);
+  }
+}
+async function burnTicket(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget, blocks, runCtx, slot) {
   const { project, feature } = ctx;
-  const workspaceMode = resolveBurnWorkspaceMode(config2);
-  if (workspaceMode === "isolated")
+  const startedAt = Date.now();
+  const workspaceMode = resolveBurnWorkspaceMode(slot === undefined ? { ...config2, burnCache: "off" } : config2);
+  const agentRepoPath = slot !== undefined ? slotRepoPath(slot) : ISOLATED_REPO_PATH;
+  if (workspaceMode !== "mounted")
     await ensureIsolatedPushTarget();
   const attachments = attachmentSources(ticket.context);
   const attachmentCommands = buildAttachmentCopyCommands(attachments);
@@ -7936,7 +8791,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const ticketJson = buildTicketJson(ticket);
   const featureBrief = buildFeatureBrief(feature);
   const docsDigest = blocks.docsDigest;
-  const workspaceNotes = buildWorkspaceNotes(workspaceMode);
+  const workspaceNotes = buildWorkspaceNotes(workspaceMode, agentRepoPath);
   const guardInstalled = config2.burnGuard && config2.sandbox !== "noSandbox";
   const prepared = resolvePreparedSettings(config2, project);
   const verifyNotes = buildVerifyNotes(prepared);
@@ -7949,30 +8804,56 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
     DRIVE_NOTES: blocks.driveNotes,
     GUARD_NOTES: buildGuardNotes(guardInstalled),
     TICKET_JSON: ticketJson,
-    BLOCKERS: buildBlockersBlock(ticket.blockedBy, runCtx.digests)
+    BLOCKERS: buildBlockersBlock(ticket.blockedBy, runCtx.digests),
+    FIX_NOTES: buildFixNotes(ticket)
   });
   const toolchain = readRepoToolchain(project.repoPath);
   const pm = detectPackageManager(toolchain);
   const setupCommand = resolveSetupCommand(toolchain, prepared.setupCommand);
-  const mounts = [];
-  if (config2.sandbox !== "noSandbox" && pm) {
-    const mount = cacheMountFor(pm, burnCacheDir(pm));
-    if (mount) {
+  const cache = buildBurnCacheMounts(slot, project.id, config2.sandbox, pm);
+  const sandboxEnv = cache.env;
+  const mounts = [...cache.mounts];
+  for (const mount of cache.mounts) {
+    if ("hostPath" in mount)
       mkdirSync9(mount.hostPath, { recursive: true });
-      mounts.push(mount);
-    }
   }
+  const codexAuthMount = codexAuthMountFor(model.runtime, config2.sandbox);
+  if (codexAuthMount)
+    mounts.push(codexAuthMount);
   const guardInstall = guardInstalled ? buildGuardInstallCommand(model.runtime) : undefined;
-  const withGuard = (setup) => guardInstall === undefined ? setup : setup ? `${guardInstall} && ${setup}` : guardInstall;
+  const withPrelude = (setup) => chainSetupCommands(codexAuthMount ? buildCodexAuthCopyCommand() : undefined, guardInstall, setup);
   const agentOptions = guardInstalled ? { bypassHookTrust: true } : {};
+  const slotStamp = buildSlotStamp(resolveSandboxImage(config2), toolchain.packageManagerField);
+  const setupHookFor = (branch) => withPrelude(slot !== undefined ? buildSlotSetupCommand(slot, branch, setupCommand, pm, slotStamp) : workspaceMode === "isolated" ? buildIsolatedSetupCommand(branch, setupCommand, pm) : setupCommand);
   mkdirSync9(logsDir(), { recursive: true });
   const logFilePath = join14(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
   beginTranscript(ticket.id);
   const timer = createToolTimer();
+  const setupRun = { worktree: undefined, iteration: null };
+  const consumeSetupMarker = (iteration) => {
+    if (slot === undefined || !setupRun.worktree || setupRun.iteration === iteration)
+      return;
+    setupRun.iteration = iteration;
+    const marker = takeSetupMarker(setupRun.worktree);
+    if (!marker)
+      return;
+    ctx.emitEvent({
+      type: "burn.setup",
+      message: `ticket ${ticket.seq}: cache slot ${slot} ${marker.cold ? "cold" : "warm"} \u2014 synced in ${fmtSeconds(marker.syncMs)}, installed in ${fmtSeconds(marker.installMs)}`,
+      ticketId: ticket.id,
+      data: { slot, cold: marker.cold, syncMs: marker.syncMs, installMs: marker.installMs }
+    });
+  };
+  const beginSetupSpan = (branch) => {
+    setupRun.worktree = burnWorktreePath(project.repoPath, branch);
+    setupRun.iteration = null;
+    timer.beginSetup();
+  };
   const onStreamEvent = (event) => {
     throttle.onEvent(event);
     timer.onEvent(event);
+    consumeSetupMarker(event.iteration);
     if (event.type === "text") {
       appendTranscript(ticket.id, { kind: "text", text: event.message });
     } else if (event.type === "toolCall") {
@@ -8008,6 +8889,12 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const preserveChain = (branch) => {
     ctx.updateTicket(ticket.id, { attemptBranch: branch });
   };
+  const discards = new Map;
+  const discardWorktree = (branch) => {
+    const pending = discards.get(branch) ?? cleanupBurnWorktree(project.repoPath, branch);
+    discards.set(branch, pending);
+    return pending;
+  };
   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);
@@ -8023,7 +8910,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
       OTHER_SIDE: buildOtherSideBlock(otherSide),
       MERGE_COMMAND: resolveMergeCommand(workspaceMode, feature.branch)
     });
-    const hookCommand = withGuard(workspaceMode === "isolated" ? buildIsolatedSetupCommand(resolveBranch, setupCommand, pm) : setupCommand);
+    const hookCommand = setupHookFor(resolveBranch);
     appendTranscript(ticket.id, {
       kind: "text",
       text: `
@@ -8036,9 +8923,10 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
     };
     let result;
     try {
+      beginSetupSpan(resolveBranch);
       result = await run2({
         agent: buildBurnAgent(config2, token, model, agentOptions),
-        sandbox: selectSandbox(config2, mounts),
+        sandbox: selectSandbox(config2, mounts, sandboxEnv),
         cwd: project.repoPath,
         prompt,
         branchStrategy: { type: "branch", branch: resolveBranch, baseBranch: input.branch },
@@ -8055,6 +8943,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
         logging: { type: "file", path: logFilePath, onAgentStreamEvent: onStreamEvent }
       });
     } catch (err) {
+      await discardWorktree(resolveBranch);
       if (ctx.signal.aborted)
         throw err;
       const tip = await bestTip();
@@ -8066,9 +8955,9 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
           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 = readAgentFile([result?.preservedWorktreePath, project.repoPath], "BLOCKED.md");
+    await discardWorktree(resolveBranch);
     if (blocked !== undefined && blocked.trim().length > 0) {
       return {
         ok: false,
@@ -8158,17 +9047,18 @@ ${blocked.trim()}`
     let tempBranch = "";
     for (let attempt = 1;; attempt++) {
       tempBranch = ticketBranchName(feature.slug, ticket.seq, newId("b").slice(2, 10));
-      const hookCommand = withGuard(workspaceMode === "isolated" ? buildIsolatedSetupCommand(tempBranch, setupCommand, pm) : setupCommand);
+      const hookCommand = setupHookFor(tempBranch);
       if (hookCommand && attempt === 1) {
         ctx.emitEvent({
           type: "burn.setup",
-          message: workspaceMode === "isolated" ? `preparing isolated workspace (native-FS clone)${setupCommand ? ` + deps install: ${setupCommand}` : ""}` : `installing deps before agent start: ${setupCommand}`,
-          ticketId: ticket.id
+          message: slot !== undefined ? `preparing cache slot ${slot}${setupCommand ? ` + deps install: ${setupCommand}` : ""}` : workspaceMode === "isolated" ? `preparing isolated workspace (native-FS clone)${setupCommand ? ` + deps install: ${setupCommand}` : ""}` : `installing deps before agent start: ${setupCommand}`,
+          ticketId: ticket.id,
+          ...slot !== undefined ? { data: { slot } } : {}
         });
       }
       const runOptions = {
         agent: buildBurnAgent(config2, token, model, agentOptions),
-        sandbox: selectSandbox(config2, mounts),
+        sandbox: selectSandbox(config2, mounts, sandboxEnv),
         cwd: project.repoPath,
         prompt: retryNotes ? `${basePrompt}
 
@@ -8193,14 +9083,17 @@ ${retryNotes}` : basePrompt,
       };
       try {
         await excludeAttachments();
+        beginSetupSpan(tempBranch);
         result = await run2(runOptions);
         await clearAttachmentsFor(tempBranch);
         break;
       } catch (err) {
         await clearAttachmentsFor(tempBranch);
+        await discardWorktree(tempBranch);
         if (ctx.signal.aborted)
           throw err;
         const msg = err instanceof Error ? err.message : String(err);
+        const missingBinary = missingAgentBinaryMessage(err, model.runtime, resolveSandboxImage(config2));
         const salvaged = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
         if (salvaged.length > 0)
           baseBranch = tempBranch;
@@ -8217,7 +9110,7 @@ ${retryNotes}` : basePrompt,
           };
         }
         if (isWorktreeTeardownError(err)) {
-          const removed = await cleanupBurnWorktree(project.repoPath, tempBranch);
+          const removed = await discardWorktree(tempBranch);
           if (salvaged.length > 0) {
             ctx.emitEvent({
               type: "burn.worktree.teardown-failed",
@@ -8242,6 +9135,11 @@ ${retryNotes}` : basePrompt,
             }
           };
         }
+        if (missingBinary) {
+          if (salvaged.length > 0)
+            preserveChain(tempBranch);
+          return { status: "failed", error: missingBinary };
+        }
         if (classifyTicketRunError(err, model.runtime) === "retryable" && attempt < maxAttempts) {
           const headline = errorHeadline(msg);
           retryNotes = buildRetryNotes({ error: headline, commitCount: salvaged.length });
@@ -8283,6 +9181,7 @@ ${retryNotes}` : basePrompt,
     const agentFileDirs = [result.preservedWorktreePath, project.repoPath];
     const blocked = readAgentFile(agentFileDirs, "BLOCKED.md");
     harvestedDigest = harvestDigest(agentFileDirs);
+    await discardWorktree(tempBranch);
     const chain = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
     let outcome;
     if (result.commits.length === 0 && blocked !== undefined && blocked.trim().length > 0) {
@@ -8303,27 +9202,43 @@ ${blocked.trim()}` };
     releaseTicketAbort(ticket.id);
     throttle.flush();
     endTranscript(ticket.id);
-    const timing = timer.summary();
-    if (timing.calls > 0) {
-      ctx.emitEvent({
-        type: "ticket.timing",
-        message: `ticket ${ticket.seq} spent ${formatTimingSummary(timing)}`,
-        ticketId: ticket.id,
-        data: timing
-      });
-    }
+    emitTicketTiming(ctx, ticket, buildTicketTiming(timer.summary(), startedAt, Date.now()));
   }
 }
 function resolveTicketModel(config2, project, runOverride, ticket) {
-  return resolveModelEntry("implement", config2, project, ticket.model ?? runOverride);
+  const step = isReviewTicket(ticket) ? "review" : "implement";
+  return resolveModelEntry(step, config2, project, ticket.model ?? runOverride);
 }
 function resolveBurnDeps(ctx) {
   const config2 = loadConfig();
   const model = resolveModelEntry("implement", config2, ctx.project, ctx.modelOverride);
   const token = readTokenFromEnvFile(envPath(), model.runtime);
+  const exec = createSystemExec({ cwd: ctx.project.repoPath });
+  const imageProbeCache = new Map;
+  const cachedExec = (command, args) => {
+    const key = `${resolveSandboxImage(config2)}\x00${model.runtime}`;
+    let result = imageProbeCache.get(key);
+    if (!result) {
+      result = exec(command, args);
+      imageProbeCache.set(key, result);
+    }
+    return result;
+  };
   const land = createSerialQueue();
   let pushTargetReady;
   const ensureIsolatedPushTarget = () => pushTargetReady ??= allowPushToCheckedOutBranches(ctx.project.repoPath);
+  let cacheVolumeReady;
+  const ensureCacheVolume = () => {
+    if (resolveBurnCacheMode(config2) !== "volume")
+      return Promise.resolve();
+    const engine = config2.sandbox === "podman" ? "podman" : "docker";
+    return cacheVolumeReady ??= ensureBurnCacheVolume({
+      engine,
+      imageName: resolveSandboxImage(config2),
+      projectId: ctx.project.id,
+      exec
+    });
+  };
   const docs2 = readDocsDigest(ctx.project.id, ctx.feature.slug);
   emitDocsDigestEvent(ctx, docs2);
   const blocks = {
@@ -8337,28 +9252,39 @@ function resolveBurnDeps(ctx) {
       dbResetCommand: ctx.project.dbResetCommand
     })
   };
+  const ticketCredentials = (ticket) => {
+    const ticketModel = resolveTicketModel(config2, ctx.project, ctx.modelOverride, ticket);
+    return {
+      model: ticketModel,
+      token: ticketModel.runtime === model.runtime ? token : readTokenFromEnvFile(envPath(), ticketModel.runtime)
+    };
+  };
   return {
     config: config2,
     runtime: model.runtime,
-    hasAuthToken: token !== undefined,
+    hasAuthToken: burnAuthReady(model.runtime, token),
+    exec: cachedExec,
+    ticketAuthMissing: (ticket) => {
+      const { model: ticketModel, token: ticketToken } = ticketCredentials(ticket);
+      return burnAuthReady(ticketModel.runtime, ticketToken) ? undefined : ticketModel.runtime;
+    },
     concurrency: config2.burnConcurrency,
     executeTicketRun: (c, ticket, run3) => {
-      const ticketModel = resolveTicketModel(config2, ctx.project, ctx.modelOverride, ticket);
-      const ticketToken = ticketModel.runtime === model.runtime ? token : readTokenFromEnvFile(envPath(), ticketModel.runtime);
+      const { model: ticketModel, token: ticketToken } = ticketCredentials(ticket);
       return isReviewTicket(ticket) ? executeReviewTicket(c, ticket, {
         config: config2,
         token: ticketToken,
         model: ticketModel,
         docsDigest: docs2.text,
         lapDigests: run3.digests
-      }) : realExecuteTicketRun(c, ticket, config2, ticketToken, ticketModel, land, ensureIsolatedPushTarget, blocks, run3);
+      }) : realExecuteTicketRun(c, ticket, config2, ticketToken, ticketModel, land, ensureIsolatedPushTarget, ensureCacheVolume, blocks, run3);
     }
   };
 }
 function readTokenFromEnvFile(path, runtime) {
   const key = RUNTIME_AUTH_KEY[runtime];
   let fromFile;
-  if (existsSync15(path)) {
+  if (existsSync16(path)) {
     try {
       fromFile = parseEnvFile2(readFileSync9(path, "utf8"))[key];
     } catch {
@@ -8368,18 +9294,25 @@ function readTokenFromEnvFile(path, runtime) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env[key];
   return token && token.length > 0 ? token : undefined;
 }
-var AUTH_MISSING_EVENT = "auth.missing", DROPPED_MAP_SECTIONS, AGENT_CONVENTIONS_FILE = "CLAUDE.md", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RUNTIME_FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, RUNTIME_RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
+var AUTH_MISSING_EVENT = "auth.missing", IMAGE_RUNTIME_MISSING_EVENT = "burn.image_runtime_missing", RUNTIME_BINARY, DROPPED_MAP_SECTIONS, AGENT_CONVENTIONS_FILE = "CLAUDE.md", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, CODEX_HOST_MOUNT_PATH = "/mnt/host-codex", SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", SETUP_MARKER_FILE = ".runcastle-setup", SETUP_MARKER = "RUNCASTLE_SETUP", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RUNTIME_FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, RUNTIME_RETRYABLE_ERROR_PATTERNS, AGENT_BINARY, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
   init_paths();
   init_skills_root();
+  init_codex_auth();
+  init_system_exec();
   init_knowledge();
   init_setup();
   init_agent_stream();
   init_git();
   init_burn_guard();
+  init_burn_cache();
   init_review_ticket();
+  RUNTIME_BINARY = {
+    "claude-code": "claude",
+    codex: "codex"
+  };
   DROPPED_MAP_SECTIONS = ["Not yet specified", "Out of scope"];
   PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
   PM_CACHE_SANDBOX_PATHS = {
@@ -8432,7 +9365,10 @@ var init_ticket_burner = __esm(() => {
       /\b401\b|\b403\b/,
       /insufficient_quota|exceeded your current quota/i,
       /model_not_found|does not exist or you do not have access/i,
-      /CODEX_API_KEY/
+      /CODEX_API_KEY/,
+      /not logged in/i,
+      /\bauth (failed|required)\b/i,
+      /refresh token/i
     ]
   };
   RETRYABLE_ERROR_PATTERNS = [
@@ -8449,6 +9385,10 @@ var init_ticket_burner = __esm(() => {
     "claude-code": [],
     codex: [/rate_limit_exceeded/i, /\b429\b/, /server_error/i, /stream (disconnected|interrupted)/i]
   };
+  AGENT_BINARY = {
+    "claude-code": "claude",
+    codex: "codex"
+  };
   activeTicketAborts = new Map;
   SETUP_HOOK_TIMEOUT_MS = 15 * 60000;
   ticketBurner = {
@@ -8460,7 +9400,7 @@ var init_ticket_burner = __esm(() => {
 // src/workflows/research.ts
 import { mkdirSync as mkdirSync10, readFileSync as readFileSync10 } from "fs";
 import { dirname as dirname7, join as join15 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { fileURLToPath as fileURLToPath7 } from "url";
 import { run as run3 } from "@ai-hero/sandcastle";
 function waypointSlug(waypoint) {
   const base = waypoint.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -8528,7 +9468,7 @@ function interpretResearchResult(result, docRelPath) {
   return { status: "failed", error: "agent produced no commits \u2014 no research summary landed" };
 }
 function researchTemplatePath() {
-  const here = dirname7(fileURLToPath6(import.meta.url));
+  const here = dirname7(fileURLToPath7(import.meta.url));
   return join15(resolveSkillsRoot(here), "burner", "research-waypoint.md");
 }
 async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
@@ -8545,14 +9485,16 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   mkdirSync10(logsDir(), { recursive: true });
   const logFilePath = join15(logsDir(), `research-${feature.id}-${waypoint.seq}.log`);
   const throttle = createResearchStreamThrottle((e) => ctx.emitEvent(e));
+  const codexAuthMount = codexAuthMountFor(model.runtime, config2.sandbox);
   const runOptions = {
     agent: buildBurnAgent(config2, token, model),
-    sandbox: selectSandbox(config2),
+    sandbox: selectSandbox(config2, codexAuthMount ? [codexAuthMount] : []),
     cwd: project.repoPath,
     prompt,
     branchStrategy: { type: "branch", branch: tempBranch, baseBranch: feature.branch },
     signal: ctx.signal,
     name: `research-${waypoint.seq}`,
+    ...codexAuthMount ? { hooks: { sandbox: { onSandboxReady: [{ command: buildCodexAuthCopyCommand() }] } } } : {},
     logging: { type: "file", path: logFilePath, onAgentStreamEvent: throttle.onEvent }
   };
   let result;
@@ -8600,7 +9542,7 @@ function resolveResearchDeps(ctx) {
   return {
     config: config2,
     runtime: model.runtime,
-    hasAuthToken: token !== undefined,
+    hasAuthToken: burnAuthReady(model.runtime, token),
     executeResearchRun: (c, waypoint) => realExecuteResearchRun(c, waypoint, config2, token, model)
   };
 }
@@ -8635,7 +9577,7 @@ var init_registry2 = __esm(() => {
 });
 
 // src/workflows/runner.ts
-import { eq as eq9 } from "drizzle-orm";
+import { eq as eq10 } from "drizzle-orm";
 function workflowClaimsFeatureBranch(workflowId) {
   return BRANCH_CLAIMING.has(workflowId);
 }
@@ -8664,7 +9606,7 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
       claim(ctx, opts.claimWaypointId, runId);
     } catch (e) {
       const summary = e instanceof Error ? e.message : "claim failed";
-      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq9(runs.id, runId)).run();
+      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq10(runs.id, runId)).run();
       throw e;
     }
   }
@@ -8695,6 +9637,10 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
     updateTicket: (id, patch) => {
       updateTicket(ctx, id, patch);
     },
+    listTickets: () => listByFeature2(ctx, featureId),
+    updateFinding: (findingId, progress, reason) => {
+      markFixProgress(ctx, findingId, progress, reason);
+    },
     input: opts.input,
     modelOverride: opts.modelOverride,
     resolveWaypoint: (id, disposition, summary) => {
@@ -8732,7 +9678,7 @@ async function executeRun(ctx, runId, featureId, workflow2, runPromise, controll
   } finally {
     controllers.delete(runId);
   }
-  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary, ...digest ? { digest } : {} }).where(eq9(runs.id, runId)).run();
+  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary, ...digest ? { digest } : {} }).where(eq10(runs.id, runId)).run();
   releaseForSession(ctx, runId);
   if (workflowClaimsFeatureBranch(workflow2)) {
     sweepOrphanedBurning(ctx, featureId, `orphaned \u2014 the run ended (${status}) while it was burning`);
@@ -8772,6 +9718,7 @@ var init_runner = __esm(() => {
   init_gates();
   init_git();
   init_repo();
+  init_review_findings();
   init_tickets();
   init_waypoints();
   init_registry2();
@@ -8780,14 +9727,13 @@ var init_runner = __esm(() => {
 });
 
 // src/services/features.ts
-import { desc as desc5, eq as eq10 } from "drizzle-orm";
+import { desc as desc5, eq as eq11 } from "drizzle-orm";
 import { rmSync as rmSync4 } from "fs";
 async function createFeature(ctx, input) {
   const project = requireProjectById(ctx, input.projectId);
   const slug = uniqueSlug(ctx, project.id, input.title);
   const branch = `feature/${slug}`;
-  const requestedBase = input.baseBranch?.trim() || project.mainBranch;
-  const cut = input.draft ? null : await ensureFeatureBranch(project, slug, requestedBase);
+  const cut = input.draft ? null : await ensureFeatureBranch(project, slug, await requestedBase(project, input.baseBranch));
   const row = {
     id: newId("feat"),
     projectId: project.id,
@@ -8818,12 +9764,7 @@ async function createFeature(ctx, input) {
   });
   if (!cut)
     return feature;
-  scaffoldDocs(ctx, feature, { brief: input.brief });
-  if (cut.branchReady) {
-    try {
-      await commitDocs(project.repoPath, `runcastle: scaffold ${slug} docs`);
-    } catch {}
-  }
+  await scaffoldDocsOnFeatureBranch(ctx, project, feature, { brief: input.brief });
   return feature;
 }
 function requireNotDraft(feature) {
@@ -8837,21 +9778,16 @@ async function startDraft(ctx, featureId, opts = {}) {
     throw new GateError(`feature ${feature.slug} is not a draft \u2014 it has already been started`);
   }
   const project = projectForFeature(ctx, feature);
-  const requestedBase = opts.baseBranch?.trim() || project.mainBranch;
-  const { branchReady, baseBranch } = await ensureFeatureBranch(project, feature.slug, requestedBase);
-  ctx.db.update(features).set({ status: "active", baseBranch }).where(eq10(features.id, featureId)).run();
+  const base = await requestedBase(project, opts.baseBranch);
+  const { branchReady, baseBranch } = await ensureFeatureBranch(project, feature.slug, base);
+  ctx.db.update(features).set({ status: "active", baseBranch }).where(eq11(features.id, featureId)).run();
   const started = { ...feature, status: "active", baseBranch };
   emit(ctx, featureId, {
     type: "feature.started",
     message: branchReady ? `feature ${feature.slug} started (${feature.branch} \u2190 ${baseBranch})` : `feature ${feature.slug} started (branch pending)`,
     data: { branch: feature.branch, baseBranch, branchReady }
   });
-  scaffoldDocs(ctx, started, { brief: feature.brief });
-  if (branchReady) {
-    try {
-      await commitDocs(project.repoPath, `runcastle: scaffold ${feature.slug} docs`);
-    } catch {}
-  }
+  await scaffoldDocsOnFeatureBranch(ctx, project, started, { brief: feature.brief });
   return started;
 }
 function quickTicketTitle(prose) {
@@ -8877,10 +9813,10 @@ ${body}
 function quickReviewTicket(proses) {
   return {
     title: "Review the integrated change",
-    goal: "Review the integrated feature branch and report what you find. Code-review the branch's " + "diff against its base \u2014 always, whatever this change turned out to be \u2014 and additionally " + "drive the app when the diff touches something a human can operate. Write one note per " + "finding; finding bugs is a successful review, and the notes are the deliverable.",
-    context: "This feature came through the quick-change door, so there was no grill session and there " + "is no spec.md or decisions.md to review it against: the whole statement of intent is the " + `${proses.length === 1 ? "sentence" : `${proses.length} sentences`} the human typed, which ` + "are the other tickets in this batch and are reproduced verbatim in brief.md. Nobody " + "prescribed a walkthrough for you either \u2014 judge from the diff whether there is anything " + "drivable, and if there is not, say so and let the code review stand alone. Your digest is " + "the lap's prose summary of what landed; the review page leads with it.",
+    goal: "Review the integrated feature branch and report what you find, in exactly one mode: " + "drive the app in a browser against the criteria below when this change touched something " + "a human can operate and a drive is available, and otherwise run the verify gates and " + "code-review the branch's diff against its base. Write one note per finding; finding bugs " + "is a successful review, and the notes are the deliverable.",
+    context: "This feature came through the quick-change door, so there was no grill session and there " + "is no spec.md or decisions.md to review it against: the whole statement of intent is the " + `${proses.length === 1 ? "sentence" : `${proses.length} sentences`} the human typed, which ` + "are the other tickets in this batch and are reproduced verbatim in brief.md. Nobody " + "prescribed a walkthrough for you either \u2014 judge from the diff whether there is anything " + "drivable, and if there is not, take the gates-and-diff mode. Your digest is " + "the lap's prose summary of what landed, and its first line names the mode you ran; the " + "review page leads with it.",
     acceptanceCriteria: [
-      "The branch's diff against its base is code-reviewed on both axes \u2014 the repo's own " + "standards, and the change against what was asked for.",
+      "Reviewed in one mode \u2014 either walked in a browser, or put through the verify gates and " + "code-reviewed on both axes (the repo's own standards, and the change against what was " + "asked for).",
       ...proses.map((prose) => `Landed and does what it says: ${prose}`)
     ],
     seams: [],
@@ -8898,8 +9834,8 @@ async function quickChange(ctx, input) {
     throw new InvalidInputError("a quick change needs a sentence describing the change");
   const slug = uniqueSlug(ctx, project.id, title);
   const branch = `feature/${slug}`;
-  const requestedBase = input.baseBranch?.trim() || project.mainBranch;
-  const { branchReady, baseBranch } = await ensureFeatureBranch(project, slug, requestedBase);
+  const base = await requestedBase(project, input.baseBranch);
+  const { branchReady, baseBranch } = await ensureFeatureBranch(project, slug, base);
   const inserted = ctx.db.insert(features).values({
     id: newId("feat"),
     projectId: project.id,
@@ -8921,7 +9857,7 @@ async function quickChange(ctx, input) {
     message: branchReady ? `feature.created (${branch} \u2190 ${baseBranch})` : "feature.created (branch pending)",
     data: { slug, branch, baseBranch, branchReady }
   });
-  scaffoldDocs(ctx, feature, { brief: quickBrief(title, proses) });
+  await scaffoldDocsOnFeatureBranch(ctx, project, feature, { brief: quickBrief(title, proses) });
   const stored = storeTickets(ctx, feature.id, [
     ...proses.map((prose) => ({
       title: quickTicketTitle(prose),
@@ -8941,24 +9877,42 @@ async function quickChange(ctx, input) {
     message: `quick change \u2014 born at implementation on lap 1 with ${tally} (${typed.map((t) => `#${t.seq}`).join(", ")}) plus a review ticket (#${review.seq}); no grill session, no spec.md`,
     data: { slug, ticketSeqs: stored.map((t) => t.seq), phase: "implementation" }
   });
-  if (branchReady) {
-    try {
-      await commitDocs(project.repoPath, `runcastle: scaffold ${slug} docs`);
-    } catch {}
-  }
   return feature;
 }
-async function ensureFeatureBranch(project, slug, requestedBase) {
+async function requestedBase(project, picked) {
+  return picked?.trim() || await currentCheckoutBranch(project);
+}
+async function ensureFeatureBranch(project, slug, base) {
   try {
-    const baseBranch = await resolveBaseBranch(project, requestedBase);
+    const baseBranch = await resolveBaseBranch(project, base);
     await createFeatureBranch(project, slug, baseBranch);
     return { branchReady: true, baseBranch };
   } catch (e) {
     if (isNotImplemented(e))
-      return { branchReady: false, baseBranch: requestedBase };
+      return { branchReady: false, baseBranch: base };
     throw e;
   }
 }
+async function scaffoldDocsOnFeatureBranch(ctx, project, feature, opts) {
+  let worktreePath;
+  try {
+    worktreePath = await ensureTalkWorktree(project, feature);
+  } catch (e) {
+    if (isNotImplemented(e)) {
+      scaffoldDocs(ctx, feature, opts);
+      return;
+    }
+    emit(ctx, feature.id, {
+      type: "docs.scaffold_failed",
+      message: `docs not scaffolded onto ${feature.branch}: ${e instanceof Error ? e.message : String(e)}`
+    });
+    return;
+  }
+  scaffoldDocs(ctx, feature, opts);
+  try {
+    await commitDocs(worktreePath, `runcastle: scaffold ${feature.slug} docs`);
+  } catch {}
+}
 function getFeatureFull(ctx, id) {
   const feature = getFeatureRow(ctx, id);
   const waypoints2 = feature.mapped ? listByFeature(ctx, id) : [];
@@ -8975,7 +9929,7 @@ function getFeatureFull(ctx, id) {
   };
 }
 function list(ctx, projectId) {
-  const rows = ctx.db.select().from(features).where(eq10(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
+  const rows = ctx.db.select().from(features).where(eq11(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
   const lastActivity = latestTsByFeature(ctx, projectId);
   return rows.map((row) => {
     const feature = rowToFeature(row);
@@ -9090,7 +10044,7 @@ function rethink(ctx, featureId) {
     throw new GateError(`${feature.slug} is being test-driven \u2014 stop the test drive first, it holds the feature branch`);
   }
   const lap = feature.lap + 1;
-  ctx.db.update(features).set({ lap }).where(eq10(features.id, featureId)).run();
+  ctx.db.update(features).set({ lap }).where(eq11(features.id, featureId)).run();
   return setPhase(ctx, featureId, RETHINK_LOOP_BACK.to, "lap.started", `rethink \u2014 lap ${lap}`);
 }
 async function rethinkAndLaunch(ctx, featureId, launch) {
@@ -9099,7 +10053,7 @@ async function rethinkAndLaunch(ctx, featureId, launch) {
   try {
     return await launch(feature);
   } catch (e) {
-    ctx.db.update(features).set({ lap: before.lap }).where(eq10(features.id, featureId)).run();
+    ctx.db.update(features).set({ lap: before.lap }).where(eq11(features.id, featureId)).run();
     setPhase(ctx, featureId, before.phase, "lap.aborted", `lap ${feature.lap} aborted \u2014 its terminal could not be opened (${errMsg2(e)}); back at ${before.phase} on lap ${before.lap}`);
     throw e;
   }
@@ -9178,7 +10132,7 @@ function escalateToMap(ctx, featureId, input) {
     return { ok: true, warning: `feature ${feature.slug} is already mapped \u2014 no changes made` };
   }
   const project = projectForFeature(ctx, feature);
-  ctx.db.update(features).set({ mapped: true }).where(eq10(features.id, featureId)).run();
+  ctx.db.update(features).set({ mapped: true }).where(eq11(features.id, featureId)).run();
   scaffoldMapDoc(project, { ...feature, mapped: true }, input);
   emit(ctx, featureId, {
     type: "feature.escalated",
@@ -9196,7 +10150,7 @@ function archiveFeature(ctx, featureId) {
   const live = listSessionsByFeature(ctx, featureId).find((s) => s.status === "live");
   if (live)
     endSession(ctx, live.id);
-  ctx.db.update(features).set({ status: "archived" }).where(eq10(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: "archived" }).where(eq11(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.archived",
     message: `feature ${feature.slug} archived`,
@@ -9210,7 +10164,7 @@ function unarchiveFeature(ctx, featureId) {
     throw new GateError(`feature ${feature.slug} is not archived`);
   }
   const restored = feature.phase === "shipped" ? "shipped" : "active";
-  ctx.db.update(features).set({ status: restored }).where(eq10(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: restored }).where(eq11(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.unarchived",
     message: `feature ${feature.slug} unarchived (${restored})`,
@@ -9250,13 +10204,13 @@ async function deleteFeature(ctx, featureId) {
   return { ok: true, slug: feature.slug };
 }
 function deleteFeatureRows(ctx, featureId) {
-  ctx.db.delete(tickets).where(eq10(tickets.featureId, featureId)).run();
-  ctx.db.delete(sessions).where(eq10(sessions.featureId, featureId)).run();
-  ctx.db.delete(runs).where(eq10(runs.featureId, featureId)).run();
-  ctx.db.delete(events).where(eq10(events.featureId, featureId)).run();
-  ctx.db.delete(gateOverrides).where(eq10(gateOverrides.featureId, featureId)).run();
-  ctx.db.delete(waypoints).where(eq10(waypoints.featureId, featureId)).run();
-  ctx.db.delete(features).where(eq10(features.id, featureId)).run();
+  ctx.db.delete(tickets).where(eq11(tickets.featureId, featureId)).run();
+  ctx.db.delete(sessions).where(eq11(sessions.featureId, featureId)).run();
+  ctx.db.delete(runs).where(eq11(runs.featureId, featureId)).run();
+  ctx.db.delete(events).where(eq11(events.featureId, featureId)).run();
+  ctx.db.delete(gateOverrides).where(eq11(gateOverrides.featureId, featureId)).run();
+  ctx.db.delete(waypoints).where(eq11(waypoints.featureId, featureId)).run();
+  ctx.db.delete(features).where(eq11(features.id, featureId)).run();
 }
 function gateState(ctx, feature) {
   const gate = nextGate(feature);
@@ -9267,7 +10221,7 @@ function gateState(ctx, feature) {
 }
 function uniqueSlug(ctx, projectId, title) {
   const base = slugify(title);
-  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq10(features.projectId, projectId)).all().map((r) => r.slug));
+  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq11(features.projectId, projectId)).all().map((r) => r.slug));
   if (!existing.has(base))
     return base;
   let n = 2;
@@ -9298,9 +10252,9 @@ var init_features = __esm(() => {
 });
 
 // src/services/test-notes.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname8 } from "path";
-import { asc as asc4, eq as eq11 } from "drizzle-orm";
+import { asc as asc5, eq as eq12 } from "drizzle-orm";
 function rowToNote(row) {
   return TestNote.parse({
     id: row.id,
@@ -9311,13 +10265,13 @@ function rowToNote(row) {
     author: row.author,
     ticketId: row.ticketId ?? undefined,
     videoTimestamp: row.videoTimestamp ?? undefined,
-    screenshotUrl: existsSync17(annotationPath(row.id)) ? noteScreenshotUrl(row.id) : undefined,
+    screenshotUrl: existsSync18(annotationPath(row.id)) ? noteScreenshotUrl(row.id) : undefined,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   });
 }
 function getNote(ctx, id) {
-  const row = ctx.db.select().from(testNotes).where(eq11(testNotes.id, id)).get();
+  const row = ctx.db.select().from(testNotes).where(eq12(testNotes.id, id)).get();
   if (!row)
     throw new NotFoundError(`test note ${id} not found`);
   return rowToNote(row);
@@ -9333,8 +10287,8 @@ function assertOpen(note, action) {
     throw new InvalidInputError(`cannot ${action} note ${note.id} \u2014 it is ${note.status}; only open notes can be changed`);
   }
 }
-function listByFeature3(ctx, featureId) {
-  return ctx.db.select().from(testNotes).where(eq11(testNotes.featureId, featureId)).orderBy(asc4(testNotes.createdAt), asc4(testNotes.id)).all().map(rowToNote);
+function listByFeature4(ctx, featureId) {
+  return ctx.db.select().from(testNotes).where(eq12(testNotes.featureId, featureId)).orderBy(asc5(testNotes.createdAt), asc5(testNotes.id)).all().map(rowToNote);
 }
 function addNote(ctx, featureId, text2, author = "human", videoTimestamp) {
   const body = cleanText(text2);
@@ -9365,7 +10319,7 @@ function editNote(ctx, noteId, text2) {
   const current2 = getNote(ctx, noteId);
   assertOpen(current2, "edit");
   const body = cleanText(text2);
-  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq11(testNotes.id, noteId)).run();
+  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq12(testNotes.id, noteId)).run();
   emit(ctx, current2.featureId, {
     type: "note.edited",
     message: "note edited",
@@ -9377,7 +10331,7 @@ function editNote(ctx, noteId, text2) {
 function deleteNote(ctx, noteId) {
   const current2 = getNote(ctx, noteId);
   assertOpen(current2, "delete");
-  ctx.db.delete(testNotes).where(eq11(testNotes.id, noteId)).run();
+  ctx.db.delete(testNotes).where(eq12(testNotes.id, noteId)).run();
   rmSync5(annotationPath(noteId), { force: true });
   emit(ctx, current2.featureId, {
     type: "note.deleted",
@@ -9404,7 +10358,7 @@ function toggleNote(ctx, noteId) {
     throw new InvalidInputError(`cannot toggle note ${noteId} \u2014 it is promoted, and promoted notes are frozen`);
   }
   const status = current2.status === "open" ? "done" : "open";
-  ctx.db.update(testNotes).set({ status, updatedAt: Date.now() }).where(eq11(testNotes.id, noteId)).run();
+  ctx.db.update(testNotes).set({ status, updatedAt: Date.now() }).where(eq12(testNotes.id, noteId)).run();
   emit(ctx, current2.featureId, {
     type: "note.toggled",
     message: `note ${current2.status} \u2192 ${status}`,
@@ -9454,7 +10408,7 @@ function freezeAsTickets(ctx, noteIds) {
   const tickets2 = storeTickets(ctx, featureId, selected.map((note) => promotionTicket(feature, note)));
   const now = Date.now();
   selected.forEach((note, i) => {
-    ctx.db.update(testNotes).set({ status: "promoted", ticketId: tickets2[i].id, updatedAt: now }).where(eq11(testNotes.id, note.id)).run();
+    ctx.db.update(testNotes).set({ status: "promoted", ticketId: tickets2[i].id, updatedAt: now }).where(eq12(testNotes.id, note.id)).run();
   });
   return { feature, notes: selected.map((n) => getNote(ctx, n.id)), tickets: tickets2 };
 }
@@ -9492,7 +10446,7 @@ function noteLine(ctx, note) {
   return `- [x] ${note.text}${ticket}${shot}`;
 }
 function renderTestNotes(ctx, feature) {
-  const notes = listByFeature3(ctx, feature.id);
+  const notes = listByFeature4(ctx, feature.id);
   const laps = [...new Set(notes.map((n) => n.lap))].sort((a, b) => a - b);
   const lines = ["# Test notes"];
   for (const lap of laps) {
@@ -9519,7 +10473,7 @@ var init_test_notes = __esm(() => {
 });
 
 // src/mcp/server.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
 import { join as join16, relative as relative3, resolve as resolve9, sep as sep2 } from "path";
 import { StreamableHTTPTransport } from "@hono/mcp";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -9818,6 +10772,23 @@ function toolAddTestNote(ctx, caller, input) {
   const identity = requireRunIdentity(ctx, caller, "add_test_note");
   return addNote(ctx, identity.featureId, input.text, "agent");
 }
+function toolReportFinding(ctx, caller, input) {
+  const identity = requireRunIdentity(ctx, caller, "report_finding");
+  const reviewTicket = listByFeature2(ctx, identity.featureId).find((ticket) => ticket.kind === "review" && ticket.status === "burning");
+  if (!reviewTicket) {
+    throw new GateError("report_finding requires a burning review ticket on this run\u2019s feature");
+  }
+  const result = reportFinding(ctx, {
+    featureId: identity.featureId,
+    reviewTicket,
+    input
+  });
+  return {
+    findingId: result.finding.id,
+    fixTicketSeq: result.fixTicket?.seq ?? null,
+    overCap: result.overCap
+  };
+}
 async function toolRetryDrive(ctx, session) {
   if (session.kind !== "drive-fix") {
     throw new GateError(`retrying a drive belongs to a drive-fix session, and this is a ${session.kind} session. ` + "It stops and restarts a test drive on the human's machine \u2014 only the session opened on " + "that failed drive may do that; everyone else asks the human to drive from the review panel.");
@@ -9873,7 +10844,7 @@ async function toolCreateFeature(ctx, session, input) {
     phase: feature.phase
   };
 }
-function toolGetProjectContext(ctx, session) {
+async function toolGetProjectContext(ctx, session) {
   const project = requireProject(ctx, session);
   const charter = readCharter(session.worktreePath);
   return {
@@ -9881,7 +10852,18 @@ function toolGetProjectContext(ctx, session) {
     ...charter !== undefined ? { charter } : {},
     adrs: listLiveAdrs(session.worktreePath).map(adrRef),
     adrsNote: ADRS_NOTE,
-    featureIndex: list(ctx, project.id).map(featureIndexLine)
+    featureIndex: list(ctx, project.id).map(featureIndexLine),
+    baseBranches: await readBaseBranches(project)
+  };
+}
+async function readBaseBranches(project) {
+  const { current: current2, branches, remoteBranches } = await listBranches(project);
+  const selectable = [...branches, ...remoteBranches];
+  return {
+    current: current2,
+    currentIsSelectable: selectable.includes(current2),
+    selectable,
+    detectedMain: await detectMainBranch(project.repoPath)
   };
 }
 function adrRef(adr) {
@@ -9903,7 +10885,7 @@ function toolReadAdr(ctx, session, input) {
   if (rel === "" || rel.startsWith("..") || rel.split(sep2).includes("..")) {
     throw new InvalidInputError(`adr path escapes ${ADR_DIR_REL}: ${input.relPath}`);
   }
-  if (!existsSync18(target))
+  if (!existsSync19(target))
     throw new NotFoundError(`adr not found: ${input.relPath}`);
   return { relPath: `${ADR_DIR_REL}/${name}`, content: readFileSync11(target, "utf8") };
 }
@@ -10065,6 +11047,16 @@ function buildMcpServer(audience) {
       return ok(toolAddTestNote(rc.ctx, rc.caller, args));
     });
   }
+  if (wants("report_finding")) {
+    server.registerTool("report_finding", {
+      title: "Report a structured review finding",
+      description: "Report one typed finding for the feature under review. Actionable defects mint fix " + "tickets automatically up to the review cap; observations are retained for the digest.",
+      inputSchema: ReviewFindingInput.shape
+    }, async (args, extra) => {
+      const rc = await resolveRunCaller(extra);
+      return ok(toolReportFinding(rc.ctx, rc.caller, ReviewFindingInput.parse(args)));
+    });
+  }
   if (wants("retry_drive")) {
     server.registerTool("retry_drive", {
       title: "Retry this feature\u2019s test drive",
@@ -10100,7 +11092,7 @@ function buildMcpServer(audience) {
       inputSchema: {
         title: z4.string().min(1).describe("The feature\u2019s name; its slug and branch derive from this."),
         oneLiner: z4.string().optional().describe("One line saying what this feature is. Required for every shape EXCEPT `tickets`, " + "where the first ticket\u2019s prose becomes the one-liner and anything sent here is " + "ignored."),
-        baseBranch: z4.string().optional().describe("Branch to cut from; defaults to the project\u2019s main branch."),
+        baseBranch: z4.string().optional().describe("Branch to cut from \u2014 always pass it explicitly, naming the base you told the " + "human you would use (see `get_project_context`\u2019s `baseBranches`). Omitted, it " + "falls back to whatever the project checkout happens to be on. Drafts pass none: " + "a parked feature picks its base at Start."),
         brief: z4.string().optional().describe("The reasoning you just worked out with the human \u2014 why this feature exists and " + "what it must NOT swallow. Becomes brief.md verbatim, and without it that " + "reasoning is lost. Unused by the `tickets` shape, whose brief IS the proses."),
         draft: z4.boolean().optional().describe("PARK it instead of starting it: a row and its brief, no branch and no files, " + "until the human clicks Start. Ask them per feature whether to start or park."),
         tickets: z4.array(z4.string().min(1)).min(1).optional().describe("The quick-change shape: work too small to deserve a grill. Creates ONE feature at " + "the implementation phase carrying a ticket per prose (plus the review ticket " + "every batch closes with). Send every sentence of one quick change in a SINGLE " + "call \u2014 calling this once per ticket makes one feature per ticket.")
@@ -10115,13 +11107,13 @@ function buildMcpServer(audience) {
   if (wants("get_project_context")) {
     server.registerTool("get_project_context", {
       title: "Get project context",
-      description: "The project as it stands: the project row, the charter (CONTEXT.md) in full, an INDEX " + "of every live ADR (superseded ones omitted) and a one-line index of every feature. " + "ADR bodies are not inlined \u2014 read the ones your work touches with `read_adr`. Shipped " + "features carry their one-liner and docs path (readable on disk); in-flight ones carry " + "slug, phase, lap and ticket counts but no docs path, because their docs live on an " + "unmerged branch. Use the slug with `get_work_record` to see what one actually did.",
+      description: "The project as it stands: the project row, the charter (CONTEXT.md) in full, an INDEX " + "of every live ADR (superseded ones omitted) and a one-line index of every feature. " + "ADR bodies are not inlined \u2014 read the ones your work touches with `read_adr`. Shipped " + "features carry their one-liner and docs path (readable on disk); in-flight ones carry " + "slug, phase, lap and ticket counts but no docs path, because their docs live on an " + "unmerged branch. Use the slug with `get_work_record` to see what one actually did. " + "Plus `baseBranches` \u2014 the branch a new feature would cut from: the checkout\u2019s `current` " + "branch, `currentIsSelectable` (false mid test drive or on a detached HEAD, the one case " + "with no default), every `selectable` base, and the `detectedMain` line to suggest then.",
       inputSchema: {}
     }, async (_args, extra) => {
       const rs = await resolveCtxSession(extra);
       if (!rs)
         return noSession();
-      return ok(toolGetProjectContext(rs.ctx, rs.session));
+      return ok(await toolGetProjectContext(rs.ctx, rs.session));
     });
   }
   if (wants("read_adr")) {
@@ -10360,6 +11352,7 @@ var init_server = __esm(() => {
   init_features();
   init_events();
   init_findings();
+  init_review_findings();
   init_git();
   init_knowledge();
   init_repo();
@@ -10399,7 +11392,8 @@ var init_server = __esm(() => {
     dry_run_drive: ["prepare"],
     retry_drive: ["drive-fix"],
     review_drive: ["run"],
-    add_test_note: ["run"],
+    report_finding: ["run"],
+    add_test_note: [],
     record_event: [...FEATURE_KINDS, ...PROJECT_KINDS]
   };
   CompletablePhase = Phase.exclude(["shipped"]);
@@ -10489,7 +11483,7 @@ var init_ws = __esm(() => {
 });
 
 // src/services/prep.ts
-import { and as and8, desc as desc6, eq as eq12, inArray as inArray4 } from "drizzle-orm";
+import { and as and9, desc as desc6, eq as eq13, inArray as inArray4 } from "drizzle-orm";
 function keysToPrepare(ctx, project) {
   return unsetPreparedKeys(project).filter((key) => isOverwritable(ctx, project.id, key));
 }
@@ -10499,10 +11493,10 @@ function isPrepared(ctx, project) {
   return hasCompletedProjectSession(ctx, project.id, "prepare");
 }
 function preparedAt(ctx, projectId) {
-  const prepareSessions = new Set(ctx.db.select({ id: sessions.id }).from(sessions).where(and8(eq12(sessions.projectId, projectId), eq12(sessions.kind, "prepare"))).all().map((r) => r.id));
+  const prepareSessions = new Set(ctx.db.select({ id: sessions.id }).from(sessions).where(and9(eq13(sessions.projectId, projectId), eq13(sessions.kind, "prepare"))).all().map((r) => r.id));
   if (prepareSessions.size === 0)
     return null;
-  const ends = ctx.db.select({ ts: events.ts, data: events.data }).from(events).where(and8(eq12(events.projectId, projectId), inArray4(events.type, ["session.ended", "session.reconciled"]))).orderBy(desc6(events.ts)).all();
+  const ends = ctx.db.select({ ts: events.ts, data: events.data }).from(events).where(and9(eq13(events.projectId, projectId), inArray4(events.type, ["session.ended", "session.reconciled"]))).orderBy(desc6(events.ts)).all();
   for (const end of ends) {
     const sessionId = end.data?.sessionId;
     if (sessionId && prepareSessions.has(sessionId))
@@ -10757,7 +11751,7 @@ var init_hooks = __esm(() => {
 });
 
 // src/routes/reviews.ts
-import { createReadStream, statSync as statSync3 } from "fs";
+import { createReadStream, statSync as statSync4 } from "fs";
 import { Readable } from "stream";
 import { Hono as Hono3 } from "hono";
 function walkthroughUrl(ticketId) {
@@ -10765,7 +11759,7 @@ function walkthroughUrl(ticketId) {
 }
 function fileSize(path) {
   try {
-    const stat = statSync3(path);
+    const stat = statSync4(path);
     return stat.isFile() ? stat.size : undefined;
   } catch {
     return;
@@ -10943,7 +11937,7 @@ var init_stream = __esm(() => {
 });
 
 // src/routes/web.ts
-import { existsSync as existsSync19, statSync as statSync4 } from "fs";
+import { existsSync as existsSync20, statSync as statSync5 } from "fs";
 import { readFile } from "fs/promises";
 import { extname, join as join17, normalize, resolve as resolve10, sep as sep3 } from "path";
 function contentType(path) {
@@ -10951,7 +11945,7 @@ function contentType(path) {
 }
 function isFile(path) {
   try {
-    return statSync4(path).isFile();
+    return statSync5(path).isFile();
   } catch {
     return false;
   }
@@ -10996,7 +11990,7 @@ function mountWebApp(app, distDir) {
 }
 function mountWebAppIfBuilt(app) {
   const dist = resolveWebDist();
-  if (existsSync19(join17(dist, "index.html")))
+  if (existsSync20(join17(dist, "index.html")))
     mountWebApp(app, dist);
 }
 var MIME;
@@ -11025,11 +12019,11 @@ var init_web = __esm(() => {
 // src/version.ts
 import { readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname9, join as join18 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { fileURLToPath as fileURLToPath8 } from "url";
 function runcastleVersion() {
   if (cached2)
     return cached2;
-  const here = dirname9(fileURLToPath7(import.meta.url));
+  const here = dirname9(fileURLToPath8(import.meta.url));
   for (const pkgPath of [join18(here, "..", "package.json"), join18(here, "package.json")]) {
     try {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
@@ -11047,12 +12041,12 @@ var init_version = () => {};
 
 // src/services/install-id.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname10 } from "path";
 function getInstallId() {
   const file = installIdPath();
   try {
-    if (existsSync20(file)) {
+    if (existsSync21(file)) {
       const existing = readFileSync13(file, "utf8").trim();
       if (UUID_RE.test(existing))
         return existing;
@@ -11252,9 +12246,9 @@ var init_events2 = __esm(() => {
 });
 
 // src/launcher/launcher.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { join as join19 } from "path";
-import { and as and9, eq as eq13 } from "drizzle-orm";
+import { and as and10, eq as eq14 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
   return `terminal exited (code ${label})`;
@@ -11274,7 +12268,7 @@ function renderCommand(runtime, spec) {
   return [...env, runtime.binary, ...spec.argv].join(" ");
 }
 function activeRunFor(ctx, featureId) {
-  const row = ctx.db.select().from(runs).where(and9(eq13(runs.featureId, featureId), eq13(runs.status, "running"))).limit(1).get();
+  const row = ctx.db.select().from(runs).where(and10(eq14(runs.featureId, featureId), eq14(runs.status, "running"))).limit(1).get();
   return row ? rowToRun(row) : null;
 }
 function assertSpawnable(ctx, feature, excludeSessionId) {
@@ -11638,7 +12632,7 @@ async function launchProjectSession(ctx, input, opts = {}) {
   const model = resolveModelEntry("project", ctx.config, project);
   const runtime = runtimeAdapterFor(model.runtime);
   assertRuntimeReady(runtime, opts);
-  const worktreePath = await ensureProjectWorktree(project, (res) => reportProjectLanding(ctx, project, res, { retried: true }));
+  const { worktreePath, base } = await ensureProjectWorktree(project, (res) => reportProjectLanding(ctx, project, res, { retried: true }));
   const session = createSessionRow(ctx, {
     projectId: project.id,
     kind: "project",
@@ -11691,7 +12685,7 @@ async function launchProjectSession(ctx, input, opts = {}) {
     session,
     project,
     config: ctx.config,
-    projectBrief: { project, branch: PROJECT_BRANCH, worktreePath },
+    projectBrief: { project, branch: PROJECT_BRANCH, worktreePath, base },
     worktreePath,
     serverUrl: serverUrlFor(ctx.config),
     model: model.id,
@@ -11725,7 +12719,7 @@ async function buildPrepareBrief(ctx, project) {
   };
 }
 function probePrepareHost(repoPath) {
-  const has = (rel) => existsSync21(join19(repoPath, rel));
+  const has = (rel) => existsSync22(join19(repoPath, rel));
   const lock = LOCKFILES.find(([file]) => has(file));
   return {
     platform: process.platform,
@@ -12075,10 +13069,10 @@ var init_feature = __esm(() => {
 });
 
 // src/services/fsbrowse.ts
-import { existsSync as existsSync22, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync23, readdirSync as readdirSync6, statSync as statSync6 } from "fs";
+import { homedir as homedir3 } from "os";
 import { basename as basename3, dirname as dirname11, isAbsolute as isAbsolute2, join as join21, resolve as resolve11, sep as sep4 } from "path";
-function expandPath(input, home = homedir4()) {
+function expandPath(input, home = homedir3()) {
   const trimmed = input.trim();
   if (trimmed === "")
     return trimmed;
@@ -12091,31 +13085,31 @@ function expandPath(input, home = homedir4()) {
 }
 function looksLikeRepo(dir) {
   try {
-    return existsSync22(join21(dir, ".git"));
+    return existsSync23(join21(dir, ".git"));
   } catch {
     return false;
   }
 }
-function listRoots(home = homedir4()) {
+function listRoots(home = homedir3()) {
   const roots = [];
   if (process.platform === "win32") {
     for (let code = 67;code <= 90; code++) {
       const drive = `${String.fromCharCode(code)}:${sep4}`;
       try {
-        if (existsSync22(drive))
+        if (existsSync23(drive))
           roots.push({ label: drive.replace(/\\$/, ""), path: drive, kind: "drive" });
       } catch {}
     }
   } else {
     roots.push({ label: "/", path: "/", kind: "drive" });
   }
-  if (existsSync22(home))
+  if (existsSync23(home))
     roots.push({ label: "Home", path: home, kind: "home" });
   const seen = new Set(roots.map(pathKey));
   for (const name of COMMON_DIRS) {
     const candidate = join21(home, name);
     const key = pathKey({ path: candidate });
-    if (seen.has(key) || !existsSync22(candidate))
+    if (seen.has(key) || !existsSync23(candidate))
       continue;
     seen.add(key);
     roots.push({ label: name, path: candidate, kind: "common" });
@@ -12141,17 +13135,17 @@ function parentOf(dir) {
   const parent = dirname11(dir);
   return parent === dir ? null : parent;
 }
-function browseDir(input, showHidden = false, home = homedir4()) {
+function browseDir(input, showHidden = false, home = homedir3()) {
   const target = input && input.trim() !== "" ? expandPath(input, home) : home;
   if (!isAbsolute2(target)) {
     throw new InvalidInputError(`path is not absolute: ${target}`);
   }
-  if (!existsSync22(target)) {
+  if (!existsSync23(target)) {
     throw new InvalidInputError(`path does not exist: ${target}`);
   }
   let dir = target;
   try {
-    if (!statSync5(target).isDirectory())
+    if (!statSync6(target).isDirectory())
       dir = dirname11(target);
   } catch (e) {
     throw new InvalidInputError(`cannot read path: ${target} (${errMsg4(e)})`);
@@ -12181,7 +13175,7 @@ function browseDir(input, showHidden = false, home = homedir4()) {
     let isDirectory = dirent.isDirectory();
     if (isSymlink) {
       try {
-        isDirectory = statSync5(path).isDirectory();
+        isDirectory = statSync6(path).isDirectory();
       } catch {
         continue;
       }
@@ -12371,9 +13365,9 @@ var init_conversations = __esm(() => {
 });
 
 // src/services/projects.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { basename as basename4, join as join22 } from "path";
-import { eq as eq14, isNull } from "drizzle-orm";
+import { eq as eq15, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
 }
@@ -12391,15 +13385,14 @@ function warnIfTranslatedMount(ctx, projectId, repoPath) {
 async function openProject(ctx, rawPath) {
   const repoPath = expandPath(rawPath);
   await assertRepoTolerant(ctx, repoPath);
-  const mainBranch = await detectMainBranchTolerant(ctx, repoPath);
   const name = basename4(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
-    ctx.db.update(projects).set({ mainBranch, repoPath, closedAt: null }).where(eq14(projects.id, existing.id)).run();
-    const reopened = { ...existing, mainBranch, repoPath, closedAt: undefined };
+    ctx.db.update(projects).set({ repoPath, closedAt: null }).where(eq15(projects.id, existing.id)).run();
+    const reopened = { ...existing, repoPath, closedAt: undefined };
     emitProject(ctx, existing.id, {
       type: "project.opened",
-      message: `project ${existing.name} re-opened at ${repoPath} (${mainBranch})`
+      message: `project ${existing.name} re-opened at ${repoPath}`
     });
     warnIfTranslatedMount(ctx, existing.id, repoPath);
     return reopened;
@@ -12408,7 +13401,6 @@ async function openProject(ctx, rawPath) {
     id: newId("proj"),
     name,
     repoPath,
-    mainBranch,
     devCommand: null,
     closedAt: null
   };
@@ -12416,7 +13408,7 @@ async function openProject(ctx, rawPath) {
   const project = rowToProject(inserted);
   emitProject(ctx, project.id, {
     type: "project.opened",
-    message: `project ${name} at ${repoPath} (${mainBranch})`
+    message: `project ${name} at ${repoPath}`
   });
   warnIfTranslatedMount(ctx, project.id, repoPath);
   return project;
@@ -12426,7 +13418,7 @@ function closeProject(ctx, projectId) {
   if (projectHasActiveRun(ctx, projectId)) {
     throw new InvalidInputError(`cannot close ${project.name}: a run is in flight \u2014 wait for it to finish or cancel it first`);
   }
-  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq14(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq15(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.closed",
     message: `project ${project.name} closed`
@@ -12435,7 +13427,7 @@ function closeProject(ctx, projectId) {
 }
 function renameProject(ctx, projectId, name) {
   const project = requireProjectById(ctx, projectId);
-  ctx.db.update(projects).set({ name }).where(eq14(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ name }).where(eq15(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.renamed",
     message: `project renamed ${project.name} \u2192 ${name}`,
@@ -12453,20 +13445,11 @@ async function assertRepoTolerant(ctx, repoPath) {
   } catch (e) {
     if (!isNotImplemented(e))
       throw e;
-    if (!existsSync23(join22(repoPath, ".git"))) {
+    if (!existsSync24(join22(repoPath, ".git"))) {
       throw new InvalidInputError(`not a git repository: ${repoPath}`);
     }
   }
 }
-async function detectMainBranchTolerant(ctx, repoPath) {
-  try {
-    return await detectMainBranch(repoPath);
-  } catch (e) {
-    if (!isNotImplemented(e))
-      throw e;
-    return ctx.config.mainBranch;
-  }
-}
 var init_projects = __esm(() => {
   init_src();
   init_schema();
@@ -12496,6 +13479,7 @@ var init_project = __esm(() => {
     roots: publicProcedure.query(() => listRoots()),
     browse: publicProcedure.input(z8.object({ dir: z8.string().optional(), showHidden: z8.boolean().optional() }).optional()).query(({ input }) => browseDir(input?.dir, input?.showHidden ?? false)),
     branches: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId))),
+    sessionBranch: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => sessionBranchView(requireProjectById(ctx, input.projectId))),
     open: publicProcedure.input(z8.object({ repoPath: z8.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
     close: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
     rename: publicProcedure.input(z8.object({ projectId: z8.string(), name: ProjectName })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name)),
@@ -12514,8 +13498,26 @@ var init_project = __esm(() => {
   });
 });
 
-// src/trpc/routers/run.ts
+// src/trpc/routers/review-findings.ts
 import * as z9 from "zod";
+var reviewFindingsRouter;
+var init_review_findings2 = __esm(() => {
+  init_features();
+  init_review_findings();
+  init_context();
+  reviewFindingsRouter = router({
+    listByFeature: publicProcedure.input(z9.object({ featureId: z9.string() })).query(({ ctx, input }) => viewByFeature(ctx, input.featureId)),
+    dismiss: publicProcedure.input(z9.object({ findingId: z9.string() })).mutation(({ ctx, input }) => dismiss(ctx, input.findingId)),
+    fixOpenDefects: publicProcedure.input(z9.object({ featureId: z9.string() })).mutation(async ({ ctx, input }) => {
+      const promoted = promoteOpenDefects(ctx, input.featureId);
+      const { runId } = await burn(ctx, input.featureId);
+      return { ...promoted, runId };
+    })
+  });
+});
+
+// src/trpc/routers/run.ts
+import * as z10 from "zod";
 var runRouter;
 var init_run = __esm(() => {
   init_agent_stream();
@@ -12523,9 +13525,9 @@ var init_run = __esm(() => {
   init_runner();
   init_context();
   runRouter = router({
-    get: publicProcedure.input(z9.object({ runId: z9.string() })).query(({ ctx, input }) => getRunRow(ctx, input.runId)),
-    agentTranscript: publicProcedure.input(z9.object({ ticketId: z9.string(), after: z9.number().int().optional() })).query(({ input }) => readTranscript(input.ticketId, input.after ?? -1)),
-    cancel: publicProcedure.input(z9.object({ runId: z9.string() })).mutation(({ ctx, input }) => {
+    get: publicProcedure.input(z10.object({ runId: z10.string() })).query(({ ctx, input }) => getRunRow(ctx, input.runId)),
+    agentTranscript: publicProcedure.input(z10.object({ ticketId: z10.string(), after: z10.number().int().optional() })).query(({ input }) => readTranscript(input.ticketId, input.after ?? -1)),
+    cancel: publicProcedure.input(z10.object({ runId: z10.string() })).mutation(({ ctx, input }) => {
       getRunRow(ctx, input.runId);
       cancelRun(input.runId);
       return { ok: true };
@@ -12534,47 +13536,21 @@ var init_run = __esm(() => {
 });
 
 // src/trpc/routers/settings.ts
-import * as z10 from "zod";
+import * as z11 from "zod";
 var settingsRouter;
 var init_settings2 = __esm(() => {
   init_src();
   init_settings();
   init_context();
   settingsRouter = router({
-    get: publicProcedure.input(z10.object({ projectId: z10.string().optional() }).optional()).query(({ ctx, input }) => getSettings(ctx, input?.projectId)),
+    get: publicProcedure.input(z11.object({ projectId: z11.string().optional() }).optional()).query(({ ctx, input }) => getSettings(ctx, input?.projectId)),
     update: publicProcedure.input(SettingsUpdateInput).mutation(({ ctx, input }) => updateSettings(ctx, input))
   });
 });
 
-// src/doctor/system-exec.ts
-import { spawn as spawn4 } from "child_process";
-function createSystemExec(opts = {}) {
-  return (command, args) => new Promise((resolve12) => {
-    const { file, args: spawnArgs } = resolveSpawnTarget(command, args);
-    let stdout = "";
-    let stderr = "";
-    const child = spawn4(file, spawnArgs, { cwd: opts.cwd, windowsHide: true });
-    child.stdout?.on("data", (d) => {
-      stdout += d.toString();
-    });
-    child.stderr?.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.on("error", (err) => {
-      resolve12({ ok: false, code: null, stdout, stderr: stderr || String(err) });
-    });
-    child.on("close", (code) => {
-      resolve12({ ok: true, code: code ?? 0, stdout, stderr });
-    });
-  });
-}
-var init_system_exec = __esm(() => {
-  init_resolve_executable();
-});
-
 // src/trpc/routers/setup.ts
-import { isNotNull as isNotNull2 } from "drizzle-orm";
-import * as z11 from "zod";
+import { isNotNull as isNotNull3 } from "drizzle-orm";
+import * as z12 from "zod";
 var setupRouter;
 var init_setup2 = __esm(() => {
   init_src();
@@ -12587,7 +13563,7 @@ var init_setup2 = __esm(() => {
   init_context();
   setupRouter = router({
     doctor: publicProcedure.query(({ ctx }) => {
-      const projectModels = ctx.db.select({ model: projects.model }).from(projects).where(isNotNull2(projects.model)).all().map((p) => p.model);
+      const projectModels = ctx.db.select({ model: projects.model }).from(projects).where(isNotNull3(projects.model)).all().map((p) => p.model);
       return runDoctor({
         exec: createSystemExec(),
         runtimes: configuredRuntimes(ctx.config, projectModels),
@@ -12595,10 +13571,10 @@ var init_setup2 = __esm(() => {
       });
     }),
     runtimeGuide: publicProcedure.query(() => runtimeInstallGuide(process.platform)),
-    gitIdentity: publicProcedure.input(z11.object({ name: z11.string(), email: z11.string() })).mutation(({ input }) => writeGitIdentity(createSystemExec(), input)),
-    afkToken: publicProcedure.input(z11.object({ token: z11.string(), runtime: AgentRuntime.default("claude-code") })).mutation(({ input }) => saveAfkCredential(fileAfkTokenIo(createSystemExec(), input.runtime), input.token, input.runtime)),
-    seedModelDefaults: publicProcedure.input(z11.object({ runtimes: z11.array(AgentRuntime) })).mutation(({ ctx, input }) => seedModelDefaults(ctx, input.runtimes)),
-    startTerminal: publicProcedure.input(z11.object({ kind: z11.enum(["setup-token", "build-image", "claude-login", "codex-login"]) })).mutation(async ({ ctx, input }) => {
+    gitIdentity: publicProcedure.input(z12.object({ name: z12.string(), email: z12.string() })).mutation(({ input }) => writeGitIdentity(createSystemExec(), input)),
+    afkToken: publicProcedure.input(z12.object({ token: z12.string(), runtime: AgentRuntime.default("claude-code") })).mutation(({ input }) => saveAfkCredential(fileAfkTokenIo(createSystemExec(), input.runtime), input.token, input.runtime)),
+    seedModelDefaults: publicProcedure.input(z12.object({ runtimes: z12.array(AgentRuntime) })).mutation(({ ctx, input }) => seedModelDefaults(ctx, input.runtimes)),
+    startTerminal: publicProcedure.input(z12.object({ kind: z12.enum(["setup-token", "build-image", "claude-login", "codex-login"]) })).mutation(async ({ ctx, input }) => {
       const exec = createSystemExec();
       const preferred = ctx.config.sandbox === "podman" ? "podman" : "docker";
       const runtime = await resolveRuntime(exec, preferred);
@@ -12620,40 +13596,80 @@ var init_setup2 = __esm(() => {
 });
 
 // src/trpc/routers/system.ts
-var systemRouter;
+import * as z13 from "zod";
+function burnCacheEngine(sandbox) {
+  return sandbox === "docker" || sandbox === "podman" ? sandbox : null;
+}
+var projectInput, systemRouter;
 var init_system = __esm(() => {
+  init_src();
+  init_system_exec();
+  init_errors();
+  init_events();
   init_update_check();
+  init_burn_cache();
   init_version();
   init_context();
+  projectInput = z13.object({ projectId: z13.string() });
   systemRouter = router({
     version: publicProcedure.query(() => ({ version: runcastleVersion() })),
-    checkUpdate: publicProcedure.query(() => getUpdateInfo(runcastleVersion()))
+    checkUpdate: publicProcedure.query(() => getUpdateInfo(runcastleVersion())),
+    burnCache: router({
+      status: publicProcedure.input(projectInput).query(async ({ ctx, input }) => {
+        const mode = resolveBurnCacheMode(ctx.config);
+        const engine = burnCacheEngine(ctx.config.sandbox);
+        const sizeBytes = mode === "volume" && engine ? await burnCacheVolumeSize({
+          engine,
+          projectId: input.projectId,
+          exec: createSystemExec()
+        }) : null;
+        return { mode, engine, volumeName: burnCacheVolumeName(input.projectId), sizeBytes };
+      }),
+      clear: publicProcedure.input(projectInput).mutation(async ({ ctx, input }) => {
+        const engine = burnCacheEngine(ctx.config.sandbox);
+        if (!engine) {
+          throw new InvalidInputError(`the burn cache needs a docker or podman sandbox; this one is "${ctx.config.sandbox}"`);
+        }
+        const volumeName = burnCacheVolumeName(input.projectId);
+        await removeBurnCacheVolume({
+          engine,
+          projectId: input.projectId,
+          exec: createSystemExec(),
+          slots: getBurnSlotAllocator(ctx.config.burnConcurrency).held()
+        });
+        emitProject(ctx, input.projectId, {
+          type: "burn-cache.cleared",
+          message: `cleared the burn cache volume ${volumeName}`
+        });
+        return { volumeName };
+      })
+    })
   });
 });
 
 // src/trpc/routers/test-notes.ts
-import * as z12 from "zod";
+import * as z14 from "zod";
 var testNotesRouter;
 var init_test_notes2 = __esm(() => {
   init_test_notes();
   init_context();
   testNotesRouter = router({
-    list: publicProcedure.input(z12.object({ featureId: z12.string() })).query(({ ctx, input }) => listByFeature3(ctx, input.featureId)),
-    add: publicProcedure.input(z12.object({
-      featureId: z12.string(),
-      text: z12.string().min(1),
-      videoTimestamp: z12.number().nonnegative().optional()
+    list: publicProcedure.input(z14.object({ featureId: z14.string() })).query(({ ctx, input }) => listByFeature4(ctx, input.featureId)),
+    add: publicProcedure.input(z14.object({
+      featureId: z14.string(),
+      text: z14.string().min(1),
+      videoTimestamp: z14.number().nonnegative().optional()
     })).mutation(({ ctx, input }) => addNote(ctx, input.featureId, input.text, "human", input.videoTimestamp)),
-    edit: publicProcedure.input(z12.object({ noteId: z12.string(), text: z12.string().min(1) })).mutation(({ ctx, input }) => editNote(ctx, input.noteId, input.text)),
-    remove: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => deleteNote(ctx, input.noteId)),
-    toggle: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => toggleNote(ctx, input.noteId)),
-    promote: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => promoteNote(ctx, input.noteId)),
-    promoteMany: publicProcedure.input(z12.object({ noteIds: z12.array(z12.string()).min(1) })).mutation(({ ctx, input }) => promoteMany(ctx, input.noteIds))
+    edit: publicProcedure.input(z14.object({ noteId: z14.string(), text: z14.string().min(1) })).mutation(({ ctx, input }) => editNote(ctx, input.noteId, input.text)),
+    remove: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => deleteNote(ctx, input.noteId)),
+    toggle: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => toggleNote(ctx, input.noteId)),
+    promote: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => promoteNote(ctx, input.noteId)),
+    promoteMany: publicProcedure.input(z14.object({ noteIds: z14.array(z14.string()).min(1) })).mutation(({ ctx, input }) => promoteMany(ctx, input.noteIds))
   });
 });
 
 // src/trpc/routers/ticket.ts
-import * as z13 from "zod";
+import * as z15 from "zod";
 var ticketRouter;
 var init_ticket = __esm(() => {
   init_features();
@@ -12662,8 +13678,8 @@ var init_ticket = __esm(() => {
   init_ticket_burner();
   init_context();
   ticketRouter = router({
-    retry: publicProcedure.input(z13.object({ ticketId: z13.string(), fresh: z13.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
-    stop: publicProcedure.input(z13.object({ ticketId: z13.string() })).mutation(({ ctx, input }) => {
+    retry: publicProcedure.input(z15.object({ ticketId: z15.string(), fresh: z15.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
+    stop: publicProcedure.input(z15.object({ ticketId: z15.string() })).mutation(({ ctx, input }) => {
       if (stopTicketRun(input.ticketId))
         return { stopped: true, swept: false };
       const ticket = getTicket(ctx, input.ticketId);
@@ -12673,14 +13689,14 @@ var init_ticket = __esm(() => {
       }
       return { stopped: false, swept: false };
     }),
-    cancel: publicProcedure.input(z13.object({ ticketId: z13.string(), reason: z13.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
-    edit: publicProcedure.input(z13.object({
-      ticketId: z13.string(),
-      title: z13.string().min(1).optional(),
-      goal: z13.string().min(1).optional(),
-      context: z13.string().optional(),
-      acceptanceCriteria: z13.array(z13.string().min(1)).optional(),
-      model: z13.string().optional()
+    cancel: publicProcedure.input(z15.object({ ticketId: z15.string(), reason: z15.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
+    edit: publicProcedure.input(z15.object({
+      ticketId: z15.string(),
+      title: z15.string().min(1).optional(),
+      goal: z15.string().min(1).optional(),
+      context: z15.string().optional(),
+      acceptanceCriteria: z15.array(z15.string().min(1)).optional(),
+      model: z15.string().optional()
     })).mutation(({ ctx, input }) => {
       const { ticketId, ...patch } = input;
       return editTicket(ctx, ticketId, patch);
@@ -12696,6 +13712,7 @@ var init_router = __esm(() => {
   init_events2();
   init_feature();
   init_project();
+  init_review_findings2();
   init_run();
   init_settings2();
   init_setup2();
@@ -12708,6 +13725,7 @@ var init_router = __esm(() => {
     run: runRouter,
     ticket: ticketRouter,
     notes: testNotesRouter,
+    findings: reviewFindingsRouter,
     events: eventsRouter,
     docs: docsRouter,
     settings: settingsRouter,
@@ -12717,14 +13735,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq15 } from "drizzle-orm";
+import { eq as eq16 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq15(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq16(runs.status, "running")).all().map(rowToRun);
   const reconciled = [];
   for (const run4 of stale) {
     if (isRunActive(run4.id))
       continue;
-    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq15(runs.id, run4.id)).run();
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq16(runs.id, run4.id)).run();
     const released = releaseForSession(ctx, run4.id);
     const swept = workflowClaimsFeatureBranch(run4.workflow) ? sweepOrphanedBurning(ctx, run4.featureId, "orphaned by server restart \u2014 retry to resume its commits") : [];
     if (workflowClaimsFeatureBranch(run4.workflow)) {
@@ -12898,6 +13916,7 @@ var GLYPH;
 var init_report = __esm(() => {
   GLYPH = {
     ok: "\u2713",
+    stale: "\u2717",
     missing: "\u2717",
     "daemon-dead": "\u2717",
     "machine-stopped": "\u2717",
@@ -12913,7 +13932,7 @@ __export(exports_cli, {
   resolveDoctorEnv: () => resolveDoctorEnv,
   parseMode: () => parseMode
 });
-import { existsSync as existsSync24, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync15 } from "fs";
 function parseMode(argv) {
   return argv.includes("--gate") || argv.includes("--boot") ? "gate" : "diagnostic";
 }
@@ -12921,7 +13940,7 @@ function envWithAfkCredentials() {
   const merged = { ...process.env };
   try {
     const path = envPath();
-    if (existsSync24(path)) {
+    if (existsSync25(path)) {
       const fromFile = parseEnvFile2(readFileSync15(path, "utf8"));
       for (const runtime of AGENT_RUNTIMES) {
         const key = RUNTIME_SPECS[runtime].afkKey;
@@ -12974,7 +13993,7 @@ var init_cli = __esm(() => {
 init_asset_paths();
 init_version();
 import { dirname as dirname12, resolve as resolve12 } from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+import { fileURLToPath as fileURLToPath9 } from "url";
 function parseCommand(argv) {
   const [first, ...rest] = argv;
   if (first === undefined)
@@ -12998,7 +14017,7 @@ Usage:
   runcastle --help     Show this help
 `;
 async function main(argv) {
-  applyInstalledAssetEnv(resolve12(dirname12(fileURLToPath8(import.meta.url)), ".."));
+  applyInstalledAssetEnv(resolve12(dirname12(fileURLToPath9(import.meta.url)), ".."));
   const { command, args } = parseCommand(argv);
   switch (command) {
     case "version":