runcastle 1.2.10 → 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"
@@ -157,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
@@ -166,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([
@@ -198,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(),
@@ -206,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(),
@@ -537,7 +576,7 @@ 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(),
@@ -616,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(),
@@ -789,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)) {
@@ -834,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();
@@ -864,6 +933,7 @@ var init_schema = __esm(() => {
   init_src();
   schema = {
     projects,
+    reviewFindings,
     features,
     sessions,
     tickets,
@@ -1572,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) {
@@ -1586,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)
@@ -1594,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) {
@@ -3254,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;
 }
@@ -3353,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 };
@@ -4630,7 +4901,8 @@ function codexLoggedIn(env = process.env, fileExists = existsSync8) {
 var init_codex_auth = () => {};
 
 // src/doctor/doctor.ts
-import { existsSync as existsSync9 } from "fs";
+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) {
@@ -4837,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 {
@@ -4872,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),
@@ -4886,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,
@@ -4943,7 +5231,7 @@ import {
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   readdirSync as readdirSync2,
-  statSync,
+  statSync as statSync2,
   writeFileSync as writeFileSync3
 } from "fs";
 import { basename, dirname as dirname3, join as join10, resolve as resolve7 } from "path";
@@ -5062,7 +5350,7 @@ function gitInfoDir(worktreePath) {
   const dotGit = join10(worktreePath, ".git");
   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)
@@ -5174,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({
@@ -5525,7 +5813,7 @@ function transcriptBytes(session) {
   if (!session?.transcriptPath)
     return;
   try {
-    return statSync2(session.transcriptPath).size;
+    return statSync3(session.transcriptPath).size;
   } catch {
     return;
   }
@@ -5640,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) {
@@ -5665,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,
@@ -5690,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, {
@@ -6072,11 +6362,195 @@ 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 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 (!existsSync13(configFile))
     return {};
@@ -6116,7 +6590,7 @@ 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,
@@ -6149,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 = {}) {
@@ -6180,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",
@@ -6196,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",
@@ -6275,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();
@@ -6441,7 +6917,7 @@ var init_settings = __esm(() => {
 // src/services/setup.ts
 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();
@@ -6544,7 +7020,7 @@ 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 (existsSync14(manifestPath)) {
@@ -6579,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 (existsSync14(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) {
@@ -6662,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 });
@@ -6717,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:.}}'`,
@@ -6732,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(`
@@ -6782,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:]]*<<`,
@@ -6833,6 +7361,37 @@ function findOnPath(bin, env = process.env, platform = process.platform) {
   }
   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 });
@@ -6854,13 +7413,19 @@ 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 (!feature.baseBranch) {
     return couldNotReview(ticket, `feature ${feature.slug} has no recorded base branch, so there is nothing to diff \`${feature.branch}\` against.`);
   }
-  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.`);
-  }
   const artifacts = writeReviewArtifacts(ticket, ctx.runId, deps.config);
   const prompt = renderReviewPrompt(readFileSync8(reviewTemplatePath(), "utf8"), {
     TICKET_JSON: buildTicketJson(ticket),
@@ -6869,6 +7434,8 @@ async function executeReviewTicket(ctx, ticket, deps) {
     LAP_DIGESTS: buildLapDigestsBlock(deps.lapDigests),
     FEATURE_BRANCH: feature.branch,
     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
@@ -6878,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") {
@@ -6952,11 +7520,15 @@ var init_review_ticket = __esm(() => {
 // src/workflows/ticket-burner.ts
 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;
@@ -7159,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) {
@@ -7182,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._";
@@ -7218,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);
     }
@@ -7272,6 +7856,16 @@ 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;
@@ -7285,6 +7879,8 @@ function chainSetupCommands(...steps) {
   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")
@@ -7292,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 buildWorkspaceNotes(mode) {
+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, repoPath = ISOLATED_REPO_PATH) {
   if (mode === "mounted") {
     return [
       "Work in the current directory \u2014 it is the repo checkout on your branch.",
@@ -7323,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(`
@@ -7474,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;
@@ -7492,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)
@@ -7500,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)
@@ -7520,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)))
@@ -7637,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)
@@ -7659,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(`
 
 `);
@@ -7672,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 });
@@ -7682,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}`,
@@ -7691,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)`,
@@ -7714,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();
@@ -7770,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)
@@ -7798,11 +8517,27 @@ 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 ");
@@ -7813,7 +8548,8 @@ async function burnRun(ctx, deps) {
     });
     return { status: "failed", summary: `dependency cycle: ${path}` };
   }
-  const { done, digests } = await burnTickets(ctx, tickets2, gateTicketAuth(deps), 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);
@@ -7826,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 = "") {
@@ -7987,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);
@@ -8000,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);
@@ -8026,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);
@@ -8039,18 +8804,18 @@ 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)
@@ -8058,14 +8823,37 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const guardInstall = guardInstalled ? buildGuardInstallCommand(model.runtime) : undefined;
   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") {
