runcastle 1.0.14 → 1.0.16

package/bin/runcastle.js

@@ -186,7 +186,7 @@ var init_ids = () => {};
 
 // ../core/src/schemas.ts
 import * as z2 from "zod";
-var Phase, FeatureSize, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, Project, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, Project, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
 var init_schemas = __esm(() => {
   Phase = z2.enum([
     "ideation",
@@ -196,11 +196,10 @@ var init_schemas = __esm(() => {
     "review",
     "shipped"
   ]);
-  FeatureSize = z2.enum(["full", "collapsed"]);
   TicketStatus = z2.enum(["pending", "burning", "done", "failed", "cancelled"]);
   SessionKind = z2.enum(["ideation", "qa", "waypoint", "converge", "revisit"]);
   RunStatus = z2.enum(["running", "succeeded", "failed", "cancelled"]);
-  FeatureStatus = z2.enum(["active", "shipped"]);
+  FeatureStatus = z2.enum(["active", "shipped", "archived"]);
   SessionStatus = z2.enum(["launching", "live", "ended"]);
   TicketInput = z2.object({
     title: z2.string(),
@@ -253,7 +252,6 @@ var init_schemas = __esm(() => {
     slug: z2.string(),
     title: z2.string(),
     oneLiner: z2.string(),
-    size: FeatureSize,
     mapped: z2.boolean(),
     phase: Phase,
     branch: z2.string(),
@@ -379,11 +377,7 @@ function nextPhase(feature) {
   const i = ORDER.indexOf(feature.phase);
   if (i < 0 || i >= ORDER.length - 1)
     return null;
-  const step = ORDER[i + 1];
-  if (feature.size === "collapsed" && step === "spec") {
-    return ORDER[i + 2] ?? null;
-  }
-  return step;
+  return ORDER[i + 1];
 }
 function nextGate(feature) {
   const i = ORDER.indexOf(feature.phase);
@@ -394,7 +388,7 @@ function nextGate(feature) {
     return MAPPED_G1;
   return gate;
 }
-var PIPELINE, ORDER, MAPPED_G1;
+var PIPELINE, ORDER, REVIEW_LOOP_BACK, MAPPED_G1;
 var init_pipeline = __esm(() => {
   PIPELINE = [
     { phase: "ideation" },
@@ -410,7 +404,7 @@ var init_pipeline = __esm(() => {
       phase: "tickets",
       gateToEnter: {
         id: "G2",
-        description: "Spec written before breaking into tickets (auto-satisfied for collapsed features)",
+        description: "Spec written before breaking into tickets",
         check: "spec-file-exists"
       }
     },
@@ -440,6 +434,7 @@ var init_pipeline = __esm(() => {
     }
   ];
   ORDER = PIPELINE.map((p) => p.phase);
+  REVIEW_LOOP_BACK = { from: "review", to: "implementation" };
   MAPPED_G1 = {
     id: "G1",
     description: "Every waypoint resolved or dropped before converging",
@@ -467,7 +462,6 @@ var init_db_schema = __esm(() => {
     slug: text("slug").notNull(),
     title: text("title").notNull(),
     oneLiner: text("one_liner").notNull(),
-    size: text("size").notNull().$type(),
     mapped: integer("mapped", { mode: "boolean" }).notNull().default(false),
     phase: text("phase").notNull().$type(),
     branch: text("branch").notNull(),
@@ -1195,7 +1189,6 @@ function rowToFeature(row) {
     slug: row.slug,
     title: row.title,
     oneLiner: row.oneLiner,
-    size: row.size,
     mapped: row.mapped,
     phase: row.phase,
     branch: row.branch,
@@ -1516,15 +1509,20 @@ function markSessionLive(ctx, id, input = {}) {
   const firstTimeLive = existing.status !== "live";
   if (firstTimeLive) {
     promoteLastSession(ctx, id);
-    if (existing.kind === "converge")
-      scheduleConvergeKickoff(ctx, existing);
+    scheduleKickoff(ctx, existing);
   }
   return getSessionRow(ctx, id);
 }
-function writeKickoffSequence(io, submitDelayMs = CONVERGE_KICKOFF_SUBMIT_DELAY_MS) {
+function kickoffLineFor(kind, override) {
+  return override ?? KICKOFF_LINES[kind];
+}
+function setKickoffOverride(sessionId, line) {
+  pendingKickoffOverrides.set(sessionId, line);
+}
+function writeKickoffSequence(line, io, submitDelayMs = KICKOFF_SUBMIT_DELAY_MS) {
   if (!io.alive())
     return;
-  io.write(CONVERGE_KICKOFF_LINE);
+  io.write(line);
   const submit = setTimeout(() => {
     try {
       if (!io.alive())
@@ -1535,10 +1533,12 @@ function writeKickoffSequence(io, submitDelayMs = CONVERGE_KICKOFF_SUBMIT_DELAY_
   }, submitDelayMs);
   submit.unref?.();
 }
-function scheduleConvergeKickoff(ctx, session) {
+function scheduleKickoff(ctx, session) {
+  const line = kickoffLineFor(session.kind, pendingKickoffOverrides.get(session.id));
+  pendingKickoffOverrides.delete(session.id);
   const timer = setTimeout(() => {
     try {
-      writeKickoffSequence({
+      writeKickoffSequence(line, {
         write: (data) => ptyRegistry().get(session.id)?.pty.write(data),
         alive: () => {
           const entry = ptyRegistry().get(session.id);
@@ -1547,19 +1547,20 @@ function scheduleConvergeKickoff(ctx, session) {
         onSubmitted: () => {
           emit(ctx, session.featureId, {
             type: "session.kickoff",
-            message: "converge session kicked off automatically",
-            data: { sessionId: session.id }
+            message: `${session.kind} session kicked off automatically`,
+            data: { sessionId: session.id, kind: session.kind }
           });
         }
       });
     } catch {}
-  }, CONVERGE_KICKOFF_DELAY_MS);
+  }, KICKOFF_DELAY_MS);
   timer.unref?.();
 }
 function markSessionEnded(ctx, id) {
   const existing = getSessionRow(ctx, id);
   if (!existing)
     return null;
+  pendingKickoffOverrides.delete(id);
   ctx.db.update(sessions).set({ status: "ended" }).where(eq4(sessions.id, id)).run();
   return getSessionRow(ctx, id);
 }
@@ -1571,7 +1572,7 @@ function mostRecentLiveSession(ctx) {
   const row = ctx.db.select().from(sessions).where(eq4(sessions.status, "live")).orderBy(desc2(sql2`rowid`)).limit(1).get();
   return row ? rowToSession(row) : null;
 }
-var CONVERGE_KICKOFF_DELAY_MS = 1500, CONVERGE_KICKOFF_SUBMIT_DELAY_MS = 350, CONVERGE_KICKOFF_LINE;
+var KICKOFF_DELAY_MS = 1500, KICKOFF_SUBMIT_DELAY_MS = 350, CONVERGE_KICKOFF_LINE, KICKOFF_LINES, pendingKickoffOverrides;
 var init_sessions = __esm(() => {
   init_src();
   init_schema();
@@ -1580,6 +1581,14 @@ var init_sessions = __esm(() => {
   init_waypoints();
   init_repo();
   CONVERGE_KICKOFF_LINE = "Proceed with your task: invoke /runcastle:converge and drive spec then tickets " + "from map.md + decisions.md, per your system prompt.";
+  KICKOFF_LINES = {
+    ideation: "Proceed with your task: invoke the /runcastle:ideate skill and drive the ideation session.",
+    qa: "Proceed with your task: invoke the /runcastle:qa skill and answer questions from the " + "docs and code \u2014 do not advance phases or emit tickets.",
+    waypoint: "Proceed with your task: invoke the /runcastle:waypoint skill and work your assigned " + "waypoint to a resolution.",
+    converge: CONVERGE_KICKOFF_LINE,
+    revisit: "Proceed with your task: invoke the /runcastle:revisit skill and work through what the " + "human brings up."
+  };
+  pendingKickoffOverrides = new Map;
 });
 
 // src/launcher/reconcile.ts
@@ -1808,8 +1817,6 @@ function checkGate(ctx, check, feature) {
       };
     }
     case "spec-file-exists":
-      if (feature.size === "collapsed")
-        return { satisfied: true };
       return fileGate(ctx, feature, "spec.md", "write the spec (spec.md) before breaking into tickets");
     case "tickets-approved": {
       const count = listByFeature2(ctx, feature.id).filter((t) => t.status !== "cancelled").length;
@@ -2326,6 +2333,44 @@ async function cleanupTempBranches(repoPath) {
   }
   return { deleted, kept };
 }
+async function removeTalkWorktree(repoPath, worktreePath) {
+  const g = git(repoPath);
+  try {
+    await g.raw(["worktree", "remove", "--force", worktreePath]);
+  } catch {
+    try {
+      rmSync(worktreePath, { recursive: true, force: true });
+    } catch {}
+  }
+  try {
+    await g.raw(["worktree", "prune"]);
+  } catch {}
+  if (existsSync7(worktreePath)) {
+    throw new InvalidInputError(`could not remove talk worktree at ${worktreePath} \u2014 a file may be locked; ` + "close anything using it and retry the delete");
+  }
+}
+async function deleteFeatureBranches(repoPath, slug) {
+  const deleted = [];
+  const kept = [];
+  const g = git(repoPath);
+  const featureBranchName = featureBranch(slug);
+  const seg = tempBranchSlugSegment(slug);
+  const tempPrefixes = TEMP_BRANCH_PREFIXES.map((p) => `${p}${seg}/`);
+  let all;
+  try {
+    all = (await g.branchLocal()).all;
+  } catch {
+    return { deleted, kept };
+  }
+  const targets = all.filter((b) => b === featureBranchName || tempPrefixes.some((p) => b.startsWith(p)));
+  for (const branch of targets) {
+    if (await deleteBranchDetachingWorktrees(g, repoPath, branch))
+      deleted.push(branch);
+    else
+      kept.push(branch);
+  }
+  return { deleted, kept };
+}
 async function commitDocs(worktreePath, message) {
   if (!existsSync7(resolve3(worktreePath, DOCS_PATHSPEC)))
     return;
@@ -2441,9 +2486,10 @@ async function mergeFeature(project, feature) {
     return { ok: true, target };
   } catch (e) {
     if (await mergeInProgress(g)) {
+      const files = await conflictedFiles(g);
       await g.raw(["merge", "--abort"]);
       await restoreBranch(g, previous, target);
-      return { ok: false, conflict: true, target };
+      return { ok: false, conflict: true, target, files };
     }
     throw e instanceof Error ? e : new Error(errMsg(e));
   }
@@ -2455,6 +2501,15 @@ async function restoreBranch(g, previous, target) {
     await g.checkout(previous);
   } catch {}
 }
+async function conflictedFiles(g) {
+  try {
+    const out = (await g.raw(["diff", "--name-only", "--diff-filter=U"])).trim();
+    return out ? out.split(`
+`).map((s) => s.trim()).filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
 async function mergeInProgress(g) {
   try {
     await g.raw(["rev-parse", "--verify", "--quiet", "MERGE_HEAD"]);
@@ -2569,6 +2624,33 @@ var init_knowledge = __esm(() => {
   ];
 });
 
+// src/pty/end-session.ts
+function endSession(ctx, sessionId) {
+  const registry = ptyRegistry();
+  const killed = registry.kill(sessionId);
+  registry.remove(sessionId);
+  const session = markSessionEnded(ctx, sessionId);
+  if (session) {
+    releaseForSession(ctx, sessionId);
+    emit(ctx, session.featureId, {
+      type: "session.ended",
+      message: "session ended by user",
+      data: { sessionId, killed }
+    });
+  } else {
+    const existing = getSessionRow(ctx, sessionId);
+    if (!existing)
+      return { sessionId, ok: false, killed };
+  }
+  return { sessionId, ok: true, killed };
+}
+var init_end_session = __esm(() => {
+  init_sessions();
+  init_events();
+  init_waypoints();
+  init_registry();
+});
+
 // src/launcher/skills-root.ts
 import { existsSync as existsSync9 } from "fs";
 import { dirname as dirname2, join as join8, resolve as resolve5 } from "path";
@@ -3778,6 +3860,7 @@ var init_runner = __esm(() => {
 
 // src/services/features.ts
 import { desc as desc3, eq as eq7 } from "drizzle-orm";
+import { rmSync as rmSync2 } from "fs";
 async function createFeature(ctx, input) {
   const project = requireProjectById(ctx, input.projectId);
   const slug = uniqueSlug(ctx, project.id, input.title);
@@ -3790,8 +3873,7 @@ async function createFeature(ctx, input) {
     slug,
     title: input.title,
     oneLiner: input.oneLiner,
-    size: input.size,
-    mapped: input.mapped ?? false,
+    mapped: false,
     phase: "ideation",
     branch,
     baseBranch,
@@ -3874,12 +3956,21 @@ function advance(ctx, featureId) {
 }
 async function burn(ctx, featureId, opts = {}) {
   const feature = getFeatureRow(ctx, featureId);
-  const restarting = feature.phase === "implementation" && !hasActiveRun(ctx, featureId);
-  if (feature.phase !== "tickets" && !restarting) {
-    const why = feature.phase === "implementation" ? "a run is already burning this feature" : `feature must be in the tickets phase to burn (currently ${feature.phase})`;
+  const running = hasActiveRun(ctx, featureId);
+  const tickets2 = listByFeature2(ctx, featureId);
+  const pending = tickets2.filter((t) => t.status !== "done" && t.status !== "failed" && t.status !== "cancelled");
+  const restarting = feature.phase === "implementation" && !running;
+  const iterating = feature.phase === "review" && !running && pending.length >= 1;
+  if (feature.phase !== "tickets" && !restarting && !iterating) {
+    let why;
+    if (running)
+      why = "a run is already burning this feature";
+    else if (feature.phase === "review")
+      why = "no pending tickets to burn \u2014 emit fix tickets before burning from review";
+    else
+      why = `feature must be in the tickets phase to burn (currently ${feature.phase})`;
     throw new GateError(why);
   }
-  const tickets2 = listByFeature2(ctx, featureId);
   if (tickets2.filter((t) => t.status !== "cancelled").length < 1) {
     throw new GateError(tickets2.length > 0 ? "no burnable tickets \u2014 every ticket is cancelled" : "no tickets to burn");
   }
@@ -3893,6 +3984,8 @@ async function burn(ctx, featureId, opts = {}) {
       message: failed.length > 0 ? `restarting burn \u2014 retrying ${failed.length} failed ticket(s)` : "restarting burn (previous run cancelled or crashed)",
       data: { retried: failed.map((t) => t.seq) }
     });
+  } else if (iterating) {
+    setPhase(ctx, featureId, REVIEW_LOOP_BACK.to, "burn.started", "burn from review \u2014 iterating");
   } else {
     setPhase(ctx, featureId, "implementation", "burn.started", "burning tickets");
   }
@@ -3979,6 +4072,76 @@ function escalateToMap(ctx, featureId, input) {
   });
   return { ok: true };
 }
+function archiveFeature(ctx, featureId) {
+  const feature = getFeatureRow(ctx, featureId);
+  if (feature.status === "archived") {
+    throw new GateError(`feature ${feature.slug} is already archived`);
+  }
+  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();
+  emit(ctx, featureId, {
+    type: "feature.archived",
+    message: `feature ${feature.slug} archived`,
+    data: { from: feature.status }
+  });
+  return { ...feature, status: "archived" };
+}
+function unarchiveFeature(ctx, featureId) {
+  const feature = getFeatureRow(ctx, featureId);
+  if (feature.status !== "archived") {
+    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();
+  emit(ctx, featureId, {
+    type: "feature.unarchived",
+    message: `feature ${feature.slug} unarchived (${restored})`,
+    data: { status: restored }
+  });
+  return { ...feature, status: restored };
+}
+async function deleteFeature(ctx, featureId) {
+  const feature = getFeatureRow(ctx, featureId);
+  if (feature.status === "shipped") {
+    throw new GateError(`feature ${feature.slug} is shipped \u2014 archive it instead (delete is for non-shipped features)`);
+  }
+  const project = projectForFeature(ctx, feature);
+  for (const run3 of listRunsByFeature(ctx, featureId)) {
+    if (run3.status === "running")
+      cancelRun(run3.id);
+  }
+  const live = listSessionsByFeature(ctx, featureId).find((s) => s.status === "live");
+  if (live)
+    endSession(ctx, live.id);
+  if (activeTestDriveFeatureId() === featureId) {
+    await testDrive(ctx, project, feature, "stop");
+  }
+  await removeTalkWorktree(project.repoPath, worktreeDir(project.id, feature.slug));
+  await deleteFeatureBranches(project.repoPath, feature.slug);
+  emitProject(ctx, project.id, {
+    type: "feature.deleted",
+    message: `feature ${feature.slug} deleted`,
+    data: { featureId, slug: feature.slug }
+  });
+  for (const s of listSessionsByFeature(ctx, featureId)) {
+    try {
+      rmSync2(sessionDir(s.id), { recursive: true, force: true });
+    } catch {}
+  }
+  deleteFeatureRows(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();
+}
 function gateState(ctx, feature) {
   const gate = nextGate(feature);
   if (!gate)
@@ -4002,6 +4165,7 @@ function slugify(title) {
 }
 var init_features = __esm(() => {
   init_src();
+  init_paths();
   init_schema();
   init_errors();
   init_events();
@@ -4009,6 +4173,7 @@ var init_features = __esm(() => {
   init_git();
   init_knowledge();
   init_repo();
+  init_end_session();
   init_tickets();
   init_waypoints();
   init_runner();
@@ -4415,8 +4580,8 @@ 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} (size: ${feature.size}); branch: ${feature.branch}`,
-    `docs: docs/features/${feature.slug}/ (brief.md, decisions.md${feature.size === "full" ? ", spec.md" : ""})`,
+    `phase: ${feature.phase}; 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."
   ].join(`
@@ -4621,19 +4786,19 @@ function renderSystemPrompt(feature, kind, waypoint) {
     "## Feature",
     `- Slug: \`${feature.slug}\``,
     `- Branch: \`${feature.branch}\``,
-    `- Current phase: **${feature.phase}** (size: ${feature.size})`,
+    `- Current phase: **${feature.phase}**`,
     "",
     "## Pipeline",
     "Features move ideation \u2192 spec \u2192 tickets \u2192 implementation \u2192 review \u2192 shipped.",
-    "A `collapsed` feature skips the `spec` phase. Each transition is guarded by a",
-    "gate; you cross a gate by calling the `complete_phase` MCP tool, which runs",
-    "the gate check server-side and advances the feature.",
+    "Each transition is guarded by a gate; you cross a gate by calling the",
+    "`complete_phase` MCP tool, which runs the gate check server-side and advances",
+    "the feature.",
     "",
     "## Knowledge (versioned in the target repo)",
     `Feature docs live at \`${docs}/\`:`,
     `- \`${docs}/brief.md\` \u2014 the seed brief (title + one-liner).`,
     `- \`${docs}/decisions.md\` \u2014 decisions you capture while grilling (satisfies gate G1).`,
-    `- \`${docs}/spec.md\` \u2014 the spec, for \`full\` features (satisfies gate G2).`,
+    `- \`${docs}/spec.md\` \u2014 the spec (satisfies gate G2).`,
     "Write these files in THIS working directory (the feature's talk worktree);",
     "they are committed to the feature branch automatically at phase boundaries.",
     "",
@@ -4675,7 +4840,7 @@ function renderWaypointPrompt(feature, waypoint) {
     "## Feature",
     `- Slug: \`${feature.slug}\``,
     `- Branch: \`${feature.branch}\``,
-    `- Current phase: **${feature.phase}** (size: ${feature.size})`,
+    `- Current phase: **${feature.phase}**`,
     "",
     "## Map + knowledge (versioned in the target repo)",
     `Feature docs live at \`${docs}/\`:`,
@@ -4718,7 +4883,7 @@ function renderConvergePrompt(feature) {
     "## Feature",
     `- Slug: \`${feature.slug}\``,
     `- Branch: \`${feature.branch}\``,
-    `- Current phase: **${feature.phase}** (size: ${feature.size})`,
+    `- Current phase: **${feature.phase}**`,
     "",
     "## runcastle MCP tools",
     "- `get_feature_context()` \u2014 full feature + phase + docs contents (map + decisions).",
@@ -4738,6 +4903,17 @@ function renderConvergePrompt(feature) {
 }
 function renderRevisitPrompt(feature) {
   const docs = featureDocsRel(feature.slug);
+  const reviewIteration = 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",
+    "run outcome and every ticket\u2019s state via `get_feature_context`, ask what the test",
+    "drive surfaced (bugs, rough edges, tweaks), then emit fix tickets for that work and",
+    "edit/cancel any stale pending tickets. Do NOT advance the phase: once the cards are",
+    "ready, tell the human to review them and click Burn \u2014 burning from review loops the",
+    "feature back through implementation and returns it here when the run finishes.",
+    ""
+  ] : [];
   return [
     `# runcastle \u2014 ${feature.title} (revisit session)`,
     "",
@@ -4750,10 +4926,11 @@ 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.",
     "",
+    ...reviewIteration,
     "## Feature",
     `- Slug: \`${feature.slug}\``,
     `- Branch: \`${feature.branch}\``,
-    `- Current phase: **${feature.phase}** (size: ${feature.size})`,
+    `- Current phase: **${feature.phase}**`,
     "",
     "## Knowledge (versioned in the target repo)",
     `Feature docs live at \`${docs}/\`:`,
@@ -4844,33 +5021,6 @@ var init_artifacts = __esm(() => {
   ];
 });
 
-// src/pty/end-session.ts
-function endSession(ctx, sessionId) {
-  const registry = ptyRegistry();
-  const killed = registry.kill(sessionId);
-  registry.remove(sessionId);
-  const session = markSessionEnded(ctx, sessionId);
-  if (session) {
-    releaseForSession(ctx, sessionId);
-    emit(ctx, session.featureId, {
-      type: "session.ended",
-      message: "session ended by user",
-      data: { sessionId, killed }
-    });
-  } else {
-    const existing = getSessionRow(ctx, sessionId);
-    if (!existing)
-      return { sessionId, ok: false, killed };
-  }
-  return { sessionId, ok: true, killed };
-}
-var init_end_session = __esm(() => {
-  init_sessions();
-  init_events();
-  init_waypoints();
-  init_registry();
-});
-
 // src/launcher/launcher.ts
 import { existsSync as existsSync13 } from "fs";
 import { dirname as dirname5, join as join13, resolve as resolve7 } from "path";
@@ -4974,6 +5124,8 @@ async function launchSession(ctx, input, opts = {}) {
     kind: input.kind,
     worktreePath
   });
+  if (input.kickoffLine)
+    setKickoffOverride(session.id, input.kickoffLine);
   let waypoint;
   let resumeSessionId;
   let resumeUnavailableFrom;
@@ -5233,18 +5385,23 @@ var init_feature = __esm(() => {
       projectId: z6.string(),
       title: z6.string().min(1),
       oneLiner: z6.string(),
-      size: FeatureSize,
-      mapped: z6.boolean().optional(),
       baseBranch: z6.string().optional()
     })).mutation(({ ctx, input }) => createFeature(ctx, input)),
     list: publicProcedure.input(z6.object({ projectId: z6.string() })).query(({ ctx, input }) => list(ctx, input.projectId)),
     get: publicProcedure.input(z6.object({ id: z6.string() })).query(({ ctx, input }) => getFeatureFull(ctx, input.id)),
-    launchSession: publicProcedure.input(z6.object({ featureId: z6.string(), kind: SessionKind })).mutation(({ ctx, input }) => launchSession(ctx, input)),
+    launchSession: publicProcedure.input(z6.object({
+      featureId: z6.string(),
+      kind: SessionKind,
+      kickoffLine: z6.string().min(1).optional()
+    })).mutation(({ ctx, input }) => launchSession(ctx, input)),
     workWaypoint: publicProcedure.input(z6.object({ featureId: z6.string(), waypointId: z6.string() })).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 })),
     endSession: publicProcedure.input(z6.object({ sessionId: z6.string() })).mutation(({ ctx, input }) => endSession(ctx, input.sessionId)),
     advance: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => advance(ctx, input.featureId)),
     overrideGate: publicProcedure.input(z6.object({ featureId: z6.string(), gate: gateId, reason: z6.string().min(1) })).mutation(({ ctx, input }) => overrideGate(ctx, input.featureId, input.gate, input.reason)),
+    archive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => archiveFeature(ctx, input.featureId)),
+    unarchive: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => unarchiveFeature(ctx, input.featureId)),
+    delete: publicProcedure.input(z6.object({ featureId: z6.string() })).mutation(({ ctx, input }) => deleteFeature(ctx, input.featureId)),
     burn: publicProcedure.input(z6.object({ featureId: z6.string(), model: z6.string().min(1).optional() })).mutation(({ ctx, input }) => burn(ctx, input.featureId, { modelOverride: input.model })),
     testDrive: publicProcedure.input(z6.object({ featureId: z6.string(), action: z6.enum(["start", "stop"]) })).mutation(async ({ ctx, input }) => {
       const feature = getFeatureRow(ctx, input.featureId);
@@ -5266,10 +5423,10 @@ var init_feature = __esm(() => {
         emit(ctx, input.featureId, {
           type: "merge.conflict",
           message: "merge conflict \u2014 resolve and retry",
-          data: { conflict: res.conflict }
+          data: { conflict: res.conflict, base: res.target, files: res.files ?? [] }
         });
       }
-      return { ok: res.ok, conflict: res.conflict };
+      return { ok: res.ok, conflict: res.conflict, base: res.target, files: res.files ?? [] };
     })
   });
 });

package/drizzle/0008_panoramic_molecule_man.sql

@@ -0,0 +1 @@
+ALTER TABLE `features` DROP COLUMN `size`;