runcastle 1.2.12 → 1.3.1

package/bin/runcastle.js

@@ -176,7 +176,23 @@ import * as z2 from "zod";
 function isProjectSessionKind(kind) {
   return PROJECT_SESSION_KINDS.includes(kind);
 }
-var Phase, TicketStatus, SessionKind, PROJECT_SESSION_KINDS, SessionPurpose, MergeBranchPair, RunStatus, FeatureStatus, SessionStatus, TicketKind, FindingKind, FindingSeverity, FindingStatus, FindingOpenReason, ReviewFindingInput, ReviewFinding, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNoteAuthor, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+function unresolvedMergeConflict(events) {
+  let conflict = null;
+  for (const event of events) {
+    if (event.type === "merge.conflict") {
+      const data = event.data ?? {};
+      conflict = {
+        base: typeof data.base === "string" ? data.base : "",
+        files: Array.isArray(data.files) ? data.files.filter((file) => typeof file === "string") : [],
+        at: event.ts
+      };
+    } else if (["burn.started", "merge.resolved", "feature.shipped"].includes(event.type)) {
+      conflict = null;
+    }
+  }
+  return conflict;
+}
+var Phase, TicketStatus, SessionKind, PROJECT_SESSION_KINDS, SessionPurpose, MergeBranchPair, RunStatus, FeatureStatus, SessionStatus, TicketKind, FindingKind, FindingSeverity, FindingStatus, FindingOpenReason, ReviewFindingInput, ReviewFinding, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNoteAuthor, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow, DriveState;
 var init_schemas = __esm(() => {
   init_config();
   Phase = z2.enum([
@@ -211,7 +227,7 @@ var init_schemas = __esm(() => {
   FindingKind = z2.enum(["defect", "observation"]);
   FindingSeverity = z2.enum(["high", "medium", "low"]);
   FindingStatus = z2.enum(["open", "fixing", "fixed", "failed", "dismissed"]);
-  FindingOpenReason = z2.enum(["over-cap", "fix-failed"]);
+  FindingOpenReason = z2.enum(["over-cap", "fix-failed", "verification"]);
   ReviewFindingInput = z2.object({
     kind: FindingKind,
     severity: FindingSeverity,
@@ -245,6 +261,7 @@ var init_schemas = __esm(() => {
     seams: z2.array(z2.string()),
     blockedBy: z2.array(z2.number()),
     kind: TicketKind.default("implementation"),
+    passKind: z2.enum(["review", "verification"]).default("review"),
     model: z2.string().optional(),
     originFindingId: z2.string().optional()
   });
@@ -255,6 +272,8 @@ var init_schemas = __esm(() => {
     status: TicketStatus,
     lap: z2.number(),
     commits: z2.array(z2.string()),
+    reviewedCommit: z2.string().nullable().default(null),
+    completedAt: z2.number().nullable().default(null),
     error: z2.string().optional(),
     attemptBranch: z2.string().optional(),
     conflictFiles: z2.array(z2.string()).optional(),
@@ -280,7 +299,7 @@ var init_schemas = __esm(() => {
     lastSessionId: z2.string().optional(),
     summary: z2.string().optional()
   });
-  TestNoteStatus = z2.enum(["open", "done", "promoted"]);
+  TestNoteStatus = z2.enum(["open", "done", "promoted", "carried"]);
   TestNoteAuthor = z2.enum(["human", "agent"]);
   TestNote = z2.object({
     id: z2.string(),
@@ -290,6 +309,8 @@ var init_schemas = __esm(() => {
     status: TestNoteStatus,
     author: TestNoteAuthor.default("human"),
     ticketId: z2.string().optional(),
+    reviewTicketId: z2.string().optional(),
+    carriedLap: z2.number().optional(),
     videoTimestamp: z2.number().optional(),
     screenshotUrl: z2.string().optional(),
     createdAt: z2.number(),
@@ -356,6 +377,7 @@ var init_schemas = __esm(() => {
     id: z2.string(),
     featureId: z2.string().optional(),
     projectId: z2.string().optional(),
+    lap: z2.number(),
     kind: SessionKind,
     purpose: SessionPurpose.optional(),
     purposeData: MergeBranchPair.optional(),
@@ -366,8 +388,10 @@ var init_schemas = __esm(() => {
     worktreePath: z2.string(),
     model: z2.string().optional(),
     runtime: AgentRuntime.optional(),
-    title: z2.string().optional(),
-    createdAt: z2.number().optional()
+    title: z2.string().nullable().optional(),
+    transcriptMissing: z2.boolean().optional(),
+    createdAt: z2.number().optional(),
+    endedAt: z2.number().optional()
   });
   Run = z2.object({
     id: z2.string(),
@@ -409,16 +433,27 @@ var init_schemas = __esm(() => {
     message: z2.string(),
     data: z2.unknown().optional()
   });
+  DriveState = z2.enum([
+    "idle",
+    "starting",
+    "serving",
+    "bare-checkout",
+    "setup-failed",
+    "review-agent-driving"
+  ]);
 });
 
 // ../core/src/routes.ts
+function reviewWalkthroughUrl(ticketId) {
+  return `${REVIEWS_BASE}${REVIEW_WALKTHROUGH_ROUTE.replace(":ticketId", encodeURIComponent(ticketId))}`;
+}
 function fillNoteId(route, noteId) {
   return `${REVIEWS_BASE}${route.replace(":noteId", encodeURIComponent(noteId))}`;
 }
 function noteScreenshotUrl(noteId) {
   return fillNoteId(NOTE_SCREENSHOT_ROUTE, noteId);
 }
-var REVIEWS_BASE = "/api/reviews", NOTE_SCREENSHOT_UPLOAD_ROUTE = "/note/:noteId/screenshot", NOTE_SCREENSHOT_ROUTE;
+var REVIEWS_BASE = "/api/reviews", REVIEW_ARTIFACTS_ROUTE = "/:featureId", REVIEW_WALKTHROUGH_ROUTE = "/ticket/:ticketId/walkthrough.webm", NOTE_SCREENSHOT_UPLOAD_ROUTE = "/note/:noteId/screenshot", NOTE_SCREENSHOT_ROUTE;
 var init_routes = __esm(() => {
   NOTE_SCREENSHOT_ROUTE = `${NOTE_SCREENSHOT_UPLOAD_ROUTE}.png`;
 });
@@ -434,6 +469,17 @@ function fmtClock(seconds) {
   const mm = h > 0 ? String(m).padStart(2, "0") : String(m);
   return `${h > 0 ? `${h}:` : ""}${mm}:${String(s).padStart(2, "0")}`;
 }
+function ticketTitleFromNote(text) {
+  const clean = text.trim();
+  const boundary = clean.search(/(?:[.!?](?:\s|$)|\n)/);
+  const sentence = (boundary < 0 ? clean : clean.slice(0, boundary + (clean[boundary] === `
+` ? 0 : 1))).trim();
+  if (sentence.length <= 80)
+    return sentence;
+  const cut = sentence.slice(0, 80);
+  const wordBoundary = cut.lastIndexOf(" ");
+  return (wordBoundary > 0 ? cut.slice(0, wordBoundary) : cut).trimEnd();
+}
 
 // ../core/src/blocking.ts
 function resolveBatchBlocking(nodes, { startSeq, label = "ticket" }) {
@@ -636,7 +682,8 @@ var init_db_schema = __esm(() => {
     model: text("model"),
     runtime: text("runtime").$type(),
     title: text("title"),
-    createdAt: integer("created_at")
+    createdAt: integer("created_at"),
+    endedAt: integer("ended_at")
   });
   tickets = sqliteTable("tickets", {
     id: text("id").primaryKey(),
@@ -649,6 +696,9 @@ var init_db_schema = __esm(() => {
     seams: text("seams", { mode: "json" }).notNull().$type(),
     blockedBy: text("blocked_by", { mode: "json" }).notNull().$type(),
     kind: text("kind").notNull().$type().default("implementation"),
+    passKind: text("pass_kind").notNull().$type().default("review"),
+    reviewedCommit: text("reviewed_commit"),
+    completedAt: integer("completed_at"),
     model: text("model"),
     lap: integer("lap").notNull().default(1),
     status: text("status").notNull().$type(),
@@ -685,6 +735,8 @@ var init_db_schema = __esm(() => {
     status: text("status").notNull().$type(),
     author: text("author").notNull().$type().default("human"),
     ticketId: text("ticket_id"),
+    reviewTicketId: text("review_ticket_id"),
+    carriedLap: integer("carried_lap"),
     videoTimestamp: real("video_timestamp"),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull()
@@ -2077,6 +2129,7 @@ function rowToSession(row) {
     id: row.id,
     featureId: row.featureId ?? undefined,
     projectId: row.projectId ?? undefined,
+    lap: row.lap,
     kind: row.kind,
     purpose: row.purpose ?? undefined,
     purposeData: row.purposeData ?? undefined,
@@ -2088,7 +2141,8 @@ function rowToSession(row) {
     model: row.model ?? undefined,
     runtime: row.runtime ?? undefined,
     title: row.title ?? undefined,
-    createdAt: row.createdAt ?? undefined
+    createdAt: row.createdAt ?? undefined,
+    endedAt: row.endedAt ?? undefined
   });
 }
 function tryGetFeature(ctx, id) {
@@ -2854,6 +2908,19 @@ import {
 import { tmpdir } from "os";
 import { dirname, join as join6, resolve as resolve4 } from "path";
 import { simpleGit } from "simple-git";
+function deriveDriveState(info) {
+  if (!info)
+    return "idle";
+  if (info.hookFailure)
+    return "setup-failed";
+  if (info.purpose === "review")
+    return "review-agent-driving";
+  if (!info.devConfigured)
+    return "bare-checkout";
+  if (info.devReady)
+    return "serving";
+  return "starting";
+}
 function migrationPaths(paths) {
   return paths.filter((p) => MIGRATION_DIR_RE.test(p) || DRIZZLE_SQL_RE.test(p));
 }
@@ -2949,12 +3016,12 @@ async function createFeatureBranch(project, slug, base) {
   await g.raw(["branch", branch, from]);
   return branch;
 }
-async function listBranches(project) {
+async function listBranches(project, options = {}) {
   const g = git(project.repoPath);
   const local = await g.branchLocal();
   const detachedRef = local.detached ? local.current : null;
   const current = local.detached ? "" : local.current;
-  const branches = local.all.filter((name) => !name.startsWith("feature/") && name !== detachedRef);
+  const branches = local.all.filter((name) => (options.includeFeatureBranches || !name.startsWith("feature/")) && name !== detachedRef);
   const localSet = new Set(local.all);
   let remoteBranches = [];
   try {
@@ -2964,7 +3031,8 @@ async function listBranches(project) {
       return !short.startsWith("feature/") && !localSet.has(short);
     });
   } catch {}
-  return { current, branches, remoteBranches };
+  const detected = await detectMainBranch(project.repoPath);
+  return { current, detected, branches, remoteBranches };
 }
 async function resolveBaseBranch(project, base) {
   const g = git(project.repoPath);
@@ -3262,6 +3330,17 @@ async function reviewCommitCount(project, feature) {
     return { base };
   }
 }
+async function mergeDelta(project, feature) {
+  const counted = await reviewCommitCount(project, feature);
+  const branch = featureBranch(feature.slug);
+  try {
+    const files = (await git(project.repoPath).raw(["diff", "--name-only", `${counted.base}...${branch}`])).split(`
+`).map((path) => path.trim()).filter(Boolean).length;
+    return { base: counted.base, commits: counted.count, files };
+  } catch {
+    return { base: counted.base, commits: counted.count };
+  }
+}
 async function featureBranchDelta(project, feature) {
   const base = featureBase(feature);
   const branch = featureBranch(feature.slug);
@@ -3545,6 +3624,18 @@ async function commitDocs(worktreePath, message) {
     return;
   await g.commit(message, [DOCS_PATHSPEC]);
 }
+async function onBranch(repoPath, branch, action) {
+  const g = git(repoPath);
+  const previous = (await g.revparse(["--abbrev-ref", "HEAD"])).trim();
+  if (previous !== branch)
+    await g.checkout(branch);
+  try {
+    return await action();
+  } finally {
+    if (previous !== branch && previous !== "HEAD")
+      await g.checkout(previous);
+  }
+}
 async function commitPipelineDocs(repoPath) {
   try {
     await commitDocs(repoPath, "runcastle: docs the pipeline left uncommitted");
@@ -3557,7 +3648,7 @@ function activeDriveInfo() {
   const state = testDriveState;
   if (!state)
     return null;
-  return {
+  const info = {
     ...state.kind === "feature" ? {
       featureId: state.featureId,
       purpose: state.purpose,
@@ -3571,6 +3662,7 @@ function activeDriveInfo() {
     ...state.devReadiness === "timedOut" ? { devReadyTimedOut: true } : {},
     devConfigured: state.devConfigured
   };
+  return { ...info, state: deriveDriveState(info) };
 }
 function recordDriveUrl(ctx, featureId, url) {
   if (testDriveState?.kind !== "feature")
@@ -5155,7 +5247,7 @@ async function sandcastleImageProbe(exec, imageName, burnerDockerfile, fileMtime
           status: "stale",
           severity: "error",
           detail: `${imageName} built ${date(created)}, burner Dockerfile changed ${date(dockerfileChanged)} \u2014 rebuild`,
-          fix: 'Open Settings \u2192 AFK burns and click "Rebuild image".'
+          fix: "Open Settings \u2192 Burns (Rebuild image)."
         };
       }
       return { id, label, tier: 2, status: "ok", severity: "error", detail: `${imageName} present` };
@@ -5785,7 +5877,7 @@ function markSessionEnded(ctx, id) {
   forgetKickoff(id);
   if (existing.featureId)
     stopDocsWatch(existing.featureId);
-  ctx.db.update(sessions).set({ status: "ended" }).where(eq5(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ status: "ended", ...existing.endedAt === undefined ? { endedAt: Date.now() } : {} }).where(eq5(sessions.id, id)).run();
   return getSessionRow(ctx, id);
 }
 function mostRecentResumableSession(ctx, featureId, kind) {
@@ -5802,6 +5894,9 @@ function projectSessions(ctx, projectId, kind) {
 function setSessionTitle(ctx, id, title) {
   ctx.db.update(sessions).set({ title }).where(eq5(sessions.id, id)).run();
 }
+function clearSessionTitle(ctx, id) {
+  ctx.db.update(sessions).set({ title: null }).where(eq5(sessions.id, id)).run();
+}
 function hasCompletedProjectSession(ctx, projectId, kind) {
   return ctx.db.select({ id: sessions.id }).from(sessions).where(and5(eq5(sessions.projectId, projectId), eq5(sessions.kind, kind), eq5(sessions.status, "ended"))).limit(1).get() !== undefined;
 }
@@ -5933,8 +6028,198 @@ async function getRuntimeCtx() {
 }
 var current = null;
 
+// src/services/review-findings.ts
+import { and as and6, asc as asc3, eq as eq6, isNotNull as isNotNull2 } from "drizzle-orm";
+function rowToFinding(row) {
+  return ReviewFinding.parse(row);
+}
+function getFinding(ctx, id) {
+  const row = ctx.db.select().from(reviewFindings).where(eq6(reviewFindings.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`review finding ${id} not found`);
+  return rowToFinding(row);
+}
+function listByFeature3(ctx, featureId) {
+  return ctx.db.select().from(reviewFindings).where(eq6(reviewFindings.featureId, featureId)).orderBy(asc3(reviewFindings.createdAt), asc3(reviewFindings.id)).all().map(rowToFinding);
+}
+function buildFixTicket(finding) {
+  return {
+    title: finding.title,
+    goal: `Fix: ${finding.title}`,
+    context: [
+      `Location: ${finding.location}`,
+      `Citation: ${finding.citation}`,
+      `Detail: ${finding.detail}`,
+      `Repro step: ${finding.reproStep}`
+    ].join(`
+
+`),
+    acceptanceCriteria: [
+      `The repro step no longer reproduces / the cited criterion holds: ${finding.reproStep}`
+    ],
+    seams: [],
+    blockedBy: [],
+    kind: "implementation",
+    originFindingId: finding.id
+  };
+}
+function reportFinding(ctx, args) {
+  const { featureId, reviewTicket, input } = args;
+  const feature = getFeatureRow(ctx, featureId);
+  const id = newId("finding");
+  const ticketCount = ctx.db.select({ id: reviewFindings.id }).from(reviewFindings).where(and6(eq6(reviewFindings.reviewTicketId, reviewTicket.id), isNotNull2(reviewFindings.fixTicketId))).all().length;
+  const verification = reviewTicket.passKind === "verification";
+  const overCap = input.kind === "defect" && !verification && ticketCount >= AUTO_FIX_CAP;
+  ctx.db.insert(reviewFindings).values({
+    id,
+    featureId,
+    lap: feature.lap,
+    reviewTicketId: reviewTicket.id,
+    ...input,
+    reproStep: input.reproStep ?? "",
+    status: "open",
+    openReason: verification && input.kind === "defect" ? "verification" : overCap ? "over-cap" : null,
+    failureReason: null,
+    fixTicketId: null,
+    createdAt: Date.now()
+  }).run();
+  let fixTicket = null;
+  if (input.kind === "defect" && !overCap && !verification) {
+    const finding2 = getFinding(ctx, id);
+    fixTicket = storeTickets(ctx, featureId, [
+      { ...buildFixTicket(finding2), blockedBy: [reviewTicket.seq] }
+    ], { blockedByAreGlobal: true })[0];
+    ctx.db.update(reviewFindings).set({ fixTicketId: fixTicket.id }).where(eq6(reviewFindings.id, id)).run();
+  }
+  const finding = getFinding(ctx, id);
+  emit(ctx, featureId, {
+    type: "finding.reported",
+    message: `${input.kind} reported: ${input.title}`,
+    ticketId: fixTicket?.id,
+    data: { findingId: id, fixTicketId: fixTicket?.id, overCap }
+  });
+  return { finding, fixTicket, overCap };
+}
+function updateStatus(ctx, findingId, patch) {
+  const current2 = getFinding(ctx, findingId);
+  ctx.db.update(reviewFindings).set(patch).where(eq6(reviewFindings.id, findingId)).run();
+  emit(ctx, current2.featureId, {
+    type: "finding.updated",
+    message: `finding ${findingId} marked ${patch.status}`,
+    data: { findingId, status: patch.status, reason: patch.failureReason }
+  });
+  return getFinding(ctx, findingId);
+}
+function markFixing(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "fixing",
+    openReason: null,
+    failureReason: null
+  });
+}
+function markFixed(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "fixed",
+    openReason: null,
+    failureReason: null
+  });
+}
+function markFailed(ctx, findingId, reason) {
+  return updateStatus(ctx, findingId, {
+    status: "failed",
+    openReason: "fix-failed",
+    failureReason: reason ?? null
+  });
+}
+function markFixProgress(ctx, findingId, progress, reason) {
+  if (progress === "fixing")
+    return markFixing(ctx, findingId);
+  if (progress === "fixed")
+    return markFixed(ctx, findingId);
+  return markFailed(ctx, findingId, reason);
+}
+function dismiss(ctx, findingId) {
+  return updateStatus(ctx, findingId, {
+    status: "dismissed",
+    openReason: null,
+    failureReason: null
+  });
+}
+function defectState(finding, fixTicket) {
+  if (finding.status === "dismissed")
+    return "dismissed";
+  if (finding.status === "fixed" || fixTicket?.status === "done")
+    return "fixed";
+  if (fixTicket && fixTicket.status !== "failed" && fixTicket.status !== "cancelled") {
+    return "fixing";
+  }
+  return finding.status === "open" || finding.status === "failed" || fixTicket?.status === "failed" || fixTicket?.status === "cancelled" ? "open" : "fixing";
+}
+function viewByFeature(ctx, featureId) {
+  const findings = listByFeature3(ctx, featureId);
+  const tickets2 = listByFeature2(ctx, featureId);
+  const summary = { found: 0, fixed: 0, open: 0, observations: 0 };
+  const openDefects = [];
+  for (const finding of findings) {
+    if (finding.kind === "observation") {
+      summary.observations += 1;
+      continue;
+    }
+    summary.found += 1;
+    const state = defectState(finding, fixTicketOf(finding, tickets2));
+    if (state === "fixed")
+      summary.fixed += 1;
+    else if (state === "open") {
+      summary.open += 1;
+      openDefects.push(finding);
+    }
+  }
+  return { findings, openDefects, summary };
+}
+function fixTicketOf(finding, tickets2) {
+  return finding.fixTicketId ? tickets2.find((t) => t.id === finding.fixTicketId) : undefined;
+}
+function promoteOpenDefects(ctx, featureId, findingIds) {
+  const open = viewByFeature(ctx, featureId).openDefects;
+  const defects = findingIds ? findingIds.map((id) => {
+    const finding = open.find((candidate) => candidate.id === id);
+    if (!finding)
+      throw new InvalidInputError(`finding ${id} is not an open defect of this feature`);
+    return finding;
+  }) : open;
+  if (findingIds && new Set(findingIds).size !== findingIds.length)
+    throw new InvalidInputError("duplicate finding selected");
+  if (defects.length === 0)
+    throw new InvalidInputError("no open defects to fix");
+  const tickets2 = storeTickets(ctx, featureId, defects.map(buildFixTicket));
+  const findings = defects.map((defect, index2) => {
+    ctx.db.update(reviewFindings).set({
+      status: "fixing",
+      openReason: null,
+      failureReason: null,
+      fixTicketId: tickets2[index2].id
+    }).where(eq6(reviewFindings.id, defect.id)).run();
+    return getFinding(ctx, defect.id);
+  });
+  emit(ctx, featureId, {
+    type: "finding.fixing",
+    message: `${findings.length} open defect${findings.length === 1 ? "" : "s"} promoted to fix ticket${tickets2.length === 1 ? ` ${tickets2[0].seq}` : `s ${tickets2.map((t) => t.seq).join(", ")}`}`,
+    data: { findingIds: findings.map((f) => f.id), seqs: tickets2.map((t) => t.seq) }
+  });
+  return { findings, tickets: tickets2 };
+}
+var AUTO_FIX_CAP = 8;
+var init_review_findings = __esm(() => {
+  init_src();
+  init_schema();
+  init_errors();
+  init_events();
+  init_repo();
+  init_tickets();
+});
+
 // src/services/tickets.ts
-import { and as and6, asc as asc3, eq as eq6 } from "drizzle-orm";
+import { and as and7, asc as asc4, eq as eq7, inArray as inArray3 } from "drizzle-orm";
 function rowToTicket(row) {
   return Ticket.parse({
     id: row.id,
@@ -5947,6 +6232,9 @@ function rowToTicket(row) {
     seams: row.seams,
     blockedBy: row.blockedBy,
     kind: row.kind,
+    passKind: row.passKind,
+    reviewedCommit: row.reviewedCommit,
+    completedAt: row.completedAt,
     model: row.model ?? undefined,
     lap: row.lap,
     status: row.status,
@@ -5978,13 +6266,13 @@ function normalizeModel(ctx, value) {
   return id;
 }
 function listByFeature2(ctx, featureId) {
-  return ctx.db.select().from(tickets).where(eq6(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
+  return ctx.db.select().from(tickets).where(eq7(tickets.featureId, featureId)).orderBy(asc4(tickets.seq)).all().map(rowToTicket);
 }
 function storeTickets(ctx, featureId, inputs, options = {}) {
   if (inputs.length === 0)
     return [];
   const { lap } = getFeatureRow(ctx, featureId);
-  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq6(tickets.featureId, featureId)).all();
+  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq7(tickets.featureId, featureId)).all();
   const startSeq = existing.reduce((max2, r) => Math.max(max2, r.seq), 0) + 1;
   const resolved = options.blockedByAreGlobal ? inputs.map((input, index2) => ({ seq: startSeq + index2, blockedBy: input.blockedBy })) : resolveBlocking(inputs, startSeq);
   const rows = inputs.map((t, i) => ({
@@ -5998,6 +6286,9 @@ function storeTickets(ctx, featureId, inputs, options = {}) {
     seams: t.seams,
     blockedBy: resolved[i].blockedBy,
     kind: t.kind ?? "implementation",
+    passKind: t.passKind ?? "review",
+    reviewedCommit: null,
+    completedAt: null,
     model: normalizeModel(ctx, t.model),
     lap,
     status: "pending",
@@ -6017,7 +6308,7 @@ function storeTickets(ctx, featureId, inputs, options = {}) {
   return rows.map(rowToTicket);
 }
 function getTicket(ctx, id) {
-  const row = ctx.db.select().from(tickets).where(eq6(tickets.id, id)).get();
+  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);
@@ -6046,7 +6337,7 @@ function editTicket(ctx, id, patch) {
   if (Object.keys(set).length === 0) {
     throw new InvalidInputError("nothing to edit \u2014 pass at least one field");
   }
-  ctx.db.update(tickets).set(set).where(eq6(tickets.id, id)).run();
+  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(", ")})`,
@@ -6058,7 +6349,11 @@ function editTicket(ctx, id, patch) {
 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(eq6(tickets.id, id)).run();
+  ctx.db.update(tickets).set({
+    status: "cancelled",
+    error: reason?.trim() ? reason.trim() : null,
+    completedAt: Date.now()
+  }).where(eq7(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.cancelled",
     message: `ticket ${current2.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
@@ -6068,9 +6363,12 @@ function cancelTicket(ctx, id, reason) {
   return getTicket(ctx, id);
 }
 function sweepOrphanedBurning(ctx, featureId, reason) {
-  const orphaned = ctx.db.select().from(tickets).where(and6(eq6(tickets.featureId, featureId), eq6(tickets.status, "burning"))).all().map(rowToTicket);
+  const orphaned = ctx.db.select().from(tickets).where(and7(eq7(tickets.featureId, featureId), eq7(tickets.status, "burning"))).all().map(rowToTicket);
+  const swept = [];
   for (const t of orphaned) {
-    updateTicket(ctx, t.id, { status: "failed", error: reason });
+    swept.push(updateTicket(ctx, t.id, { status: "failed", error: reason }));
+    if (t.originFindingId)
+      markFailed(ctx, t.originFindingId, reason);
     emit(ctx, featureId, {
       type: "ticket.failed",
       message: `ticket ${t.seq} failed: ${reason}`,
@@ -6078,15 +6376,18 @@ function sweepOrphanedBurning(ctx, featureId, reason) {
       data: { error: reason, orphaned: true }
     });
   }
-  return orphaned.map((t) => ({ ...t, status: "failed", error: reason }));
+  return swept;
 }
 function updateTicket(ctx, id, patch) {
-  const current2 = ctx.db.select().from(tickets).where(eq6(tickets.id, id)).get();
+  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.status !== undefined) {
+    set.completedAt = ["done", "failed", "cancelled"].includes(patch.status) ? Date.now() : null;
+  }
   if (patch.commits !== undefined)
     set.commits = patch.commits;
   if (patch.error !== undefined)
@@ -6097,16 +6398,44 @@ function updateTicket(ctx, id, patch) {
     set.conflictFiles = patch.conflictFiles;
   if (patch.digest !== undefined)
     set.digest = patch.digest;
-  ctx.db.update(tickets).set(set).where(eq6(tickets.id, id)).run();
+  if (patch.reviewedCommit !== undefined)
+    set.reviewedCommit = patch.reviewedCommit;
+  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(eq6(tickets.id, id)).get();
+  const updated = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
   return rowToTicket(updated);
 }
+function listByIds(ctx, ids2) {
+  if (ids2.length === 0)
+    return [];
+  return ctx.db.select().from(tickets).where(inArray3(tickets.id, [...ids2])).orderBy(asc4(tickets.seq)).all().map(rowToTicket);
+}
+function timingWallMs(data) {
+  if (typeof data !== "object" || data === null)
+    return;
+  const ms = data.wallMs;
+  return typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+function ticketDurationStats(ctx, projectId) {
+  const rows = ctx.db.select({ ticketId: events.ticketId, data: events.data }).from(events).innerJoin(tickets, eq7(events.ticketId, tickets.id)).where(and7(eq7(events.projectId, projectId), eq7(events.type, "ticket.timing"), eq7(tickets.status, "done"), eq7(tickets.kind, "implementation"))).orderBy(asc4(events.id)).all();
+  const perTicket = new Map;
+  for (const row of rows) {
+    const ms = timingWallMs(row.data);
+    if (row.ticketId && ms !== undefined)
+      perTicket.set(row.ticketId, ms);
+  }
+  const samples = [...perTicket.values()].sort((a, b) => a - b);
+  if (samples.length === 0)
+    return { medianMs: 0, sampleSize: 0 };
+  const mid = samples.length >> 1;
+  const medianMs = samples.length % 2 === 1 ? samples[mid] : Math.round((samples[mid - 1] + samples[mid]) / 2);
+  return { medianMs, sampleSize: samples.length };
+}
 var MUTABLE_STATUSES;
 var init_tickets = __esm(() => {
   init_src();
@@ -6114,12 +6443,13 @@ var init_tickets = __esm(() => {
   init_errors();
   init_events();
   init_repo();
+  init_review_findings();
   MUTABLE_STATUSES = new Set(["pending", "failed"]);
 });
 
 // src/services/gates.ts
 import { existsSync as existsSync11 } from "fs";
-import { and as and7, desc as desc4, eq as eq7, inArray as inArray3 } from "drizzle-orm";
+import { and as and8, desc as desc4, eq as eq8, inArray as inArray4 } from "drizzle-orm";
 function checkGate(ctx, check, feature) {
   switch (check) {
     case "decisions-file-exists":
@@ -6130,10 +6460,17 @@ function checkGate(ctx, check, feature) {
         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"])
-      };
+      if (open.length > 0)
+        return {
+          satisfied: false,
+          reason: notYetTerminal("waypoint", open.map((w) => w.status), ["open", "claimed"])
+        };
+      if (feature.lap > 1 && !lapWorked(ctx, feature))
+        return {
+          satisfied: false,
+          reason: `the map is an earlier lap's \u2014 no lap ${feature.lap} session has worked this feature yet; open the lap's session before converging`
+        };
+      return { satisfied: true };
     }
     case "spec-file-exists":
       return docGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
@@ -6170,12 +6507,14 @@ function fileGate(ctx, feature, fileName, reason) {
   const project = projectForFeature(ctx, feature);
   return existsSync11(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
 }
+function lapWorked(ctx, feature) {
+  return ctx.db.select({ id: sessions.id }).from(sessions).where(and8(eq8(sessions.featureId, feature.id), eq8(sessions.lap, feature.lap), inArray4(sessions.kind, [...DOC_WRITING_KINDS]))).all().length > 0;
+}
 function docGate(ctx, feature, fileName, reason) {
   const file = fileGate(ctx, feature, fileName, reason);
   if (!file.satisfied || feature.lap === 1)
     return file;
-  const worked = ctx.db.select({ id: sessions.id }).from(sessions).where(and7(eq7(sessions.featureId, feature.id), eq7(sessions.lap, feature.lap), inArray3(sessions.kind, [...DOC_WRITING_KINDS]))).all();
-  return worked.length > 0 ? { satisfied: true } : {
+  return lapWorked(ctx, feature) ? { satisfied: true } : {
     satisfied: false,
     reason: `${fileName} is an earlier lap's \u2014 no lap ${feature.lap} session has worked this feature yet; open the lap's session before promoting`
   };
@@ -6201,10 +6540,10 @@ function overrideGate(ctx, featureId, gate, reason) {
   return feature;
 }
 function undoLastGateOverride(ctx, featureId, gate) {
-  const last = ctx.db.select({ id: gateOverrides.id }).from(gateOverrides).where(and7(eq7(gateOverrides.featureId, featureId), eq7(gateOverrides.gate, gate))).orderBy(desc4(gateOverrides.id)).get();
+  const last = ctx.db.select({ id: gateOverrides.id }).from(gateOverrides).where(and8(eq8(gateOverrides.featureId, featureId), eq8(gateOverrides.gate, gate))).orderBy(desc4(gateOverrides.id)).get();
   if (!last)
     return false;
-  ctx.db.delete(gateOverrides).where(eq7(gateOverrides.id, last.id)).run();
+  ctx.db.delete(gateOverrides).where(eq8(gateOverrides.id, last.id)).run();
   return true;
 }
 function undoGateOverride(ctx, featureId, gate) {
@@ -6232,7 +6571,7 @@ var init_gates = __esm(() => {
 });
 
 // src/services/knowledge.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join11, relative as relative2, resolve as resolve8, sep } from "path";
 function scaffoldDocs(ctx, feature, opts = {}) {
   const project = projectForFeature(ctx, feature);
@@ -6320,7 +6659,10 @@ function listDocs(ctx, feature) {
   const dir = featureDocsDir(project, feature);
   if (!existsSync12(dir))
     return [];
-  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => ({ relPath: e.name, title: readTitle(join11(dir, e.name), e.name) })).sort((a, b) => a.relPath.localeCompare(b.relPath));
+  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => {
+    const path = join11(dir, e.name);
+    return { relPath: e.name, title: readTitle(path, e.name), ...writtenAt(path) };
+  }).sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
 function readDoc(ctx, feature, relPath) {
   const project = projectForFeature(ctx, feature);
@@ -6335,6 +6677,13 @@ function readDoc(ctx, feature, relPath) {
     throw new NotFoundError(`doc not found: ${relPath}`);
   return { content: readFileSync5(target, "utf8") };
 }
+function writtenAt(path) {
+  try {
+    return { updatedAt: Math.floor(statSync4(path).mtimeMs) };
+  } catch {
+    return {};
+  }
+}
 function readTitle(path, fallback) {
   try {
     const firstLine = readFileSync5(path, "utf8").split(`
@@ -6388,187 +6737,6 @@ var init_end_session = __esm(() => {
   init_registry();
 });
 
-// src/services/review-findings.ts
-import { and as and8, asc as asc4, eq as eq8, isNotNull as isNotNull2 } from "drizzle-orm";
-function rowToFinding(row) {
-  return ReviewFinding.parse(row);
-}
-function getFinding(ctx, id) {
-  const row = ctx.db.select().from(reviewFindings).where(eq8(reviewFindings.id, id)).get();
-  if (!row)
-    throw new NotFoundError(`review finding ${id} not found`);
-  return rowToFinding(row);
-}
-function listByFeature3(ctx, featureId) {
-  return ctx.db.select().from(reviewFindings).where(eq8(reviewFindings.featureId, featureId)).orderBy(asc4(reviewFindings.createdAt), asc4(reviewFindings.id)).all().map(rowToFinding);
-}
-function buildFixTicket(finding) {
-  return {
-    title: finding.title,
-    goal: `Fix: ${finding.title}`,
-    context: [
-      `Location: ${finding.location}`,
-      `Citation: ${finding.citation}`,
-      `Detail: ${finding.detail}`,
-      `Repro step: ${finding.reproStep}`
-    ].join(`
-
-`),
-    acceptanceCriteria: [
-      `The repro step no longer reproduces / the cited criterion holds: ${finding.reproStep}`
-    ],
-    seams: [],
-    blockedBy: [],
-    kind: "implementation",
-    originFindingId: finding.id
-  };
-}
-function reportFinding(ctx, args) {
-  const { featureId, reviewTicket, input } = args;
-  const feature = getFeatureRow(ctx, featureId);
-  const id = newId("finding");
-  const ticketCount = ctx.db.select({ id: reviewFindings.id }).from(reviewFindings).where(and8(eq8(reviewFindings.reviewTicketId, reviewTicket.id), isNotNull2(reviewFindings.fixTicketId))).all().length;
-  const overCap = input.kind === "defect" && ticketCount >= AUTO_FIX_CAP;
-  ctx.db.insert(reviewFindings).values({
-    id,
-    featureId,
-    lap: feature.lap,
-    reviewTicketId: reviewTicket.id,
-    ...input,
-    reproStep: input.reproStep ?? "",
-    status: "open",
-    openReason: overCap ? "over-cap" : null,
-    failureReason: null,
-    fixTicketId: null,
-    createdAt: Date.now()
-  }).run();
-  let fixTicket = null;
-  if (input.kind === "defect" && !overCap) {
-    const finding2 = getFinding(ctx, id);
-    fixTicket = storeTickets(ctx, featureId, [
-      { ...buildFixTicket(finding2), blockedBy: [reviewTicket.seq] }
-    ], { blockedByAreGlobal: true })[0];
-    ctx.db.update(reviewFindings).set({ fixTicketId: fixTicket.id }).where(eq8(reviewFindings.id, id)).run();
-  }
-  const finding = getFinding(ctx, id);
-  emit(ctx, featureId, {
-    type: "finding.reported",
-    message: `${input.kind} reported: ${input.title}`,
-    ticketId: fixTicket?.id,
-    data: { findingId: id, fixTicketId: fixTicket?.id, overCap }
-  });
-  return { finding, fixTicket, overCap };
-}
-function updateStatus(ctx, findingId, patch) {
-  const current2 = getFinding(ctx, findingId);
-  ctx.db.update(reviewFindings).set(patch).where(eq8(reviewFindings.id, findingId)).run();
-  emit(ctx, current2.featureId, {
-    type: "finding.updated",
-    message: `finding ${findingId} marked ${patch.status}`,
-    data: { findingId, status: patch.status, reason: patch.failureReason }
-  });
-  return getFinding(ctx, findingId);
-}
-function markFixing(ctx, findingId) {
-  return updateStatus(ctx, findingId, {
-    status: "fixing",
-    openReason: null,
-    failureReason: null
-  });
-}
-function markFixed(ctx, findingId) {
-  return updateStatus(ctx, findingId, {
-    status: "fixed",
-    openReason: null,
-    failureReason: null
-  });
-}
-function markFailed(ctx, findingId, reason) {
-  return updateStatus(ctx, findingId, {
-    status: "failed",
-    openReason: "fix-failed",
-    failureReason: reason ?? null
-  });
-}
-function markFixProgress(ctx, findingId, progress, reason) {
-  if (progress === "fixing")
-    return markFixing(ctx, findingId);
-  if (progress === "fixed")
-    return markFixed(ctx, findingId);
-  return markFailed(ctx, findingId, reason);
-}
-function dismiss(ctx, findingId) {
-  return updateStatus(ctx, findingId, {
-    status: "dismissed",
-    openReason: null,
-    failureReason: null
-  });
-}
-function defectState(finding, fixTicket) {
-  if (finding.status === "dismissed")
-    return "dismissed";
-  if (finding.status === "fixed" || fixTicket?.status === "done")
-    return "fixed";
-  if (fixTicket && fixTicket.status !== "failed" && fixTicket.status !== "cancelled") {
-    return "fixing";
-  }
-  return finding.status === "open" || finding.status === "failed" ? "open" : "fixing";
-}
-function viewByFeature(ctx, featureId) {
-  const findings = listByFeature3(ctx, featureId);
-  const tickets2 = listByFeature2(ctx, featureId);
-  const summary = { found: 0, fixed: 0, open: 0, observations: 0 };
-  const openDefects = [];
-  for (const finding of findings) {
-    if (finding.kind === "observation") {
-      summary.observations += 1;
-      continue;
-    }
-    summary.found += 1;
-    const state = defectState(finding, fixTicketOf(finding, tickets2));
-    if (state === "fixed")
-      summary.fixed += 1;
-    else if (state === "open") {
-      summary.open += 1;
-      openDefects.push(finding);
-    }
-  }
-  return { findings, openDefects, summary };
-}
-function fixTicketOf(finding, tickets2) {
-  return finding.fixTicketId ? tickets2.find((t) => t.id === finding.fixTicketId) : undefined;
-}
-function promoteOpenDefects(ctx, featureId) {
-  const defects = viewByFeature(ctx, featureId).openDefects;
-  if (defects.length === 0)
-    throw new InvalidInputError("no open defects to fix");
-  const tickets2 = storeTickets(ctx, featureId, defects.map(buildFixTicket));
-  const findings = defects.map((defect, index2) => {
-    ctx.db.update(reviewFindings).set({
-      status: "fixing",
-      openReason: null,
-      failureReason: null,
-      fixTicketId: tickets2[index2].id
-    }).where(eq8(reviewFindings.id, defect.id)).run();
-    return getFinding(ctx, defect.id);
-  });
-  emit(ctx, featureId, {
-    type: "finding.fixing",
-    message: `${findings.length} open defect${findings.length === 1 ? "" : "s"} promoted to fix ticket${tickets2.length === 1 ? ` ${tickets2[0].seq}` : `s ${tickets2.map((t) => t.seq).join(", ")}`}`,
-    data: { findingIds: findings.map((f) => f.id), seqs: tickets2.map((t) => t.seq) }
-  });
-  return { findings, tickets: tickets2 };
-}
-var AUTO_FIX_CAP = 8;
-var init_review_findings = __esm(() => {
-  init_src();
-  init_schema();
-  init_errors();
-  init_events();
-  init_repo();
-  init_tickets();
-});
-
 // ../../node_modules/.bun/@ai-hero+sandcastle@0.12.0/node_modules/@ai-hero/sandcastle/dist/chunk-NGBM7T3E.js
 import { createRequire as createRequire3 } from "module";
 var require$1, __create, __defProp2, __getOwnPropDesc, __getOwnPropNames, __getProtoOf, __hasOwnProp, __require2, __commonJS = (cb, mod) => function __require22() {
@@ -6628,7 +6796,7 @@ import { createRequire as createRequire4 } from "module";
 import * as clack from "@clack/prompts";
 import { join as join$1, basename as basename2, dirname as dirname4, resolve as resolve9, posix as posix2, normalize, isAbsolute as isAbsolute2 } from "path";
 import { styleText, promisify } from "util";
-import { existsSync as existsSync13, statSync as statSync4 } from "fs";
+import { existsSync as existsSync13, statSync as statSync5 } from "fs";
 import { tmpdir as tmpdir2, homedir as homedir3 } from "os";
 import { mkdtemp, writeFile, mkdir, readFile, rm, readdir, stat } from "fs/promises";
 import { exec, execFile } from "child_process";
@@ -18440,7 +18608,7 @@ Worktree removed (no uncommitted changes)`);
   const selinux = mount.volume !== undefined ? undefined : selinuxLabel || undefined;
   const options = [mount.readonly ? "ro" : undefined, selinux].filter((option5) => option5 !== undefined).join(",");
   return options ? `${base}:${options}` : base;
-}, processFileMountParents = (mounts, sandboxHomedir, statFn = statSync4) => {
+}, processFileMountParents = (mounts, sandboxHomedir, statFn = statSync5) => {
   const parentDirs = /* @__PURE__ */ new Set;
   for (const mount of mounts) {
     let isFile2;
@@ -55378,10 +55546,11 @@ var init_no_sandbox = __esm(() => {
 // src/workflows/review-ticket.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 import { delimiter, join as join16 } from "path";
-function reviewTemplatePath() {
-  return burnerAssetPath("review-ticket.md");
+function reviewTemplatePath(ticket) {
+  return burnerAssetPath(ticket?.passKind === "verification" ? "verify-fixes.md" : "review-ticket.md");
 }
-function renderReviewPrompt(template, values) {
+function renderReviewPrompt(templateOrTicket, values) {
+  const template = typeof templateOrTicket === "string" ? templateOrTicket : readFileSync8(reviewTemplatePath(templateOrTicket), "utf8");
   return renderTemplate(template, values);
 }
 function findOnPath(bin, env = process.env, platform = process.platform) {
@@ -55396,7 +55565,10 @@ function findOnPath(bin, env = process.env, platform = process.platform) {
   }
   return;
 }
-function buildDriveAvailability(browserPath, devCommand) {
+function buildDriveAvailability(browserPath, devCommand, inheritedMode) {
+  if (inheritedMode) {
+    return inheritedMode === "drive" ? "Inherited mode: **Drive**. The pass being verified left a recording, so run Drive mode and record the full tour; do not choose Gates mode." : "Inherited mode: **Gates**. The pass being verified left no recording, so run Gates mode; do not choose Drive mode or call `review_drive`.";
+  }
   const missing = [];
   if (!browserPath) {
     missing.push(`\`${AGENT_BROWSER_BIN}\` is not on this machine's PATH, so there is no browser to walk the app with`);
@@ -55409,6 +55581,9 @@ function buildDriveAvailability(browserPath, devCommand) {
   }
   return `A drive is **not** available: ${missing.join(", and ")}. So the mode is already decided \u2014 ` + "run Gates mode, whatever this lap touched, and do not call `review_drive`. This is not a " + "degraded review; it is the whole review this lap gets.";
 }
+function inheritedReviewMode(verifiedTicketId, fileExists2 = existsSync16) {
+  return verifiedTicketId && fileExists2(reviewWalkthroughPath(verifiedTicketId)) ? "drive" : "gates";
+}
 function buildGateNotes(config2) {
   const commands = config2.verifyCommands?.trim();
   const failures2 = config2.knownFailures?.trim();
@@ -55462,18 +55637,24 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
     return couldNotReview(ticket, `feature ${feature.slug} has no recorded base branch, so there is nothing to diff \`${feature.branch}\` against.`);
   }
   const artifacts = writeReviewArtifacts(ticket, ctx.runId, deps.config);
-  const prompt = renderReviewPrompt(readFileSync8(reviewTemplatePath(), "utf8"), {
+  const allTickets = ctx.listTickets?.() ?? ctx.tickets;
+  const verifies = allTickets.filter((candidate) => candidate.kind === "review" && candidate.id !== ticket.id && candidate.status === "done").sort((a, b) => (a.completedAt ?? 0) - (b.completedAt ?? 0) || a.seq - b.seq).at(-1);
+  const inheritedMode = ticket.passKind === "verification" ? inheritedReviewMode(verifies?.id) : undefined;
+  const prompt = renderReviewPrompt(ticket, {
     TICKET_JSON: buildTicketJson(ticket),
     FEATURE_BRIEF: buildFeatureBrief(feature),
     DOCS_DIGEST: deps.docsDigest,
     LAP_DIGESTS: buildLapDigestsBlock(deps.lapDigests),
     FEATURE_BRANCH: feature.branch,
     BASE_BRANCH: feature.baseBranch,
-    DRIVE_AVAILABILITY: buildDriveAvailability(findOnPath(AGENT_BROWSER_BIN), project3.devCommand),
+    DRIVE_AVAILABILITY: buildDriveAvailability(findOnPath(AGENT_BROWSER_BIN), project3.devCommand, inheritedMode),
     GATE_NOTES: buildGateNotes(deps.config),
     DIGEST_PATH: artifacts.digestPath,
     BLOCKED_PATH: artifacts.blockedPath,
-    WALKTHROUGH_PATH: artifacts.walkthroughPath
+    WALKTHROUGH_PATH: artifacts.walkthroughPath,
+    LANDED_FIXES: ticket.context,
+    VERIFIES_PASS: verifies ? `#${verifies.seq} \xB7 ${inheritedMode === "drive" ? "Drive" : "Gates"} mode` : "no earlier review in this run \xB7 Gates mode",
+    AUTO_FIX_CAP: String(AUTO_FIX_CAP)
   });
   mkdirSync9(logsDir(), { recursive: true });
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
@@ -55551,6 +55732,7 @@ var init_review_ticket = __esm(() => {
   init_artifacts();
   init_agent_stream();
   init_git();
+  init_review_findings();
   init_ticket_burner();
 });
 
@@ -56111,7 +56293,7 @@ import { dirname as dirname9, join as join17, posix as posixPath, win32 as winPa
 import { fileURLToPath as fileURLToPath7 } from "url";
 function missingImageRuntimeMessage(runtime5, image) {
   const binary = RUNTIME_BINARY[runtime5];
-  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 AFK burns (Rebuild image).`;
+  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 Burns (Rebuild image).`;
 }
 function burnAuthReady(runtime5, token, loggedIn = codexLoggedIn) {
   if (token !== undefined)
@@ -56121,6 +56303,17 @@ function burnAuthReady(runtime5, token, loggedIn = codexLoggedIn) {
 function isReviewTicket(ticket) {
   return ticket.kind === "review";
 }
+function verificationDue(tickets2, runTicketIds) {
+  const inRun = tickets2.filter((ticket) => runTicketIds.has(ticket.id));
+  const reviews = inRun.filter(isReviewTicket).filter((ticket) => ticket.completedAt !== null).sort((a, b) => (a.completedAt ?? 0) - (b.completedAt ?? 0) || a.seq - b.seq);
+  const lastReview = reviews.at(-1) ?? null;
+  const verifies = [...reviews].reverse().find((ticket) => ticket.status === "done") ?? null;
+  if (lastReview?.status === "failed")
+    return { due: false, landed: [], verifies };
+  const cutoff = verifies?.completedAt ?? Number.NEGATIVE_INFINITY;
+  const landed = inRun.filter((ticket) => !isReviewTicket(ticket) && ticket.status === "done" && ticket.completedAt !== null && (ticket.completedAt > cutoff || ticket.completedAt === cutoff && verifies !== null && ticket.seq > verifies.seq));
+  return { due: landed.length > 0, landed, verifies };
+}
 function indexBySeq(tickets2) {
   return new Map(tickets2.map((t) => [t.seq, t]));
 }
@@ -56487,7 +56680,7 @@ function buildRepoSetupSteps(repoPath, tempBranch, setupCommand, pm) {
   const repoAttachmentsDir = `${repoPath}/${ATTACHMENTS_DIR}`;
   const excludeFile = `${repoPath}/.git/info/exclude`;
   const pre = [
-    `if [ -d "${attachmentsDir}" ]; then mkdir -p "${repoAttachmentsDir}" && cp -r "${attachmentsDir}/." "${repoAttachmentsDir}/" && mkdir -p "${repoPath}/.git/info" && { grep -qxF '${ATTACHMENTS_DIR}/' "${excludeFile}" 2>/dev/null || printf '%s\\n' '${ATTACHMENTS_DIR}/' >> "${excludeFile}"; }; fi`,
+    `if [ -d "${attachmentsDir}" ]; then mkdir -p "${repoAttachmentsDir}" && cp -r "${attachmentsDir}/." "${repoAttachmentsDir}/" && mkdir -p "${repoPath}/.git/info" && { grep -qxF '${ATTACHMENTS_PREFIX}' "${excludeFile}" 2>/dev/null || printf '%s\\n' '${ATTACHMENTS_PREFIX}' >> "${excludeFile}"; }; fi`,
     `printf '#!/bin/sh\\nunset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE\\ngit push --quiet origin HEAD:%s && exit 0\\nsleep 2\\ngit push --quiet origin HEAD:%s && exit 0\\necho "runcastle: commit sync failed (will retry on your next commit); do not re-commit" >&2\\nexit 0\\n' '${tempBranch}' '${tempBranch}' > ${hookFile}`,
     `chmod +x ${hookFile}`
   ];
@@ -56574,7 +56767,7 @@ function buildWorkspaceNotes(mode, repoPath = ISOLATED_REPO_PATH) {
 `);
 }
 function attachedNoteIds(context5) {
-  const marker = `${ATTACHMENTS_DIR}/`;
+  const marker = ATTACHMENTS_PREFIX;
   const ids3 = [];
   for (let at = context5.indexOf(marker);at !== -1; at = context5.indexOf(marker, at + 1)) {
     const id3 = /^([\w-]+)\.png/.exec(context5.slice(at + marker.length))?.[1];
@@ -56605,7 +56798,7 @@ function buildAttachmentCopyCommands(sources, platform = process.platform) {
 }
 async function clearAttachments(workspacePath, repoPath) {
   rmSync3(join17(workspacePath, ATTACHMENTS_DIR), { recursive: true, force: true });
-  await unexcludePath(repoPath, `${ATTACHMENTS_DIR}/`);
+  await unexcludePath(repoPath, ATTACHMENTS_PREFIX);
 }
 function buildVerifyNotes(config2) {
   const commands = config2.verifyCommands?.trim();
@@ -56785,7 +56978,7 @@ function missingAgentBinaryMessage(err, runtime5, image) {
   const missing = new RegExp(`\\b${binary}\\b[^\\n]*(?:exited with code 127|command not found|not found|no such file or directory)`, "i");
   if (!missing.test(msg))
     return;
-  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 AFK burns (Rebuild image).`;
+  return `${binary} is not installed in image ${image} \u2014 the image predates the burner Dockerfile. Rebuild it from Settings \u2192 Burns (Rebuild image).`;
 }
 function classifyTicketRunError(err, runtime5) {
   const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
@@ -56913,6 +57106,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
   const inFlight = new Map;
   const digests = [];
   let admitted = 0;
+  let verificationChecked = false;
   const satisfied = (t, s) => s === "done" || s === "cancelled" || isReviewTicket(t) && s === "failed";
   const implementationsSettled = () => scheduled.every((t) => isReviewTicket(t) || !pending3.has(t.seq) && !inFlight.has(t.seq));
   const admitNewTickets = () => {
@@ -56937,6 +57131,46 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
       data: { seqs: added }
     });
   };
+  const appendVerificationIfDue = () => {
+    verificationChecked = true;
+    if (!ctx.listTickets || !ctx.storeTickets)
+      return;
+    const allTickets = ctx.listTickets();
+    const runTicketIds = new Set(scheduled.map((ticket) => ticket.id));
+    const decision = verificationDue(allTickets, runTicketIds);
+    if (!decision.due)
+      return;
+    const findings = new Map((ctx.listFindings?.() ?? []).map((finding) => [finding.id, finding]));
+    const landedLines = decision.landed.map((ticket) => {
+      const finding = ticket.originFindingId ? findings.get(ticket.originFindingId) : undefined;
+      const detail = finding ? `
+  Finding: ${finding.title}
+  Location: ${finding.location}
+  Repro step: ${finding.reproStep}` : "";
+      return `- #${ticket.seq} ${ticket.title}${detail}`;
+    });
+    ctx.storeTickets([{
+      kind: "review",
+      passKind: "verification",
+      title: "Verify the fixes that landed",
+      goal: "Tour the current build and verify the fixes that landed in this run.",
+      context: [
+        `Verifies pass: ${decision.verifies ? `#${decision.verifies.seq}` : "none in this run"}`,
+        "Landed implementation tickets:",
+        ...landedLines
+      ].join(`
+`),
+      acceptanceCriteria: ["Tour the current build and verify every landed fix listed in the context."],
+      seams: ["review evidence and the landed fixes listed in the context"],
+      blockedBy: []
+    }]);
+    ctx.emitEvent({
+      type: "ticket.verification_minted",
+      message: `verification pass appended \u2014 ${decision.landed.length} fixes landed after the review`,
+      data: { landedSeqs: decision.landed.map((ticket) => ticket.seq) }
+    });
+    admitNewTickets();
+  };
   const mirrorFinding = (t, progress, reason) => {
     if (!t.originFindingId)
       return;
@@ -56990,7 +57224,13 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
     const outcome = await execute(ctx, t, { digests: [...digests] });
     if (outcome.status === "done") {
       status3.set(seq2, "done");
-      ctx.updateTicket(t.id, { status: "done", commits: outcome.commits, digest: outcome.digest });
+      const reviewedCommit = isReviewTicket(t) ? await headSha(ctx.project.repoPath, ctx.feature.branch) : undefined;
+      ctx.updateTicket(t.id, {
+        status: "done",
+        commits: outcome.commits,
+        digest: outcome.digest,
+        ...reviewedCommit ? { reviewedCommit } : {}
+      });
       mirrorFinding(t, "fixed");
       ctx.emitEvent({
         type: "ticket.done",
@@ -57018,8 +57258,13 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
     if (isReviewTicket(t))
       admitNewTickets();
   };
-  while (pending3.size > 0 || inFlight.size > 0) {
+  while (pending3.size > 0 || inFlight.size > 0 || !verificationChecked) {
     ctx.signal.throwIfAborted();
+    if (pending3.size === 0 && inFlight.size === 0) {
+      appendVerificationIfDue();
+      if (pending3.size === 0)
+        break;
+    }
     for (const seq2 of [...pending3]) {
       const st = readyState(seq2);
       if (typeof st === "object") {
@@ -57365,7 +57610,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land, ensureIsolat
   const attachmentCommands = buildAttachmentCopyCommands(attachments);
   const excludeAttachments = async () => {
     if (attachments.length > 0)
-      await excludePath(project3.repoPath, `${ATTACHMENTS_DIR}/`);
+      await excludePath(project3.repoPath, ATTACHMENTS_PREFIX);
   };
   const clearAttachmentsFor = async (branch) => {
     if (attachments.length > 0) {
@@ -57878,7 +58123,7 @@ function readTokenFromEnvFile(path2, runtime5) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env[key];
   return token && token.length > 0 ? token : undefined;
 }
-var AUTH_MISSING_EVENT = "auth.missing", IMAGE_RUNTIME_MISSING_EVENT = "burn.image_runtime_missing", RUNTIME_BINARY, DROPPED_MAP_SECTIONS, AGENT_CONVENTIONS_FILE = "CLAUDE.md", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, CODEX_HOST_MOUNT_PATH = "/mnt/host-codex", SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", SETUP_MARKER_FILE = ".runcastle-setup", SETUP_MARKER = "RUNCASTLE_SETUP", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RUNTIME_FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, RUNTIME_RETRYABLE_ERROR_PATTERNS, AGENT_BINARY, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
+var ATTACHMENTS_PREFIX, AUTH_MISSING_EVENT = "auth.missing", IMAGE_RUNTIME_MISSING_EVENT = "burn.image_runtime_missing", RUNTIME_BINARY, DROPPED_MAP_SECTIONS, AGENT_CONVENTIONS_FILE = "CLAUDE.md", PACKAGE_MANAGERS, PM_CACHE_SANDBOX_PATHS, CODEX_HOST_MOUNT_PATH = "/mnt/host-codex", SANDBOX_WORKSPACE_PATH = "/home/agent/workspace", ISOLATED_REPO_PATH = "/home/agent/repo", SETUP_MARKER_FILE = ".runcastle-setup", SETUP_MARKER = "RUNCASTLE_SETUP", RUN, BASH_PATTERNS, TOOL_NAME_CATEGORY, MAX_ATTRIBUTABLE_GAP_MS, BURN_WORKTREE_PATH, WORKTREE_REMOVAL_FAILURES, FATAL_ERROR_PATTERNS, RUNTIME_FATAL_ERROR_PATTERNS, RETRYABLE_ERROR_PATTERNS, RUNTIME_RETRYABLE_ERROR_PATTERNS, AGENT_BINARY, activeTicketAborts, SETUP_HOOK_TIMEOUT_MS, ticketBurner;
 var init_ticket_burner = __esm(() => {
   init_src();
   init_config_load();
@@ -57897,6 +58142,7 @@ var init_ticket_burner = __esm(() => {
   init_docker();
   init_podman();
   init_no_sandbox();
+  ATTACHMENTS_PREFIX = `${ATTACHMENTS_DIR}/`;
   RUNTIME_BINARY = {
     "claude-code": "claude",
     codex: "codex"
@@ -58226,6 +58472,8 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
       updateTicket(ctx, id3, patch9);
     },
     listTickets: () => listByFeature2(ctx, featureId),
+    storeTickets: (inputs) => storeTickets(ctx, featureId, inputs),
+    listFindings: () => listByFeature3(ctx, featureId),
     updateFinding: (findingId, progress, reason) => {
       markFixProgress(ctx, findingId, progress, reason);
     },
@@ -58508,7 +58756,7 @@ function getFeatureFull(ctx, id3) {
   return {
     feature,
     tickets: listByFeature2(ctx, id3),
-    sessions: listSessionsByFeature(ctx, id3),
+    sessions: listSessionsByFeature(ctx, id3).map((session) => session.kind === "qa" && session.status === "ended" && !session.ccSessionId ? { ...session, title: null, transcriptMissing: true } : session),
     runs: listRunsByFeature(ctx, id3),
     docs: listDocs(ctx, feature),
     gate: gateState(ctx, feature),
@@ -58615,22 +58863,25 @@ async function burn(ctx, featureId, opts = {}) {
     throw e;
   }
 }
+function assertIterable(ctx, feature) {
+  if (hasActiveRun(ctx, feature.id)) {
+    throw new GateError("a run is burning this feature \u2014 cancel or wait for it before iterating");
+  }
+  if (activeTestDriveFeatureId() === feature.id) {
+    throw new GateError(`${feature.slug} is being test-driven \u2014 stop the test drive first, it holds the feature branch`);
+  }
+}
 function rethink(ctx, featureId) {
   const feature = getFeatureRow(ctx, featureId);
   requireNotDraft(feature);
   if (feature.phase !== RETHINK_LOOP_BACK.from) {
     throw new GateError(`feature must be in the review phase to rethink (currently ${feature.phase})`);
   }
-  if (hasActiveRun(ctx, featureId)) {
-    throw new GateError("a run is burning this feature \u2014 cancel or wait for it before rethinking");
-  }
+  assertIterable(ctx, feature);
   const live = activeSessionsForFeature(ctx, featureId);
   if (live.length > 0) {
     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`);
   }
-  if (activeTestDriveFeatureId() === featureId) {
-    throw new GateError(`${feature.slug} is being test-driven \u2014 stop the test drive first, it holds the feature branch`);
-  }
   const lap = feature.lap + 1;
   ctx.db.update(features).set({ lap }).where(eq11(features.id, featureId)).run();
   return setPhase(ctx, featureId, RETHINK_LOOP_BACK.to, "lap.started", `rethink \u2014 lap ${lap}`);
@@ -58842,7 +59093,7 @@ var init_features = __esm(() => {
 // src/services/test-notes.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync12, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname11 } from "path";
-import { asc as asc5, eq as eq12 } from "drizzle-orm";
+import { and as and9, asc as asc5, eq as eq12, lt } from "drizzle-orm";
 function rowToNote(row) {
   return TestNote.parse({
     id: row.id,
@@ -58852,6 +59103,8 @@ function rowToNote(row) {
     status: row.status,
     author: row.author,
     ticketId: row.ticketId ?? undefined,
+    reviewTicketId: row.reviewTicketId ?? undefined,
+    carriedLap: row.carriedLap ?? undefined,
     videoTimestamp: row.videoTimestamp ?? undefined,
     screenshotUrl: existsSync19(annotationPath(row.id)) ? noteScreenshotUrl(row.id) : undefined,
     createdAt: row.createdAt,
@@ -58878,9 +59131,14 @@ function assertOpen(note2, action) {
 function listByFeature4(ctx, featureId) {
   return ctx.db.select().from(testNotes).where(eq12(testNotes.featureId, featureId)).orderBy(asc5(testNotes.createdAt), asc5(testNotes.id)).all().map(rowToNote);
 }
-function addNote(ctx, featureId, text3, author = "human", videoTimestamp) {
+function addNote(ctx, featureId, text3, author = "human", videoTimestamp, reviewTicketId) {
   const body = cleanText(text3);
   const feature = getFeatureRow(ctx, featureId);
+  if (reviewTicketId) {
+    const ticket = getTicket(ctx, reviewTicketId);
+    if (ticket.featureId !== featureId || ticket.kind !== "review")
+      throw new InvalidInputError("review ticket must be a review of the same feature");
+  }
   const now = Date.now();
   const row = ctx.db.insert(testNotes).values({
     id: newId("note"),
@@ -58891,6 +59149,8 @@ function addNote(ctx, featureId, text3, author = "human", videoTimestamp) {
     author,
     ticketId: null,
     videoTimestamp: videoTimestamp ?? null,
+    reviewTicketId: reviewTicketId ?? null,
+    carriedLap: null,
     createdAt: now,
     updatedAt: now
   }).returning().get();
@@ -58942,7 +59202,7 @@ function attachScreenshot(ctx, noteId, png) {
 }
 function toggleNote(ctx, noteId) {
   const current2 = getNote(ctx, noteId);
-  if (current2.status === "promoted") {
+  if (current2.status === "promoted" || current2.status === "carried") {
     throw new InvalidInputError(`cannot toggle note ${noteId} \u2014 it is promoted, and promoted notes are frozen`);
   }
   const status3 = current2.status === "open" ? "done" : "open";
@@ -58962,12 +59222,10 @@ function screenshotParagraph(note2) {
   return `An annotated screenshot of the problem is at ${attachmentRelPath(note2.id)} in your workspace${moment} \u2014 Read it before starting; the drawing marks the problem area.`;
 }
 function promotionTicket(feature, note2) {
-  const firstLine = note2.text.split(`
-`)[0].trim();
   const docs2 = featureDocsRel(feature.slug);
   const screenshot = screenshotParagraph(note2);
   return {
-    title: firstLine.length <= TITLE_MAX ? firstLine : `${firstLine.slice(0, TITLE_MAX - 1).trimEnd()}\u2026`,
+    title: ticketTitleFromNote(note2.text),
     goal: note2.text,
     context: [
       `Found during lap ${note2.lap} test drive of ${feature.slug}.`,
@@ -59030,9 +59288,56 @@ function noteLine(ctx, note2) {
   const shot = screenshotSuffix(note2);
   if (note2.status === "open")
     return `- [ ] ${note2.text}${shot}`;
+  if (note2.status === "carried")
+    return `- [\u2192] ${note2.text} (carried into lap ${note2.carriedLap})${shot}`;
   const ticket = note2.ticketId ? ` (\u2192 ticket ${getTicket(ctx, note2.ticketId).seq})` : "";
   return `- [x] ${note2.text}${ticket}${shot}`;
 }
+function carryNotes(ctx, featureId, noteIds, lap) {
+  const selected = noteIds.map((id3) => getNote(ctx, id3));
+  for (const note2 of selected) {
+    if (note2.featureId !== featureId)
+      throw new InvalidInputError("every carried note must belong to the feature");
+    assertOpen(note2, "carry");
+    ctx.db.update(testNotes).set({ status: "carried", carriedLap: lap, updatedAt: Date.now() }).where(eq12(testNotes.id, note2.id)).run();
+    emit(ctx, featureId, { type: "note.carried", message: `note carried into lap ${lap}`, data: { noteId: note2.id, lap } });
+  }
+  renderTestNotes(ctx, getFeatureRow(ctx, featureId));
+  return selected.map((note2) => getNote(ctx, note2.id));
+}
+function reopenNote(ctx, noteId) {
+  const note2 = getNote(ctx, noteId);
+  if (note2.status !== "carried")
+    throw new InvalidInputError("only a carried note can be reopened");
+  ctx.db.update(testNotes).set({ status: "open", carriedLap: null, updatedAt: Date.now() }).where(eq12(testNotes.id, noteId)).run();
+  emit(ctx, note2.featureId, { type: "note.reopened", message: "note reopened", data: { noteId } });
+  renderTestNotes(ctx, getFeatureRow(ctx, note2.featureId));
+  return getNote(ctx, noteId);
+}
+function triageNotes(ctx, featureId, input) {
+  const feature = getFeatureRow(ctx, featureId);
+  assertIterable(ctx, feature);
+  for (const id3 of input.dismissIds)
+    deleteNote(ctx, id3);
+  const noteTickets = input.quickFixIds.length ? freezeAsTickets(ctx, input.quickFixIds).tickets.length : 0;
+  const findingTickets = input.quickFixFindingIds.length ? promoteOpenDefects(ctx, featureId, input.quickFixFindingIds).tickets.length : 0;
+  const remaining = input.carry ? listByFeature4(ctx, featureId).filter((note2) => note2.status === "open") : [];
+  if (remaining.length)
+    carryNotes(ctx, featureId, remaining.map((note2) => note2.id), feature.lap + 1);
+  return { minted: noteTickets + findingTickets, carried: remaining.length, dismissed: input.dismissIds.length };
+}
+function triagePreview(ctx, featureId) {
+  const feature = getFeatureRow(ctx, featureId);
+  const standing = ctx.db.select().from(tickets).where(and9(eq12(tickets.featureId, featureId), eq12(tickets.kind, "implementation"), eq12(tickets.status, "pending"), lt(tickets.lap, feature.lap))).all();
+  const grouped = new Map;
+  for (const ticket of standing)
+    grouped.set(ticket.lap, (grouped.get(ticket.lap) ?? 0) + 1);
+  return {
+    openNotes: listByFeature4(ctx, featureId).filter((note2) => note2.status === "open").length,
+    openDefects: viewByFeature(ctx, featureId).openDefects.length,
+    standingFixTickets: [...grouped].sort(([a], [b]) => a - b).map(([lap, count3]) => ({ count: count3, lap }))
+  };
+}
 function renderTestNotes(ctx, feature) {
   const notes = listByFeature4(ctx, feature.id);
   const laps = [...new Set(notes.map((n) => n.lap))].sort((a, b) => a - b);
@@ -59048,7 +59353,6 @@ function renderTestNotes(ctx, feature) {
 `)}
 `, "utf8");
 }
-var TITLE_MAX = 60;
 var init_test_notes = __esm(() => {
   init_src();
   init_paths();
@@ -59058,6 +59362,8 @@ var init_test_notes = __esm(() => {
   init_feature_docs();
   init_repo();
   init_tickets();
+  init_features();
+  init_review_findings();
 });
 
 // src/mcp/server.ts
@@ -59302,7 +59608,7 @@ function requireProject(ctx, session) {
     throw new GateError(`project ${session.projectId} not found`);
   return project3;
 }
-function toolRecordFinding(ctx, session, input) {
+async function toolRecordFinding(ctx, session, input) {
   const project3 = requireProject(ctx, session);
   const source = input.userSupplied ? "human" : "session";
   if (!isOverwritable(ctx, project3.id, input.key) && !input.userSupplied) {
@@ -59313,11 +59619,17 @@ function toolRecordFinding(ctx, session, input) {
       skipped: `${input.key} was set by a human and is not auto-overwritable \u2014 ask them to clear it first if it should change`
     };
   }
+  let establishedSha;
+  try {
+    const mainLine = await detectMainBranch(project3.repoPath);
+    establishedSha = await headSha(project3.repoPath, mainLine);
+  } catch {}
   recordFinding(ctx, project3.id, {
     key: input.key,
     value: input.value,
     source,
-    ...input.evidence ? { evidence: input.evidence } : {}
+    ...input.evidence ? { evidence: input.evidence } : {},
+    ...establishedSha ? { establishedSha } : {}
   });
   emitProject(ctx, project3.id, {
     type: "prep.finding_recorded",
@@ -59594,7 +59906,7 @@ function buildMcpServer(audience) {
       const rs = await resolveCtxSession(extra);
       if (!rs)
         return noSession();
-      return ok(toolRecordFinding(rs.ctx, rs.session, args2));
+      return ok(await toolRecordFinding(rs.ctx, rs.session, args2));
     });
   }
   if (wants("dry_run_drive")) {
@@ -60071,7 +60383,7 @@ var init_ws = __esm(() => {
 });
 
 // src/services/prep.ts
-import { and as and9, desc as desc6, eq as eq13, inArray as inArray4 } from "drizzle-orm";
+import { and as and10, desc as desc6, eq as eq13, inArray as inArray5 } from "drizzle-orm";
 function keysToPrepare(ctx, project3) {
   return unsetPreparedKeys(project3).filter((key) => isOverwritable(ctx, project3.id, key));
 }
@@ -60081,10 +60393,10 @@ function isPrepared(ctx, project3) {
   return hasCompletedProjectSession(ctx, project3.id, "prepare");
 }
 function preparedAt(ctx, projectId) {
-  const prepareSessions = new Set(ctx.db.select({ id: sessions.id }).from(sessions).where(and9(eq13(sessions.projectId, projectId), eq13(sessions.kind, "prepare"))).all().map((r) => r.id));
+  const prepareSessions = new Set(ctx.db.select({ id: sessions.id }).from(sessions).where(and10(eq13(sessions.projectId, projectId), eq13(sessions.kind, "prepare"))).all().map((r) => r.id));
   if (prepareSessions.size === 0)
     return null;
-  const ends = ctx.db.select({ ts: events.ts, data: events.data }).from(events).where(and9(eq13(events.projectId, projectId), inArray4(events.type, ["session.ended", "session.reconciled"]))).orderBy(desc6(events.ts)).all();
+  const ends = ctx.db.select({ ts: events.ts, data: events.data }).from(events).where(and10(eq13(events.projectId, projectId), inArray5(events.type, ["session.ended", "session.reconciled"]))).orderBy(desc6(events.ts)).all();
   for (const end5 of ends) {
     const sessionId = end5.data?.sessionId;
     if (sessionId && prepareSessions.has(sessionId))
@@ -60339,15 +60651,12 @@ var init_hooks = __esm(() => {
 });
 
 // src/routes/reviews.ts
-import { createReadStream, statSync as statSync5 } from "fs";
+import { createReadStream, statSync as statSync6 } from "fs";
 import { Readable } from "stream";
 import { Hono as Hono3 } from "hono";
-function walkthroughUrl(ticketId) {
-  return `/api/reviews/ticket/${ticketId}/walkthrough.webm`;
-}
 function fileSize(path2) {
   try {
-    const stat3 = statSync5(path2);
+    const stat3 = statSync6(path2);
     return stat3.isFile() ? stat3.size : undefined;
   } catch {
     return;
@@ -60390,9 +60699,6 @@ function parseRange(header, size6) {
 function fileStream(path2, start3, end5) {
   return Readable.toWeb(createReadStream(path2, { start: start3, end: end5 }));
 }
-function findNote(ctx, noteId) {
-  return lookupOrUndefined(() => getNote(ctx, noteId));
-}
 function isPng(bytes) {
   return bytes.length > PNG_MAGIC.length && PNG_MAGIC.every((byte, i) => bytes[i] === byte);
 }
@@ -60404,20 +60710,32 @@ var init_reviews = __esm(() => {
   init_test_notes();
   init_tickets();
   reviews = new Hono3;
-  reviews.get("/:featureId", async (c) => {
+  reviews.get(REVIEW_ARTIFACTS_ROUTE, async (c) => {
     const ctx = await getRuntimeCtx();
-    const artifacts = listByFeature2(ctx, c.req.param("featureId")).filter((t) => t.kind === "review").map((t) => {
+    const allTickets = listByFeature2(ctx, c.req.param("featureId"));
+    const artifacts = allTickets.filter((t) => t.kind === "review").map((t) => {
       const hasVideo = fileSize(reviewWalkthroughPath(t.id)) !== undefined;
       return {
         ticketId: t.id,
         seq: t.seq,
+        lap: t.lap,
+        passKind: t.passKind,
+        reviewedCommit: t.reviewedCommit,
+        completedAt: t.completedAt,
+        landedSince: t.completedAt === null ? 0 : allTickets.filter((candidate) => candidate.kind === "implementation" && candidate.status === "done" && candidate.completedAt !== null && candidate.completedAt > t.completedAt).length,
         hasVideo,
-        videoUrl: hasVideo ? walkthroughUrl(t.id) : null
-      };
+        videoUrl: hasVideo ? reviewWalkthroughUrl(t.id) : null
+      };
+    }).sort((a, b) => {
+      if (a.completedAt === null)
+        return b.completedAt === null ? a.seq - b.seq : 1;
+      if (b.completedAt === null)
+        return -1;
+      return a.completedAt - b.completedAt || a.seq - b.seq;
     });
     return c.json(artifacts);
   });
-  reviews.get("/ticket/:ticketId/walkthrough.webm", async (c) => {
+  reviews.get(REVIEW_WALKTHROUGH_ROUTE, async (c) => {
     const ctx = await getRuntimeCtx();
     const ticket = findReviewTicket(ctx, c.req.param("ticketId"));
     if (!ticket)
@@ -60448,7 +60766,7 @@ var init_reviews = __esm(() => {
   PNG_MAGIC = Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10]);
   reviews.post(NOTE_SCREENSHOT_UPLOAD_ROUTE, async (c) => {
     const ctx = await getRuntimeCtx();
-    const note2 = findNote(ctx, c.req.param("noteId"));
+    const note2 = lookupOrUndefined(() => getNote(ctx, c.req.param("noteId")));
     if (!note2)
       return c.notFound();
     const png = new Uint8Array(await c.req.arrayBuffer());
@@ -60458,7 +60776,7 @@ var init_reviews = __esm(() => {
   });
   reviews.get(NOTE_SCREENSHOT_ROUTE, async (c) => {
     const ctx = await getRuntimeCtx();
-    const note2 = findNote(ctx, c.req.param("noteId"));
+    const note2 = lookupOrUndefined(() => getNote(ctx, c.req.param("noteId")));
     if (!note2)
       return c.notFound();
     const path2 = annotationPath(note2.id);
@@ -60525,7 +60843,7 @@ var init_stream = __esm(() => {
 });
 
 // src/routes/web.ts
-import { existsSync as existsSync21, statSync as statSync6 } from "fs";
+import { existsSync as existsSync21, statSync as statSync7 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { extname, join as join20, normalize as normalize2, resolve as resolve11, sep as sep3 } from "path";
 function contentType(path2) {
@@ -60533,7 +60851,7 @@ function contentType(path2) {
 }
 function isFile2(path2) {
   try {
-    return statSync6(path2).isFile();
+    return statSync7(path2).isFile();
   } catch {
     return false;
   }
@@ -60836,7 +61154,7 @@ var init_events2 = __esm(() => {
 // src/launcher/launcher.ts
 import { existsSync as existsSync23 } from "fs";
 import { join as join23 } from "path";
-import { and as and10, eq as eq14 } from "drizzle-orm";
+import { and as and11, eq as eq14 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
   return `terminal exited (code ${label})`;
@@ -60856,7 +61174,7 @@ function renderCommand(runtime5, spec) {
   return [...env, runtime5.binary, ...spec.argv].join(" ");
 }
 function activeRunFor(ctx, featureId) {
-  const row = ctx.db.select().from(runs).where(and10(eq14(runs.featureId, featureId), eq14(runs.status, "running"))).limit(1).get();
+  const row = ctx.db.select().from(runs).where(and11(eq14(runs.featureId, featureId), eq14(runs.status, "running"))).limit(1).get();
   return row ? rowToRun(row) : null;
 }
 function assertSpawnable(ctx, feature, excludeSessionId) {
@@ -61500,69 +61818,126 @@ var init_launcher = __esm(() => {
 // src/services/outcome.ts
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync10 } from "fs";
 import { join as join25 } from "path";
-function composeOutcomeDoc(feature, tickets2, shippedAt) {
+function digestHasSubstance(text3) {
+  return text3.split(`
+`).some((line) => {
+    const trimmed = line.trim();
+    return /^[-*]\s+/.test(trimmed) && !EMPTY_VALUE.test(trimmed);
+  });
+}
+function findingResolution(finding) {
+  return finding.status === "fixed" ? "fixed" : finding.status === "dismissed" ? "dismissed" : "open";
+}
+function noteResolution(note2) {
+  if (note2.status === "promoted")
+    return `quick-fixed \u2192 ticket ${note2.ticketId ?? "unknown"}`;
+  if (note2.status === "carried")
+    return `carried \u2192 lap ${note2.carriedLap ?? "?"}`;
+  if (note2.status === "done")
+    return "dismissed/done";
+  return "open";
+}
+function composeOutcomeDoc(input) {
+  const { feature, tickets: tickets2, findings, notes, artifacts, shippedAt, delta } = input;
+  const laps = Math.max(feature.lap, ...tickets2.map((ticket) => ticket.lap), 1);
   const blocks = [
     `# Outcome \u2014 ${feature.title}`,
     feature.oneLiner,
-    [`- Shipped: ${shippedDate(shippedAt)}`, `- Lap: ${feature.lap}`].join(`
-`)
+    `- Shipped: ${new Date(shippedAt).toISOString().slice(0, 10)}
+- Laps run: ${laps}`,
+    `## What shipped
+
+${delta.commits} commits \xB7 ${delta.files} files`
   ];
-  let oneLiners = [];
-  const flush = () => {
-    if (oneLiners.length > 0)
-      blocks.push(oneLiners.join(`
-`));
-    oneLiners = [];
-  };
-  for (const ticket of [...tickets2].sort((a, b) => a.seq - b.seq)) {
-    if (ticket.status === "done") {
-      flush();
-      blocks.push(`## ${ticket.seq}. ${ticket.title}`, ticket.digest?.trim() || NO_DIGEST);
-    } else {
-      oneLiners.push(oneLineEntry(ticket));
+  for (let lap = 1;lap <= laps; lap += 1) {
+    const implementation = tickets2.filter((ticket) => ticket.kind === "implementation" && ticket.lap === lap);
+    const line = (status3, label) => {
+      const matches = implementation.filter((ticket) => ticket.status === status3);
+      return `- ${matches.length} ${label}${matches.length ? `: ${matches.map((t2) => `#${t2.seq} ${t2.title}`).join("; ")}` : ""}`;
+    };
+    blocks.push(`### Lap ${lap}
+${line("done", "tickets landed")}
+${line("cancelled", "waived")}
+${line("failed", "failed")}`);
+  }
+  blocks.push("## Review record");
+  const completed = artifacts.filter((artifact) => artifact.completedAt !== null);
+  const latest = [...completed].sort((a, b) => a.completedAt - b.completedAt).at(-1);
+  for (const artifact of completed) {
+    const ticket = tickets2.find((candidate) => candidate.id === artifact.ticketId);
+    blocks.push(`### Lap ${artifact.lap} \xB7 ${artifact.passKind}
+
+- Reviewed commit: ${artifact.reviewedCommit ?? "unknown"}
+- Landed since: ${artifact.landedSince}
+- Outcome: ${ticket?.status ?? "unknown"}`);
+    if (artifact.ticketId === latest?.ticketId) {
+      const passFindings = findings.filter((finding) => finding.reviewTicketId === artifact.ticketId);
+      blocks.push(passFindings.length ? passFindings.map((finding) => `- **${finding.title}** \u2014 ${findingResolution(finding)}`).join(`
+`) : "- No findings");
+    }
+  }
+  if (!completed.length)
+    blocks.push("- No completed review pass");
+  blocks.push("## Notes record", notes.length ? notes.map((note2) => `- ${note2.text} \u2014 ${noteResolution(note2)}`).join(`
+`) : "- No human notes");
+  const substantive = tickets2.filter((ticket) => ticket.digest && digestHasSubstance(ticket.digest));
+  if (substantive.length) {
+    blocks.push("## Per-ticket digests");
+    for (let lap = 1;lap <= laps; lap += 1) {
+      const inLap = substantive.filter((ticket) => ticket.lap === lap);
+      if (inLap.length)
+        blocks.push(`### Lap ${lap}`, ...inLap.map((ticket) => `#### ${ticket.seq}. ${ticket.title}
+
+${ticket.digest.trim()}`));
     }
   }
-  flush();
   return `${blocks.join(`
 
 `)}
 `;
 }
-function shippedDate(shippedAt) {
-  return new Date(shippedAt).toISOString().slice(0, 10);
-}
-function oneLineEntry(ticket) {
-  const headline = errorHeadline3(ticket.error ?? "");
-  return `- **${ticket.seq}. ${ticket.title}** \u2014 ${ticket.status}${headline ? `: ${headline}` : ""}`;
-}
-function errorHeadline3(error) {
-  const lines = error.split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const causes = lines.filter((l) => /^(fatal|error):/i.test(l));
-  const headline = causes.at(-1) ?? lines[0] ?? "";
-  return headline.length > HEADLINE_MAX ? `${headline.slice(0, HEADLINE_MAX)}\u2026` : headline;
-}
-async function promoteOutcomeDoc(ctx, project3, feature) {
+async function promoteOutcomeDoc(ctx, project3, feature, target, delta) {
   try {
-    const worktreePath = await ensureTalkWorktree(project3, feature);
-    const docsDir = join25(worktreePath, ...featureDocsRel(feature.slug).split("/"));
-    mkdirSync14(docsDir, { recursive: true });
-    const doc = composeOutcomeDoc(feature, listByFeature2(ctx, feature.id), Date.now());
-    writeFileSync10(join25(docsDir, "outcome.md"), doc, "utf8");
-    await commitDocs(worktreePath, `runcastle: outcome for ${feature.slug}`);
-  } catch (e) {
+    const tickets2 = listByFeature2(ctx, feature.id);
+    const artifacts = tickets2.filter((ticket) => ticket.kind === "review").map((ticket) => ({
+      ticketId: ticket.id,
+      lap: ticket.lap,
+      passKind: ticket.passKind,
+      reviewedCommit: ticket.reviewedCommit,
+      completedAt: ticket.completedAt,
+      landedSince: ticket.completedAt === null ? 0 : tickets2.filter((candidate) => candidate.kind === "implementation" && candidate.status === "done" && candidate.completedAt !== null && candidate.completedAt > ticket.completedAt).length
+    }));
+    const doc = composeOutcomeDoc({
+      feature,
+      tickets: tickets2,
+      findings: listByFeature3(ctx, feature.id),
+      notes: listByFeature4(ctx, feature.id),
+      artifacts,
+      shippedAt: Date.now(),
+      delta: { commits: delta.commits ?? 0, files: delta.files ?? 0 }
+    });
+    await onBranch(project3.repoPath, target, async () => {
+      const docsDir = join25(project3.repoPath, ...featureDocsRel(feature.slug).split("/"));
+      mkdirSync14(docsDir, { recursive: true });
+      writeFileSync10(join25(docsDir, "outcome.md"), doc, "utf8");
+      await commitDocs(project3.repoPath, `runcastle: outcome for ${feature.slug}`);
+    });
+  } catch (error) {
     emit(ctx, feature.id, {
       type: "docs.outcome_failed",
-      message: `outcome.md not promoted: ${e instanceof Error ? e.message : String(e)}`
+      message: `outcome.md not promoted on ${target}: ${error instanceof Error ? error.message : String(error)}`
     });
   }
 }
-var NO_DIGEST = "_no digest captured_", HEADLINE_MAX = 160;
+var EMPTY_VALUE;
 var init_outcome = __esm(() => {
   init_paths();
   init_events();
   init_git();
+  init_review_findings();
+  init_test_notes();
   init_tickets();
+  EMPTY_VALUE = /^(?:[-*]\s*)?(?:none|nothing|n\/?a)[.!]?$/i;
 });
 
 // src/trpc/routers/feature.ts
@@ -61585,6 +61960,7 @@ var init_feature = __esm(() => {
       projectId: z7.string(),
       title: z7.string().min(1),
       oneLiner: z7.string(),
+      brief: z7.string().optional(),
       baseBranch: z7.string().optional(),
       draft: z7.boolean().optional()
     })).mutation(({ ctx, input }) => createFeature(ctx, input)),
@@ -61632,6 +62008,10 @@ var init_feature = __esm(() => {
       const feature = getFeatureRow(ctx, input.featureId);
       return reviewCommitCount(projectForFeature(ctx, feature), feature);
     }),
+    mergeDelta: publicProcedure.input(z7.object({ featureId: z7.string() })).query(({ ctx, input }) => {
+      const feature = getFeatureRow(ctx, input.featureId);
+      return mergeDelta(projectForFeature(ctx, feature), feature);
+    }),
     merge: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(async ({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
       requireNotDraft(feature);
@@ -61639,9 +62019,17 @@ var init_feature = __esm(() => {
       if (activeTestDriveFeatureId() === feature.id) {
         await testDrive(ctx, project3, feature, "stop");
       }
-      await promoteOutcomeDoc(ctx, project3, feature);
+      const delta = await mergeDelta(project3, feature);
+      const standingConflict = unresolvedMergeConflict(listAfter(ctx, feature.id, 0));
       const res = await mergeFeature(project3, feature);
       if (res.ok) {
+        if (standingConflict) {
+          emit(ctx, input.featureId, {
+            type: "merge.resolved",
+            message: "conflict retired by the merge"
+          });
+        }
+        await promoteOutcomeDoc(ctx, project3, feature, res.target, delta);
         setPhase(ctx, input.featureId, "shipped", "feature.shipped", `merged to ${res.target}`);
         setFeatureStatus(ctx, input.featureId, "shipped");
       } else {
@@ -61657,9 +62045,9 @@ var init_feature = __esm(() => {
 });
 
 // src/services/fsbrowse.ts
-import { existsSync as existsSync24, readdirSync as readdirSync6, statSync as statSync7 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync6, statSync as statSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename4, dirname as dirname14, isAbsolute as isAbsolute3, join as join26, resolve as resolve12, sep as sep4 } from "path";
+import { basename as basename3, dirname as dirname14, isAbsolute as isAbsolute3, join as join26, resolve as resolve12, sep as sep4 } from "path";
 function expandPath(input, home = homedir4()) {
   const trimmed = input.trim();
   if (trimmed === "")
@@ -61711,7 +62099,7 @@ function crumbsFor(dir) {
   const out = [];
   let cur = dir;
   for (;; ) {
-    out.unshift({ name: basename4(cur) || cur, path: cur });
+    out.unshift({ name: basename3(cur) || cur, path: cur });
     const parent = dirname14(cur);
     if (parent === cur)
       break;
@@ -61733,7 +62121,7 @@ function browseDir(input, showHidden = false, home = homedir4()) {
   }
   let dir = target;
   try {
-    if (!statSync7(target).isDirectory())
+    if (!statSync8(target).isDirectory())
       dir = dirname14(target);
   } catch (e) {
     throw new InvalidInputError(`cannot read path: ${target} (${errMsg4(e)})`);
@@ -61763,7 +62151,7 @@ function browseDir(input, showHidden = false, home = homedir4()) {
     let isDirectory = dirent.isDirectory();
     if (isSymlink) {
       try {
-        isDirectory = statSync7(path2).isDirectory();
+        isDirectory = statSync8(path2).isDirectory();
       } catch {
         continue;
       }
@@ -61901,38 +62289,72 @@ function withoutKickoff(turns, kind, runtime5) {
   const kickoff = kickoffLineFor(kind, undefined, runtime5);
   return turns.filter((turn) => !(turn.role === "user" && promptMatchesKickoff(kickoff, turn.text)));
 }
+function saidText(text3) {
+  const trimmed = text3.trim();
+  if (trimmed.startsWith("<command-name>"))
+    return null;
+  if (trimmed === INTERRUPTED)
+    return null;
+  return trimmed.replace(/\[Image #\d+\]/g, " ").trim() || null;
+}
 function deriveTitle(turns, runtime5) {
-  const first = withoutKickoff(turns, "project", runtime5).find((turn) => turn.role === "user");
-  return first ? elide(first.text) : null;
+  for (const turn of withoutKickoff(turns, "project", runtime5)) {
+    if (turn.role !== "user")
+      continue;
+    const said = saidText(turn.text);
+    if (said)
+      return elide(said);
+  }
+  return null;
 }
 function elide(text3) {
   const line = text3.replace(/\s+/g, " ").trim();
-  if (line.length <= TITLE_MAX2)
+  if (line.length <= TITLE_MAX)
     return line;
-  return `${line.slice(0, TITLE_MAX2).trimEnd()}\u2026`;
+  return `${line.slice(0, TITLE_MAX).trimEnd()}\u2026`;
 }
-function untitled(createdAt) {
-  return createdAt ? `Chat from ${new Date(createdAt).toISOString().slice(0, 10)}` : "Untitled chat";
+function junkTitle(title) {
+  return title.startsWith("<command-name>") || title.startsWith("[");
 }
 function listProjectConversations(ctx, projectId) {
-  return projectSessions(ctx, projectId, "project").map((session) => {
-    const createdAt = session.createdAt ?? null;
-    const runtime5 = session.runtime ?? DEFAULT_RUNTIME;
-    let title = session.title ?? null;
-    if (!title) {
-      title = deriveTitle(readTranscript2(session.transcriptPath, runtime5).turns, runtime5);
-      if (title)
-        setSessionTitle(ctx, session.id, title);
-    }
+  return groupByConversation(projectSessions(ctx, projectId, "project")).map((group) => {
+    const [latest] = group;
+    const earliest = group[group.length - 1];
+    const stamps = group.map((s) => s.createdAt).filter((at) => at !== undefined);
     return {
-      id: session.id,
-      title: title ?? untitled(createdAt),
-      createdAt,
-      status: session.status,
-      resumable: !!session.ccSessionId
+      id: latest.id,
+      title: conversationTitle(ctx, earliest),
+      createdAt: stamps.length ? Math.min(...stamps) : null,
+      status: latest.status,
+      resumable: true
     };
   });
 }
+function groupByConversation(rows) {
+  const groups = new Map;
+  for (const row of rows) {
+    if (!row.ccSessionId)
+      continue;
+    const group = groups.get(row.ccSessionId);
+    if (group)
+      group.push(row);
+    else
+      groups.set(row.ccSessionId, [row]);
+  }
+  return [...groups.values()];
+}
+function conversationTitle(ctx, earliest) {
+  const cached5 = earliest.title;
+  if (cached5 && !junkTitle(cached5))
+    return cached5;
+  const runtime5 = earliest.runtime ?? DEFAULT_RUNTIME;
+  const derived = deriveTitle(readTranscript2(earliest.transcriptPath, runtime5).turns, runtime5);
+  if (derived)
+    setSessionTitle(ctx, earliest.id, derived);
+  else if (cached5)
+    clearSessionTitle(ctx, earliest.id);
+  return derived ?? UNTITLED;
+}
 function conversationTranscript(ctx, sessionId) {
   const session = getSessionRow(ctx, sessionId);
   if (!session)
@@ -61945,7 +62367,7 @@ function conversationTranscript(ctx, sessionId) {
     runtime: runtime5
   };
 }
-var TITLE_MAX2 = 60;
+var TITLE_MAX = 60, INTERRUPTED = "[Request interrupted by user]", UNTITLED = "Untitled";
 var init_conversations = __esm(() => {
   init_src();
   init_sessions();
@@ -61954,7 +62376,7 @@ var init_conversations = __esm(() => {
 
 // src/services/projects.ts
 import { existsSync as existsSync25 } from "fs";
-import { basename as basename5, join as join27 } from "path";
+import { basename as basename4, join as join27 } from "path";
 import { eq as eq15, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
@@ -61973,7 +62395,7 @@ function warnIfTranslatedMount(ctx, projectId, repoPath) {
 async function openProject(ctx, rawPath) {
   const repoPath = expandPath(rawPath);
   await assertRepoTolerant(ctx, repoPath);
-  const name = basename5(repoPath) || repoPath;
+  const name = basename4(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
     ctx.db.update(projects).set({ repoPath, closedAt: null }).where(eq15(projects.id, existing.id)).run();
@@ -62066,7 +62488,9 @@ var init_project = __esm(() => {
     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))),
+    branches: publicProcedure.input(z8.object({ projectId: z8.string(), includeFeatureBranches: z8.boolean().optional() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId), {
+      includeFeatureBranches: input.includeFeatureBranches
+    })),
     sessionBranch: publicProcedure.input(z8.object({ projectId: z8.string() })).query(({ ctx, input }) => sessionBranchView(requireProjectById(ctx, input.projectId))),
     open: publicProcedure.input(z8.object({ repoPath: z8.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
     close: publicProcedure.input(z8.object({ projectId: z8.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
@@ -62104,16 +62528,52 @@ var init_review_findings2 = __esm(() => {
   });
 });
 
+// src/services/runs.ts
+import { and as and12, asc as asc6, eq as eq16, isNotNull as isNotNull3 } from "drizzle-orm";
+function runTicketIds(ctx, runId) {
+  const rows = ctx.db.select({ ticketId: events.ticketId }).from(events).where(and12(eq16(events.runId, runId), isNotNull3(events.ticketId))).orderBy(asc6(events.id)).all();
+  const seen = new Set;
+  for (const row of rows)
+    if (row.ticketId)
+      seen.add(row.ticketId);
+  return [...seen];
+}
+function runLap(ctx, runId) {
+  const row = ctx.db.select({ lap: events.lap }).from(events).where(eq16(events.runId, runId)).orderBy(asc6(events.id)).limit(1).get();
+  return row?.lap ?? 1;
+}
+function listRunSummaries(ctx, featureId) {
+  return listRunsByFeature(ctx, featureId).map((run7) => ({
+    id: run7.id,
+    status: run7.status,
+    startedAt: run7.startedAt,
+    ...run7.endedAt === undefined ? {} : { endedAt: run7.endedAt },
+    lap: runLap(ctx, run7.id),
+    ticketIds: runTicketIds(ctx, run7.id)
+  }));
+}
+function getRunWithTickets(ctx, runId) {
+  const run7 = getRunRow(ctx, runId);
+  return { ...run7, tickets: listByIds(ctx, runTicketIds(ctx, runId)) };
+}
+var init_runs = __esm(() => {
+  init_schema();
+  init_repo();
+  init_tickets();
+});
+
 // src/trpc/routers/run.ts
 import * as z10 from "zod";
 var runRouter;
 var init_run = __esm(() => {
   init_agent_stream();
   init_repo();
+  init_runs();
   init_runner();
   init_context();
   runRouter = router({
-    get: publicProcedure.input(z10.object({ runId: z10.string() })).query(({ ctx, input }) => getRunRow(ctx, input.runId)),
+    get: publicProcedure.input(z10.object({ runId: z10.string() })).query(({ ctx, input }) => getRunWithTickets(ctx, input.runId)),
+    listByFeature: publicProcedure.input(z10.object({ featureId: z10.string() })).query(({ ctx, input }) => listRunSummaries(ctx, input.featureId)),
     agentTranscript: publicProcedure.input(z10.object({ ticketId: z10.string(), after: z10.number().int().optional() })).query(({ input }) => readTranscript(input.ticketId, input.after ?? -1)),
     cancel: publicProcedure.input(z10.object({ runId: z10.string() })).mutation(({ ctx, input }) => {
       getRunRow(ctx, input.runId);
@@ -62137,7 +62597,7 @@ var init_settings2 = __esm(() => {
 });
 
 // src/trpc/routers/setup.ts
-import { isNotNull as isNotNull3 } from "drizzle-orm";
+import { isNotNull as isNotNull4 } from "drizzle-orm";
 import * as z12 from "zod";
 var setupRouter;
 var init_setup2 = __esm(() => {
@@ -62151,7 +62611,7 @@ var init_setup2 = __esm(() => {
   init_context();
   setupRouter = router({
     doctor: publicProcedure.query(({ ctx }) => {
-      const projectModels = ctx.db.select({ model: projects.model }).from(projects).where(isNotNull3(projects.model)).all().map((p) => p.model);
+      const projectModels = ctx.db.select({ model: projects.model }).from(projects).where(isNotNull4(projects.model)).all().map((p) => p.model);
       return runDoctor({
         exec: createSystemExec(),
         runtimes: configuredRuntimes(ctx.config, projectModels),
@@ -62241,18 +62701,27 @@ var testNotesRouter;
 var init_test_notes2 = __esm(() => {
   init_test_notes();
   init_context();
+  init_errors();
   testNotesRouter = router({
     list: publicProcedure.input(z14.object({ featureId: z14.string() })).query(({ ctx, input }) => listByFeature4(ctx, input.featureId)),
     add: publicProcedure.input(z14.object({
       featureId: z14.string(),
       text: z14.string().min(1),
-      videoTimestamp: z14.number().nonnegative().optional()
-    })).mutation(({ ctx, input }) => addNote(ctx, input.featureId, input.text, "human", input.videoTimestamp)),
+      videoTimestamp: z14.number().nonnegative().optional(),
+      reviewTicketId: z14.string().optional()
+    })).mutation(({ ctx, input }) => {
+      if (input.videoTimestamp !== undefined && !input.reviewTicketId)
+        throw new InvalidInputError("a video timestamp must identify its review ticket");
+      return addNote(ctx, input.featureId, input.text, "human", input.videoTimestamp, input.reviewTicketId);
+    }),
     edit: publicProcedure.input(z14.object({ noteId: z14.string(), text: z14.string().min(1) })).mutation(({ ctx, input }) => editNote(ctx, input.noteId, input.text)),
     remove: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => deleteNote(ctx, input.noteId)),
     toggle: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => toggleNote(ctx, input.noteId)),
     promote: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => promoteNote(ctx, input.noteId)),
-    promoteMany: publicProcedure.input(z14.object({ noteIds: z14.array(z14.string()).min(1) })).mutation(({ ctx, input }) => promoteMany(ctx, input.noteIds))
+    promoteMany: publicProcedure.input(z14.object({ noteIds: z14.array(z14.string()).min(1) })).mutation(({ ctx, input }) => promoteMany(ctx, input.noteIds)),
+    reopen: publicProcedure.input(z14.object({ noteId: z14.string() })).mutation(({ ctx, input }) => reopenNote(ctx, input.noteId)),
+    triage: publicProcedure.input(z14.object({ featureId: z14.string(), quickFixIds: z14.array(z14.string()), quickFixFindingIds: z14.array(z14.string()), dismissIds: z14.array(z14.string()), carry: z14.boolean() })).mutation(({ ctx, input }) => triageNotes(ctx, input.featureId, input)),
+    triagePreview: publicProcedure.input(z14.object({ featureId: z14.string() })).query(({ ctx, input }) => triagePreview(ctx, input.featureId))
   });
 });
 
@@ -62278,6 +62747,7 @@ var init_ticket = __esm(() => {
       return { stopped: false, swept: false };
     }),
     cancel: publicProcedure.input(z15.object({ ticketId: z15.string(), reason: z15.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
+    durationStats: publicProcedure.input(z15.object({ projectId: z15.string() })).query(({ ctx, input }) => ticketDurationStats(ctx, input.projectId)),
     edit: publicProcedure.input(z15.object({
       ticketId: z15.string(),
       title: z15.string().min(1).optional(),
@@ -62323,14 +62793,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq16 } from "drizzle-orm";
+import { eq as eq17 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq16(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq17(runs.status, "running")).all().map(rowToRun);
   const reconciled = [];
   for (const run7 of stale) {
     if (isRunActive(run7.id))
       continue;
-    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq16(runs.id, run7.id)).run();
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq17(runs.id, run7.id)).run();
     const released = releaseForSession(ctx, run7.id);
     const swept = workflowClaimsFeatureBranch(run7.workflow) ? sweepOrphanedBurning(ctx, run7.featureId, "orphaned by server restart \u2014 retry to resume its commits") : [];
     if (workflowClaimsFeatureBranch(run7.workflow)) {