@@ -8101,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);
@@ -8116,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 = withPrelude(workspaceMode === "isolated" ? buildIsolatedSetupCommand(resolveBranch, setupCommand, pm) : setupCommand);
+    const hookCommand = setupHookFor(resolveBranch);
     appendTranscript(ticket.id, {
       kind: "text",
       text: `
@@ -8129,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 },
@@ -8148,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();
@@ -8159,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,
@@ -8251,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 = withPrelude(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}
 
@@ -8286,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;
@@ -8310,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",
@@ -8335,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 });
@@ -8376,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) {
@@ -8396,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 = {
@@ -8441,6 +9263,7 @@ function resolveBurnDeps(ctx) {
     config: config2,
     runtime: model.runtime,
     hasAuthToken: burnAuthReady(model.runtime, token),
+    exec: cachedExec,
     ticketAuthMissing: (ticket) => {
       const { model: ticketModel, token: ticketToken } = ticketCredentials(ticket);
       return burnAuthReady(ticketModel.runtime, ticketToken) ? undefined : ticketModel.runtime;
@@ -8454,7 +9277,7 @@ function resolveBurnDeps(ctx) {
         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);
     }
   };
 }
@@ -8471,19 +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, CODEX_HOST_MOUNT_PATH = "/mnt/host-codex", 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 = {
@@ -8556,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 = {
@@ -8567,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, "");
@@ -8635,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) {
@@ -8744,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);
 }
@@ -8773,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;
     }
   }
@@ -8804,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) => {
@@ -8841,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`);
@@ -8881,6 +9718,7 @@ var init_runner = __esm(() => {
   init_gates();
   init_git();
   init_repo();
+  init_review_findings();
   init_tickets();
   init_waypoints();
   init_registry2();
@@ -8889,7 +9727,7 @@ 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);
@@ -8926,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) {
@@ -8947,19 +9780,14 @@ async function startDraft(ctx, featureId, opts = {}) {
   const project = projectForFeature(ctx, feature);
   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(eq10(features.id, featureId)).run();
+  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) {
@@ -8985,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: [],
@@ -9029,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),
@@ -9049,11 +9877,6 @@ 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 requestedBase(project, picked) {
@@ -9070,6 +9893,26 @@ async function ensureFeatureBranch(project, slug, 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) : [];
@@ -9086,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);
@@ -9201,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) {
@@ -9210,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;
   }
@@ -9289,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",
@@ -9307,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`,
@@ -9321,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})`,
@@ -9361,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);
@@ -9378,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;
@@ -9411,7 +10254,7 @@ var init_features = __esm(() => {
 // src/services/test-notes.ts
 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,
@@ -9428,7 +10271,7 @@ function rowToNote(row) {
   });
 }
 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);
@@ -9444,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);
@@ -9476,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",
@@ -9488,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",
@@ -9515,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}`,
@@ -9565,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 };
 }
@@ -9603,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) {
@@ -9929,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.");
@@ -10187,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",
@@ -10482,6 +11352,7 @@ var init_server = __esm(() => {
   init_features();
   init_events();
   init_findings();
+  init_review_findings();
   init_git();
   init_knowledge();
   init_repo();
@@ -10521,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"]);
@@ -10611,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));
 }
@@ -10621,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))
@@ -10879,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) {
@@ -10887,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;
@@ -11065,7 +11937,7 @@ var init_stream = __esm(() => {
 });
 
 // src/routes/web.ts
-import { existsSync as existsSync20, 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) {
@@ -11073,7 +11945,7 @@ function contentType(path) {
 }
 function isFile(path) {
   try {
-    return statSync4(path).isFile();
+    return statSync5(path).isFile();
   } catch {
     return false;
   }
@@ -11147,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"));
@@ -11376,7 +12248,7 @@ var init_events2 = __esm(() => {
 // src/launcher/launcher.ts
 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})`;
@@ -11396,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) {
@@ -12197,7 +13069,7 @@ var init_feature = __esm(() => {
 });
 
 // src/services/fsbrowse.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+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 = homedir3()) {
@@ -12273,7 +13145,7 @@ function browseDir(input, showHidden = false, home = homedir3()) {
   }
   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)})`);
@@ -12303,7 +13175,7 @@ function browseDir(input, showHidden = false, home = homedir3()) {
     let isDirectory = dirent.isDirectory();
     if (isSymlink) {
       try {
-        isDirectory = statSync5(path).isDirectory();
+        isDirectory = statSync6(path).isDirectory();
       } catch {
         continue;
       }
@@ -12495,7 +13367,7 @@ var init_conversations = __esm(() => {
 // src/services/projects.ts
 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);
 }
@@ -12516,7 +13388,7 @@ async function openProject(ctx, rawPath) {
   const name = basename4(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
-    ctx.db.update(projects).set({ repoPath, closedAt: null }).where(eq14(projects.id, existing.id)).run();
+    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",
@@ -12546,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`
@@ -12555,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}`,
@@ -12626,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();
@@ -12635,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 };
@@ -12646,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();
@@ -12699,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),
@@ -12707,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);
@@ -12732,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();
@@ -12774,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);
@@ -12785,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);
@@ -12808,6 +13712,7 @@ var init_router = __esm(() => {
   init_events2();
   init_feature();
   init_project();
+  init_review_findings2();
   init_run();
   init_settings2();
   init_setup2();
@@ -12820,6 +13725,7 @@ var init_router = __esm(() => {
     run: runRouter,
     ticket: ticketRouter,
     notes: testNotesRouter,
+    findings: reviewFindingsRouter,
     events: eventsRouter,
     docs: docsRouter,
     settings: settingsRouter,
@@ -12829,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)) {
@@ -13010,6 +13916,7 @@ var GLYPH;
 var init_report = __esm(() => {
   GLYPH = {
     ok: "\u2713",
+    stale: "\u2717",
     missing: "\u2717",
     "daemon-dead": "\u2717",
     "machine-stopped": "\u2717",
@@ -13086,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)
@@ -13110,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":