runcastle 1.0.14 → 1.0.16

package/index.js

@@ -185,7 +185,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",
@@ -195,11 +195,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(),
@@ -252,7 +251,6 @@ var init_schemas = __esm(() => {
     slug: z2.string(),
     title: z2.string(),
     oneLiner: z2.string(),
-    size: FeatureSize,
     mapped: z2.boolean(),
     phase: Phase,
     branch: z2.string(),
@@ -378,11 +376,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);
@@ -393,7 +387,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" },
@@ -409,7 +403,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"
       }
     },
@@ -439,6 +433,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",
@@ -466,7 +461,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(),
@@ -1194,7 +1188,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,
@@ -1515,15 +1508,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())
@@ -1534,10 +1532,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);
@@ -1546,19 +1546,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);
 }
@@ -1570,7 +1571,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();
@@ -1579,6 +1580,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
@@ -1807,8 +1816,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;
@@ -2325,6 +2332,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;
@@ -2440,9 +2485,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));
   }
@@ -2454,6 +2500,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"]);
@@ -2568,6 +2623,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";
@@ -3777,6 +3859,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);
@@ -3789,8 +3872,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,
@@ -3873,12 +3955,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");
   }
@@ -3892,6 +3983,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");
   }
@@ -3978,6 +4071,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)
@@ -4001,6 +4164,7 @@ function slugify(title) {
 }
 var init_features = __esm(() => {
   init_src();
+  init_paths();
   init_schema();
   init_errors();
   init_events();
@@ -4008,6 +4172,7 @@ var init_features = __esm(() => {
   init_git();
   init_knowledge();
   init_repo();
+  init_end_session();
   init_tickets();
   init_waypoints();
   init_runner();
@@ -4414,8 +4579,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(`
@@ -4620,19 +4785,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.",
     "",
@@ -4674,7 +4839,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}/\`:`,
@@ -4717,7 +4882,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).",
@@ -4737,6 +4902,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)`,
     "",
@@ -4749,10 +4925,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}/\`:`,
@@ -4843,33 +5020,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";
@@ -4973,6 +5123,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;
@@ -5232,18 +5384,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);
@@ -5265,10 +5422,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcastle",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Burn tickets into shipped features with Claude Code.",
   "license": "MIT",
   "type": "module",

package/skills/packs/README.md

@@ -9,7 +9,7 @@ Four phase-scoped skills, each namespaced `/runcastle:<skill>`:
 | Skill | Invoked | Does |
 |---|---|---|
 | `/runcastle:ideate` | entry for `kind=ideation` | grills the human, locks decisions incrementally, drives spec + tickets out of one unbroken window |
-| `/runcastle:spec` | by ideate (size=full) | synthesizes `spec.md`, completes the `spec` phase |
+| `/runcastle:spec` | by ideate | synthesizes `spec.md`, completes the `spec` phase |
 | `/runcastle:tickets` | by ideate | emits tracer-bullet tickets via MCP, completes the `tickets` phase |
 | `/runcastle:qa` | entry for `kind=qa` | read-only Q&A over an existing feature; never advances phases |
 

package/skills/packs/runcastle/skills/converge/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: false
 
 # Converge — close a mapped feature
 
-A mapped feature was too big for one window, so it was charted into a map and its waypoints were worked in their own sessions. Every waypoint is now terminal, the human clicked **Converge**, and the feature has already crossed G1 into the `spec` phase (or `tickets` for a `collapsed` feature). Your job: turn the compressed knowledge into a spec and tickets — the exact output an unbroken ideation session produces.
+A mapped feature was too big for one window, so it was charted into a map and its waypoints were worked in their own sessions. Every waypoint is now terminal, the human clicked **Converge**, and the feature has already crossed G1 into the `spec` phase. Your job: turn the compressed knowledge into a spec and tickets — the exact output an unbroken ideation session produces.
 
 ## Context hygiene is the whole game
 
@@ -15,19 +15,16 @@ Everything happens in this one window. **Never compact. Never `/clear`. Never su
 
 ## 0. Read ONLY the compressed knowledge
 
-1. Call `mcp__runcastle__get_feature_context`. It returns the feature (`slug`, `title`, `oneLiner`, `size`), current `phase`, and the docs on disk.
+1. Call `mcp__runcastle__get_feature_context`. It returns the feature (`slug`, `title`, `oneLiner`), current `phase`, and the docs on disk.
 2. Read **only** these two files under `docs/features/<slug>/`:
    - `map.md` — the destination, notes, and out-of-scope decisions.
    - `decisions.md` — every decision the waypoint sessions locked.
    **Do NOT read the waypoint session transcripts.** The map and decisions are the compression; trust them. If a decision is genuinely missing you may check the codebase for a *fact*, but never re-grill the human and never reopen a resolved waypoint — converge, do not re-ideate.
 3. `mcp__runcastle__record_event({ type: "converge.started", message: "<feature title>" })`.
 
-## 1. Size branch — run the pipeline in this window
+## 1. Run the pipeline in this window
 
-Read `feature.size` from step 0:
-
-- **`full`** → invoke `/runcastle:spec` (it writes `spec.md` and completes the `spec` phase); when it returns, invoke `/runcastle:tickets`.
-- **`collapsed`** → skip spec entirely; invoke `/runcastle:tickets` directly (it works from `decisions.md` + `map.md`).
+Invoke `/runcastle:spec` (it writes `spec.md` and completes the `spec` phase); when it returns, invoke `/runcastle:tickets`.
 
 **Re-convergence** — you may be a fresh session continuing a converge that crashed
 or was closed mid-way (the feature is past G1 but has no tickets). Pick up from
@@ -37,8 +34,7 @@ whatever already exists on disk:
   rewrite it, and proceed straight to `/runcastle:tickets`. (If the current
   `phase` is still `spec`, call `complete_phase` for spec first — the spec work
   is already done.)
-- If it does not exist (or the feature is `collapsed`), run the size branch
-  above as normal.
+- If it does not exist, run `/runcastle:spec` then `/runcastle:tickets` as normal.
 
 Do not open a new session for these. They run here, on top of the compressed knowledge you just read.