runcastle 1.1.1 → 1.2.1

package/index.js

@@ -107,7 +107,7 @@ function resolvePreparedSettings(config, project) {
   };
 }
 function resolveModel(step, config, project, runOverride) {
-  return runOverride ?? config.stepModels[step] ?? project?.model ?? config.model;
+  return runOverride ?? project?.model ?? config.stepModels[step] ?? config.model;
 }
 var MODEL_STEPS, ModelStep, DEFAULT_SMOKE_MODEL = "claude-haiku-4-5", foldLegacyModelConfig = (raw) => {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw))
@@ -245,7 +245,7 @@ var init_ids = () => {};
 
 // ../core/src/schemas.ts
 import * as z2 from "zod";
-var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, PREPARED_KEYS, PreparedKey, FindingSource, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
 var init_schemas = __esm(() => {
   Phase = z2.enum([
     "ideation",
@@ -307,6 +307,17 @@ var init_schemas = __esm(() => {
     lastSessionId: z2.string().optional(),
     summary: z2.string().optional()
   });
+  TestNoteStatus = z2.enum(["open", "done", "promoted"]);
+  TestNote = z2.object({
+    id: z2.string(),
+    featureId: z2.string(),
+    lap: z2.number(),
+    text: z2.string(),
+    status: TestNoteStatus,
+    ticketId: z2.string().optional(),
+    createdAt: z2.number(),
+    updatedAt: z2.number()
+  });
   PREPARED_KEYS = [
     "setupCommand",
     "verifyCommands",
@@ -318,7 +329,14 @@ var init_schemas = __esm(() => {
     "dbResetCommand"
   ];
   PreparedKey = z2.enum(PREPARED_KEYS);
+  DRIVE_LOOP_KEYS = [
+    "devCommand",
+    "driveSetupCommand",
+    "driveStopCommand",
+    "driveEnv"
+  ];
   FindingSource = z2.enum(["prep", "human", "session"]);
+  ProjectName = z2.string().min(1, "a project needs a name").max(PROJECT_NAME_MAX, `a project name can be at most ${PROJECT_NAME_MAX} characters`);
   Project = z2.object({
     id: z2.string(),
     name: z2.string(),
@@ -340,7 +358,9 @@ var init_schemas = __esm(() => {
     evidence: z2.string().optional(),
     establishedAt: z2.number(),
     establishedSha: z2.string().optional(),
-    staleCommits: z2.number().optional()
+    staleCommits: z2.number().optional(),
+    verifiedAt: z2.number().optional(),
+    verifiedSha: z2.string().optional()
   });
   Feature = z2.object({
     id: z2.string(),
@@ -364,6 +384,7 @@ var init_schemas = __esm(() => {
     ccSessionId: z2.string().optional(),
     transcriptPath: z2.string().optional(),
     status: SessionStatus,
+    awaitingInput: z2.boolean(),
     worktreePath: z2.string()
   });
   Run = z2.object({
@@ -477,6 +498,12 @@ function nextPhase(feature) {
     return null;
   return ORDER[i + 1];
 }
+function previousPhase(feature) {
+  const i = ORDER.indexOf(feature.phase);
+  if (i <= 0)
+    return null;
+  return ORDER[i - 1];
+}
 function nextGate(feature) {
   const i = ORDER.indexOf(feature.phase);
   if (i < 0 || i >= ORDER.length - 1)
@@ -543,7 +570,7 @@ var init_pipeline = __esm(() => {
 
 // ../core/src/db-schema.ts
 import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var projects, projectFindings, features, sessions, tickets, waypoints, runs, events, gateOverrides;
+var projects, projectFindings, features, sessions, tickets, testNotes, waypoints, runs, events, gateOverrides;
 var init_db_schema = __esm(() => {
   projects = sqliteTable("projects", {
     id: text("id").primaryKey(),
@@ -568,7 +595,9 @@ var init_db_schema = __esm(() => {
     source: text("source").notNull().$type(),
     evidence: text("evidence"),
     establishedAt: integer("established_at").notNull(),
-    establishedSha: text("established_sha")
+    establishedSha: text("established_sha"),
+    verifiedAt: integer("verified_at"),
+    verifiedSha: text("verified_sha")
   }, (t) => [primaryKey({ columns: [t.projectId, t.key] })]);
   features = sqliteTable("features", {
     id: text("id").primaryKey(),
@@ -593,6 +622,7 @@ var init_db_schema = __esm(() => {
     ccSessionId: text("cc_session_id"),
     transcriptPath: text("transcript_path"),
     status: text("status").notNull().$type(),
+    awaitingInput: integer("awaiting_input", { mode: "boolean" }).notNull().default(false),
     worktreePath: text("worktree_path").notNull()
   });
   tickets = sqliteTable("tickets", {
@@ -612,6 +642,16 @@ var init_db_schema = __esm(() => {
     attemptBranch: text("attempt_branch"),
     conflictFiles: text("conflict_files", { mode: "json" }).$type()
   });
+  testNotes = sqliteTable("test_notes", {
+    id: text("id").primaryKey(),
+    featureId: text("feature_id").notNull(),
+    lap: integer("lap").notNull(),
+    text: text("text").notNull(),
+    status: text("status").notNull().$type(),
+    ticketId: text("ticket_id"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  });
   waypoints = sqliteTable("waypoints", {
     id: text("id").primaryKey(),
     featureId: text("feature_id").notNull(),
@@ -674,6 +714,7 @@ var init_schema = __esm(() => {
     features,
     sessions,
     tickets,
+    testNotes,
     waypoints,
     runs,
     events,
@@ -1359,7 +1400,7 @@ var init_bus = __esm(() => {
 });
 
 // src/services/events.ts
-import { and, asc, desc, eq, gt } from "drizzle-orm";
+import { and, asc, desc, eq, gt, max } from "drizzle-orm";
 function rowToEvent(row) {
   return {
     id: row.id,
@@ -1389,6 +1430,9 @@ function emit(ctx, featureId, e) {
 function emitProject(ctx, projectId, e) {
   return insertEvent(ctx, projectId, null, e);
 }
+function emitScoped(ctx, scope, e) {
+  return "featureId" in scope ? emit(ctx, scope.featureId, e) : emitProject(ctx, scope.projectId, e);
+}
 function emitForSession(ctx, session, e) {
   if (session.featureId)
     return emit(ctx, session.featureId, e);
@@ -1425,6 +1469,15 @@ function latestEventTs(ctx, featureId, type) {
   const row = ctx.db.select({ ts: events.ts }).from(events).where(and(eq(events.featureId, featureId), eq(events.type, type))).orderBy(desc(events.ts)).limit(1).get();
   return row?.ts;
 }
+function latestTsByFeature(ctx, projectId) {
+  const rows = ctx.db.select({ featureId: events.featureId, ts: max(events.ts) }).from(events).where(eq(events.projectId, projectId)).groupBy(events.featureId).all();
+  const out = new Map;
+  for (const row of rows) {
+    if (row.featureId !== null && row.ts !== null)
+      out.set(row.featureId, row.ts);
+  }
+  return out;
+}
 function listByProject(ctx, projectId, afterId = 0) {
   const rows = ctx.db.select().from(events).where(and(eq(events.projectId, projectId), gt(events.id, afterId))).orderBy(asc(events.id)).all();
   return rows.map(rowToEvent);
@@ -1490,6 +1543,7 @@ function rowToSession(row) {
     ccSessionId: row.ccSessionId ?? undefined,
     transcriptPath: row.transcriptPath ?? undefined,
     status: row.status,
+    awaitingInput: row.awaitingInput,
     worktreePath: row.worktreePath
   };
 }
@@ -1606,7 +1660,7 @@ function storeWaypoints(ctx, featureId, inputs) {
   if (inputs.length === 0)
     return [];
   const existing = listByFeature(ctx, featureId);
-  const startSeq = existing.reduce((max, w) => Math.max(max, w.seq), 0) + 1;
+  const startSeq = existing.reduce((max2, w) => Math.max(max2, w.seq), 0) + 1;
   const seqById = new Map(existing.map((w) => [w.id, w.seq]));
   const positionEdges = inputs.map((inp) => ({
     blockedBy: inp.blockedBy.filter((b) => typeof b === "number")
@@ -1741,8 +1795,8 @@ var init_waypoints = __esm(() => {
 });
 
 // src/pty/dev-pane.ts
-function drivePaneId(featureId) {
-  return `${DRIVE_PREFIX}${featureId}`;
+function drivePaneId(ownerId) {
+  return `${DRIVE_PREFIX}${ownerId}`;
 }
 function sniffDevUrl(text2) {
   const m = text2.match(/https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/[^\s"'<>`\x1b]*)?/i);
@@ -1755,8 +1809,8 @@ function devSpawnTarget(devCommand) {
   return { file: "/bin/sh", args: ["-c", devCommand] };
 }
 function startDevPane(input) {
-  const { ctx, featureId, repoPath, devCommand, env, onUrl } = input;
-  const paneId = drivePaneId(featureId);
+  const { ctx, scope, repoPath, devCommand, env, onUrl } = input;
+  const paneId = drivePaneId("featureId" in scope ? scope.featureId : scope.projectId);
   const { file, args } = devSpawnTarget(devCommand);
   try {
     ptyRegistry().create({
@@ -1766,7 +1820,7 @@ function startDevPane(input) {
       opts: { cwd: repoPath, env: env ?? process.env, cols: 80, rows: 24, useConpty: true }
     });
   } catch (err) {
-    emit(ctx, featureId, {
+    emitScoped(ctx, scope, {
       type: "testdrive.dev_failed",
       message: `dev server failed to start: ${err instanceof Error ? err.message : String(err)}`,
       data: { paneId }
@@ -1789,13 +1843,17 @@ function startDevPane(input) {
     sendControl() {}
   };
   ptyRegistry().attach(paneId, sniffer);
-  emit(ctx, featureId, {
+  emitScoped(ctx, scope, {
     type: "testdrive.dev_started",
     message: `dev server spawned: ${devCommand}`,
     data: { paneId }
   });
   return paneId;
 }
+function devPaneLive(paneId) {
+  const entry = ptyRegistry().get(paneId);
+  return !!entry && !entry.exited;
+}
 function stopDevPane(paneId) {
   const reg = ptyRegistry();
   const entry = reg.get(paneId);
@@ -1815,13 +1873,13 @@ var init_dev_pane = __esm(() => {
 
 // src/services/drive-hooks.ts
 import { spawn as spawn2 } from "child_process";
-function tailLines(text2, max = OUTPUT_TAIL_LINES) {
+function tailLines(text2, max2 = OUTPUT_TAIL_LINES) {
   const lines = text2.replace(/\r\n/g, `
 `).split(`
 `);
   while (lines.length > 0 && lines[lines.length - 1]?.trim() === "")
     lines.pop();
-  return lines.slice(-max).join(`
+  return lines.slice(-max2).join(`
 `).trim();
 }
 function hookSpawnTarget(command) {
@@ -1910,13 +1968,13 @@ var init_drive_hooks = __esm(() => {
 
 // src/services/drive-env.ts
 import { createHash } from "crypto";
-function identifierSafe(slug, max = MAX_ID_LENGTH) {
+function identifierSafe(slug, max2 = MAX_ID_LENGTH) {
   const cleaned = slug.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   const safe = cleaned === "" || /^[0-9]/.test(cleaned) ? `x_${cleaned}` : cleaned;
-  if (safe.length <= max)
+  if (safe.length <= max2)
     return safe;
   const digest = createHash("sha1").update(slug).digest("hex").slice(0, 6);
-  return `${safe.slice(0, max - digest.length - 1)}_${digest}`;
+  return `${safe.slice(0, max2 - digest.length - 1)}_${digest}`;
 }
 function driveVars(identity) {
   return {
@@ -1982,6 +2040,144 @@ var init_drive_env = __esm(() => {
   PLACEHOLDER_RE = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
 });
 
+// src/services/findings.ts
+import { and as and4, eq as eq4 } from "drizzle-orm";
+function isPreparedKey(key) {
+  return PREPARED_SET.has(key);
+}
+function findingRow(ctx, projectId, key) {
+  return ctx.db.select({
+    source: projectFindings.source,
+    evidence: projectFindings.evidence,
+    establishedAt: projectFindings.establishedAt,
+    establishedSha: projectFindings.establishedSha
+  }).from(projectFindings).where(and4(eq4(projectFindings.projectId, projectId), eq4(projectFindings.key, key))).get();
+}
+function isOverwritable(ctx, projectId, key) {
+  return findingRow(ctx, projectId, key)?.source !== "human";
+}
+function recordFinding(ctx, projectId, input) {
+  const { key, value, source, evidence, establishedSha } = input;
+  ctx.db.transaction((tx) => {
+    tx.update(projects).set({ [COLUMN_NAME[key]]: value }).where(eq4(projects.id, projectId)).run();
+    if (value === null) {
+      tx.delete(projectFindings).where(and4(eq4(projectFindings.projectId, projectId), eq4(projectFindings.key, key))).run();
+      return;
+    }
+    tx.insert(projectFindings).values({
+      projectId,
+      key,
+      source,
+      evidence: evidence ?? null,
+      establishedAt: Date.now(),
+      establishedSha: establishedSha ?? null,
+      ...UNVERIFIED
+    }).onConflictDoUpdate({
+      target: [projectFindings.projectId, projectFindings.key],
+      set: {
+        source,
+        evidence: evidence ?? null,
+        establishedAt: Date.now(),
+        establishedSha: establishedSha ?? null,
+        ...UNVERIFIED
+      }
+    }).run();
+  });
+}
+function recordHuman(ctx, projectId, key, value) {
+  if (!isPreparedKey(key))
+    return;
+  const existing = findingRow(ctx, projectId, key);
+  if (value === null) {
+    if (existing) {
+      ctx.db.delete(projectFindings).where(and4(eq4(projectFindings.projectId, projectId), eq4(projectFindings.key, key))).run();
+    }
+    return;
+  }
+  ctx.db.insert(projectFindings).values({
+    projectId,
+    key,
+    source: "human",
+    evidence: null,
+    establishedAt: Date.now(),
+    establishedSha: null,
+    ...UNVERIFIED
+  }).onConflictDoUpdate({
+    target: [projectFindings.projectId, projectFindings.key],
+    set: {
+      source: "human",
+      evidence: null,
+      establishedAt: Date.now(),
+      establishedSha: null,
+      ...UNVERIFIED
+    }
+  }).run();
+}
+function markVerified(ctx, projectId, keys, sha) {
+  const verifiedAt = Date.now();
+  for (const key of keys) {
+    ctx.db.update(projectFindings).set({ verifiedAt, verifiedSha: sha }).where(and4(eq4(projectFindings.projectId, projectId), eq4(projectFindings.key, key))).run();
+  }
+}
+async function listFindings(ctx, project) {
+  const rows = ctx.db.select().from(projectFindings).where(eq4(projectFindings.projectId, project.id)).all();
+  const distances = new Map;
+  for (const row of rows) {
+    const sha = row.establishedSha;
+    if (!sha || distances.has(sha))
+      continue;
+    distances.set(sha, await commitsSince(project.repoPath, sha, project.mainBranch));
+  }
+  const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
+  return rows.filter((row) => isPreparedKey(row.key)).sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0)).map((row) => {
+    const staleCommits = row.establishedSha ? distances.get(row.establishedSha) : undefined;
+    return {
+      key: row.key,
+      source: row.source,
+      ...row.evidence ? { evidence: row.evidence } : {},
+      establishedAt: row.establishedAt,
+      ...row.establishedSha ? { establishedSha: row.establishedSha } : {},
+      ...staleCommits !== undefined ? { staleCommits } : {},
+      ...row.verifiedAt !== null ? { verifiedAt: row.verifiedAt } : {},
+      ...row.verifiedSha ? { verifiedSha: row.verifiedSha } : {}
+    };
+  });
+}
+function unsetPreparedKeys(project) {
+  return PREPARED_KEYS.filter((key) => {
+    const value = project[key];
+    return value === undefined || value.trim() === "";
+  });
+}
+var VALUE_COLUMN, COLUMN_NAME, PREPARED_SET, UNVERIFIED;
+var init_findings = __esm(() => {
+  init_src();
+  init_schema();
+  init_git();
+  VALUE_COLUMN = {
+    setupCommand: projects.setupCommand,
+    verifyCommands: projects.verifyCommands,
+    knownFailures: projects.knownFailures,
+    devCommand: projects.devCommand,
+    driveSetupCommand: projects.driveSetupCommand,
+    driveStopCommand: projects.driveStopCommand,
+    driveEnv: projects.driveEnv,
+    dbResetCommand: projects.dbResetCommand
+  };
+  COLUMN_NAME = {
+    setupCommand: "setupCommand",
+    verifyCommands: "verifyCommands",
+    knownFailures: "knownFailures",
+    devCommand: "devCommand",
+    driveSetupCommand: "driveSetupCommand",
+    driveStopCommand: "driveStopCommand",
+    driveEnv: "driveEnv",
+    dbResetCommand: "dbResetCommand"
+  };
+  PREPARED_SET = new Set(PREPARED_KEYS);
+  UNVERIFIED = { verifiedAt: null, verifiedSha: null };
+});
+
 // src/services/git.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, mkdtempSync, realpathSync, rmSync } from "fs";
 import { tmpdir } from "os";
@@ -1993,6 +2189,9 @@ function migrationPaths(paths) {
 function featureBranch(slug) {
   return `feature/${slug}`;
 }
+function mergeTarget(project, feature) {
+  return feature.baseBranch ?? project.mainBranch;
+}
 function git(repoPath) {
   return simpleGit(repoPath);
 }
@@ -2096,6 +2295,10 @@ async function ensureTalkWorktree(project, feature) {
   await ensureBranchExists(g, branch, feature.baseBranch ?? project.mainBranch);
   if (await worktreeIsValid(g, worktreePath, branch))
     return worktreePath;
+  if (existsSync5(worktreePath) && (await registeredWorktrees(g)).has(canon(worktreePath))) {
+    if (await checkoutInWorktree(worktreePath, branch))
+      return worktreePath;
+  }
   return addWorktree(g, worktreePath, branch, "talk worktree");
 }
 async function addWorktree(g, worktreePath, branch, label) {
@@ -2269,6 +2472,25 @@ async function branchCommitsAhead(repoPath, base, branch) {
     return [];
   }
 }
+async function reviewCommitCount(project, feature) {
+  const base = mergeTarget(project, feature);
+  const branch = featureBranch(feature.slug);
+  try {
+    const out = (await git(project.repoPath).raw(["rev-list", "--count", `${base}..${branch}`])).trim();
+    const n = Number(out);
+    return { base, count: Number.isInteger(n) && n >= 0 ? n : undefined };
+  } catch {
+    return { base };
+  }
+}
+async function headSha(repoPath, ref) {
+  try {
+    const out = (await git(repoPath).revparse([ref])).trim();
+    return out.length > 0 ? out : undefined;
+  } catch {
+    return;
+  }
+}
 async function commitsSince(repoPath, sha, branch) {
   try {
     const out = (await git(repoPath).raw(["rev-list", "--count", `${sha}..${branch}`])).trim();
@@ -2534,20 +2756,23 @@ async function commitDocs(worktreePath, message) {
   await g.commit(message, [DOCS_PATHSPEC]);
 }
 function activeTestDriveFeatureId() {
-  return testDriveState?.featureId;
+  return testDriveState?.kind === "feature" ? testDriveState.featureId : undefined;
 }
 function activeDriveInfo() {
   if (!testDriveState)
     return null;
   return {
-    featureId: testDriveState.featureId,
+    ...testDriveState.kind === "feature" ? { featureId: testDriveState.featureId } : { dryRun: true },
     branch: testDriveState.branch,
     devPaneId: testDriveState.devPaneId,
-    devUrl: testDriveState.devUrl
+    devUrl: testDriveState.devUrl,
+    devConfigured: testDriveState.devConfigured
   };
 }
 function recordDriveUrl(ctx, featureId, url) {
-  if (!testDriveState || testDriveState.featureId !== featureId || testDriveState.devUrl)
+  if (testDriveState?.kind !== "feature")
+    return;
+  if (testDriveState.featureId !== featureId || testDriveState.devUrl)
     return;
   testDriveState.devUrl = url;
   emit(ctx, featureId, {
@@ -2559,15 +2784,18 @@ function recordDriveUrl(ctx, featureId, url) {
 async function testDrive(ctx, project, feature, action) {
   const g = git(project.repoPath);
   const branch = featureBranch(feature.slug);
+  const scope = { featureId: feature.id };
   if (action === "stop") {
     if (!testDriveState)
       return { ok: false, deniedReason: DENY_NONE_ACTIVE };
+    if (testDriveState.kind !== "feature")
+      return { ok: false, deniedReason: DENY_DRY_RUN_ACTIVE };
     const previousBranch2 = testDriveState.previousBranch;
     const detachedWorktree2 = testDriveState.detachedWorktree;
     const devPaneId = testDriveState.devPaneId;
     if (devPaneId)
       stopDevPane(devPaneId);
-    const teardownFailure = await runDriveHookStep(ctx, feature.id, project.repoPath, "teardown", project.driveStopCommand, driveEnvFor(ctx, project, feature, branch));
+    const teardown = await runDriveHookStep(ctx, scope, project.repoPath, "teardown", project.driveStopCommand, driveEnvFor(ctx, project, { slug: feature.slug, branch }, scope).env);
     const carriedChanges = await dirtyPaths(g);
     await g.checkout(previousBranch2);
     if (detachedWorktree2)
@@ -2591,14 +2819,18 @@ async function testDrive(ctx, project, feature, action) {
       branch: previousBranch2,
       ...carriedChanges.length > 0 ? { carriedChanges } : {},
       ...dbDrift ? { dbDrift } : {},
-      ...teardownFailure ? { hookFailure: teardownFailure } : {}
+      ...teardown?.failure ? { hookFailure: teardown.failure } : {}
     };
   }
   const porcelain = (await g.raw(["status", "--porcelain"])).trim();
   if (porcelain !== "")
     return { ok: false, deniedReason: DENY_DIRTY };
-  if (testDriveState)
-    return { ok: false, deniedReason: DENY_ACTIVE };
+  if (testDriveState) {
+    return {
+      ok: false,
+      deniedReason: testDriveState.kind === "dryRun" ? DENY_DRY_RUN_ACTIVE : DENY_ACTIVE
+    };
+  }
   if (hasActiveRun(ctx, feature.id))
     return { ok: false, deniedReason: DENY_ACTIVE_RUN };
   const talkWorktree = worktreeDir(project.id, feature.slug);
@@ -2610,18 +2842,25 @@ async function testDrive(ctx, project, feature, action) {
   }
   const previousBranch = (await g.revparse(["--abbrev-ref", "HEAD"])).trim();
   await g.checkout(branch);
-  testDriveState = { featureId: feature.id, branch, previousBranch, detachedWorktree };
+  testDriveState = {
+    kind: "feature",
+    featureId: feature.id,
+    branch,
+    previousBranch,
+    detachedWorktree,
+    devConfigured: !!project.devCommand
+  };
   emit(ctx, feature.id, {
     type: "testdrive.started",
     message: `test driving ${branch} (was on ${previousBranch})`,
     data: { branch, previousBranch }
   });
-  const driveEnv = driveEnvFor(ctx, project, feature, branch);
-  const setupFailure = await runDriveHookStep(ctx, feature.id, project.repoPath, "setup", project.driveSetupCommand, driveEnv);
+  const driveEnv = driveEnvFor(ctx, project, { slug: feature.slug, branch }, scope).env;
+  const setup = await runDriveHookStep(ctx, scope, project.repoPath, "setup", project.driveSetupCommand, driveEnv);
   if (project.devCommand) {
     const devPaneId = startDevPane({
       ctx,
-      featureId: feature.id,
+      scope,
       repoPath: project.repoPath,
       devCommand: project.devCommand,
       env: driveEnv,
@@ -2630,45 +2869,188 @@ async function testDrive(ctx, project, feature, action) {
     if (devPaneId)
       testDriveState.devPaneId = devPaneId;
   }
-  return { ok: true, branch, ...setupFailure ? { hookFailure: setupFailure } : {} };
+  return { ok: true, branch, ...setup?.failure ? { hookFailure: setup.failure } : {} };
+}
+async function dryRunDrive(ctx, project, action) {
+  if (action === "start")
+    return startDryRun(ctx, project);
+  if (testDriveState?.kind !== "dryRun") {
+    return { ok: false, action, deniedReason: DENY_NO_DRY_RUN };
+  }
+  const state = testDriveState;
+  if (action === "status")
+    return { ok: true, action, ...liveFields(state) };
+  return stopDryRun(ctx, project, state);
+}
+async function startDryRun(ctx, project) {
+  if (testDriveState) {
+    return {
+      ok: false,
+      action: "start",
+      deniedReason: testDriveState.kind === "dryRun" ? DENY_DRY_RUN_ACTIVE : DENY_ACTIVE
+    };
+  }
+  const scope = { projectId: project.id };
+  const branch = (await git(project.repoPath).revparse(["--abbrev-ref", "HEAD"])).trim();
+  const identity = { slug: DRY_RUN_SLUG, branch };
+  emitProject(ctx, project.id, {
+    type: "prep.dryrun.started",
+    message: `preparation dry-run drive on ${branch} as \`${DRY_RUN_SLUG}\``,
+    data: { branch, slug: DRY_RUN_SLUG }
+  });
+  const { env, keys, unknown: unknown2 } = driveEnvFor(ctx, project, identity, scope);
+  const state = {
+    kind: "dryRun",
+    projectId: project.id,
+    branch,
+    devConfigured: !!project.devCommand,
+    env,
+    observed: { envUnknowns: unknown2 }
+  };
+  testDriveState = state;
+  const setup = await runDriveHookStep(ctx, scope, project.repoPath, "setup", project.driveSetupCommand, env);
+  state.observed.setupOk = setup?.result.ok;
+  if (project.devCommand) {
+    const devPaneId = startDevPane({
+      ctx,
+      scope,
+      repoPath: project.repoPath,
+      devCommand: project.devCommand,
+      env,
+      onUrl: (url) => recordDryRunUrl(ctx, project.id, url)
+    });
+    if (devPaneId)
+      state.devPaneId = devPaneId;
+  }
+  return {
+    ok: true,
+    action: "start",
+    envKeys: keys,
+    envUnknowns: unknown2,
+    ...setup ? { setup: hookReport(setup) } : {},
+    ...liveFields(state)
+  };
+}
+async function stopDryRun(ctx, project, state) {
+  const scope = { projectId: project.id };
+  if (state.devPaneId)
+    stopDevPane(state.devPaneId);
+  const teardown = await runDriveHookStep(ctx, scope, project.repoPath, "teardown", project.driveStopCommand, state.env);
+  state.observed.teardownOk = teardown?.result.ok;
+  testDriveState = undefined;
+  emitProject(ctx, project.id, {
+    type: "prep.dryrun.stopped",
+    message: `preparation dry-run drive stopped on ${state.branch}`,
+    data: { branch: state.branch }
+  });
+  const { participating, failure } = dryRunVerdict(project, state);
+  if (!failure && participating.length > 0) {
+    const sha = await headSha(project.repoPath, project.mainBranch) ?? null;
+    markVerified(ctx, project.id, participating, sha);
+    emitProject(ctx, project.id, {
+      type: "prep.dryrun.verified",
+      message: `dry-run drive verified ${participating.join(", ")}`,
+      data: { keys: participating, sha }
+    });
+  }
+  return {
+    ok: true,
+    action: "stop",
+    identity: { slug: DRY_RUN_SLUG, branch: state.branch },
+    envUnknowns: state.observed.envUnknowns,
+    ...teardown ? { teardown: hookReport(teardown) } : {},
+    verified: failure ? [] : participating,
+    ...failure ? { failure } : {}
+  };
+}
+function recordDryRunUrl(ctx, projectId, url) {
+  if (testDriveState?.kind !== "dryRun")
+    return;
+  if (testDriveState.projectId !== projectId || testDriveState.devUrl)
+    return;
+  testDriveState.devUrl = url;
+  emitProject(ctx, projectId, {
+    type: "prep.dryrun.url",
+    message: `dry-run dev server ready at ${url}`,
+    data: { url }
+  });
+}
+function dryRunVerdict(project, state) {
+  const participating = [];
+  let failure;
+  for (const key of DRIVE_LOOP_KEYS) {
+    if (!project[key]?.trim())
+      continue;
+    participating.push(key);
+    failure ??= observableFailure(key, state);
+  }
+  return { participating, ...failure ? { failure } : {} };
+}
+function observableFailure(key, state) {
+  const { envUnknowns, setupOk, teardownOk } = state.observed;
+  switch (key) {
+    case "driveEnv":
+      return envUnknowns.length === 0 ? undefined : `driveEnv left ${envUnknowns.map((u) => `{{${u}}}`).join(", ")} unsubstituted`;
+    case "driveSetupCommand":
+      return setupOk ? undefined : "driveSetupCommand did not exit 0";
+    case "devCommand":
+      if (!state.devPaneId)
+        return "devCommand never spawned a dev pane";
+      return state.devUrl ? undefined : 'devCommand spawned but printed no localhost URL \u2014 "Open app" depends on one';
+    case "driveStopCommand":
+      return teardownOk ? undefined : "driveStopCommand did not exit 0";
+  }
+}
+function liveFields(state) {
+  return {
+    identity: { slug: DRY_RUN_SLUG, branch: state.branch },
+    devConfigured: state.devConfigured,
+    devPaneLive: !!state.devPaneId && devPaneLive(state.devPaneId),
+    ...state.devUrl ? { devUrl: state.devUrl } : {}
+  };
 }
-function driveEnvFor(ctx, project, feature, branch) {
-  const { vars, unknown: unknown2 } = parseDriveEnv(project.driveEnv, { slug: feature.slug, branch });
+function hookReport(run) {
+  const { ok, exitCode, timedOut, output } = run.result;
+  return { command: run.command, ok, exitCode, timedOut, output };
+}
+function driveEnvFor(ctx, project, identity, scope) {
+  const { vars, unknown: unknown2 } = parseDriveEnv(project.driveEnv, identity);
   if (unknown2.length > 0) {
-    emit(ctx, feature.id, {
+    emitScoped(ctx, scope, {
       type: "testdrive.env_unknown_placeholder",
       message: `drive environment left ${unknown2.map((u) => `{{${u}}}`).join(", ")} unsubstituted \u2014 known variables are {{slug}}, {{branch}}, {{id}}`,
       data: { unknown: unknown2 }
     });
   }
-  if (Object.keys(vars).length > 0) {
-    emit(ctx, feature.id, {
+  const keys = Object.keys(vars);
+  if (keys.length > 0) {
+    emitScoped(ctx, scope, {
       type: "testdrive.env",
       message: describeDriveEnv(vars),
-      data: { keys: Object.keys(vars) }
+      data: { keys }
     });
   }
-  return driveProcessEnv(vars);
+  return { env: driveProcessEnv(vars), keys, unknown: unknown2 };
 }
-async function runDriveHookStep(ctx, featureId, repoPath, phase, command, env) {
+async function runDriveHookStep(ctx, scope, repoPath, phase, command, env) {
   const cmd = command?.trim();
   if (!cmd)
     return;
-  emit(ctx, featureId, {
+  emitScoped(ctx, scope, {
     type: `testdrive.${phase}_started`,
     message: phase === "setup" ? `preparing environment: \`${cmd}\`` : `tearing down environment: \`${cmd}\``,
     data: { command: cmd }
   });
   const result = await runDriveHook(cmd, { cwd: repoPath, env });
   if (result.ok) {
-    emit(ctx, featureId, {
+    emitScoped(ctx, scope, {
       type: `testdrive.${phase}_ok`,
       message: describeHookResult(cmd, result),
       data: { command: cmd, durationMs: result.durationMs }
     });
-    return;
+    return { command: cmd, result };
   }
-  emit(ctx, featureId, {
+  emitScoped(ctx, scope, {
     type: `testdrive.${phase}_failed`,
     message: `${describeHookResult(cmd, result)}${result.output ? `
 ${result.output}` : ""}`,
@@ -2680,11 +3062,15 @@ ${result.output}` : ""}`,
     }
   });
   return {
-    phase,
     command: cmd,
-    exitCode: result.exitCode,
-    timedOut: result.timedOut,
-    output: result.output
+    result,
+    failure: {
+      phase,
+      command: cmd,
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      output: result.output
+    }
   };
 }
 async function dirtyPaths(g) {
@@ -2717,7 +3103,7 @@ async function detectDbDrift(ctx, project, feature, previousBranch, driveBranch)
   return drift;
 }
 async function mergeFeature(project, feature) {
-  const target = feature.baseBranch ?? project.mainBranch;
+  const target = mergeTarget(project, feature);
   if (testDriveState) {
     throw new GateError("Cannot merge while a test drive is active \u2014 stop it first");
   }
@@ -2771,14 +3157,16 @@ async function mergeInProgress(g) {
     return false;
   }
 }
-var DOCS_PATHSPEC = "docs/features", MIGRATION_DIR_RE, DRIZZLE_SQL_RE, DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", RESEARCH_BRANCH_PREFIX = "runcastle/research/", TICKET_BRANCH_PREFIX = "runcastle/ticket/", PROJECT_BRANCH = "runcastle/project", TEMP_BRANCH_PREFIXES, TEMP_BRANCH_SLUG_MAX = 16, testDriveState;
+var DOCS_PATHSPEC = "docs/features", MIGRATION_DIR_RE, DRIZZLE_SQL_RE, DENY_DIRTY = "Working tree has uncommitted changes \u2014 commit or stash first", DENY_ACTIVE = "A test drive is already active \u2014 stop it first", DENY_ACTIVE_RUN = "Feature has an active run \u2014 wait for it to finish", DENY_NONE_ACTIVE = "No test drive is active", DENY_DRY_RUN_ACTIVE = "A preparation dry-run is in progress \u2014 stop it first", DENY_NO_DRY_RUN = "No preparation dry-run is in progress", RESEARCH_BRANCH_PREFIX = "runcastle/research/", TICKET_BRANCH_PREFIX = "runcastle/ticket/", PROJECT_BRANCH = "runcastle/project", TEMP_BRANCH_PREFIXES, TEMP_BRANCH_SLUG_MAX = 16, testDriveState, DRY_RUN_SLUG = "prep-dry-run";
 var init_git = __esm(() => {
+  init_src();
   init_paths();
   init_errors();
   init_dev_pane();
   init_drive_hooks();
   init_drive_env();
   init_events();
+  init_findings();
   init_repo();
   MIGRATION_DIR_RE = /(^|\/)(migrations|migrate)\//i;
   DRIZZLE_SQL_RE = /(^|\/)drizzle\/.*\.sql$/i;
@@ -2786,7 +3174,7 @@ var init_git = __esm(() => {
 });
 
 // src/launcher/sessions.ts
-import { and as and4, desc as desc3, eq as eq4, inArray, isNotNull, sql as sql2 } from "drizzle-orm";
+import { and as and5, desc as desc3, eq as eq5, inArray, isNotNull, sql as sql2 } from "drizzle-orm";
 function createSessionRow(ctx, input) {
   const row = ctx.db.insert(sessions).values({
     id: newId("sess"),
@@ -2802,11 +3190,20 @@ function createSessionRow(ctx, input) {
   return rowToSession(row);
 }
 function getSessionRow(ctx, id) {
-  const row = ctx.db.select().from(sessions).where(eq4(sessions.id, id)).get();
+  const row = ctx.db.select().from(sessions).where(eq5(sessions.id, id)).get();
   return row ? rowToSession(row) : null;
 }
 function activeSessionsForFeature(ctx, featureId) {
-  return ctx.db.select().from(sessions).where(and4(eq4(sessions.featureId, featureId), inArray(sessions.status, ["launching", "live"]))).all().map(rowToSession);
+  return ctx.db.select().from(sessions).where(and5(eq5(sessions.featureId, featureId), inArray(sessions.status, ["launching", "live"]))).all().map(rowToSession);
+}
+function markAgentWorking(ctx, id) {
+  setAwaitingInput(ctx, id, false);
+}
+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();
 }
 function markSessionLive(ctx, id, input = {}) {
   const existing = getSessionRow(ctx, id);
@@ -2816,7 +3213,7 @@ function markSessionLive(ctx, id, input = {}) {
     status: "live",
     ccSessionId: input.ccSessionId ?? existing.ccSessionId ?? null,
     transcriptPath: input.transcriptPath ?? existing.transcriptPath ?? null
-  }).where(eq4(sessions.id, id)).run();
+  }).where(eq5(sessions.id, id)).run();
   const firstTimeLive = existing.status !== "live";
   if (firstTimeLive) {
     promoteLastSession(ctx, id);
@@ -2830,6 +3227,13 @@ function lapKickoff(lap) {
 function kickoffLineFor(kind, override) {
   return override ?? KICKOFF_LINES[kind];
 }
+function planKickoff(input) {
+  const lapBriefing = input.lap > 1 ? lapKickoff(input.lap) : undefined;
+  const line = input.kickoffLine ?? (input.kind === "ideation" ? lapBriefing : undefined);
+  if (!line)
+    return { explicit: false };
+  return { line, explicit: true, lap: line === lapBriefing ? input.lap : undefined };
+}
 function resumeKickoffLine(kind) {
   return RESUME_KICKOFF_PREFIX + KICKOFF_LINES[kind];
 }
@@ -2885,6 +3289,7 @@ function attemptKickoff(ctx, session, d, delayMs, clearFirst = false) {
       return;
     }
     d.attempts += 1;
+    d.written = true;
     const attempt = d.attempts;
     try {
       if (clearFirst)
@@ -2929,6 +3334,8 @@ function noteKickoffPrompt(ctx, sessionId, prompt) {
   const session = getSessionRow(ctx, sessionId);
   if (!session)
     return;
+  if (!d.written)
+    return;
   if (promptMatchesKickoff(d.line, prompt)) {
     d.confirmed = true;
     d.settled = true;
@@ -2962,6 +3369,7 @@ function resendKickoff(ctx, sessionId) {
     line: kickoffLineFor(session.kind, pendingKickoffOverrides.get(sessionId)),
     attempts: 0,
     confirmed: false,
+    written: false,
     settled: false,
     timers: new Set
   };
@@ -2990,11 +3398,17 @@ function armSessionReadyWatchdog(ctx, session) {
 }
 function scheduleKickoff(ctx, session) {
   const line = kickoffLineFor(session.kind, pendingKickoffOverrides.get(session.id));
-  pendingKickoffOverrides.delete(session.id);
   const existing = deliveries.get(session.id);
   if (existing)
     stopTimers(existing);
-  const d = { line, attempts: 0, confirmed: false, settled: false, timers: new Set };
+  const d = {
+    line,
+    attempts: 0,
+    confirmed: false,
+    written: false,
+    settled: false,
+    timers: new Set
+  };
   deliveries.set(session.id, d);
   attemptKickoff(ctx, session, d, KICKOFF_DELAY_MS);
 }
@@ -3034,26 +3448,26 @@ function markSessionEnded(ctx, id) {
   if (!existing)
     return null;
   forgetKickoff(id);
-  ctx.db.update(sessions).set({ status: "ended" }).where(eq4(sessions.id, id)).run();
+  ctx.db.update(sessions).set({ status: "ended" }).where(eq5(sessions.id, id)).run();
   return getSessionRow(ctx, id);
 }
 function mostRecentResumableSession(ctx, featureId, kind) {
-  const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.featureId, featureId), eq4(sessions.status, "ended"), isNotNull(sessions.ccSessionId), ...kind ? [eq4(sessions.kind, kind)] : [])).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  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();
   return row ? rowToSession(row) : null;
 }
 function activeProjectSession(ctx, projectId, kind) {
-  const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), inArray(sessions.status, ["launching", "live"]))).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  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();
   return row ? rowToSession(row) : null;
 }
 function hasCompletedProjectSession(ctx, projectId, kind) {
-  return ctx.db.select({ id: sessions.id }).from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), eq4(sessions.status, "ended"))).limit(1).get() !== undefined;
+  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;
 }
 function mostRecentResumableProjectSession(ctx, projectId, kind) {
-  const row = ctx.db.select().from(sessions).where(and4(eq4(sessions.projectId, projectId), eq4(sessions.kind, kind), eq4(sessions.status, "ended"), isNotNull(sessions.ccSessionId))).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  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();
   return row ? rowToSession(row) : null;
 }
 function mostRecentLiveSession(ctx) {
-  const row = ctx.db.select().from(sessions).where(eq4(sessions.status, "live")).orderBy(desc3(sql2`rowid`)).limit(1).get();
+  const row = ctx.db.select().from(sessions).where(eq5(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, CONVERGE_KICKOFF_LINE, KICKOFF_LINES, RESUME_KICKOFF_PREFIX, pendingKickoffOverrides, deliveries, MATCH_PREFIX = 40, landedProjectSessions;
@@ -3149,7 +3563,7 @@ var init_feature_docs = __esm(() => {
 });
 
 // src/services/tickets.ts
-import { and as and5, asc as asc3, eq as eq5 } from "drizzle-orm";
+import { and as and6, asc as asc3, eq as eq6 } from "drizzle-orm";
 function rowToTicket(row) {
   return {
     id: row.id,
@@ -3179,14 +3593,14 @@ function resolveBlocking(inputs, startSeq) {
   }
 }
 function listByFeature2(ctx, featureId) {
-  return ctx.db.select().from(tickets).where(eq5(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
+  return ctx.db.select().from(tickets).where(eq6(tickets.featureId, featureId)).orderBy(asc3(tickets.seq)).all().map(rowToTicket);
 }
 function storeTickets(ctx, featureId, inputs) {
   if (inputs.length === 0)
     return [];
   const { lap } = getFeatureRow(ctx, featureId);
-  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq5(tickets.featureId, featureId)).all();
-  const startSeq = existing.reduce((max, r) => Math.max(max, r.seq), 0) + 1;
+  const existing = ctx.db.select({ seq: tickets.seq }).from(tickets).where(eq6(tickets.featureId, featureId)).all();
+  const startSeq = existing.reduce((max2, r) => Math.max(max2, r.seq), 0) + 1;
   const resolved = resolveBlocking(inputs, startSeq);
   const rows = inputs.map((t, i) => ({
     id: newId("tkt"),
@@ -3214,7 +3628,7 @@ function storeTickets(ctx, featureId, inputs) {
   return rows.map(rowToTicket);
 }
 function getTicket(ctx, id) {
-  const row = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  const row = ctx.db.select().from(tickets).where(eq6(tickets.id, id)).get();
   if (!row)
     throw new NotFoundError(`ticket ${id} not found`);
   return rowToTicket(row);
@@ -3241,7 +3655,7 @@ function editTicket(ctx, id, patch) {
   if (Object.keys(set).length === 0) {
     throw new InvalidInputError("nothing to edit \u2014 pass at least one content field");
   }
-  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  ctx.db.update(tickets).set(set).where(eq6(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.edited",
     message: `ticket ${current2.seq} content edited (${Object.keys(set).join(", ")})`,
@@ -3253,7 +3667,7 @@ function editTicket(ctx, id, patch) {
 function cancelTicket(ctx, id, reason) {
   const current2 = getTicket(ctx, id);
   assertMutable(current2, "cancel");
-  ctx.db.update(tickets).set({ status: "cancelled", error: reason?.trim() ? reason.trim() : null }).where(eq5(tickets.id, id)).run();
+  ctx.db.update(tickets).set({ status: "cancelled", error: reason?.trim() ? reason.trim() : null }).where(eq6(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.cancelled",
     message: `ticket ${current2.seq} cancelled${reason?.trim() ? `: ${reason.trim()}` : ""}`,
@@ -3263,7 +3677,7 @@ function cancelTicket(ctx, id, reason) {
   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 orphaned = ctx.db.select().from(tickets).where(and6(eq6(tickets.featureId, featureId), eq6(tickets.status, "burning"))).all().map(rowToTicket);
   for (const t of orphaned) {
     updateTicket(ctx, t.id, { status: "failed", error: reason });
     emit(ctx, featureId, {
@@ -3276,7 +3690,7 @@ function sweepOrphanedBurning(ctx, featureId, reason) {
   return orphaned.map((t) => ({ ...t, status: "failed", error: reason }));
 }
 function updateTicket(ctx, id, patch) {
-  const current2 = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  const current2 = ctx.db.select().from(tickets).where(eq6(tickets.id, id)).get();
   if (!current2)
     throw new NotFoundError(`ticket ${id} not found`);
   const set = {};
@@ -3290,14 +3704,14 @@ function updateTicket(ctx, id, patch) {
     set.attemptBranch = patch.attemptBranch;
   if (patch.conflictFiles !== undefined)
     set.conflictFiles = patch.conflictFiles;
-  ctx.db.update(tickets).set(set).where(eq5(tickets.id, id)).run();
+  ctx.db.update(tickets).set(set).where(eq6(tickets.id, id)).run();
   emit(ctx, current2.featureId, {
     type: "ticket.updated",
     message: `ticket ${current2.seq} \u2192 ${patch.status ?? current2.status}`,
     ticketId: id,
     data: patch
   });
-  const updated = ctx.db.select().from(tickets).where(eq5(tickets.id, id)).get();
+  const updated = ctx.db.select().from(tickets).where(eq6(tickets.id, id)).get();
   return rowToTicket(updated);
 }
 var MUTABLE_STATUSES;
@@ -3312,10 +3726,11 @@ var init_tickets = __esm(() => {
 
 // src/services/gates.ts
 import { existsSync as existsSync7 } from "fs";
+import { and as and7, desc as desc4, eq as eq7, inArray as inArray3 } from "drizzle-orm";
 function checkGate(ctx, check, feature) {
   switch (check) {
     case "decisions-file-exists":
-      return fileGate(ctx, feature, "decisions.md", "run the ideation session to capture decisions first");
+      return docGate(ctx, feature, "decisions.md", "run the ideation session to capture decisions first");
     case "all-waypoints-terminal": {
       const wps = listByFeature(ctx, feature.id);
       if (wps.length === 0) {
@@ -3328,7 +3743,7 @@ function checkGate(ctx, check, feature) {
       };
     }
     case "spec-file-exists":
-      return fileGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
+      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" };
@@ -3362,6 +3777,16 @@ function fileGate(ctx, feature, fileName, reason) {
   const project = projectForFeature(ctx, feature);
   return existsSync7(featureDocPath(project, feature, fileName)) ? { satisfied: true } : { satisfied: false, reason };
 }
+function docGate(ctx, feature, fileName, reason) {
+  const file = fileGate(ctx, feature, fileName, reason);
+  if (!file.satisfied || feature.lap === 1)
+    return file;
+  const worked = ctx.db.select({ id: sessions.id }).from(sessions).where(and7(eq7(sessions.featureId, feature.id), eq7(sessions.lap, feature.lap), inArray3(sessions.kind, [...DOC_WRITING_KINDS]))).all();
+  return worked.length > 0 ? { satisfied: true } : {
+    satisfied: false,
+    reason: `${fileName} is an earlier lap's \u2014 no lap ${feature.lap} session has worked this feature yet; open the lap's session before promoting`
+  };
+}
 function overrideGate(ctx, featureId, gate, reason) {
   const feature = getFeatureRow(ctx, featureId);
   ctx.db.insert(gateOverrides).values({ featureId, gate, reason, ts: Date.now() }).run();
@@ -3375,14 +3800,35 @@ function overrideGate(ctx, featureId, gate, reason) {
     return setPhase(ctx, featureId, next, "phase.advanced", `advanced to ${next} (override)`);
   return feature;
 }
+function undoLastGateOverride(ctx, featureId, gate) {
+  const last = ctx.db.select({ id: gateOverrides.id }).from(gateOverrides).where(and7(eq7(gateOverrides.featureId, featureId), eq7(gateOverrides.gate, gate))).orderBy(desc4(gateOverrides.id)).get();
+  if (!last)
+    return false;
+  ctx.db.delete(gateOverrides).where(eq7(gateOverrides.id, last.id)).run();
+  return true;
+}
+function undoGateOverride(ctx, featureId, gate) {
+  const feature = getFeatureRow(ctx, featureId);
+  const back = previousPhase(feature);
+  if (!back) {
+    throw new GateError(`${feature.phase} is the first phase \u2014 there is nothing to step back to`);
+  }
+  if (!undoLastGateOverride(ctx, featureId, gate)) {
+    throw new GateError(`no ${gate} override is recorded on this feature`);
+  }
+  return setPhase(ctx, featureId, back, "gate.override.undone", `${gate} override undone \u2014 back to ${back}`);
+}
+var DOC_WRITING_KINDS;
 var init_gates = __esm(() => {
   init_src();
   init_schema();
+  init_errors();
   init_events();
   init_feature_docs();
   init_repo();
   init_tickets();
   init_waypoints();
+  DOC_WRITING_KINDS = ["ideation", "revisit", "converge"];
 });
 
 // src/services/knowledge.ts
@@ -3819,13 +4265,13 @@ function parseEnvFile(content) {
     if (line.length === 0 || line.startsWith("#"))
       continue;
     const body = line.startsWith("export ") ? line.slice(7).trim() : line;
-    const eq6 = body.indexOf("=");
-    if (eq6 === -1)
+    const eq8 = body.indexOf("=");
+    if (eq8 === -1)
       continue;
-    const key = body.slice(0, eq6).trim();
+    const key = body.slice(0, eq8).trim();
     if (key.length === 0)
       continue;
-    let value = body.slice(eq6 + 1).trim();
+    let value = body.slice(eq8 + 1).trim();
     if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
       value = value.slice(1, -1);
     }
@@ -5036,7 +5482,7 @@ var init_registry2 = __esm(() => {
 });
 
 // src/workflows/runner.ts
-import { eq as eq6 } from "drizzle-orm";
+import { eq as eq8 } from "drizzle-orm";
 function workflowClaimsFeatureBranch(workflowId) {
   return BRANCH_CLAIMING.has(workflowId);
 }
@@ -5065,7 +5511,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(eq6(runs.id, runId)).run();
+      ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary }).where(eq8(runs.id, runId)).run();
       throw e;
     }
   }
@@ -5130,7 +5576,7 @@ async function executeRun(ctx, runId, featureId, workflow2, runPromise, controll
   } finally {
     controllers.delete(runId);
   }
-  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary }).where(eq6(runs.id, runId)).run();
+  ctx.db.update(runs).set({ status, endedAt: Date.now(), summary }).where(eq8(runs.id, runId)).run();
   releaseForSession(ctx, runId);
   if (workflowClaimsFeatureBranch(workflow2)) {
     sweepOrphanedBurning(ctx, featureId, `orphaned \u2014 the run ended (${status}) while it was burning`);
@@ -5178,7 +5624,7 @@ var init_runner = __esm(() => {
 });
 
 // src/services/features.ts
-import { desc as desc4, eq as eq7 } from "drizzle-orm";
+import { desc as desc5, eq as eq9 } from "drizzle-orm";
 import { rmSync as rmSync2 } from "fs";
 async function createFeature(ctx, input) {
   const project = requireProjectById(ctx, input.projectId);
@@ -5302,7 +5748,8 @@ function getFeatureFull(ctx, id) {
   };
 }
 function list(ctx, projectId) {
-  const rows = ctx.db.select().from(features).where(eq7(features.projectId, projectId)).orderBy(desc4(features.createdAt)).all();
+  const rows = ctx.db.select().from(features).where(eq9(features.projectId, projectId)).orderBy(desc5(features.createdAt)).all();
+  const lastActivity = latestTsByFeature(ctx, projectId);
   return rows.map((row) => {
     const feature = rowToFeature(row);
     const tickets2 = listByFeature2(ctx, feature.id);
@@ -5314,9 +5761,22 @@ function list(ctx, projectId) {
       failed: tickets2.filter((t) => t.status === "failed").length,
       cancelled: tickets2.filter((t) => t.status === "cancelled").length
     };
-    return { ...feature, ticketCounts: counts, activeRun: hasActiveRun(ctx, feature.id) };
+    return {
+      ...feature,
+      ticketCounts: counts,
+      activeRun: hasActiveRun(ctx, feature.id),
+      liveSession: liveSessionOf(ctx, feature.id),
+      lastActivityAt: lastActivity.get(feature.id) ?? feature.createdAt
+    };
   });
 }
+function liveSessionOf(ctx, featureId) {
+  const open = activeSessionsForFeature(ctx, featureId);
+  const session = open.find((s) => s.status === "live") ?? open[0];
+  if (!session || session.status === "ended")
+    return null;
+  return { status: session.status, awaitingInput: session.awaitingInput };
+}
 function advance(ctx, featureId) {
   const feature = getFeatureRow(ctx, featureId);
   const gate = nextGate(feature);
@@ -5372,10 +5832,17 @@ async function burn(ctx, featureId, opts = {}) {
   } else {
     setPhase(ctx, featureId, "implementation", "burn.started", "burning tickets");
   }
-  const { runId } = await startRun(ctx, featureId, "ticket-burner", {
-    modelOverride: opts.modelOverride
-  });
-  return { runId };
+  try {
+    const { runId } = await startRun(ctx, featureId, "ticket-burner", {
+      modelOverride: opts.modelOverride
+    });
+    return { runId };
+  } catch (e) {
+    if (iterating) {
+      setPhase(ctx, featureId, REVIEW_LOOP_BACK.from, "burn.aborted", `the burn never started (${errMsg2(e)}) \u2014 back at review`);
+    }
+    throw e;
+  }
 }
 function rethink(ctx, featureId) {
   const feature = getFeatureRow(ctx, featureId);
@@ -5389,17 +5856,34 @@ function rethink(ctx, featureId) {
   if (live.length > 0) {
     throw new GateError(`a ${live[0].kind} session is already live for ${feature.slug} \u2014 only one terminal per feature; end or resume it first`);
   }
+  if (activeTestDriveFeatureId() === featureId) {
+    throw new GateError(`${feature.slug} is being test-driven \u2014 stop the test drive first, it holds the feature branch`);
+  }
   const lap = feature.lap + 1;
-  ctx.db.update(features).set({ lap }).where(eq7(features.id, featureId)).run();
+  ctx.db.update(features).set({ lap }).where(eq9(features.id, featureId)).run();
   return setPhase(ctx, featureId, RETHINK_LOOP_BACK.to, "lap.started", `rethink \u2014 lap ${lap}`);
 }
-async function retryTicket(ctx, ticketId, opts = {}) {
-  const ticket = getTicket(ctx, ticketId);
-  const feature = getFeatureRow(ctx, ticket.featureId);
-  if (ticket.status !== "failed") {
-    throw new GateError(`only failed tickets can be retried \u2014 ticket ${ticket.seq} is ${ticket.status}`);
-  }
-  if (hasActiveRun(ctx, feature.id)) {
+async function rethinkAndLaunch(ctx, featureId, launch) {
+  const before = getFeatureRow(ctx, featureId);
+  const feature = rethink(ctx, featureId);
+  try {
+    return await launch(feature);
+  } catch (e) {
+    ctx.db.update(features).set({ lap: before.lap }).where(eq9(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;
+  }
+}
+function errMsg2(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function retryTicket(ctx, ticketId, opts = {}) {
+  const ticket = getTicket(ctx, ticketId);
+  const feature = getFeatureRow(ctx, ticket.featureId);
+  if (ticket.status !== "failed") {
+    throw new GateError(`only failed tickets can be retried \u2014 ticket ${ticket.seq} is ${ticket.status}`);
+  }
+  if (hasActiveRun(ctx, feature.id)) {
     throw new GateError("a run is live for this feature \u2014 retry after it finishes, or cancel it first");
   }
   const project = projectForFeature(ctx, feature);
@@ -5464,7 +5948,7 @@ function escalateToMap(ctx, featureId, input) {
     return { ok: true, warning: `feature ${feature.slug} is already mapped \u2014 no changes made` };
   }
   const project = projectForFeature(ctx, feature);
-  ctx.db.update(features).set({ mapped: true }).where(eq7(features.id, featureId)).run();
+  ctx.db.update(features).set({ mapped: true }).where(eq9(features.id, featureId)).run();
   scaffoldMapDoc(project, { ...feature, mapped: true }, input);
   emit(ctx, featureId, {
     type: "feature.escalated",
@@ -5481,7 +5965,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(eq7(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: "archived" }).where(eq9(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.archived",
     message: `feature ${feature.slug} archived`,
@@ -5495,7 +5979,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(eq7(features.id, featureId)).run();
+  ctx.db.update(features).set({ status: restored }).where(eq9(features.id, featureId)).run();
   emit(ctx, featureId, {
     type: "feature.unarchived",
     message: `feature ${feature.slug} unarchived (${restored})`,
@@ -5535,13 +6019,13 @@ async function deleteFeature(ctx, featureId) {
   return { ok: true, slug: feature.slug };
 }
 function deleteFeatureRows(ctx, featureId) {
-  ctx.db.delete(tickets).where(eq7(tickets.featureId, featureId)).run();
-  ctx.db.delete(sessions).where(eq7(sessions.featureId, featureId)).run();
-  ctx.db.delete(runs).where(eq7(runs.featureId, featureId)).run();
-  ctx.db.delete(events).where(eq7(events.featureId, featureId)).run();
-  ctx.db.delete(gateOverrides).where(eq7(gateOverrides.featureId, featureId)).run();
-  ctx.db.delete(waypoints).where(eq7(waypoints.featureId, featureId)).run();
-  ctx.db.delete(features).where(eq7(features.id, featureId)).run();
+  ctx.db.delete(tickets).where(eq9(tickets.featureId, featureId)).run();
+  ctx.db.delete(sessions).where(eq9(sessions.featureId, featureId)).run();
+  ctx.db.delete(runs).where(eq9(runs.featureId, featureId)).run();
+  ctx.db.delete(events).where(eq9(events.featureId, featureId)).run();
+  ctx.db.delete(gateOverrides).where(eq9(gateOverrides.featureId, featureId)).run();
+  ctx.db.delete(waypoints).where(eq9(waypoints.featureId, featureId)).run();
+  ctx.db.delete(features).where(eq9(features.id, featureId)).run();
 }
 function gateState(ctx, feature) {
   const gate = nextGate(feature);
@@ -5552,7 +6036,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(eq7(features.projectId, projectId)).all().map((r) => r.slug));
+  const existing = new Set(ctx.db.select({ slug: features.slug }).from(features).where(eq9(features.projectId, projectId)).all().map((r) => r.slug));
   if (!existing.has(base))
     return base;
   let n = 2;
@@ -5581,126 +6065,6 @@ var init_features = __esm(() => {
   init_runner();
 });
 
-// src/services/findings.ts
-import { and as and6, eq as eq8 } from "drizzle-orm";
-function isPreparedKey(key) {
-  return PREPARED_SET.has(key);
-}
-function findingRow(ctx, projectId, key) {
-  return ctx.db.select({
-    source: projectFindings.source,
-    evidence: projectFindings.evidence,
-    establishedAt: projectFindings.establishedAt,
-    establishedSha: projectFindings.establishedSha
-  }).from(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).get();
-}
-function isOverwritable(ctx, projectId, key) {
-  return findingRow(ctx, projectId, key)?.source !== "human";
-}
-function recordFinding(ctx, projectId, input) {
-  const { key, value, source, evidence, establishedSha } = input;
-  ctx.db.transaction((tx) => {
-    tx.update(projects).set({ [COLUMN_NAME[key]]: value }).where(eq8(projects.id, projectId)).run();
-    if (value === null) {
-      tx.delete(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).run();
-      return;
-    }
-    tx.insert(projectFindings).values({
-      projectId,
-      key,
-      source,
-      evidence: evidence ?? null,
-      establishedAt: Date.now(),
-      establishedSha: establishedSha ?? null
-    }).onConflictDoUpdate({
-      target: [projectFindings.projectId, projectFindings.key],
-      set: {
-        source,
-        evidence: evidence ?? null,
-        establishedAt: Date.now(),
-        establishedSha: establishedSha ?? null
-      }
-    }).run();
-  });
-}
-function recordHuman(ctx, projectId, key, value) {
-  if (!isPreparedKey(key))
-    return;
-  const existing = findingRow(ctx, projectId, key);
-  if (value === null) {
-    if (existing) {
-      ctx.db.delete(projectFindings).where(and6(eq8(projectFindings.projectId, projectId), eq8(projectFindings.key, key))).run();
-    }
-    return;
-  }
-  ctx.db.insert(projectFindings).values({
-    projectId,
-    key,
-    source: "human",
-    evidence: null,
-    establishedAt: Date.now(),
-    establishedSha: null
-  }).onConflictDoUpdate({
-    target: [projectFindings.projectId, projectFindings.key],
-    set: { source: "human", evidence: null, establishedAt: Date.now(), establishedSha: null }
-  }).run();
-}
-async function listFindings(ctx, project) {
-  const rows = ctx.db.select().from(projectFindings).where(eq8(projectFindings.projectId, project.id)).all();
-  const distances = new Map;
-  for (const row of rows) {
-    const sha = row.establishedSha;
-    if (!sha || distances.has(sha))
-      continue;
-    distances.set(sha, await commitsSince(project.repoPath, sha, project.mainBranch));
-  }
-  const order = new Map(PREPARED_KEYS.map((k, i) => [k, i]));
-  return rows.filter((row) => isPreparedKey(row.key)).sort((a, b) => (order.get(a.key) ?? 0) - (order.get(b.key) ?? 0)).map((row) => {
-    const staleCommits = row.establishedSha ? distances.get(row.establishedSha) : undefined;
-    return {
-      key: row.key,
-      source: row.source,
-      ...row.evidence ? { evidence: row.evidence } : {},
-      establishedAt: row.establishedAt,
-      ...row.establishedSha ? { establishedSha: row.establishedSha } : {},
-      ...staleCommits !== undefined ? { staleCommits } : {}
-    };
-  });
-}
-function unsetPreparedKeys(project) {
-  return PREPARED_KEYS.filter((key) => {
-    const value = project[key];
-    return value === undefined || value.trim() === "";
-  });
-}
-var VALUE_COLUMN, COLUMN_NAME, PREPARED_SET;
-var init_findings = __esm(() => {
-  init_src();
-  init_schema();
-  init_git();
-  VALUE_COLUMN = {
-    setupCommand: projects.setupCommand,
-    verifyCommands: projects.verifyCommands,
-    knownFailures: projects.knownFailures,
-    devCommand: projects.devCommand,
-    driveSetupCommand: projects.driveSetupCommand,
-    driveStopCommand: projects.driveStopCommand,
-    driveEnv: projects.driveEnv,
-    dbResetCommand: projects.dbResetCommand
-  };
-  COLUMN_NAME = {
-    setupCommand: "setupCommand",
-    verifyCommands: "verifyCommands",
-    knownFailures: "knownFailures",
-    devCommand: "devCommand",
-    driveSetupCommand: "driveSetupCommand",
-    driveStopCommand: "driveStopCommand",
-    driveEnv: "driveEnv",
-    dbResetCommand: "dbResetCommand"
-  };
-  PREPARED_SET = new Set(PREPARED_KEYS);
-});
-
 // src/mcp/server.ts
 import { StreamableHTTPTransport } from "@hono/mcp";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -5871,6 +6235,13 @@ function toolRecordFinding(ctx, session, input) {
   });
   return { ok: true, key: input.key, source };
 }
+async function toolDryRunDrive(ctx, session, input) {
+  const project = requireProject(ctx, session);
+  if (session.kind !== "prepare") {
+    throw new GateError(`the dry-run drive belongs to a preparation conversation, and this is a ${session.kind} ` + "session. It starts services and creates a database on the human's machine \u2014 only the " + "session that established those values may run them.");
+  }
+  return dryRunDrive(ctx, project, input.action);
+}
 async function toolCreateFeature(ctx, session, input) {
   const project = requireProject(ctx, session);
   const feature = input.ticket ? await quickChange(ctx, {
@@ -5986,6 +6357,16 @@ function buildMcpServer() {
       return noSession();
     return ok(toolRecordFinding(rs.ctx, rs.session, args));
   });
+  server.registerTool("dry_run_drive", {
+    title: "Dry-run the test drive",
+    description: "Prove the drive keys you recorded by having the server run its REAL test-drive " + "machinery \u2014 same env rendering, same hooks, same dev pane \u2014 under a synthetic identity " + "(slug `prep-dry-run`) on the current branch. Nothing is checked out. `start` renders " + "driveEnv, runs driveSetupCommand and spawns devCommand; `status` reports the pane and " + "the sniffed localhost URL while you inspect; `stop` runs driveStopCommand and rules on " + "the run. Ask the human before starting: it starts services and creates a database on " + "their machine. A clean full pass stamps the participating keys verified, computed from " + "what the machinery observed \u2014 your own checks decide whether to fix and re-run, never " + "the stamp.",
+    inputSchema: { action: z3.enum(["start", "status", "stop"]) }
+  }, async (args, extra) => {
+    const rs = await resolveCtxSession(extra);
+    if (!rs)
+      return noSession();
+    return ok(await toolDryRunDrive(rs.ctx, rs.session, args));
+  });
   server.registerTool("create_feature", {
     title: "Create a feature",
     description: "Create a feature from the project session \u2014 the end of intake. Pass `brief` with the " + "reasoning you just worked out with the human (why this feature exists, what it must NOT " + "swallow): it becomes brief.md verbatim, and without it that reasoning is lost. Pass " + "`ticket: { prose }` for a quick change \u2014 work too small to deserve a grill \u2014 which " + "creates the feature at the implementation phase with that one ticket, and whose brief.md " + "is the prose itself (so `brief` is unused there). This does NOT open " + "a terminal on what it creates; the new card in the rail is the feedback, and the human " + "decides what to work on next.",
@@ -6234,7 +6615,51 @@ var init_ws = __esm(() => {
   };
 });
 
+// src/launcher/edit-guard.ts
+import { isAbsolute, relative as relative2, resolve as resolve7 } from "path";
+function guardsEdits(kind) {
+  return kind !== "project";
+}
+function evaluateEditGuard(input) {
+  if (!guardsEdits(input.kind))
+    return null;
+  if (!input.toolName || !EDIT_TOOLS.includes(input.toolName))
+    return null;
+  if (!input.filePath)
+    return null;
+  if (!input.featureSlug) {
+    return {
+      reason: `This ${input.kind} session does not edit files \u2014 it runs in the developer's own ` + "checkout. Record what you establish with the `record_finding` MCP tool, and ask the " + "human to make any change to the repo itself."
+    };
+  }
+  const docs = featureDocsRel(input.featureSlug);
+  const docsDir = resolve7(input.worktreePath, docs);
+  const target = resolve7(input.worktreePath, input.filePath);
+  const rel = relative2(docsDir, target);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel))
+    return null;
+  return {
+    reason: `Talk sessions do not write code. This ${input.kind} session may only write this ` + `feature's docs under \`${docs}/\` \u2014 ${input.filePath} is outside them. The change you ` + "want belongs in a ticket: capture the decision in `decisions.md`, amend `spec.md`, and " + "emit a ticket for the work. An implementation agent burns it in its own sandbox."
+  };
+}
+function editDenyResponse(denial) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: denial.reason
+    }
+  };
+}
+var EDIT_TOOLS, EDIT_TOOL_MATCHER;
+var init_edit_guard = __esm(() => {
+  init_paths();
+  EDIT_TOOLS = ["Edit", "Write", "NotebookEdit"];
+  EDIT_TOOL_MATCHER = EDIT_TOOLS.join("|");
+});
+
 // src/services/prep.ts
+import { and as and8, desc as desc6, eq as eq10, inArray as inArray4 } from "drizzle-orm";
 function keysToPrepare(ctx, project) {
   return unsetPreparedKeys(project).filter((key) => isOverwritable(ctx, project.id, key));
 }
@@ -6243,16 +6668,33 @@ function isPrepared(ctx, project) {
     return true;
   return hasCompletedProjectSession(ctx, project.id, "prepare");
 }
+function preparedAt(ctx, projectId) {
+  const prepareSessions = new Set(ctx.db.select({ id: sessions.id }).from(sessions).where(and8(eq10(sessions.projectId, projectId), eq10(sessions.kind, "prepare"))).all().map((r) => r.id));
+  if (prepareSessions.size === 0)
+    return null;
+  const ends = ctx.db.select({ ts: events.ts, data: events.data }).from(events).where(and8(eq10(events.projectId, projectId), inArray4(events.type, ["session.ended", "session.reconciled"]))).orderBy(desc6(events.ts)).all();
+  for (const end of ends) {
+    const sessionId = end.data?.sessionId;
+    if (sessionId && prepareSessions.has(sessionId))
+      return end.ts;
+  }
+  return null;
+}
 async function prepView(ctx, project) {
+  const drive = activeDriveInfo();
   return {
     pendingKeys: keysToPrepare(ctx, project),
     findings: await listFindings(ctx, project),
-    prepared: isPrepared(ctx, project)
+    prepared: isPrepared(ctx, project),
+    preparedAt: preparedAt(ctx, project.id),
+    dryRun: drive?.dryRun ? drive : null
   };
 }
 var init_prep = __esm(() => {
+  init_schema();
   init_sessions();
   init_findings();
+  init_git();
 });
 
 // src/routes/hooks.ts
@@ -6277,52 +6719,70 @@ function handleSessionStart(ctx, sessionId, feature, payload) {
     }
   };
 }
-function handlePrepareSessionStart(ctx, session, payload) {
+function handleProjectScopedSessionStart(ctx, session, payload) {
   const ccSessionId = typeof payload?.session_id === "string" ? payload.session_id : undefined;
   const transcriptPath = typeof payload?.transcript_path === "string" ? payload.transcript_path : undefined;
   const source = typeof payload?.source === "string" ? payload.source : undefined;
+  const noun = projectScopedNoun(session.kind);
   const wasLive = getSessionRow(ctx, session.id)?.status === "live";
   markSessionLive(ctx, session.id, { ccSessionId, transcriptPath });
   if (!wasLive) {
     emitForSession(ctx, session, {
       type: "session.started",
-      message: source === "resume" ? "preparation session live (resumed)" : "preparation session live",
+      message: source === "resume" ? `${noun} live (resumed)` : `${noun} live`,
       data: { sessionId: session.id, ccSessionId, transcriptPath, source: source ?? null }
     });
   }
   return {
     hookSpecificOutput: {
       hookEventName: "SessionStart",
-      additionalContext: prepareStartContext(ctx, session)
+      additionalContext: projectScopedStartContext(ctx, session)
     }
   };
 }
-function handlePrepareUserPrompt(ctx, session, payload) {
+function handleProjectScopedUserPrompt(ctx, session, payload) {
   const prompt = typeof payload?.prompt === "string" ? payload.prompt : undefined;
   noteKickoffPrompt(ctx, session.id, prompt);
   return {
     hookSpecificOutput: {
       hookEventName: "UserPromptSubmit",
-      additionalContext: `[runcastle] preparation session (project-scoped, no feature)`
+      additionalContext: projectScopedPromptLabel(session.kind)
     }
   };
 }
-function handlePrepareSessionEnd(ctx, session) {
+function handleProjectScopedSessionEnd(ctx, session) {
   markSessionEnded(ctx, session.id);
   emitForSession(ctx, session, {
     type: "session.ended",
-    message: "preparation session ended",
+    message: `${projectScopedNoun(session.kind)} ended`,
     data: { sessionId: session.id }
   });
   return {};
 }
-function prepareStartContext(ctx, session) {
+function projectScopedNoun(kind) {
+  switch (kind) {
+    case "prepare":
+      return "preparation session";
+    case "project":
+      return "project session";
+    default:
+      return "session";
+  }
+}
+function projectScopedPromptLabel(kind) {
+  return kind === "prepare" ? "[runcastle] preparation session (project-scoped, no feature)" : `[runcastle] ${projectScopedNoun(kind)}`;
+}
+function projectScopedStartContext(ctx, session) {
+  const noun = projectScopedNoun(session.kind);
   const project = session.projectId ? getProjectById(ctx, session.projectId) : null;
   if (!project)
-    return "[runcastle] preparation session \u2014 project not found";
+    return `[runcastle] ${noun} \u2014 project not found`;
+  const scope = `[runcastle] ${noun} for ${project.name} (${project.repoPath})`;
+  if (session.kind !== "prepare")
+    return scope;
   const remaining = keysToPrepare(ctx, project);
   return [
-    `[runcastle] preparation session for ${project.name} (${project.repoPath}).`,
+    `${scope}.`,
     remaining.length > 0 ? `Still unestablished: ${remaining.join(", ")}.` : "Every prepared field currently has a value.",
     "Record what you establish with the `record_finding` MCP tool \u2014 a value the user",
     "gives you or confirms verbatim is theirs (userSupplied: true), anything you measured is not."
@@ -6349,6 +6809,19 @@ function handleSessionEnd(ctx, sessionId, feature) {
   });
   return {};
 }
+function handlePreToolUse(session, feature, payload) {
+  const toolName = typeof payload?.tool_name === "string" ? payload.tool_name : undefined;
+  const toolInput = payload?.tool_input ?? {};
+  const path = typeof toolInput.file_path === "string" ? toolInput.file_path : typeof toolInput.notebook_path === "string" ? toolInput.notebook_path : undefined;
+  const denial = evaluateEditGuard({
+    kind: session.kind,
+    worktreePath: session.worktreePath,
+    toolName,
+    filePath: path,
+    featureSlug: feature?.slug
+  });
+  return denial ? editDenyResponse(denial) : {};
+}
 function sessionStartContext(ctx, feature) {
   const tickets2 = listByFeature2(ctx, feature.id);
   const byStatus = tickets2.reduce((acc, t) => {
@@ -6358,7 +6831,7 @@ function sessionStartContext(ctx, feature) {
   const ticketSummary = tickets2.length === 0 ? "none yet" : `${tickets2.length} (${Object.entries(byStatus).map(([s, n]) => `${n} ${s}`).join(", ")})`;
   return [
     `[runcastle] ${feature.title} \u2014 ${feature.oneLiner}`,
-    `phase: ${feature.phase}; branch: ${feature.branch}`,
+    `phase: ${feature.phase}; lap: ${feature.lap}; branch: ${feature.branch}`,
     `docs: docs/features/${feature.slug}/ (brief.md, decisions.md, spec.md)`,
     `tickets: ${ticketSummary}`,
     "Call the runcastle MCP tool `get_feature_context` for the full docs + tickets."
@@ -6367,6 +6840,7 @@ function sessionStartContext(ctx, feature) {
 }
 var hooks, hooks_default;
 var init_hooks = __esm(() => {
+  init_edit_guard();
   init_sessions();
   init_events();
   init_prep();
@@ -6391,14 +6865,22 @@ var init_hooks = __esm(() => {
       const session = getSessionRow(ctx, sessionId);
       if (!session)
         return c.json({});
+      if (event === "user-prompt")
+        markAgentWorking(ctx, sessionId);
+      if (event === "stop") {
+        markAwaitingInput(ctx, sessionId);
+        return c.json({});
+      }
       if (!session.featureId) {
         switch (event) {
           case "session-start":
-            return c.json(handlePrepareSessionStart(ctx, session, body.payload));
+            return c.json(handleProjectScopedSessionStart(ctx, session, body.payload));
           case "user-prompt":
-            return c.json(handlePrepareUserPrompt(ctx, session, body.payload));
+            return c.json(handleProjectScopedUserPrompt(ctx, session, body.payload));
           case "session-end":
-            return c.json(handlePrepareSessionEnd(ctx, session));
+            return c.json(handleProjectScopedSessionEnd(ctx, session));
+          case "pre-tool":
+            return c.json(handlePreToolUse(session, undefined, body.payload));
           default:
             return c.json({});
         }
@@ -6413,6 +6895,8 @@ var init_hooks = __esm(() => {
           return c.json(handleUserPrompt(ctx, sessionId, feature, body.payload));
         case "session-end":
           return c.json(handleSessionEnd(ctx, sessionId, feature));
+        case "pre-tool":
+          return c.json(handlePreToolUse(session, feature, body.payload));
         default:
           return c.json({});
       }
@@ -6477,7 +6961,7 @@ var init_stream = __esm(() => {
 // src/routes/web.ts
 import { existsSync as existsSync12, statSync } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join11, normalize, resolve as resolve7, sep as sep2 } from "path";
+import { extname, join as join11, normalize, resolve as resolve8, sep as sep2 } from "path";
 function contentType(path) {
   return MIME[extname(path).toLowerCase()] ?? "application/octet-stream";
 }
@@ -6503,11 +6987,11 @@ function safeJoin(root, pathname) {
 function resolveWebDist() {
   const override = process.env.RUNCASTLE_WEB_DIST;
   if (override)
-    return resolve7(override);
-  return resolve7(import.meta.dirname, "..", "..", "..", "..", "apps", "web", "dist");
+    return resolve8(override);
+  return resolve8(import.meta.dirname, "..", "..", "..", "..", "apps", "web", "dist");
 }
 function mountWebApp(app, distDir) {
-  const root = resolve7(distDir);
+  const root = resolve8(distDir);
   const indexHtml = join11(root, "index.html");
   app.get("*", async (c, next) => {
     const { pathname } = new URL(c.req.url);
@@ -6611,13 +7095,16 @@ function hookClientPath() {
 function serverUrlFor(config2) {
   return `http://localhost:${config2.serverPort}`;
 }
-function renderSystemPrompt(feature, kind, waypoint) {
+function noCodeRule(docs) {
+  return `- **Talk sessions do not write code.** You may write this feature's docs under \`${docs}/\` ` + "and nothing else in this checkout. Every code change rides a ticket, burned by an " + "implementation agent in its own sandbox \u2014 even the one-line fix that is obviously faster " + "to just do. This is enforced by a hook, not left to your judgement: edits outside the docs " + "are denied.";
+}
+function renderSystemPrompt(feature, kind, waypoint, lap) {
   if (kind === "waypoint")
     return renderWaypointPrompt(feature, waypoint);
   if (kind === "converge")
     return renderConvergePrompt(feature);
   if (kind === "revisit")
-    return renderRevisitPrompt(feature);
+    return renderRevisitPrompt(feature, lap);
   const docs = featureDocsRel(feature.slug);
   const entry = kind === "ideation" ? "Begin by invoking the `/runcastle:ideate` skill and drive the ideation session to completion." : "This is a Q&A session: invoke `/runcastle:qa`. Answer questions from the docs + code. Do NOT advance phases or emit tickets.";
   return [
@@ -6653,6 +7140,9 @@ function renderSystemPrompt(feature, kind, waypoint) {
     "  acceptanceCriteria, seams, blockedBy = 1-based positions within the batch).",
     "- `complete_phase({ phase })` \u2014 mark a phase done; advances past its gate.",
     "",
+    "## Rules",
+    noCodeRule(docs),
+    "",
     "## Your task",
     entry,
     ""
@@ -6743,9 +7233,30 @@ function renderConvergePrompt(feature) {
   ].join(`
 `);
 }
-function renderRevisitPrompt(feature) {
+function renderRevisitPrompt(feature, lap) {
   const docs = featureDocsRel(feature.slug);
-  const reviewIteration = feature.phase === "review" ? [
+  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. Unlike an`,
+    "ordinary revisit, a lap MOVES the pipeline \u2014 you drive the whole front half of it in",
+    "THIS session: grill the human about the drive, then `complete_phase` through",
+    "**ideation \u2192 spec \u2192 tickets**, emitting this lap\u2019s tickets on the way. Nothing else",
+    "advances it; if you stop early the feature sits at ideation with no lap tickets and",
+    "the human has no way forward.",
+    "",
+    "Your inputs, both OPTIONAL \u2014 a missing one is normal, not an error:",
+    `- \`${docs}/test-notes.md\`, section \`## Lap ${lap - 1}\` \u2014 what the drive surfaced.`,
+    `- \`${docs}/spec.md\`, section \`## Later laps\` \u2014 scope parked by earlier laps.`,
+    "Say plainly which you found, then interview the human from what they tell you.",
+    "",
+    `Write what you settle on into \`${docs}/decisions.md\` under a \`## Lap ${lap}\` heading`,
+    "(supersede, never rewrite), amend `spec.md` for this lap (pruning anything you promote",
+    "out of `## Later laps`), then `emit_tickets` for this lap\u2019s work. Finish by telling the",
+    "human to review the cards and click Burn.",
+    ""
+  ] : [];
+  const reviewIteration = !lap && feature.phase === "review" ? [
     "## Review iteration",
     "This feature is at **review**: its tickets were burned and the human has been",
     "test-driving the branch. Treat this as a fix-ticket interview \u2014 read the latest",
@@ -6768,6 +7279,7 @@ function renderRevisitPrompt(feature) {
     "into the record, then reconcile the tickets with it. The docs are the",
     "artifact \u2014 later phases read them, never the transcripts.",
     "",
+    ...lapIteration,
     ...reviewIteration,
     "## Feature",
     `- Slug: \`${feature.slug}\``,
@@ -6788,9 +7300,10 @@ function renderRevisitPrompt(feature) {
     "- `record_event({ type, message })` \u2014 drop a timeline note summarising the revisit.",
     "",
     "## Rules",
-    "- Do NOT call `complete_phase` \u2014 a revisit never moves the pipeline.",
+    lap ? "- DO call `complete_phase` \u2014 this lap advances ideation \u2192 spec \u2192 tickets, and only you can." : "- Do NOT call `complete_phase` \u2014 a revisit never moves the pipeline.",
     "- Do NOT touch `done`/`burning` tickets; if done work is now wrong, emit a new ticket that fixes it.",
     "- Docs first, tickets second: capture the decision prose before any ticket surgery.",
+    noCodeRule(docs),
     "",
     "## Your task",
     "Invoke the `/runcastle:revisit` skill and work through what the human brings up.",
@@ -6818,6 +7331,29 @@ function renderPreparePrompt(brief) {
     "service, creates or migrates a database, or writes outside the repo needs the human to",
     "agree first \u2014 say what you are about to run and why, then wait.",
     "",
+    "## What the five host keys mean",
+    "Take this from here. These semantics live in runcastle's source, not in the installed",
+    "build \u2014 grepping the shipped bundle for them finds nothing and proves nothing.",
+    "",
+    "- `devCommand` \u2014 spawned in a drive-owned terminal pane for the length of a test drive.",
+    '  The first localhost URL it prints becomes the "Open app" link.',
+    "- `driveSetupCommand` / `driveStopCommand` \u2014 run on the host, in the project repo, before",
+    "  the dev pane starts and after the drive stops.",
+    "- `driveEnv` \u2014 `KEY=VALUE` lines whose values render `{{slug}}`, `{{branch}}` and `{{id}}`",
+    "  (`{{id}}` is the slug made identifier-safe \u2014 legal as a database name). Rendered ONCE per",
+    "  drive and shared by the setup hook, the dev pane and the stop hook. So this, not a helper",
+    "  script, is where a branch\u2192database-name derivation belongs: name it once here and have both",
+    "  hooks read the variable. A database per branch is exactly this shape \u2014",
+    "",
+    "      driveEnv:           DB_NAME=myapp_{{id}}",
+    "                          DATABASE_URL=postgres://localhost/myapp_{{id}}",
+    '      driveSetupCommand:  createdb "$DB_NAME" && npm run migrate',
+    '      driveStopCommand:   dropdb --if-exists "$DB_NAME"',
+    "",
+    "- `dbResetCommand` \u2014 NOT part of the drive loop. Its only consumer is the migration-drift",
+    "  banner after a drive stops: when the drive branch and the branch you returned to disagree",
+    "  about migration files, this is offered as the one-click dev-database rebuild.",
+    "",
     ...established.length > 0 ? [
       "## Already established \u2014 do not re-derive",
       "These are recorded findings. Treat them as true unless the human says otherwise;",
@@ -6848,6 +7384,36 @@ function renderPreparePrompt(brief) {
     "## Your task",
     "Open by telling the human which fields are still open and what you need from them for",
     "each. Work them one at a time: propose, ask, run it if they agree, then record it.",
+    "",
+    "## Closing move: propose a dry-run drive",
+    "Once the open keys are recorded, end the session by PROPOSING one \u2014 recorded values that",
+    "have never been driven look exactly as trustworthy as values that run perfectly, and the",
+    "first person to find out otherwise is someone mid-feature with a broken environment.",
+    "",
+    "**Ask before you act.** This starts services and creates a database on their machine. Name",
+    "what will run \u2014 the setup command, the dev command, the stop command \u2014 then wait. If they",
+    "decline, end the session normally: the keys simply stay unverified, and the drive UI will",
+    "keep saying so.",
+    "",
+    "On a yes, `dry_run_drive({ action })` runs it in two halves and you inspect between them:",
+    "",
+    "1. `start` \u2014 the server renders `driveEnv`, runs `driveSetupCommand` and spawns `devCommand`",
+    "   in a real drive pane. Identity is the reserved slug `prep-dry-run` (`{{id}}` renders",
+    "   `prep_dry_run`, so the temp database is e.g. `myapp_prep_dry_run`) on the current branch.",
+    "   Nothing is checked out.",
+    "2. While it is up, check what the server cannot: the temp database exists and is FRESH, the",
+    "   migrations applied, and the app actually RESPONDS at the sniffed URL \u2014 printing one is not",
+    "   the same as serving. `status` gives you the pane and the URL while you work.",
+    "3. `stop` \u2014 the server runs `driveStopCommand`. Then check the cleanup: temp database gone,",
+    "   no orphaned process or container left behind.",
+    "",
+    "Anything off at any step, fix the finding with `record_finding` and run the WHOLE thing",
+    "again until a pass is clean. A leftover `myapp_prep_dry_run` making the retry's `createdb`",
+    "fail loudly is not a bug \u2014 that is the freshness check working.",
+    "",
+    "The verified stamps are computed server-side from what the machinery observed, and only on a",
+    "clean full pass. You cannot mark your own homework: your deeper checks decide whether to",
+    "retry, never what gets stamped.",
     ""
   ].join(`
 `);
@@ -6902,7 +7468,9 @@ function renderProjectPrompt(brief) {
     "ordinary file tools. The index says where.",
     "",
     "## Your task",
-    "Invoke the `/runcastle:project` skill and drive the project session.",
+    "Invoke the `/runcastle:project` skill, then open by asking the human what they brought.",
+    "Do not explore the project first: orienting before you know the ask spends their wait on",
+    "context you may not need. Once they have told you, read only what answering calls for.",
     ""
   ].join(`
 `);
@@ -6914,7 +7482,7 @@ function renderSettings(hookClient, kind) {
   const cmd = (event) => ({
     type: "command",
     command: `bun run "${hookClient}" ${event}`,
-    timeout: event === "user-prompt" ? 5 : 10
+    timeout: event === "session-start" || event === "session-end" ? 10 : 5
   });
   return {
     permissions: { allow: [...RUNCASTLE_MCP_ALLOW_RULES, ...sessionBashAllowRules(kind)] },
@@ -6924,7 +7492,9 @@ function renderSettings(hookClient, kind) {
         hooks: [cmd("session-start")]
       })),
       UserPromptSubmit: [{ hooks: [cmd("user-prompt")] }],
-      SessionEnd: [{ hooks: [cmd("session-end")] }]
+      Stop: [{ hooks: [cmd("stop")] }],
+      SessionEnd: [{ hooks: [cmd("session-end")] }],
+      ...kind === undefined || guardsEdits(kind) ? { PreToolUse: [{ matcher: EDIT_TOOL_MATCHER, hooks: [cmd("pre-tool")] }] } : {}
     }
   };
 }
@@ -6940,13 +7510,13 @@ function renderMcpConfig(session, config2) {
   };
 }
 async function writeSessionArtifacts(input) {
-  const { session, feature, config: config2, waypoint, prepare, projectBrief } = input;
+  const { session, feature, config: config2, waypoint, prepare, projectBrief, lap } = input;
   const dir = sessionDir(session.id);
   mkdirSync6(dir, { recursive: true });
   const systemPromptPath = join12(dir, "system-prompt.md");
   const settingsPath = join12(dir, "settings.json");
   const mcpConfigPath = join12(dir, "mcp.json");
-  const systemPrompt = feature ? renderSystemPrompt(feature, session.kind, waypoint) : prepare ? renderPreparePrompt(prepare) : projectBrief ? renderProjectPrompt(projectBrief) : (() => {
+  const systemPrompt = feature ? renderSystemPrompt(feature, session.kind, waypoint, lap) : prepare ? renderPreparePrompt(prepare) : projectBrief ? renderProjectPrompt(projectBrief) : (() => {
     throw new Error(`session ${session.id} has no feature and no project-session brief`);
   })();
   writeFileSync2(systemPromptPath, systemPrompt, "utf8");
@@ -6958,6 +7528,7 @@ var RUNCASTLE_MCP_ALLOW_RULES, SESSION_BASH_READ_RULES, SESSION_BASH_WRITE_RULES
 var init_artifacts = __esm(() => {
   init_paths();
   init_asset_paths();
+  init_edit_guard();
   RUNCASTLE_MCP_ALLOW_RULES = [
     "mcp__runcastle__get_feature_context",
     "mcp__runcastle__emit_tickets",
@@ -6969,6 +7540,7 @@ var init_artifacts = __esm(() => {
     "mcp__runcastle__emit_waypoints",
     "mcp__runcastle__resolve_waypoint",
     "mcp__runcastle__record_finding",
+    "mcp__runcastle__dry_run_drive",
     "mcp__runcastle__create_feature",
     "mcp__runcastle__get_project_context",
     "mcp__runcastle__get_work_record"
@@ -6994,9 +7566,9 @@ var init_artifacts = __esm(() => {
 
 // src/launcher/launcher.ts
 import { existsSync as existsSync13 } from "fs";
-import { dirname as dirname5, join as join13, resolve as resolve8 } from "path";
+import { dirname as dirname5, join as join13, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { and as and7, eq as eq9 } from "drizzle-orm";
+import { and as and9, eq as eq11 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
   return `terminal exited (code ${label})`;
@@ -7031,7 +7603,7 @@ function resolvePluginDir(fromDir = dirname5(fileURLToPath5(import.meta.url))) {
   const rel = join13("packages", "skills", "packs", "runcastle");
   const override = process.env[SKILLS_DIR_ENV];
   if (override) {
-    const dir2 = join13(resolve8(override), "packs", "runcastle");
+    const dir2 = join13(resolve9(override), "packs", "runcastle");
     if (existsSync13(dir2))
       return dir2;
     throw new Error(`${SKILLS_DIR_ENV}=${override} has no plugin dir at ${dir2}`);
@@ -7053,7 +7625,7 @@ function resolvePluginDir(fromDir = dirname5(fileURLToPath5(import.meta.url))) {
   `)}`);
 }
 function activeRunFor(ctx, featureId) {
-  const row = ctx.db.select().from(runs).where(and7(eq9(runs.featureId, featureId), eq9(runs.status, "running"))).limit(1).get();
+  const row = ctx.db.select().from(runs).where(and9(eq11(runs.featureId, featureId), eq11(runs.status, "running"))).limit(1).get();
   return row ? rowToRun(row) : null;
 }
 function assertSpawnable(ctx, feature, excludeSessionId) {
@@ -7114,12 +7686,13 @@ async function launchSession(ctx, input, opts = {}) {
     kind: input.kind,
     worktreePath
   });
+  const plan = planKickoff({ kind: input.kind, lap: feature.lap, kickoffLine: input.kickoffLine });
   let waypoint;
   let resumeSessionId;
   let resumeUnavailableFrom;
   if (input.waypointId) {
     const before = getWaypoint(ctx, input.waypointId);
-    if (before.lastSessionId) {
+    if (before.lastSessionId && !plan.explicit) {
       resumeSessionId = getSessionRow(ctx, before.lastSessionId)?.ccSessionId ?? undefined;
       if (!resumeSessionId)
         resumeUnavailableFrom = before.lastSessionId;
@@ -7139,17 +7712,19 @@ async function launchSession(ctx, input, opts = {}) {
       markSessionEnded(ctx, session.id);
       throw e;
     }
-    const prior = mostRecentResumableSession(ctx, feature.id);
-    if (prior?.ccSessionId) {
-      resumeSessionId = prior.ccSessionId;
-    } else {
-      resumeUnavailableFrom = "revisit";
+    if (!plan.explicit) {
+      const prior = mostRecentResumableSession(ctx, feature.id);
+      if (prior?.ccSessionId) {
+        resumeSessionId = prior.ccSessionId;
+      } else {
+        resumeUnavailableFrom = "revisit";
+      }
     }
   }
-  if (input.kind !== "waypoint" && input.kind !== "revisit") {
+  if (input.kind !== "waypoint" && input.kind !== "revisit" && !plan.explicit) {
     resumeSessionId = mostRecentResumableSession(ctx, feature.id, input.kind)?.ccSessionId;
   }
-  const kickoffLine = input.kickoffLine ?? (resumeSessionId ? resumeKickoffLine(input.kind) : undefined);
+  const kickoffLine = plan.line ?? (resumeSessionId ? resumeKickoffLine(input.kind) : undefined);
   if (kickoffLine)
     setKickoffOverride(session.id, kickoffLine);
   emit(ctx, feature.id, {
@@ -7183,7 +7758,8 @@ async function launchSession(ctx, input, opts = {}) {
     feature,
     project,
     config: ctx.config,
-    waypoint
+    waypoint,
+    lap: plan.lap
   });
   const serverUrl = serverUrlFor(ctx.config);
   const buildInput = {
@@ -7224,11 +7800,16 @@ async function launchPrepareSession(ctx, input, opts = {}) {
     kind: "prepare",
     worktreePath: project.repoPath
   });
-  const resumeSessionId = mostRecentResumableProjectSession(ctx, project.id, "prepare")?.ccSessionId;
+  const resumeSessionId = input.fresh ? undefined : mostRecentResumableProjectSession(ctx, project.id, "prepare")?.ccSessionId;
   emitProject(ctx, project.id, {
     type: "session.launching",
-    message: "launching preparation session",
-    data: { sessionId: session.id, kind: "prepare", worktreePath: project.repoPath }
+    message: input.fresh ? "launching preparation session from scratch" : "launching preparation session",
+    data: {
+      sessionId: session.id,
+      kind: "prepare",
+      worktreePath: project.repoPath,
+      ...input.fresh ? { fresh: true } : {}
+    }
   });
   if (resumeSessionId) {
     emitProject(ctx, project.id, {
@@ -7379,6 +7960,7 @@ async function converge(ctx, input, opts = {}) {
   if (!gate)
     throw new GateError("feature is already at the final phase");
   const result = checkGate(ctx, gate.check, feature);
+  let overrode = false;
   if (result.satisfied) {
     const next = nextPhase(feature);
     if (!next)
@@ -7386,10 +7968,21 @@ async function converge(ctx, input, opts = {}) {
     setPhase(ctx, feature.id, next, "phase.advanced", `converging (${next})`);
   } else if (input.overrideReason) {
     overrideGate(ctx, feature.id, gate.id, input.overrideReason);
+    overrode = true;
   } else {
     throw new GateError(result.reason ?? "the map is not ready to converge \u2014 resolve its waypoints or override with a reason");
   }
-  return launchSession(ctx, { featureId: feature.id, kind: "converge" }, opts);
+  try {
+    return await launchSession(ctx, { featureId: feature.id, kind: "converge" }, opts);
+  } catch (e) {
+    if (overrode)
+      undoLastGateOverride(ctx, feature.id, gate.id);
+    setPhase(ctx, feature.id, feature.phase, "converge.aborted", `converge aborted \u2014 its session could not be opened (${errMsg3(e)}); back at ${feature.phase}`);
+    throw e;
+  }
+}
+function errMsg3(e) {
+  return e instanceof Error ? e.message : String(e);
 }
 async function reconverge(ctx, feature, opts) {
   if (feature.phase !== "spec" && feature.phase !== "tickets") {
@@ -7542,18 +8135,16 @@ var init_feature = __esm(() => {
     })).mutation(({ ctx, input }) => launchSession(ctx, input)),
     workWaypoint: publicProcedure.input(z6.object({ featureId: z6.string(), waypointId: z6.string(), endLive: z6.boolean().optional() })).mutation(({ ctx, input }) => workWaypoint(ctx, input)),
     converge: publicProcedure.input(z6.object({ featureId: z6.string(), overrideReason: z6.string().min(1).optional() })).mutation(({ ctx, input }) => converge(ctx, { featureId: input.featureId, overrideReason: input.overrideReason })),
-    rethink: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => {
-      const feature = rethink(ctx, input.featureId);
-      return launchSession(ctx, {
-        featureId: input.featureId,
-        kind: "revisit",
-        kickoffLine: lapKickoff(feature.lap)
-      });
-    }),
+    rethink: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => rethinkAndLaunch(ctx, input.featureId, (feature) => launchSession(ctx, {
+      featureId: input.featureId,
+      kind: "revisit",
+      kickoffLine: lapKickoff(feature.lap)
+    }))),
     resendKickoff: publicProcedure.input(z6.object({ sessionId: z6.string() })).mutation(({ ctx, input }) => resendKickoff(ctx, input.sessionId)),
     endSession: publicProcedure.input(z6.object({ sessionId: z6.string() })).mutation(({ ctx, input }) => endSession(ctx, input.sessionId)),
     advance: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => advance(ctx, input.featureId)),
     overrideGate: publicProcedure.input(z6.object({ featureId: z6.string(), gate: gateId, reason: z6.string().min(1) })).mutation(({ ctx, input }) => overrideGate(ctx, input.featureId, input.gate, input.reason)),
+    undoGateOverride: publicProcedure.input(z6.object({ featureId: z6.string(), gate: gateId })).mutation(({ ctx, input }) => undoGateOverride(ctx, input.featureId, input.gate)),
     archive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => archiveFeature(ctx, input.featureId)),
     unarchive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => unarchiveFeature(ctx, input.featureId)),
     delete: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => deleteFeature(ctx, input.featureId)),
@@ -7564,6 +8155,10 @@ var init_feature = __esm(() => {
       return testDrive(ctx, project, feature, input.action);
     }),
     driveInfo: publicProcedure.query(() => activeDriveInfo()),
+    commitCount: publicProcedure.input(z6.object({ featureId: z6.string() })).query(({ ctx, input }) => {
+      const feature = getFeatureRow(ctx, input.featureId);
+      return reviewCommitCount(projectForFeature(ctx, feature), feature);
+    }),
     merge: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(async ({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
       const project = projectForFeature(ctx, feature);
@@ -7589,7 +8184,7 @@ var init_feature = __esm(() => {
 // src/services/fsbrowse.ts
 import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname6, isAbsolute, join as join14, resolve as resolve9, sep as sep3 } from "path";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute2, join as join14, resolve as resolve10, sep as sep3 } from "path";
 function expandPath(input, home = homedir2()) {
   const trimmed = input.trim();
   if (trimmed === "")
@@ -7599,7 +8194,7 @@ function expandPath(input, home = homedir2()) {
     out = home;
   else if (out.startsWith("~/") || out.startsWith("~\\"))
     out = join14(home, out.slice(2));
-  return resolve9(out);
+  return resolve10(out);
 }
 function looksLikeRepo(dir) {
   try {
@@ -7655,7 +8250,7 @@ function parentOf(dir) {
 }
 function browseDir(input, showHidden = false, home = homedir2()) {
   const target = input && input.trim() !== "" ? expandPath(input, home) : home;
-  if (!isAbsolute(target)) {
+  if (!isAbsolute2(target)) {
     throw new InvalidInputError(`path is not absolute: ${target}`);
   }
   if (!existsSync14(target)) {
@@ -7666,13 +8261,13 @@ function browseDir(input, showHidden = false, home = homedir2()) {
     if (!statSync2(target).isDirectory())
       dir = dirname6(target);
   } catch (e) {
-    throw new InvalidInputError(`cannot read path: ${target} (${errMsg2(e)})`);
+    throw new InvalidInputError(`cannot read path: ${target} (${errMsg4(e)})`);
   }
   let dirents;
   try {
     dirents = readdirSync5(dir, { withFileTypes: true, encoding: "utf8" });
   } catch (e) {
-    throw new InvalidInputError(`cannot read directory: ${dir} (${errMsg2(e)})`);
+    throw new InvalidInputError(`cannot read directory: ${dir} (${errMsg4(e)})`);
   }
   const entries = [];
   let truncated = false;
@@ -7688,6 +8283,8 @@ function browseDir(input, showHidden = false, home = homedir2()) {
       continue;
     const path = join14(dir, name);
     const isSymlink = dirent.isSymbolicLink();
+    if (isSymlink && !showHidden)
+      continue;
     let isDirectory = dirent.isDirectory();
     if (isSymlink) {
       try {
@@ -7710,7 +8307,7 @@ function browseDir(input, showHidden = false, home = homedir2()) {
     truncated
   };
 }
-function errMsg2(e) {
+function errMsg4(e) {
   return e instanceof Error ? e.message : String(e);
 }
 var SKIP_ALWAYS, MAX_ENTRIES = 1000, COMMON_DIRS;
@@ -7723,7 +8320,7 @@ var init_fsbrowse = __esm(() => {
 // src/services/projects.ts
 import { existsSync as existsSync15 } from "fs";
 import { basename as basename2, join as join15 } from "path";
-import { eq as eq10, isNull } from "drizzle-orm";
+import { eq as eq12, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
 }
@@ -7745,7 +8342,7 @@ async function openProject(ctx, rawPath) {
   const name = basename2(repoPath) || repoPath;
   const existing = getProjectByRepoPath(ctx, repoPath) ?? findProjectByCanonPath(ctx, repoPath);
   if (existing) {
-    ctx.db.update(projects).set({ mainBranch, repoPath, closedAt: null }).where(eq10(projects.id, existing.id)).run();
+    ctx.db.update(projects).set({ mainBranch, repoPath, closedAt: null }).where(eq12(projects.id, existing.id)).run();
     const reopened = { ...existing, mainBranch, repoPath };
     emitProject(ctx, existing.id, {
       type: "project.opened",
@@ -7776,7 +8373,7 @@ function closeProject(ctx, projectId) {
   if (projectHasActiveRun(ctx, projectId)) {
     throw new InvalidInputError(`cannot close ${project.name}: a run is in flight \u2014 wait for it to finish or cancel it first`);
   }
-  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq10(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ closedAt: Date.now() }).where(eq12(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.closed",
     message: `project ${project.name} closed`
@@ -7785,7 +8382,7 @@ function closeProject(ctx, projectId) {
 }
 function renameProject(ctx, projectId, name) {
   const project = requireProjectById(ctx, projectId);
-  ctx.db.update(projects).set({ name }).where(eq10(projects.id, projectId)).run();
+  ctx.db.update(projects).set({ name }).where(eq12(projects.id, projectId)).run();
   emitProject(ctx, projectId, {
     type: "project.renamed",
     message: `project renamed ${project.name} \u2192 ${name}`,
@@ -7831,6 +8428,7 @@ var init_projects = __esm(() => {
 import * as z7 from "zod";
 var projectRouter;
 var init_project = __esm(() => {
+  init_src();
   init_fsbrowse();
   init_git();
   init_prep();
@@ -7846,12 +8444,13 @@ var init_project = __esm(() => {
     branches: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId))),
     open: publicProcedure.input(z7.object({ repoPath: z7.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
     close: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
-    rename: publicProcedure.input(z7.object({ projectId: z7.string(), name: z7.string().min(1) })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name)),
-    talkToPrep: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => launchPrepareSession(ctx, { projectId: input.projectId })),
+    rename: publicProcedure.input(z7.object({ projectId: z7.string(), name: ProjectName })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name)),
+    talkToPrep: publicProcedure.input(z7.object({ projectId: z7.string(), fresh: z7.boolean().optional() })).mutation(({ ctx, input }) => launchPrepareSession(ctx, { projectId: input.projectId, fresh: input.fresh })),
     prepSession: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "prepare")),
     talkToProject: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => launchProjectSession(ctx, { projectId: input.projectId })),
     projectSession: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => activeProjectSession(ctx, input.projectId, "project")),
-    prep: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => prepView(ctx, requireProjectById(ctx, input.projectId)))
+    prep: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => prepView(ctx, requireProjectById(ctx, input.projectId))),
+    dryRunStop: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => dryRunDrive(ctx, requireProjectById(ctx, input.projectId), "stop"))
   });
 });
 
@@ -7877,7 +8476,7 @@ var init_run = __esm(() => {
 import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7 } from "path";
 import * as z9 from "zod";
-import { eq as eq11 } from "drizzle-orm";
+import { eq as eq13 } from "drizzle-orm";
 function readRawConfig(configFile) {
   if (!existsSync16(configFile))
     return {};
@@ -7917,7 +8516,7 @@ function projectOverrides(ctx, projectId) {
     driveSetupCommand: projects.driveSetupCommand,
     driveStopCommand: projects.driveStopCommand,
     driveEnv: projects.driveEnv
-  }).from(projects).where(eq11(projects.id, projectId)).get();
+  }).from(projects).where(eq13(projects.id, projectId)).get();
   return {
     model: row?.model ?? null,
     sandbox: row?.sandbox ?? null,
@@ -7931,26 +8530,26 @@ function projectOverrides(ctx, projectId) {
     driveEnv: row?.driveEnv ?? null
   };
 }
-function resolveField(desc5, layers) {
+function resolveField(desc7, layers) {
   const scoped = layers.overrides !== null;
-  const scope = scoped && desc5.projectColumn ? "project" : "global";
-  const base = { key: desc5.key, restartRequired: desc5.restartRequired, scope };
-  if (desc5.envVar) {
-    const raw = layers.env[desc5.envVar];
+  const scope = scoped && desc7.projectColumn ? "project" : "global";
+  const base = { key: desc7.key, restartRequired: desc7.restartRequired, scope };
+  if (desc7.envVar) {
+    const raw = layers.env[desc7.envVar];
     if (raw !== undefined && raw !== "") {
-      return { ...base, value: desc5.parseEnv(raw), source: "env", editable: false };
+      return { ...base, value: desc7.parseEnv(raw), source: "env", editable: false };
     }
   }
-  if (layers.overrides && desc5.projectColumn) {
-    const ov = layers.overrides[desc5.projectColumn];
+  if (layers.overrides && desc7.projectColumn) {
+    const ov = layers.overrides[desc7.projectColumn];
     if (ov !== null && ov !== "") {
       return { ...base, value: ov, source: "project", editable: true };
     }
   }
-  if (desc5.configKey && Object.prototype.hasOwnProperty.call(layers.fileRaw, desc5.configKey)) {
-    return { ...base, value: layers.fileRaw[desc5.configKey], source: "file", editable: true };
+  if (desc7.configKey && Object.prototype.hasOwnProperty.call(layers.fileRaw, desc7.configKey)) {
+    return { ...base, value: layers.fileRaw[desc7.configKey], source: "file", editable: true };
   }
-  const value = desc5.configKey ? DEFAULTS[desc5.configKey] ?? null : null;
+  const value = desc7.configKey ? DEFAULTS[desc7.configKey] ?? null : null;
   return { ...base, value, source: "default", editable: true };
 }
 function getSettings(ctx, projectId, io = {}) {
@@ -7967,56 +8566,56 @@ function updateSettings(ctx, input, io = {}) {
   if (input.key.startsWith("stepModels.")) {
     return updateStepModel(ctx, input, configFile, io);
   }
-  const desc5 = DESCRIPTORS.find((d) => d.key === input.key);
-  if (!desc5)
+  const desc7 = DESCRIPTORS.find((d) => d.key === input.key);
+  if (!desc7)
     throw new InvalidInputError(`unknown setting: ${input.key}`);
-  if (desc5.envVar) {
-    const raw = env[desc5.envVar];
+  if (desc7.envVar) {
+    const raw = env[desc7.envVar];
     if (raw !== undefined && raw !== "") {
-      throw new InvalidInputError(`${desc5.key} is set by environment variable ${desc5.envVar}; unset it to edit`);
+      throw new InvalidInputError(`${desc7.key} is set by environment variable ${desc7.envVar}; unset it to edit`);
     }
   }
-  const toProject = input.projectId !== undefined && desc5.projectColumn !== undefined;
+  const toProject = input.projectId !== undefined && desc7.projectColumn !== undefined;
   if (input.value === null) {
     if (!toProject)
-      throw new InvalidInputError(`${desc5.key} cannot be cleared`);
+      throw new InvalidInputError(`${desc7.key} cannot be cleared`);
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: null }).where(eq11(projects.id, project.id)).run();
-    recordHuman(ctx, project.id, desc5.key, null);
+    ctx.db.update(projects).set({ [desc7.projectColumn]: null }).where(eq13(projects.id, project.id)).run();
+    recordHuman(ctx, project.id, desc7.key, null);
     emitProject(ctx, project.id, {
       type: "settings.updated",
-      message: `${desc5.key} override cleared`,
-      data: { key: desc5.key, scope: "project", value: null }
+      message: `${desc7.key} override cleared`,
+      data: { key: desc7.key, scope: "project", value: null }
     });
-    return field(getSettings(ctx, input.projectId, io), desc5.key);
+    return field(getSettings(ctx, input.projectId, io), desc7.key);
   }
-  const parsed = desc5.valueSchema.safeParse(input.value);
+  const parsed = desc7.valueSchema.safeParse(input.value);
   if (!parsed.success) {
-    throw new InvalidInputError(`invalid value for ${desc5.key}: ${parsed.error.issues[0]?.message}`);
+    throw new InvalidInputError(`invalid value for ${desc7.key}: ${parsed.error.issues[0]?.message}`);
   }
   const value = parsed.data;
   if (toProject) {
     const project = requireProjectById(ctx, input.projectId);
-    ctx.db.update(projects).set({ [desc5.projectColumn]: String(value) }).where(eq11(projects.id, project.id)).run();
-    recordHuman(ctx, project.id, desc5.key, String(value));
+    ctx.db.update(projects).set({ [desc7.projectColumn]: String(value) }).where(eq13(projects.id, project.id)).run();
+    recordHuman(ctx, project.id, desc7.key, String(value));
     emitProject(ctx, project.id, {
       type: "settings.updated",
-      message: `${desc5.key} override set to ${String(value)}`,
-      data: { key: desc5.key, scope: "project", value }
+      message: `${desc7.key} override set to ${String(value)}`,
+      data: { key: desc7.key, scope: "project", value }
     });
-    return field(getSettings(ctx, input.projectId, io), desc5.key);
+    return field(getSettings(ctx, input.projectId, io), desc7.key);
   }
-  if (!desc5.configKey) {
-    throw new InvalidInputError(`${desc5.key} is a per-project setting; provide a projectId`);
+  if (!desc7.configKey) {
+    throw new InvalidInputError(`${desc7.key} is a per-project setting; provide a projectId`);
   }
-  writeGlobal(configFile, desc5.configKey, value);
-  ctx.config[desc5.configKey] = value;
+  writeGlobal(configFile, desc7.configKey, value);
+  ctx.config[desc7.configKey] = value;
   emitProject(ctx, GLOBAL_EVENT_KEY, {
     type: "settings.updated",
-    message: `${desc5.key} set to ${String(value)}`,
-    data: { key: desc5.key, scope: "global", value }
+    message: `${desc7.key} set to ${String(value)}`,
+    data: { key: desc7.key, scope: "global", value }
   });
-  return field(getSettings(ctx, input.projectId, io), desc5.key);
+  return field(getSettings(ctx, input.projectId, io), desc7.key);
 }
 function writeGlobal(configFile, configKey, value) {
   const raw = readRawConfig(configFile);
@@ -8414,7 +9013,7 @@ var init_doctor = __esm(() => {
 // src/doctor/system-exec.ts
 import { spawn as spawn3 } from "child_process";
 function createSystemExec(opts = {}) {
-  return (command, args) => new Promise((resolve10) => {
+  return (command, args) => new Promise((resolve11) => {
     const { file, args: spawnArgs } = resolveSpawnTarget(command, args);
     let stdout = "";
     let stderr = "";
@@ -8426,10 +9025,10 @@ function createSystemExec(opts = {}) {
       stderr += d.toString();
     });
     child.on("error", (err) => {
-      resolve10({ ok: false, code: null, stdout, stderr: stderr || String(err) });
+      resolve11({ ok: false, code: null, stdout, stderr: stderr || String(err) });
     });
     child.on("close", (code) => {
-      resolve10({ ok: true, code: code ?? 0, stdout, stderr });
+      resolve11({ ok: true, code: code ?? 0, stdout, stderr });
     });
   });
 }
@@ -8652,6 +9251,29 @@ var init_setup2 = __esm(() => {
   });
 });
 
+// src/version.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname9, join as join17 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+function runcastleVersion() {
+  if (cached2)
+    return cached2;
+  const here = dirname9(fileURLToPath7(import.meta.url));
+  for (const pkgPath of [join17(here, "..", "package.json"), join17(here, "package.json")]) {
+    try {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+      if (typeof pkg.version === "string") {
+        cached2 = pkg.version;
+        return cached2;
+      }
+    } catch {}
+  }
+  cached2 = UNKNOWN_VERSION;
+  return cached2;
+}
+var cached2, UNKNOWN_VERSION = "0.0.0";
+var init_version = () => {};
+
 // src/services/update-check.ts
 function parse(version) {
   const cleaned = version.trim().replace(/^v/, "");
@@ -8694,6 +9316,8 @@ function compareSemver(a, b) {
 async function checkForUpdate(opts) {
   const { current: current2 } = opts;
   const fetchImpl = opts.fetchImpl ?? fetch;
+  if (current2 === UNKNOWN_VERSION)
+    return NO_UPDATE(current2);
   try {
     const res = await fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
     if (!res.ok)
@@ -8727,32 +9351,10 @@ var PACKAGE_NAME = "runcastle", UPDATE_COMMAND, NO_UPDATE = (current2) => ({
   command: UPDATE_COMMAND
 }), cache;
 var init_update_check = __esm(() => {
+  init_version();
   UPDATE_COMMAND = `bun add -g ${PACKAGE_NAME}@latest`;
 });
 
-// src/version.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname9, join as join17 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
-function runcastleVersion() {
-  if (cached2)
-    return cached2;
-  const here = dirname9(fileURLToPath7(import.meta.url));
-  for (const pkgPath of [join17(here, "..", "package.json"), join17(here, "package.json")]) {
-    try {
-      const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
-      if (typeof pkg.version === "string") {
-        cached2 = pkg.version;
-        return cached2;
-      }
-    } catch {}
-  }
-  cached2 = "0.0.0";
-  return cached2;
-}
-var cached2;
-var init_version = () => {};
-
 // src/trpc/routers/system.ts
 var systemRouter;
 var init_system = __esm(() => {
@@ -8765,8 +9367,188 @@ var init_system = __esm(() => {
   });
 });
 
-// src/trpc/routers/ticket.ts
+// src/services/test-notes.ts
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname10 } from "path";
+import { asc as asc4, eq as eq14 } from "drizzle-orm";
+function rowToNote(row) {
+  return {
+    id: row.id,
+    featureId: row.featureId,
+    lap: row.lap,
+    text: row.text,
+    status: row.status,
+    ticketId: row.ticketId ?? undefined,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function getNote(ctx, id) {
+  const row = ctx.db.select().from(testNotes).where(eq14(testNotes.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`test note ${id} not found`);
+  return rowToNote(row);
+}
+function cleanText(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed)
+    throw new InvalidInputError("note text cannot be empty");
+  return trimmed;
+}
+function assertOpen(note, action) {
+  if (note.status !== "open") {
+    throw new InvalidInputError(`cannot ${action} note ${note.id} \u2014 it is ${note.status}; only open notes can be changed`);
+  }
+}
+function listByFeature3(ctx, featureId) {
+  return ctx.db.select().from(testNotes).where(eq14(testNotes.featureId, featureId)).orderBy(asc4(testNotes.createdAt), asc4(testNotes.id)).all().map(rowToNote);
+}
+function addNote(ctx, featureId, text2) {
+  const body = cleanText(text2);
+  const feature = getFeatureRow(ctx, featureId);
+  const now = Date.now();
+  const row = ctx.db.insert(testNotes).values({
+    id: newId("note"),
+    featureId,
+    lap: feature.lap,
+    text: body,
+    status: "open",
+    ticketId: null,
+    createdAt: now,
+    updatedAt: now
+  }).returning().get();
+  const note = rowToNote(row);
+  emit(ctx, featureId, {
+    type: "note.added",
+    message: `note captured on lap ${note.lap}`,
+    data: { noteId: note.id, lap: note.lap }
+  });
+  renderTestNotes(ctx, feature);
+  return note;
+}
+function editNote(ctx, noteId, text2) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "edit");
+  const body = cleanText(text2);
+  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.edited",
+    message: "note edited",
+    data: { noteId }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+  return getNote(ctx, noteId);
+}
+function deleteNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "delete");
+  ctx.db.delete(testNotes).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.deleted",
+    message: "note deleted",
+    data: { noteId }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+}
+function toggleNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  if (current2.status === "promoted") {
+    throw new InvalidInputError(`cannot toggle note ${noteId} \u2014 it is promoted, and promoted notes are frozen`);
+  }
+  const status = current2.status === "open" ? "done" : "open";
+  ctx.db.update(testNotes).set({ status, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.toggled",
+    message: `note ${current2.status} \u2192 ${status}`,
+    data: { noteId, from: current2.status, to: status }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+  return getNote(ctx, noteId);
+}
+function promotionTicket(feature, note) {
+  const firstLine = note.text.split(`
+`)[0].trim();
+  const docs = featureDocsRel(feature.slug);
+  return {
+    title: firstLine.length <= TITLE_MAX ? firstLine : `${firstLine.slice(0, TITLE_MAX - 1).trimEnd()}\u2026`,
+    goal: note.text,
+    context: [
+      `Found during lap ${note.lap} test drive of ${feature.slug}.`,
+      `Read ${docs}/spec.md and ${docs}/decisions.md for what this feature is meant to do.`
+    ].join(`
+
+`),
+    acceptanceCriteria: [`The noted behavior no longer reproduces: ${note.text}`],
+    seams: [],
+    blockedBy: []
+  };
+}
+function promoteNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "promote");
+  const feature = getFeatureRow(ctx, current2.featureId);
+  const [ticket] = storeTickets(ctx, current2.featureId, [promotionTicket(feature, current2)]);
+  ctx.db.update(testNotes).set({ status: "promoted", ticketId: ticket.id, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.promoted",
+    message: `note promoted to ticket ${ticket.seq}`,
+    ticketId: ticket.id,
+    data: { noteId, seq: ticket.seq }
+  });
+  renderTestNotes(ctx, feature);
+  return { note: getNote(ctx, noteId), ticket };
+}
+function noteLine(ctx, note) {
+  if (note.status === "open")
+    return `- [ ] ${note.text}`;
+  const ticket = note.ticketId ? ` (\u2192 ticket ${getTicket(ctx, note.ticketId).seq})` : "";
+  return `- [x] ${note.text}${ticket}`;
+}
+function renderTestNotes(ctx, feature) {
+  const notes = listByFeature3(ctx, feature.id);
+  const laps = [...new Set(notes.map((n) => n.lap))].sort((a, b) => a - b);
+  const lines = ["# Test notes"];
+  for (const lap of laps) {
+    lines.push("", `## Lap ${lap}`, "");
+    for (const note of notes.filter((n) => n.lap === lap))
+      lines.push(noteLine(ctx, note));
+  }
+  const path = featureDocPath(projectForFeature(ctx, feature), feature, "test-notes.md");
+  mkdirSync9(dirname10(path), { recursive: true });
+  writeFileSync5(path, `${lines.join(`
+`)}
+`, "utf8");
+}
+var TITLE_MAX = 60;
+var init_test_notes = __esm(() => {
+  init_src();
+  init_paths();
+  init_schema();
+  init_errors();
+  init_events();
+  init_feature_docs();
+  init_repo();
+  init_tickets();
+});
+
+// src/trpc/routers/test-notes.ts
 import * as z12 from "zod";
+var testNotesRouter;
+var init_test_notes2 = __esm(() => {
+  init_test_notes();
+  init_context();
+  testNotesRouter = router({
+    list: publicProcedure.input(z12.object({ featureId: z12.string() })).query(({ ctx, input }) => listByFeature3(ctx, input.featureId)),
+    add: publicProcedure.input(z12.object({ featureId: z12.string(), text: z12.string().min(1) })).mutation(({ ctx, input }) => addNote(ctx, input.featureId, input.text)),
+    edit: publicProcedure.input(z12.object({ noteId: z12.string(), text: z12.string().min(1) })).mutation(({ ctx, input }) => editNote(ctx, input.noteId, input.text)),
+    remove: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => deleteNote(ctx, input.noteId)),
+    toggle: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => toggleNote(ctx, input.noteId)),
+    promote: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => promoteNote(ctx, input.noteId))
+  });
+});
+
+// src/trpc/routers/ticket.ts
+import * as z13 from "zod";
 var ticketRouter;
 var init_ticket = __esm(() => {
   init_features();
@@ -8775,8 +9557,8 @@ var init_ticket = __esm(() => {
   init_ticket_burner();
   init_context();
   ticketRouter = router({
-    retry: publicProcedure.input(z12.object({ ticketId: z12.string(), fresh: z12.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
-    stop: publicProcedure.input(z12.object({ ticketId: z12.string() })).mutation(({ ctx, input }) => {
+    retry: publicProcedure.input(z13.object({ ticketId: z13.string(), fresh: z13.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
+    stop: publicProcedure.input(z13.object({ ticketId: z13.string() })).mutation(({ ctx, input }) => {
       if (stopTicketRun(input.ticketId))
         return { stopped: true, swept: false };
       const ticket = getTicket(ctx, input.ticketId);
@@ -8786,13 +9568,13 @@ var init_ticket = __esm(() => {
       }
       return { stopped: false, swept: false };
     }),
-    cancel: publicProcedure.input(z12.object({ ticketId: z12.string(), reason: z12.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
-    edit: publicProcedure.input(z12.object({
-      ticketId: z12.string(),
-      title: z12.string().min(1).optional(),
-      goal: z12.string().min(1).optional(),
-      context: z12.string().optional(),
-      acceptanceCriteria: z12.array(z12.string().min(1)).optional()
+    cancel: publicProcedure.input(z13.object({ ticketId: z13.string(), reason: z13.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
+    edit: publicProcedure.input(z13.object({
+      ticketId: z13.string(),
+      title: z13.string().min(1).optional(),
+      goal: z13.string().min(1).optional(),
+      context: z13.string().optional(),
+      acceptanceCriteria: z13.array(z13.string().min(1)).optional()
     })).mutation(({ ctx, input }) => {
       const { ticketId, ...patch } = input;
       return editTicket(ctx, ticketId, patch);
@@ -8812,12 +9594,14 @@ var init_router = __esm(() => {
   init_settings2();
   init_setup2();
   init_system();
+  init_test_notes2();
   init_ticket();
   appRouter = router({
     project: projectRouter,
     feature: featureRouter,
     run: runRouter,
     ticket: ticketRouter,
+    notes: testNotesRouter,
     events: eventsRouter,
     docs: docsRouter,
     settings: settingsRouter,
@@ -8827,14 +9611,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq12 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq12(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq15(runs.status, "running")).all().map(rowToRun);
   const reconciled = [];
   for (const run3 of stale) {
     if (isRunActive(run3.id))
       continue;
-    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq12(runs.id, run3.id)).run();
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq15(runs.id, run3.id)).run();
     const released = releaseForSession(ctx, run3.id);
     const swept = workflowClaimsFeatureBranch(run3.workflow) ? sweepOrphanedBurning(ctx, run3.featureId, "orphaned by server restart \u2014 retry to resume its commits") : [];
     if (workflowClaimsFeatureBranch(run3.workflow)) {