runcastle 1.3.3 → 1.3.4

package/index.js

@@ -24,6 +24,12 @@ function newId(prefix) {
 var init_ids = () => {};
 
 // ../core/src/docs.ts
+function withheldFeatureDocs(state) {
+  if (!state.carriedNotesOpen)
+    return WITHHELD_FEATURE_DOCS;
+  const { "test-notes.md": _testNotes, ...rest } = WITHHELD_FEATURE_DOCS;
+  return rest;
+}
 function isAgentDigestDoc(relPath) {
   if (relPath.includes("/") || relPath.includes("\\"))
     return false;
@@ -322,7 +328,8 @@ var init_schemas = __esm(() => {
     "devCommand",
     "driveSetupCommand",
     "driveStopCommand",
-    "dbResetCommand"
+    "dbResetCommand",
+    "driveInstructions"
   ];
   PreparedKey = z2.enum(PREPARED_KEYS);
   DRIVE_LOOP_KEYS = [
@@ -345,6 +352,7 @@ var init_schemas = __esm(() => {
     dbResetCommand: z2.string().optional(),
     driveSetupCommand: z2.string().optional(),
     driveStopCommand: z2.string().optional(),
+    driveInstructions: z2.string().optional(),
     closedAt: z2.number().optional()
   });
   ProjectFinding = z2.object({
@@ -366,6 +374,7 @@ var init_schemas = __esm(() => {
     brief: z2.string().optional(),
     mapped: z2.boolean(),
     lap: z2.number(),
+    ticketsReadyLap: z2.number().nullable(),
     phase: Phase,
     branch: z2.string(),
     baseBranch: z2.string().optional(),
@@ -550,6 +559,9 @@ function nextPhase(feature) {
     return null;
   return ORDER[i + 1];
 }
+function isPastPhase(feature, phase) {
+  return ORDER.indexOf(feature.phase) > ORDER.indexOf(phase);
+}
 function previousPhase(feature) {
   const i = ORDER.indexOf(feature.phase);
   if (i <= 0)
@@ -637,6 +649,7 @@ var init_db_schema = __esm(() => {
     verifyCommands: text("verify_commands"),
     knownFailures: text("known_failures"),
     dbResetCommand: text("db_reset_command"),
+    driveInstructions: text("drive_instructions"),
     driveSetupCommand: text("drive_setup_command"),
     driveStopCommand: text("drive_stop_command")
   });
@@ -659,6 +672,7 @@ var init_db_schema = __esm(() => {
     brief: text("brief"),
     mapped: integer("mapped", { mode: "boolean" }).notNull().default(false),
     lap: integer("lap").notNull().default(1),
+    ticketsReadyLap: integer("tickets_ready_lap"),
     phase: text("phase").notNull().$type(),
     branch: text("branch").notNull(),
     baseBranch: text("base_branch"),
@@ -2099,6 +2113,7 @@ function rowToFeature(row) {
     brief: row.brief ?? undefined,
     mapped: row.mapped,
     lap: row.lap,
+    ticketsReadyLap: row.ticketsReadyLap,
     phase: row.phase,
     branch: row.branch,
     baseBranch: row.baseBranch ?? undefined,
@@ -2120,6 +2135,7 @@ function rowToProject(row) {
     dbResetCommand: row.dbResetCommand ?? undefined,
     driveSetupCommand: row.driveSetupCommand ?? undefined,
     driveStopCommand: row.driveStopCommand ?? undefined,
+    driveInstructions: row.driveInstructions ?? undefined,
     closedAt: row.closedAt ?? undefined
   });
 }
@@ -2223,6 +2239,16 @@ function setPhase(ctx, featureId, toPhase, eventType = "phase.changed", message)
   });
   return { ...current, phase: toPhase };
 }
+function markTicketsReady(ctx, featureId, nextPhase2) {
+  const current = getFeatureRow(ctx, featureId);
+  ctx.db.update(features).set({ ticketsReadyLap: current.lap }).where(eq2(features.id, featureId)).run();
+  emit(ctx, featureId, {
+    type: "tickets.awaiting_burn",
+    message: "tickets complete \u2014 waiting on the human Burn click (gate G3)",
+    data: { phase: current.phase, nextPhase: nextPhase2, waitingOn: "human burn" }
+  });
+  return { ...current, ticketsReadyLap: current.lap };
+}
 function setFeatureStatus(ctx, featureId, status) {
   const current = getFeatureRow(ctx, featureId);
   ctx.db.update(features).set({ status }).where(eq2(features.id, featureId)).run();
@@ -2891,7 +2917,8 @@ var init_findings = __esm(() => {
     devCommand: projects.devCommand,
     driveSetupCommand: projects.driveSetupCommand,
     driveStopCommand: projects.driveStopCommand,
-    dbResetCommand: projects.dbResetCommand
+    dbResetCommand: projects.dbResetCommand,
+    driveInstructions: projects.driveInstructions
   };
   COLUMN_NAME = {
     setupCommand: "setupCommand",
@@ -2900,7 +2927,8 @@ var init_findings = __esm(() => {
     devCommand: "devCommand",
     driveSetupCommand: "driveSetupCommand",
     driveStopCommand: "driveStopCommand",
-    dbResetCommand: "dbResetCommand"
+    dbResetCommand: "dbResetCommand",
+    driveInstructions: "driveInstructions"
   };
   PREPARED_SET = new Set(PREPARED_KEYS);
   UNVERIFIED = { verifiedAt: null, verifiedSha: null };
@@ -4192,6 +4220,460 @@ var init_git = __esm(() => {
   TEMP_BRANCH_PREFIXES = [RESEARCH_BRANCH_PREFIX, TICKET_BRANCH_PREFIX];
 });
 
+// src/services/tickets.ts
+import { and as and5, asc as asc3, eq as eq5, inArray } from "drizzle-orm";
+function rowToTicket(row) {
+  return Ticket.parse({
+    id: row.id,
+    featureId: row.featureId,
+    seq: row.seq,
+    title: row.title,
+    goal: row.goal,
+    context: row.context,
+    acceptanceCriteria: row.acceptanceCriteria,
+    seams: row.seams,
+    blockedBy: row.blockedBy,
+    kind: row.kind,
+    passKind: row.passKind,
+    reviewedCommit: row.reviewedCommit,
+    completedAt: row.completedAt,
+    model: row.model ?? undefined,
+    lap: row.lap,
+    status: row.status,
+    commits: row.commits,
+    error: row.error ?? undefined,
+    attemptBranch: row.attemptBranch ?? undefined,
+    conflictFiles: row.conflictFiles ?? undefined,
+    digest: row.digest ?? undefined,
+    originFindingId: row.originFindingId ?? undefined
+  });
+}
+function resolveBlocking(inputs, startSeq) {
+  try {
+    return resolveBatchBlocking(inputs, { startSeq });
+  } catch (e) {
+    if (e instanceof BlockingEdgeError)
+      throw new InvalidInputError(e.message);
+    throw e;
+  }
+}
+function normalizeModel(ctx, value) {
+  const id = value?.trim();
+  if (!id)
+    return null;
+  const roster = modelRoster(ctx.config);
+  if (!roster.some((m) => m.id === id)) {
+    throw new InvalidInputError(`unknown model "${id}" \u2014 assign one of the configured models: ${roster.map((m) => m.id).join(", ")}`);
+  }
+  return id;
+}
+function listByFeature2(ctx, featureId) {
+  return ctx.db.select().from(tickets).where(eq5(tickets.featureId, featureId)).orderBy(asc3(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(eq5(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) => ({
+    id: newId("tkt"),
+    featureId,
+    seq: resolved[i].seq,
+    title: t.title,
+    goal: t.goal,
+    context: t.context,
+    acceptanceCriteria: t.acceptanceCriteria,
+    seams: t.seams,
+    blockedBy: resolved[i].blockedBy,
+    kind: t.kind ?? "implementation",
+    passKind: t.passKind ?? "review",
+    reviewedCommit: null,
+    completedAt: null,
+    model: normalizeModel(ctx, t.model),
+    lap,
+    status: "pending",
+    commits: [],
+    error: null,
+    attemptBranch: null,
+    conflictFiles: null,
+    digest: null,
+    originFindingId: t.originFindingId ?? null
+  }));
+  ctx.db.insert(tickets).values(rows).run();
+  emit(ctx, featureId, {
+    type: "tickets.stored",
+    message: `${rows.length} ticket(s) stored`,
+    data: { count: rows.length, seqs: rows.map((r) => r.seq) }
+  });
+  return rows.map(rowToTicket);
+}
+function getTicket(ctx, id) {
+  const row = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`ticket ${id} not found`);
+  return rowToTicket(row);
+}
+function assertMutable(t, verb) {
+  if (!MUTABLE_STATUSES.has(t.status)) {
+    throw new InvalidInputError(`cannot ${verb} ticket ${t.seq} \u2014 it is ${t.status}; only pending or failed tickets can be ${verb}${verb.endsWith("l") ? "led" : "ed"}`);
+  }
+}
+function editTicket(ctx, id, patch) {
+  const current = getTicket(ctx, id);
+  assertMutable(current, "edit");
+  const set = {};
+  if (patch.title !== undefined)
+    set.title = patch.title;
+  if (patch.goal !== undefined)
+    set.goal = patch.goal;
+  if (patch.context !== undefined)
+    set.context = patch.context;
+  if (patch.acceptanceCriteria !== undefined)
+    set.acceptanceCriteria = patch.acceptanceCriteria;
+  if (patch.seams !== undefined)
+    set.seams = patch.seams;
+  if (patch.model !== undefined)
+    set.model = normalizeModel(ctx, patch.model);
+  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(eq5(tickets.id, id)).run();
+  emit(ctx, current.featureId, {
+    type: "ticket.edited",
+    message: `ticket ${current.seq} content edited (${Object.keys(set).join(", ")})`,
+    ticketId: id,
+    data: { fields: Object.keys(set) }
+  });
+  return getTicket(ctx, id);
+}
+function cancelTicket(ctx, id, reason, opts) {
+  const current = getTicket(ctx, id);
+  if (!(opts?.agentStopped && current.status === "burning"))
+    assertMutable(current, "cancel");
+  ctx.db.update(tickets).set({
+    status: "cancelled",
+    error: reason?.trim() ? reason.trim() : null,
+    completedAt: Date.now()
+  }).where(eq5(tickets.id, id)).run();
+  emit(ctx, current.featureId, {
+    type: "ticket.cancelled",
+    message: `ticket ${current.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
+    ticketId: id,
+    data: { reason: reason ?? null }
+  });
+  return getTicket(ctx, id);
+}
+function sweepOrphanedBurning(ctx, featureId, reason) {
+  const orphaned = ctx.db.select().from(tickets).where(and5(eq5(tickets.featureId, featureId), eq5(tickets.status, "burning"))).all().map(rowToTicket);
+  const swept = [];
+  for (const t of orphaned) {
+    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}`,
+      ticketId: t.id,
+      data: { error: reason, orphaned: true }
+    });
+  }
+  return swept;
+}
+function updateTicket(ctx, id, patch) {
+  const current = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  if (!current)
+    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)
+    set.error = patch.error;
+  if (patch.attemptBranch !== undefined)
+    set.attemptBranch = patch.attemptBranch;
+  if (patch.conflictFiles !== undefined)
+    set.conflictFiles = patch.conflictFiles;
+  if (patch.digest !== undefined)
+    set.digest = patch.digest;
+  if (patch.reviewedCommit !== undefined)
+    set.reviewedCommit = patch.reviewedCommit;
+  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  emit(ctx, current.featureId, {
+    type: "ticket.updated",
+    message: `ticket ${current.seq} \u2192 ${patch.status ?? current.status}`,
+    ticketId: id,
+    data: patch
+  });
+  const updated = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  return rowToTicket(updated);
+}
+function listByIds(ctx, ids2) {
+  if (ids2.length === 0)
+    return [];
+  return ctx.db.select().from(tickets).where(inArray(tickets.id, [...ids2])).orderBy(asc3(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, eq5(events.ticketId, tickets.id)).where(and5(eq5(events.projectId, projectId), eq5(events.type, "ticket.timing"), eq5(tickets.status, "done"), eq5(tickets.kind, "implementation"))).orderBy(asc3(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();
+  init_schema();
+  init_errors();
+  init_events();
+  init_repo();
+  init_review_findings();
+  MUTABLE_STATUSES = new Set(["pending", "failed"]);
+});
+
+// src/services/review-findings.ts
+import { and as and6, asc as asc4, eq as eq6, isNotNull } 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(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(and6(eq6(reviewFindings.reviewTicketId, reviewTicket.id), isNotNull(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 current = getFinding(ctx, findingId);
+  ctx.db.update(reviewFindings).set(patch).where(eq6(reviewFindings.id, findingId)).run();
+  emit(ctx, current.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/carried-work.ts
+import { and as and7, eq as eq7 } from "drizzle-orm";
+function carriedWork(ctx, featureId) {
+  const carried = ctx.db.select({ id: testNotes.id }).from(testNotes).where(and7(eq7(testNotes.featureId, featureId), eq7(testNotes.status, "carried"))).all();
+  return {
+    carriedNotes: carried.length,
+    openDefects: viewByFeature(ctx, featureId).openDefects.map((defect) => ({
+      title: defect.title,
+      location: defect.location,
+      detail: defect.detail,
+      reproStep: defect.reproStep
+    }))
+  };
+}
+function hasCarriedWork(carried) {
+  return carried !== undefined && (carried.carriedNotes > 0 || carried.openDefects.length > 0);
+}
+function carriedWorkSummary(carried) {
+  if (!hasCarriedWork(carried))
+    return;
+  const parts = [];
+  if (carried.carriedNotes > 0) {
+    parts.push(`${carried.carriedNotes} note${carried.carriedNotes === 1 ? "" : "s"} carried`);
+  }
+  const defects = carried.openDefects.length;
+  if (defects > 0)
+    parts.push(`${defects} defect${defects === 1 ? "" : "s"} open`);
+  return `${parts.join(" and ")} from earlier laps`;
+}
+var init_carried_work = __esm(() => {
+  init_schema();
+  init_review_findings();
+});
+
 // src/launcher/edit-guard.ts
 import { isAbsolute, relative, resolve as resolve5 } from "path";
 function guardsEdits(kind) {
@@ -4304,15 +4786,15 @@ function noCodeRule(docs2) {
 function conflictResolutionRule() {
   return "- **This session resolves a merge conflict, so it DOES write code here.** Edit the " + "conflicted files in this checkout, resolving them from the feature docs\u2019 intent, and " + "commit the merge. That is the exception and its whole extent: the edit guard exempts " + "writes only while the merge is in progress, so work the merge revealed but did not " + "cause still rides a ticket.";
 }
-function renderSystemPrompt(feature, kind, waypoint, lap, purpose, runtime = DEFAULT_RUNTIME) {
+function renderSystemPrompt(feature, kind, waypoint, lap, purpose, runtime = DEFAULT_RUNTIME, carried) {
   if (lap !== undefined)
-    return renderRevisitPrompt(feature, lap, purpose, runtime);
+    return renderRevisitPrompt(feature, lap, purpose, runtime, carried);
   if (kind === "waypoint")
     return renderWaypointPrompt(feature, waypoint, runtime);
   if (kind === "converge")
     return renderConvergePrompt(feature, runtime);
   if (kind === "revisit")
-    return renderRevisitPrompt(feature, lap, purpose, runtime);
+    return renderRevisitPrompt(feature, lap, purpose, runtime, carried);
   if (kind === "qa")
     return renderQaPrompt(feature, runtime);
   const docs2 = featureDocsRel(feature.slug);
@@ -4460,18 +4942,30 @@ function renderConvergePrompt(feature, runtime = DEFAULT_RUNTIME) {
   ].join(`
 `);
 }
-function renderRevisitPrompt(feature, lap, purpose, runtime = DEFAULT_RUNTIME) {
+function renderRevisitPrompt(feature, lap, purpose, runtime = DEFAULT_RUNTIME, carried) {
   if (lap !== undefined && purpose === "resolve-conflict") {
     throw new Error(`cannot brief one revisit session as both lap ${lap} and a conflict resolution \u2014 ` + "a lap advances the pipeline and writes no code; resolving a conflict writes code " + "and advances nothing. Launch them as separate sessions.");
   }
   const docs2 = featureDocsRel(feature.slug);
+  const carriedSummary = carriedWorkSummary(carried);
   const lapIteration = lap ? [
     `## This is lap ${lap}`,
     `You are running **lap ${lap}** of this feature (ADR-0010): the human test-drove what`,
-    `lap ${lap - 1} burned and came back with what it taught them. Its inputs, both`,
-    "OPTIONAL \u2014 a missing one is normal, not an error:",
-    `- \`${docs2}/test-notes.md\`, section \`## Lap ${lap - 1}\` \u2014 what the drive surfaced.`,
-    `- \`${docs2}/spec.md\`, section \`## Later laps\` \u2014 scope parked by earlier laps.`,
+    `lap ${lap - 1} burned and came back with what it taught them.`,
+    ...carriedSummary ? [
+      `**${carriedSummary} \u2014 address them.** They are this lap's opening agenda:`,
+      `- \`${docs2}/test-notes.md\`, section \`## Carried, still open\` \u2014 every note carried`,
+      "  and not yet done, whatever lap captured it. It exists; read it.",
+      "- `get_feature_context` \u2192 `openDefects` \u2014 each open defect with its title,",
+      "  location, detail and repro step.",
+      `- \`${docs2}/spec.md\`, section \`## Later laps\` \u2014 scope parked by earlier laps,`,
+      "  OPTIONAL; a missing one is normal, not an error."
+    ] : [
+      "Its inputs, both OPTIONAL \u2014 a missing one is normal, not an error:",
+      `- \`${docs2}/test-notes.md\`, section \`## Carried, still open\` \u2014 every note carried`,
+      "  and not yet done, whatever lap captured it.",
+      `- \`${docs2}/spec.md\`, section \`## Later laps\` \u2014 scope parked by earlier laps.`
+    ],
     `New decisions go under a \`## Lap ${lap}\` heading in \`${docs2}/decisions.md\`.`,
     "",
     "Unlike an ordinary revisit a lap MOVES the pipeline, and only this session will:",
@@ -4813,11 +5307,12 @@ function renderRunMcpConfig(runId, config2) {
   };
 }
 function renderSessionPrompt(input) {
-  const { session, feature, waypoint, prepare, projectBrief, driveFix, lap, purpose, runtime } = input;
+  const { session, feature, waypoint, prepare, projectBrief, driveFix, lap, purpose, runtime, carried } = input;
   if (driveFix)
     return renderDriveFixPrompt(driveFix);
-  if (feature)
-    return renderSystemPrompt(feature, session.kind, waypoint, lap, purpose, runtime);
+  if (feature) {
+    return renderSystemPrompt(feature, session.kind, waypoint, lap, purpose, runtime, carried);
+  }
   if (prepare)
     return renderPreparePrompt(prepare);
   if (projectBrief)
@@ -4840,6 +5335,7 @@ var RUNCASTLE_MCP_ALLOW_RULES, SESSION_BASH_READ_RULES, SESSION_BASH_WRITE_RULES
 var init_artifacts = __esm(() => {
   init_src();
   init_paths();
+  init_carried_work();
   init_asset_paths();
   init_edit_guard();
   init_skills();
@@ -5604,7 +6100,7 @@ var init_runtimes = __esm(() => {
 
 // src/launcher/sessions.ts
 import { statSync as statSync3 } from "fs";
-import { and as and5, desc as desc3, eq as eq5, inArray, isNotNull, sql as sql2 } from "drizzle-orm";
+import { and as and8, desc as desc3, eq as eq8, inArray as inArray2, isNotNull as isNotNull2, sql as sql2 } from "drizzle-orm";
 function createSessionRow(ctx, input) {
   const row = ctx.db.insert(sessions).values({
     id: newId("sess"),
@@ -5626,11 +6122,11 @@ function createSessionRow(ctx, input) {
   return rowToSession(row);
 }
 function getSessionRow(ctx, id) {
-  const row = ctx.db.select().from(sessions).where(eq5(sessions.id, id)).get();
+  const row = ctx.db.select().from(sessions).where(eq8(sessions.id, id)).get();
   return row ? rowToSession(row) : null;
 }
 function activeSessionsForFeature(ctx, featureId) {
-  return ctx.db.select().from(sessions).where(and5(eq5(sessions.featureId, featureId), inArray(sessions.status, ["launching", "live"]))).all().map(rowToSession);
+  return ctx.db.select().from(sessions).where(and8(eq8(sessions.featureId, featureId), inArray2(sessions.status, ["launching", "live"]))).all().map(rowToSession);
 }
 function markAgentWorking(ctx, id) {
   setAwaitingInput(ctx, id, false);
@@ -5639,7 +6135,7 @@ function markAwaitingInput(ctx, id) {
   setAwaitingInput(ctx, id, true);
 }
 function setAwaitingInput(ctx, id, awaitingInput) {
-  ctx.db.update(sessions).set({ awaitingInput }).where(eq5(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ awaitingInput }).where(eq8(sessions.id, id)).run();
 }
 function markSessionLive(ctx, id, input = {}) {
   const existing = getSessionRow(ctx, id);
@@ -5649,7 +6145,7 @@ function markSessionLive(ctx, id, input = {}) {
     status: "live",
     ccSessionId: input.ccSessionId ?? existing.ccSessionId ?? null,
     transcriptPath: input.transcriptPath ?? existing.transcriptPath ?? null
-  }).where(eq5(sessions.id, id)).run();
+  }).where(eq8(sessions.id, id)).run();
   const firstTimeLive = existing.status !== "live";
   if (firstTimeLive) {
     promoteLastSession(ctx, id);
@@ -5657,8 +6153,9 @@ function markSessionLive(ctx, id, input = {}) {
   }
   return getSessionRow(ctx, id);
 }
-function lapKickoff(lap) {
-  return `Proceed with your task: invoke the /runcastle:revisit skill for LAP ${lap} REVIEW ITERATION. ` + `Call get_feature_context, then read this feature's test-notes.md (the "## Lap ${lap - 1}" ` + 'section \u2014 what the last drive surfaced) and the "## Later laps" section of its spec.md. ' + "EITHER MAY NOT EXIST YET; that is normal, not an error \u2014 say so and carry on from what I " + "tell you. Interview me about what the test drive taught: what was wrong, what was missing, " + "what I want next. Write what we settle on into decisions.md and amend spec.md for this lap " + '(pruning anything you promote out of "## Later laps"), then call emit_tickets for this ' + `lap's work. Finish in THIS session: complete_phase through ideation \u2192 spec \u2192 tickets, then ` + "tell me to review the cards and click Burn.";
+function lapKickoff(lap, carried) {
+  const summary = carriedWorkSummary(carried);
+  return `Proceed with your task: invoke the /runcastle:revisit skill for LAP ${lap} REVIEW ITERATION. ` + (summary ? `${summary} \u2014 address them. ` : "") + `Call get_feature_context, then read this feature's test-notes.md (its "## Carried, still ` + 'open" section \u2014 every note carried and not yet done, whatever lap captured it), the open ' + `defects in that payload's openDefects, and the "## Later laps" section of its spec.md. ` + (summary ? 'THE "## Later laps" SECTION MAY NOT EXIST; that is normal, not an error. ' : "ANY OF THOSE MAY NOT EXIST YET; that is normal, not an error \u2014 say so and carry on from " + "what I tell you. ") + "Interview me about what the test drive taught: what was wrong, what was missing, " + "what I want next. Write what we settle on into decisions.md and amend spec.md for this lap " + '(pruning anything you promote out of "## Later laps"), then call emit_tickets for this ' + `lap's work. Finish in THIS session: complete_phase through ideation \u2192 spec \u2192 tickets, then ` + "tell me to review the cards and click Burn.";
 }
 function kickoffLineFor(kind, override, runtime = DEFAULT_RUNTIME) {
   return override ?? runtimeAdapterFor(runtime).kickoffLine(kind);
@@ -5668,7 +6165,7 @@ function lapInFlight(input) {
 }
 function planKickoff(input) {
   const running = input.lapInFlight === true;
-  const lapBriefing = input.lap > 1 ? lapKickoff(input.lap) : undefined;
+  const lapBriefing = input.lap > 1 ? lapKickoff(input.lap, input.carried) : undefined;
   const line = input.kickoffLine ?? (running ? lapBriefing : undefined);
   const lap = running ? input.lap : undefined;
   if (!line)
@@ -5900,31 +6397,31 @@ function markSessionEnded(ctx, id) {
   forgetKickoff(id);
   if (existing.featureId)
     stopDocsWatch(existing.featureId);
-  ctx.db.update(sessions).set({ status: "ended", ...existing.endedAt === undefined ? { endedAt: Date.now() } : {} }).where(eq5(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ status: "ended", ...existing.endedAt === undefined ? { endedAt: Date.now() } : {} }).where(eq8(sessions.id, id)).run();
   return getSessionRow(ctx, id);
 }
 function mostRecentResumableSession(ctx, featureId, kind) {
-  const row = ctx.db.select().from(sessions).where(and5(eq5(sessions.featureId, featureId), eq5(sessions.status, "ended"), isNotNull(sessions.ccSessionId), ...kind ? [eq5(sessions.kind, kind)] : [])).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  const row = ctx.db.select().from(sessions).where(and8(eq8(sessions.featureId, featureId), eq8(sessions.status, "ended"), isNotNull2(sessions.ccSessionId), ...kind ? [eq8(sessions.kind, kind)] : [])).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
 function activeProjectSession(ctx, projectId, kind) {
-  const row = ctx.db.select().from(sessions).where(and5(eq5(sessions.projectId, projectId), eq5(sessions.kind, kind), inArray(sessions.status, ["launching", "live"]))).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  const row = ctx.db.select().from(sessions).where(and8(eq8(sessions.projectId, projectId), eq8(sessions.kind, kind), inArray2(sessions.status, ["launching", "live"]))).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
 function projectSessions(ctx, projectId, kind) {
-  return ctx.db.select().from(sessions).where(and5(eq5(sessions.projectId, projectId), eq5(sessions.kind, kind))).orderBy(desc3(sql2`rowid`)).all().map(rowToSession);
+  return ctx.db.select().from(sessions).where(and8(eq8(sessions.projectId, projectId), eq8(sessions.kind, kind))).orderBy(desc3(sql2`rowid`)).all().map(rowToSession);
 }
 function setSessionTitle(ctx, id, title) {
-  ctx.db.update(sessions).set({ title }).where(eq5(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ title }).where(eq8(sessions.id, id)).run();
 }
 function clearSessionTitle(ctx, id) {
-  ctx.db.update(sessions).set({ title: null }).where(eq5(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ title: null }).where(eq8(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;
+  return ctx.db.select({ id: sessions.id }).from(sessions).where(and8(eq8(sessions.projectId, projectId), eq8(sessions.kind, kind), eq8(sessions.status, "ended"))).limit(1).get() !== undefined;
 }
 function mostRecentResumableProjectSession(ctx, projectId, kind) {
-  const row = ctx.db.select().from(sessions).where(and5(eq5(sessions.projectId, projectId), eq5(sessions.kind, kind), eq5(sessions.status, "ended"), isNotNull(sessions.ccSessionId))).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  const row = ctx.db.select().from(sessions).where(and8(eq8(sessions.projectId, projectId), eq8(sessions.kind, kind), eq8(sessions.status, "ended"), isNotNull2(sessions.ccSessionId))).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
 function envInt(name, fallback) {
@@ -5964,17 +6461,17 @@ function transcriptBytes(session) {
 }
 function reentryCount(ctx, scope) {
   const where = [
-    eq5(sessions.status, "ended"),
-    isNotNull(sessions.ccSessionId),
-    ...scope.featureId ? [eq5(sessions.featureId, scope.featureId)] : [],
-    ...scope.projectId ? [eq5(sessions.projectId, scope.projectId)] : [],
-    ...scope.kind ? [eq5(sessions.kind, scope.kind)] : []
+    eq8(sessions.status, "ended"),
+    isNotNull2(sessions.ccSessionId),
+    ...scope.featureId ? [eq8(sessions.featureId, scope.featureId)] : [],
+    ...scope.projectId ? [eq8(sessions.projectId, scope.projectId)] : [],
+    ...scope.kind ? [eq8(sessions.kind, scope.kind)] : []
   ];
-  const row = ctx.db.select({ n: sql2`count(*)` }).from(sessions).where(and5(...where)).get();
+  const row = ctx.db.select({ n: sql2`count(*)` }).from(sessions).where(and8(...where)).get();
   return row?.n ?? 0;
 }
 function mostRecentLiveSession(ctx) {
-  const row = ctx.db.select().from(sessions).where(eq5(sessions.status, "live")).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  const row = ctx.db.select().from(sessions).where(eq8(sessions.status, "live")).orderBy(desc3(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
 var KICKOFF_DELAY_MS = 1500, KICKOFF_SUBMIT_DELAY_MS = 350, KICKOFF_CONFIRM_MS = 12000, KICKOFF_MAX_ATTEMPTS = 3, CLEAR_INPUT = "\x15", SESSION_READY_TIMEOUT_MS = 25000, PREPARE_CONFIRM_KICKOFF, RESUME_KICKOFF_PREFIX, pendingKickoffOverrides, deliveries, MATCH_PREFIX = 40, landedProjectSessions, inFlightLandings, LANDING_KEPT, RESUME_MAX_TRANSCRIPT_BYTES, RESUME_MAX_REENTRIES;
@@ -5985,6 +6482,7 @@ var init_sessions = __esm(() => {
   init_docs_watch();
   init_events();
   init_git();
+  init_carried_work();
   init_waypoints();
   init_repo();
   init_runtimes();
@@ -6001,9 +6499,9 @@ var init_sessions = __esm(() => {
 });
 
 // src/launcher/reconcile.ts
-import { inArray as inArray2 } from "drizzle-orm";
+import { inArray as inArray3 } from "drizzle-orm";
 function reconcileStaleSessions(ctx) {
-  const stale = ctx.db.select().from(sessions).where(inArray2(sessions.status, ["launching", "live"])).all().map(rowToSession);
+  const stale = ctx.db.select().from(sessions).where(inArray3(sessions.status, ["launching", "live"])).all().map(rowToSession);
   const reconciled = [];
   for (const session of stale) {
     const entry = ptyRegistry().get(session.id);
@@ -6051,428 +6549,9 @@ 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 and7, asc as asc4, eq as eq7, inArray as inArray3 } from "drizzle-orm";
-function rowToTicket(row) {
-  return Ticket.parse({
-    id: row.id,
-    featureId: row.featureId,
-    seq: row.seq,
-    title: row.title,
-    goal: row.goal,
-    context: row.context,
-    acceptanceCriteria: row.acceptanceCriteria,
-    seams: row.seams,
-    blockedBy: row.blockedBy,
-    kind: row.kind,
-    passKind: row.passKind,
-    reviewedCommit: row.reviewedCommit,
-    completedAt: row.completedAt,
-    model: row.model ?? undefined,
-    lap: row.lap,
-    status: row.status,
-    commits: row.commits,
-    error: row.error ?? undefined,
-    attemptBranch: row.attemptBranch ?? undefined,
-    conflictFiles: row.conflictFiles ?? undefined,
-    digest: row.digest ?? undefined,
-    originFindingId: row.originFindingId ?? undefined
-  });
-}
-function resolveBlocking(inputs, startSeq) {
-  try {
-    return resolveBatchBlocking(inputs, { startSeq });
-  } catch (e) {
-    if (e instanceof BlockingEdgeError)
-      throw new InvalidInputError(e.message);
-    throw e;
-  }
-}
-function normalizeModel(ctx, value) {
-  const id = value?.trim();
-  if (!id)
-    return null;
-  const roster = modelRoster(ctx.config);
-  if (!roster.some((m) => m.id === id)) {
-    throw new InvalidInputError(`unknown model "${id}" \u2014 assign one of the configured models: ${roster.map((m) => m.id).join(", ")}`);
-  }
-  return id;
-}
-function listByFeature2(ctx, featureId) {
-  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(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) => ({
-    id: newId("tkt"),
-    featureId,
-    seq: resolved[i].seq,
-    title: t.title,
-    goal: t.goal,
-    context: t.context,
-    acceptanceCriteria: t.acceptanceCriteria,
-    seams: t.seams,
-    blockedBy: resolved[i].blockedBy,
-    kind: t.kind ?? "implementation",
-    passKind: t.passKind ?? "review",
-    reviewedCommit: null,
-    completedAt: null,
-    model: normalizeModel(ctx, t.model),
-    lap,
-    status: "pending",
-    commits: [],
-    error: null,
-    attemptBranch: null,
-    conflictFiles: null,
-    digest: null,
-    originFindingId: t.originFindingId ?? null
-  }));
-  ctx.db.insert(tickets).values(rows).run();
-  emit(ctx, featureId, {
-    type: "tickets.stored",
-    message: `${rows.length} ticket(s) stored`,
-    data: { count: rows.length, seqs: rows.map((r) => r.seq) }
-  });
-  return rows.map(rowToTicket);
-}
-function getTicket(ctx, id) {
-  const row = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
-  if (!row)
-    throw new NotFoundError(`ticket ${id} not found`);
-  return rowToTicket(row);
-}
-function assertMutable(t, verb) {
-  if (!MUTABLE_STATUSES.has(t.status)) {
-    throw new InvalidInputError(`cannot ${verb} ticket ${t.seq} \u2014 it is ${t.status}; only pending or failed tickets can be ${verb}${verb.endsWith("l") ? "led" : "ed"}`);
-  }
-}
-function editTicket(ctx, id, patch) {
-  const current2 = getTicket(ctx, id);
-  assertMutable(current2, "edit");
-  const set = {};
-  if (patch.title !== undefined)
-    set.title = patch.title;
-  if (patch.goal !== undefined)
-    set.goal = patch.goal;
-  if (patch.context !== undefined)
-    set.context = patch.context;
-  if (patch.acceptanceCriteria !== undefined)
-    set.acceptanceCriteria = patch.acceptanceCriteria;
-  if (patch.seams !== undefined)
-    set.seams = patch.seams;
-  if (patch.model !== undefined)
-    set.model = normalizeModel(ctx, patch.model);
-  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(eq7(tickets.id, id)).run();
-  emit(ctx, current2.featureId, {
-    type: "ticket.edited",
-    message: `ticket ${current2.seq} content edited (${Object.keys(set).join(", ")})`,
-    ticketId: id,
-    data: { fields: Object.keys(set) }
-  });
-  return getTicket(ctx, id);
-}
-function cancelTicket(ctx, id, reason) {
-  const current2 = getTicket(ctx, id);
-  assertMutable(current2, "cancel");
-  ctx.db.update(tickets).set({
-    status: "cancelled",
-    error: reason?.trim() ? reason.trim() : null,
-    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()}` : ""}`,
-    ticketId: id,
-    data: { reason: reason ?? null }
-  });
-  return getTicket(ctx, id);
-}
-function sweepOrphanedBurning(ctx, featureId, reason) {
-  const orphaned = ctx.db.select().from(tickets).where(and7(eq7(tickets.featureId, featureId), eq7(tickets.status, "burning"))).all().map(rowToTicket);
-  const swept = [];
-  for (const t of orphaned) {
-    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}`,
-      ticketId: t.id,
-      data: { error: reason, orphaned: true }
-    });
-  }
-  return swept;
-}
-function updateTicket(ctx, id, patch) {
-  const current2 = ctx.db.select().from(tickets).where(eq7(tickets.id, id)).get();
-  if (!current2)
-    throw new NotFoundError(`ticket ${id} not found`);
-  const set = {};
-  if (patch.status !== undefined)
-    set.status = patch.status;
-  if (patch.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)
-    set.error = patch.error;
-  if (patch.attemptBranch !== undefined)
-    set.attemptBranch = patch.attemptBranch;
-  if (patch.conflictFiles !== undefined)
-    set.conflictFiles = patch.conflictFiles;
-  if (patch.digest !== undefined)
-    set.digest = patch.digest;
-  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(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();
-  init_schema();
-  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 and8, desc as desc4, eq as eq8, inArray as inArray4 } from "drizzle-orm";
+import { and as and9, desc as desc4, eq as eq9, inArray as inArray4 } from "drizzle-orm";
 function checkGate(ctx, check, feature) {
   switch (check) {
     case "decisions-file-exists":
@@ -6498,8 +6577,16 @@ function checkGate(ctx, check, feature) {
     case "spec-file-exists":
       return docGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
     case "tickets-approved": {
-      const count = listByFeature2(ctx, feature.id).filter((t) => t.lap === feature.lap && t.status !== "cancelled").length;
-      return count >= 1 ? { satisfied: true } : { satisfied: false, reason: "no tickets to burn" };
+      const burnable = listByFeature2(ctx, feature.id).filter((t) => t.lap === feature.lap && t.status !== "cancelled");
+      if (burnable.length === 0)
+        return { satisfied: false, reason: "no tickets to burn" };
+      if (!burnable.some((t) => t.kind === "review")) {
+        return {
+          satisfied: false,
+          reason: 'no review ticket on this lap \u2014 every batch closes with one (kind: "review"); emit it, ' + "fix the kind on a review-shaped ticket, or override this gate with a reason"
+        };
+      }
+      return { satisfied: true };
     }
     case "all-tickets-terminal": {
       const tickets2 = listByFeature2(ctx, feature.id);
@@ -6531,7 +6618,7 @@ function fileGate(ctx, feature, fileName, reason) {
   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;
+  return ctx.db.select({ id: sessions.id }).from(sessions).where(and9(eq9(sessions.featureId, feature.id), eq9(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);
@@ -6563,10 +6650,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(and8(eq8(gateOverrides.featureId, featureId), eq8(gateOverrides.gate, gate))).orderBy(desc4(gateOverrides.id)).get();
+  const last = ctx.db.select({ id: gateOverrides.id }).from(gateOverrides).where(and9(eq9(gateOverrides.featureId, featureId), eq9(gateOverrides.gate, gate))).orderBy(desc4(gateOverrides.id)).get();
   if (!last)
     return false;
-  ctx.db.delete(gateOverrides).where(eq8(gateOverrides.id, last.id)).run();
+  ctx.db.delete(gateOverrides).where(eq9(gateOverrides.id, last.id)).run();
   return true;
 }
 function undoGateOverride(ctx, featureId, gate) {
@@ -6760,6 +6847,133 @@ var init_end_session = __esm(() => {
   init_registry();
 });
 
+// src/workflows/kill-registry.ts
+import { spawn as spawn4 } from "child_process";
+function log2(msg) {
+  console.error(`[kill-registry] ${msg}`);
+}
+function runDockerCommand(args) {
+  return new Promise((resolve9) => {
+    let settled = false;
+    const settle = (ok) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve9(ok);
+    };
+    const timer = setTimeout(() => settle(false), DOCKER_COMMAND_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      const child = spawn4("docker", args, { windowsHide: true, stdio: "ignore" });
+      child.on("exit", (code) => settle(code === 0));
+      child.on("close", (code) => settle(code === 0));
+      child.on("error", () => settle(false));
+    } catch {
+      settle(false);
+    }
+  });
+}
+function withDeadline2(body, ms) {
+  return new Promise((resolve9) => {
+    const timer = setTimeout(() => resolve9(false), ms);
+    body.catch(() => false).then((confirmed) => {
+      clearTimeout(timer);
+      resolve9(confirmed);
+    });
+  });
+}
+function forget() {}
+function delay(ms) {
+  return new Promise((resolve9) => {
+    const timer = setTimeout(resolve9, ms);
+    timer.unref?.();
+  });
+}
+
+class KillRegistry {
+  deps;
+  handles = new Map;
+  killsInFlight = new Map;
+  constructor(deps = REAL_DEPS) {
+    this.deps = deps;
+  }
+  registerContainer(laneKey, containerName, owner = {}) {
+    this.handles.set(laneKey, { kind: "container", containerName, ...owner });
+  }
+  registerHostPid(laneKey, pid, owner = {}) {
+    this.handles.set(laneKey, { kind: "host", pid, ...owner });
+  }
+  release(laneKey) {
+    this.handles.delete(laneKey);
+  }
+  killAndWait(laneKey, opts) {
+    const handle = this.handles.get(laneKey);
+    if (!handle)
+      return Promise.resolve({ confirmed: true });
+    const kill = this.killLane(laneKey, handle, opts);
+    const entry = { runId: handle.runId, settled: kill.then(forget, forget) };
+    this.killsInFlight.set(laneKey, entry);
+    entry.settled.then(() => {
+      if (this.killsInFlight.get(laneKey) === entry)
+        this.killsInFlight.delete(laneKey);
+    });
+    return kill;
+  }
+  async whenKillSettled(laneKey) {
+    await this.killsInFlight.get(laneKey)?.settled;
+  }
+  async whenRunKillsSettled(runId) {
+    await Promise.all([...this.killsInFlight.values()].filter((kill) => kill.runId === runId).map((kill) => kill.settled));
+  }
+  async killLane(laneKey, handle, opts) {
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const started = Date.now();
+    const confirmed = await withDeadline2(this.kill(handle, started + timeoutMs), timeoutMs);
+    if (confirmed)
+      this.handles.delete(laneKey);
+    const target = handle.kind === "container" ? handle.containerName : `pid=${handle.pid}`;
+    log2(`killAndWait: lane=${laneKey} ${handle.kind}=${target} ${confirmed ? "confirmed dead" : `NOT confirmed dead (${timeoutMs}ms deadline)`} after ${Date.now() - started}ms`);
+    return { confirmed };
+  }
+  async killAllForRun(runId, opts) {
+    const lanes = [...this.handles].filter(([, handle]) => handle.runId === runId).map(([laneKey]) => laneKey);
+    const outcomes = await Promise.all(lanes.map((laneKey) => this.killAndWait(laneKey, opts)));
+    return { confirmed: outcomes.every((outcome) => outcome.confirmed) };
+  }
+  keys() {
+    return [...this.handles.keys()];
+  }
+  async kill(handle, deadline) {
+    if (handle.kind === "host") {
+      await this.deps.killTree(handle.pid);
+      return true;
+    }
+    await this.deps.runDocker(["rm", "-f", handle.containerName]);
+    do {
+      if (!await this.deps.runDocker(["inspect", handle.containerName]))
+        return true;
+      await delay(DEATH_POLL_INTERVAL_MS);
+    } while (Date.now() < deadline);
+    return false;
+  }
+}
+function killRegistry() {
+  const g = globalThis;
+  if (!g[REGISTRY_KEY2])
+    g[REGISTRY_KEY2] = new KillRegistry;
+  return g[REGISTRY_KEY2];
+}
+function registerHostChildren(laneKey, owner) {
+  return (pid) => killRegistry().registerHostPid(laneKey, pid, owner);
+}
+var DEFAULT_TIMEOUT_MS = 1e4, DEATH_POLL_INTERVAL_MS = 100, DOCKER_COMMAND_TIMEOUT_MS = 5000, REAL_DEPS, REGISTRY_KEY2;
+var init_kill_registry = __esm(() => {
+  init_kill_tree();
+  REAL_DEPS = { runDocker: runDockerCommand, killTree: killProcessTree };
+  REGISTRY_KEY2 = Symbol.for("runcastle.kill.registry");
+});
+
 // ../../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() {
@@ -10285,7 +10499,7 @@ ${prefix}}`;
 }, _catch, catchAllDefect, catchSomeCause, catchSomeDefect, catchTag, catchTags, cause = (self) => matchCause(self, {
   onFailure: identity,
   onSuccess: () => empty7
-}), clockWith3, clock, delay, descriptorWith = (f) => withFiberRuntime((state, status3) => f({
+}), clockWith3, clock, delay2, descriptorWith = (f) => withFiberRuntime((state, status3) => f({
   id: state.id(),
   status: status3,
   interruptors: interruptors(state.getFiberRef(currentInterruptedCause))
@@ -10356,7 +10570,7 @@ ${prefix}}`;
     fiberState.log(message, cause3, levelOption);
     return void_2;
   });
-}, log3, logTrace, logDebug, logInfo, logWarning, logError, logFatal, withLogSpan, logAnnotations, loop = (initial, options) => options.discard ? loopDiscard(initial, options.while, options.step, options.body) : map10(loopInternal(initial, options.while, options.step, options.body), fromIterable2), loopInternal = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap7(body(initial), (a) => map10(loopInternal(inc(initial), cont, inc, body), prepend3(a))) : sync(() => empty11())), loopDiscard = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap7(body(initial), () => loopDiscard(inc(initial), cont, inc, body)) : void_2), mapAccum2, mapErrorCause, memoize = (self) => pipe(deferredMake(), flatMap7((deferred) => pipe(diffFiberRefsAndRuntimeFlags(self), intoDeferred(deferred), once, map10((complete4) => zipRight2(complete4, pipe(deferredAwait(deferred), flatMap7(([patch9, a]) => as2(zip2(patchFiberRefs(patch9[0]), updateRuntimeFlags(patch9[1])), a)))))))), merge5 = (self) => matchEffect(self, {
+}, log4, logTrace, logDebug, logInfo, logWarning, logError, logFatal, withLogSpan, logAnnotations, loop = (initial, options) => options.discard ? loopDiscard(initial, options.while, options.step, options.body) : map10(loopInternal(initial, options.while, options.step, options.body), fromIterable2), loopInternal = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap7(body(initial), (a) => map10(loopInternal(inc(initial), cont, inc, body), prepend3(a))) : sync(() => empty11())), loopDiscard = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap7(body(initial), () => loopDiscard(inc(initial), cont, inc, body)) : void_2), mapAccum2, mapErrorCause, memoize = (self) => pipe(deferredMake(), flatMap7((deferred) => pipe(diffFiberRefsAndRuntimeFlags(self), intoDeferred(deferred), once, map10((complete4) => zipRight2(complete4, pipe(deferredAwait(deferred), flatMap7(([patch9, a]) => as2(zip2(patchFiberRefs(patch9[0]), updateRuntimeFlags(patch9[1])), a)))))))), merge5 = (self) => matchEffect(self, {
   onFailure: (e) => succeed(e),
   onSuccess: succeed
 }), negate = (self) => map10(self, (b) => !b), none6 = (self) => flatMap7(self, (option5) => {
@@ -11970,11 +12184,11 @@ ${prefix}}`;
       return end5 - time2 <= 0 ? some2(computeCachedValue(self, timeToLive, time2)) : none2();
     }
   }
-})), flatMap7((option5) => isNone2(option5) ? dieMessage("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait(option5.value[1]))))), invalidateCache = (cache) => set4(cache, none2()), ensuringChild, ensuringChildren, forkAll, forkIn, forkScoped = (self) => scopeWith((scope5) => forkIn(self, scope5)), fromFiber = (fiber) => join22(fiber), fromFiberEffect = (fiber) => suspend(() => flatMap7(fiber, join22)), memoKeySymbol, Key, cachedFunction = (f, eq9) => {
+})), flatMap7((option5) => isNone2(option5) ? dieMessage("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait(option5.value[1]))))), invalidateCache = (cache) => set4(cache, none2()), ensuringChild, ensuringChildren, forkAll, forkIn, forkScoped = (self) => scopeWith((scope5) => forkIn(self, scope5)), fromFiber = (fiber) => join22(fiber), fromFiberEffect = (fiber) => suspend(() => flatMap7(fiber, join22)), memoKeySymbol, Key, cachedFunction = (f, eq10) => {
   return pipe(sync(() => empty22()), flatMap7(makeSynchronized), map10((ref) => (a) => pipe(ref.modifyEffect((map27) => {
-    const result = pipe(map27, get12(new Key(a, eq9)));
+    const result = pipe(map27, get12(new Key(a, eq10)));
     if (isNone2(result)) {
-      return pipe(deferredMake(), tap2((deferred) => pipe(diffFiberRefs(f(a)), intoDeferred(deferred), fork)), map10((deferred) => [deferred, pipe(map27, set6(new Key(a, eq9), deferred))]));
+      return pipe(deferredMake(), tap2((deferred) => pipe(diffFiberRefs(f(a)), intoDeferred(deferred), fork)), map10((deferred) => [deferred, pipe(map27, set6(new Key(a, eq10), deferred))]));
     }
     return succeed([result.value, map27]);
   }), flatMap7(deferredAwait), flatMap7(([patch9, b]) => pipe(patchFiberRefs(patch9), as2(b))))));
@@ -13238,7 +13452,7 @@ ${prefix}}`;
     }
     return void_2;
   });
-}, withRequestCaching, withRequestCache, isRequest2, EffectTypeId3, isEffect2, cachedWithTTL, cachedInvalidateWithTTL2, cached3, cachedFunction2, once3, all7, allWith2, allSuccesses2, dropUntil2, dropWhile2, takeUntil2, takeWhile2, every6, exists4, filter8, filterMap5, findFirst6, forEach8, head4, mergeAll5, partition4, reduce12, reduceWhile2, reduceRight3, reduceEffect3, replicate2, replicateEffect2, validateAll2, validateFirst2, async2, asyncEffect2, custom2, withFiberRuntime2, fail10, failSync4, failCause9, failCauseSync4, die7, dieMessage2, dieSync4, gen3, never4, none9, promise2, succeed10, succeedNone2, succeedSome2, suspend4, sync6, _void, yieldNow4, _catch2, catchAll3, catchAllCause3, catchAllDefect2, catchIf2, catchSome2, catchSomeCause2, catchSomeDefect2, catchTag2, catchTags2, cause2, eventually2, ignore2, ignoreLogged2, parallelErrors2, sandbox2, retry2, withExecutionPlan2, retryOrElse, try_2, tryMap2, tryMapPromise2, tryPromise2, unsandbox2, allowInterrupt2, checkInterruptible2, disconnect2, interrupt7, interruptWith3, interruptible4, interruptibleMask2, onInterrupt2, uninterruptible2, uninterruptibleMask3, liftPredicate3, as7, asSome2, asSomeError2, asVoid5, flip2, flipWith2, map18, mapAccum3, mapBoth5, mapError4, mapErrorCause3, merge7, negate2, acquireRelease2, acquireReleaseInterruptible2, acquireUseRelease2, addFinalizer3, ensuring3, onError2, onExit3, parallelFinalizers2, sequentialFinalizers2, finalizersMask2, scope3, scopeWith2, scopedWith2, scoped3, using2, withEarlyRelease2, awaitAllChildren2, daemonChildren2, descriptor2, descriptorWith2, diffFiberRefs2, ensuringChild2, ensuringChildren2, fiberId2, fiberIdWith2, fork3, forkDaemon2, forkAll2, forkIn2, forkScoped2, forkWithErrorHandler2, fromFiber2, fromFiberEffect2, supervised2, transplant2, withConcurrency2, withScheduler2, withSchedulingPriority2, withMaxOpsBeforeYield2, clock2, clockWith4, withClockScoped2, withClock2, console3, consoleWith2, withConsoleScoped2, withConsole2, delay2, sleep4, timed2, timedWith2, timeout2, timeoutOption2, timeoutFail2, timeoutFailCause2, timeoutTo2, configProviderWith2, withConfigProvider2, withConfigProviderScoped2, context3, contextWith2, contextWithEffect2, mapInputContext3, provide2, provideService3, provideServiceEffect2, serviceFunction2, serviceFunctionEffect2, serviceFunctions2, serviceConstants2, serviceMembers2, serviceOption2, serviceOptional2, updateService2, Do3, bind4, bindAll2, bindTo4, let_4, option2, either4, exit3, intoDeferred2, if_2, filterOrDie2, filterOrDieMessage2, filterOrElse2, filterOrFail2, filterEffectOrElse2, filterEffectOrFail2, unless2, unlessEffect2, when2, whenEffect2, whenFiberRef2, whenRef2, flatMap11, andThen6, flatten8, race2, raceAll2, raceFirst2, raceWith2, summarized2, tap4, tapBoth2, tapDefect2, tapError3, tapErrorTag2, tapErrorCause3, forever3, iterate2, loop2, repeat, repeatN2, repeatOrElse, schedule, scheduleForked2, scheduleFrom, whileLoop3, getFiberRefs, inheritFiberRefs2, locally, locallyWith, locallyScoped, locallyScopedWith, patchFiberRefs2, setFiberRefs2, updateFiberRefs2, isFailure4, isSuccess3, match14, matchCause4, matchCauseEffect3, matchEffect3, log32, logWithLevel2 = (level, ...message) => logWithLevel(level)(...message), logTrace2, logDebug2, logInfo2, logWarning2, logError2, logFatal2, withLogSpan2, annotateLogs3, annotateLogsScoped2, logAnnotations2, withUnhandledErrorLogLevel2, whenLogLevel2, orDie3, orDieWith2, orElse6, orElseFail2, orElseSucceed2, firstSuccessOf2, random3, randomWith2, withRandom2, withRandomFixed, withRandomScoped2, runtime4, getRuntimeFlags, patchRuntimeFlags, withRuntimeFlagsPatch, withRuntimeFlagsPatchScoped, tagMetrics2, labelMetrics2, tagMetricsScoped2, labelMetricsScoped2, metricLabels2, withMetric2, unsafeMakeSemaphore2, makeSemaphore2, unsafeMakeLatch2, makeLatch2, runFork2, runCallback, runPromise, runPromiseExit, runSync, runSyncExit, validate2, validateWith2, zip6, zipLeft6, zipRight6, zipWith8, ap2, blocked2, runRequestBlock2, step3, request, cacheRequestResult, withRequestBatching2, withRequestCaching2, withRequestCache2, tracer2, tracerWith4, withTracer2, withTracerScoped2, withTracerEnabled2, withTracerTiming2, annotateSpans3, annotateCurrentSpan2, currentSpan2, currentParentSpan2, spanAnnotations2, spanLinks2, linkSpans2, linkSpanCurrent2, makeSpan2, makeSpanScoped2, useSpan2, withSpan3, functionWithSpan2, withSpanScoped2, withParentSpan3, fromNullable3, optionFromOptional2, transposeOption = (self) => {
+}, withRequestCaching, withRequestCache, isRequest2, EffectTypeId3, isEffect2, cachedWithTTL, cachedInvalidateWithTTL2, cached3, cachedFunction2, once3, all7, allWith2, allSuccesses2, dropUntil2, dropWhile2, takeUntil2, takeWhile2, every6, exists4, filter8, filterMap5, findFirst6, forEach8, head4, mergeAll5, partition4, reduce12, reduceWhile2, reduceRight3, reduceEffect3, replicate2, replicateEffect2, validateAll2, validateFirst2, async2, asyncEffect2, custom2, withFiberRuntime2, fail10, failSync4, failCause9, failCauseSync4, die7, dieMessage2, dieSync4, gen3, never4, none9, promise2, succeed10, succeedNone2, succeedSome2, suspend4, sync6, _void, yieldNow4, _catch2, catchAll3, catchAllCause3, catchAllDefect2, catchIf2, catchSome2, catchSomeCause2, catchSomeDefect2, catchTag2, catchTags2, cause2, eventually2, ignore2, ignoreLogged2, parallelErrors2, sandbox2, retry2, withExecutionPlan2, retryOrElse, try_2, tryMap2, tryMapPromise2, tryPromise2, unsandbox2, allowInterrupt2, checkInterruptible2, disconnect2, interrupt7, interruptWith3, interruptible4, interruptibleMask2, onInterrupt2, uninterruptible2, uninterruptibleMask3, liftPredicate3, as7, asSome2, asSomeError2, asVoid5, flip2, flipWith2, map18, mapAccum3, mapBoth5, mapError4, mapErrorCause3, merge7, negate2, acquireRelease2, acquireReleaseInterruptible2, acquireUseRelease2, addFinalizer3, ensuring3, onError2, onExit3, parallelFinalizers2, sequentialFinalizers2, finalizersMask2, scope3, scopeWith2, scopedWith2, scoped3, using2, withEarlyRelease2, awaitAllChildren2, daemonChildren2, descriptor2, descriptorWith2, diffFiberRefs2, ensuringChild2, ensuringChildren2, fiberId2, fiberIdWith2, fork3, forkDaemon2, forkAll2, forkIn2, forkScoped2, forkWithErrorHandler2, fromFiber2, fromFiberEffect2, supervised2, transplant2, withConcurrency2, withScheduler2, withSchedulingPriority2, withMaxOpsBeforeYield2, clock2, clockWith4, withClockScoped2, withClock2, console3, consoleWith2, withConsoleScoped2, withConsole2, delay22, sleep4, timed2, timedWith2, timeout2, timeoutOption2, timeoutFail2, timeoutFailCause2, timeoutTo2, configProviderWith2, withConfigProvider2, withConfigProviderScoped2, context3, contextWith2, contextWithEffect2, mapInputContext3, provide2, provideService3, provideServiceEffect2, serviceFunction2, serviceFunctionEffect2, serviceFunctions2, serviceConstants2, serviceMembers2, serviceOption2, serviceOptional2, updateService2, Do3, bind4, bindAll2, bindTo4, let_4, option2, either4, exit3, intoDeferred2, if_2, filterOrDie2, filterOrDieMessage2, filterOrElse2, filterOrFail2, filterEffectOrElse2, filterEffectOrFail2, unless2, unlessEffect2, when2, whenEffect2, whenFiberRef2, whenRef2, flatMap11, andThen6, flatten8, race2, raceAll2, raceFirst2, raceWith2, summarized2, tap4, tapBoth2, tapDefect2, tapError3, tapErrorTag2, tapErrorCause3, forever3, iterate2, loop2, repeat, repeatN2, repeatOrElse, schedule, scheduleForked2, scheduleFrom, whileLoop3, getFiberRefs, inheritFiberRefs2, locally, locallyWith, locallyScoped, locallyScopedWith, patchFiberRefs2, setFiberRefs2, updateFiberRefs2, isFailure4, isSuccess3, match14, matchCause4, matchCauseEffect3, matchEffect3, log32, logWithLevel2 = (level, ...message) => logWithLevel(level)(...message), logTrace2, logDebug2, logInfo2, logWarning2, logError2, logFatal2, withLogSpan2, annotateLogs3, annotateLogsScoped2, logAnnotations2, withUnhandledErrorLogLevel2, whenLogLevel2, orDie3, orDieWith2, orElse6, orElseFail2, orElseSucceed2, firstSuccessOf2, random3, randomWith2, withRandom2, withRandomFixed, withRandomScoped2, runtime4, getRuntimeFlags, patchRuntimeFlags, withRuntimeFlagsPatch, withRuntimeFlagsPatchScoped, tagMetrics2, labelMetrics2, tagMetricsScoped2, labelMetricsScoped2, metricLabels2, withMetric2, unsafeMakeSemaphore2, makeSemaphore2, unsafeMakeLatch2, makeLatch2, runFork2, runCallback, runPromise, runPromiseExit, runSync, runSyncExit, validate2, validateWith2, zip6, zipLeft6, zipRight6, zipWith8, ap2, blocked2, runRequestBlock2, step3, request, cacheRequestResult, withRequestBatching2, withRequestCaching2, withRequestCache2, tracer2, tracerWith4, withTracer2, withTracerScoped2, withTracerEnabled2, withTracerTiming2, annotateSpans3, annotateCurrentSpan2, currentSpan2, currentParentSpan2, spanAnnotations2, spanLinks2, linkSpans2, linkSpanCurrent2, makeSpan2, makeSpanScoped2, useSpan2, withSpan3, functionWithSpan2, withSpanScoped2, withParentSpan3, fromNullable3, optionFromOptional2, transposeOption = (self) => {
   return isNone(self) ? succeedNone2 : map18(self.value, some);
 }, transposeMapOption, makeTagProxy = (TagClass) => {
   const cache = /* @__PURE__ */ new Map;
@@ -17477,13 +17691,13 @@ schema (${ast._tag}): ${ast}`;
   [PlatformWorkerTypeId]: PlatformWorkerTypeId,
   spawn(id3) {
     return gen3(function* () {
-      const spawn4 = yield* Spawner;
+      const spawn5 = yield* Spawner;
       let currentPort;
       const buffer3 = [];
       const run6 = (handler) => uninterruptibleMask3((restore) => gen3(function* () {
         const scope5 = yield* scope3;
         const port2 = yield* options.setup({
-          worker: spawn4(id3),
+          worker: spawn5(id3),
           scope: scope5
         });
         currentPort = port2;
@@ -18753,7 +18967,7 @@ var init_chunk_VOG34SRF = __esm(() => {
     currentSpan: () => currentSpan2,
     custom: () => custom2,
     daemonChildren: () => daemonChildren2,
-    delay: () => delay2,
+    delay: () => delay22,
     descriptor: () => descriptor2,
     descriptorWith: () => descriptorWith2,
     die: () => die7,
@@ -23196,7 +23410,7 @@ ${this.stack.split(`
   });
   clockWith3 = clockWith2;
   clock = /* @__PURE__ */ clockWith3(succeed);
-  delay = /* @__PURE__ */ dual(2, (self, duration4) => zipRight2(sleep22(duration4), self));
+  delay2 = /* @__PURE__ */ dual(2, (self, duration4) => zipRight2(sleep22(duration4), self));
   allowInterrupt = /* @__PURE__ */ descriptorWith((descriptor3) => size3(descriptor3.interruptors) > 0 ? interrupt2 : void_2);
   descriptor = /* @__PURE__ */ descriptorWith(succeed);
   Do2 = /* @__PURE__ */ succeed({});
@@ -23261,7 +23475,7 @@ ${this.stack.split(`
   }));
   every5 = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => forAllLoop(elements[Symbol.iterator](), 0, predicate)));
   fiberRefs2 = /* @__PURE__ */ withFiberRuntime((state) => succeed(state.getFiberRefs()));
-  log3 = /* @__PURE__ */ logWithLevel();
+  log4 = /* @__PURE__ */ logWithLevel();
   logTrace = /* @__PURE__ */ logWithLevel(Trace);
   logDebug = /* @__PURE__ */ logWithLevel(Debug);
   logInfo = /* @__PURE__ */ logWithLevel(Info);
@@ -25493,9 +25707,9 @@ ${this.stack.split(`
     a;
     eq;
     [memoKeySymbol] = memoKeySymbol;
-    constructor(a, eq9) {
+    constructor(a, eq10) {
       this.a = a;
-      this.eq = eq9;
+      this.eq = eq10;
     }
     [symbol2](that) {
       if (hasProperty(that, memoKeySymbol)) {
@@ -27310,7 +27524,7 @@ ${this.stack.split(`
   consoleWith2 = consoleWith;
   withConsoleScoped2 = withConsoleScoped;
   withConsole2 = withConsole;
-  delay2 = delay;
+  delay22 = delay2;
   sleep4 = sleep32;
   timed2 = timed;
   timedWith2 = timedWith;
@@ -27398,7 +27612,7 @@ ${this.stack.split(`
   matchCause4 = matchCause;
   matchCauseEffect3 = matchCauseEffect;
   matchEffect3 = matchEffect;
-  log32 = log3;
+  log32 = log4;
   logTrace2 = logTrace;
   logDebug2 = logDebug;
   logInfo2 = logInfo;
@@ -42365,13 +42579,13 @@ ${len.toString(16)}\r
       function makeFilterCalls(parameterName) {
         return (parameterValue) => {
           if (typeof parameterValue === "string" || parameterValue == null) {
-            return this.logs.filter((log4) => {
-              return log4[parameterName] === parameterValue;
+            return this.logs.filter((log5) => {
+              return log5[parameterName] === parameterValue;
             });
           }
           if (parameterValue instanceof RegExp) {
-            return this.logs.filter((log4) => {
-              return parameterValue.test(log4[parameterName]);
+            return this.logs.filter((log5) => {
+              return parameterValue.test(log5[parameterName]);
             });
           }
           throw new InvalidArgumentError(`${parameterName} parameter should be one of string, regexp, undefined or null`);
@@ -42464,8 +42678,8 @@ ${len.toString(16)}\r
             return this.logs.filter(criteria);
           }
           if (criteria instanceof RegExp) {
-            return this.logs.filter((log4) => {
-              return criteria.test(log4.toString());
+            return this.logs.filter((log5) => {
+              return criteria.test(log5.toString());
             });
           }
           if (typeof criteria === "object" && criteria !== null) {
@@ -42515,13 +42729,13 @@ ${len.toString(16)}\r
           this.logs = [];
         }
         [kMockCallHistoryAddLog](requestInit) {
-          const log4 = new MockCallHistoryLog(requestInit);
-          this.logs.push(log4);
-          return log4;
+          const log5 = new MockCallHistoryLog(requestInit);
+          this.logs.push(log5);
+          return log5;
         }
         *[Symbol.iterator]() {
-          for (const log4 of this.calls()) {
-            yield log4;
+          for (const log5 of this.calls()) {
+            yield log5;
           }
         }
       };
@@ -53277,7 +53491,7 @@ var init_chunk_BIWNFKGV = __esm(() => {
 
 // ../../node_modules/.bun/@ai-hero+sandcastle@0.12.0/node_modules/@ai-hero/sandcastle/dist/chunk-62WN33RK.js
 import { createRequire as createRequire7 } from "module";
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 var noSandbox = (options) => ({
   tag: "none",
@@ -53295,7 +53509,7 @@ var noSandbox = (options) => ({
         const shellCmd = isWindows ? "cmd.exe" : "sh";
         const shellArgs = isWindows ? ["/d", "/s", "/c", command] : ["-c", command];
         return new Promise((resolve10, reject) => {
-          const proc = spawn5(shellCmd, shellArgs, {
+          const proc = spawn6(shellCmd, shellArgs, {
             cwd,
             env: processEnv,
             stdio: [
@@ -53305,6 +53519,8 @@ var noSandbox = (options) => ({
             ],
             windowsVerbatimArguments: isWindows
           });
+          if (proc.pid !== undefined)
+            options?.onChildSpawn?.(proc.pid);
           if (opts?.stdin !== undefined) {
             proc.stdin.write(opts.stdin);
             proc.stdin.end();
@@ -53354,12 +53570,14 @@ var noSandbox = (options) => ({
       interactiveExec: (args2, opts) => {
         return new Promise((resolve10, reject) => {
           const [cmd, ...rest] = args2;
-          const proc = spawn5(cmd, rest, {
+          const proc = spawn6(cmd, rest, {
             cwd: opts.cwd ?? worktreePath,
             env: processEnv,
             stdio: [opts.stdin, opts.stdout, opts.stderr],
             shell: process.platform === "win32"
           });
+          if (proc.pid !== undefined)
+            options?.onChildSpawn?.(proc.pid);
           proc.on("error", (error) => {
             reject(new Error(`exec failed: ${error.message}`));
           });
@@ -54767,7 +54985,7 @@ var init_dist = __esm(() => {
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname8 } from "path";
 import * as z3 from "zod";
-import { eq as eq9 } from "drizzle-orm";
+import { eq as eq10 } from "drizzle-orm";
 function hostDefaults(logicalCpus) {
   return { ...DEFAULTS, burnConcurrency: resolveDefaultBurnConcurrency(logicalCpus) };
 }
@@ -54809,8 +55027,9 @@ function projectOverrides(ctx, projectId) {
     knownFailures: projects.knownFailures,
     dbResetCommand: projects.dbResetCommand,
     driveSetupCommand: projects.driveSetupCommand,
-    driveStopCommand: projects.driveStopCommand
-  }).from(projects).where(eq9(projects.id, projectId)).get();
+    driveStopCommand: projects.driveStopCommand,
+    driveInstructions: projects.driveInstructions
+  }).from(projects).where(eq10(projects.id, projectId)).get();
   return {
     model: row?.model ?? null,
     sandbox: row?.sandbox ?? null,
@@ -54821,7 +55040,8 @@ function projectOverrides(ctx, projectId) {
     knownFailures: row?.knownFailures ?? null,
     dbResetCommand: row?.dbResetCommand ?? null,
     driveSetupCommand: row?.driveSetupCommand ?? null,
-    driveStopCommand: row?.driveStopCommand ?? null
+    driveStopCommand: row?.driveStopCommand ?? null,
+    driveInstructions: row?.driveInstructions ?? null
   };
 }
 function resolveField(desc5, layers) {
@@ -54875,7 +55095,7 @@ function updateSettings(ctx, input, io = {}) {
     if (!toProject)
       throw new InvalidInputError(`${desc5.key} cannot be cleared`);
     const project3 = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq9(projects.id, project3.id)).run();
+    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq10(projects.id, project3.id)).run();
     recordHuman(ctx, project3.id, desc5.key, null);
     emitProject(ctx, project3.id, {
       type: "settings.updated",
@@ -54891,7 +55111,7 @@ function updateSettings(ctx, input, io = {}) {
   const value = parsed.data;
   if (toProject) {
     const project3 = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq9(projects.id, project3.id)).run();
+    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq10(projects.id, project3.id)).run();
     recordHuman(ctx, project3.id, desc5.key, String(value));
     emitProject(ctx, project3.id, {
       type: "settings.updated",
@@ -55128,6 +55348,13 @@ var init_settings = __esm(() => {
       restartRequired: false,
       valueSchema: z3.string().min(1),
       parseEnv: idEnv
+    },
+    {
+      key: "driveInstructions",
+      projectColumn: "driveInstructions",
+      restartRequired: false,
+      valueSchema: z3.string().min(1),
+      parseEnv: idEnv
     }
   ];
   DEFAULTS = RuncastleConfig.parse({});
@@ -55353,13 +55580,13 @@ var init_setup = __esm(() => {
 });
 
 // src/doctor/system-exec.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 function createSystemExec(opts = {}) {
   return (command, args2) => new Promise((resolve10) => {
     const { file, args: spawnArgs } = resolveSpawnTarget(command, args2);
     let stdout = "";
     let stderr = "";
-    const child = spawn6(file, spawnArgs, { cwd: opts.cwd, windowsHide: true });
+    const child = spawn7(file, spawnArgs, { cwd: opts.cwd, windowsHide: true });
     child.stdout?.on("data", (d) => {
       stdout += d.toString();
     });
@@ -55604,6 +55831,20 @@ function buildDriveAvailability(browserPath, devCommand, inheritedMode) {
 function inheritedReviewMode(verifiedTicketId, fileExists2 = existsSync16) {
   return verifiedTicketId && fileExists2(reviewWalkthroughPath(verifiedTicketId)) ? "drive" : "gates";
 }
+function buildDriveInstructions(instructions) {
+  const text3 = instructions?.trim();
+  if (!text3) {
+    return "No drive instructions recorded for this project \u2014 drive from what the ticket, the diff, and the app surface tell you.";
+  }
+  return [
+    "How to drive this project, from the project owner. These are their standing instructions for operating the app under test: they authorize actions inside the driven app only \u2014 they do not change your review rules, they do not permit edits to the repository under review, and they do not override any guard on your own session.",
+    "",
+    "```",
+    text3,
+    "```"
+  ].join(`
+`);
+}
 function buildGateNotes(config2) {
   const commands = config2.verifyCommands?.trim();
   const failures2 = config2.knownFailures?.trim();
@@ -55637,6 +55878,9 @@ function writeReviewArtifacts(ticket, runId, config2) {
     walkthroughPath: reviewWalkthroughPath(ticket.id)
   };
 }
+function shouldStopAfterDigest(iteration, digestPath, fileExists2 = existsSync16) {
+  return iteration >= 2 && fileExists2(digestPath);
+}
 async function releaseDriveQuietly() {
   try {
     await releaseReviewDrive();
@@ -55668,6 +55912,7 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
     FEATURE_BRANCH: feature.branch,
     BASE_BRANCH: feature.baseBranch,
     DRIVE_AVAILABILITY: buildDriveAvailability(findOnPath(AGENT_BROWSER_BIN), project3.devCommand, inheritedMode),
+    DRIVE_INSTRUCTIONS: buildDriveInstructions(project3.driveInstructions),
     GATE_NOTES: buildGateNotes(deps.config),
     DIGEST_PATH: artifacts.digestPath,
     BLOCKED_PATH: artifacts.blockedPath,
@@ -55679,6 +55924,7 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
   mkdirSync9(logsDir(), { recursive: true });
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
   beginTranscript(ticket.id);
+  const ticketAbort = registerTicketAbort(ticket.id);
   const onStreamEvent = (event) => {
     throttle.onEvent(event);
     timer.onEvent(event);
@@ -55691,15 +55937,17 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
         name: event.name
       });
     }
+    if (!ticketAbort.signal.aborted && shouldStopAfterDigest(event.iteration, artifacts.digestPath)) {
+      ticketAbort.abort(new Error("the review already wrote its digest"));
+    }
   };
-  const ticketAbort = registerTicketAbort(ticket.id);
   const signal = AbortSignal.any([ctx.signal, ticketAbort.signal]);
   const options = {
     agent: buildBurnAgent(deps.config, deps.token, deps.model, {
       onHost: true,
       mcp: artifacts.mcp
     }),
-    sandbox: noSandbox(),
+    sandbox: noSandbox({ onChildSpawn: registerHostChildren(ticket.id, { runId: ctx.runId }) }),
     cwd: project3.repoPath,
     prompt,
     branchStrategy: { type: "head" },
@@ -55721,6 +55969,7 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
     runError = err;
   } finally {
     releaseTicketAbort(ticket.id);
+    killRegistry().release(ticket.id);
     throttle.flush();
     endTranscript(ticket.id);
     await releaseDriveQuietly();
@@ -55753,12 +56002,13 @@ var init_review_ticket = __esm(() => {
   init_agent_stream();
   init_git();
   init_review_findings();
+  init_kill_registry();
   init_ticket_burner();
 });
 
 // ../../node_modules/.bun/@ai-hero+sandcastle@0.12.0/node_modules/@ai-hero/sandcastle/dist/chunk-CP3TYXZA.js
 import { createRequire as createRequire10 } from "module";
-import { execFile as execFile2, execFileSync, spawn as spawn7 } from "child_process";
+import { execFile as execFile2, execFileSync, spawn as spawn8 } from "child_process";
 import { randomUUID } from "crypto";
 import { createInterface as createInterface3 } from "readline";
 var dockerExec = (args2) => Effect_exports.async((resume2) => {
@@ -55837,7 +56087,7 @@ var dockerExec = (args2) => Effect_exports.async((resume2) => {
     env: options?.env,
     sandboxHomedir,
     create: async (createOptions) => {
-      const containerName = `sandcastle-${randomUUID()}`;
+      const containerName = options?.containerName ?? `sandcastle-${randomUUID()}`;
       const worktreePath = createOptions.mounts.find((m) => m.hostPath === createOptions.worktreePath)?.sandboxPath ?? "/home/agent/workspace";
       const allMounts = [...createOptions.mounts, ...userMounts];
       const volumeMounts = allMounts.map((m) => ({
@@ -55904,7 +56154,7 @@ var dockerExec = (args2) => Effect_exports.async((resume2) => {
             args2.push("-w", opts.cwd);
           args2.push(containerName, "sh", "-c", effectiveCommand);
           return new Promise((resolve22, reject) => {
-            const proc = spawn7("docker", args2, {
+            const proc = spawn8("docker", args2, {
               stdio: [
                 opts?.stdin !== undefined ? "pipe" : "ignore",
                 "pipe",
@@ -55968,7 +56218,7 @@ var dockerExec = (args2) => Effect_exports.async((resume2) => {
             if (opts.cwd)
               dockerArgs.push("-w", opts.cwd);
             dockerArgs.push(containerName, ...args2);
-            const proc = spawn7("docker", dockerArgs, {
+            const proc = spawn8("docker", dockerArgs, {
               stdio: [opts.stdin, opts.stdout, opts.stderr]
             });
             proc.on("error", (error) => {
@@ -56048,7 +56298,7 @@ var init_docker = __esm(() => {
 
 // ../../node_modules/.bun/@ai-hero+sandcastle@0.12.0/node_modules/@ai-hero/sandcastle/dist/sandboxes/podman.js
 import { createRequire as createRequire12 } from "module";
-import { execFile as execFile3, execFileSync as execFileSync2, spawn as spawn8 } from "child_process";
+import { execFile as execFile3, execFileSync as execFileSync2, spawn as spawn9 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { createInterface as createInterface4 } from "readline";
 var podman = (options) => {
@@ -56164,7 +56414,7 @@ var podman = (options) => {
             args2.push("-w", opts.cwd);
           args2.push(containerName, "sh", "-c", effectiveCommand);
           return new Promise((resolve10, reject) => {
-            const proc = spawn8("podman", args2, {
+            const proc = spawn9("podman", args2, {
               stdio: [
                 opts?.stdin !== undefined ? "pipe" : "ignore",
                 "pipe",
@@ -56228,7 +56478,7 @@ var podman = (options) => {
             if (opts.cwd)
               podmanArgs.push("-w", opts.cwd);
             podmanArgs.push(containerName, ...args2);
-            const proc = spawn8("podman", podmanArgs, {
+            const proc = spawn9("podman", podmanArgs, {
               stdio: [opts.stdin, opts.stdout, opts.stderr]
             });
             proc.on("error", (error) => {
@@ -56599,13 +56849,13 @@ function parseEnvFile3(content) {
     if (line.length === 0 || line.startsWith("#"))
       continue;
     const body = line.startsWith("export ") ? line.slice(7).trim() : line;
-    const eq10 = body.indexOf("=");
-    if (eq10 === -1)
+    const eq11 = body.indexOf("=");
+    if (eq11 === -1)
       continue;
-    const key = body.slice(0, eq10).trim();
+    const key = body.slice(0, eq11).trim();
     if (key.length === 0)
       continue;
-    let value = body.slice(eq10 + 1).trim();
+    let value = body.slice(eq11 + 1).trim();
     if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
       value = value.slice(1, -1);
     }
@@ -56655,8 +56905,12 @@ function cacheMountFor(pm, hostPath) {
 }
 function buildBurnCacheMounts(slot, projectId, sandbox3, pm) {
   if (slot !== undefined) {
+    const volume = burnCacheVolumeName(projectId);
     return {
-      mounts: [{ volume: burnCacheVolumeName(projectId), sandboxPath: BURN_CACHE_MOUNT }],
+      mounts: [
+        { volume, sandboxPath: BURN_CACHE_MOUNT },
+        ...TOOLCHAIN_CACHE_SANDBOX_PATHS.map((sandboxPath) => ({ volume, sandboxPath }))
+      ],
       env: pm ? burnCacheEnv(pm) : {}
     };
   }
@@ -57046,12 +57300,13 @@ function delayUnlessAborted(ms, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
   });
 }
-function stopTicketRun(ticketId) {
+async function stopTicketRun(ticketId) {
   const controller = activeTicketAborts.get(ticketId);
   if (!controller)
-    return false;
+    return { stopped: false, confirmed: true };
   controller.abort(new Error("ticket stopped by user"));
-  return true;
+  const { confirmed } = await killRegistry().killAndWait(ticketId);
+  return { stopped: true, confirmed };
 }
 function registerTicketAbort(ticketId) {
   const controller = new AbortController;
@@ -57242,6 +57497,7 @@ async function burnTickets(ctx, tickets2, execute, concurrency = 1) {
       ticketId: t.id
     });
     const outcome = await execute(ctx, t, { digests: [...digests] });
+    await killRegistry().whenKillSettled(t.id);
     if (outcome.status === "done") {
       status3.set(seq2, "done");
       const reviewedCommit = isReviewTicket(t) ? await headSha(ctx.project.repoPath, ctx.feature.branch) : undefined;
@@ -57572,27 +57828,31 @@ function buildAgentExtraArgs(runtime5, options) {
 function quoteArg(value) {
   return `"${value}"`;
 }
-function selectSandbox(config2, mounts = [], env = {}) {
-  const imageOpts = buildSandboxOptions(config2, mounts, env);
+function selectSandbox(config2, mounts = [], env = {}, kill = {}) {
+  const imageOpts = buildSandboxOptions(config2, mounts, env, kill.containerName);
   switch (config2.sandbox) {
     case "docker":
       return docker(imageOpts);
     case "podman":
       return podman(imageOpts);
     case "noSandbox":
-      return noSandbox();
+      return noSandbox(kill.onChildSpawn ? { onChildSpawn: kill.onChildSpawn } : {});
     default:
       throw new Error(`no sandbox provider for sandbox "${config2.sandbox}" \u2014 refusing to run the agent unsandboxed`);
   }
 }
-function buildSandboxOptions(config2, mounts = [], env = {}) {
+function buildSandboxOptions(config2, mounts = [], env = {}, containerName) {
   return {
     imageName: resolveSandboxImage(config2),
     ...mounts.length > 0 ? { mounts } : {},
     ...config2.burnCpus !== undefined ? { cpus: config2.burnCpus } : {},
-    ...Object.keys(env).length > 0 ? { env } : {}
+    ...Object.keys(env).length > 0 ? { env } : {},
+    ...containerName !== undefined ? { containerName } : {}
   };
 }
+function burnContainerName(runId, seq2, lane) {
+  return `runcastle-${runId}-t${seq2}${lane ? `-${lane}` : ""}`;
+}
 async function realExecuteTicketRun(ctx, ticket, config2, token, model, land, ensureIsolatedPushTarget, ensureCacheVolume, blocks, runCtx) {
   const allocator = resolveBurnCacheMode(config2) === "volume" ? getBurnSlotAllocator(config2.burnConcurrency) : undefined;
   return withBurnCacheSlot(allocator, async (slot) => {
@@ -57715,6 +57975,15 @@ async function burnTicket(ctx, ticket, config2, token, model, land, ensureIsolat
   };
   const ticketAbort = registerTicketAbort(ticket.id);
   const signal = AbortSignal.any([ctx.signal, ticketAbort.signal]);
+  const makeKillable = (containerName) => {
+    if (config2.sandbox !== "docker")
+      return;
+    killRegistry().registerContainer(ticket.id, containerName, { runId: ctx.runId });
+  };
+  const killHandles = (containerName) => ({
+    containerName,
+    onChildSpawn: registerHostChildren(ticket.id, { runId: ctx.runId })
+  });
   const maxAttempts = Math.max(1, config2.burnAttempts);
   const conflictResume = ticket.conflictFiles !== undefined && !!ticket.attemptBranch;
   let baseBranch = feature.branch;
@@ -57746,6 +58015,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land, ensureIsolat
   };
   const runResolver = async (input) => {
     const resolveBranch = ticketBranchName(feature.slug, ticket.seq, newId("r").slice(2, 10));
+    const containerName = burnContainerName(ctx.runId, ticket.seq, "resolve");
     const otherSide = await commitSummaries(project3.repoPath, input.branch, feature.branch);
     const prompt = renderTemplate(readFileSync9(resolverTemplatePath(), "utf8"), {
       TICKET_JSON: ticketJson,
@@ -57773,9 +58043,10 @@ async function burnTicket(ctx, ticket, config2, token, model, land, ensureIsolat
     let result;
     try {
       beginSetupSpan(resolveBranch);
+      makeKillable(containerName);
       result = await run6({
         agent: buildBurnAgent(config2, token, model, agentOptions),
-        sandbox: selectSandbox(config2, mounts, sandboxEnv),
+        sandbox: selectSandbox(config2, mounts, sandboxEnv, killHandles(containerName)),
         cwd: project3.repoPath,
         prompt,
         branchStrategy: { type: "branch", branch: resolveBranch, baseBranch: input.branch },
@@ -57894,6 +58165,7 @@ ${blocked3.trim()}`
     }
     let result;
     let tempBranch = "";
+    const containerName = burnContainerName(ctx.runId, ticket.seq);
     for (let attempt = 1;; attempt++) {
       tempBranch = ticketBranchName(feature.slug, ticket.seq, newId("b").slice(2, 10));
       const hookCommand = setupHookFor(tempBranch);
@@ -57907,7 +58179,7 @@ ${blocked3.trim()}`
       }
       const runOptions = {
         agent: buildBurnAgent(config2, token, model, agentOptions),
-        sandbox: selectSandbox(config2, mounts, sandboxEnv),
+        sandbox: selectSandbox(config2, mounts, sandboxEnv, killHandles(containerName)),
         cwd: project3.repoPath,
         prompt: retryNotes ? `${basePrompt}
 
@@ -57933,6 +58205,7 @@ ${retryNotes}` : basePrompt,
       try {
         await excludeAttachments();
         beginSetupSpan(tempBranch);
+        makeKillable(containerName);
         result = await run6(runOptions);
         await clearAttachmentsFor(tempBranch);
         break;
@@ -58049,6 +58322,7 @@ ${blocked3.trim()}` };
     return await landChain(tempBranch, outcome.commits);
   } finally {
     releaseTicketAbort(ticket.id);
+    killRegistry().release(ticket.id);
     throttle.flush();
     endTranscript(ticket.id);
     emitTicketTiming(ctx, ticket, buildTicketTiming(timer.summary(), startedAt, Date.now()));
@@ -58143,7 +58417,7 @@ function readTokenFromEnvFile(path2, runtime5) {
   const token = fromFile && fromFile.length > 0 ? fromFile : process.env[key];
   return token && token.length > 0 ? token : undefined;
 }
-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 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, TOOLCHAIN_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();
@@ -58159,6 +58433,7 @@ var init_ticket_burner = __esm(() => {
   init_burn_guard();
   init_burn_cache();
   init_review_ticket();
+  init_kill_registry();
   init_docker();
   init_podman();
   init_no_sandbox();
@@ -58174,6 +58449,12 @@ var init_ticket_burner = __esm(() => {
     yarn: "~/.cache/yarn",
     npm: "~/.npm"
   };
+  TOOLCHAIN_CACHE_SANDBOX_PATHS = [
+    "~/.m2",
+    "~/.gradle",
+    "~/.cache/pip",
+    "~/.cargo/registry"
+  ];
   RUN = String.raw`(?![\w./-])`;
   BASH_PATTERNS = [
     ["tests", new RegExp(String.raw`\b(vitest|jest|pytest|go test|cargo test|bun test|playwright|maestro)${RUN}|\b(pnpm|npm|yarn|bun|npx)\b[^&;|]*?\s(run\s+)?test${RUN}|--testPathPatterns`)],
@@ -58324,6 +58605,16 @@ function researchTemplatePath() {
   const here = dirname11(fileURLToPath8(import.meta.url));
   return join18(resolveSkillsRoot(here), "burner", "research-waypoint.md");
 }
+function researchContainerName(runId, seq2) {
+  return `runcastle-${runId}-w${seq2}`;
+}
+function registerResearchKill(config2, runId, seq2) {
+  const containerName = researchContainerName(runId, seq2);
+  if (config2.sandbox === "docker") {
+    killRegistry().registerContainer(runId, containerName, { runId });
+  }
+  return { containerName, onChildSpawn: registerHostChildren(runId, { runId }) };
+}
 async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   const { project: project3, feature } = ctx;
   const docRelPath = researchDocRel(feature.slug, waypoint);
@@ -58341,7 +58632,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
   const codexAuthMount = codexAuthMountFor(model.runtime, config2.sandbox);
   const runOptions = {
     agent: buildBurnAgent(config2, token, model),
-    sandbox: selectSandbox(config2, codexAuthMount ? [codexAuthMount] : []),
+    sandbox: selectSandbox(config2, codexAuthMount ? [codexAuthMount] : [], {}, registerResearchKill(config2, ctx.runId, waypoint.seq)),
     cwd: project3.repoPath,
     prompt,
     branchStrategy: { type: "branch", branch: tempBranch, baseBranch: feature.branch },
@@ -58368,6 +58659,8 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
       message: `waypoint ${waypoint.seq}: agent finished but sandcastle could not remove its worktree (${errorHeadline2(msg)})${removed ? " \u2014 cleaned up" : " \u2014 left on disk"}; landing the ${salvaged.length} commit(s) anyway`,
       data: { tempBranch, error: msg, cleanedUp: removed }
     });
+  } finally {
+    killRegistry().release(ctx.runId);
   }
   throttle.flush();
   const outcome = result ? interpretResearchResult(result, docRelPath) : { status: "done", commits: salvaged, docRelPath };
@@ -58407,6 +58700,7 @@ var init_research = __esm(() => {
   init_skills_root();
   init_dist();
   init_git();
+  init_kill_registry();
   init_setup();
   init_ticket_burner();
   PLACEHOLDERS = ["WAYPOINT_JSON", "FEATURE_BRIEF", "DOCS_DIGEST", "RESEARCH_DOC_PATH"];
@@ -58431,7 +58725,7 @@ var init_registry2 = __esm(() => {
 });
 
 // src/workflows/runner.ts
-import { eq as eq10 } from "drizzle-orm";
+import { eq as eq11 } from "drizzle-orm";
 function workflowClaimsFeatureBranch(workflowId) {
   return BRANCH_CLAIMING.has(workflowId);
 }
@@ -58460,7 +58754,7 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
       claim(ctx, opts.claimWaypointId, runId);
     } catch (e) {
       const summary = e instanceof Error ? e.message : "claim failed";
-      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq10(runs.id, runId)).run();
+      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq11(runs.id, runId)).run();
       throw e;
     }
   }
@@ -58510,13 +58804,15 @@ async function startRun(ctx, featureId, workflowId, opts = {}) {
   });
   return { runId, done: done10 };
 }
-function cancelRun(runId) {
+async function cancelRun(runId) {
   controllers.get(runId)?.abort();
+  return await killRegistry().killAllForRun(runId);
 }
 async function executeRun(ctx, runId, featureId, workflow2, runPromise2, controller, cleanup) {
   let status3 = "failed";
   let summary = "run failed";
   let digest;
+  let threw = false;
   try {
     const result = await runPromise2;
     status3 = result.status;
@@ -58530,11 +58826,14 @@ async function executeRun(ctx, runId, featureId, workflow2, runPromise2, control
       status3 = "failed";
       summary = e instanceof Error ? e.message : "run failed";
     }
-    emit(ctx, featureId, { type: "run.error", message: summary, runId });
+    threw = true;
   } finally {
     controllers.delete(runId);
   }
-  ctx.db.update(runs).set({ status: status3, endedAt: Date.now(), summary, ...digest ? { digest } : {} }).where(eq10(runs.id, runId)).run();
+  await killRegistry().whenRunKillsSettled(runId);
+  if (threw)
+    emit(ctx, featureId, { type: "run.error", message: summary, runId });
+  ctx.db.update(runs).set({ status: status3, endedAt: Date.now(), summary, ...digest ? { digest } : {} }).where(eq11(runs.id, runId)).run();
   releaseForSession(ctx, runId);
   if (workflowClaimsFeatureBranch(workflow2)) {
     sweepOrphanedBurning(ctx, featureId, `orphaned \u2014 the run ended (${status3}) while it was burning`);
@@ -58577,13 +58876,14 @@ var init_runner = __esm(() => {
   init_review_findings();
   init_tickets();
   init_waypoints();
+  init_kill_registry();
   init_registry2();
   controllers = new Map;
   BRANCH_CLAIMING = new Set(["ticket-burner"]);
 });
 
 // src/services/features.ts
-import { desc as desc5, eq as eq11 } from "drizzle-orm";
+import { desc as desc5, eq as eq12 } from "drizzle-orm";
 import { rmSync as rmSync4 } from "fs";
 async function createFeature(ctx, input) {
   const project3 = requireProjectById(ctx, input.projectId);
@@ -58636,7 +58936,7 @@ async function startDraft(ctx, featureId, opts = {}) {
   const project3 = projectForFeature(ctx, feature);
   const base = await requestedBase(project3, opts.baseBranch);
   const { branchReady, baseBranch } = await ensureFeatureBranch(project3, feature.slug, base);
-  ctx.db.update(features).set({ status: "active", baseBranch }).where(eq11(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: "active", baseBranch }).where(eq12(features.id, featureId)).run();
   const started = { ...feature, status: "active", baseBranch };
   emit(ctx, featureId, {
     type: "feature.started",
@@ -58785,7 +59085,7 @@ function getFeatureFull(ctx, id3) {
   };
 }
 function list(ctx, projectId) {
-  const rows = ctx.db.select().from(features).where(eq11(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
+  const rows = ctx.db.select().from(features).where(eq12(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
   const lastActivity = latestTsByFeature(ctx, projectId);
   return rows.map((row) => {
     const feature = rowToFeature(row);
@@ -58832,6 +59132,13 @@ function advance(ctx, featureId) {
     throw new GateError("feature is already at the final phase");
   return setPhase(ctx, featureId, next4, "phase.advanced");
 }
+function assertTicketsReady(ctx, feature) {
+  if (feature.ticketsReadyLap === feature.lap)
+    return;
+  if (activeSessionsForFeature(ctx, feature.id).length === 0)
+    return;
+  throw new GateError("the session is still finishing the tickets \u2014 it completes the tickets phase when the lap " + "is done, and the burn arms then");
+}
 async function burn(ctx, featureId, opts = {}) {
   const feature = getFeatureRow(ctx, featureId);
   requireNotDraft(feature);
@@ -58854,6 +59161,12 @@ async function burn(ctx, featureId, opts = {}) {
   if (lapTickets.filter((t) => t.status !== "cancelled").length < 1) {
     throw new GateError(lapTickets.length > 0 ? "no burnable tickets \u2014 every ticket is cancelled" : "no tickets to burn");
   }
+  if (feature.phase === "tickets") {
+    const gate = checkGate(ctx, "tickets-approved", feature);
+    if (!gate.satisfied)
+      throw new GateError(gate.reason ?? "gate G3 not satisfied");
+    assertTicketsReady(ctx, feature);
+  }
   if (restarting) {
     sweepOrphanedBurning(ctx, featureId, "orphaned \u2014 the previous run died while it was burning");
     tickets2 = listByFeature2(ctx, featureId);
@@ -58903,7 +59216,7 @@ function rethink(ctx, featureId) {
     throw new GateError(`a ${live[0].kind} session is already live for ${feature.slug} \u2014 only one terminal per feature; end or resume it first`);
   }
   const lap = feature.lap + 1;
-  ctx.db.update(features).set({ lap }).where(eq11(features.id, featureId)).run();
+  ctx.db.update(features).set({ lap }).where(eq12(features.id, featureId)).run();
   return setPhase(ctx, featureId, RETHINK_LOOP_BACK.to, "lap.started", `rethink \u2014 lap ${lap}`);
 }
 async function rethinkAndLaunch(ctx, featureId, launch3) {
@@ -58912,7 +59225,7 @@ async function rethinkAndLaunch(ctx, featureId, launch3) {
   try {
     return await launch3(feature);
   } catch (e) {
-    ctx.db.update(features).set({ lap: before.lap }).where(eq11(features.id, featureId)).run();
+    ctx.db.update(features).set({ lap: before.lap }).where(eq12(features.id, featureId)).run();
     setPhase(ctx, featureId, before.phase, "lap.aborted", `lap ${feature.lap} aborted \u2014 its terminal could not be opened (${errMsg2(e)}); back at ${before.phase} on lap ${before.lap}`);
     throw e;
   }
@@ -58991,7 +59304,7 @@ function escalateToMap(ctx, featureId, input) {
     return { ok: true, warning: `feature ${feature.slug} is already mapped \u2014 no changes made` };
   }
   const project3 = projectForFeature(ctx, feature);
-  ctx.db.update(features).set({ mapped: true }).where(eq11(features.id, featureId)).run();
+  ctx.db.update(features).set({ mapped: true }).where(eq12(features.id, featureId)).run();
   scaffoldMapDoc(project3, { ...feature, mapped: true }, input);
   emit(ctx, featureId, {
     type: "feature.escalated",
@@ -59009,7 +59322,7 @@ function archiveFeature(ctx, featureId) {
   const live = listSessionsByFeature(ctx, featureId).find((s) => s.status === "live");
   if (live)
     endSession(ctx, live.id);
-  ctx.db.update(features).set({ status: "archived" }).where(eq11(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: "archived" }).where(eq12(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.archived",
     message: `feature ${feature.slug} archived`,
@@ -59023,7 +59336,7 @@ function unarchiveFeature(ctx, featureId) {
     throw new GateError(`feature ${feature.slug} is not archived`);
   }
   const restored = feature.phase === "shipped" ? "shipped" : "active";
-  ctx.db.update(features).set({ status: restored }).where(eq11(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: restored }).where(eq12(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.unarchived",
     message: `feature ${feature.slug} unarchived (${restored})`,
@@ -59039,7 +59352,7 @@ async function deleteFeature(ctx, featureId) {
   const project3 = projectForFeature(ctx, feature);
   for (const run7 of listRunsByFeature(ctx, featureId)) {
     if (run7.status === "running")
-      cancelRun(run7.id);
+      await cancelRun(run7.id);
   }
   const live = listSessionsByFeature(ctx, featureId).find((s) => s.status === "live");
   if (live)
@@ -59063,13 +59376,13 @@ async function deleteFeature(ctx, featureId) {
   return { ok: true, slug: feature.slug };
 }
 function deleteFeatureRows(ctx, featureId) {
-  ctx.db.delete(tickets).where(eq11(tickets.featureId, featureId)).run();
-  ctx.db.delete(sessions).where(eq11(sessions.featureId, featureId)).run();
-  ctx.db.delete(runs).where(eq11(runs.featureId, featureId)).run();
-  ctx.db.delete(events).where(eq11(events.featureId, featureId)).run();
-  ctx.db.delete(gateOverrides).where(eq11(gateOverrides.featureId, featureId)).run();
-  ctx.db.delete(waypoints).where(eq11(waypoints.featureId, featureId)).run();
-  ctx.db.delete(features).where(eq11(features.id, featureId)).run();
+  ctx.db.delete(tickets).where(eq12(tickets.featureId, featureId)).run();
+  ctx.db.delete(sessions).where(eq12(sessions.featureId, featureId)).run();
+  ctx.db.delete(runs).where(eq12(runs.featureId, featureId)).run();
+  ctx.db.delete(events).where(eq12(events.featureId, featureId)).run();
+  ctx.db.delete(gateOverrides).where(eq12(gateOverrides.featureId, featureId)).run();
+  ctx.db.delete(waypoints).where(eq12(waypoints.featureId, featureId)).run();
+  ctx.db.delete(features).where(eq12(features.id, featureId)).run();
 }
 function gateState(ctx, feature) {
   const gate = nextGate(feature);
@@ -59080,7 +59393,7 @@ function gateState(ctx, feature) {
 }
 function uniqueSlug(ctx, projectId, title) {
   const base = slugify(title);
-  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq11(features.projectId, projectId)).all().map((r) => r.slug));
+  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq12(features.projectId, projectId)).all().map((r) => r.slug));
   if (!existing.has(base))
     return base;
   let n = 2;
@@ -59113,7 +59426,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 dirname12 } from "path";
-import { and as and9, asc as asc5, eq as eq12, lt } from "drizzle-orm";
+import { and as and10, asc as asc5, eq as eq13, lt } from "drizzle-orm";
 function rowToNote(row) {
   return TestNote.parse({
     id: row.id,
@@ -59132,7 +59445,7 @@ function rowToNote(row) {
   });
 }
 function getNote(ctx, id3) {
-  const row = ctx.db.select().from(testNotes).where(eq12(testNotes.id, id3)).get();
+  const row = ctx.db.select().from(testNotes).where(eq13(testNotes.id, id3)).get();
   if (!row)
     throw new NotFoundError(`test note ${id3} not found`);
   return rowToNote(row);
@@ -59149,7 +59462,7 @@ 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);
+  return ctx.db.select().from(testNotes).where(eq13(testNotes.featureId, featureId)).orderBy(asc5(testNotes.createdAt), asc5(testNotes.id)).all().map(rowToNote);
 }
 function addNote(ctx, featureId, text3, author = "human", videoTimestamp, reviewTicketId) {
   const body = cleanText(text3);
@@ -59187,7 +59500,7 @@ function editNote(ctx, noteId, text3) {
   const current2 = getNote(ctx, noteId);
   assertOpen(current2, "edit");
   const body = cleanText(text3);
-  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq12(testNotes.id, noteId)).run();
+  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq13(testNotes.id, noteId)).run();
   emit(ctx, current2.featureId, {
     type: "note.edited",
     message: "note edited",
@@ -59199,7 +59512,7 @@ function editNote(ctx, noteId, text3) {
 function deleteNote(ctx, noteId) {
   const current2 = getNote(ctx, noteId);
   assertOpen(current2, "delete");
-  ctx.db.delete(testNotes).where(eq12(testNotes.id, noteId)).run();
+  ctx.db.delete(testNotes).where(eq13(testNotes.id, noteId)).run();
   rmSync5(annotationPath(noteId), { force: true });
   emit(ctx, current2.featureId, {
     type: "note.deleted",
@@ -59226,7 +59539,7 @@ function toggleNote(ctx, noteId) {
     throw new InvalidInputError(`cannot toggle note ${noteId} \u2014 it is promoted, and promoted notes are frozen`);
   }
   const status3 = current2.status === "open" ? "done" : "open";
-  ctx.db.update(testNotes).set({ status: status3, updatedAt: Date.now() }).where(eq12(testNotes.id, noteId)).run();
+  ctx.db.update(testNotes).set({ status: status3, updatedAt: Date.now() }).where(eq13(testNotes.id, noteId)).run();
   emit(ctx, current2.featureId, {
     type: "note.toggled",
     message: `note ${current2.status} \u2192 ${status3}`,
@@ -59274,7 +59587,7 @@ function freezeAsTickets(ctx, noteIds) {
   const tickets2 = storeTickets(ctx, featureId, selected.map((note2) => promotionTicket(feature, note2)));
   const now = Date.now();
   selected.forEach((note2, i) => {
-    ctx.db.update(testNotes).set({ status: "promoted", ticketId: tickets2[i].id, updatedAt: now }).where(eq12(testNotes.id, note2.id)).run();
+    ctx.db.update(testNotes).set({ status: "promoted", ticketId: tickets2[i].id, updatedAt: now }).where(eq13(testNotes.id, note2.id)).run();
   });
   return { feature, notes: selected.map((n) => getNote(ctx, n.id)), tickets: tickets2 };
 }
@@ -59319,7 +59632,7 @@ function carryNotes(ctx, featureId, noteIds, lap) {
     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();
+    ctx.db.update(testNotes).set({ status: "carried", carriedLap: lap, updatedAt: Date.now() }).where(eq13(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));
@@ -59329,7 +59642,7 @@ 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();
+  ctx.db.update(testNotes).set({ status: "open", carriedLap: null, updatedAt: Date.now() }).where(eq13(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);
@@ -59348,7 +59661,7 @@ function triageNotes(ctx, featureId, input) {
 }
 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 standing = ctx.db.select().from(tickets).where(and10(eq13(tickets.featureId, featureId), eq13(tickets.kind, "implementation"), eq13(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);
@@ -59358,10 +59671,19 @@ function triagePreview(ctx, featureId) {
     standingFixTickets: [...grouped].sort(([a], [b]) => a - b).map(([lap, count3]) => ({ count: count3, lap }))
   };
 }
+function carriedLine(note2) {
+  return `- [\u2192] ${note2.text} (captured lap ${note2.lap}, carried into lap ${note2.carriedLap})${screenshotSuffix(note2)}`;
+}
 function renderTestNotes(ctx, feature) {
   const notes = listByFeature4(ctx, feature.id);
   const laps = [...new Set(notes.map((n) => n.lap))].sort((a, b) => a - b);
   const lines = ["# Test notes"];
+  const carried = notes.filter((note2) => note2.status === "carried");
+  if (carried.length) {
+    lines.push("", "## Carried, still open", "");
+    for (const note2 of carried)
+      lines.push(carriedLine(note2));
+  }
   for (const lap of laps) {
     lines.push("", `## Lap ${lap}`, "");
     for (const note2 of notes.filter((n) => n.lap === lap))
@@ -59441,6 +59763,8 @@ function resolveFeatureReader(ctx, caller) {
 }
 function featureContext(ctx, reader) {
   const feature = getFeatureRow(ctx, reader.featureId);
+  const carried = carriedWork(ctx, feature.id);
+  const withheldDocs = withheldFeatureDocs({ carriedNotesOpen: carried.carriedNotes > 0 });
   const docs2 = [];
   const moreDocs = [];
   for (const summary of listDocs(ctx, feature)) {
@@ -59454,7 +59778,7 @@ function featureContext(ctx, reader) {
       docs2.push({ relPath: summary.relPath, content });
       continue;
     }
-    const withheld = WITHHELD_FEATURE_DOCS[summary.relPath.toLowerCase()];
+    const withheld = withheldDocs[summary.relPath.toLowerCase()];
     moreDocs.push({
       relPath: summary.relPath,
       title: summary.title,
@@ -59470,6 +59794,7 @@ function featureContext(ctx, reader) {
     docs: docs2,
     moreDocs,
     docsNote: DOCS_NOTE,
+    openDefects: carried.openDefects,
     tickets: listByFeature2(ctx, feature.id).map(stripDigest),
     annotatedModels: annotatedModels(ctx)
   };
@@ -59516,9 +59841,16 @@ function toolResolveWaypoint(ctx, session, input) {
     frontierIds: after3.map((w) => w.id)
   };
 }
+function refuseMisKindedReview(inputs) {
+  const misKinded = inputs.find((t) => REVIEW_TITLE.test(t.title) && t.kind !== "review");
+  if (!misKinded)
+    return;
+  throw new GateError(`ticket "${misKinded.title}" is titled like a review ticket but its kind is ` + `"${misKinded.kind ?? "implementation"}" \u2014 set kind: "review" if it is the batch-closing ` + "review (almost certainly), or retitle it if it genuinely is an implementation ticket. " + "Nothing was stored; fix it and re-emit the batch.");
+}
 function toolEmitTickets(ctx, session, input) {
   const feature = getFeatureRow(ctx, requireFeatureId(session));
   refuseIfReadOnly(session, "emitting tickets");
+  refuseMisKindedReview(input.tickets);
   const stored = storeTickets(ctx, feature.id, input.tickets);
   return {
     stored: stored.length,
@@ -59580,14 +59912,26 @@ function toolCompletePhase(ctx, session, input) {
     message: `session marked phase '${input.phase}' complete`,
     data: { phase: input.phase, currentPhase: feature.phase }
   });
+  if (input.phase === "tickets" && isPastPhase(feature, "tickets")) {
+    return {
+      ok: true,
+      nextPhase: feature.phase,
+      note: "tickets phase already crossed \u2014 the burn has started; nothing left to complete"
+    };
+  }
   const gate = nextGate(feature);
   if (gate?.id === "G3") {
+    const result = checkGate(ctx, gate.check, feature);
+    if (!result.satisfied) {
+      const failed = requirement(gate);
+      return {
+        ok: false,
+        reason: result.reason ?? `gate ${gate.id} not satisfied`,
+        ...failed ? { gate: failed } : {}
+      };
+    }
     const next4 = nextPhase(feature) ?? "implementation";
-    emit(ctx, feature.id, {
-      type: "tickets.awaiting_burn",
-      message: "tickets complete \u2014 waiting on the human Burn click (gate G3)",
-      data: { phase: feature.phase, nextPhase: next4, waitingOn: "human burn" }
-    });
+    markTicketsReady(ctx, feature.id, next4);
     const after3 = requirement(nextGate({ ...feature, phase: next4 }));
     return {
       ok: true,
@@ -60235,7 +60579,7 @@ function buildMcpServer(audience) {
   if (wants("complete_phase")) {
     server.registerTool("complete_phase", {
       title: "Complete phase",
-      description: "Mark the named phase complete. Runs the gate check server-side and advances the " + "feature, or returns { ok: false, reason, gate } naming what the gate wanted. On " + "success it also returns `nextGate` \u2014 what the FOLLOWING gate requires \u2014 so the next " + 'step is not a guess. The tickets \u2192 implementation gate (G3) is the human "Burn" ' + "approval: completing the tickets phase records the work done and returns " + '{ ok: true, nextPhase: "implementation", waitingOn: "human burn" } WITHOUT advancing.',
+      description: "Mark the named phase complete. Runs the gate check server-side and advances the " + "feature, or returns { ok: false, reason, gate } naming what the gate wanted. On " + "success it also returns `nextGate` \u2014 what the FOLLOWING gate requires \u2014 so the next " + 'step is not a guess. The tickets \u2192 implementation gate (G3) is the human "Burn" ' + "approval: completing the tickets phase records the work done and returns " + '{ ok: true, nextPhase: "implementation", waitingOn: "human burn" } WITHOUT advancing. ' + "That call is also what ARMS the Burn click \u2014 until it lands, the button waits on you " + "rather than burning tickets you are still writing, so make it the last thing you do " + "in the tickets phase. If the human burned while you were closing out, it comes back " + "{ ok: true, note } saying the phase was already crossed: nothing left to do.",
       inputSchema: {
         phase: CompletablePhase.describe("The phase you are finishing \u2014 normally the feature\u2019s current one. `shipped` is not " + "completable by any session: a feature ships when the human merges it.")
       }
@@ -60262,7 +60606,7 @@ async function resolveAudience(sessionId, runId) {
     return;
   }
 }
-var DOCS_NOTE, DRAFTING_KINDS, ADRS_NOTE, FEATURE_KINDS, FEATURE_WRITE_KINDS, PROJECT_KINDS, ALL_AUDIENCES, TOOL_AUDIENCES, CompletablePhase, EventType, mcp, server_default;
+var DOCS_NOTE, REVIEW_TITLE, DRAFTING_KINDS, ADRS_NOTE, FEATURE_KINDS, FEATURE_WRITE_KINDS, PROJECT_KINDS, ALL_AUDIENCES, TOOL_AUDIENCES, CompletablePhase, EventType, mcp, server_default;
 var init_server = __esm(() => {
   init_src();
   init_paths();
@@ -60270,8 +60614,10 @@ var init_server = __esm(() => {
   init_artifacts();
   init_sessions();
   init_features();
+  init_carried_work();
   init_events();
   init_findings();
+  init_gates();
   init_review_findings();
   init_git();
   init_knowledge();
@@ -60280,6 +60626,7 @@ var init_server = __esm(() => {
   init_tickets();
   init_waypoints();
   DOCS_NOTE = "docs[] holds this feature\u2019s canonical docs in full. moreDocs[] is everything else that " + "exists in docs/features/<slug>/ \u2014 not inlined, not gone: read any of them with " + "read_feature_doc({ relPath }). A `withheld` reason means it was left out on purpose; fetch " + "it anyway if a ticket points at it.";
+  REVIEW_TITLE = /^review[: ]/i;
   DRAFTING_KINDS = ["ideation", "revisit", "waypoint", "converge"];
   ADRS_NOTE = "adrs[] is an index of the project\u2019s LIVE decisions (superseded ones are already omitted), not " + "their text. Read the ones your work touches with read_adr({ relPath }) \u2014 they bind you the " + "same either way. They are also plain files in this worktree at docs/adr/.";
   FEATURE_KINDS = [
@@ -60403,7 +60750,7 @@ var init_ws = __esm(() => {
 });
 
 // src/services/prep.ts
-import { and as and10, desc as desc6, eq as eq13, inArray as inArray5 } from "drizzle-orm";
+import { and as and11, desc as desc6, eq as eq14, inArray as inArray5 } from "drizzle-orm";
 function keysToPrepare(ctx, project3) {
   return unsetPreparedKeys(project3).filter((key) => isOverwritable(ctx, project3.id, key));
 }
@@ -60413,10 +60760,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(and10(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(and11(eq14(sessions.projectId, projectId), eq14(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(and10(eq13(events.projectId, projectId), inArray5(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(and11(eq14(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))
@@ -61174,7 +61521,7 @@ var init_events2 = __esm(() => {
 // src/launcher/launcher.ts
 import { existsSync as existsSync23 } from "fs";
 import { join as join23 } from "path";
-import { and as and11, eq as eq14 } from "drizzle-orm";
+import { and as and12, eq as eq15 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
   return `terminal exited (code ${label})`;
@@ -61194,7 +61541,7 @@ function renderCommand(runtime5, spec) {
   return [...env, runtime5.binary, ...spec.argv].join(" ");
 }
 function activeRunFor(ctx, featureId) {
-  const row = ctx.db.select().from(runs).where(and11(eq14(runs.featureId, featureId), eq14(runs.status, "running"))).limit(1).get();
+  const row = ctx.db.select().from(runs).where(and12(eq15(runs.featureId, featureId), eq15(runs.status, "running"))).limit(1).get();
   return row ? rowToRun(row) : null;
 }
 function assertSpawnable(ctx, feature, excludeSessionId) {
@@ -61275,6 +61622,7 @@ async function launchSession(ctx, input, opts = {}) {
     worktreePath,
     model
   });
+  const carried = carriedWork(ctx, feature.id);
   const plan = planKickoff({
     kind: input.kind,
     lap: feature.lap,
@@ -61283,7 +61631,8 @@ async function launchSession(ctx, input, opts = {}) {
       lap: feature.lap,
       phase: feature.phase,
       ticketLaps: listByFeature2(ctx, feature.id).map((t2) => t2.lap)
-    })
+    }),
+    carried
   });
   let waypoint;
   let resumeSessionId;
@@ -61380,6 +61729,7 @@ async function launchSession(ctx, input, opts = {}) {
     config: ctx.config,
     waypoint,
     lap: plan.lap,
+    carried: plan.lap === undefined ? undefined : carried,
     purpose: input.purpose,
     worktreePath,
     serverUrl: serverUrlFor(ctx.config),
@@ -61801,6 +62151,7 @@ var init_launcher = __esm(() => {
   init_errors();
   init_end_session();
   init_registry();
+  init_carried_work();
   init_docs_watch();
   init_events();
   init_gates();
@@ -61967,6 +62318,7 @@ var init_feature = __esm(() => {
   init_src();
   init_launcher();
   init_sessions();
+  init_carried_work();
   init_events();
   init_features();
   init_gates();
@@ -62006,7 +62358,7 @@ var init_feature = __esm(() => {
     rethink: publicProcedure.input(z7.object({ featureId: z7.string() })).mutation(({ ctx, input }) => rethinkAndLaunch(ctx, input.featureId, (feature) => launchSession(ctx, {
       featureId: input.featureId,
       kind: "revisit",
-      kickoffLine: lapKickoff(feature.lap)
+      kickoffLine: lapKickoff(feature.lap, carriedWork(ctx, input.featureId))
     }))),
     resendKickoff: publicProcedure.input(z7.object({ sessionId: z7.string() })).mutation(({ ctx, input }) => resendKickoff(ctx, input.sessionId)),
     endSession: publicProcedure.input(z7.object({ sessionId: z7.string() })).mutation(({ ctx, input }) => endSession(ctx, input.sessionId)),
@@ -62397,7 +62749,7 @@ var init_conversations = __esm(() => {
 // src/services/projects.ts
 import { existsSync as existsSync25 } from "fs";
 import { basename as basename4, join as join27 } from "path";
-import { eq as eq15, isNull } from "drizzle-orm";
+import { eq as eq16, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
 }
@@ -62418,7 +62770,7 @@ async function openProject(ctx, rawPath) {
   const name = basename4(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
-    ctx.db.update(projects).set({ repoPath, closedAt: null }).where(eq15(projects.id, existing.id)).run();
+    ctx.db.update(projects).set({ repoPath, closedAt: null }).where(eq16(projects.id, existing.id)).run();
     const reopened = { ...existing, repoPath, closedAt: undefined };
     emitProject(ctx, existing.id, {
       type: "project.opened",
@@ -62448,7 +62800,7 @@ function closeProject(ctx, projectId) {
   if (projectHasActiveRun(ctx, projectId)) {
     throw new InvalidInputError(`cannot close ${project3.name}: a run is in flight \u2014 wait for it to finish or cancel it first`);
   }
-  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq15(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq16(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.closed",
     message: `project ${project3.name} closed`
@@ -62457,7 +62809,7 @@ function closeProject(ctx, projectId) {
 }
 function renameProject(ctx, projectId, name) {
   const project3 = requireProjectById(ctx, projectId);
-  ctx.db.update(projects).set({ name }).where(eq15(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ name }).where(eq16(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.renamed",
     message: `project renamed ${project3.name} \u2192 ${name}`,
@@ -62549,9 +62901,9 @@ 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";
+import { and as and13, asc as asc6, eq as eq17, 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 rows = ctx.db.select({ ticketId: events.ticketId }).from(events).where(and13(eq17(events.runId, runId), isNotNull3(events.ticketId))).orderBy(asc6(events.id)).all();
   const seen = new Set;
   for (const row of rows)
     if (row.ticketId)
@@ -62559,7 +62911,7 @@ function runTicketIds(ctx, runId) {
   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();
+  const row = ctx.db.select({ lap: events.lap }).from(events).where(eq17(events.runId, runId)).orderBy(asc6(events.id)).limit(1).get();
   return row?.lap ?? 1;
 }
 function listRunSummaries(ctx, featureId) {
@@ -62587,6 +62939,7 @@ import * as z10 from "zod";
 var runRouter;
 var init_run = __esm(() => {
   init_agent_stream();
+  init_events();
   init_repo();
   init_runs();
   init_runner();
@@ -62595,10 +62948,17 @@ var init_run = __esm(() => {
     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);
-      cancelRun(input.runId);
-      return { ok: true };
+    cancel: publicProcedure.input(z10.object({ runId: z10.string() })).mutation(async ({ ctx, input }) => {
+      const run7 = getRunRow(ctx, input.runId);
+      const { confirmed } = await cancelRun(input.runId);
+      if (!confirmed) {
+        emit(ctx, run7.featureId, {
+          type: "run.cancel_timeout",
+          message: "cancel timed out \u2014 an agent of this run may still be running",
+          runId: run7.id
+        });
+      }
+      return { ok: true, confirmed };
     })
   });
 });
@@ -62776,8 +63136,17 @@ var init_test_notes2 = __esm(() => {
 
 // src/trpc/routers/ticket.ts
 import * as z15 from "zod";
+function noteStopTimeout(ctx, ticketId) {
+  const ticket = getTicket(ctx, ticketId);
+  emit(ctx, ticket.featureId, {
+    type: "ticket.stop_timeout",
+    message: `ticket #${ticket.seq}: stop timed out \u2014 the process may still be running`,
+    ticketId: ticket.id
+  });
+}
 var ticketRouter;
 var init_ticket = __esm(() => {
+  init_events();
   init_features();
   init_repo();
   init_tickets();
@@ -62785,17 +63154,27 @@ var init_ticket = __esm(() => {
   init_context();
   ticketRouter = router({
     retry: publicProcedure.input(z15.object({ ticketId: z15.string(), fresh: z15.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
-    stop: publicProcedure.input(z15.object({ ticketId: z15.string() })).mutation(({ ctx, input }) => {
-      if (stopTicketRun(input.ticketId))
-        return { stopped: true, swept: false };
+    stop: publicProcedure.input(z15.object({ ticketId: z15.string() })).mutation(async ({ ctx, input }) => {
+      const { stopped, confirmed } = await stopTicketRun(input.ticketId);
+      if (stopped) {
+        if (!confirmed)
+          noteStopTimeout(ctx, input.ticketId);
+        return { stopped: true, swept: false, confirmed };
+      }
       const ticket = getTicket(ctx, input.ticketId);
       if (ticket.status === "burning" && !hasActiveRun(ctx, ticket.featureId)) {
         sweepOrphanedBurning(ctx, ticket.featureId, "orphaned \u2014 the run that was burning it is gone");
-        return { stopped: false, swept: true };
+        return { stopped: false, swept: true, confirmed };
       }
-      return { stopped: false, swept: false };
+      return { stopped: false, swept: false, confirmed };
+    }),
+    cancel: publicProcedure.input(z15.object({ ticketId: z15.string(), reason: z15.string().optional() })).mutation(async ({ ctx, input }) => {
+      const { stopped, confirmed } = await stopTicketRun(input.ticketId);
+      if (stopped && !confirmed)
+        noteStopTimeout(ctx, input.ticketId);
+      const ticket = cancelTicket(ctx, input.ticketId, input.reason, { agentStopped: stopped });
+      return { ticket, stopped, confirmed };
     }),
-    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(),
@@ -62842,14 +63221,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq17(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq18(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(eq17(runs.id, run7.id)).run();
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq18(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)) {