runcastle 1.0.28 → 1.1.1

package/bin/runcastle.js

@@ -151,7 +151,6 @@ var init_config = __esm(() => {
     burnMaxIterations: z.number().int().min(1).max(10).default(3),
     burnAttempts: z.number().int().min(1).max(5).default(3),
     burnConflictAttempts: z.number().int().min(0).max(3).default(2),
-    autoPrepare: z.boolean().default(true),
     setupCommand: z.string().optional(),
     verifyCommands: z.string().optional(),
     knownFailures: z.string().optional(),
@@ -247,7 +246,7 @@ var init_ids = () => {};
 
 // ../core/src/schemas.ts
 import * as z2 from "zod";
-var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, PREPARED_KEYS, PreparedKey, FindingSource, Project, ProjectFinding, PrepStatus, PrepRun, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, PREPARED_KEYS, PreparedKey, FindingSource, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
 var init_schemas = __esm(() => {
   Phase = z2.enum([
     "ideation",
@@ -344,16 +343,6 @@ var init_schemas = __esm(() => {
     establishedSha: z2.string().optional(),
     staleCommits: z2.number().optional()
   });
-  PrepStatus = z2.enum(["running", "succeeded", "failed", "cancelled"]);
-  PrepRun = z2.object({
-    id: z2.string(),
-    projectId: z2.string(),
-    status: PrepStatus,
-    startedAt: z2.number(),
-    endedAt: z2.number().optional(),
-    summary: z2.string().optional(),
-    headSha: z2.string().optional()
-  });
   Feature = z2.object({
     id: z2.string(),
     projectId: z2.string(),
@@ -555,7 +544,7 @@ var init_pipeline = __esm(() => {
 
 // ../core/src/db-schema.ts
 import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var projects, projectFindings, projectPreps, features, sessions, tickets, waypoints, runs, events, gateOverrides;
+var projects, projectFindings, features, sessions, tickets, waypoints, runs, events, gateOverrides;
 var init_db_schema = __esm(() => {
   projects = sqliteTable("projects", {
     id: text("id").primaryKey(),
@@ -582,15 +571,6 @@ var init_db_schema = __esm(() => {
     establishedAt: integer("established_at").notNull(),
     establishedSha: text("established_sha")
   }, (t) => [primaryKey({ columns: [t.projectId, t.key] })]);
-  projectPreps = sqliteTable("project_preps", {
-    id: text("id").primaryKey(),
-    projectId: text("project_id").notNull(),
-    status: text("status").notNull().$type(),
-    startedAt: integer("started_at").notNull(),
-    endedAt: integer("ended_at"),
-    summary: text("summary"),
-    headSha: text("head_sha")
-  });
   features = sqliteTable("features", {
     id: text("id").primaryKey(),
     projectId: text("project_id").notNull(),
@@ -699,8 +679,7 @@ var init_schema = __esm(() => {
     runs,
     events,
     gateOverrides,
-    projectFindings,
-    projectPreps
+    projectFindings
   };
 });
 
@@ -2245,21 +2224,6 @@ async function reattachWorktree(path, branch) {
     await git(path).checkout(branch);
   } catch {}
 }
-function prepBranchName(unique) {
-  return `${PREP_BRANCH_PREFIX}${unique}`;
-}
-async function readFileAtRef(repoPath, ref, path) {
-  try {
-    return await git(repoPath).raw(["show", `${ref}:${path}`]);
-  } catch {
-    return;
-  }
-}
-async function deletePrepBranch(repoPath, branch) {
-  try {
-    await deleteBranchDetachingWorktrees(git(repoPath), repoPath, branch);
-  } catch {}
-}
 function tempBranchSlugSegment(slug) {
   return slug.slice(0, TEMP_BRANCH_SLUG_MAX).replace(/-+$/, "");
 }
@@ -2306,14 +2270,6 @@ async function branchCommitsAhead(repoPath, base, branch) {
     return [];
   }
 }
-async function headSha(repoPath, ref) {
-  try {
-    const out = (await git(repoPath).revparse([ref])).trim();
-    return out.length > 0 ? out : undefined;
-  } catch {
-    return;
-  }
-}
 async function commitsSince(repoPath, sha, branch) {
   try {
     const out = (await git(repoPath).raw(["rev-list", "--count", `${sha}..${branch}`])).trim();
@@ -2816,7 +2772,7 @@ async function mergeInProgress(g) {
     return false;
   }
 }
-var DOCS_PATHSPEC = "docs/features", MIGRATION_DIR_RE, DRIZZLE_SQL_RE, DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", RESEARCH_BRANCH_PREFIX = "runcastle/research/", TICKET_BRANCH_PREFIX = "runcastle/ticket/", PREP_BRANCH_PREFIX = "runcastle/prep/", PROJECT_BRANCH = "runcastle/project", TEMP_BRANCH_PREFIXES, TEMP_BRANCH_SLUG_MAX = 16, testDriveState;
+var DOCS_PATHSPEC = "docs/features", MIGRATION_DIR_RE, DRIZZLE_SQL_RE, DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", RESEARCH_BRANCH_PREFIX = "runcastle/research/", TICKET_BRANCH_PREFIX = "runcastle/ticket/", PROJECT_BRANCH = "runcastle/project", TEMP_BRANCH_PREFIXES, TEMP_BRANCH_SLUG_MAX = 16, testDriveState;
 var init_git = __esm(() => {
   init_paths();
   init_errors();
@@ -3090,6 +3046,9 @@ function activeProjectSession(ctx, projectId, kind) {
   const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), inArray(sessions.status, ["launching", "live"]))).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
+function hasCompletedProjectSession(ctx, projectId, kind) {
+  return ctx.db.select({ id: sessions.id }).from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), eq4(sessions.status, "ended"))).limit(1).get() !== undefined;
+}
 function mostRecentResumableProjectSession(ctx, projectId, kind) {
   const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), eq4(sessions.status, "ended"), isNotNull(sessions.ccSessionId))).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
@@ -3156,655 +3115,1083 @@ var init_reconcile = __esm(() => {
   init_sessions();
 });
 
-// src/launcher/skills-root.ts
+// src/launcher/runtime.ts
+function setRuntimeCtx(ctx) {
+  current = ctx;
+}
+async function getRuntimeCtx() {
+  if (current)
+    return current;
+  const [{ createDb: createDb2 }, { dbPath: dbPath2 }, { loadConfig: loadConfig2 }] = await Promise.all([
+    Promise.resolve().then(() => (init_client(), exports_client)),
+    Promise.resolve().then(() => (init_paths(), exports_paths)),
+    Promise.resolve().then(() => (init_config_load(), exports_config_load))
+  ]);
+  const db = createDb2(dbPath2());
+  current = { db, config: loadConfig2() };
+  return current;
+}
+var current = null;
+
+// src/services/feature-docs.ts
 import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname2, join as join6, resolve as resolve5 } from "path";
-function resolveSkillsRoot(fromDir) {
-  const override = process.env[SKILLS_DIR_ENV];
-  if (override) {
-    const root = resolve5(override);
-    if (existsSync6(join6(root, SKILLS_MARKER)))
-      return root;
-    throw new Error(`${SKILLS_DIR_ENV}=${override} is not a runcastle skills root (missing ${SKILLS_MARKER})`);
-  }
-  const searched = [];
-  let dir = fromDir;
-  for (let i = 0;i < 8; i += 1) {
-    const candidate = join6(dir, "packages", "skills");
-    searched.push(candidate);
-    if (existsSync6(join6(candidate, SKILLS_MARKER)))
-      return candidate;
-    const parent = dirname2(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  throw new Error(`runcastle skills root not found; searched:
-  ${searched.join(`
-  `)}`);
+import { join as join6 } from "path";
+function featureDocsDir(project, feature) {
+  const relSegments = featureDocsRel(feature.slug).split("/");
+  const worktree = worktreeDir(project.id, feature.slug);
+  const base = existsSync6(worktree) ? worktree : project.repoPath;
+  return join6(base, ...relSegments);
 }
-var SKILLS_DIR_ENV = "RUNCASTLE_SKILLS_DIR", SKILLS_MARKER;
-var init_skills_root = __esm(() => {
-  SKILLS_MARKER = join6("packs", "runcastle");
+function featureDocPath(project, feature, fileName) {
+  return join6(featureDocsDir(project, feature), fileName);
+}
+var init_feature_docs = __esm(() => {
+  init_paths();
 });
 
-// src/services/agent-stream.ts
-function beginTranscript(ticketId) {
-  transcripts.set(ticketId, { live: true, chunks: [], nextIndex: 0, bytes: 0 });
-  publishLive({ kind: "transcript", ticketId });
+// src/services/tickets.ts
+import { and as and5, asc as asc3, eq as eq5 } from "drizzle-orm";
+function rowToTicket(row) {
+  return {
+    id: row.id,
+    featureId: row.featureId,
+    seq: row.seq,
+    title: row.title,
+    goal: row.goal,
+    context: row.context,
+    acceptanceCriteria: row.acceptanceCriteria,
+    seams: row.seams,
+    blockedBy: row.blockedBy,
+    lap: row.lap,
+    status: row.status,
+    commits: row.commits,
+    error: row.error ?? undefined,
+    attemptBranch: row.attemptBranch ?? undefined,
+    conflictFiles: row.conflictFiles ?? undefined
+  };
 }
-function appendTranscript(ticketId, chunk) {
-  const t = transcripts.get(ticketId);
-  if (!t)
-    return;
-  const full = { ...chunk, i: t.nextIndex, ts: chunk.ts ?? Date.now() };
-  t.nextIndex += 1;
-  t.chunks.push(full);
-  t.bytes += full.text.length;
-  while (t.chunks.length > MAX_CHUNKS || t.bytes > MAX_BYTES && t.chunks.length > 1) {
-    const dropped = t.chunks.shift();
-    if (!dropped)
-      break;
-    t.bytes -= dropped.text.length;
+function resolveBlocking(inputs, startSeq) {
+  try {
+    return resolveBatchBlocking(inputs, { startSeq });
+  } catch (e) {
+    if (e instanceof BlockingEdgeError)
+      throw new InvalidInputError(e.message);
+    throw e;
   }
-  publishLive({ kind: "transcript", ticketId });
 }
-function endTranscript(ticketId) {
-  const t = transcripts.get(ticketId);
-  if (t)
-    t.live = false;
-  publishLive({ kind: "transcript", ticketId });
+function listByFeature2(ctx, featureId) {
+  return ctx.db.select().from(tickets).where(eq5(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
 }
-function readTranscript(ticketId, after = -1) {
-  const t = transcripts.get(ticketId);
-  if (!t)
-    return { live: false, chunks: [], firstIndex: 0, nextIndex: 0 };
-  return {
-    live: t.live,
-    chunks: after < 0 ? [...t.chunks] : t.chunks.filter((c) => c.i > after),
-    firstIndex: t.chunks[0]?.i ?? t.nextIndex,
-    nextIndex: t.nextIndex
-  };
+function storeTickets(ctx, featureId, inputs) {
+  if (inputs.length === 0)
+    return [];
+  const { lap } = getFeatureRow(ctx, featureId);
+  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq5(tickets.featureId, featureId)).all();
+  const startSeq = existing.reduce((max, r) => Math.max(max, r.seq), 0) + 1;
+  const resolved = resolveBlocking(inputs, startSeq);
+  const rows = inputs.map((t, i) => ({
+    id: newId("tkt"),
+    featureId,
+    seq: resolved[i].seq,
+    title: t.title,
+    goal: t.goal,
+    context: t.context,
+    acceptanceCriteria: t.acceptanceCriteria,
+    seams: t.seams,
+    blockedBy: resolved[i].blockedBy,
+    lap,
+    status: "pending",
+    commits: [],
+    error: null,
+    attemptBranch: null,
+    conflictFiles: null
+  }));
+  ctx.db.insert(tickets).values(rows).run();
+  emit(ctx, featureId, {
+    type: "tickets.stored",
+    message: `${rows.length} ticket(s) stored`,
+    data: { count: rows.length, seqs: rows.map((r) => r.seq) }
+  });
+  return rows.map(rowToTicket);
 }
-var MAX_CHUNKS = 4000, MAX_BYTES = 1500000, transcripts;
-var init_agent_stream = __esm(() => {
-  init_bus();
-  transcripts = new Map;
-});
-
-// src/workflows/burn-guard.ts
-function renderGuardScript(rules = GUARD_RULES) {
-  const lines = [
-    "#!/bin/sh",
-    "# runcastle burn guard (PreToolUse). Generated \u2014 edit burn-guard.ts, not this.",
-    "set -u",
-    "payload=$(cat 2>/dev/null || true)",
-    '[ -n "$payload" ] || exit 0',
-    "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',
-    "",
-    "# 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")`,
-    "",
-    "deny() {",
-    `  printf %s "$1" | jq -R -s '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:.}}'`,
-    "  exit 0",
-    "}",
-    ""
-  ];
-  for (const rule of rules) {
-    lines.push(`# ${rule.id}`, `if printf %s "$cmd" | grep -Eq -- ${shSingleQuote(rule.pattern)}; then`, `  deny ${shSingleQuote(rule.reason)}`, "fi", "");
+function getTicket(ctx, id) {
+  const row = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`ticket ${id} not found`);
+  return rowToTicket(row);
+}
+function assertMutable(t, verb) {
+  if (!MUTABLE_STATUSES.has(t.status)) {
+    throw new InvalidInputError(`cannot ${verb} ticket ${t.seq} \u2014 it is ${t.status}; only pending or failed tickets can be ${verb}${verb.endsWith("l") ? "led" : "ed"}`);
   }
-  lines.push("exit 0", "");
-  return lines.join(`
-`);
 }
-function shSingleQuote(value) {
-  return `'${value.split("'").join(`'\\''`)}'`;
+function editTicket(ctx, id, patch) {
+  const current2 = getTicket(ctx, id);
+  assertMutable(current2, "edit");
+  const set = {};
+  if (patch.title !== undefined)
+    set.title = patch.title;
+  if (patch.goal !== undefined)
+    set.goal = patch.goal;
+  if (patch.context !== undefined)
+    set.context = patch.context;
+  if (patch.acceptanceCriteria !== undefined)
+    set.acceptanceCriteria = patch.acceptanceCriteria;
+  if (patch.seams !== undefined)
+    set.seams = patch.seams;
+  if (Object.keys(set).length === 0) {
+    throw new InvalidInputError("nothing to edit \u2014 pass at least one content field");
+  }
+  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  emit(ctx, current2.featureId, {
+    type: "ticket.edited",
+    message: `ticket ${current2.seq} content edited (${Object.keys(set).join(", ")})`,
+    ticketId: id,
+    data: { fields: Object.keys(set) }
+  });
+  return getTicket(ctx, id);
 }
-function renderGuardSettings() {
-  return {
-    hooks: {
-      PreToolUse: [
-        {
-          matcher: "Bash",
-          hooks: [{ type: "command", command: `sh ${GUARD_SCRIPT_PATH}`, timeout: 5 }]
-        }
-      ]
-    }
-  };
+function cancelTicket(ctx, id, reason) {
+  const current2 = getTicket(ctx, id);
+  assertMutable(current2, "cancel");
+  ctx.db.update(tickets).set({ status: "cancelled", error: reason?.trim() ? reason.trim() : null }).where(eq5(tickets.id, id)).run();
+  emit(ctx, current2.featureId, {
+    type: "ticket.cancelled",
+    message: `ticket ${current2.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
+    ticketId: id,
+    data: { reason: reason ?? null }
+  });
+  return getTicket(ctx, id);
 }
-function buildGuardInstallCommand() {
-  const script = Buffer.from(renderGuardScript(), "utf8").toString("base64");
-  const settings = Buffer.from(JSON.stringify(renderGuardSettings(), null, 2), "utf8").toString("base64");
-  return [
-    `mkdir -p "$HOME/.claude/hooks"`,
-    `printf %s '${script}' | base64 -d > "${GUARD_SCRIPT_PATH}"`,
-    `chmod +x "${GUARD_SCRIPT_PATH}"`,
-    `printf %s '${settings}' | base64 -d > "${GUARD_SETTINGS_PATH}"`
-  ].join(" && ");
+function sweepOrphanedBurning(ctx, featureId, reason) {
+  const orphaned = ctx.db.select().from(tickets).where(and5(eq5(tickets.featureId, featureId), eq5(tickets.status, "burning"))).all().map(rowToTicket);
+  for (const t of orphaned) {
+    updateTicket(ctx, t.id, { status: "failed", error: reason });
+    emit(ctx, featureId, {
+      type: "ticket.failed",
+      message: `ticket ${t.seq} failed: ${reason}`,
+      ticketId: t.id,
+      data: { error: reason, orphaned: true }
+    });
+  }
+  return orphaned.map((t) => ({ ...t, status: "failed", error: reason }));
 }
-var CMD_START = "(^|[;&|(]|&&)[[:space:]]*", GUARD_RULES, GUARD_SCRIPT_PATH = "$HOME/.claude/hooks/burn-guard.sh", GUARD_SETTINGS_PATH = "$HOME/.claude/settings.json";
-var init_burn_guard = __esm(() => {
-  GUARD_RULES = [
-    {
-      id: "no-stash",
-      pattern: `${CMD_START}git[[:space:]]+stash`,
-      reason: "git stash is blocked in burns: stashed work is invisible to the orchestrator and unrecoverable if this process dies, and only commits survive. To compare against the pre-change state use `git show HEAD:<path>`, or the pre-existing-failure baseline in your prompt."
-    },
-    {
-      id: "no-serialised-tests",
-      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-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-cat-heredoc-edit",
-      pattern: `${CMD_START}cat[[:space:]]+>>?[[:space:]]*[^[:space:]|]+[[:space:]]*<<`,
-      reason: "Do not write files with `cat > file <<EOF`. Use the Write tool for a new file, or Edit to change part of an existing one."
-    }
-  ];
+function updateTicket(ctx, id, patch) {
+  const current2 = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  if (!current2)
+    throw new NotFoundError(`ticket ${id} not found`);
+  const set = {};
+  if (patch.status !== undefined)
+    set.status = patch.status;
+  if (patch.commits !== undefined)
+    set.commits = patch.commits;
+  if (patch.error !== undefined)
+    set.error = patch.error;
+  if (patch.attemptBranch !== undefined)
+    set.attemptBranch = patch.attemptBranch;
+  if (patch.conflictFiles !== undefined)
+    set.conflictFiles = patch.conflictFiles;
+  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  emit(ctx, current2.featureId, {
+    type: "ticket.updated",
+    message: `ticket ${current2.seq} \u2192 ${patch.status ?? current2.status}`,
+    ticketId: id,
+    data: patch
+  });
+  const updated = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  return rowToTicket(updated);
+}
+var MUTABLE_STATUSES;
+var init_tickets = __esm(() => {
+  init_src();
+  init_schema();
+  init_errors();
+  init_events();
+  init_repo();
+  MUTABLE_STATUSES = new Set(["pending", "failed"]);
 });
 
-// src/workflows/ticket-burner.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { claudeCode, run } from "@ai-hero/sandcastle";
-import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
-import { podman } from "@ai-hero/sandcastle/sandboxes/podman";
-import { noSandbox } from "@ai-hero/sandcastle/sandboxes/no-sandbox";
-function indexBySeq(tickets2) {
-  return new Map(tickets2.map((t) => [t.seq, t]));
-}
-function detectCycle(tickets2) {
-  const bySeq = indexBySeq(tickets2);
-  const WHITE = 0;
-  const GRAY = 1;
-  const BLACK = 2;
-  const color = new Map;
-  const stack = [];
-  const dfs = (seq) => {
-    color.set(seq, GRAY);
-    stack.push(seq);
-    const t = bySeq.get(seq);
-    if (t) {
-      for (const b of t.blockedBy) {
-        if (!bySeq.has(b))
-          continue;
-        const c = color.get(b) ?? WHITE;
-        if (c === GRAY) {
-          const idx = stack.indexOf(b);
-          return [...stack.slice(idx), b];
-        }
-        if (c === WHITE) {
-          const found = dfs(b);
-          if (found)
-            return found;
-        }
+// src/services/gates.ts
+import { existsSync as existsSync7 } from "fs";
+function checkGate(ctx, check, feature) {
+  switch (check) {
+    case "decisions-file-exists":
+      return fileGate(ctx, feature, "decisions.md", "run the ideation session to capture decisions first");
+    case "all-waypoints-terminal": {
+      const wps = listByFeature(ctx, feature.id);
+      if (wps.length === 0) {
+        return { satisfied: false, reason: "no waypoints charted yet \u2014 chart the map before converging" };
       }
+      const open = wps.filter((w) => w.status !== "resolved" && w.status !== "dropped");
+      return open.length === 0 ? { satisfied: true } : {
+        satisfied: false,
+        reason: notYetTerminal("waypoint", open.map((w) => w.status), ["open", "claimed"])
+      };
     }
-    color.set(seq, BLACK);
-    stack.pop();
-    return null;
-  };
-  for (const t of tickets2) {
-    if ((color.get(t.seq) ?? WHITE) === WHITE) {
-      const found = dfs(t.seq);
-      if (found)
-        return found;
+    case "spec-file-exists":
+      return fileGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
+    case "tickets-approved": {
+      const count = listByFeature2(ctx, feature.id).filter((t) => t.lap === feature.lap && t.status !== "cancelled").length;
+      return count >= 1 ? { satisfied: true } : { satisfied: false, reason: "no tickets to burn" };
     }
+    case "all-tickets-terminal": {
+      const tickets2 = listByFeature2(ctx, feature.id);
+      if (tickets2.length === 0)
+        return { satisfied: false, reason: "no tickets have run yet" };
+      const open = tickets2.filter((t) => t.status !== "done" && t.status !== "failed" && t.status !== "cancelled");
+      return open.length === 0 ? { satisfied: true } : {
+        satisfied: false,
+        reason: notYetTerminal("ticket", open.map((t) => t.status), ["pending", "burning"])
+      };
+    }
+    case "human-merge":
+      return { satisfied: false, reason: "use the Merge button to ship" };
   }
-  return null;
-}
-function renderTemplate2(template, values) {
-  let out = template;
-  for (const [key, value] of Object.entries(values)) {
-    out = out.split(`{{${key}}}`).join(value);
-  }
-  return out;
 }
-function renderTicketPrompt(template, values) {
-  return renderTemplate2(template, values);
+function notYetTerminal(noun, statuses, order) {
+  const counts = new Map;
+  for (const s of statuses)
+    counts.set(s, (counts.get(s) ?? 0) + 1);
+  const ordered = [
+    ...order.filter((s) => counts.has(s)),
+    ...[...counts.keys()].filter((s) => !order.includes(s))
+  ];
+  const breakdown = ordered.map((s) => `${counts.get(s)} ${s}`).join(", ");
+  return `${statuses.length} ${statuses.length === 1 ? noun : `${noun}s`} not yet terminal (${breakdown})`;
 }
-function buildTicketJson(ticket) {
-  return JSON.stringify({
-    seq: ticket.seq,
-    title: ticket.title,
-    goal: ticket.goal,
-    context: ticket.context,
-    acceptanceCriteria: ticket.acceptanceCriteria,
-    seams: ticket.seams,
-    blockedBy: ticket.blockedBy
-  }, null, 2);
+function fileGate(ctx, feature, fileName, reason) {
+  const project = projectForFeature(ctx, feature);
+  return existsSync7(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
 }
-function buildFeatureBrief(feature) {
-  return [
-    `**${feature.title}** (\`${feature.slug}\`)`,
-    "",
-    feature.oneLiner,
-    "",
-    `Working branch: \`${feature.branch}\``
-  ].join(`
-`);
+function overrideGate(ctx, featureId, gate, reason) {
+  const feature = getFeatureRow(ctx, featureId);
+  ctx.db.insert(gateOverrides).values({ featureId, gate, reason, ts: Date.now() }).run();
+  emit(ctx, featureId, {
+    type: "gate.overridden",
+    message: `gate ${gate} overridden: ${reason}`,
+    data: { gate, reason }
+  });
+  const next = nextPhase(feature);
+  if (next)
+    return setPhase(ctx, featureId, next, "phase.advanced", `advanced to ${next} (override)`);
+  return feature;
 }
-function buildDocsDigest(files) {
-  if (files.length === 0) {
-    return "_No feature docs found \u2014 work from the ticket context and the code._";
-  }
-  return files.map((f) => `### ${f.name}
-
-${f.content.trim()}`).join(`
-
----
+var init_gates = __esm(() => {
+  init_src();
+  init_schema();
+  init_events();
+  init_feature_docs();
+  init_repo();
+  init_tickets();
+  init_waypoints();
+});
 
+// src/services/knowledge.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync } from "fs";
+import { join as join7, relative, resolve as resolve5, sep } from "path";
+function scaffoldDocs(ctx, feature, opts = {}) {
+  const project = projectForFeature(ctx, feature);
+  const dir = featureDocsDir(project, feature);
+  mkdirSync3(dir, { recursive: true });
+  const briefPath = featureDocPath(project, feature, "brief.md");
+  if (!existsSync8(briefPath)) {
+    const override = opts.brief?.trim();
+    const created = new Date().toISOString();
+    const brief = override ? `${override}
+` : [
+      `# ${feature.title}`,
+      "",
+      feature.oneLiner,
+      "",
+      `- Slug: ${feature.slug}`,
+      `- Created: ${created}`,
+      ""
+    ].join(`
 `);
-}
-function buildConflictFilesBlock(files) {
-  if (files.length === 0) {
-    return "_git did not report the paths \u2014 run `git status` after starting the merge to see them._";
+    writeFileSync(briefPath, brief, "utf8");
   }
-  return files.map((f) => `- \`${f}\``).join(`
-`);
-}
-function buildOtherSideBlock(summaries) {
-  if (summaries.length === 0) {
-    return "_No commit summaries available \u2014 inspect `git log` on the feature branch._";
+  if (feature.mapped) {
+    scaffoldMapDoc(project, feature);
   }
-  return summaries.map((s) => `- ${s}`).join(`
-`);
+  emit(ctx, feature.id, {
+    type: "docs.scaffolded",
+    message: feature.mapped ? `scaffolded docs/features/${feature.slug}/{brief,map}.md` : `scaffolded docs/features/${feature.slug}/brief.md`
+  });
 }
-function resolveMergeCommand(mode, featureBranch2) {
-  return mode === "mounted" ? `git merge --no-edit ${featureBranch2}` : `git fetch origin ${featureBranch2} && git merge --no-edit FETCH_HEAD`;
-}
-function parseEnvFile(content) {
-  const out = {};
-  for (const rawLine of content.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (line.length === 0 || line.startsWith("#"))
-      continue;
-    const body = line.startsWith("export ") ? line.slice(7).trim() : line;
-    const eq5 = body.indexOf("=");
-    if (eq5 === -1)
-      continue;
-    const key = body.slice(0, eq5).trim();
-    if (key.length === 0)
-      continue;
-    let value = body.slice(eq5 + 1).trim();
-    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    out[key] = value;
-  }
-  return out;
+function scaffoldMapDoc(project, feature, seed) {
+  mkdirSync3(featureDocsDir(project, feature), { recursive: true });
+  const mapPath = featureDocPath(project, feature, "map.md");
+  if (existsSync8(mapPath))
+    return;
+  writeFileSync(mapPath, mapDocBody(feature, seed), "utf8");
 }
-function detectPackageManager(tc) {
-  const pinned = tc.packageManagerField?.split("@")[0];
-  if (pinned && PACKAGE_MANAGERS.includes(pinned)) {
-    return pinned;
+function mapDocBody(feature, seed) {
+  const seeded = {
+    Destination: seed?.destination?.trim(),
+    Notes: seed?.notes?.trim()
+  };
+  const lines = [`# ${feature.title} \u2014 map`, ""];
+  for (const section of MAP_SECTIONS) {
+    lines.push(`## ${section}`, "");
+    const body = seeded[section];
+    if (body)
+      lines.push(body, "");
   }
-  if (tc.lockfiles.bun)
-    return "bun";
-  if (tc.lockfiles.pnpm)
-    return "pnpm";
-  if (tc.lockfiles.yarn)
-    return "yarn";
-  if (tc.lockfiles.npm)
-    return "npm";
-  return tc.hasPackageJson ? "npm" : undefined;
-}
-function orFallback(strict, permissive) {
-  return `( ${strict} || ${permissive} )`;
+  return lines.join(`
+`);
 }
-function resolveSetupCommand(tc, override) {
-  const trimmed = override?.trim();
-  if (trimmed)
-    return trimmed;
-  const pm = detectPackageManager(tc);
-  if (!pm)
+function readCharter(repoRoot) {
+  const path = join7(repoRoot, CHARTER_FILE);
+  if (!existsSync8(path))
+    return;
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
     return;
-  switch (pm) {
-    case "bun":
-      return tc.lockfiles.bun ? orFallback("bun install --frozen-lockfile", "bun install") : "bun install";
-    case "pnpm":
-      return tc.lockfiles.pnpm ? orFallback("corepack pnpm install --frozen-lockfile", "corepack pnpm install") : "corepack pnpm install";
-    case "yarn":
-      return tc.lockfiles.yarn ? orFallback("corepack yarn install --frozen-lockfile", "corepack yarn install") : "corepack yarn install";
-    case "npm":
-      return tc.lockfiles.npm ? orFallback("npm ci", "npm install") : "npm install";
   }
 }
-function cacheMountFor(pm, hostPath) {
-  const sandboxPath = PM_CACHE_SANDBOX_PATHS[pm];
-  return sandboxPath ? { hostPath, sandboxPath } : undefined;
+function listLiveAdrs(repoRoot) {
+  const dir = join7(repoRoot, ADR_DIR_REL);
+  if (!existsSync8(dir))
+    return [];
+  const docs = [];
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".md"))
+      continue;
+    let content;
+    try {
+      content = readFileSync3(join7(dir, entry.name), "utf8");
+    } catch {
+      continue;
+    }
+    if (SUPERSEDED_RE.test(content))
+      continue;
+    docs.push({ relPath: `${ADR_DIR_REL}/${entry.name}`, content });
+  }
+  return docs.sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
-function resolveBurnWorkspaceMode(config2, platform = process.platform) {
-  if (config2.sandbox === "noSandbox")
-    return "mounted";
-  if (config2.burnWorkspace === "auto")
-    return platform === "linux" ? "mounted" : "isolated";
-  return config2.burnWorkspace;
+function listDocs(ctx, feature) {
+  const project = projectForFeature(ctx, feature);
+  const dir = featureDocsDir(project, feature);
+  if (!existsSync8(dir))
+    return [];
+  return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => ({ relPath: e.name, title: readTitle(join7(dir, e.name), e.name) })).sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
-function buildIsolatedSetupCommand(tempBranch, setupCommand, pm) {
-  const hookFile = `${ISOLATED_REPO_PATH}/.git/hooks/post-commit`;
-  const parts = [
-    `git config --global --add safe.directory '*'`,
-    `git clone ${SANDBOX_WORKSPACE_PATH} ${ISOLATED_REPO_PATH}`,
-    `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}`,
-    `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}"`);
+function readDoc(ctx, feature, relPath) {
+  const project = projectForFeature(ctx, feature);
+  const dir = featureDocsDir(project, feature);
+  const root = resolve5(dir);
+  const target = resolve5(dir, relPath);
+  const rel = relative(root, target);
+  if (rel === "" || rel.startsWith("..") || rel.split(sep).includes("..")) {
+    throw new InvalidInputError(`doc path escapes the feature docs dir: ${relPath}`);
   }
-  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(" && ");
+  if (!existsSync8(target))
+    throw new NotFoundError(`doc not found: ${relPath}`);
+  return { content: readFileSync3(target, "utf8") };
 }
-function buildWorkspaceNotes(mode) {
-  if (mode === "mounted") {
-    return "Work in the current directory \u2014 it is the repo checkout on your branch.";
+function readTitle(path, fallback) {
+  try {
+    const firstLine = readFileSync3(path, "utf8").split(`
+`, 1)[0] ?? "";
+    const heading = firstLine.match(/^#\s+(.+)$/);
+    return heading ? heading[1].trim() : fallback;
+  } catch {
+    return fallback;
   }
-  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.`,
-    "",
-    `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.`,
-    "",
-    `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.`
-  ].join(`
-`);
 }
-function buildVerifyNotes(config2) {
-  const commands = config2.verifyCommands?.trim();
-  const failures = config2.knownFailures?.trim();
-  const out = [];
-  if (commands) {
-    out.push("Verify with exactly these commands \u2014 they are correct for this repo, so do not go looking for alternatives or guess at workspace/package filter names:", "", "```", commands, "```");
+var MAP_SECTIONS, CHARTER_FILE = "CONTEXT.md", ADR_DIR_REL = "docs/adr", SUPERSEDED_RE;
+var init_knowledge = __esm(() => {
+  init_errors();
+  init_events();
+  init_feature_docs();
+  init_repo();
+  MAP_SECTIONS = [
+    "Destination",
+    "Notes",
+    "Not yet specified",
+    "Out of scope"
+  ];
+  SUPERSEDED_RE = /superseded by ADR-\d+/i;
+});
+
+// src/pty/end-session.ts
+function endSession(ctx, sessionId) {
+  const registry = ptyRegistry();
+  const killed = registry.kill(sessionId);
+  registry.remove(sessionId);
+  const session = markSessionEnded(ctx, sessionId);
+  if (session) {
+    releaseForSession(ctx, sessionId);
+    landProjectSession(ctx, session);
+    emitForSession(ctx, session, {
+      type: "session.ended",
+      message: "session ended by user",
+      data: { sessionId, killed }
+    });
   } else {
-    out.push("No verification commands are configured, so derive them ONCE from the repo (root `package.json` scripts, the workspace's own manifest, CI config) before your first test run \u2014 reading a manifest is free, discovering a filter name by running the wrong suite is not. Write the working commands into your notes and reuse them verbatim for the rest of the ticket.");
+    const existing = getSessionRow(ctx, sessionId);
+    if (!existing)
+      return { sessionId, ok: false, killed };
   }
-  out.push("");
-  if (failures) {
-    out.push("These tests ALREADY fail on this repo before you touch anything:", "", "```", failures, "```", "", "Treat that as your baseline \u2014 do NOT spend a run establishing it yourself. Only a failure outside this set is yours to fix; if you hit one that looks pre-existing but is not listed, confirm it on a single targeted run of that one test, never a whole-suite re-run.");
-  } else {
-    out.push("No pre-existing-failure baseline is configured. If the suite is already red, capture the baseline ONCE \u2014 the first full run you do, before your changes land, is the baseline \u2014 and compare every later run against those saved results. Never re-run a whole suite just to re-establish what was already failing.");
+  return { sessionId, ok: true, killed };
+}
+var init_end_session = __esm(() => {
+  init_sessions();
+  init_events();
+  init_waypoints();
+  init_registry();
+});
+
+// src/launcher/skills-root.ts
+import { existsSync as existsSync9 } from "fs";
+import { dirname as dirname2, join as join8, resolve as resolve6 } from "path";
+function resolveSkillsRoot(fromDir) {
+  const override = process.env[SKILLS_DIR_ENV];
+  if (override) {
+    const root = resolve6(override);
+    if (existsSync9(join8(root, SKILLS_MARKER)))
+      return root;
+    throw new Error(`${SKILLS_DIR_ENV}=${override} is not a runcastle skills root (missing ${SKILLS_MARKER})`);
   }
-  return out.join(`
-`);
+  const searched = [];
+  let dir = fromDir;
+  for (let i = 0;i < 8; i += 1) {
+    const candidate = join8(dir, "packages", "skills");
+    searched.push(candidate);
+    if (existsSync9(join8(candidate, SKILLS_MARKER)))
+      return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  throw new Error(`runcastle skills root not found; searched:
+  ${searched.join(`
+  `)}`);
 }
-function readRepoToolchain(repoPath) {
-  const pkgPath = join7(repoPath, "package.json");
-  const hasPackageJson = existsSync7(pkgPath);
-  let packageManagerField;
-  if (hasPackageJson) {
-    try {
-      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
-      if (typeof pkg.packageManager === "string")
-        packageManagerField = pkg.packageManager;
-    } catch {}
+var SKILLS_DIR_ENV = "RUNCASTLE_SKILLS_DIR", SKILLS_MARKER;
+var init_skills_root = __esm(() => {
+  SKILLS_MARKER = join8("packs", "runcastle");
+});
+
+// src/services/agent-stream.ts
+function beginTranscript(ticketId) {
+  transcripts.set(ticketId, { live: true, chunks: [], nextIndex: 0, bytes: 0 });
+  publishLive({ kind: "transcript", ticketId });
+}
+function appendTranscript(ticketId, chunk) {
+  const t = transcripts.get(ticketId);
+  if (!t)
+    return;
+  const full = { ...chunk, i: t.nextIndex, ts: chunk.ts ?? Date.now() };
+  t.nextIndex += 1;
+  t.chunks.push(full);
+  t.bytes += full.text.length;
+  while (t.chunks.length > MAX_CHUNKS || t.bytes > MAX_BYTES && t.chunks.length > 1) {
+    const dropped = t.chunks.shift();
+    if (!dropped)
+      break;
+    t.bytes -= dropped.text.length;
   }
-  return {
-    hasPackageJson,
-    ...packageManagerField !== undefined ? { packageManagerField } : {},
-    lockfiles: {
-      bun: existsSync7(join7(repoPath, "bun.lock")) || existsSync7(join7(repoPath, "bun.lockb")),
-      pnpm: existsSync7(join7(repoPath, "pnpm-lock.yaml")),
-      yarn: existsSync7(join7(repoPath, "yarn.lock")),
-      npm: existsSync7(join7(repoPath, "package-lock.json"))
-    }
-  };
+  publishLive({ kind: "transcript", ticketId });
 }
-function createStreamThrottle(emit3, opts = {}) {
-  const intervalMs = opts.intervalMs ?? 2000;
-  const maxChars = opts.maxChars ?? 500;
-  const now = opts.now ?? Date.now;
-  let buffer = "";
-  let lastIteration = 0;
-  let lastFlush = now();
-  const flushText = () => {
-    if (buffer.length === 0)
-      return;
-    emit3({ type: "burn.text", message: buffer, data: { iteration: lastIteration } });
-    buffer = "";
-    lastFlush = now();
-  };
-  const onEvent = (event) => {
-    if (event.type === "text") {
-      lastIteration = event.iteration;
-      buffer += event.message;
-      if (buffer.length >= maxChars || now() - lastFlush >= intervalMs)
-        flushText();
-    } else if (event.type === "toolCall") {
-      lastIteration = event.iteration;
-      flushText();
-      const rawArgs = event.formattedArgs ?? "";
-      const args = rawArgs.length > 200 ? `${rawArgs.slice(0, 200)}\u2026` : rawArgs;
-      emit3({
-        type: "burn.tool",
-        message: args.length > 0 ? `${event.name} ${args}` : event.name,
-        data: { name: event.name, args: rawArgs, iteration: event.iteration }
-      });
-    }
-  };
-  return { onEvent, flush: flushText };
+function endTranscript(ticketId) {
+  const t = transcripts.get(ticketId);
+  if (t)
+    t.live = false;
+  publishLive({ kind: "transcript", ticketId });
 }
-function normalizeCommandForClassification(command) {
-  return command.replace(/<<\s*['"]?(\w+)['"]?[\s\S]*?(^|\n)\s*\1\b/gm, "<<$1 ").replace(/<<\s*['"]?(\w+)['"]?[\s\S]*$/, "<<$1 ").replace(/'[^']*'/g, " ").replace(/"[^"]*"/g, " ");
+function readTranscript(ticketId, after = -1) {
+  const t = transcripts.get(ticketId);
+  if (!t)
+    return { live: false, chunks: [], firstIndex: 0, nextIndex: 0 };
+  return {
+    live: t.live,
+    chunks: after < 0 ? [...t.chunks] : t.chunks.filter((c) => c.i > after),
+    firstIndex: t.chunks[0]?.i ?? t.nextIndex,
+    nextIndex: t.nextIndex
+  };
 }
-function classifyToolCall(name, args) {
-  const byName = TOOL_NAME_CATEGORY[name];
-  if (byName)
-    return byName;
-  if (name !== "Bash")
-    return "other";
-  const normalized = normalizeCommandForClassification(args);
-  for (const [category, pattern] of BASH_PATTERNS) {
-    if (pattern.test(normalized))
-      return category;
+var MAX_CHUNKS = 4000, MAX_BYTES = 1500000, transcripts;
+var init_agent_stream = __esm(() => {
+  init_bus();
+  transcripts = new Map;
+});
+
+// src/workflows/burn-guard.ts
+function renderGuardScript(rules = GUARD_RULES) {
+  const lines = [
+    "#!/bin/sh",
+    "# runcastle burn guard (PreToolUse). Generated \u2014 edit burn-guard.ts, not this.",
+    "set -u",
+    "payload=$(cat 2>/dev/null || true)",
+    '[ -n "$payload" ] || exit 0',
+    "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',
+    "",
+    "# 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")`,
+    "",
+    "deny() {",
+    `  printf %s "$1" | jq -R -s '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:.}}'`,
+    "  exit 0",
+    "}",
+    ""
+  ];
+  for (const rule of rules) {
+    lines.push(`# ${rule.id}`, `if printf %s "$cmd" | grep -Eq -- ${shSingleQuote(rule.pattern)}; then`, `  deny ${shSingleQuote(rule.reason)}`, "fi", "");
   }
-  return "other";
+  lines.push("exit 0", "");
+  return lines.join(`
+`);
 }
-function createToolTimer() {
-  const byCategory = {};
-  let calls = 0;
-  let totalMs = 0;
-  let pending = null;
-  let iteration = null;
-  const charge = (category, ms) => {
-    const slot = byCategory[category] ??= { calls: 0, ms: 0 };
-    slot.ms += ms;
-    totalMs += ms;
+function shSingleQuote(value) {
+  return `'${value.split("'").join(`'\\''`)}'`;
+}
+function renderGuardSettings() {
+  return {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [{ type: "command", command: `sh ${GUARD_SCRIPT_PATH}`, timeout: 5 }]
+        }
+      ]
+    }
   };
-  const onEvent = (event) => {
-    if (event.type === "raw")
-      return;
-    const at = event.timestamp.getTime();
-    if (iteration !== null && event.iteration !== iteration)
-      pending = null;
-    iteration = event.iteration;
-    if (pending) {
-      const gap = at - pending.at;
-      if (gap > 0 && gap <= MAX_ATTRIBUTABLE_GAP_MS)
-        charge(pending.category, gap);
+}
+function buildGuardInstallCommand() {
+  const script = Buffer.from(renderGuardScript(), "utf8").toString("base64");
+  const settings = Buffer.from(JSON.stringify(renderGuardSettings(), null, 2), "utf8").toString("base64");
+  return [
+    `mkdir -p "$HOME/.claude/hooks"`,
+    `printf %s '${script}' | base64 -d > "${GUARD_SCRIPT_PATH}"`,
+    `chmod +x "${GUARD_SCRIPT_PATH}"`,
+    `printf %s '${settings}' | base64 -d > "${GUARD_SETTINGS_PATH}"`
+  ].join(" && ");
+}
+var CMD_START = "(^|[;&|(]|&&)[[:space:]]*", GUARD_RULES, GUARD_SCRIPT_PATH = "$HOME/.claude/hooks/burn-guard.sh", GUARD_SETTINGS_PATH = "$HOME/.claude/settings.json";
+var init_burn_guard = __esm(() => {
+  GUARD_RULES = [
+    {
+      id: "no-stash",
+      pattern: `${CMD_START}git[[:space:]]+stash`,
+      reason: "git stash is blocked in burns: stashed work is invisible to the orchestrator and unrecoverable if this process dies, and only commits survive. To compare against the pre-change state use `git show HEAD:<path>`, or the pre-existing-failure baseline in your prompt."
+    },
+    {
+      id: "no-serialised-tests",
+      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-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-cat-heredoc-edit",
+      pattern: `${CMD_START}cat[[:space:]]+>>?[[:space:]]*[^[:space:]|]+[[:space:]]*<<`,
+      reason: "Do not write files with `cat > file <<EOF`. Use the Write tool for a new file, or Edit to change part of an existing one."
     }
-    if (event.type === "toolCall") {
-      const category = classifyToolCall(event.name, event.formattedArgs ?? "");
-      const slot = byCategory[category] ??= { calls: 0, ms: 0 };
-      slot.calls += 1;
-      calls += 1;
-      pending = { category, at };
-    } else {
-      pending = { category: "model", at };
+  ];
+});
+
+// src/workflows/ticket-burner.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { claudeCode, run } from "@ai-hero/sandcastle";
+import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
+import { podman } from "@ai-hero/sandcastle/sandboxes/podman";
+import { noSandbox } from "@ai-hero/sandcastle/sandboxes/no-sandbox";
+function indexBySeq(tickets2) {
+  return new Map(tickets2.map((t) => [t.seq, t]));
+}
+function detectCycle(tickets2) {
+  const bySeq = indexBySeq(tickets2);
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = new Map;
+  const stack = [];
+  const dfs = (seq) => {
+    color.set(seq, GRAY);
+    stack.push(seq);
+    const t = bySeq.get(seq);
+    if (t) {
+      for (const b of t.blockedBy) {
+        if (!bySeq.has(b))
+          continue;
+        const c = color.get(b) ?? WHITE;
+        if (c === GRAY) {
+          const idx = stack.indexOf(b);
+          return [...stack.slice(idx), b];
+        }
+        if (c === WHITE) {
+          const found = dfs(b);
+          if (found)
+            return found;
+        }
+      }
     }
+    color.set(seq, BLACK);
+    stack.pop();
+    return null;
   };
-  return { onEvent, summary: () => ({ totalMs, calls, byCategory }) };
-}
-function formatTimingSummary(s) {
-  if (s.totalMs === 0)
-    return `${s.calls} tool call(s), no measurable time`;
-  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(", ")}`;
+  for (const t of tickets2) {
+    if ((color.get(t.seq) ?? WHITE) === WHITE) {
+      const found = dfs(t.seq);
+      if (found)
+        return found;
+    }
+  }
+  return null;
 }
-function interpretRunResult(result, blockedContent) {
-  const commits = result.commits.map((c) => c.sha);
-  if (commits.length > 0)
-    return { status: "done", commits };
-  if (blockedContent !== undefined && blockedContent.trim().length > 0) {
-    return { status: "failed", error: `agent reported BLOCKED:
-${blockedContent.trim()}` };
+function renderTemplate2(template, values) {
+  let out = template;
+  for (const [key, value] of Object.entries(values)) {
+    out = out.split(`{{${key}}}`).join(value);
   }
-  return { status: "failed", error: "agent made no commits" };
+  return out;
 }
-function isWorktreeTeardownError(err) {
-  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
-  if (!BURN_WORKTREE_PATH.test(msg))
-    return false;
-  return WORKTREE_REMOVAL_FAILURES.some((p) => p.test(msg));
+function renderTicketPrompt(template, values) {
+  return renderTemplate2(template, values);
 }
-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 buildTicketJson(ticket) {
+  return JSON.stringify({
+    seq: ticket.seq,
+    title: ticket.title,
+    goal: ticket.goal,
+    context: ticket.context,
+    acceptanceCriteria: ticket.acceptanceCriteria,
+    seams: ticket.seams,
+    blockedBy: ticket.blockedBy
+  }, null, 2);
 }
-function classifyTicketRunError(err) {
-  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
-  if (FATAL_ERROR_PATTERNS.some((p) => p.test(msg)))
-    return "fatal";
-  if (RETRYABLE_ERROR_PATTERNS.some((p) => p.test(msg)))
-    return "retryable";
-  return "fatal";
-}
-function retryDelayMs(attempt) {
-  return Math.min(30000, 5000 * 2 ** (attempt - 1));
-}
-function buildRetryNotes(input) {
-  const cause = input.error ? ` (${input.error})` : "";
-  const commits = input.commitCount > 0 ? `${input.commitCount} commit(s) from the previous attempt(s) are already on your branch \u2014 completed work, not noise.` : "The previous attempt had not committed anything yet, so you are effectively starting clean.";
+function buildFeatureBrief(feature) {
   return [
-    "## Recovery context \u2014 a previous attempt was interrupted",
-    "",
-    `A previous agent working THIS SAME ticket was killed by a transient infrastructure error${cause} \u2014 not by anything it did wrong, and not by a human decision. You are picking up where it left off.`,
+    `**${feature.title}** (\`${feature.slug}\`)`,
     "",
-    commits,
+    feature.oneLiner,
     "",
-    "Before doing anything else, run `git log --oneline -15` and `git status` to see what was already completed. Build on that work \u2014 do NOT revert or redo existing commits. Uncommitted changes from the previous attempt were lost; only commits survived. If the ticket turns out to be fully implemented already, verify the acceptance criteria and finish normally."
+    `Working branch: \`${feature.branch}\``
   ].join(`
 `);
 }
-function delayUnlessAborted(ms, signal) {
-  return new Promise((resolve6) => {
-    if (signal.aborted) {
-      resolve6();
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(t);
-      resolve6();
-    };
-    const t = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve6();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
+function buildDocsDigest(files) {
+  if (files.length === 0) {
+    return "_No feature docs found \u2014 work from the ticket context and the code._";
+  }
+  return files.map((f) => `### ${f.name}
+
+${f.content.trim()}`).join(`
+
+---
+
+`);
 }
-function stopTicketRun(ticketId) {
-  const controller = activeTicketAborts.get(ticketId);
-  if (!controller)
-    return false;
-  controller.abort(new Error("ticket stopped by user"));
-  return true;
+function buildConflictFilesBlock(files) {
+  if (files.length === 0) {
+    return "_git did not report the paths \u2014 run `git status` after starting the merge to see them._";
+  }
+  return files.map((f) => `- \`${f}\``).join(`
+`);
 }
-function createSerialQueue() {
-  let tail = Promise.resolve();
-  return (task) => {
-    const next = tail.then(task);
-    tail = next.catch(() => {
-      return;
-    });
-    return next;
-  };
+function buildOtherSideBlock(summaries) {
+  if (summaries.length === 0) {
+    return "_No commit summaries available \u2014 inspect `git log` on the feature branch._";
+  }
+  return summaries.map((s) => `- ${s}`).join(`
+`);
 }
-async function landWithResolve(branch, deps) {
-  let current = branch;
-  for (let attempt = 1;; attempt++) {
-    const merge = await deps.merge(current);
-    if (merge.ok)
-      return { status: "landed", branch: current };
-    const detail = merge.error ?? "merge failed";
-    if (!merge.conflict)
-      return { status: "failed", branch: current, error: detail };
-    const files = merge.files ?? [];
-    if (attempt > deps.maxResolveAttempts) {
-      return { status: "conflict", branch: current, files, error: detail };
-    }
-    const where = files.length > 0 ? `${files.length} file(s)` : "the merge";
-    deps.emit({
-      type: "merge.conflict.resolving",
-      message: `${deps.label}: conflicts with ${deps.featureBranch} on ${where} \u2014 resolving with an agent (pass ${attempt}/${deps.maxResolveAttempts})`,
-      data: { branch: current, files, attempt, maxAttempts: deps.maxResolveAttempts }
-    });
-    const resolved = await deps.resolve({
-      branch: current,
-      files,
-      attempt,
-      maxAttempts: deps.maxResolveAttempts
-    });
-    current = resolved.branch;
-    if (!resolved.ok) {
-      return { status: "conflict", branch: current, files, error: resolved.error ?? detail };
+function resolveMergeCommand(mode, featureBranch2) {
+  return mode === "mounted" ? `git merge --no-edit ${featureBranch2}` : `git fetch origin ${featureBranch2} && git merge --no-edit FETCH_HEAD`;
+}
+function parseEnvFile(content) {
+  const out = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    const body = line.startsWith("export ") ? line.slice(7).trim() : line;
+    const eq6 = body.indexOf("=");
+    if (eq6 === -1)
+      continue;
+    const key = body.slice(0, eq6).trim();
+    if (key.length === 0)
+      continue;
+    let value = body.slice(eq6 + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
     }
-    deps.emit({
-      type: "merge.conflict.resolved",
-      message: `${deps.label}: conflict resolved on ${current} \u2014 landing`,
-      data: { branch: current, files, attempt }
-    });
+    out[key] = value;
   }
+  return out;
 }
-function errorHeadline(s) {
-  const lines = s.split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const causes = lines.filter((l) => /^(fatal|error):/i.test(l));
-  return causes.at(-1) ?? lines[0] ?? "";
+function detectPackageManager(tc) {
+  const pinned = tc.packageManagerField?.split("@")[0];
+  if (pinned && PACKAGE_MANAGERS.includes(pinned)) {
+    return pinned;
+  }
+  if (tc.lockfiles.bun)
+    return "bun";
+  if (tc.lockfiles.pnpm)
+    return "pnpm";
+  if (tc.lockfiles.yarn)
+    return "yarn";
+  if (tc.lockfiles.npm)
+    return "npm";
+  return tc.hasPackageJson ? "npm" : undefined;
 }
-async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
-  const width = Math.max(1, Math.floor(concurrency));
-  const bySeq = indexBySeq(tickets2);
-  const status = new Map(tickets2.map((t) => [t.seq, t.status]));
-  const pending = new Set(tickets2.filter((t) => t.status === "pending").map((t) => t.seq));
-  const inFlight = new Map;
-  const satisfied = (s) => s === "done" || s === "cancelled";
-  const readyState = (seq) => {
-    const t = bySeq.get(seq);
-    if (!t)
-      return "wait";
-    for (const b of t.blockedBy) {
-      const present = bySeq.has(b);
-      const bs = present ? status.get(b) : undefined;
-      if (!present || bs === "failed")
-        return { blockedBy: b, present };
+function orFallback(strict, permissive) {
+  return `( ${strict} || ${permissive} )`;
+}
+function resolveSetupCommand(tc, override) {
+  const trimmed = override?.trim();
+  if (trimmed)
+    return trimmed;
+  const pm = detectPackageManager(tc);
+  if (!pm)
+    return;
+  switch (pm) {
+    case "bun":
+      return tc.lockfiles.bun ? orFallback("bun install --frozen-lockfile", "bun install") : "bun install";
+    case "pnpm":
+      return tc.lockfiles.pnpm ? orFallback("corepack pnpm install --frozen-lockfile", "corepack pnpm install") : "corepack pnpm install";
+    case "yarn":
+      return tc.lockfiles.yarn ? orFallback("corepack yarn install --frozen-lockfile", "corepack yarn install") : "corepack yarn install";
+    case "npm":
+      return tc.lockfiles.npm ? orFallback("npm ci", "npm install") : "npm install";
+  }
+}
+function cacheMountFor(pm, hostPath) {
+  const sandboxPath = PM_CACHE_SANDBOX_PATHS[pm];
+  return sandboxPath ? { hostPath, sandboxPath } : undefined;
+}
+function resolveBurnWorkspaceMode(config2, platform = process.platform) {
+  if (config2.sandbox === "noSandbox")
+    return "mounted";
+  if (config2.burnWorkspace === "auto")
+    return platform === "linux" ? "mounted" : "isolated";
+  return config2.burnWorkspace;
+}
+function buildIsolatedSetupCommand(tempBranch, setupCommand, pm) {
+  const hookFile = `${ISOLATED_REPO_PATH}/.git/hooks/post-commit`;
+  const parts = [
+    `git config --global --add safe.directory '*'`,
+    `git clone ${SANDBOX_WORKSPACE_PATH} ${ISOLATED_REPO_PATH}`,
+    `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}`,
+    `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}"`);
+  }
+  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(" && ");
+}
+function buildWorkspaceNotes(mode) {
+  if (mode === "mounted") {
+    return "Work in the current directory \u2014 it is the repo checkout on your branch.";
+  }
+  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.`,
+    "",
+    `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.`,
+    "",
+    `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.`
+  ].join(`
+`);
+}
+function buildVerifyNotes(config2) {
+  const commands = config2.verifyCommands?.trim();
+  const failures = config2.knownFailures?.trim();
+  const out = [];
+  if (commands) {
+    out.push("Verify with exactly these commands \u2014 they are correct for this repo, so do not go looking for alternatives or guess at workspace/package filter names:", "", "```", commands, "```");
+  } else {
+    out.push("No verification commands are configured, so derive them ONCE from the repo (root `package.json` scripts, the workspace's own manifest, CI config) before your first test run \u2014 reading a manifest is free, discovering a filter name by running the wrong suite is not. Write the working commands into your notes and reuse them verbatim for the rest of the ticket.");
+  }
+  out.push("");
+  if (failures) {
+    out.push("These tests ALREADY fail on this repo before you touch anything:", "", "```", failures, "```", "", "Treat that as your baseline \u2014 do NOT spend a run establishing it yourself. Only a failure outside this set is yours to fix; if you hit one that looks pre-existing but is not listed, confirm it on a single targeted run of that one test, never a whole-suite re-run.");
+  } else {
+    out.push("No pre-existing-failure baseline is configured. If the suite is already red, capture the baseline ONCE \u2014 the first full run you do, before your changes land, is the baseline \u2014 and compare every later run against those saved results. Never re-run a whole suite just to re-establish what was already failing.");
+  }
+  return out.join(`
+`);
+}
+function readRepoToolchain(repoPath) {
+  const pkgPath = join9(repoPath, "package.json");
+  const hasPackageJson = existsSync10(pkgPath);
+  let packageManagerField;
+  if (hasPackageJson) {
+    try {
+      const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+      if (typeof pkg.packageManager === "string")
+        packageManagerField = pkg.packageManager;
+    } catch {}
+  }
+  return {
+    hasPackageJson,
+    ...packageManagerField !== undefined ? { packageManagerField } : {},
+    lockfiles: {
+      bun: existsSync10(join9(repoPath, "bun.lock")) || existsSync10(join9(repoPath, "bun.lockb")),
+      pnpm: existsSync10(join9(repoPath, "pnpm-lock.yaml")),
+      yarn: existsSync10(join9(repoPath, "yarn.lock")),
+      npm: existsSync10(join9(repoPath, "package-lock.json"))
     }
-    return t.blockedBy.every((b) => satisfied(status.get(b))) ? "ready" : "wait";
   };
-  const failTicket = (seq, error, extra) => {
-    const t = bySeq.get(seq);
-    status.set(seq, "failed");
-    if (!t)
+}
+function createStreamThrottle(emit3, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 2000;
+  const maxChars = opts.maxChars ?? 500;
+  const now = opts.now ?? Date.now;
+  let buffer = "";
+  let lastIteration = 0;
+  let lastFlush = now();
+  const flushText = () => {
+    if (buffer.length === 0)
       return;
-    ctx.updateTicket(t.id, { status: "failed", error });
-    if (extra)
-      ctx.emitEvent({ ...extra, ticketId: t.id });
-  };
-  const runOne = async (seq) => {
+    emit3({ type: "burn.text", message: buffer, data: { iteration: lastIteration } });
+    buffer = "";
+    lastFlush = now();
+  };
+  const onEvent = (event) => {
+    if (event.type === "text") {
+      lastIteration = event.iteration;
+      buffer += event.message;
+      if (buffer.length >= maxChars || now() - lastFlush >= intervalMs)
+        flushText();
+    } else if (event.type === "toolCall") {
+      lastIteration = event.iteration;
+      flushText();
+      const rawArgs = event.formattedArgs ?? "";
+      const args = rawArgs.length > 200 ? `${rawArgs.slice(0, 200)}\u2026` : rawArgs;
+      emit3({
+        type: "burn.tool",
+        message: args.length > 0 ? `${event.name} ${args}` : event.name,
+        data: { name: event.name, args: rawArgs, iteration: event.iteration }
+      });
+    }
+  };
+  return { onEvent, flush: flushText };
+}
+function normalizeCommandForClassification(command) {
+  return command.replace(/<<\s*['"]?(\w+)['"]?[\s\S]*?(^|\n)\s*\1\b/gm, "<<$1 ").replace(/<<\s*['"]?(\w+)['"]?[\s\S]*$/, "<<$1 ").replace(/'[^']*'/g, " ").replace(/"[^"]*"/g, " ");
+}
+function classifyToolCall(name, args) {
+  const byName = TOOL_NAME_CATEGORY[name];
+  if (byName)
+    return byName;
+  if (name !== "Bash")
+    return "other";
+  const normalized = normalizeCommandForClassification(args);
+  for (const [category, pattern] of BASH_PATTERNS) {
+    if (pattern.test(normalized))
+      return category;
+  }
+  return "other";
+}
+function createToolTimer() {
+  const byCategory = {};
+  let calls = 0;
+  let totalMs = 0;
+  let pending = null;
+  let iteration = null;
+  const charge = (category, ms) => {
+    const slot = byCategory[category] ??= { calls: 0, ms: 0 };
+    slot.ms += ms;
+    totalMs += ms;
+  };
+  const onEvent = (event) => {
+    if (event.type === "raw")
+      return;
+    const at = event.timestamp.getTime();
+    if (iteration !== null && event.iteration !== iteration)
+      pending = null;
+    iteration = event.iteration;
+    if (pending) {
+      const gap = at - pending.at;
+      if (gap > 0 && gap <= MAX_ATTRIBUTABLE_GAP_MS)
+        charge(pending.category, gap);
+    }
+    if (event.type === "toolCall") {
+      const category = classifyToolCall(event.name, event.formattedArgs ?? "");
+      const slot = byCategory[category] ??= { calls: 0, ms: 0 };
+      slot.calls += 1;
+      calls += 1;
+      pending = { category, at };
+    } else {
+      pending = { category: "model", at };
+    }
+  };
+  return { onEvent, summary: () => ({ totalMs, calls, byCategory }) };
+}
+function formatTimingSummary(s) {
+  if (s.totalMs === 0)
+    return `${s.calls} tool call(s), no measurable time`;
+  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 interpretRunResult(result, blockedContent) {
+  const commits = result.commits.map((c) => c.sha);
+  if (commits.length > 0)
+    return { status: "done", commits };
+  if (blockedContent !== undefined && blockedContent.trim().length > 0) {
+    return { status: "failed", error: `agent reported BLOCKED:
+${blockedContent.trim()}` };
+  }
+  return { status: "failed", error: "agent made no commits" };
+}
+function isWorktreeTeardownError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+  if (!BURN_WORKTREE_PATH.test(msg))
+    return false;
+  return WORKTREE_REMOVAL_FAILURES.some((p) => p.test(msg));
+}
+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 classifyTicketRunError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+  if (FATAL_ERROR_PATTERNS.some((p) => p.test(msg)))
+    return "fatal";
+  if (RETRYABLE_ERROR_PATTERNS.some((p) => p.test(msg)))
+    return "retryable";
+  return "fatal";
+}
+function retryDelayMs(attempt) {
+  return Math.min(30000, 5000 * 2 ** (attempt - 1));
+}
+function buildRetryNotes(input) {
+  const cause = input.error ? ` (${input.error})` : "";
+  const commits = input.commitCount > 0 ? `${input.commitCount} commit(s) from the previous attempt(s) are already on your branch \u2014 completed work, not noise.` : "The previous attempt had not committed anything yet, so you are effectively starting clean.";
+  return [
+    "## Recovery context \u2014 a previous attempt was interrupted",
+    "",
+    `A previous agent working THIS SAME ticket was killed by a transient infrastructure error${cause} \u2014 not by anything it did wrong, and not by a human decision. You are picking up where it left off.`,
+    "",
+    commits,
+    "",
+    "Before doing anything else, run `git log --oneline -15` and `git status` to see what was already completed. Build on that work \u2014 do NOT revert or redo existing commits. Uncommitted changes from the previous attempt were lost; only commits survived. If the ticket turns out to be fully implemented already, verify the acceptance criteria and finish normally."
+  ].join(`
+`);
+}
+function delayUnlessAborted(ms, signal) {
+  return new Promise((resolve7) => {
+    if (signal.aborted) {
+      resolve7();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve7();
+    };
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve7();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function stopTicketRun(ticketId) {
+  const controller = activeTicketAborts.get(ticketId);
+  if (!controller)
+    return false;
+  controller.abort(new Error("ticket stopped by user"));
+  return true;
+}
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  return (task) => {
+    const next = tail.then(task);
+    tail = next.catch(() => {
+      return;
+    });
+    return next;
+  };
+}
+async function landWithResolve(branch, deps) {
+  let current2 = branch;
+  for (let attempt = 1;; attempt++) {
+    const merge = await deps.merge(current2);
+    if (merge.ok)
+      return { status: "landed", branch: current2 };
+    const detail = merge.error ?? "merge failed";
+    if (!merge.conflict)
+      return { status: "failed", branch: current2, error: detail };
+    const files = merge.files ?? [];
+    if (attempt > deps.maxResolveAttempts) {
+      return { status: "conflict", branch: current2, files, error: detail };
+    }
+    const where = files.length > 0 ? `${files.length} file(s)` : "the merge";
+    deps.emit({
+      type: "merge.conflict.resolving",
+      message: `${deps.label}: conflicts with ${deps.featureBranch} on ${where} \u2014 resolving with an agent (pass ${attempt}/${deps.maxResolveAttempts})`,
+      data: { branch: current2, files, attempt, maxAttempts: deps.maxResolveAttempts }
+    });
+    const resolved = await deps.resolve({
+      branch: current2,
+      files,
+      attempt,
+      maxAttempts: deps.maxResolveAttempts
+    });
+    current2 = resolved.branch;
+    if (!resolved.ok) {
+      return { status: "conflict", branch: current2, files, error: resolved.error ?? detail };
+    }
+    deps.emit({
+      type: "merge.conflict.resolved",
+      message: `${deps.label}: conflict resolved on ${current2} \u2014 landing`,
+      data: { branch: current2, files, attempt }
+    });
+  }
+}
+function errorHeadline(s) {
+  const lines = s.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const causes = lines.filter((l) => /^(fatal|error):/i.test(l));
+  return causes.at(-1) ?? lines[0] ?? "";
+}
+async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
+  const width = Math.max(1, Math.floor(concurrency));
+  const bySeq = indexBySeq(tickets2);
+  const status = new Map(tickets2.map((t) => [t.seq, t.status]));
+  const pending = new Set(tickets2.filter((t) => t.status === "pending").map((t) => t.seq));
+  const inFlight = new Map;
+  const satisfied = (s) => s === "done" || s === "cancelled";
+  const readyState = (seq) => {
+    const t = bySeq.get(seq);
+    if (!t)
+      return "wait";
+    for (const b of t.blockedBy) {
+      const present = bySeq.has(b);
+      const bs = present ? status.get(b) : undefined;
+      if (!present || bs === "failed")
+        return { blockedBy: b, present };
+    }
+    return t.blockedBy.every((b) => satisfied(status.get(b))) ? "ready" : "wait";
+  };
+  const failTicket = (seq, error, extra) => {
+    const t = bySeq.get(seq);
+    status.set(seq, "failed");
+    if (!t)
+      return;
+    ctx.updateTicket(t.id, { status: "failed", error });
+    if (extra)
+      ctx.emitEvent({ ...extra, ticketId: t.id });
+  };
+  const runOne = async (seq) => {
     const t = bySeq.get(seq);
     if (!t)
       return;
@@ -3924,26 +4311,26 @@ function resolverTemplatePath() {
 }
 function burnerAssetPath(file) {
   const here = dirname3(fileURLToPath2(import.meta.url));
-  return join7(resolveSkillsRoot(here), "burner", file);
+  return join9(resolveSkillsRoot(here), "burner", file);
 }
 function readDocsDigestFromDisk(projectId, slug) {
   const worktree = worktreeDir(projectId, slug);
-  if (!existsSync7(worktree))
+  if (!existsSync10(worktree))
     return "_No talk worktree on disk \u2014 docs digest skipped._";
-  const docsDir = join7(worktree, ...featureDocsRel(slug).split("/"));
-  if (!existsSync7(docsDir))
+  const docsDir = join9(worktree, ...featureDocsRel(slug).split("/"));
+  if (!existsSync10(docsDir))
     return "_No docs/features dir in the talk worktree \u2014 docs digest skipped._";
-  const files = readdirSync2(docsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, content: readFileSync3(join7(docsDir, e.name), "utf8") }));
+  const files = readdirSync3(docsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, content: readFileSync4(join9(docsDir, e.name), "utf8") }));
   return buildDocsDigest(files);
 }
 function readBlockedFile(dirs) {
   for (const dir of dirs) {
     if (!dir)
       continue;
-    const p = join7(dir, "BLOCKED.md");
-    if (existsSync7(p)) {
+    const p = join9(dir, "BLOCKED.md");
+    if (existsSync10(p)) {
       try {
-        return readFileSync3(p, "utf8");
+        return readFileSync4(p, "utf8");
       } catch {}
     }
   }
@@ -3998,7 +4385,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const workspaceNotes = buildWorkspaceNotes(workspaceMode);
   const prepared = resolvePreparedSettings(config2, project);
   const verifyNotes = buildVerifyNotes(prepared);
-  const basePrompt = renderTicketPrompt(readFileSync3(burnerTemplatePath(), "utf8"), {
+  const basePrompt = renderTicketPrompt(readFileSync4(burnerTemplatePath(), "utf8"), {
     TICKET_JSON: ticketJson,
     FEATURE_BRIEF: featureBrief,
     DOCS_DIGEST: docsDigest,
@@ -4013,14 +4400,14 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   if (config2.sandbox !== "noSandbox" && pm) {
     const mount = cacheMountFor(pm, burnCacheDir(pm));
     if (mount) {
-      mkdirSync3(mount.hostPath, { recursive: true });
+      mkdirSync4(mount.hostPath, { recursive: true });
       mounts.push(mount);
     }
   }
   const guardInstall = config2.burnGuard && config2.sandbox !== "noSandbox" ? buildGuardInstallCommand() : undefined;
   const withGuard = (setup) => guardInstall === undefined ? setup : setup ? `${guardInstall} && ${setup}` : guardInstall;
-  mkdirSync3(logsDir(), { recursive: true });
-  const logFilePath = join7(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
+  mkdirSync4(logsDir(), { recursive: true });
+  const logFilePath = join9(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
   beginTranscript(ticket.id);
   const timer = createToolTimer();
@@ -4066,7 +4453,7 @@ async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, en
   const runResolver = async (input) => {
     const resolveBranch = ticketBranchName(feature.slug, ticket.seq, newId("r").slice(2, 10));
     const otherSide = await commitSummaries(project.repoPath, input.branch, feature.branch);
-    const prompt = renderTemplate2(readFileSync3(resolverTemplatePath(), "utf8"), {
+    const prompt = renderTemplate2(readFileSync4(resolverTemplatePath(), "utf8"), {
       TICKET_JSON: ticketJson,
       FEATURE_BRIEF: featureBrief,
       DOCS_DIGEST: docsDigest,
@@ -4295,1118 +4682,166 @@ ${retryNotes}` : basePrompt,
           appendTranscript(ticket.id, {
             kind: "text",
             text: `
-\u2014 attempt ${attempt} interrupted (${headline}); starting attempt ${attempt + 1}${salvaged.length > 0 ? " with committed work preserved" : ""} \u2014
-`
-          });
-          await delayUnlessAborted(retryDelayMs(attempt), signal);
-          ctx.signal.throwIfAborted();
-          if (ticketAbort.signal.aborted) {
-            if (salvaged.length > 0)
-              preserveChain(tempBranch);
-            return {
-              status: "failed",
-              error: `stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved; retry to continue from them` : ""}`,
-              event: {
-                type: "ticket.stopped",
-                message: `ticket ${ticket.seq} stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved for retry` : ""}`
-              }
-            };
-          }
-          continue;
-        }
-        if (salvaged.length > 0)
-          preserveChain(tempBranch);
-        return { status: "failed", error: msg };
-      }
-    }
-    if (!result)
-      return { status: "failed", error: "internal: run loop produced no result" };
-    const blocked = readBlockedFile([result.preservedWorktreePath, project.repoPath]);
-    const chain = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
-    let outcome;
-    if (result.commits.length === 0 && blocked !== undefined && blocked.trim().length > 0) {
-      outcome = { status: "failed", error: `agent reported BLOCKED:
-${blocked.trim()}` };
-    } else if (chain.length > 0) {
-      outcome = { status: "done", commits: chain };
-    } else {
-      outcome = interpretRunResult(result, blocked);
-    }
-    if (outcome.status !== "done") {
-      if (chain.length > 0)
-        preserveChain(tempBranch);
-      return outcome;
-    }
-    return await landChain(tempBranch, outcome.commits);
-  } finally {
-    activeTicketAborts.delete(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
-      });
-    }
-  }
-}
-function resolveBurnDeps(ctx) {
-  const config2 = loadConfig();
-  const token = readTokenFromEnvFile(envPath());
-  const model = resolveModel("implement", config2, ctx.project, ctx.modelOverride);
-  const land = createSerialQueue();
-  let pushTargetReady;
-  const ensureIsolatedPushTarget = () => pushTargetReady ??= allowPushToCheckedOutBranches(ctx.project.repoPath);
-  return {
-    config: config2,
-    hasAuthToken: token !== undefined,
-    concurrency: config2.burnConcurrency,
-    executeTicketRun: (c, ticket) => realExecuteTicketRun(c, ticket, config2, token, model, land, ensureIsolatedPushTarget)
-  };
-}
-function readTokenFromEnvFile(path) {
-  let fromFile;
-  if (existsSync7(path)) {
-    try {
-      fromFile = parseEnvFile(readFileSync3(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
-    } catch {
-      fromFile = undefined;
-    }
-  }
-  const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
-  return token && token.length > 0 ? token : undefined;
-}
-var AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
-var init_ticket_burner = __esm(() => {
-  init_src();
-  init_config_load();
-  init_paths();
-  init_skills_root();
-  init_agent_stream();
-  init_git();
-  init_burn_guard();
-  PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
-  PM_CACHE_SANDBOX_PATHS = {
-    bun: "~/.bun/install/cache",
-    yarn: "~/.cache/yarn",
-    npm: "~/.npm"
-  };
-  RUN = String.raw`(?![\w./-])`;
-  BASH_PATTERNS = [
-    ["tests", new RegExp(String.raw`\b(vitest|jest|pytest|go test|cargo test|bun test|playwright|maestro)${RUN}|\b(pnpm|npm|yarn|bun|npx)\b[^&;|]*?\s(run\s+)?test${RUN}|--testPathPatterns`)],
-    ["typecheck", /\btsc\b|\btypecheck\b|\bmypy\b|\bcargo check\b/],
-    ["build", new RegExp(String.raw`\bbuild${RUN}|\bprisma\s+(generate|migrate)\b|\bcodegen${RUN}`)],
-    ["lint", new RegExp(String.raw`\b(eslint|prettier|ruff|biome|lint|format)${RUN}`)],
-    ["install", /\b(pnpm|npm|yarn|bun|corepack)\s+\w*\s*install\b|\bnpm ci\b/],
-    ["git", /\bgit\b/],
-    ["search", /\b(grep|rg|ag|find)\b/],
-    ["file-read", /\b(cat|sed|head|tail|less|wc|ls)\b/],
-    ["file-edit", /<<\s*['"]?(PY|EOF|SH|JS|TS)\b|\bpython3?\s+-\s*<</]
-  ];
-  TOOL_NAME_CATEGORY = {
-    Read: "file-read",
-    NotebookRead: "file-read",
-    Grep: "search",
-    Glob: "search",
-    Edit: "file-edit",
-    Write: "file-edit",
-    NotebookEdit: "file-edit"
-  };
-  MAX_ATTRIBUTABLE_GAP_MS = 20 * 60000;
-  BURN_WORKTREE_PATH = /[\\/]\.sandcastle[\\/]worktrees[\\/]/i;
-  WORKTREE_REMOVAL_FAILURES = [
-    /failed to delete/i,
-    /directory not empty|enotempty/i,
-    /unable to (unlink|delete)/i,
-    /is not a working tree/i,
-    /resource busy|ebusy|eperm|eacces/i
-  ];
-  FATAL_ERROR_PATTERNS = [
-    /invalid (api key|x-api-key)/i,
-    /authentication|unauthorized|permission denied/i,
-    /credit balance|billing/i,
-    /oauth token|setup-token/i,
-    /issue with the selected model|model not found|unknown model/i,
-    /does not support resumeSession|resumeSession .* not found/i
-  ];
-  RETRYABLE_ERROR_PATTERNS = [
-    /exited with code \d+/i,
-    /idle timeout|AgentIdleTimeout/i,
-    /connection (closed|error|refused|reset)|socket hang up|fetch failed/i,
-    /econnreset|etimedout|econnrefused|epipe|eai_again/i,
-    /overloaded|rate.?limit|too many requests/i,
-    /internal server error|service unavailable|bad gateway|gateway timeout/i,
-    /\bapi error\b/i,
-    /session capture failed/i
-  ];
-  activeTicketAborts = new Map;
-  SETUP_HOOK_TIMEOUT_MS = 15 * 60000;
-  ticketBurner = {
-    id: "ticket-burner",
-    run: (ctx) => burnRun(ctx, resolveBurnDeps(ctx))
-  };
-});
-
-// src/workflows/project-prep.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { run as run2 } from "@ai-hero/sandcastle";
-import * as z3 from "zod";
-function parsePrepFindings(raw) {
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch (e) {
-    throw new Error(`findings file is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const outer = RawFindings.safeParse(json);
-  if (!outer.success)
-    throw new Error("findings file is not a JSON object");
-  const warnings = [];
-  const values = {};
-  const known = new Set(PREPARED_KEYS);
-  for (const [key, rawValue] of Object.entries(outer.data)) {
-    if (key === "notes")
-      continue;
-    if (!known.has(key)) {
-      warnings.push(`ignored unknown key "${key}"`);
-      continue;
-    }
-    const parsed = RawFinding.safeParse(rawValue);
-    if (!parsed.success) {
-      warnings.push(`ignored "${key}": not a string or {value, evidence} object`);
-      continue;
-    }
-    const entry = parsed.data;
-    const value = (typeof entry === "string" ? entry : entry.value ?? "").trim();
-    if (value === "")
-      continue;
-    const evidence = typeof entry === "string" ? undefined : entry.evidence?.trim();
-    values[key] = { value, ...evidence ? { evidence } : {} };
-  }
-  const notes = outer.data.notes?.trim();
-  return { findings: { values, ...notes ? { notes } : {} }, warnings };
-}
-function renderPrepPrompt(template, values) {
-  let out = template;
-  for (const key of PLACEHOLDERS) {
-    out = out.split(`{{${key}}}`).join(values[key]);
-  }
-  return out;
-}
-function buildRequestedKeysBlock(keys) {
-  if (keys.length === 0) {
-    return "_Everything is already established. Report an empty findings object and stop._";
-  }
-  const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
-  return [...keys].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0)).map((k) => `- ${KEY_BRIEF[k]}`).join(`
-`);
-}
-async function prepRun(ctx, deps) {
-  if (ctx.keys.length === 0) {
-    ctx.emitEvent({
-      type: "prep.skipped",
-      message: "nothing to prepare \u2014 every field is already set"
-    });
-    return { status: "succeeded", summary: "nothing to prepare" };
-  }
-  if (deps.config.sandbox !== "noSandbox" && !deps.hasAuthToken) {
-    ctx.emitEvent({ type: AUTH_MISSING_EVENT2, message: AUTH_MISSING_MESSAGE2 });
-    return { status: "failed", summary: "preparation aborted: auth token missing" };
-  }
-  ctx.emitEvent({
-    type: "prep.started",
-    message: `preparing ${ctx.project.name} \u2014 establishing ${ctx.keys.join(", ")}`,
-    data: { keys: [...ctx.keys] }
-  });
-  const outcome = await deps.executePrepRun(ctx);
-  if (outcome.status === "failed") {
-    ctx.emitEvent({
-      type: "prep.failed",
-      message: `preparation failed: ${errorHeadline2(outcome.error)}`,
-      data: { error: outcome.error }
-    });
-    return { status: "failed", summary: outcome.error };
-  }
-  for (const warning of outcome.warnings) {
-    ctx.emitEvent({ type: "prep.warning", message: `preparation: ${warning}` });
-  }
-  const found = Object.keys(outcome.findings.values);
-  const missed = ctx.keys.filter((k) => !found.includes(k));
-  const summary = found.length === 0 ? "preparation established nothing" : `established ${found.join(", ")}${missed.length > 0 ? ` (could not establish ${missed.join(", ")})` : ""}`;
-  return { status: "succeeded", summary, findings: outcome.findings };
-}
-function errorHeadline2(s) {
-  const lines = s.split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const causes = lines.filter((l) => /^(fatal|error):/i.test(l));
-  return causes.at(-1) ?? lines[0] ?? "";
-}
-function createPrepStreamThrottle(emit3, opts = {}) {
-  return createStreamThrottle((e) => emit3({ ...e, type: e.type.replace(/^burn\./, "prep.") }), opts);
-}
-function nonFatalSetup(setupCommand) {
-  return `( ${setupCommand} || true )`;
-}
-function prepTemplatePath() {
-  const here = dirname4(fileURLToPath3(import.meta.url));
-  return join8(resolveSkillsRoot(here), "burner", "prepare-project.md");
-}
-async function realExecutePrepRun(ctx, config2, token, model) {
-  const { project } = ctx;
-  const branch = prepBranchName(newId("b").slice(2, 10));
-  const toolchain = readRepoToolchain(project.repoPath);
-  const pm = detectPackageManager(toolchain);
-  const prepared = resolvePreparedSettings(config2, project);
-  const setupCommand = resolveSetupCommand(toolchain, prepared.setupCommand);
-  const workspaceMode = resolveBurnWorkspaceMode(config2);
-  const mounts = [];
-  if (config2.sandbox !== "noSandbox" && pm) {
-    const mount = cacheMountFor(pm, burnCacheDir(pm));
-    if (mount) {
-      mkdirSync4(mount.hostPath, { recursive: true });
-      mounts.push(mount);
-    }
-  }
-  const template = readFileSync4(prepTemplatePath(), "utf8");
-  const prompt = renderPrepPrompt(template, {
-    REQUESTED_KEYS: buildRequestedKeysBlock(ctx.keys),
-    SETUP_COMMAND: setupCommand ?? "(no install step detected)"
-  });
-  mkdirSync4(logsDir(), { recursive: true });
-  const logFilePath = join8(logsDir(), `prep-${project.id}.log`);
-  const throttle = createPrepStreamThrottle((e) => ctx.emitEvent(e));
-  if (setupCommand) {
-    ctx.emitEvent({
-      type: "prep.setup",
-      message: `attempting a dependency install before the agent starts (best-effort): ${setupCommand}`
-    });
-  }
-  const prepSetupCommand = setupCommand ? nonFatalSetup(setupCommand) : undefined;
-  const hookCommand = workspaceMode === "isolated" ? buildIsolatedSetupCommand(branch, prepSetupCommand, pm) : prepSetupCommand;
-  const runOptions = {
-    agent: buildBurnAgent(config2, token, model),
-    sandbox: selectSandbox(config2, mounts),
-    cwd: project.repoPath,
-    prompt,
-    branchStrategy: { type: "branch", branch, baseBranch: project.mainBranch },
-    signal: ctx.signal,
-    name: "prepare",
-    maxIterations: 1,
-    ...hookCommand ? {
-      hooks: {
-        sandbox: {
-          onSandboxReady: [{ command: hookCommand, timeoutMs: PREP_SETUP_TIMEOUT_MS }]
-        }
-      }
-    } : {},
-    logging: { type: "file", path: logFilePath, onAgentStreamEvent: throttle.onEvent }
-  };
-  try {
-    let result;
-    try {
-      result = await run2(runOptions);
-    } catch (err) {
-      throttle.flush();
-      if (ctx.signal.aborted)
-        throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      const salvaged = await readFindings(project.repoPath, branch);
-      if (!salvaged)
-        return { status: "failed", error: msg };
-      ctx.emitEvent({
-        type: "prep.salvaged",
-        message: `the agent finished but sandcastle errored on teardown (${errorHeadline2(msg)}) \u2014 reading the findings it committed anyway`
-      });
-      return salvaged;
-    }
-    throttle.flush();
-    if (result.commits.length === 0) {
-      return {
-        status: "failed",
-        error: `agent produced no commits \u2014 no ${PREP_FINDINGS_PATH} landed`
-      };
-    }
-    const read = await readFindings(project.repoPath, branch);
-    return read ?? {
-      status: "failed",
-      error: `agent committed, but ${PREP_FINDINGS_PATH} is missing from ${branch}`
-    };
-  } finally {
-    await deletePrepBranch(project.repoPath, branch);
-  }
-}
-async function readFindings(repoPath, branch) {
-  const raw = await readFileAtRef(repoPath, branch, PREP_FINDINGS_PATH);
-  if (raw === undefined)
-    return;
-  try {
-    const { findings, warnings } = parsePrepFindings(raw);
-    return { status: "done", findings, warnings };
-  } catch (e) {
-    return { status: "failed", error: e instanceof Error ? e.message : String(e) };
-  }
-}
-function resolvePrepDeps(project) {
-  const config2 = loadConfig();
-  const token = readTokenFromEnvFile(envPath());
-  const model = resolveModel("prepare", config2, project);
-  return {
-    config: config2,
-    hasAuthToken: token !== undefined,
-    executePrepRun: (c) => realExecutePrepRun(c, config2, token, model)
-  };
-}
-async function prepHeadSha(project) {
-  return existsSync8(project.repoPath) ? headSha(project.repoPath, project.mainBranch) : undefined;
-}
-var AUTH_MISSING_EVENT2 = "auth.missing", AUTH_MISSING_MESSAGE2 = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PREP_FINDINGS_PATH = ".runcastle/prep.json", PREP_SETUP_TIMEOUT_MS, RawFinding, RawFindings, PLACEHOLDERS, KEY_BRIEF;
-var init_project_prep = __esm(() => {
-  init_src();
-  init_config_load();
-  init_paths();
-  init_skills_root();
-  init_git();
-  init_ticket_burner();
-  PREP_SETUP_TIMEOUT_MS = 15 * 60000;
-  RawFinding = z3.union([
-    z3.string(),
-    z3.object({
-      value: z3.string().nullish(),
-      evidence: z3.string().nullish()
-    })
-  ]);
-  RawFindings = z3.object({ notes: z3.string().nullish() }).catchall(z3.unknown());
-  PLACEHOLDERS = ["REQUESTED_KEYS", "SETUP_COMMAND"];
-  KEY_BRIEF = {
-    setupCommand: "**`setupCommand`** \u2014 the command that takes a clean checkout to a state where the code builds and tests run: dependency install, plus any codegen or contract build that every task would otherwise discover it needed mid-flight (ORM client generation, protobuf, a `contracts:build` step). Run it and report what worked.",
-    verifyCommands: "**`verifyCommands`** \u2014 the exact typecheck / test / lint commands for this repo, one per line. In a monorepo these must include the correct workspace filter names. Run each one and confirm it executes the thing it claims to.",
-    knownFailures: '**`knownFailures`** \u2014 which tests are ALREADY failing on this checkout, before anything is changed. Run the full suite once and report the count plus the failing suite names. "0 known failures" is a real, useful answer.',
-    devCommand: "**`devCommand`** \u2014 the command that starts this project's dev server on a developer's own machine. Read it from config; do not run it here.",
-    driveSetupCommand: "**`driveSetupCommand`** \u2014 a single shell command that takes this repo from a fresh checkout to \"the dev server would actually work\": backing services up, schema applied, whatever this project needs. Chain steps with `&&`. Read it from the repo's own config (compose file, Makefile, package scripts, README); do not run it here. Omit it if the dev command alone is enough \u2014 an empty answer is better than a guessed one, because this runs on a developer's real machine.",
-    driveStopCommand: "**`driveStopCommand`** \u2014 the matching teardown for `driveSetupCommand`, if this project has one (`docker compose down`, a stop script). Read it from config; do not run it here. Omit it if setup leaves nothing that needs stopping.",
-    driveEnv: "**`driveEnv`** \u2014 `KEY=VALUE` lines (one per line) overlaid on the dev server's environment during a test drive, with `{{slug}}`, `{{branch}}` and `{{id}}` (an identifier-safe slug) rendered per drive. Its purpose is giving a branch its own database, e.g. `DATABASE_URL=postgres://localhost:5432/myapp_{{id}}` paired with a `driveSetupCommand` that creates it. Report it ONLY if you can read the real connection variable's name and shape out of the repo's own config or `.env.example`; a connection string you assembled from defaults points at the wrong database convincingly, which is worse than omitting the key. Omit it if the project has no database or you had to guess the host, port or credentials.",
-    dbResetCommand: "**`dbResetCommand`** \u2014 the command that rebuilds the dev database from the migrations currently in the working tree. Read it from config; do not run it here. Omit it entirely if this repo has no database."
-  };
-});
-
-// src/services/findings.ts
-import { and as and5, eq as eq5 } from "drizzle-orm";
-function isPreparedKey(key) {
-  return PREPARED_SET.has(key);
-}
-function findingRow(ctx, projectId, key) {
-  return ctx.db.select({
-    source: projectFindings.source,
-    evidence: projectFindings.evidence,
-    establishedAt: projectFindings.establishedAt,
-    establishedSha: projectFindings.establishedSha
-  }).from(projectFindings).where(and5(eq5(projectFindings.projectId, projectId), eq5(projectFindings.key, key))).get();
-}
-function isOverwritable(ctx, projectId, key) {
-  return findingRow(ctx, projectId, key)?.source !== "human";
-}
-function recordFinding(ctx, projectId, input) {
-  const { key, value, source, evidence, establishedSha } = input;
-  ctx.db.transaction((tx) => {
-    tx.update(projects).set({ [COLUMN_NAME[key]]: value }).where(eq5(projects.id, projectId)).run();
-    if (value === null) {
-      tx.delete(projectFindings).where(and5(eq5(projectFindings.projectId, projectId), eq5(projectFindings.key, key))).run();
-      return;
-    }
-    tx.insert(projectFindings).values({
-      projectId,
-      key,
-      source,
-      evidence: evidence ?? null,
-      establishedAt: Date.now(),
-      establishedSha: establishedSha ?? null
-    }).onConflictDoUpdate({
-      target: [projectFindings.projectId, projectFindings.key],
-      set: {
-        source,
-        evidence: evidence ?? null,
-        establishedAt: Date.now(),
-        establishedSha: establishedSha ?? null
-      }
-    }).run();
-  });
-}
-function recordHuman(ctx, projectId, key, value) {
-  if (!isPreparedKey(key))
-    return;
-  const existing = findingRow(ctx, projectId, key);
-  if (value === null) {
-    if (existing) {
-      ctx.db.delete(projectFindings).where(and5(eq5(projectFindings.projectId, projectId), eq5(projectFindings.key, key))).run();
-    }
-    return;
-  }
-  ctx.db.insert(projectFindings).values({
-    projectId,
-    key,
-    source: "human",
-    evidence: null,
-    establishedAt: Date.now(),
-    establishedSha: null
-  }).onConflictDoUpdate({
-    target: [projectFindings.projectId, projectFindings.key],
-    set: { source: "human", evidence: null, establishedAt: Date.now(), establishedSha: null }
-  }).run();
-}
-async function listFindings(ctx, project) {
-  const rows = ctx.db.select().from(projectFindings).where(eq5(projectFindings.projectId, project.id)).all();
-  const distances = new Map;
-  for (const row of rows) {
-    const sha = row.establishedSha;
-    if (!sha || distances.has(sha))
-      continue;
-    distances.set(sha, await commitsSince(project.repoPath, sha, project.mainBranch));
-  }
-  const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
-  return rows.filter((row) => isPreparedKey(row.key)).sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0)).map((row) => {
-    const staleCommits = row.establishedSha ? distances.get(row.establishedSha) : undefined;
-    return {
-      key: row.key,
-      source: row.source,
-      ...row.evidence ? { evidence: row.evidence } : {},
-      establishedAt: row.establishedAt,
-      ...row.establishedSha ? { establishedSha: row.establishedSha } : {},
-      ...staleCommits !== undefined ? { staleCommits } : {}
-    };
-  });
-}
-function unsetPreparedKeys(project) {
-  return PREPARED_KEYS.filter((key) => {
-    const value = project[key];
-    return value === undefined || value.trim() === "";
-  });
-}
-var VALUE_COLUMN, COLUMN_NAME, PREPARED_SET;
-var init_findings = __esm(() => {
-  init_src();
-  init_schema();
-  init_git();
-  VALUE_COLUMN = {
-    setupCommand: projects.setupCommand,
-    verifyCommands: projects.verifyCommands,
-    knownFailures: projects.knownFailures,
-    devCommand: projects.devCommand,
-    driveSetupCommand: projects.driveSetupCommand,
-    driveStopCommand: projects.driveStopCommand,
-    driveEnv: projects.driveEnv,
-    dbResetCommand: projects.dbResetCommand
-  };
-  COLUMN_NAME = {
-    setupCommand: "setupCommand",
-    verifyCommands: "verifyCommands",
-    knownFailures: "knownFailures",
-    devCommand: "devCommand",
-    driveSetupCommand: "driveSetupCommand",
-    driveStopCommand: "driveStopCommand",
-    driveEnv: "driveEnv",
-    dbResetCommand: "dbResetCommand"
-  };
-  PREPARED_SET = new Set(PREPARED_KEYS);
-});
-
-// src/services/prep.ts
-import { and as and6, desc as desc4, eq as eq6 } from "drizzle-orm";
-function isPreparing(projectId) {
-  return controllers.has(projectId);
-}
-function keysToPrepare(ctx, project, opts = {}) {
-  const unset = new Set(unsetPreparedKeys(project));
-  const candidates = opts.keys ?? (opts.refresh ? PREPARED_KEYS : [...unset]);
-  return candidates.filter((key) => (opts.refresh || unset.has(key)) && isOverwritable(ctx, project.id, key));
-}
-function shouldAutoPrepare(ctx, project) {
-  if (!ctx.config.autoPrepare)
-    return false;
-  if (latestPrep(ctx, project.id))
-    return false;
-  return keysToPrepare(ctx, project).length > 0;
-}
-async function startPrep(ctx, projectId, opts = {}) {
-  const project = requireProjectById(ctx, projectId);
-  if (controllers.has(projectId)) {
-    throw new InvalidInputError(`${project.name} is already being prepared`);
-  }
-  const keys = keysToPrepare(ctx, project, opts);
-  const prepId = newId("prep");
-  const headSha2 = await prepHeadSha(project);
-  ctx.db.insert(projectPreps).values({
-    id: prepId,
-    projectId,
-    status: "running",
-    startedAt: Date.now(),
-    endedAt: null,
-    summary: null,
-    headSha: headSha2 ?? null
-  }).run();
-  emitProject(ctx, projectId, {
-    type: "prep.run.started",
-    message: keys.length === 0 ? `preparing ${project.name} \u2014 nothing left to establish` : `preparing ${project.name} \u2014 ${keys.length} field(s) to establish`,
-    data: { prepId, keys }
-  });
-  const controller = new AbortController;
-  controllers.set(projectId, { runId: prepId, controller });
-  const prepCtx = {
-    project,
-    keys,
-    emitEvent: (e) => {
-      emitProject(ctx, projectId, { type: e.type, message: e.message, data: e.data });
-    },
-    signal: controller.signal
-  };
-  const deps = opts.deps ?? resolvePrepDeps(project);
-  const done = finalize(ctx, project, prepId, prepCtx, deps, controller, headSha2);
-  return { prepId, keys, done };
-}
-function cancelPrep(projectId) {
-  controllers.get(projectId)?.controller.abort();
-}
-async function finalize(ctx, project, prepId, prepCtx, deps, controller, headSha2) {
-  let status = "failed";
-  let summary = "preparation failed";
-  let findings;
-  try {
-    const result = await prepRun(prepCtx, deps);
-    status = result.status === "succeeded" ? "succeeded" : "failed";
-    summary = result.summary;
-    findings = result.findings;
-  } catch (e) {
-    if (controller.signal.aborted) {
-      status = "cancelled";
-      summary = "preparation cancelled";
-    } else {
-      status = "failed";
-      summary = e instanceof Error ? e.message : "preparation failed";
-    }
-  } finally {
-    controllers.delete(project.id);
-  }
-  const applied = findings ? applyFindings(ctx, project, findings, headSha2) : [];
-  ctx.db.update(projectPreps).set({ status, endedAt: Date.now(), summary }).where(eq6(projectPreps.id, prepId)).run();
-  emitProject(ctx, project.id, {
-    type: "prep.run.finished",
-    message: `preparation ${status}: ${summary}`,
-    data: { prepId, status, summary, applied }
-  });
-}
-function applyFindings(ctx, project, findings, headSha2) {
-  const applied = [];
-  for (const [key, finding] of Object.entries(findings.values)) {
-    if (!isOverwritable(ctx, project.id, key)) {
-      emitProject(ctx, project.id, {
-        type: "prep.skipped_field",
-        message: `kept your ${key} \u2014 preparation proposed "${truncate(finding.value)}" but you set this by hand`,
-        data: { key, proposed: finding.value }
-      });
-      continue;
-    }
-    recordFinding(ctx, project.id, {
-      key,
-      value: finding.value,
-      source: "prep",
-      ...finding.evidence ? { evidence: finding.evidence } : {},
-      ...headSha2 ? { establishedSha: headSha2 } : {}
-    });
-    applied.push(key);
-    emitProject(ctx, project.id, {
-      type: "prep.established",
-      message: `${key}: ${truncate(finding.value)}`,
-      data: { key, value: finding.value, evidence: finding.evidence }
-    });
-  }
-  if (findings.notes) {
-    emitProject(ctx, project.id, {
-      type: "prep.notes",
-      message: `preparation notes: ${findings.notes}`,
-      data: { notes: findings.notes }
-    });
-  }
-  return applied;
-}
-function truncate(value, max = 120) {
-  const oneLine = value.replace(/\s*\n\s*/g, " \xB7 ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
-}
-function latestPrep(ctx, projectId) {
-  const row = ctx.db.select().from(projectPreps).where(eq6(projectPreps.projectId, projectId)).orderBy(desc4(projectPreps.startedAt)).get();
-  if (!row)
-    return null;
-  return {
-    id: row.id,
-    projectId: row.projectId,
-    status: row.status,
-    startedAt: row.startedAt,
-    ...row.endedAt !== null ? { endedAt: row.endedAt } : {},
-    ...row.summary !== null ? { summary: row.summary } : {},
-    ...row.headSha !== null ? { headSha: row.headSha } : {}
-  };
-}
-function latestPrepNotes(ctx, projectId) {
-  const row = ctx.db.select({ data: events.data }).from(events).where(and6(eq6(events.projectId, projectId), eq6(events.type, "prep.notes"))).orderBy(desc4(events.id)).get();
-  const notes = row?.data?.notes;
-  return typeof notes === "string" && notes.trim() !== "" ? notes : undefined;
-}
-function reconcilePreps(ctx) {
-  const stale = ctx.db.select({ id: projectPreps.id, projectId: projectPreps.projectId }).from(projectPreps).where(eq6(projectPreps.status, "running")).all().filter((row) => !controllers.has(row.projectId));
-  for (const row of stale) {
-    ctx.db.update(projectPreps).set({ status: "failed", endedAt: Date.now(), summary: "server stopped while preparing" }).where(eq6(projectPreps.id, row.id)).run();
-  }
-  return stale.length;
-}
-var controllers;
-var init_prep = __esm(() => {
-  init_src();
-  init_schema();
-  init_errors();
-  init_project_prep();
-  init_events();
-  init_findings();
-  init_repo();
-  controllers = new Map;
-});
-
-// src/launcher/runtime.ts
-function setRuntimeCtx(ctx) {
-  current = ctx;
-}
-async function getRuntimeCtx() {
-  if (current)
-    return current;
-  const [{ createDb: createDb2 }, { dbPath: dbPath2 }, { loadConfig: loadConfig2 }] = await Promise.all([
-    Promise.resolve().then(() => (init_client(), exports_client)),
-    Promise.resolve().then(() => (init_paths(), exports_paths)),
-    Promise.resolve().then(() => (init_config_load(), exports_config_load))
-  ]);
-  const db = createDb2(dbPath2());
-  current = { db, config: loadConfig2() };
-  return current;
-}
-var current = null;
-
-// src/services/feature-docs.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
-function featureDocsDir(project, feature) {
-  const relSegments = featureDocsRel(feature.slug).split("/");
-  const worktree = worktreeDir(project.id, feature.slug);
-  const base = existsSync9(worktree) ? worktree : project.repoPath;
-  return join9(base, ...relSegments);
-}
-function featureDocPath(project, feature, fileName) {
-  return join9(featureDocsDir(project, feature), fileName);
-}
-var init_feature_docs = __esm(() => {
-  init_paths();
-});
-
-// src/services/tickets.ts
-import { and as and7, asc as asc3, eq as eq7 } from "drizzle-orm";
-function rowToTicket(row) {
-  return {
-    id: row.id,
-    featureId: row.featureId,
-    seq: row.seq,
-    title: row.title,
-    goal: row.goal,
-    context: row.context,
-    acceptanceCriteria: row.acceptanceCriteria,
-    seams: row.seams,
-    blockedBy: row.blockedBy,
-    lap: row.lap,
-    status: row.status,
-    commits: row.commits,
-    error: row.error ?? undefined,
-    attemptBranch: row.attemptBranch ?? undefined,
-    conflictFiles: row.conflictFiles ?? undefined
-  };
-}
-function resolveBlocking(inputs, startSeq) {
-  try {
-    return resolveBatchBlocking(inputs, { startSeq });
-  } catch (e) {
-    if (e instanceof BlockingEdgeError)
-      throw new InvalidInputError(e.message);
-    throw e;
-  }
-}
-function listByFeature2(ctx, featureId) {
-  return ctx.db.select().from(tickets).where(eq7(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
-}
-function storeTickets(ctx, featureId, inputs) {
-  if (inputs.length === 0)
-    return [];
-  const { lap } = getFeatureRow(ctx, featureId);
-  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq7(tickets.featureId, featureId)).all();
-  const startSeq = existing.reduce((max, r) => Math.max(max, r.seq), 0) + 1;
-  const resolved = resolveBlocking(inputs, startSeq);
-  const rows = inputs.map((t, i) => ({
-    id: newId("tkt"),
-    featureId,
-    seq: resolved[i].seq,
-    title: t.title,
-    goal: t.goal,
-    context: t.context,
-    acceptanceCriteria: t.acceptanceCriteria,
-    seams: t.seams,
-    blockedBy: resolved[i].blockedBy,
-    lap,
-    status: "pending",
-    commits: [],
-    error: null,
-    attemptBranch: null,
-    conflictFiles: null
-  }));
-  ctx.db.insert(tickets).values(rows).run();
-  emit(ctx, featureId, {
-    type: "tickets.stored",
-    message: `${rows.length} ticket(s) stored`,
-    data: { count: rows.length, seqs: rows.map((r) => r.seq) }
-  });
-  return rows.map(rowToTicket);
-}
-function getTicket(ctx, id) {
-  const row = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
-  if (!row)
-    throw new NotFoundError(`ticket ${id} not found`);
-  return rowToTicket(row);
-}
-function assertMutable(t, verb) {
-  if (!MUTABLE_STATUSES.has(t.status)) {
-    throw new InvalidInputError(`cannot ${verb} ticket ${t.seq} \u2014 it is ${t.status}; only pending or failed tickets can be ${verb}${verb.endsWith("l") ? "led" : "ed"}`);
-  }
-}
-function editTicket(ctx, id, patch) {
-  const current2 = getTicket(ctx, id);
-  assertMutable(current2, "edit");
-  const set = {};
-  if (patch.title !== undefined)
-    set.title = patch.title;
-  if (patch.goal !== undefined)
-    set.goal = patch.goal;
-  if (patch.context !== undefined)
-    set.context = patch.context;
-  if (patch.acceptanceCriteria !== undefined)
-    set.acceptanceCriteria = patch.acceptanceCriteria;
-  if (patch.seams !== undefined)
-    set.seams = patch.seams;
-  if (Object.keys(set).length === 0) {
-    throw new InvalidInputError("nothing to edit \u2014 pass at least one content field");
-  }
-  ctx.db.update(tickets).set(set).where(eq7(tickets.id, id)).run();
-  emit(ctx, current2.featureId, {
-    type: "ticket.edited",
-    message: `ticket ${current2.seq} content edited (${Object.keys(set).join(", ")})`,
-    ticketId: id,
-    data: { fields: Object.keys(set) }
-  });
-  return getTicket(ctx, id);
-}
-function cancelTicket(ctx, id, reason) {
-  const current2 = getTicket(ctx, id);
-  assertMutable(current2, "cancel");
-  ctx.db.update(tickets).set({ status: "cancelled", error: reason?.trim() ? reason.trim() : null }).where(eq7(tickets.id, id)).run();
-  emit(ctx, current2.featureId, {
-    type: "ticket.cancelled",
-    message: `ticket ${current2.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
-    ticketId: id,
-    data: { reason: reason ?? null }
-  });
-  return getTicket(ctx, id);
-}
-function sweepOrphanedBurning(ctx, featureId, reason) {
-  const orphaned = ctx.db.select().from(tickets).where(and7(eq7(tickets.featureId, featureId), eq7(tickets.status, "burning"))).all().map(rowToTicket);
-  for (const t of orphaned) {
-    updateTicket(ctx, t.id, { status: "failed", error: reason });
-    emit(ctx, featureId, {
-      type: "ticket.failed",
-      message: `ticket ${t.seq} failed: ${reason}`,
-      ticketId: t.id,
-      data: { error: reason, orphaned: true }
-    });
-  }
-  return orphaned.map((t) => ({ ...t, status: "failed", error: reason }));
-}
-function updateTicket(ctx, id, patch) {
-  const current2 = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
-  if (!current2)
-    throw new NotFoundError(`ticket ${id} not found`);
-  const set = {};
-  if (patch.status !== undefined)
-    set.status = patch.status;
-  if (patch.commits !== undefined)
-    set.commits = patch.commits;
-  if (patch.error !== undefined)
-    set.error = patch.error;
-  if (patch.attemptBranch !== undefined)
-    set.attemptBranch = patch.attemptBranch;
-  if (patch.conflictFiles !== undefined)
-    set.conflictFiles = patch.conflictFiles;
-  ctx.db.update(tickets).set(set).where(eq7(tickets.id, id)).run();
-  emit(ctx, current2.featureId, {
-    type: "ticket.updated",
-    message: `ticket ${current2.seq} \u2192 ${patch.status ?? current2.status}`,
-    ticketId: id,
-    data: patch
-  });
-  const updated = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
-  return rowToTicket(updated);
-}
-var MUTABLE_STATUSES;
-var init_tickets = __esm(() => {
-  init_src();
-  init_schema();
-  init_errors();
-  init_events();
-  init_repo();
-  MUTABLE_STATUSES = new Set(["pending", "failed"]);
-});
-
-// src/services/gates.ts
-import { existsSync as existsSync10 } from "fs";
-function checkGate(ctx, check, feature) {
-  switch (check) {
-    case "decisions-file-exists":
-      return fileGate(ctx, feature, "decisions.md", "run the ideation session to capture decisions first");
-    case "all-waypoints-terminal": {
-      const wps = listByFeature(ctx, feature.id);
-      if (wps.length === 0) {
-        return { satisfied: false, reason: "no waypoints charted yet \u2014 chart the map before converging" };
+\u2014 attempt ${attempt} interrupted (${headline}); starting attempt ${attempt + 1}${salvaged.length > 0 ? " with committed work preserved" : ""} \u2014
+`
+          });
+          await delayUnlessAborted(retryDelayMs(attempt), signal);
+          ctx.signal.throwIfAborted();
+          if (ticketAbort.signal.aborted) {
+            if (salvaged.length > 0)
+              preserveChain(tempBranch);
+            return {
+              status: "failed",
+              error: `stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved; retry to continue from them` : ""}`,
+              event: {
+                type: "ticket.stopped",
+                message: `ticket ${ticket.seq} stopped by user${salvaged.length > 0 ? ` \u2014 ${salvaged.length} commit(s) preserved for retry` : ""}`
+              }
+            };
+          }
+          continue;
+        }
+        if (salvaged.length > 0)
+          preserveChain(tempBranch);
+        return { status: "failed", error: msg };
       }
-      const open = wps.filter((w) => w.status !== "resolved" && w.status !== "dropped");
-      return open.length === 0 ? { satisfied: true } : {
-        satisfied: false,
-        reason: notYetTerminal("waypoint", open.map((w) => w.status), ["open", "claimed"])
-      };
     }
-    case "spec-file-exists":
-      return fileGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
-    case "tickets-approved": {
-      const count = listByFeature2(ctx, feature.id).filter((t) => t.lap === feature.lap && t.status !== "cancelled").length;
-      return count >= 1 ? { satisfied: true } : { satisfied: false, reason: "no tickets to burn" };
+    if (!result)
+      return { status: "failed", error: "internal: run loop produced no result" };
+    const blocked = readBlockedFile([result.preservedWorktreePath, project.repoPath]);
+    const chain = await branchCommitsAhead(project.repoPath, feature.branch, tempBranch);
+    let outcome;
+    if (result.commits.length === 0 && blocked !== undefined && blocked.trim().length > 0) {
+      outcome = { status: "failed", error: `agent reported BLOCKED:
+${blocked.trim()}` };
+    } else if (chain.length > 0) {
+      outcome = { status: "done", commits: chain };
+    } else {
+      outcome = interpretRunResult(result, blocked);
     }
-    case "all-tickets-terminal": {
-      const tickets2 = listByFeature2(ctx, feature.id);
-      if (tickets2.length === 0)
-        return { satisfied: false, reason: "no tickets have run yet" };
-      const open = tickets2.filter((t) => t.status !== "done" && t.status !== "failed" && t.status !== "cancelled");
-      return open.length === 0 ? { satisfied: true } : {
-        satisfied: false,
-        reason: notYetTerminal("ticket", open.map((t) => t.status), ["pending", "burning"])
-      };
+    if (outcome.status !== "done") {
+      if (chain.length > 0)
+        preserveChain(tempBranch);
+      return outcome;
+    }
+    return await landChain(tempBranch, outcome.commits);
+  } finally {
+    activeTicketAborts.delete(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
+      });
     }
-    case "human-merge":
-      return { satisfied: false, reason: "use the Merge button to ship" };
-  }
-}
-function notYetTerminal(noun, statuses, order) {
-  const counts = new Map;
-  for (const s of statuses)
-    counts.set(s, (counts.get(s) ?? 0) + 1);
-  const ordered = [
-    ...order.filter((s) => counts.has(s)),
-    ...[...counts.keys()].filter((s) => !order.includes(s))
-  ];
-  const breakdown = ordered.map((s) => `${counts.get(s)} ${s}`).join(", ");
-  return `${statuses.length} ${statuses.length === 1 ? noun : `${noun}s`} not yet terminal (${breakdown})`;
-}
-function fileGate(ctx, feature, fileName, reason) {
-  const project = projectForFeature(ctx, feature);
-  return existsSync10(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
-}
-function overrideGate(ctx, featureId, gate, reason) {
-  const feature = getFeatureRow(ctx, featureId);
-  ctx.db.insert(gateOverrides).values({ featureId, gate, reason, ts: Date.now() }).run();
-  emit(ctx, featureId, {
-    type: "gate.overridden",
-    message: `gate ${gate} overridden: ${reason}`,
-    data: { gate, reason }
-  });
-  const next = nextPhase(feature);
-  if (next)
-    return setPhase(ctx, featureId, next, "phase.advanced", `advanced to ${next} (override)`);
-  return feature;
-}
-var init_gates = __esm(() => {
-  init_src();
-  init_schema();
-  init_events();
-  init_feature_docs();
-  init_repo();
-  init_tickets();
-  init_waypoints();
-});
-
-// src/services/knowledge.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync } from "fs";
-import { join as join10, relative, resolve as resolve6, sep } from "path";
-function scaffoldDocs(ctx, feature, opts = {}) {
-  const project = projectForFeature(ctx, feature);
-  const dir = featureDocsDir(project, feature);
-  mkdirSync5(dir, { recursive: true });
-  const briefPath = featureDocPath(project, feature, "brief.md");
-  if (!existsSync11(briefPath)) {
-    const override = opts.brief?.trim();
-    const created = new Date().toISOString();
-    const brief = override ? `${override}
-` : [
-      `# ${feature.title}`,
-      "",
-      feature.oneLiner,
-      "",
-      `- Slug: ${feature.slug}`,
-      `- Created: ${created}`,
-      ""
-    ].join(`
-`);
-    writeFileSync(briefPath, brief, "utf8");
-  }
-  if (feature.mapped) {
-    scaffoldMapDoc(project, feature);
   }
-  emit(ctx, feature.id, {
-    type: "docs.scaffolded",
-    message: feature.mapped ? `scaffolded docs/features/${feature.slug}/{brief,map}.md` : `scaffolded docs/features/${feature.slug}/brief.md`
-  });
-}
-function scaffoldMapDoc(project, feature, seed) {
-  mkdirSync5(featureDocsDir(project, feature), { recursive: true });
-  const mapPath = featureDocPath(project, feature, "map.md");
-  if (existsSync11(mapPath))
-    return;
-  writeFileSync(mapPath, mapDocBody(feature, seed), "utf8");
 }
-function mapDocBody(feature, seed) {
-  const seeded = {
-    Destination: seed?.destination?.trim(),
-    Notes: seed?.notes?.trim()
+function resolveBurnDeps(ctx) {
+  const config2 = loadConfig();
+  const token = readTokenFromEnvFile(envPath());
+  const model = resolveModel("implement", config2, ctx.project, ctx.modelOverride);
+  const land = createSerialQueue();
+  let pushTargetReady;
+  const ensureIsolatedPushTarget = () => pushTargetReady ??= allowPushToCheckedOutBranches(ctx.project.repoPath);
+  return {
+    config: config2,
+    hasAuthToken: token !== undefined,
+    concurrency: config2.burnConcurrency,
+    executeTicketRun: (c, ticket) => realExecuteTicketRun(c, ticket, config2, token, model, land, ensureIsolatedPushTarget)
   };
-  const lines = [`# ${feature.title} \u2014 map`, ""];
-  for (const section of MAP_SECTIONS) {
-    lines.push(`## ${section}`, "");
-    const body = seeded[section];
-    if (body)
-      lines.push(body, "");
-  }
-  return lines.join(`
-`);
 }
-function readCharter(repoRoot) {
-  const path = join10(repoRoot, CHARTER_FILE);
-  if (!existsSync11(path))
-    return;
-  try {
-    return readFileSync5(path, "utf8");
-  } catch {
-    return;
-  }
-}
-function listLiveAdrs(repoRoot) {
-  const dir = join10(repoRoot, ADR_DIR_REL);
-  if (!existsSync11(dir))
-    return [];
-  const docs = [];
-  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-    if (!entry.isFile() || !entry.name.endsWith(".md"))
-      continue;
-    let content;
+function readTokenFromEnvFile(path) {
+  let fromFile;
+  if (existsSync10(path)) {
     try {
-      content = readFileSync5(join10(dir, entry.name), "utf8");
+      fromFile = parseEnvFile(readFileSync4(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
     } catch {
-      continue;
+      fromFile = undefined;
     }
-    if (SUPERSEDED_RE.test(content))
-      continue;
-    docs.push({ relPath: `${ADR_DIR_REL}/${entry.name}`, content });
-  }
-  return docs.sort((a, b) => a.relPath.localeCompare(b.relPath));
-}
-function listDocs(ctx, feature) {
-  const project = projectForFeature(ctx, feature);
-  const dir = featureDocsDir(project, feature);
-  if (!existsSync11(dir))
-    return [];
-  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => ({ relPath: e.name, title: readTitle(join10(dir, e.name), e.name) })).sort((a, b) => a.relPath.localeCompare(b.relPath));
-}
-function readDoc(ctx, feature, relPath) {
-  const project = projectForFeature(ctx, feature);
-  const dir = featureDocsDir(project, feature);
-  const root = resolve6(dir);
-  const target = resolve6(dir, relPath);
-  const rel = relative(root, target);
-  if (rel === "" || rel.startsWith("..") || rel.split(sep).includes("..")) {
-    throw new InvalidInputError(`doc path escapes the feature docs dir: ${relPath}`);
-  }
-  if (!existsSync11(target))
-    throw new NotFoundError(`doc not found: ${relPath}`);
-  return { content: readFileSync5(target, "utf8") };
-}
-function readTitle(path, fallback) {
-  try {
-    const firstLine = readFileSync5(path, "utf8").split(`
-`, 1)[0] ?? "";
-    const heading = firstLine.match(/^#\s+(.+)$/);
-    return heading ? heading[1].trim() : fallback;
-  } catch {
-    return fallback;
   }
+  const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  return token && token.length > 0 ? token : undefined;
 }
-var MAP_SECTIONS, CHARTER_FILE = "CONTEXT.md", ADR_DIR_REL = "docs/adr", SUPERSEDED_RE;
-var init_knowledge = __esm(() => {
-  init_errors();
-  init_events();
-  init_feature_docs();
-  init_repo();
-  MAP_SECTIONS = [
-    "Destination",
-    "Notes",
-    "Not yet specified",
-    "Out of scope"
+var AUTH_MISSING_EVENT = "auth.missing", AUTH_MISSING_MESSAGE = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
+var init_ticket_burner = __esm(() => {
+  init_src();
+  init_config_load();
+  init_paths();
+  init_skills_root();
+  init_agent_stream();
+  init_git();
+  init_burn_guard();
+  PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
+  PM_CACHE_SANDBOX_PATHS = {
+    bun: "~/.bun/install/cache",
+    yarn: "~/.cache/yarn",
+    npm: "~/.npm"
+  };
+  RUN = String.raw`(?![\w./-])`;
+  BASH_PATTERNS = [
+    ["tests", new RegExp(String.raw`\b(vitest|jest|pytest|go test|cargo test|bun test|playwright|maestro)${RUN}|\b(pnpm|npm|yarn|bun|npx)\b[^&;|]*?\s(run\s+)?test${RUN}|--testPathPatterns`)],
+    ["typecheck", /\btsc\b|\btypecheck\b|\bmypy\b|\bcargo check\b/],
+    ["build", new RegExp(String.raw`\bbuild${RUN}|\bprisma\s+(generate|migrate)\b|\bcodegen${RUN}`)],
+    ["lint", new RegExp(String.raw`\b(eslint|prettier|ruff|biome|lint|format)${RUN}`)],
+    ["install", /\b(pnpm|npm|yarn|bun|corepack)\s+\w*\s*install\b|\bnpm ci\b/],
+    ["git", /\bgit\b/],
+    ["search", /\b(grep|rg|ag|find)\b/],
+    ["file-read", /\b(cat|sed|head|tail|less|wc|ls)\b/],
+    ["file-edit", /<<\s*['"]?(PY|EOF|SH|JS|TS)\b|\bpython3?\s+-\s*<</]
+  ];
+  TOOL_NAME_CATEGORY = {
+    Read: "file-read",
+    NotebookRead: "file-read",
+    Grep: "search",
+    Glob: "search",
+    Edit: "file-edit",
+    Write: "file-edit",
+    NotebookEdit: "file-edit"
+  };
+  MAX_ATTRIBUTABLE_GAP_MS = 20 * 60000;
+  BURN_WORKTREE_PATH = /[\\/]\.sandcastle[\\/]worktrees[\\/]/i;
+  WORKTREE_REMOVAL_FAILURES = [
+    /failed to delete/i,
+    /directory not empty|enotempty/i,
+    /unable to (unlink|delete)/i,
+    /is not a working tree/i,
+    /resource busy|ebusy|eperm|eacces/i
   ];
-  SUPERSEDED_RE = /superseded by ADR-\d+/i;
-});
-
-// src/pty/end-session.ts
-function endSession(ctx, sessionId) {
-  const registry = ptyRegistry();
-  const killed = registry.kill(sessionId);
-  registry.remove(sessionId);
-  const session = markSessionEnded(ctx, sessionId);
-  if (session) {
-    releaseForSession(ctx, sessionId);
-    landProjectSession(ctx, session);
-    emitForSession(ctx, session, {
-      type: "session.ended",
-      message: "session ended by user",
-      data: { sessionId, killed }
-    });
-  } else {
-    const existing = getSessionRow(ctx, sessionId);
-    if (!existing)
-      return { sessionId, ok: false, killed };
-  }
-  return { sessionId, ok: true, killed };
-}
-var init_end_session = __esm(() => {
-  init_sessions();
-  init_events();
-  init_waypoints();
-  init_registry();
+  FATAL_ERROR_PATTERNS = [
+    /invalid (api key|x-api-key)/i,
+    /authentication|unauthorized|permission denied/i,
+    /credit balance|billing/i,
+    /oauth token|setup-token/i,
+    /issue with the selected model|model not found|unknown model/i,
+    /does not support resumeSession|resumeSession .* not found/i
+  ];
+  RETRYABLE_ERROR_PATTERNS = [
+    /exited with code \d+/i,
+    /idle timeout|AgentIdleTimeout/i,
+    /connection (closed|error|refused|reset)|socket hang up|fetch failed/i,
+    /econnreset|etimedout|econnrefused|epipe|eai_again/i,
+    /overloaded|rate.?limit|too many requests/i,
+    /internal server error|service unavailable|bad gateway|gateway timeout/i,
+    /\bapi error\b/i,
+    /session capture failed/i
+  ];
+  activeTicketAborts = new Map;
+  SETUP_HOOK_TIMEOUT_MS = 15 * 60000;
+  ticketBurner = {
+    id: "ticket-burner",
+    run: (ctx) => burnRun(ctx, resolveBurnDeps(ctx))
+  };
 });
 
 // src/workflows/research.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
-import { dirname as dirname5, join as join11 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { run as run3 } from "@ai-hero/sandcastle";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { run as run2 } from "@ai-hero/sandcastle";
 import { docker as docker2 } from "@ai-hero/sandcastle/sandboxes/docker";
 import { noSandbox as noSandbox2 } from "@ai-hero/sandcastle/sandboxes/no-sandbox";
 function waypointSlug(waypoint) {
@@ -5423,7 +4858,7 @@ async function researchRun(ctx, deps) {
     return { status: "failed", summary: "no waypoint to research" };
   }
   if (deps.config.sandbox === "docker" && !deps.hasAuthToken) {
-    ctx.emitEvent({ type: AUTH_MISSING_EVENT3, message: AUTH_MISSING_MESSAGE3 });
+    ctx.emitEvent({ type: AUTH_MISSING_EVENT2, message: AUTH_MISSING_MESSAGE2 });
     return { status: "failed", summary: "research aborted: auth token missing" };
   }
   ctx.emitEvent({
@@ -5444,12 +4879,12 @@ async function researchRun(ctx, deps) {
   }
   ctx.emitEvent({
     type: "research.failed",
-    message: `waypoint ${waypoint.seq} research failed: ${errorHeadline3(outcome.error)}`,
+    message: `waypoint ${waypoint.seq} research failed: ${errorHeadline2(outcome.error)}`,
     data: { waypointId: waypoint.id, error: outcome.error }
   });
   return { status: "failed", summary: outcome.error };
 }
-function errorHeadline3(s) {
+function errorHeadline2(s) {
   const lines = s.split(`
 `).map((l) => l.trim()).filter(Boolean);
   const causes = lines.filter((l) => /^(fatal|error):/i.test(l));
@@ -5460,7 +4895,7 @@ function createResearchStreamThrottle(emit3, opts = {}) {
 }
 function renderResearchPrompt(template, values) {
   let out = template;
-  for (const key of PLACEHOLDERS2) {
+  for (const key of PLACEHOLDERS) {
     out = out.split(`{{${key}}}`).join(values[key]);
   }
   return out;
@@ -5475,32 +4910,32 @@ function interpretResearchResult(result, docRelPath) {
   return { status: "failed", error: "agent produced no commits \u2014 no research summary landed" };
 }
 function researchTemplatePath() {
-  const here = dirname5(fileURLToPath4(import.meta.url));
-  return join11(resolveSkillsRoot(here), "burner", "research-waypoint.md");
+  const here = dirname4(fileURLToPath3(import.meta.url));
+  return join10(resolveSkillsRoot(here), "burner", "research-waypoint.md");
 }
 function readDocsDigestFromDisk2(projectId, slug) {
   const worktree = worktreeDir(projectId, slug);
-  if (!existsSync12(worktree))
+  if (!existsSync11(worktree))
     return "_No talk worktree on disk \u2014 docs digest skipped._";
-  const docsDir = join11(worktree, ...featureDocsRel(slug).split("/"));
-  if (!existsSync12(docsDir))
+  const docsDir = join10(worktree, ...featureDocsRel(slug).split("/"));
+  if (!existsSync11(docsDir))
     return "_No docs/features dir in the talk worktree \u2014 docs digest skipped._";
-  const files = readdirSync4(docsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, content: readFileSync6(join11(docsDir, e.name), "utf8") }));
+  const files = readdirSync4(docsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, content: readFileSync5(join10(docsDir, e.name), "utf8") }));
   return buildDocsDigest(files);
 }
 async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   const { project, feature } = ctx;
   const docRelPath = researchDocRel(feature.slug, waypoint);
   const tempBranch = researchBranchName(feature.slug, waypoint.seq, newId("b").slice(2, 10));
-  const template = readFileSync6(researchTemplatePath(), "utf8");
+  const template = readFileSync5(researchTemplatePath(), "utf8");
   const prompt = renderResearchPrompt(template, {
     WAYPOINT_JSON: buildWaypointJson(waypoint),
     FEATURE_BRIEF: buildFeatureBrief(feature),
     DOCS_DIGEST: readDocsDigestFromDisk2(project.id, feature.slug),
     RESEARCH_DOC_PATH: docRelPath
   });
-  mkdirSync6(logsDir(), { recursive: true });
-  const logFilePath = join11(logsDir(), `research-${feature.id}-${waypoint.seq}.log`);
+  mkdirSync5(logsDir(), { recursive: true });
+  const logFilePath = join10(logsDir(), `research-${feature.id}-${waypoint.seq}.log`);
   const throttle = createResearchStreamThrottle((e) => ctx.emitEvent(e));
   const runOptions = {
     agent: buildBurnAgent(config2, token, model),
@@ -5515,7 +4950,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   let result;
   let salvaged = [];
   try {
-    result = await run3(runOptions);
+    result = await run2(runOptions);
   } catch (err) {
     throttle.flush();
     if (ctx.signal.aborted)
@@ -5527,7 +4962,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
     const removed = await cleanupBurnWorktree(project.repoPath, tempBranch);
     ctx.emitEvent({
       type: "burn.worktree.teardown-failed",
-      message: `waypoint ${waypoint.seq}: agent finished but sandcastle could not remove its worktree (${errorHeadline3(msg)})${removed ? " \u2014 cleaned up" : " \u2014 left on disk"}; landing the ${salvaged.length} commit(s) anyway`,
+      message: `waypoint ${waypoint.seq}: agent finished but sandcastle could not remove its worktree (${errorHeadline2(msg)})${removed ? " \u2014 cleaned up" : " \u2014 left on disk"}; landing the ${salvaged.length} commit(s) anyway`,
       data: { tempBranch, error: msg, cleanedUp: removed }
     });
   }
@@ -5540,7 +4975,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
     const detail = merge.error ?? "merge failed";
     ctx.emitEvent({
       type: merge.conflict ? "merge.conflict.needs-human" : "research.merge_failed",
-      message: merge.conflict ? `research branch ${tempBranch} conflicts with ${feature.branch} \u2014 merge it manually (git merge ${tempBranch}; resolve; git branch -D ${tempBranch}), then resolve the waypoint` : `could not land ${tempBranch} on ${feature.branch}: ${errorHeadline3(detail)} \u2014 the branch is preserved for manual recovery`,
+      message: merge.conflict ? `research branch ${tempBranch} conflicts with ${feature.branch} \u2014 merge it manually (git merge ${tempBranch}; resolve; git branch -D ${tempBranch}), then resolve the waypoint` : `could not land ${tempBranch} on ${feature.branch}: ${errorHeadline2(detail)} \u2014 the branch is preserved for manual recovery`,
       data: { tempBranch, featureBranch: feature.branch, conflict: merge.conflict ?? false, error: detail }
     });
     return {
@@ -5562,9 +4997,9 @@ function resolveResearchDeps(ctx) {
 }
 function readTokenFromEnvFile2(path) {
   let fromFile;
-  if (existsSync12(path)) {
+  if (existsSync11(path)) {
     try {
-      fromFile = parseEnvFile(readFileSync6(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
+      fromFile = parseEnvFile(readFileSync5(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
     } catch {
       fromFile = undefined;
     }
@@ -5572,7 +5007,7 @@ function readTokenFromEnvFile2(path) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env.CLAUDE_CODE_OAUTH_TOKEN;
   return token && token.length > 0 ? token : undefined;
 }
-var AUTH_MISSING_EVENT3 = "auth.missing", AUTH_MISSING_MESSAGE3 = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS2, research;
+var AUTH_MISSING_EVENT2 = "auth.missing", AUTH_MISSING_MESSAGE2 = "run `claude setup-token` and put CLAUDE_CODE_OAUTH_TOKEN in ~/.runcastle/.env", PLACEHOLDERS, research;
 var init_research = __esm(() => {
   init_src();
   init_config_load();
@@ -5580,7 +5015,7 @@ var init_research = __esm(() => {
   init_skills_root();
   init_git();
   init_ticket_burner();
-  PLACEHOLDERS2 = ["WAYPOINT_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "RESEARCH_DOC_PATH"];
+  PLACEHOLDERS = ["WAYPOINT_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "RESEARCH_DOC_PATH"];
   research = {
     id: "research",
     run: (ctx) => researchRun(ctx, resolveResearchDeps(ctx))
@@ -5602,12 +5037,12 @@ var init_registry2 = __esm(() => {
 });
 
 // src/workflows/runner.ts
-import { eq as eq8 } from "drizzle-orm";
+import { eq as eq6 } from "drizzle-orm";
 function workflowClaimsFeatureBranch(workflowId) {
   return BRANCH_CLAIMING.has(workflowId);
 }
 function isRunActive(runId) {
-  return controllers2.has(runId);
+  return controllers.has(runId);
 }
 async function startRun(ctx, featureId, workflowId, opts = {}) {
   const feature = getFeatureRow(ctx, featureId);
@@ -5631,7 +5066,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(eq8(runs.id, runId)).run();
+      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq6(runs.id, runId)).run();
       throw e;
     }
   }
@@ -5642,7 +5077,7 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
     data: { workflow: workflowId }
   });
   const controller = new AbortController;
-  controllers2.set(runId, controller);
+  controllers.set(runId, controller);
   const talkWorktree = worktreeDir(project.id, feature.slug);
   const talkDetached = workflowClaimsFeatureBranch(workflowId) ? await detachWorktree(talkWorktree) : false;
   const wctx = {
@@ -5675,7 +5110,7 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
   return { runId, done };
 }
 function cancelRun(runId) {
-  controllers2.get(runId)?.abort();
+  controllers.get(runId)?.abort();
 }
 async function executeRun(ctx, runId, featureId, workflow2, runPromise, controller, cleanup) {
   let status = "failed";
@@ -5694,9 +5129,9 @@ async function executeRun(ctx, runId, featureId, workflow2, runPromise, controll
     }
     emit(ctx, featureId, { type: "run.error", message: summary, runId });
   } finally {
-    controllers2.delete(runId);
+    controllers.delete(runId);
   }
-  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary }).where(eq8(runs.id, runId)).run();
+  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary }).where(eq6(runs.id, runId)).run();
   releaseForSession(ctx, runId);
   if (workflowClaimsFeatureBranch(workflow2)) {
     sweepOrphanedBurning(ctx, featureId, `orphaned \u2014 the run ended (${status}) while it was burning`);
@@ -5726,7 +5161,7 @@ function maybeAutoAdvance(ctx, featureId) {
   if (next)
     setPhase(ctx, featureId, next, "phase.advanced", "auto-advanced to review after successful run");
 }
-var controllers2, BRANCH_CLAIMING;
+var controllers, BRANCH_CLAIMING;
 var init_runner = __esm(() => {
   init_src();
   init_paths();
@@ -5739,12 +5174,12 @@ var init_runner = __esm(() => {
   init_tickets();
   init_waypoints();
   init_registry2();
-  controllers2 = new Map;
+  controllers = new Map;
   BRANCH_CLAIMING = new Set(["ticket-burner"]);
 });
 
 // src/services/features.ts
-import { desc as desc5, eq as eq9 } from "drizzle-orm";
+import { desc as desc4, eq as eq7 } from "drizzle-orm";
 import { rmSync as rmSync2 } from "fs";
 async function createFeature(ctx, input) {
   const project = requireProjectById(ctx, input.projectId);
@@ -5868,7 +5303,7 @@ function getFeatureFull(ctx, id) {
   };
 }
 function list(ctx, projectId) {
-  const rows = ctx.db.select().from(features).where(eq9(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
+  const rows = ctx.db.select().from(features).where(eq7(features.projectId, projectId)).orderBy(desc4(features.createdAt)).all();
   return rows.map((row) => {
     const feature = rowToFeature(row);
     const tickets2 = listByFeature2(ctx, feature.id);
@@ -5956,7 +5391,7 @@ function rethink(ctx, featureId) {
     throw new GateError(`a ${live[0].kind} session is already live for ${feature.slug} \u2014 only one terminal per feature; end or resume it first`);
   }
   const lap = feature.lap + 1;
-  ctx.db.update(features).set({ lap }).where(eq9(features.id, featureId)).run();
+  ctx.db.update(features).set({ lap }).where(eq7(features.id, featureId)).run();
   return setPhase(ctx, featureId, RETHINK_LOOP_BACK.to, "lap.started", `rethink \u2014 lap ${lap}`);
 }
 async function retryTicket(ctx, ticketId, opts = {}) {
@@ -6030,7 +5465,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(eq9(features.id, featureId)).run();
+  ctx.db.update(features).set({ mapped: true }).where(eq7(features.id, featureId)).run();
   scaffoldMapDoc(project, { ...feature, mapped: true }, input);
   emit(ctx, featureId, {
     type: "feature.escalated",
@@ -6047,7 +5482,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(eq9(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: "archived" }).where(eq7(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.archived",
     message: `feature ${feature.slug} archived`,
@@ -6061,7 +5496,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(eq9(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: restored }).where(eq7(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.unarchived",
     message: `feature ${feature.slug} unarchived (${restored})`,
@@ -6075,9 +5510,9 @@ async function deleteFeature(ctx, featureId) {
     throw new GateError(`feature ${feature.slug} is shipped \u2014 archive it instead (delete is for non-shipped features)`);
   }
   const project = projectForFeature(ctx, feature);
-  for (const run4 of listRunsByFeature(ctx, featureId)) {
-    if (run4.status === "running")
-      cancelRun(run4.id);
+  for (const run3 of listRunsByFeature(ctx, featureId)) {
+    if (run3.status === "running")
+      cancelRun(run3.id);
   }
   const live = listSessionsByFeature(ctx, featureId).find((s) => s.status === "live");
   if (live)
@@ -6101,13 +5536,13 @@ async function deleteFeature(ctx, featureId) {
   return { ok: true, slug: feature.slug };
 }
 function deleteFeatureRows(ctx, featureId) {
-  ctx.db.delete(tickets).where(eq9(tickets.featureId, featureId)).run();
-  ctx.db.delete(sessions).where(eq9(sessions.featureId, featureId)).run();
-  ctx.db.delete(runs).where(eq9(runs.featureId, featureId)).run();
-  ctx.db.delete(events).where(eq9(events.featureId, featureId)).run();
-  ctx.db.delete(gateOverrides).where(eq9(gateOverrides.featureId, featureId)).run();
-  ctx.db.delete(waypoints).where(eq9(waypoints.featureId, featureId)).run();
-  ctx.db.delete(features).where(eq9(features.id, featureId)).run();
+  ctx.db.delete(tickets).where(eq7(tickets.featureId, featureId)).run();
+  ctx.db.delete(sessions).where(eq7(sessions.featureId, featureId)).run();
+  ctx.db.delete(runs).where(eq7(runs.featureId, featureId)).run();
+  ctx.db.delete(events).where(eq7(events.featureId, featureId)).run();
+  ctx.db.delete(gateOverrides).where(eq7(gateOverrides.featureId, featureId)).run();
+  ctx.db.delete(waypoints).where(eq7(waypoints.featureId, featureId)).run();
+  ctx.db.delete(features).where(eq7(features.id, featureId)).run();
 }
 function gateState(ctx, feature) {
   const gate = nextGate(feature);
@@ -6118,7 +5553,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(eq9(features.projectId, projectId)).all().map((r) => r.slug));
+  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq7(features.projectId, projectId)).all().map((r) => r.slug));
   if (!existing.has(base))
     return base;
   let n = 2;
@@ -6147,11 +5582,131 @@ var init_features = __esm(() => {
   init_runner();
 });
 
+// src/services/findings.ts
+import { and as and6, eq as eq8 } from "drizzle-orm";
+function isPreparedKey(key) {
+  return PREPARED_SET.has(key);
+}
+function findingRow(ctx, projectId, key) {
+  return ctx.db.select({
+    source: projectFindings.source,
+    evidence: projectFindings.evidence,
+    establishedAt: projectFindings.establishedAt,
+    establishedSha: projectFindings.establishedSha
+  }).from(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).get();
+}
+function isOverwritable(ctx, projectId, key) {
+  return findingRow(ctx, projectId, key)?.source !== "human";
+}
+function recordFinding(ctx, projectId, input) {
+  const { key, value, source, evidence, establishedSha } = input;
+  ctx.db.transaction((tx) => {
+    tx.update(projects).set({ [COLUMN_NAME[key]]: value }).where(eq8(projects.id, projectId)).run();
+    if (value === null) {
+      tx.delete(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).run();
+      return;
+    }
+    tx.insert(projectFindings).values({
+      projectId,
+      key,
+      source,
+      evidence: evidence ?? null,
+      establishedAt: Date.now(),
+      establishedSha: establishedSha ?? null
+    }).onConflictDoUpdate({
+      target: [projectFindings.projectId, projectFindings.key],
+      set: {
+        source,
+        evidence: evidence ?? null,
+        establishedAt: Date.now(),
+        establishedSha: establishedSha ?? null
+      }
+    }).run();
+  });
+}
+function recordHuman(ctx, projectId, key, value) {
+  if (!isPreparedKey(key))
+    return;
+  const existing = findingRow(ctx, projectId, key);
+  if (value === null) {
+    if (existing) {
+      ctx.db.delete(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).run();
+    }
+    return;
+  }
+  ctx.db.insert(projectFindings).values({
+    projectId,
+    key,
+    source: "human",
+    evidence: null,
+    establishedAt: Date.now(),
+    establishedSha: null
+  }).onConflictDoUpdate({
+    target: [projectFindings.projectId, projectFindings.key],
+    set: { source: "human", evidence: null, establishedAt: Date.now(), establishedSha: null }
+  }).run();
+}
+async function listFindings(ctx, project) {
+  const rows = ctx.db.select().from(projectFindings).where(eq8(projectFindings.projectId, project.id)).all();
+  const distances = new Map;
+  for (const row of rows) {
+    const sha = row.establishedSha;
+    if (!sha || distances.has(sha))
+      continue;
+    distances.set(sha, await commitsSince(project.repoPath, sha, project.mainBranch));
+  }
+  const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
+  return rows.filter((row) => isPreparedKey(row.key)).sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0)).map((row) => {
+    const staleCommits = row.establishedSha ? distances.get(row.establishedSha) : undefined;
+    return {
+      key: row.key,
+      source: row.source,
+      ...row.evidence ? { evidence: row.evidence } : {},
+      establishedAt: row.establishedAt,
+      ...row.establishedSha ? { establishedSha: row.establishedSha } : {},
+      ...staleCommits !== undefined ? { staleCommits } : {}
+    };
+  });
+}
+function unsetPreparedKeys(project) {
+  return PREPARED_KEYS.filter((key) => {
+    const value = project[key];
+    return value === undefined || value.trim() === "";
+  });
+}
+var VALUE_COLUMN, COLUMN_NAME, PREPARED_SET;
+var init_findings = __esm(() => {
+  init_src();
+  init_schema();
+  init_git();
+  VALUE_COLUMN = {
+    setupCommand: projects.setupCommand,
+    verifyCommands: projects.verifyCommands,
+    knownFailures: projects.knownFailures,
+    devCommand: projects.devCommand,
+    driveSetupCommand: projects.driveSetupCommand,
+    driveStopCommand: projects.driveStopCommand,
+    driveEnv: projects.driveEnv,
+    dbResetCommand: projects.dbResetCommand
+  };
+  COLUMN_NAME = {
+    setupCommand: "setupCommand",
+    verifyCommands: "verifyCommands",
+    knownFailures: "knownFailures",
+    devCommand: "devCommand",
+    driveSetupCommand: "driveSetupCommand",
+    driveStopCommand: "driveStopCommand",
+    driveEnv: "driveEnv",
+    dbResetCommand: "dbResetCommand"
+  };
+  PREPARED_SET = new Set(PREPARED_KEYS);
+});
+
 // src/mcp/server.ts
 import { StreamableHTTPTransport } from "@hono/mcp";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Hono } from "hono";
-import * as z4 from "zod";
+import * as z3 from "zod";
 function headerSessionId(extra) {
   const headers = extra.requestInfo?.headers;
   if (!headers)
@@ -6422,9 +5977,9 @@ function buildMcpServer() {
     description: "Store one established project setting from a preparation conversation. " + "Set userSupplied: true ONLY when the human gave you this value or confirmed it verbatim \u2014 " + "that marks it as theirs and stops any future automatic run from overwriting it. " + "Anything you worked out yourself must leave it false, even if they were watching. " + "Always include evidence: what you ran, or what the human told you.",
     inputSchema: {
       key: PreparedKey,
-      value: z4.string(),
-      evidence: z4.string().optional(),
-      userSupplied: z4.boolean().optional()
+      value: z3.string(),
+      evidence: z3.string().optional(),
+      userSupplied: z3.boolean().optional()
     }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
@@ -6436,11 +5991,11 @@ function buildMcpServer() {
     title: "Create a feature",
     description: "Create a feature from the project session \u2014 the end of intake. Pass `brief` with the " + "reasoning you just worked out with the human (why this feature exists, what it must NOT " + "swallow): it becomes brief.md verbatim, and without it that reasoning is lost. Pass " + "`ticket: { prose }` for a quick change \u2014 work too small to deserve a grill \u2014 which " + "creates the feature at the implementation phase with that one ticket, and whose brief.md " + "is the prose itself (so `brief` is unused there). This does NOT open " + "a terminal on what it creates; the new card in the rail is the feedback, and the human " + "decides what to work on next.",
     inputSchema: {
-      title: z4.string().min(1),
-      oneLiner: z4.string(),
-      baseBranch: z4.string().optional(),
-      brief: z4.string().optional(),
-      ticket: z4.object({ prose: z4.string().min(1) }).optional()
+      title: z3.string().min(1),
+      oneLiner: z3.string(),
+      baseBranch: z3.string().optional(),
+      brief: z3.string().optional(),
+      ticket: z3.object({ prose: z3.string().min(1) }).optional()
     }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
@@ -6461,7 +6016,7 @@ function buildMcpServer() {
   server.registerTool("get_work_record", {
     title: "Get work record",
     description: "What features actually DID \u2014 facts only: per feature its status, ship date, run " + "summaries and tickets as { seq, title, status, seams, commits, error? }. Never a " + "ticket's goal or acceptance criteria: those are intent from before the code existed. " + 'Query by `featureSlug` ("what did X do?") or by `seam` ("who has touched this area, and ' + 'what happened?") \u2014 the seam match is a case-insensitive substring, because seams are ' + "free prose that differs between features. At least one argument is required.",
-    inputSchema: { featureSlug: z4.string().optional(), seam: z4.string().optional() }
+    inputSchema: { featureSlug: z3.string().optional(), seam: z3.string().optional() }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6481,7 +6036,7 @@ function buildMcpServer() {
   server.registerTool("emit_tickets", {
     title: "Emit tickets",
     description: "Store the ideation session's ticket batch. Each ticket: title, goal, context, acceptanceCriteria[], seams[], blockedBy[] (1-based positions within THIS batch).",
-    inputSchema: { tickets: z4.array(TicketInput) }
+    inputSchema: { tickets: z3.array(TicketInput) }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6494,12 +6049,12 @@ function buildMcpServer() {
     title: "Update ticket",
     description: "Rewrite a stored ticket's content \u2014 title, goal, context, acceptanceCriteria, seams (any subset). Only pending or failed tickets can be edited; done/cancelled tickets are history and burning tickets are already running. Use during a revisit when a decision change makes a ticket stale. Get ids from get_feature_context.",
     inputSchema: {
-      id: z4.string(),
-      title: z4.string().optional(),
-      goal: z4.string().optional(),
-      context: z4.string().optional(),
-      acceptanceCriteria: z4.array(z4.string()).optional(),
-      seams: z4.array(z4.string()).optional()
+      id: z3.string(),
+      title: z3.string().optional(),
+      goal: z3.string().optional(),
+      context: z3.string().optional(),
+      acceptanceCriteria: z3.array(z3.string()).optional(),
+      seams: z3.array(z3.string()).optional()
     }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
@@ -6512,7 +6067,7 @@ function buildMcpServer() {
   server.registerTool("cancel_ticket", {
     title: "Cancel ticket",
     description: "Cancel a ticket that is no longer needed (terminal state; only pending or failed tickets). The burner skips cancelled tickets, and tickets blocked by a cancelled one still burn \u2014 cancellation counts as satisfied. Pass a short reason so the timeline explains why.",
-    inputSchema: { id: z4.string(), reason: z4.string().optional() }
+    inputSchema: { id: z3.string(), reason: z3.string().optional() }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6524,7 +6079,7 @@ function buildMcpServer() {
   server.registerTool("escalate_to_map", {
     title: "Escalate to map",
     description: "Escalate this grilling session into a map when the feature outgrows one context window. Flips the feature to mapped and scaffolds docs/features/<slug>/map.md, seeding Destination + Notes from your arguments (Not-yet-specified and Out-of-scope start empty). Idempotent: calling it on an already-mapped feature warns and changes nothing.",
-    inputSchema: { destination: z4.string(), notes: z4.string().optional() }
+    inputSchema: { destination: z3.string(), notes: z3.string().optional() }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6538,7 +6093,7 @@ function buildMcpServer() {
   server.registerTool("emit_waypoints", {
     title: "Emit waypoints",
     description: "Batch-create waypoints on the map (the feature must already be mapped \u2014 call escalate_to_map first). Each waypoint: title, type (grilling|research|prototype|task), question, blockedBy[] (1-based positions within THIS batch, and/or ids of already-stored waypoints). Available from any session once mapped \u2014 any session may branch the map.",
-    inputSchema: { waypoints: z4.array(WaypointInput) }
+    inputSchema: { waypoints: z3.array(WaypointInput) }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6548,7 +6103,7 @@ function buildMcpServer() {
   server.registerTool("resolve_waypoint", {
     title: "Resolve waypoint",
     description: "End the current waypoint: `resolved` (its question is answered) or `dropped` (no longer needed). Write the decision prose to decisions.md (or the gist to map.md Out-of-scope for a drop) FIRST \u2014 this tool flips machinery only (marks the waypoint terminal, frees any dependents on the frontier). `summary` is the one-line gist shown in the UI. Call this exactly once, as the last thing you do.",
-    inputSchema: { id: z4.string(), disposition: WaypointDisposition, summary: z4.string() }
+    inputSchema: { id: z3.string(), disposition: WaypointDisposition, summary: z3.string() }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6560,7 +6115,7 @@ function buildMcpServer() {
   server.registerTool("record_event", {
     title: "Record event",
     description: "Add a note to the timeline (decisions recorded, spec saved, milestones) \u2014 the feature's " + "timeline from a feature session, the project's from a project-scoped one.",
-    inputSchema: { type: z4.string(), message: z4.string() }
+    inputSchema: { type: z3.string(), message: z3.string() }
   }, async (args, extra) => {
     const rs = await resolveCtxSession(extra);
     if (!rs)
@@ -6680,6 +6235,27 @@ var init_ws = __esm(() => {
   };
 });
 
+// src/services/prep.ts
+function keysToPrepare(ctx, project) {
+  return unsetPreparedKeys(project).filter((key) => isOverwritable(ctx, project.id, key));
+}
+function isPrepared(ctx, project) {
+  if (keysToPrepare(ctx, project).length === 0)
+    return true;
+  return hasCompletedProjectSession(ctx, project.id, "prepare");
+}
+async function prepView(ctx, project) {
+  return {
+    pendingKeys: keysToPrepare(ctx, project),
+    findings: await listFindings(ctx, project),
+    prepared: isPrepared(ctx, project)
+  };
+}
+var init_prep = __esm(() => {
+  init_sessions();
+  init_findings();
+});
+
 // src/routes/hooks.ts
 import { Hono as Hono2 } from "hono";
 function handleSessionStart(ctx, sessionId, feature, payload) {
@@ -6900,9 +6476,9 @@ var init_stream = __esm(() => {
 });
 
 // src/routes/web.ts
-import { existsSync as existsSync13, statSync } from "fs";
+import { existsSync as existsSync12, statSync } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join12, normalize, resolve as resolve7, sep as sep2 } from "path";
+import { extname, join as join11, normalize, resolve as resolve7, sep as sep2 } from "path";
 function contentType(path) {
   return MIME[extname(path).toLowerCase()] ?? "application/octet-stream";
 }
@@ -6920,7 +6496,7 @@ function safeJoin(root, pathname) {
   } catch {
     return null;
   }
-  const joined = normalize(join12(root, decoded));
+  const joined = normalize(join11(root, decoded));
   if (joined !== root && !joined.startsWith(root + sep2))
     return null;
   return joined;
@@ -6933,7 +6509,7 @@ function resolveWebDist() {
 }
 function mountWebApp(app, distDir) {
   const root = resolve7(distDir);
-  const indexHtml = join12(root, "index.html");
+  const indexHtml = join11(root, "index.html");
   app.get("*", async (c, next) => {
     const { pathname } = new URL(c.req.url);
     if (/^\/(api|mcp|ws|health)(\/|$)/.test(pathname))
@@ -6953,7 +6529,7 @@ function mountWebApp(app, distDir) {
 }
 function mountWebAppIfBuilt(app) {
   const dist = resolveWebDist();
-  if (existsSync13(join12(dist, "index.html")))
+  if (existsSync12(join11(dist, "index.html")))
     mountWebApp(app, dist);
 }
 var MIME;
@@ -7000,14 +6576,14 @@ var init_context = __esm(() => {
 });
 
 // src/trpc/routers/docs.ts
-import * as z5 from "zod";
+import * as z4 from "zod";
 var docsRouter;
 var init_docs = __esm(() => {
   init_knowledge();
   init_repo();
   init_context();
   docsRouter = router({
-    read: publicProcedure.input(z5.object({ featureId: z5.string(), relPath: z5.string() })).query(({ ctx, input }) => {
+    read: publicProcedure.input(z4.object({ featureId: z4.string(), relPath: z4.string() })).query(({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
       return readDoc(ctx, feature, input.relPath);
     })
@@ -7015,23 +6591,23 @@ var init_docs = __esm(() => {
 });
 
 // src/trpc/routers/events.ts
-import * as z6 from "zod";
+import * as z5 from "zod";
 var eventsRouter;
 var init_events2 = __esm(() => {
   init_events();
   init_context();
   eventsRouter = router({
-    list: publicProcedure.input(z6.object({ featureId: z6.string(), afterId: z6.number().optional() })).query(({ ctx, input }) => listAfter(ctx, input.featureId, input.afterId)),
-    listByProject: publicProcedure.input(z6.object({ projectId: z6.string(), afterId: z6.number().optional() })).query(({ ctx, input }) => listByProject(ctx, input.projectId, input.afterId))
+    list: publicProcedure.input(z5.object({ featureId: z5.string(), afterId: z5.number().optional() })).query(({ ctx, input }) => listAfter(ctx, input.featureId, input.afterId)),
+    listByProject: publicProcedure.input(z5.object({ projectId: z5.string(), afterId: z5.number().optional() })).query(({ ctx, input }) => listByProject(ctx, input.projectId, input.afterId))
   });
 });
 
 // src/launcher/artifacts.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { join as join12 } from "path";
 function hookClientPath() {
-  return resolveAsset(ASSET_ENV.hookClient, fileURLToPath5(new URL("./hook-client.ts", import.meta.url)));
+  return resolveAsset(ASSET_ENV.hookClient, fileURLToPath4(new URL("./hook-client.ts", import.meta.url)));
 }
 function serverUrlFor(config2) {
   return `http://localhost:${config2.serverPort}`;
@@ -7224,7 +6800,7 @@ function renderRevisitPrompt(feature) {
 `);
 }
 function renderPreparePrompt(brief) {
-  const { project, remainingKeys, established, notes } = brief;
+  const { project, remainingKeys, established } = brief;
   return [
     `# runcastle \u2014 preparing ${project.name}`,
     "",
@@ -7234,11 +6810,10 @@ function renderPreparePrompt(brief) {
     "",
     "## Where this runs \u2014 and why that matters",
     `You are on the developer's own machine, in \`${project.repoPath}\`, NOT in a sandbox.`,
-    "A headless preparation run measures the repo in a throwaway container, which means it",
-    "can never verify anything about *this* machine: the dev server, the local database,",
-    "docker, credentials. Those keys \u2014 `devCommand`, `driveSetupCommand`, `driveStopCommand`,",
-    "`driveEnv`, `dbResetCommand` \u2014 are exactly what it has to leave as proposals.",
-    "You can actually run them. That is the point of this session.",
+    "That is the point of this session. A throwaway container can never verify anything about",
+    "*this* machine: the dev server, the local database, docker, credentials. Those keys \u2014",
+    "`devCommand`, `driveSetupCommand`, `driveStopCommand`, `driveEnv`, `dbResetCommand` \u2014",
+    "can only be settled here. Run what you propose; do not guess it from config.",
     "",
     "The same access is why you must **ask before you act**. Anything that starts or stops a",
     "service, creates or migrates a database, or writes outside the repo needs the human to",
@@ -7252,14 +6827,6 @@ function renderPreparePrompt(brief) {
       ...established.map((f) => `- \`${f.key}\` (${f.source})${f.evidence ? ` \u2014 ${f.evidence}` : ""}`),
       ""
     ] : [],
-    ...notes ? [
-      "## What the last run could not settle",
-      "Its own words. Where it says it declined to guess, it was right to \u2014 that is the",
-      "gap you are here to close, and closing it usually means asking one direct question.",
-      "",
-      notes,
-      ""
-    ] : [],
     "## Still open",
     remainingKeys.length > 0 ? remainingKeys.map((k) => `- \`${k}\``).join(`
 `) : "_Nothing is unset. Confirm the existing values still hold, then say so and stop._",
@@ -7376,10 +6943,10 @@ function renderMcpConfig(session, config2) {
 async function writeSessionArtifacts(input) {
   const { session, feature, config: config2, waypoint, prepare, projectBrief } = input;
   const dir = sessionDir(session.id);
-  mkdirSync7(dir, { recursive: true });
-  const systemPromptPath = join13(dir, "system-prompt.md");
-  const settingsPath = join13(dir, "settings.json");
-  const mcpConfigPath = join13(dir, "mcp.json");
+  mkdirSync6(dir, { recursive: true });
+  const systemPromptPath = join12(dir, "system-prompt.md");
+  const settingsPath = join12(dir, "settings.json");
+  const mcpConfigPath = join12(dir, "mcp.json");
   const systemPrompt = feature ? renderSystemPrompt(feature, session.kind, waypoint) : prepare ? renderPreparePrompt(prepare) : projectBrief ? renderProjectPrompt(projectBrief) : (() => {
     throw new Error(`session ${session.id} has no feature and no project-session brief`);
   })();
@@ -7427,10 +6994,10 @@ var init_artifacts = __esm(() => {
 });
 
 // src/launcher/launcher.ts
-import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname6, join as join14, resolve as resolve8 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { and as and8, eq as eq10 } from "drizzle-orm";
+import { existsSync as existsSync13 } from "fs";
+import { dirname as dirname5, join as join13, resolve as resolve8 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { and as and7, eq as eq9 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
   return `terminal exited (code ${label})`;
@@ -7461,23 +7028,23 @@ function resolveClaudeExecutable() {
 function claudeSpawnTarget(claudeArgs) {
   return spawnTargetFor(resolveClaudeExecutable(), claudeArgs);
 }
-function resolvePluginDir(fromDir = dirname6(fileURLToPath6(import.meta.url))) {
-  const rel = join14("packages", "skills", "packs", "runcastle");
+function resolvePluginDir(fromDir = dirname5(fileURLToPath5(import.meta.url))) {
+  const rel = join13("packages", "skills", "packs", "runcastle");
   const override = process.env[SKILLS_DIR_ENV];
   if (override) {
-    const dir2 = join14(resolve8(override), "packs", "runcastle");
-    if (existsSync14(dir2))
+    const dir2 = join13(resolve8(override), "packs", "runcastle");
+    if (existsSync13(dir2))
       return dir2;
     throw new Error(`${SKILLS_DIR_ENV}=${override} has no plugin dir at ${dir2}`);
   }
   const searched = [];
   let dir = fromDir;
   for (let i = 0;i < 8; i += 1) {
-    const candidate = join14(dir, rel);
+    const candidate = join13(dir, rel);
     searched.push(candidate);
-    if (existsSync14(candidate))
+    if (existsSync13(candidate))
       return candidate;
-    const parent = dirname6(dir);
+    const parent = dirname5(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -7487,7 +7054,7 @@ function resolvePluginDir(fromDir = dirname6(fileURLToPath6(import.meta.url))) {
   `)}`);
 }
 function activeRunFor(ctx, featureId) {
-  const row = ctx.db.select().from(runs).where(and8(eq10(runs.featureId, featureId), eq10(runs.status, "running"))).limit(1).get();
+  const row = ctx.db.select().from(runs).where(and7(eq9(runs.featureId, featureId), eq9(runs.status, "running"))).limit(1).get();
   return row ? rowToRun(row) : null;
 }
 function assertSpawnable(ctx, feature, excludeSessionId) {
@@ -7771,7 +7338,6 @@ async function launchProjectSession(ctx, input, opts = {}) {
 }
 async function buildPrepareBrief(ctx, project) {
   const findings = await listFindings(ctx, project);
-  const notes = latestPrepNotes(ctx, project.id);
   return {
     project,
     remainingKeys: keysToPrepare(ctx, project),
@@ -7779,8 +7345,7 @@ async function buildPrepareBrief(ctx, project) {
       key: f.key,
       source: f.source,
       ...f.evidence ? { evidence: f.evidence } : {}
-    })),
-    ...notes ? { notes } : {}
+    }))
   };
 }
 async function workWaypoint(ctx, input, opts = {}) {
@@ -7943,7 +7508,7 @@ var init_launcher = __esm(() => {
 });
 
 // src/trpc/routers/feature.ts
-import * as z7 from "zod";
+import * as z6 from "zod";
 var gateId, featureRouter;
 var init_feature = __esm(() => {
   init_src();
@@ -7955,30 +7520,30 @@ var init_feature = __esm(() => {
   init_git();
   init_repo();
   init_context();
-  gateId = z7.enum(["G1", "G2", "G3", "G4", "G5"]);
+  gateId = z6.enum(["G1", "G2", "G3", "G4", "G5"]);
   featureRouter = router({
-    create: publicProcedure.input(z7.object({
-      projectId: z7.string(),
-      title: z7.string().min(1),
-      oneLiner: z7.string(),
-      baseBranch: z7.string().optional()
+    create: publicProcedure.input(z6.object({
+      projectId: z6.string(),
+      title: z6.string().min(1),
+      oneLiner: z6.string(),
+      baseBranch: z6.string().optional()
     })).mutation(({ ctx, input }) => createFeature(ctx, input)),
-    quickChange: publicProcedure.input(z7.object({
-      projectId: z7.string(),
-      title: z7.string().min(1),
-      prose: z7.string().min(1),
-      baseBranch: z7.string().optional()
+    quickChange: publicProcedure.input(z6.object({
+      projectId: z6.string(),
+      title: z6.string().min(1),
+      prose: z6.string().min(1),
+      baseBranch: z6.string().optional()
     })).mutation(({ ctx, input }) => quickChange(ctx, input)),
-    list: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => list(ctx, input.projectId)),
-    get: publicProcedure.input(z7.object({ id: z7.string() })).query(({ ctx, input }) => getFeatureFull(ctx, input.id)),
-    launchSession: publicProcedure.input(z7.object({
-      featureId: z7.string(),
+    list: publicProcedure.input(z6.object({ projectId: z6.string() })).query(({ ctx, input }) => list(ctx, input.projectId)),
+    get: publicProcedure.input(z6.object({ id: z6.string() })).query(({ ctx, input }) => getFeatureFull(ctx, input.id)),
+    launchSession: publicProcedure.input(z6.object({
+      featureId: z6.string(),
       kind: SessionKind,
-      kickoffLine: z7.string().min(1).optional()
+      kickoffLine: z6.string().min(1).optional()
     })).mutation(({ ctx, input }) => launchSession(ctx, input)),
-    workWaypoint: publicProcedure.input(z7.object({ featureId: z7.string(), waypointId: z7.string(), endLive: z7.boolean().optional() })).mutation(({ ctx, input }) => workWaypoint(ctx, input)),
-    converge: publicProcedure.input(z7.object({ featureId: z7.string(), overrideReason: z7.string().min(1).optional() })).mutation(({ ctx, input }) => converge(ctx, { featureId: input.featureId, overrideReason: input.overrideReason })),
-    rethink: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => {
+    workWaypoint: publicProcedure.input(z6.object({ featureId: z6.string(), waypointId: z6.string(), endLive: z6.boolean().optional() })).mutation(({ ctx, input }) => workWaypoint(ctx, input)),
+    converge: publicProcedure.input(z6.object({ featureId: z6.string(), overrideReason: z6.string().min(1).optional() })).mutation(({ ctx, input }) => converge(ctx, { featureId: input.featureId, overrideReason: input.overrideReason })),
+    rethink: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => {
       const feature = rethink(ctx, input.featureId);
       return launchSession(ctx, {
         featureId: input.featureId,
@@ -7986,21 +7551,21 @@ var init_feature = __esm(() => {
         kickoffLine: lapKickoff(feature.lap)
       });
     }),
-    resendKickoff: publicProcedure.input(z7.object({ sessionId: z7.string() })).mutation(({ ctx, input }) => resendKickoff(ctx, input.sessionId)),
-    endSession: publicProcedure.input(z7.object({ sessionId: z7.string() })).mutation(({ ctx, input }) => endSession(ctx, input.sessionId)),
-    advance: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => advance(ctx, input.featureId)),
-    overrideGate: publicProcedure.input(z7.object({ featureId: z7.string(), gate: gateId, reason: z7.string().min(1) })).mutation(({ ctx, input }) => overrideGate(ctx, input.featureId, input.gate, input.reason)),
-    archive: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => archiveFeature(ctx, input.featureId)),
-    unarchive: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => unarchiveFeature(ctx, input.featureId)),
-    delete: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => deleteFeature(ctx, input.featureId)),
-    burn: publicProcedure.input(z7.object({ featureId: z7.string(), model: z7.string().min(1).optional() })).mutation(({ ctx, input }) => burn(ctx, input.featureId, { modelOverride: input.model })),
-    testDrive: publicProcedure.input(z7.object({ featureId: z7.string(), action: z7.enum(["start", "stop"]) })).mutation(async ({ ctx, input }) => {
+    resendKickoff: publicProcedure.input(z6.object({ sessionId: z6.string() })).mutation(({ ctx, input }) => resendKickoff(ctx, input.sessionId)),
+    endSession: publicProcedure.input(z6.object({ sessionId: z6.string() })).mutation(({ ctx, input }) => endSession(ctx, input.sessionId)),
+    advance: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => advance(ctx, input.featureId)),
+    overrideGate: publicProcedure.input(z6.object({ featureId: z6.string(), gate: gateId, reason: z6.string().min(1) })).mutation(({ ctx, input }) => overrideGate(ctx, input.featureId, input.gate, input.reason)),
+    archive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => archiveFeature(ctx, input.featureId)),
+    unarchive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => unarchiveFeature(ctx, input.featureId)),
+    delete: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => deleteFeature(ctx, input.featureId)),
+    burn: publicProcedure.input(z6.object({ featureId: z6.string(), model: z6.string().min(1).optional() })).mutation(({ ctx, input }) => burn(ctx, input.featureId, { modelOverride: input.model })),
+    testDrive: publicProcedure.input(z6.object({ featureId: z6.string(), action: z6.enum(["start", "stop"]) })).mutation(async ({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
       const project = projectForFeature(ctx, feature);
       return testDrive(ctx, project, feature, input.action);
     }),
     driveInfo: publicProcedure.query(() => activeDriveInfo()),
-    merge: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(async ({ ctx, input }) => {
+    merge: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(async ({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
       const project = projectForFeature(ctx, feature);
       if (activeTestDriveFeatureId() === feature.id) {
@@ -8023,9 +7588,9 @@ var init_feature = __esm(() => {
 });
 
 // src/services/fsbrowse.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname7, isAbsolute, join as join15, resolve as resolve9, sep as sep3 } from "path";
+import { basename, dirname as dirname6, isAbsolute, join as join14, resolve as resolve9, sep as sep3 } from "path";
 function expandPath(input, home = homedir2()) {
   const trimmed = input.trim();
   if (trimmed === "")
@@ -8034,12 +7599,12 @@ function expandPath(input, home = homedir2()) {
   if (out === "~")
     out = home;
   else if (out.startsWith("~/") || out.startsWith("~\\"))
-    out = join15(home, out.slice(2));
+    out = join14(home, out.slice(2));
   return resolve9(out);
 }
 function looksLikeRepo(dir) {
   try {
-    return existsSync15(join15(dir, ".git"));
+    return existsSync14(join14(dir, ".git"));
   } catch {
     return false;
   }
@@ -8050,20 +7615,20 @@ function listRoots(home = homedir2()) {
     for (let code = 67;code <= 90; code++) {
       const drive = `${String.fromCharCode(code)}:${sep3}`;
       try {
-        if (existsSync15(drive))
+        if (existsSync14(drive))
           roots.push({ label: drive.replace(/\\$/, ""), path: drive, kind: "drive" });
       } catch {}
     }
   } else {
     roots.push({ label: "/", path: "/", kind: "drive" });
   }
-  if (existsSync15(home))
+  if (existsSync14(home))
     roots.push({ label: "Home", path: home, kind: "home" });
   const seen = new Set(roots.map(pathKey));
   for (const name of COMMON_DIRS) {
-    const candidate = join15(home, name);
+    const candidate = join14(home, name);
     const key = pathKey({ path: candidate });
-    if (seen.has(key) || !existsSync15(candidate))
+    if (seen.has(key) || !existsSync14(candidate))
       continue;
     seen.add(key);
     roots.push({ label: name, path: candidate, kind: "common" });
@@ -8078,7 +7643,7 @@ function crumbsFor(dir) {
   let cur = dir;
   for (;; ) {
     out.unshift({ name: basename(cur) || cur, path: cur });
-    const parent = dirname7(cur);
+    const parent = dirname6(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -8086,7 +7651,7 @@ function crumbsFor(dir) {
   return out;
 }
 function parentOf(dir) {
-  const parent = dirname7(dir);
+  const parent = dirname6(dir);
   return parent === dir ? null : parent;
 }
 function browseDir(input, showHidden = false, home = homedir2()) {
@@ -8094,13 +7659,13 @@ function browseDir(input, showHidden = false, home = homedir2()) {
   if (!isAbsolute(target)) {
     throw new InvalidInputError(`path is not absolute: ${target}`);
   }
-  if (!existsSync15(target)) {
+  if (!existsSync14(target)) {
     throw new InvalidInputError(`path does not exist: ${target}`);
   }
   let dir = target;
   try {
     if (!statSync2(target).isDirectory())
-      dir = dirname7(target);
+      dir = dirname6(target);
   } catch (e) {
     throw new InvalidInputError(`cannot read path: ${target} (${errMsg2(e)})`);
   }
@@ -8122,7 +7687,7 @@ function browseDir(input, showHidden = false, home = homedir2()) {
       continue;
     if (!showHidden && name.startsWith("."))
       continue;
-    const path = join15(dir, name);
+    const path = join14(dir, name);
     const isSymlink = dirent.isSymbolicLink();
     let isDirectory = dirent.isDirectory();
     if (isSymlink) {
@@ -8157,9 +7722,9 @@ var init_fsbrowse = __esm(() => {
 });
 
 // src/services/projects.ts
-import { existsSync as existsSync16 } from "fs";
-import { basename as basename2, join as join16 } from "path";
-import { eq as eq11, isNull } from "drizzle-orm";
+import { existsSync as existsSync15 } from "fs";
+import { basename as basename2, join as join15 } from "path";
+import { eq as eq10, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
 }
@@ -8181,14 +7746,13 @@ async function openProject(ctx, rawPath) {
   const name = basename2(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
-    ctx.db.update(projects).set({ mainBranch, repoPath, closedAt: null }).where(eq11(projects.id, existing.id)).run();
+    ctx.db.update(projects).set({ mainBranch, repoPath, closedAt: null }).where(eq10(projects.id, existing.id)).run();
     const reopened = { ...existing, mainBranch, repoPath };
     emitProject(ctx, existing.id, {
       type: "project.opened",
       message: `project ${existing.name} re-opened at ${repoPath} (${mainBranch})`
     });
     warnIfTranslatedMount(ctx, existing.id, repoPath);
-    maybeAutoPrepare(ctx, reopened);
     return reopened;
   }
   const row = {
@@ -8206,25 +7770,14 @@ async function openProject(ctx, rawPath) {
     message: `project ${name} at ${repoPath} (${mainBranch})`
   });
   warnIfTranslatedMount(ctx, project.id, repoPath);
-  maybeAutoPrepare(ctx, project);
   return project;
 }
-function maybeAutoPrepare(ctx, project) {
-  if (!shouldAutoPrepare(ctx, project))
-    return;
-  startPrep(ctx, project.id).catch((e) => {
-    emitProject(ctx, project.id, {
-      type: "prep.run.failed",
-      message: `could not start preparation: ${e instanceof Error ? e.message : String(e)}`
-    });
-  });
-}
 function closeProject(ctx, projectId) {
   const project = requireProjectById(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(eq11(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq10(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.closed",
     message: `project ${project.name} closed`
@@ -8233,7 +7786,7 @@ function closeProject(ctx, projectId) {
 }
 function renameProject(ctx, projectId, name) {
   const project = requireProjectById(ctx, projectId);
-  ctx.db.update(projects).set({ name }).where(eq11(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ name }).where(eq10(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.renamed",
     message: `project renamed ${project.name} \u2192 ${name}`,
@@ -8251,7 +7804,7 @@ async function assertRepoTolerant(ctx, repoPath) {
   } catch (e) {
     if (!isNotImplemented(e))
       throw e;
-    if (!existsSync16(join16(repoPath, ".git"))) {
+    if (!existsSync15(join15(repoPath, ".git"))) {
       throw new InvalidInputError(`not a git repository: ${repoPath}`);
     }
   }
@@ -8272,16 +7825,13 @@ var init_projects = __esm(() => {
   init_events();
   init_fsbrowse();
   init_git();
-  init_prep();
   init_repo();
 });
 
 // src/trpc/routers/project.ts
-import * as z8 from "zod";
+import * as z7 from "zod";
 var projectRouter;
 var init_project = __esm(() => {
-  init_src();
-  init_findings();
   init_fsbrowse();
   init_git();
   init_prep();
@@ -8293,44 +7843,21 @@ var init_project = __esm(() => {
   projectRouter = router({
     list: publicProcedure.query(({ ctx }) => listProjects(ctx)),
     roots: publicProcedure.query(() => listRoots()),
-    browse: publicProcedure.input(z8.object({ dir: z8.string().optional(), showHidden: z8.boolean().optional() }).optional()).query(({ input }) => browseDir(input?.dir, input?.showHidden ?? false)),
-    branches: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId))),
-    open: publicProcedure.input(z8.object({ repoPath: z8.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
-    close: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
-    rename: publicProcedure.input(z8.object({ projectId: z8.string(), name: z8.string().min(1) })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name)),
-    prepare: publicProcedure.input(z8.object({
-      projectId: z8.string(),
-      refresh: z8.boolean().optional(),
-      keys: z8.array(PreparedKey).optional()
-    })).mutation(async ({ ctx, input }) => {
-      const { prepId, keys } = await startPrep(ctx, input.projectId, {
-        ...input.refresh !== undefined ? { refresh: input.refresh } : {},
-        ...input.keys ? { keys: input.keys } : {}
-      });
-      return { prepId, keys };
-    }),
-    talkToPrep: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ ctx, input }) => launchPrepareSession(ctx, { projectId: input.projectId })),
-    prepSession: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "prepare")),
-    talkToProject: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ ctx, input }) => launchProjectSession(ctx, { projectId: input.projectId })),
-    projectSession: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "project")),
-    cancelPrepare: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ input }) => {
-      cancelPrep(input.projectId);
-      return { ok: true };
-    }),
-    prep: publicProcedure.input(z8.object({ projectId: z8.string() })).query(async ({ ctx, input }) => {
-      const project = requireProjectById(ctx, input.projectId);
-      return {
-        latest: latestPrep(ctx, project.id),
-        running: isPreparing(project.id),
-        pendingKeys: keysToPrepare(ctx, project),
-        findings: await listFindings(ctx, project)
-      };
-    })
+    browse: publicProcedure.input(z7.object({ dir: z7.string().optional(), showHidden: z7.boolean().optional() }).optional()).query(({ input }) => browseDir(input?.dir, input?.showHidden ?? false)),
+    branches: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId))),
+    open: publicProcedure.input(z7.object({ repoPath: z7.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
+    close: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
+    rename: publicProcedure.input(z7.object({ projectId: z7.string(), name: z7.string().min(1) })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name)),
+    talkToPrep: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => launchPrepareSession(ctx, { projectId: input.projectId })),
+    prepSession: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "prepare")),
+    talkToProject: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => launchProjectSession(ctx, { projectId: input.projectId })),
+    projectSession: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "project")),
+    prep: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => prepView(ctx, requireProjectById(ctx, input.projectId)))
   });
 });
 
 // src/trpc/routers/run.ts
-import * as z9 from "zod";
+import * as z8 from "zod";
 var runRouter;
 var init_run = __esm(() => {
   init_agent_stream();
@@ -8338,9 +7865,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(({ input }) => {
+    get: publicProcedure.input(z8.object({ runId: z8.string() })).query(({ ctx, input }) => getRunRow(ctx, input.runId)),
+    agentTranscript: publicProcedure.input(z8.object({ ticketId: z8.string(), after: z8.number().int().optional() })).query(({ input }) => readTranscript(input.ticketId, input.after ?? -1)),
+    cancel: publicProcedure.input(z8.object({ runId: z8.string() })).mutation(({ input }) => {
       cancelRun(input.runId);
       return { ok: true };
     })
@@ -8348,15 +7875,15 @@ var init_run = __esm(() => {
 });
 
 // src/services/settings.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname8 } from "path";
-import * as z10 from "zod";
-import { eq as eq12 } from "drizzle-orm";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7 } from "path";
+import * as z9 from "zod";
+import { eq as eq11 } from "drizzle-orm";
 function readRawConfig(configFile) {
-  if (!existsSync17(configFile))
+  if (!existsSync16(configFile))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync7(configFile, "utf8"));
+    const parsed = JSON.parse(readFileSync6(configFile, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return {};
     return foldLegacyModelConfig(parsed);
@@ -8391,7 +7918,7 @@ function projectOverrides(ctx, projectId) {
     driveSetupCommand: projects.driveSetupCommand,
     driveStopCommand: projects.driveStopCommand,
     driveEnv: projects.driveEnv
-  }).from(projects).where(eq12(projects.id, projectId)).get();
+  }).from(projects).where(eq11(projects.id, projectId)).get();
   return {
     model: row?.model ?? null,
     sandbox: row?.sandbox ?? null,
@@ -8405,26 +7932,26 @@ function projectOverrides(ctx, projectId) {
     driveEnv: row?.driveEnv ?? null
   };
 }
-function resolveField(desc6, layers) {
+function resolveField(desc5, layers) {
   const scoped = layers.overrides !== null;
-  const scope = scoped && desc6.projectColumn ? "project" : "global";
-  const base = { key: desc6.key, restartRequired: desc6.restartRequired, scope };
-  if (desc6.envVar) {
-    const raw = layers.env[desc6.envVar];
+  const scope = scoped && desc5.projectColumn ? "project" : "global";
+  const base = { key: desc5.key, restartRequired: desc5.restartRequired, scope };
+  if (desc5.envVar) {
+    const raw = layers.env[desc5.envVar];
     if (raw !== undefined && raw !== "") {
-      return { ...base, value: desc6.parseEnv(raw), source: "env", editable: false };
+      return { ...base, value: desc5.parseEnv(raw), source: "env", editable: false };
     }
   }
-  if (layers.overrides && desc6.projectColumn) {
-    const ov = layers.overrides[desc6.projectColumn];
+  if (layers.overrides && desc5.projectColumn) {
+    const ov = layers.overrides[desc5.projectColumn];
     if (ov !== null && ov !== "") {
       return { ...base, value: ov, source: "project", editable: true };
     }
   }
-  if (desc6.configKey && Object.prototype.hasOwnProperty.call(layers.fileRaw, desc6.configKey)) {
-    return { ...base, value: layers.fileRaw[desc6.configKey], source: "file", editable: true };
+  if (desc5.configKey && Object.prototype.hasOwnProperty.call(layers.fileRaw, desc5.configKey)) {
+    return { ...base, value: layers.fileRaw[desc5.configKey], source: "file", editable: true };
   }
-  const value = desc6.configKey ? DEFAULTS[desc6.configKey] ?? null : null;
+  const value = desc5.configKey ? DEFAULTS[desc5.configKey] ?? null : null;
   return { ...base, value, source: "default", editable: true };
 }
 function getSettings(ctx, projectId, io = {}) {
@@ -8441,61 +7968,61 @@ function updateSettings(ctx, input, io = {}) {
   if (input.key.startsWith("stepModels.")) {
     return updateStepModel(ctx, input, configFile, io);
   }
-  const desc6 = DESCRIPTORS.find((d) => d.key === input.key);
-  if (!desc6)
+  const desc5 = DESCRIPTORS.find((d) => d.key === input.key);
+  if (!desc5)
     throw new InvalidInputError(`unknown setting: ${input.key}`);
-  if (desc6.envVar) {
-    const raw = env[desc6.envVar];
+  if (desc5.envVar) {
+    const raw = env[desc5.envVar];
     if (raw !== undefined && raw !== "") {
-      throw new InvalidInputError(`${desc6.key} is set by environment variable ${desc6.envVar}; unset it to edit`);
+      throw new InvalidInputError(`${desc5.key} is set by environment variable ${desc5.envVar}; unset it to edit`);
     }
   }
-  const toProject = input.projectId !== undefined && desc6.projectColumn !== undefined;
+  const toProject = input.projectId !== undefined && desc5.projectColumn !== undefined;
   if (input.value === null) {
     if (!toProject)
-      throw new InvalidInputError(`${desc6.key} cannot be cleared`);
+      throw new InvalidInputError(`${desc5.key} cannot be cleared`);
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc6.projectColumn]: null }).where(eq12(projects.id, project.id)).run();
-    recordHuman(ctx, project.id, desc6.key, null);
+    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq11(projects.id, project.id)).run();
+    recordHuman(ctx, project.id, desc5.key, null);
     emitProject(ctx, project.id, {
       type: "settings.updated",
-      message: `${desc6.key} override cleared`,
-      data: { key: desc6.key, scope: "project", value: null }
+      message: `${desc5.key} override cleared`,
+      data: { key: desc5.key, scope: "project", value: null }
     });
-    return field(getSettings(ctx, input.projectId, io), desc6.key);
+    return field(getSettings(ctx, input.projectId, io), desc5.key);
   }
-  const parsed = desc6.valueSchema.safeParse(input.value);
+  const parsed = desc5.valueSchema.safeParse(input.value);
   if (!parsed.success) {
-    throw new InvalidInputError(`invalid value for ${desc6.key}: ${parsed.error.issues[0]?.message}`);
+    throw new InvalidInputError(`invalid value for ${desc5.key}: ${parsed.error.issues[0]?.message}`);
   }
   const value = parsed.data;
   if (toProject) {
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc6.projectColumn]: String(value) }).where(eq12(projects.id, project.id)).run();
-    recordHuman(ctx, project.id, desc6.key, String(value));
+    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq11(projects.id, project.id)).run();
+    recordHuman(ctx, project.id, desc5.key, String(value));
     emitProject(ctx, project.id, {
       type: "settings.updated",
-      message: `${desc6.key} override set to ${String(value)}`,
-      data: { key: desc6.key, scope: "project", value }
+      message: `${desc5.key} override set to ${String(value)}`,
+      data: { key: desc5.key, scope: "project", value }
     });
-    return field(getSettings(ctx, input.projectId, io), desc6.key);
+    return field(getSettings(ctx, input.projectId, io), desc5.key);
   }
-  if (!desc6.configKey) {
-    throw new InvalidInputError(`${desc6.key} is a per-project setting; provide a projectId`);
+  if (!desc5.configKey) {
+    throw new InvalidInputError(`${desc5.key} is a per-project setting; provide a projectId`);
   }
-  writeGlobal(configFile, desc6.configKey, value);
-  ctx.config[desc6.configKey] = value;
+  writeGlobal(configFile, desc5.configKey, value);
+  ctx.config[desc5.configKey] = value;
   emitProject(ctx, GLOBAL_EVENT_KEY, {
     type: "settings.updated",
-    message: `${desc6.key} set to ${String(value)}`,
-    data: { key: desc6.key, scope: "global", value }
+    message: `${desc5.key} set to ${String(value)}`,
+    data: { key: desc5.key, scope: "global", value }
   });
-  return field(getSettings(ctx, input.projectId, io), desc6.key);
+  return field(getSettings(ctx, input.projectId, io), desc5.key);
 }
 function writeGlobal(configFile, configKey, value) {
   const raw = readRawConfig(configFile);
   raw[configKey] = value;
-  mkdirSync8(dirname8(configFile), { recursive: true });
+  mkdirSync7(dirname7(configFile), { recursive: true });
   writeFileSync3(configFile, `${JSON.stringify(raw, null, 2)}
 `);
 }
@@ -8506,7 +8033,7 @@ function updateStepModel(ctx, input, configFile, io) {
   const modelStep = step;
   let value = null;
   if (input.value !== null) {
-    const parsed = z10.string().min(1).safeParse(input.value);
+    const parsed = z9.string().min(1).safeParse(input.value);
     if (!parsed.success) {
       throw new InvalidInputError(`invalid value for ${input.key}: ${parsed.error.issues[0]?.message}`);
     }
@@ -8534,7 +8061,7 @@ function writeStepModel(configFile, step, value) {
   else
     stepModels[step] = value;
   raw.stepModels = stepModels;
-  mkdirSync8(dirname8(configFile), { recursive: true });
+  mkdirSync7(dirname7(configFile), { recursive: true });
   writeFileSync3(configFile, `${JSON.stringify(raw, null, 2)}
 `);
 }
@@ -8559,7 +8086,7 @@ var init_settings = __esm(() => {
       configKey: "serverPort",
       envVar: "RUNCASTLE_SERVER_PORT",
       restartRequired: true,
-      valueSchema: z10.number().int().positive(),
+      valueSchema: z9.number().int().positive(),
       parseEnv: (raw) => Number(raw)
     },
     {
@@ -8568,7 +8095,7 @@ var init_settings = __esm(() => {
       envVar: "RUNCASTLE_MODEL",
       projectColumn: "model",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
@@ -8577,7 +8104,7 @@ var init_settings = __esm(() => {
       envVar: "RUNCASTLE_SANDBOX",
       projectColumn: "sandbox",
       restartRequired: false,
-      valueSchema: z10.enum(["docker", "podman", "noSandbox"]),
+      valueSchema: z9.enum(["docker", "podman", "noSandbox"]),
       parseEnv: idEnv
     },
     {
@@ -8585,7 +8112,7 @@ var init_settings = __esm(() => {
       configKey: "sandboxImage",
       envVar: "RUNCASTLE_SANDBOX_IMAGE",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
@@ -8593,7 +8120,7 @@ var init_settings = __esm(() => {
       configKey: "sessionMcp",
       envVar: "RUNCASTLE_SESSION_MCP",
       restartRequired: false,
-      valueSchema: z10.enum(["inherit", "runcastleOnly"]),
+      valueSchema: z9.enum(["inherit", "runcastleOnly"]),
       parseEnv: idEnv
     },
     {
@@ -8601,7 +8128,7 @@ var init_settings = __esm(() => {
       configKey: "burnConcurrency",
       envVar: "RUNCASTLE_BURN_CONCURRENCY",
       restartRequired: false,
-      valueSchema: z10.number().int().min(1).max(8),
+      valueSchema: z9.number().int().min(1).max(8),
       parseEnv: (raw) => Number(raw)
     },
     {
@@ -8609,7 +8136,7 @@ var init_settings = __esm(() => {
       configKey: "burnMaxIterations",
       envVar: "RUNCASTLE_BURN_MAX_ITERATIONS",
       restartRequired: false,
-      valueSchema: z10.number().int().min(1).max(10),
+      valueSchema: z9.number().int().min(1).max(10),
       parseEnv: (raw) => Number(raw)
     },
     {
@@ -8617,7 +8144,7 @@ var init_settings = __esm(() => {
       configKey: "burnAttempts",
       envVar: "RUNCASTLE_BURN_ATTEMPTS",
       restartRequired: false,
-      valueSchema: z10.number().int().min(1).max(5),
+      valueSchema: z9.number().int().min(1).max(5),
       parseEnv: (raw) => Number(raw)
     },
     {
@@ -8625,7 +8152,7 @@ var init_settings = __esm(() => {
       configKey: "burnConflictAttempts",
       envVar: "RUNCASTLE_BURN_CONFLICT_ATTEMPTS",
       restartRequired: false,
-      valueSchema: z10.number().int().min(0).max(3),
+      valueSchema: z9.number().int().min(0).max(3),
       parseEnv: (raw) => Number(raw)
     },
     {
@@ -8633,24 +8160,16 @@ var init_settings = __esm(() => {
       configKey: "burnCpus",
       envVar: "RUNCASTLE_BURN_CPUS",
       restartRequired: false,
-      valueSchema: z10.number().positive().max(256),
+      valueSchema: z9.number().positive().max(256),
       parseEnv: (raw) => Number(raw)
     },
-    {
-      key: "autoPrepare",
-      configKey: "autoPrepare",
-      envVar: "RUNCASTLE_AUTO_PREPARE",
-      restartRequired: false,
-      valueSchema: z10.boolean(),
-      parseEnv: (raw) => raw !== "0" && raw.toLowerCase() !== "false"
-    },
     {
       key: "setupCommand",
       configKey: "setupCommand",
       envVar: "RUNCASTLE_SETUP_COMMAND",
       projectColumn: "setupCommand",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
@@ -8659,7 +8178,7 @@ var init_settings = __esm(() => {
       envVar: "RUNCASTLE_VERIFY_COMMANDS",
       projectColumn: "verifyCommands",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
@@ -8668,7 +8187,7 @@ var init_settings = __esm(() => {
       envVar: "RUNCASTLE_KNOWN_FAILURES",
       projectColumn: "knownFailures",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
@@ -8676,42 +8195,42 @@ var init_settings = __esm(() => {
       configKey: "mainBranch",
       envVar: "RUNCASTLE_MAIN_BRANCH",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
       key: "devCommand",
       projectColumn: "devCommand",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
       key: "dbResetCommand",
       projectColumn: "dbResetCommand",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
       key: "driveSetupCommand",
       projectColumn: "driveSetupCommand",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
       key: "driveStopCommand",
       projectColumn: "driveStopCommand",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     },
     {
       key: "driveEnv",
       projectColumn: "driveEnv",
       restartRequired: false,
-      valueSchema: z10.string().min(1),
+      valueSchema: z9.string().min(1),
       parseEnv: idEnv
     }
   ];
@@ -8720,14 +8239,14 @@ var init_settings = __esm(() => {
 });
 
 // src/trpc/routers/settings.ts
-import * as z11 from "zod";
+import * as z10 from "zod";
 var settingsRouter;
 var init_settings2 = __esm(() => {
   init_src();
   init_settings();
   init_context();
   settingsRouter = router({
-    get: publicProcedure.input(z11.object({ projectId: z11.string().optional() }).optional()).query(({ ctx, input }) => getSettings(ctx, input?.projectId)),
+    get: publicProcedure.input(z10.object({ projectId: z10.string().optional() }).optional()).query(({ ctx, input }) => getSettings(ctx, input?.projectId)),
     update: publicProcedure.input(SettingsUpdateInput).mutation(({ ctx, input }) => updateSettings(ctx, input))
   });
 });
@@ -8920,9 +8439,9 @@ var init_system_exec = __esm(() => {
 });
 
 // src/services/setup.ts
-import { copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync8, readdirSync as readdirSync6, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname9, join as join17 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { copyFileSync, existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync7, readdirSync as readdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname8, join as join16 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 async function writeGitIdentity(exec, identity) {
   const name = identity.name.trim();
   const email = identity.email.trim();
@@ -8997,16 +8516,16 @@ async function resolveRuntime(exec, preferred) {
 function resolveSandcastleBin() {
   try {
     const mainUrl = import.meta.resolve("@ai-hero/sandcastle");
-    let dir = dirname9(fileURLToPath7(mainUrl));
+    let dir = dirname8(fileURLToPath6(mainUrl));
     for (let hops = 0;hops < 6; hops++) {
-      const manifestPath = join17(dir, "package.json");
-      if (existsSync18(manifestPath)) {
-        const manifest = JSON.parse(readFileSync8(manifestPath, "utf8"));
+      const manifestPath = join16(dir, "package.json");
+      if (existsSync17(manifestPath)) {
+        const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
         if (manifest.name === "@ai-hero/sandcastle" && manifest.bin?.sandcastle) {
-          return join17(dir, manifest.bin.sandcastle);
+          return join16(dir, manifest.bin.sandcastle);
         }
       }
-      const parent = dirname9(dir);
+      const parent = dirname8(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -9028,21 +8547,21 @@ function terminalSpec(kind, opts) {
   };
 }
 function sandcastleTemplateDir() {
-  return resolveAsset(ASSET_ENV.sandcastleTemplate, fileURLToPath7(new URL("../assets/sandcastle", import.meta.url)));
+  return resolveAsset(ASSET_ENV.sandcastleTemplate, fileURLToPath6(new URL("../assets/sandcastle", import.meta.url)));
 }
 function scaffoldSandcastleConfig(templateDir, targetDir) {
-  const dir = join17(targetDir, ".sandcastle");
-  if (existsSync18(dir))
+  const dir = join16(targetDir, ".sandcastle");
+  if (existsSync17(dir))
     return { scaffolded: false, dir };
-  mkdirSync9(dir, { recursive: true });
+  mkdirSync8(dir, { recursive: true });
   for (const name of readdirSync6(templateDir)) {
-    copyFileSync(join17(templateDir, name), join17(dir, name));
+    copyFileSync(join16(templateDir, name), join16(dir, name));
   }
   return { scaffolded: true, dir };
 }
 function prepareSandboxBuildContext() {
   const target = sandboxBuildDir();
-  mkdirSync9(target, { recursive: true });
+  mkdirSync8(target, { recursive: true });
   scaffoldSandcastleConfig(sandcastleTemplateDir(), target);
   return target;
 }
@@ -9078,9 +8597,9 @@ function createTokenVerifier(exec) {
 function fileAfkTokenIo(exec) {
   const path = envPath();
   return {
-    read: () => existsSync18(path) ? readFileSync8(path, "utf8") : "",
+    read: () => existsSync17(path) ? readFileSync7(path, "utf8") : "",
     write: (content) => {
-      mkdirSync9(dirname9(path), { recursive: true });
+      mkdirSync8(dirname8(path), { recursive: true });
       writeFileSync4(path, content, "utf8");
     },
     verify: createTokenVerifier(exec)
@@ -9095,7 +8614,7 @@ var init_setup = __esm(() => {
 });
 
 // src/trpc/routers/setup.ts
-import * as z12 from "zod";
+import * as z11 from "zod";
 var setupRouter;
 var init_setup2 = __esm(() => {
   init_src();
@@ -9111,9 +8630,9 @@ var init_setup2 = __esm(() => {
       ...ctx.config.sandboxImage ? { imageName: ctx.config.sandboxImage } : {}
     })),
     runtimeGuide: publicProcedure.query(() => runtimeInstallGuide(process.platform)),
-    gitIdentity: publicProcedure.input(z12.object({ name: z12.string(), email: z12.string() })).mutation(({ input }) => writeGitIdentity(createSystemExec(), input)),
-    afkToken: publicProcedure.input(z12.object({ token: z12.string() })).mutation(({ input }) => saveAfkToken(fileAfkTokenIo(createSystemExec()), input.token)),
-    startTerminal: publicProcedure.input(z12.object({ kind: z12.enum(["setup-token", "build-image"]) })).mutation(async ({ ctx, input }) => {
+    gitIdentity: publicProcedure.input(z11.object({ name: z11.string(), email: z11.string() })).mutation(({ input }) => writeGitIdentity(createSystemExec(), input)),
+    afkToken: publicProcedure.input(z11.object({ token: z11.string() })).mutation(({ input }) => saveAfkToken(fileAfkTokenIo(createSystemExec()), input.token)),
+    startTerminal: publicProcedure.input(z11.object({ kind: z11.enum(["setup-token", "build-image"]) })).mutation(async ({ ctx, input }) => {
       const exec = createSystemExec();
       const preferred = ctx.config.sandbox === "podman" ? "podman" : "docker";
       const runtime = await resolveRuntime(exec, preferred);
@@ -9213,16 +8732,16 @@ var init_update_check = __esm(() => {
 });
 
 // src/version.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname10, join as join18 } from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
+import { readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname9, join as join17 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 function runcastleVersion() {
   if (cached2)
     return cached2;
-  const here = dirname10(fileURLToPath8(import.meta.url));
-  for (const pkgPath of [join18(here, "..", "package.json"), join18(here, "package.json")]) {
+  const here = dirname9(fileURLToPath7(import.meta.url));
+  for (const pkgPath of [join17(here, "..", "package.json"), join17(here, "package.json")]) {
     try {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
       if (typeof pkg.version === "string") {
         cached2 = pkg.version;
         return cached2;
@@ -9248,7 +8767,7 @@ var init_system = __esm(() => {
 });
 
 // src/trpc/routers/ticket.ts
-import * as z13 from "zod";
+import * as z12 from "zod";
 var ticketRouter;
 var init_ticket = __esm(() => {
   init_features();
@@ -9257,8 +8776,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(z12.object({ ticketId: z12.string(), fresh: z12.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
+    stop: publicProcedure.input(z12.object({ ticketId: z12.string() })).mutation(({ ctx, input }) => {
       if (stopTicketRun(input.ticketId))
         return { stopped: true, swept: false };
       const ticket = getTicket(ctx, input.ticketId);
@@ -9268,13 +8787,13 @@ 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()
+    cancel: publicProcedure.input(z12.object({ ticketId: z12.string(), reason: z12.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
+    edit: publicProcedure.input(z12.object({
+      ticketId: z12.string(),
+      title: z12.string().min(1).optional(),
+      goal: z12.string().min(1).optional(),
+      context: z12.string().optional(),
+      acceptanceCriteria: z12.array(z12.string().min(1)).optional()
     })).mutation(({ ctx, input }) => {
       const { ticketId, ...patch } = input;
       return editTicket(ctx, ticketId, patch);
@@ -9309,18 +8828,18 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq13 } from "drizzle-orm";
+import { eq as eq12 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq13(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq12(runs.status, "running")).all().map(rowToRun);
   const reconciled = [];
-  for (const run4 of stale) {
-    if (isRunActive(run4.id))
+  for (const run3 of stale) {
+    if (isRunActive(run3.id))
       continue;
-    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq13(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)) {
-      const feature = tryGetFeature(ctx, run4.featureId);
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq12(runs.id, run3.id)).run();
+    const released = releaseForSession(ctx, run3.id);
+    const swept = workflowClaimsFeatureBranch(run3.workflow) ? sweepOrphanedBurning(ctx, run3.featureId, "orphaned by server restart \u2014 retry to resume its commits") : [];
+    if (workflowClaimsFeatureBranch(run3.workflow)) {
+      const feature = tryGetFeature(ctx, run3.featureId);
       const project = feature ? getProjectById(ctx, feature.projectId) : null;
       if (feature && project) {
         try {
@@ -9328,18 +8847,18 @@ async function reconcileStaleRuns(ctx) {
         } catch {}
       }
     }
-    emit(ctx, run4.featureId, {
+    emit(ctx, run3.featureId, {
       type: "run.reconciled",
-      message: `run marked failed at boot \u2014 the server restarted while it was running (${run4.workflow})`,
-      runId: run4.id,
+      message: `run marked failed at boot \u2014 the server restarted while it was running (${run3.workflow})`,
+      runId: run3.id,
       data: {
-        runId: run4.id,
-        workflow: run4.workflow,
+        runId: run3.id,
+        workflow: run3.workflow,
         releasedWaypointIds: released.map((w) => w.id),
         sweptTicketSeqs: swept.map((t2) => t2.seq)
       }
     });
-    reconciled.push(run4);
+    reconciled.push(run3);
   }
   for (const project of allProjects(ctx)) {
     try {
@@ -9402,10 +8921,6 @@ async function startServer() {
   if (staleRuns.length > 0) {
     console.log(`reconciled ${staleRuns.length} stale run(s) from a previous server run`);
   }
-  const stalePreps = reconcilePreps(ctx);
-  if (stalePreps > 0) {
-    console.log(`reconciled ${stalePreps} stale preparation run(s) from a previous server run`);
-  }
   const server = Bun.serve({
     port: config2.serverPort,
     fetch(req, srv) {
@@ -9435,7 +8950,6 @@ var init_src2 = __esm(() => {
   init_client();
   init_migrate();
   init_reconcile();
-  init_prep();
   init_server();
   init_registry();
   init_ws();
@@ -9500,7 +9014,7 @@ __export(exports_cli, {
   resolveDoctorEnv: () => resolveDoctorEnv,
   parseMode: () => parseMode
 });
-import { existsSync as existsSync19, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
 function parseMode(argv) {
   return argv.includes("--gate") || argv.includes("--boot") ? "gate" : "diagnostic";
 }
@@ -9508,8 +9022,8 @@ function envWithToken() {
   const merged = { ...process.env };
   try {
     const path = envPath();
-    if (existsSync19(path)) {
-      const fromFile = parseEnvFile(readFileSync10(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
+    if (existsSync18(path)) {
+      const fromFile = parseEnvFile(readFileSync9(path, "utf8")).CLAUDE_CODE_OAUTH_TOKEN;
       if (fromFile && fromFile.length > 0)
         merged.CLAUDE_CODE_OAUTH_TOKEN = fromFile;
     }
@@ -9551,8 +9065,8 @@ var init_cli = __esm(() => {
 // src/bin/runcastle.ts
 init_asset_paths();
 init_version();
-import { dirname as dirname11, resolve as resolve10 } from "path";
-import { fileURLToPath as fileURLToPath9 } from "url";
+import { dirname as dirname10, resolve as resolve10 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
 function parseCommand(argv) {
   const [first, ...rest] = argv;
   if (first === undefined)
@@ -9576,7 +9090,7 @@ Usage:
   runcastle --help     Show this help
 `;
 async function main(argv) {
-  applyInstalledAssetEnv(resolve10(dirname11(fileURLToPath9(import.meta.url)), ".."));
+  applyInstalledAssetEnv(resolve10(dirname10(fileURLToPath8(import.meta.url)), ".."));
   const { command, args } = parseCommand(argv);
   switch (command) {
     case "version":