@osolmaz/pi-workflows 0.13.4 → 0.15.0

package/src/render/graph-render.ts

@@ -1,3 +1,4 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
 import type {
   WorkflowDefinitionSnapshot,
   WorkflowRunState,
@@ -26,6 +27,9 @@ import { nodeTypeBadge } from "./node-type.js";
 export type GraphView = {
   state: WorkflowRunState;
   snapshot: WorkflowDefinitionSnapshot | null;
+  graphScene?: GraphLayout;
+  graphSteps?: WorkflowStepRecord[];
+  takenTransitions?: string[];
 };
 
 type NodeStatus =
@@ -74,8 +78,12 @@ const STATUS_STYLES: Record<NodeStatus, CanvasStyle> = {
 const CELL_GAP = 6;
 const GUTTER_GAP = 2;
 const GRAPH_SIDE_MARGIN = 2;
-const CARD_MIN_CONTENT_WIDTH = 28;
-const CARD_DYNAMIC_RESERVE = "↻ 100  ◷ 9999d 23h 59m 59s";
+const CARD_MIN_CONTENT_WIDTH = 20;
+const CARD_MAX_CONTENT_WIDTH = 28;
+const CARD_CORE_HEIGHT = 7;
+const CARD_MAX_BRANCH_ROWS = 3;
+const CARD_WIDEST_STATUS_BADGE = "◆ replay focus";
+const CARD_PAIRED_ROW_GAP = 1;
 
 function nodeTypeStyle(nodeType: string): CanvasStyle {
   switch (nodeType) {
@@ -92,14 +100,24 @@ function nodeTypeStyle(nodeType: string): CanvasStyle {
 }
 
 function fitText(text: string, width: number): string {
-  const chars = [...text];
-  if (chars.length <= width) return text;
-  return width <= 1 ? chars.slice(0, width).join("") : `${chars.slice(0, width - 1).join("")}…`;
+  if (visibleWidth(text) <= width) return text;
+  if (width <= 0) return "";
+  const ellipsis = "…";
+  const available = Math.max(0, width - visibleWidth(ellipsis));
+  let fitted = "";
+  let used = 0;
+  for (const char of text) {
+    const charWidth = visibleWidth(char);
+    if (used + charWidth > available) break;
+    fitted += char;
+    used += charWidth;
+  }
+  return `${fitted}${ellipsis}`;
 }
 
 function centeredText(text: string, width: number): string {
   const fitted = fitText(text, width);
-  const left = Math.max(0, Math.floor((width - [...fitted].length) / 2));
+  const left = Math.max(0, Math.floor((width - visibleWidth(fitted)) / 2));
   return `${" ".repeat(left)}${fitted}`;
 }
 
@@ -110,15 +128,13 @@ export type GraphRenderOptions = {
   nodeStyle?: GraphNodeStyle;
 };
 
-type CardMetrics = {
+type CardShape = {
   width: number;
   height: number;
-  contentWidth: number;
-  branchRows: number;
 };
 
-function cellHeight(nodeStyle: GraphNodeStyle, boxHeight: number): number {
-  return nodeStyle === "box" ? boxHeight : 1;
+function cellHeight(nodeStyle: GraphNodeStyle, cell: RenderedCell): number {
+  return nodeStyle === "box" ? cell.height : 1;
 }
 
 function paint(text: string, style: CanvasStyle): string {
@@ -201,39 +217,66 @@ function nodeBranchLabels(view: GraphView, nodeId: string): string[] {
   ).map(sanitizeText);
 }
 
-function cardMetrics(view: GraphView): CardMetrics {
-  const snapshot = view.snapshot;
-  if (!snapshot) {
-    return { width: CARD_MIN_CONTENT_WIDTH + 4, height: 7, contentWidth: 24, branchRows: 0 };
-  }
-  let contentWidth = CARD_MIN_CONTENT_WIDTH;
-  let branchRows = 0;
-  const measure = (text: string) => {
-    contentWidth = Math.max(contentWidth, text.length);
-  };
-  measure(CARD_DYNAMIC_RESERVE);
-  for (const status of Object.keys(STATUS_LABELS) as NodeStatus[]) {
-    measure(`${nodeTypeBadge("checkpoint")}  ${STATUS_GLYPHS[status]} ${STATUS_LABELS[status]}`);
-  }
-  for (const [nodeId, node] of Object.entries(snapshot.nodes)) {
-    measure(sanitizeText(hierarchicalNodeLabel(nodeId, node)));
-    measure(nodeTypeBadge(node.nodeType, node.actionExecution));
-    const labels = nodeBranchLabels(view, nodeId);
-    branchRows = Math.max(branchRows, labels.length);
-    for (const label of labels) measure(`◇ ${label}`);
-  }
+function cardShape(view: GraphView, nodeId: string): CardShape {
+  const node = view.snapshot?.nodes[nodeId];
+  const labels = nodeBranchLabels(view, nodeId);
+  const branchRows = Math.min(labels.length, CARD_MAX_BRANCH_ROWS);
+  const actionExecution = "actionExecution" in (node ?? {}) ? node?.actionExecution : undefined;
+  const humanAudience = node && "humanDecision" in node ? node.humanDecision.audience : undefined;
+  const configuredDetail = node?.statusDetail ?? node?.summary;
+  const assistantDetail =
+    node?.nodeType === "agent" &&
+    typeof node.expectedOutput === "object" &&
+    node.expectedOutput.kind === "assistant-message"
+      ? "assistant response"
+      : undefined;
+  const cardDetail = [assistantDetail, configuredDetail].filter(Boolean).join(" · ");
+  const typeBadge = node ? nodeTypeBadge(node.nodeType, actionExecution) : "? unknown";
+  const candidates = [
+    hierarchicalNodeLabel(nodeId, node),
+    typeBadge,
+    `${typeBadge} ${CARD_WIDEST_STATUS_BADGE}`,
+    ...(humanAudience === undefined ? [] : [`… human decision · ${humanAudience}`]),
+    ...(cardDetail === "" ? [] : [`… ${cardDetail}`]),
+    ...boundedBranchLines(labels),
+  ];
+  const desiredWidth = Math.max(...candidates.map(visibleWidth));
+  const contentWidth = Math.max(
+    CARD_MIN_CONTENT_WIDTH,
+    Math.min(CARD_MAX_CONTENT_WIDTH, desiredWidth),
+  );
   return {
     width: contentWidth + 4,
-    height: 7 + branchRows,
-    contentWidth,
-    branchRows,
+    height: CARD_CORE_HEIGHT + branchRows,
   };
 }
 
-/** Canonical outer dimensions shared by every full card in this graph. */
-export function graphCardSize(view: GraphView): { width: number; height: number } {
-  const { width, height } = cardMetrics(view);
-  return { width, height };
+/** Canonical bounded outer dimensions for one boxed node card. */
+export function graphCardSize(view: GraphView, nodeId: string): { width: number; height: number } {
+  return cardShape(view, nodeId);
+}
+
+function boundedNodeLabel(
+  nodeId: string,
+  node: WorkflowDefinitionSnapshot["nodes"][string] | undefined,
+  contentWidth: number,
+): string {
+  const full = hierarchicalNodeLabel(nodeId, node);
+  if (visibleWidth(full) <= contentWidth) return full;
+  const local = sanitizeText(node?.localNodeId ?? nodeId);
+  const suffix =
+    node?.includeTransition === "entry"
+      ? "enter"
+      : node?.includeTransition === "exit"
+        ? `${local} exit`
+        : local;
+  const candidate = `… › ${suffix}`;
+  return visibleWidth(candidate) <= contentWidth ? candidate : fitText(suffix, contentWidth);
+}
+
+function boundedBranchLines(labels: string[]): string[] {
+  if (labels.length <= CARD_MAX_BRANCH_ROWS) return labels.map((label) => `◇ ${label}`);
+  return [`◇ ${labels[0]}`, `◇ ${labels[1]}`, `+${labels.length - 2} branches`];
 }
 
 type RenderedCell = {
@@ -250,6 +293,7 @@ type RenderedCell = {
   isStart: boolean;
   isEnd: boolean;
   width: number;
+  height: number;
 };
 
 function renderCellText(
@@ -259,7 +303,7 @@ function renderCellText(
   atLatestStep: boolean,
   now: Date,
   nodeStyle: GraphNodeStyle,
-  metrics: CardMetrics,
+  shape: CardShape,
 ): RenderedCell {
   if (cell.kind === "virtual") {
     return {
@@ -276,6 +320,7 @@ function renderCellText(
       isStart: false,
       isEnd: false,
       width: 1,
+      height: 1,
     };
   }
   const state = view.state;
@@ -330,13 +375,7 @@ function renderCellText(
     human === undefined
       ? undefined
       : state.waitingOn === nodeId
-        ? `human decision · ${sanitizeText(typeof waitingRequest?.audience === "string" ? waitingRequest.audience : human.audience)}${typeof waitingRequest?.presentation?.summary === "string" ? ` · ${sanitizeText(waitingRequest.presentation.summary)}` : ""} · ${Object.values(
-            human.choices,
-          )
-            .map((choice) => sanitizeText(choice.label))
-            .join(
-              " / ",
-            )}${typeof waitingRequest?.presentationDigest === "string" ? ` · ${waitingRequest.presentationDigest.slice(7, 19)}` : ""}`
+        ? `human decision · ${sanitizeText(typeof waitingRequest?.audience === "string" ? waitingRequest.audience : human.audience)}`
         : selected !== undefined
           ? `human: ${sanitizeText(selected.label)}`
           : undefined;
@@ -356,13 +395,11 @@ function renderCellText(
       : "";
   const nodeDetail = [assistantDetail, configuredDetail].filter(Boolean).join(" · ");
   const detail = humanDetail ?? nodeDetail;
-  const branchLines = Array.from({ length: metrics.branchRows }, (_, index) =>
-    labels[index] ? `◇ ${labels[index]}` : "",
-  );
+  const branchLines = boundedBranchLines(labels);
   const count = atLatestStep && state.currentNode === nodeId ? Math.max(attempts, 1) : attempts;
   const timing =
     attempt || count > 0 ? `${count} attempt${count === 1 ? "" : "s"} · ${elapsed}` : "not visited";
-  const displayNodeId = hierarchicalNodeLabel(nodeId, node);
+  const displayNodeId = boundedNodeLabel(nodeId, node, shape.width - 4);
   const text = `${displayNodeId} [${nodeType}] ${timing}`;
   return {
     cell,
@@ -377,7 +414,8 @@ function renderCellText(
     branchLines,
     isStart,
     isEnd,
-    width: nodeStyle === "box" ? metrics.width : text.length + 2,
+    width: nodeStyle === "box" ? shape.width : visibleWidth(text) + 2,
+    height: nodeStyle === "box" ? shape.height : 1,
   };
 }
 
@@ -397,12 +435,13 @@ type RankGeometry = {
   centers: number[];
 };
 
-type PlacedRank = RankGeometry & { y: number };
+type PlacedRank = RankGeometry & { y: number; height: number };
 
 /** A strip segment with final pixel geometry and its assigned track row. */
 type GeomSegment = {
   edgeId: string;
   label?: string | undefined;
+  fromCell: number;
   fromX: number;
   toX: number;
   track: number;
@@ -441,18 +480,26 @@ export function renderGraphLines(
     return [];
   }
   const nodeStyle = options.nodeStyle ?? "line";
-  const metrics = cardMetrics(view);
-  const layout = layoutGraph(snapshot);
-  const steps = view.state.steps;
+  const layout = view.graphScene ?? layoutGraph(snapshot);
+  const stateSteps = view.state.steps;
+  const steps = view.graphSteps ?? stateSteps;
   const boundedIndex = Math.min(Math.max(selectedStepIndex, -1), steps.length - 1);
   const atLatestStep = boundedIndex >= steps.length - 1;
   const visibleSteps = steps.slice(0, boundedIndex + 1);
-  const transitions = takenTransitions(visibleSteps);
+  const transitions = new Set(view.takenTransitions ?? takenTransitions(visibleSteps));
   const activePair = derivePairInFlight(view, visibleSteps, atLatestStep);
 
   const rendered = layout.ranks.map((rank) =>
     rank.map((cell) =>
-      renderCellText(view, cell, visibleSteps, atLatestStep, now, nodeStyle, metrics),
+      renderCellText(
+        view,
+        cell,
+        visibleSteps,
+        atLatestStep,
+        now,
+        nodeStyle,
+        cell.kind === "node" ? cardShape(view, cell.nodeId) : { width: 1, height: 1 },
+      ),
     ),
   );
 
@@ -489,16 +536,17 @@ export function renderGraphLines(
   const topLanes = lanes.above(0).length;
   let y = topLanes > 0 ? topLanes + 1 : 0;
   for (const [rankIndex, rank] of geometry.entries()) {
-    placed.push({ ...rank, y });
+    const height = Math.max(1, ...rank.cells.map((cell) => cellHeight(nodeStyle, cell)));
+    placed.push({ ...rank, y, height });
     y +=
-      cellHeight(nodeStyle, metrics.height) +
+      height +
       lanes.below(rankIndex).length +
       gapRows(strips[rankIndex] as StripGeometry, rankIndex, layout.ranks.length) +
       lanes.above(rankIndex + 1).length;
   }
 
   const canvas = new CharCanvas();
-  drawNodes(canvas, placed, layout, transitions, nodeStyle, metrics.height);
+  drawNodes(canvas, placed, layout, transitions, nodeStyle);
   const labels = drawSegments(
     canvas,
     placed,
@@ -508,10 +556,9 @@ export function renderGraphLines(
     activePair,
     graphWidth,
     nodeStyle,
-    metrics.height,
     lanes,
   );
-  drawBackEdges(canvas, placed, layout, transitions, graphWidth, nodeStyle, metrics.height, lanes);
+  drawBackEdges(canvas, placed, layout, transitions, graphWidth, lanes);
   // Labels go on last, once every line is on the canvas: placement can then
   // guarantee no later stroke crosses through a label.
   for (const label of labels) {
@@ -610,7 +657,14 @@ function computeStripGeometry(
     if (targetIsNode && Math.abs(toX - fromX) <= 1) {
       toX = fromX;
     }
-    return { edgeId: segment.edgeId, label: segment.label, fromX, toX, targetIsNode };
+    return {
+      edgeId: segment.edgeId,
+      label: segment.label,
+      fromCell: segment.fromCell,
+      fromX,
+      toX,
+      targetIsNode,
+    };
   });
 
   // First-fit track assignment over pixel spans; straight unlabeled
@@ -697,7 +751,6 @@ function drawNodes(
   layout: GraphLayout,
   transitions: Set<string>,
   nodeStyle: GraphNodeStyle,
-  boxHeight: number,
 ): void {
   for (const rank of placed) {
     for (const [index, rendered] of rank.cells.entries()) {
@@ -708,12 +761,7 @@ function drawNodes(
         const taken = edge ? transitions.has(`${edge.from}->${edge.to}`) : false;
         // Pass-through cells span the full cell height so the edge stays
         // visually continuous across the rank row(s).
-        canvas.vline(
-          center,
-          rank.y,
-          rank.y + cellHeight(nodeStyle, boxHeight) - 1,
-          taken ? "taken" : "dim",
-        );
+        canvas.vline(center, rank.y, rank.y + rank.height - 1, taken ? "taken" : "dim");
         continue;
       }
       const status = rendered.status ?? "queued";
@@ -765,9 +813,13 @@ function drawNodeBox(
     rightStyle: CanvasStyle,
   ) => {
     rowBorder(row);
-    canvas.text(startX + 2, row, fitText(left, innerWidth - 2), leftStyle);
-    const rightText = fitText(right, innerWidth - 2);
-    canvas.text(rightX - 1 - [...rightText].length, row, rightText, rightStyle);
+    const contentWidth = Math.max(0, innerWidth - 2);
+    const rightText = fitText(right, contentWidth);
+    const rightWidth = visibleWidth(rightText);
+    const gap = left === "" || rightText === "" ? 0 : CARD_PAIRED_ROW_GAP;
+    const leftText = fitText(left, Math.max(0, contentWidth - rightWidth - gap));
+    canvas.text(startX + 2, row, leftText, leftStyle);
+    canvas.text(startX + 2 + contentWidth - rightWidth, row, rightText, rightStyle);
   };
 
   canvas.text(startX, y, `${chars.tl}${horizontal}${chars.tr}`, borderStyle);
@@ -825,7 +877,6 @@ function drawSegments(
   activePair: string | null,
   graphWidth: number,
   nodeStyle: GraphNodeStyle,
-  boxHeight: number,
   lanes: BackEdgeLanes,
 ): PendingLabel[] {
   const labels: PendingLabel[] = [];
@@ -839,11 +890,13 @@ function drawSegments(
     // Forward lines start right below the source cell, cross any back-edge
     // lane rows (as ┼ crossings), run their strip tracks, then cross the
     // entry lanes to the arrow row directly above the target cell.
-    const stubTop = top.y + cellHeight(nodeStyle, boxHeight);
-    const stripTop = stubTop + lanes.below(rank).length;
+    const stripTop = top.y + top.height + lanes.below(rank).length;
     const arrowY = bottom.y - 1;
     const stripBottom = arrowY - 1 - lanes.above(rank + 1).length;
     for (const segment of strip.segments) {
+      const source = top.cells[segment.fromCell];
+      const stubTop =
+        source?.cell.kind === "node" ? top.y + cellHeight(nodeStyle, source) : top.y + top.height;
       const edge = layout.edges.find((candidate) => candidate.edgeId === segment.edgeId);
       if (!edge) {
         continue;
@@ -906,23 +959,25 @@ function drawSegmentLabel(canvas: CharCanvas, label: PendingLabel): void {
   if (fromX !== toX) {
     const runStart = Math.min(fromX, toX) + 1;
     const runEnd = Math.max(fromX, toX) - 1;
-    const center = Math.floor((runStart + runEnd) / 2) - Math.floor(padded.length / 2);
+    const paddedWidth = visibleWidth(padded);
+    const center = Math.floor((runStart + runEnd) / 2) - Math.floor(paddedWidth / 2);
     if (
-      runEnd - runStart + 1 >= padded.length + 2 &&
+      runEnd - runStart + 1 >= paddedWidth + 2 &&
       canvas.textOverRun(center, trackY, padded, style)
     ) {
       return;
     }
   }
+  const textWidth = visibleWidth(text);
   const candidates: [number, number][] =
     toX >= Math.floor(graphWidth / 2)
       ? [
-          [toX - text.length - 1, labelRow],
+          [toX - textWidth - 1, labelRow],
           [toX + 2, labelRow],
         ]
       : [
           [toX + 2, labelRow],
-          [toX - text.length - 1, labelRow],
+          [toX - textWidth - 1, labelRow],
         ];
   for (const [x, y] of candidates) {
     if (canvas.textIfEmpty(x, y, text, style)) {
@@ -946,8 +1001,6 @@ function drawBackEdges(
   layout: GraphLayout,
   transitions: Set<string>,
   graphWidth: number,
-  nodeStyle: GraphNodeStyle,
-  boxHeight: number,
   lanes: BackEdgeLanes,
 ): void {
   let gutterX = graphWidth + GUTTER_GAP;
@@ -965,14 +1018,16 @@ function drawBackEdges(
       continue;
     }
     const style: CanvasStyle = transitions.has(`${edge.from}->${edge.to}`) ? "taken" : "back";
-    const exitLaneY = from.y + cellHeight(nodeStyle, boxHeight) + exit.lane;
+    const exitLaneY = from.y + from.height + exit.lane;
     const aboveCount = lanes.above(toRank).length;
     const arrowY = to.y - 1;
     const entryLaneY = arrowY - aboveCount + entry.lane;
 
-    // Downward stub out of the source cell, then right along the exit lane.
-    if (exitLaneY > from.y + cellHeight(nodeStyle, boxHeight)) {
-      canvas.vline(exit.x, from.y + cellHeight(nodeStyle, boxHeight), exitLaneY - 1, style);
+    // Downward stub out of the source cell, through any rank padding, then
+    // right below the tallest card. A short card must not route an edge
+    // through a taller card in the same rank.
+    if (exitLaneY > from.y + exit.height) {
+      canvas.vline(exit.x, from.y + exit.height, exitLaneY - 1, style);
     }
     canvas.put(exit.x, exitLaneY, "└", style);
     canvas.hline(exitLaneY, exit.x + 1, gutterX - 1, style);
@@ -992,7 +1047,7 @@ function drawBackEdges(
       canvas.text(gutterX + 2, entryLaneY, edge.label, style);
     }
     // Reserve horizontal room for this gutter and its label before the next.
-    gutterX += 2 + (edge.label === undefined ? 0 : edge.label.length + 1);
+    gutterX += 2 + (edge.label === undefined ? 0 : visibleWidth(edge.label) + 1);
   }
 }
 
@@ -1006,7 +1061,7 @@ function cellAnchor(
   nodeId: string,
   laneEdges: GraphEdge[],
   edge: GraphEdge,
-): { x: number; lane: number } | null {
+): { x: number; lane: number; height: number } | null {
   const index = rank.cells.findIndex(
     (cell) => cell.cell.kind === "node" && cell.cell.nodeId === nodeId,
   );
@@ -1017,5 +1072,5 @@ function cellAnchor(
   const cell = rank.cells[index] as RenderedCell;
   const center = rank.centers[index] as number;
   const rightmost = center + Math.floor(cell.width / 2) - 1;
-  return { x: Math.min(center + 2 + lane * 2, rightmost), lane };
+  return { x: Math.min(center + 2 + lane * 2, rightmost), lane, height: cell.height };
 }

package/src/state/database.ts

@@ -17,7 +17,7 @@ const DATABASE_FILE = "state.sqlite";
 const BUSY_TIMEOUT_MS = 5_000;
 const JOURNAL_SIZE_LIMIT = 64 * 1024 * 1024;
 const RESET_INSTRUCTION =
-  "Pi Workflows durable state is incompatible. Move or remove the old workflow state, then create a new state.sqlite database.";
+  "Pi Workflows durable state is incompatible. Back up and move state.sqlite with its -wal and -shm files, then start Pi Workflows to create a new state.sqlite database. The incompatible state was not changed.";
 
 export type StateDatabaseMode = "read-write" | "read-only";
 
@@ -114,6 +114,7 @@ export class StateDatabase {
     if (this.mode === "read-only") {
       throw new Error("Cannot mutate a read-only Pi Workflows database");
     }
+    if (this.connection.inTransaction) return operation();
     this.connection.exec("BEGIN IMMEDIATE");
     try {
       const result = operation();

package/src/state/index.ts

@@ -19,6 +19,20 @@ export {
   type ResourceType,
   type WritePermit,
 } from "./mutation.js";
+export {
+  VIEWER_DELTA_RETENTION,
+  VIEWER_PAGE_SIZE,
+  initializeViewerRun,
+  readViewerDeltas,
+  recordViewerDeltas,
+  viewerTailPatch,
+  type ViewerCursorResult,
+  type ViewerDeltaDraft,
+  type ViewerDeltaRecord,
+  type ViewerPatchOperation,
+  type ViewerTailItem,
+  type ViewerTargetType,
+} from "./viewer.js";
 export {
   STATE_APPLICATION_ID,
   STATE_APP_VERSION,

package/src/state/prune.ts

@@ -10,6 +10,7 @@ const UNSETTLED_EFFECT_STATUSES = ["pending", "applying", "ambiguous"];
 type RunAgeRow = {
   runId: string;
   parentRunId: string | null;
+  launchOptionsHash: Buffer;
   status: string;
   finishedAt: number | null;
 };
@@ -52,7 +53,7 @@ export async function pruneState(
       filePath: databasePath,
       mode: options.apply ? "read-write" : "read-only",
     });
-    const selection = selectRunTrees(state.connection, cutoff);
+    const selection = selectRunTrees(state, cutoff);
     const sizeBefore = databaseBytes(databasePath);
     const base = {
       cutoff: new Date(cutoff).toISOString(),
@@ -83,7 +84,7 @@ export async function pruneState(
     let deletedBlobBytes = 0;
     state.connection.exec("BEGIN EXCLUSIVE");
     try {
-      const checked = selectRunTrees(state.connection, cutoff);
+      const checked = selectRunTrees(state, cutoff);
       if (
         checked.runIds.join("\0") !== selection.runIds.join("\0") ||
         checked.signature !== selection.signature
@@ -141,12 +142,14 @@ export async function pruneState(
 }
 
 function selectRunTrees(
-  database: Database.Database,
+  state: StateDatabase,
   cutoff: number,
 ): { candidateTrees: number; blockedTrees: number; runIds: string[]; signature: string } {
+  const { connection: database } = state;
   const rows = database
     .prepare(
-      `SELECT run_id AS runId, parent_run_id AS parentRunId, status, finished_at AS finishedAt
+      `SELECT run_id AS runId, parent_run_id AS parentRunId,
+              launch_options_hash AS launchOptionsHash, status, finished_at AS finishedAt
        FROM runs ORDER BY created_at, run_id`,
     )
     .all()
@@ -162,15 +165,25 @@ function selectRunTrees(
       .map((row) => row.runId),
   );
   const children = new Map<string, string[]>();
+  const parents = new Map<string, string[]>();
   for (const row of rows) {
-    if (row.parentRunId === null) continue;
-    const values = children.get(row.parentRunId) ?? [];
-    values.push(row.runId);
-    children.set(row.parentRunId, values);
+    const runParents = new Set<string>();
+    if (row.parentRunId !== null) runParents.add(row.parentRunId);
+    const restartParentRunId = restartParentFromLaunchOptions(
+      state.readJson(row.launchOptionsHash),
+    );
+    if (restartParentRunId !== null) runParents.add(restartParentRunId);
+    parents.set(row.runId, [...runParents]);
+    for (const parentRunId of runParents) {
+      const values = children.get(parentRunId) ?? [];
+      values.push(row.runId);
+      children.set(parentRunId, values);
+    }
   }
   const roots = rows.filter(
     (row) =>
-      eligible.has(row.runId) && (row.parentRunId === null || !eligible.has(row.parentRunId)),
+      eligible.has(row.runId) &&
+      (parents.get(row.runId) ?? []).every((parentRunId) => !eligible.has(parentRunId)),
   );
   const selected = new Set<string>();
   let blockedTrees = 0;
@@ -407,15 +420,28 @@ function blobReferencePredicate(database: Database.Database): string {
 
 function descendants(root: string, children: Map<string, string[]>): string[] {
   const result: string[] = [];
+  const seen = new Set<string>();
   const pending = [root];
   while (pending.length !== 0) {
     const runId = pending.pop() as string;
+    if (seen.has(runId)) continue;
+    seen.add(runId);
     result.push(runId);
     pending.push(...(children.get(runId) ?? []));
   }
   return result;
 }
 
+function restartParentFromLaunchOptions(value: unknown): string | null {
+  if (!isRecord(value)) throw new Error("Stored workflow launch options are invalid");
+  const lineage = value.restartLineage;
+  if (lineage === undefined) return null;
+  if (!isRecord(lineage) || typeof lineage.parentRunId !== "string") {
+    throw new Error("Stored workflow restart lineage is invalid");
+  }
+  return lineage.parentRunId;
+}
+
 function parseCutoff(value: string): number {
   const cutoff = Date.parse(value);
   if (!Number.isFinite(cutoff)) throw new Error("state prune --before requires a valid timestamp");