runcastle 1.2.0 → 1.2.2

package/drizzle/meta/_journal.json

@@ -127,6 +127,13 @@
       "when": 1785745839500,
       "tag": "0017_certain_ezekiel_stane",
       "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "6",
+      "when": 1786021663891,
+      "tag": "0018_nice_lorna_dane",
+      "breakpoints": true
     }
   ]
 }

package/index.js

@@ -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, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, 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",
@@ -559,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(),
@@ -631,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(),
@@ -693,6 +714,7 @@ var init_schema = __esm(() => {
     features,
     sessions,
     tickets,
+    testNotes,
     waypoints,
     runs,
     events,
@@ -1773,6 +1795,7 @@ var init_waypoints = __esm(() => {
 });
 
 // src/pty/dev-pane.ts
+import { execFileSync } from "child_process";
 function drivePaneId(ownerId) {
   return `${DRIVE_PREFIX}${ownerId}`;
 }
@@ -1832,14 +1855,20 @@ function devPaneLive(paneId) {
   const entry = ptyRegistry().get(paneId);
   return !!entry && !entry.exited;
 }
+function killProcessTree(pid) {
+  try {
+    if (process.platform === "win32") {
+      execFileSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } else {
+      process.kill(-pid, "SIGTERM");
+    }
+  } catch {}
+}
 function stopDevPane(paneId) {
   const reg = ptyRegistry();
   const entry = reg.get(paneId);
-  if (entry && !entry.exited && process.platform !== "win32") {
-    try {
-      process.kill(-entry.pty.pid, "SIGTERM");
-    } catch {}
-  }
+  if (entry && !entry.exited)
+    killProcessTree(entry.pty.pid);
   reg.kill(paneId);
   reg.remove(paneId);
 }
@@ -9345,8 +9374,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();
@@ -9355,8 +9564,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);
@@ -9366,13 +9575,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);
@@ -9392,12 +9601,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,
@@ -9407,14 +9618,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq14 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq14(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(eq14(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)) {

package/package.json

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