@osolmaz/pi-workflows 0.15.3 → 0.16.1

package/src/workflows/store.ts

@@ -7,7 +7,6 @@ import {
   resourceIdFor,
   tokenHash,
   type ActorType,
-  type LeaseClaim,
   type MutationActor,
   type OwnerType,
 } from "../state/mutation.js";
@@ -18,6 +17,7 @@ import {
   VIEWER_PAGE_SIZE,
   type ViewerDeltaDraft,
 } from "../state/viewer.js";
+import { WorkflowMessageStore, workflowMessageIdFor } from "../state/workflow-messages.js";
 import { compositionMetadata } from "./composition.js";
 import { ClaimLostError } from "./errors.js";
 import { HumanDecisionStore } from "./human-decision.js";
@@ -34,7 +34,6 @@ import {
   type WorkflowFollowUpQueueRecord,
   type WorkflowFollowUpRecord,
   type WorkflowFollowUpState,
-  type WorkflowPresentationState,
   type WorkflowQueueFollowUpRequest,
   type WorkflowRemoveFollowUpRequest,
   type WorkflowSettingsChangeRecord,
@@ -70,6 +69,7 @@ import type {
   WorkflowUpdateRecord,
 } from "./types.js";
 import { MAX_CURRENT_UPDATES, createUpdateId, updateProjection } from "./updates.js";
+import { followUpWorkflowMessageContent } from "./workflow-message-content.js";
 
 export const RUN_STATE_SCHEMA = "pi-workflows.run-state.v1" as const;
 export const DEFINITION_SNAPSHOT_SCHEMA = "pi-workflows.definition-snapshot.v1" as const;
@@ -78,16 +78,43 @@ export const SESSION_EVENT_SCHEMA = "pi-workflows.session-event.v1" as const;
 export const SESSION_CAPTURE_SCHEMA = "pi-workflows.session-capture.v1" as const;
 export const SESSION_EVENT_MAX_BYTES = 1024 * 1024;
 
+const STEP_ROW_SELECT = `
+  SELECT s.step_index AS stepIndex, a.attempt_id AS attemptId, a.node_id AS nodeId,
+         a.node_type AS nodeType, a.status,
+         a.prompt_hash AS promptHash, a.output_hash AS outputHash,
+         s.output_override_hash AS outputOverrideHash,
+         a.receipt_hash AS receiptHash, a.error_hash AS errorHash,
+         prompt_entry.entry_hash AS promptEntryHash,
+         response_entry.entry_hash AS responseEntryHash,
+         first_link.entry_id AS firstEntryId, last_link.entry_id AS lastEntryId,
+         a.settings_scope_id AS settingsScopeId,
+         a.settings_change_number AS settingsChangeNumber,
+         a.settings_hash AS settingsHash,
+         a.started_at AS startedAt, a.finished_at AS finishedAt
+  FROM run_steps s
+  JOIN node_attempts a ON a.attempt_id = s.attempt_id
+  LEFT JOIN attempt_entries prompt_link
+    ON prompt_link.attempt_id = a.attempt_id AND prompt_link.role = 'prompt'
+  LEFT JOIN session_entries prompt_entry
+    ON prompt_entry.segment_id = prompt_link.segment_id
+   AND prompt_entry.entry_id = prompt_link.entry_id
+  LEFT JOIN attempt_entries response_link
+    ON response_link.attempt_id = a.attempt_id AND response_link.role = 'response'
+  LEFT JOIN session_entries response_entry
+    ON response_entry.segment_id = response_link.segment_id
+   AND response_entry.entry_id = response_link.entry_id
+  LEFT JOIN attempt_entries first_link
+    ON first_link.attempt_id = a.attempt_id AND first_link.role = 'first'
+  LEFT JOIN attempt_entries last_link
+    ON last_link.attempt_id = a.attempt_id AND last_link.role = 'last'`;
+
 const FOLLOW_UP_ROW_SELECT = `
   SELECT f.follow_up_id AS followUpId, f.resource_id AS resourceId,
-         f.queue_resource_id AS queueResourceId, f.run_id AS runId,
-         f.request_id AS requestId, f.order_number AS orderNumber,
+         f.run_id AS runId, f.request_id AS requestId, f.order_number AS orderNumber,
          f.target_session_id AS targetSessionId, f.actor_type AS actorType,
          f.actor_id AS actorId, f.source_type AS sourceType,
-         f.prompt_hash AS promptHash, f.status,
-         f.session_entry_id AS sessionEntryId, f.reason_hash AS reasonHash,
-         f.created_at AS createdAt, f.updated_at AS updatedAt, f.sent_at AS sentAt,
-         r.revision
+         f.prompt_hash AS promptHash, f.status, f.reason_hash AS reasonHash,
+         f.created_at AS createdAt, f.updated_at AS updatedAt, r.revision
   FROM workflow_follow_ups f
   JOIN resources r ON r.resource_id = f.resource_id`;
 
@@ -110,6 +137,12 @@ export type RunWriteAuthority = {
   leaseMs?: number;
 };
 
+export type WorkflowRunDisplayState = {
+  status: WorkflowRunState["status"];
+  paused: boolean;
+  error: string | null;
+};
+
 export type WorkflowRunStoreOptions = {
   authorityProvider?: (runId: string) => RunWriteAuthority | undefined;
   /** Host-owned projection updates that must commit with each run snapshot. */
@@ -120,6 +153,8 @@ export type WorkflowRunStoreOptions = {
     database: StateDatabase;
     now: number;
   }) => void;
+  /** The global host may record an attested Pi session after the worker lease ends. */
+  allowHostSessionRecording?: boolean;
   state?: StateDatabase;
   readOnly?: boolean;
 };
@@ -316,21 +351,9 @@ type SettingsChangeRow = {
   acceptedAt: number;
 };
 
-type FollowUpQueueRow = {
-  runId: string;
-  resourceId: string;
-  originSessionId: string | null;
-  presentationState: string;
-  presentationEntryId: string | null;
-  presentationAssistantEntryId: string | null;
-  presentationReasonHash: Buffer | null;
-  revision: number;
-};
-
 type FollowUpRow = {
   followUpId: string;
   resourceId: string;
-  queueResourceId: string;
   runId: string;
   requestId: string;
   orderNumber: number;
@@ -340,11 +363,9 @@ type FollowUpRow = {
   sourceType: string;
   promptHash: Buffer;
   status: string;
-  sessionEntryId: string | null;
   reasonHash: Buffer | null;
   createdAt: number;
   updatedAt: number;
-  sentAt: number | null;
   revision: number;
 };
 
@@ -410,6 +431,48 @@ export type LoadedWorkflowRun = {
   followUpQueue?: WorkflowFollowUpQueueRecord | null;
 };
 
+export type WorkflowRunViewCounts = {
+  steps: number;
+  trace: number;
+  sessionEntries: number;
+  sessionEvents: number;
+  settings: number;
+  followUps: number;
+  updates: number;
+};
+
+export type WorkflowRunViewRange = {
+  start: number;
+  limit: number;
+};
+
+export type WorkflowRunViewRead = {
+  runId: string;
+  state: WorkflowRunState;
+  snapshot: WorkflowDefinitionSnapshot;
+  traceEvents: WorkflowTraceEvent[];
+  sessionBinding: WorkflowSessionBinding | null;
+  sessionEntries: WorkflowSessionEntryRecord[];
+  sessionEvents: WorkflowSessionEventRecord[];
+  sessionCapture: WorkflowSessionCapture | null;
+  sessionIntegrity: SessionCaptureIntegrity;
+  settingsScopes: WorkflowSettingsScopeRecord[];
+  followUpQueue: WorkflowFollowUpQueueRecord | null;
+  graphSteps: WorkflowStepRecord[];
+  takenTransitions: string[];
+};
+
+export type WorkflowRunViewReadOptions = {
+  steps: WorkflowRunViewRange;
+  trace: WorkflowRunViewRange;
+  sessionEntries: WorkflowRunViewRange;
+  sessionEvents: WorkflowRunViewRange;
+  settings: WorkflowRunViewRange;
+  followUps: WorkflowRunViewRange;
+  updates: WorkflowRunViewRange;
+  graphCursor: number;
+};
+
 export type ReadWorkflowRunOptions = {
   includeTrace?: boolean;
 };
@@ -425,13 +488,16 @@ export class WorkflowRunStore {
     | ((runId: string) => RunWriteAuthority | undefined)
     | undefined;
   private readonly snapshotLifecycle: WorkflowRunStoreOptions["snapshotLifecycle"];
+  private readonly allowHostSessionRecording: boolean;
   private readonly contexts = new Map<string, RunContext>();
   private readonly ownsState: boolean;
   private readonly mutations: StateMutationStore;
+  private readonly workflowMessages: WorkflowMessageStore;
 
   constructor(databasePath: string = workflowStatePath(), options: WorkflowRunStoreOptions = {}) {
     this.authorityProvider = options.authorityProvider;
     this.snapshotLifecycle = options.snapshotLifecycle;
+    this.allowHostSessionRecording = options.allowHostSessionRecording === true;
     this.ownsState = options.state === undefined;
     this.state =
       options.state ??
@@ -442,6 +508,7 @@ export class WorkflowRunStore {
       });
     this.databasePath = this.state.filePath;
     this.mutations = new StateMutationStore(this.state);
+    this.workflowMessages = new WorkflowMessageStore(this.state);
   }
 
   close(): void {
@@ -834,6 +901,18 @@ export class WorkflowRunStore {
           return;
         }
         const definitionHash = this.state.putJson(snapshot, now);
+        const parentLineage =
+          state.parentRunId === undefined
+            ? undefined
+            : this.state.connection
+                .prepare(
+                  `SELECT root_run_id AS rootRunId, restart_number AS restartNumber
+                   FROM runs WHERE run_id = ?`,
+                )
+                .get(state.parentRunId);
+        if (state.parentRunId !== undefined && !isRunLineageRow(parentLineage)) {
+          throw new Error(`Workflow parent run is missing: ${state.parentRunId}`);
+        }
         this.state.connection
           .prepare(
             `INSERT INTO workflow_definitions(
@@ -862,16 +941,20 @@ export class WorkflowRunStore {
         this.state.connection
           .prepare(
             `INSERT INTO runs(
-               run_id, resource_id, project_id, parent_run_id, definition_digest,
+               run_id, resource_id, project_id, parent_run_id, root_run_id, lineage_kind,
+               restart_number, parent_terminal_fingerprint, definition_digest,
                workflow_ref, launch_options_hash, title, status, paused,
                status_detail, input_hash, final_output_hash, error_hash,
                created_at, updated_at, finished_at
-             ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+             ) VALUES (?, ?, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
           )
           .run(
             state.runId,
             resourceId,
             state.parentRunId ?? null,
+            isRunLineageRow(parentLineage) ? parentLineage.rootRunId : state.runId,
+            state.parentRunId === undefined ? null : "continuation",
+            isRunLineageRow(parentLineage) ? parentLineage.restartNumber : 0,
             definitionDigest,
             state.workflowName,
             launchOptionsHash,
@@ -1033,6 +1116,28 @@ export class WorkflowRunStore {
       .map((row) => this.settingsScopeRecord(row));
   }
 
+  private readSettingsScopeRange(
+    runId: string,
+    range: WorkflowRunViewRange,
+  ): WorkflowSettingsScopeRecord[] {
+    const originRunId = this.logicalOriginRunId(runId);
+    return this.state.connection
+      .prepare(
+        `SELECT s.scope_id AS scopeId, s.resource_id AS resourceId,
+                s.origin_run_id AS originRunId, s.active_run_id AS activeRunId,
+                s.mount_path AS mountPath, s.invocation,
+                s.current_hash AS currentHash, r.revision,
+                s.created_at AS createdAt, s.updated_at AS updatedAt
+         FROM workflow_settings s
+         JOIN resources r ON r.resource_id = s.resource_id
+         WHERE s.origin_run_id = ? OR s.active_run_id = ?
+         ORDER BY s.mount_path, s.invocation LIMIT ? OFFSET ?`,
+      )
+      .all(originRunId, runId, range.limit, range.start)
+      .filter(isSettingsScopeRow)
+      .map((row) => this.settingsScopeRecord(row));
+  }
+
   findSettingsScope(
     runId: string,
     mountPath: string,
@@ -1187,87 +1292,78 @@ export class WorkflowRunStore {
     if (Buffer.byteLength(request.prompt, "utf8") > 64 * 1024) {
       throw new Error("Workflow follow-up prompt cannot exceed 65536 bytes");
     }
-    for (let attempt = 0; attempt < 8; attempt += 1) {
+    return this.state.transaction(() => {
       const prior = this.followUpRowByRequest(request.runId, request.requestId);
       if (prior !== undefined) {
         this.assertSameFollowUp(prior, request);
         return { followUp: this.followUpRecord(prior), adopted: true };
       }
       this.requireRunAcceptsSettings(request.runId, true);
-      const queue = this.requireFollowUpQueueRow(request.runId);
-      try {
-        const result = this.mutations.mutate(
-          {
-            resourceId: queue.resourceId,
-            operation: "follow-up.queue",
-            actor: request.actor,
-            expectedRevision: queue.revision,
-          },
-          "follow-up.queued",
-          ({ database, now }) => {
-            this.requireRunAcceptsSettings(request.runId, true);
-            const currentQueue = this.requireFollowUpQueueRow(request.runId);
-            if (
-              currentQueue.originSessionId !== null &&
-              currentQueue.originSessionId !== request.targetSessionId
-            ) {
-              throw new Error("Workflow follow-ups must target the run's origin Pi session");
-            }
-            if (currentQueue.originSessionId === null) {
-              database.connection
-                .prepare(
-                  `UPDATE workflow_follow_up_queues
-                   SET origin_session_id = ?, updated_at = ? WHERE run_id = ?`,
-                )
-                .run(request.targetSessionId, now, request.runId);
-            }
-            const order = this.nextFollowUpOrder(request.runId);
-            const followUpId = followUpIdFor(request.runId, request.requestId);
-            const resourceId = this.mutations.ensureResource("follow_up", followUpId, now);
-            const promptHash = database.putText(request.prompt, now);
-            database.connection
-              .prepare(
-                `INSERT INTO workflow_follow_ups(
-                   follow_up_id, resource_id, queue_resource_id, run_id,
-                   request_id, order_number, target_session_id,
-                   actor_type, actor_id, source_type, prompt_hash, status,
-                   created_at, updated_at
-                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?)`,
-              )
-              .run(
-                followUpId,
-                resourceId,
-                queue.resourceId,
-                request.runId,
-                request.requestId,
-                order,
-                request.targetSessionId,
-                request.actor.type,
-                request.actor.id ?? null,
-                request.source,
-                promptHash,
-                now,
-                now,
-              );
-            recordViewerDeltas(
-              this.state,
-              request.runId,
-              this.viewerInspectorTargets(request.runId),
-              now,
-            );
-            return followUpId;
-          },
-          { payload: { runId: request.runId, requestId: request.requestId } },
-        );
-        return {
-          followUp: this.followUpRecord(this.requireFollowUpRow(result.value)),
-          adopted: false,
-        };
-      } catch (error) {
-        if (!(error instanceof StaleResourceError)) throw error;
+      if (this.originSessionId(request.runId) !== request.targetSessionId) {
+        throw new Error("Workflow follow-ups must target the run's origin Pi session");
       }
-    }
-    throw new StaleResourceError("Workflow follow-up queue kept changing; retry the request");
+      const now = Date.now();
+      const order = this.nextFollowUpOrder(request.runId);
+      const followUpId = followUpIdFor(request.runId, request.requestId);
+      const resourceId = this.mutations.ensureResource("follow_up", followUpId, now);
+      const promptHash = this.state.putText(request.prompt, now);
+      this.state.connection
+        .prepare(
+          `INSERT INTO workflow_follow_ups(
+             follow_up_id, resource_id, run_id, request_id, order_number,
+             target_session_id, actor_type, actor_id, source_type, prompt_hash,
+             status, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?)`,
+        )
+        .run(
+          followUpId,
+          resourceId,
+          request.runId,
+          request.requestId,
+          order,
+          request.targetSessionId,
+          request.actor.type,
+          request.actor.id ?? null,
+          request.source,
+          promptHash,
+          now,
+          now,
+        );
+      const workflowMessageId = workflowMessageIdFor("followUp", followUpId, "initial");
+      this.workflowMessages.create({
+        workflowMessageId,
+        runId: request.runId,
+        targetSessionId: request.targetSessionId,
+        kind: "followUp",
+        sourceId: followUpId,
+        idempotencyKey: "initial",
+        content: followUpWorkflowMessageContent({
+          workflowMessageId,
+          followUpId,
+          runId: request.runId,
+          prompt: request.prompt,
+        }),
+        now,
+      });
+      this.bumpResource(resourceId, 0, now);
+      insertGenericEvent(
+        this.state,
+        resourceId,
+        1,
+        "follow-up.queued",
+        request.actor.type,
+        request.actor.id ?? null,
+        this.state.putJson({ runId: request.runId, requestId: request.requestId }, now),
+        now,
+      );
+      recordViewerDeltas(
+        this.state,
+        request.runId,
+        this.viewerInspectorTargets(request.runId),
+        now,
+      );
+      return { followUp: this.followUpRecord(this.requireFollowUpRow(followUpId)), adopted: false };
+    });
   }
 
   removeFollowUp(request: WorkflowRemoveFollowUpRequest): WorkflowFollowUpRecord {
@@ -1277,12 +1373,13 @@ export class WorkflowRunStore {
       throw new Error(`Workflow follow-up is not part of run ${request.runId}`);
     }
     if (row.status === "removed") return this.followUpRecord(row);
-    if (row.status === "sent" || row.status === "cancelled") {
-      throw new Error(`Workflow follow-up cannot be removed after it is ${row.status}`);
+    if (row.status === "cancelled") {
+      throw new Error("A cancelled workflow follow-up cannot be removed");
     }
     this.assertFollowUpRemovalAuthority(row, request.actor, request.source);
-    if (this.hasLiveLease(row.resourceId)) {
-      throw new Error("Workflow follow-up is being delivered and cannot be removed");
+    const message = this.workflowMessages.latestForSource("followUp", request.followUpId);
+    if (message?.status === "sent") {
+      throw new Error("A sent workflow follow-up cannot be removed");
     }
     const reason = "Removed before delivery";
     this.mutations.mutate(
@@ -1299,12 +1396,13 @@ export class WorkflowRunStore {
           .prepare(
             `UPDATE workflow_follow_ups
              SET status = 'removed', reason_hash = ?, updated_at = ?
-             WHERE follow_up_id = ? AND status IN ('queued', 'pending_presentation', 'ready')`,
+             WHERE follow_up_id = ? AND status = 'queued'`,
           )
           .run(reasonHash, now, request.followUpId);
         if (update.changes !== 1) {
           throw new StaleResourceError("Workflow follow-up changed before removal");
         }
+        this.workflowMessages.cancelPendingForSource(request.followUpId, "followUp", now);
         recordViewerDeltas(
           this.state,
           request.runId,
@@ -1320,10 +1418,8 @@ export class WorkflowRunStore {
   originSessionId(runId: string): string | undefined {
     const row = this.state.connection
       .prepare(
-        `SELECT COALESCE(q.origin_session_id, b.origin_session_id) AS originSessionId
-         FROM runs r
-         LEFT JOIN workflow_follow_up_queues q ON q.run_id = r.run_id
-         LEFT JOIN run_bindings b ON b.run_id = r.run_id
+        `SELECT b.origin_session_id AS originSessionId
+         FROM runs r LEFT JOIN run_bindings b ON b.run_id = r.run_id
          WHERE r.run_id = ?`,
       )
       .get(runId);
@@ -1333,202 +1429,30 @@ export class WorkflowRunStore {
   }
 
   readFollowUpQueue(runId: string): WorkflowFollowUpQueueRecord | undefined {
-    const queue = this.followUpQueueRow(runId);
-    if (queue === undefined) return undefined;
+    const originSessionId = this.originSessionId(runId);
+    if (originSessionId === undefined) return undefined;
     const followUps = this.state.connection
       .prepare(`${FOLLOW_UP_ROW_SELECT} WHERE f.run_id = ? ORDER BY f.order_number`)
       .all(runId)
       .filter(isFollowUpRow)
       .map((row) => this.followUpRecord(row));
-    return {
-      runId,
-      ...(queue.originSessionId !== null ? { originSessionId: queue.originSessionId } : {}),
-      presentationState: assertPresentationState(queue.presentationState),
-      ...(queue.presentationEntryId !== null
-        ? { presentationEntryId: queue.presentationEntryId }
-        : {}),
-      ...(queue.presentationAssistantEntryId !== null
-        ? { presentationAssistantEntryId: queue.presentationAssistantEntryId }
-        : {}),
-      ...(queue.presentationReasonHash !== null
-        ? { presentationReason: this.readText(queue.presentationReasonHash) }
-        : {}),
-      followUps,
-    };
+    return { runId, originSessionId, followUps };
   }
 
-  listPendingPresentations(targetSessionId: string): string[] {
-    return this.state.connection
-      .prepare(
-        `SELECT run_id AS runId FROM workflow_follow_up_queues
-         WHERE origin_session_id = ? AND presentation_state = 'pending'
-         ORDER BY created_at`,
-      )
-      .all(targetSessionId)
-      .flatMap((row) => (isRecord(row) && typeof row.runId === "string" ? [row.runId] : []));
-  }
-
-  settleFollowUpPresentation(options: {
-    runId: string;
-    state: "settled" | "unavailable";
-    presentationEntryId?: string;
-    assistantEntryId?: string;
-    reason?: string;
-  }): WorkflowFollowUpQueueRecord {
-    const queue = this.requireFollowUpQueueRow(options.runId);
-    if (queue.presentationState === options.state) {
-      return this.readFollowUpQueue(options.runId) as WorkflowFollowUpQueueRecord;
-    }
-    if (queue.presentationState !== "pending") {
-      throw new Error(
-        `Workflow presentation is ${queue.presentationState}, not pending for ${options.runId}`,
-      );
-    }
-    if (
-      options.state === "settled" &&
-      (options.presentationEntryId === undefined || options.assistantEntryId === undefined)
-    ) {
-      throw new Error("Settled workflow presentation requires both session entry IDs");
-    }
-    if (options.state === "unavailable" && !options.reason?.trim()) {
-      throw new Error("Unavailable workflow presentation requires a reason");
-    }
-    try {
-      this.mutations.mutate(
-        {
-          resourceId: queue.resourceId,
-          operation: "follow-up.presentation",
-          actor: {
-            type: "session",
-            ...(queue.originSessionId !== null ? { id: queue.originSessionId } : {}),
-          },
-          expectedRevision: queue.revision,
-        },
-        `follow-up.presentation-${options.state}`,
-        ({ database, now }) => {
-          const reasonHash =
-            options.state === "unavailable"
-              ? database.putText(options.reason as string, now)
-              : null;
-          database.connection
-            .prepare(
-              `UPDATE workflow_follow_up_queues
-             SET presentation_state = ?, presentation_entry_id = ?,
-                 presentation_assistant_entry_id = ?, presentation_reason_hash = ?,
-                 presentation_updated_at = ?, updated_at = ?
-             WHERE run_id = ? AND presentation_state = 'pending'`,
-            )
-            .run(
-              options.state,
-              options.presentationEntryId ?? null,
-              options.assistantEntryId ?? null,
-              reasonHash,
-              now,
-              now,
-              options.runId,
-            );
-          database.connection
-            .prepare(
-              `UPDATE workflow_follow_ups SET status = 'ready', updated_at = ?
-             WHERE run_id = ? AND status = 'pending_presentation'`,
-            )
-            .run(now, options.runId);
-          recordViewerDeltas(
-            this.state,
-            options.runId,
-            this.viewerInspectorTargets(options.runId),
-            now,
-          );
-        },
-        { payload: { runId: options.runId, state: options.state } },
-      );
-    } catch (error) {
-      if (error instanceof StaleResourceError) {
-        const current = this.requireFollowUpQueueRow(options.runId);
-        if (current.presentationState === options.state) {
-          return this.readFollowUpQueue(options.runId) as WorkflowFollowUpQueueRecord;
-        }
-      }
-      throw error;
-    }
-    return this.readFollowUpQueue(options.runId) as WorkflowFollowUpQueueRecord;
-  }
-
-  claimNextFollowUp(
-    targetSessionId: string,
-    ownerId: string,
-    leaseMs = 30_000,
-  ): { followUp: WorkflowFollowUpRecord; claim: LeaseClaim } | undefined {
-    const rows = this.state.connection
+  private readFollowUpQueueRange(
+    runId: string,
+    range: WorkflowRunViewRange,
+  ): WorkflowFollowUpQueueRecord | null {
+    const originSessionId = this.originSessionId(runId);
+    if (originSessionId === undefined) return null;
+    const followUps = this.state.connection
       .prepare(
-        `${FOLLOW_UP_ROW_SELECT}
-         WHERE f.target_session_id = ? AND f.status = 'ready'
-         ORDER BY f.created_at, f.order_number LIMIT 16`,
+        `${FOLLOW_UP_ROW_SELECT} WHERE f.run_id = ? ORDER BY f.order_number LIMIT ? OFFSET ?`,
       )
-      .all(targetSessionId)
-      .filter(isFollowUpRow);
-    for (const row of rows) {
-      let claim: LeaseClaim | undefined;
-      try {
-        claim = this.mutations.claim({
-          resourceId: row.resourceId,
-          ownerType: "session",
-          ownerId,
-          expectedRevision: row.revision,
-          leaseMs,
-        });
-      } catch (error) {
-        if (error instanceof StaleResourceError) continue;
-        throw error;
-      }
-      if (claim === undefined) continue;
-      const current = this.requireFollowUpRow(row.followUpId);
-      if (current.status !== "ready") {
-        this.mutations.release(claim, claim.resourceRevision);
-        continue;
-      }
-      return { followUp: this.followUpRecord(current), claim };
-    }
-    return undefined;
-  }
-
-  markFollowUpSent(
-    followUpId: string,
-    claim: LeaseClaim,
-    sessionEntryId: string,
-  ): WorkflowFollowUpRecord {
-    const row = this.requireFollowUpRow(followUpId);
-    if (row.status === "sent") return this.followUpRecord(row);
-    this.mutations.mutate(
-      {
-        resourceId: row.resourceId,
-        operation: "follow-up.sent",
-        actor: { type: "session", id: claim.ownerId },
-        expectedRevision: claim.resourceRevision,
-        lease: claim,
-      },
-      "follow-up.sent",
-      ({ database, now }) => {
-        const update = database.connection
-          .prepare(
-            `UPDATE workflow_follow_ups
-             SET status = 'sent', session_entry_id = ?, sent_at = ?, updated_at = ?
-             WHERE follow_up_id = ? AND status = 'ready'`,
-          )
-          .run(sessionEntryId, now, now, followUpId);
-        if (update.changes !== 1) {
-          throw new StaleResourceError("Workflow follow-up changed before delivery completed");
-        }
-        recordViewerDeltas(this.state, row.runId, this.viewerInspectorTargets(row.runId), now);
-      },
-      { payload: { followUpId, sessionEntryId } },
-    );
-    return this.followUpRecord(this.requireFollowUpRow(followUpId));
-  }
-
-  releaseFollowUpClaim(claim: LeaseClaim): void {
-    const revision = this.requireResourceRevision(claim.resourceId);
-    this.mutations.release(claim, revision);
+      .all(runId, range.limit, range.start)
+      .filter(isFollowUpRow)
+      .map((row) => this.followUpRecord(row));
+    return { runId, originSessionId, followUps };
   }
 
   async prepareRunResume(runId: string): Promise<LoadedWorkflowRun> {
@@ -1540,7 +1464,6 @@ export class WorkflowRunStore {
     this.verifySettingsProjections(runId);
     const revision = this.resourceRevision(runId);
     this.contexts.set(runId, { revision, lock: Promise.resolve() });
-    this.finalizeRecordingCaptures(runId, "Workflow host stopped before the run finished");
     this.state.transaction(() => {
       const row = this.requireRunRow(runId);
       const context = this.contextFor(runId);
@@ -1770,7 +1693,7 @@ export class WorkflowRunStore {
       this.state.transaction(() => {
         const run = this.requireRunRow(runId);
         const context = this.contextFor(runId);
-        this.assertWriteAuthority(run, context.revision);
+        this.assertSessionWriteAuthority(runId);
         const now = Date.parse(binding.boundAt);
         const resourceId = resourceIdFor("session", segmentId);
         const bindingHash = this.state.putJson(binding, now);
@@ -1817,13 +1740,6 @@ export class WorkflowRunStore {
              ON CONFLICT(run_id) DO NOTHING`,
           )
           .run(runId, binding.piSessionId, now);
-        this.state.connection
-          .prepare(
-            `UPDATE workflow_follow_up_queues
-             SET origin_session_id = COALESCE(origin_session_id, ?), updated_at = ?
-             WHERE run_id = ?`,
-          )
-          .run(binding.piSessionId, now, runId);
         const revision = context.revision + 1;
         const at = new Date(now).toISOString();
         const traceEvent: WorkflowTraceEvent = {
@@ -2289,6 +2205,217 @@ export class WorkflowRunStore {
     };
   }
 
+  readRunViewCounts(runId: string): WorkflowRunViewCounts | null {
+    const row = this.readRunRow(runId);
+    if (row === undefined) return null;
+    const segment = this.segmentRow(segmentIdFor(runId));
+    const settingsOrigin = this.logicalOriginRunId(runId);
+    const scalar = (sql: string, ...params: unknown[]): number => {
+      const count = this.state.connection.prepare(sql).get(...params);
+      return isCountRow(count) ? count.count : 0;
+    };
+    return {
+      steps: scalar("SELECT count(*) AS count FROM run_steps WHERE run_id = ?", runId),
+      trace: scalar("SELECT count(*) AS count FROM events WHERE resource_id = ?", row.resourceId),
+      sessionEntries: segment?.entryCount ?? 0,
+      sessionEvents: segment?.eventCount ?? 0,
+      settings: scalar(
+        `SELECT count(*) AS count FROM workflow_settings
+         WHERE origin_run_id = ? OR active_run_id = ?`,
+        settingsOrigin,
+        runId,
+      ),
+      followUps: scalar(
+        "SELECT count(*) AS count FROM workflow_follow_ups WHERE run_id = ?",
+        runId,
+      ),
+      updates: scalar(
+        `SELECT count(*) AS count FROM (
+           SELECT 1 FROM workflow_updates u
+           JOIN node_attempts a ON a.attempt_id = u.attempt_id
+           WHERE a.run_id = ? GROUP BY u.update_type, u.update_key
+         )`,
+        runId,
+      ),
+    };
+  }
+
+  readRunView(runId: string, options: WorkflowRunViewReadOptions): WorkflowRunViewRead | null {
+    const row = this.readRunRow(runId);
+    if (row === undefined) return null;
+    const snapshot = this.readDefinition(row.definitionHash);
+    const steps = this.readStepRange(runId, options.steps);
+    const visibleUpdates = this.readCurrentUpdates(runId, options.updates);
+    const state = this.buildRunState(
+      row,
+      snapshot,
+      this.readLatestSteps(runId),
+      steps,
+      visibleUpdates,
+    );
+    const segment = this.segmentRow(segmentIdFor(runId));
+    const loadedSegment =
+      segment === undefined
+        ? emptySegment()
+        : this.loadSegment(segment, state, {
+            entries: options.sessionEntries,
+            events: options.sessionEvents,
+          });
+    return {
+      runId,
+      state,
+      snapshot,
+      traceEvents: this.traceEvents(row, options.trace),
+      sessionBinding: loadedSegment.binding,
+      sessionEntries: loadedSegment.entries,
+      sessionEvents: loadedSegment.events,
+      sessionCapture: loadedSegment.capture,
+      sessionIntegrity: loadedSegment.integrity,
+      settingsScopes: this.readSettingsScopeRange(runId, options.settings),
+      followUpQueue: this.readFollowUpQueueRange(runId, options.followUps),
+      graphSteps: this.readLatestSteps(runId, options.graphCursor),
+      takenTransitions: this.readTakenTransitions(runId, options.graphCursor),
+    };
+  }
+
+  traceCursorForStep(runId: string, stepCursor: number, traceTotal: number): number {
+    const step = this.state.connection
+      .prepare(
+        `SELECT a.attempt_id AS attemptId, a.node_id AS nodeId
+         FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
+         WHERE s.run_id = ? AND s.step_index = ?`,
+      )
+      .get(runId, stepCursor);
+    if (!isRecord(step) || typeof step.attemptId !== "string" || typeof step.nodeId !== "string") {
+      return Math.min(stepCursor, Math.max(0, traceTotal - 1));
+    }
+    const run = this.readRunRow(runId);
+    if (run === undefined) return 0;
+    const exactAttempt = this.state.connection
+      .prepare(
+        `SELECT e.resource_revision AS revision FROM events e
+         JOIN blobs b ON b.blob_hash = e.payload_hash
+         WHERE e.resource_id = ?
+           AND json_extract(CAST(b.content AS TEXT), '$.attemptId') = ?
+         ORDER BY e.resource_revision DESC LIMIT 1`,
+      )
+      .get(run.resourceId, step.attemptId);
+    const matched = isRevisionRow(exactAttempt)
+      ? exactAttempt
+      : this.state.connection
+          .prepare(
+            `SELECT e.resource_revision AS revision FROM events e
+             JOIN blobs b ON b.blob_hash = e.payload_hash
+             WHERE e.resource_id = ?
+               AND json_extract(CAST(b.content AS TEXT), '$.nodeId') = ?
+             ORDER BY e.resource_revision DESC LIMIT 1`,
+          )
+          .get(run.resourceId, step.nodeId);
+    if (!isRevisionRow(matched)) return Math.min(stepCursor, Math.max(0, traceTotal - 1));
+    const index = this.state.connection
+      .prepare(
+        `SELECT count(*) - 1 AS count FROM events
+         WHERE resource_id = ? AND resource_revision <= ?`,
+      )
+      .get(run.resourceId, matched.revision);
+    return isCountRow(index) ? Math.max(0, index.count) : 0;
+  }
+
+  persistViewContent(runId: string, content: Buffer, mediaType: string): string {
+    if (this.readRunRow(runId) === undefined) throw new Error(`Workflow run not found: ${runId}`);
+    return this.state.transaction(() => {
+      const hash = createHash("sha256").update(content).digest();
+      this.state.connection
+        .prepare(
+          `INSERT INTO run_view_content(
+             run_id, content_hash, media_type, byte_length, content, created_at
+           ) VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(run_id, content_hash, media_type) DO NOTHING`,
+        )
+        .run(runId, hash, mediaType, content.byteLength, content, Date.now());
+      const stored = this.state.connection
+        .prepare(
+          `SELECT media_type AS mediaType, byte_length AS byteLength, content
+           FROM run_view_content
+           WHERE run_id = ? AND content_hash = ? AND media_type = ?`,
+        )
+        .get(runId, hash, mediaType);
+      if (
+        !isRecord(stored) ||
+        stored.mediaType !== mediaType ||
+        stored.byteLength !== content.byteLength ||
+        !Buffer.isBuffer(stored.content) ||
+        !stored.content.equals(content)
+      ) {
+        throw new Error("Run-scoped view content conflict");
+      }
+      return hash.toString("hex");
+    });
+  }
+
+  readContentBlob(
+    runId: string,
+    digest: string,
+    mediaType: string,
+  ): { mediaType: string; content: Buffer } | undefined {
+    if (!/^[0-9a-f]{64}$/u.test(digest)) return undefined;
+    const stored = this.state.connection
+      .prepare(
+        `SELECT media_type AS mediaType, byte_length AS byteLength, content
+         FROM run_view_content
+         WHERE run_id = ? AND content_hash = ? AND media_type = ?`,
+      )
+      .get(runId, Buffer.from(digest, "hex"), mediaType);
+    if (
+      !isRecord(stored) ||
+      stored.mediaType !== mediaType ||
+      typeof stored.byteLength !== "number" ||
+      !Buffer.isBuffer(stored.content) ||
+      stored.content.byteLength !== stored.byteLength
+    ) {
+      return undefined;
+    }
+    return { mediaType, content: stored.content };
+  }
+
+  readDisplayState(runId: string): WorkflowRunDisplayState | null {
+    const row = this.readRunRow(runId);
+    if (row === undefined) return null;
+    return {
+      status: row.status as WorkflowRunState["status"],
+      paused: row.paused === 1,
+      error: row.errorHash === null ? null : this.readText(row.errorHash),
+    };
+  }
+
+  readSessionReplayCheckpoint(runId: string, throughSequence: number): JsonValue | null {
+    if (!Number.isSafeInteger(throughSequence) || throughSequence < 0) {
+      throw new Error("Session replay checkpoint sequence must be a non-negative integer");
+    }
+    if (throughSequence === 0) return null;
+    const row = this.state.connection
+      .prepare(
+        `SELECT event_seq AS eventSeq, state_hash AS stateHash
+         FROM viewer_session_checkpoints
+         WHERE run_id = ? AND event_seq <= ? ORDER BY event_seq DESC LIMIT 1`,
+      )
+      .get(runId, throughSequence);
+    let checkpoint = reduceSessionEvents([], [], 0);
+    if (isViewerSessionCheckpointRow(row)) {
+      const saved = this.state.readJson(row.stateHash);
+      if (!isTemporalSessionState(saved) || saved.throughSeq !== row.eventSeq) {
+        throw new Error(`Viewer session checkpoint is invalid for ${runId}`);
+      }
+      checkpoint = saved;
+    }
+    if (checkpoint.throughSeq < throughSequence) {
+      const events = this.sessionEventRecords(runId, checkpoint.throughSeq, throughSequence + 1);
+      checkpoint = reduceSessionEventsFromCheckpoint([], events, throughSequence, checkpoint);
+      checkpoint = boundedTemporalCheckpoint(checkpoint);
+    }
+    return parseJson(canonicalJson(checkpoint));
+  }
+
   listRuns(options: ReadWorkflowRunOptions = {}): LoadedWorkflowRun[] {
     const rows = this.state.connection
       .prepare("SELECT run_id AS runId FROM runs ORDER BY created_at DESC, run_id DESC")
@@ -2338,6 +2465,7 @@ export class WorkflowRunStore {
 
   private assertSessionWriteAuthority(runId: string): void {
     const run = this.requireRunRow(runId);
+    if (this.allowHostSessionRecording) return;
     this.assertWriteAuthority(run, this.contextFor(runId).revision);
   }
 
@@ -2561,10 +2689,8 @@ export class WorkflowRunStore {
         order: row.orderNumber,
         state: row.status,
         source: row.sourceType,
-        sessionEntryId: row.sessionEntryId,
       }));
     const followUpStart = Math.max(0, followUps.length - VIEWER_PAGE_SIZE);
-    const queue = this.requireFollowUpQueueRow(runId);
     return [
       {
         targetType: "inspector",
@@ -2586,12 +2712,7 @@ export class WorkflowRunStore {
           {
             op: "replace",
             path: "/followUpQueue",
-            value: parseJson(
-              canonicalJson({
-                presentationState: queue.presentationState,
-                items: followUps.slice(followUpStart),
-              }),
-            ),
+            value: parseJson(canonicalJson({ items: followUps.slice(followUpStart) })),
           },
           { op: "replace", path: "/followUpStart", value: followUpStart },
           { op: "replace", path: "/followUpTotal", value: followUps.length },
@@ -2605,25 +2726,7 @@ export class WorkflowRunStore {
     initialSettings: InitialWorkflowSettingsScope[],
     now: number,
   ): void {
-    const childQueueResourceId = this.ensureFollowUpQueue(state.runId, now);
     if (state.parentRunId !== undefined) {
-      const parentQueue = this.followUpQueueRow(state.parentRunId);
-      if (parentQueue !== undefined) {
-        this.state.connection
-          .prepare(
-            `UPDATE workflow_follow_up_queues
-             SET origin_session_id = COALESCE(origin_session_id, ?), updated_at = ?
-             WHERE run_id = ?`,
-          )
-          .run(parentQueue.originSessionId, now, state.runId);
-        this.state.connection
-          .prepare(
-            `UPDATE workflow_follow_ups
-             SET run_id = ?, queue_resource_id = ?, updated_at = ?
-             WHERE run_id = ? AND status = 'queued'`,
-          )
-          .run(state.runId, childQueueResourceId, now, state.parentRunId);
-      }
       this.state.connection
         .prepare(
           `UPDATE workflow_settings SET active_run_id = ?, updated_at = ? WHERE active_run_id = ?`,
@@ -2663,19 +2766,6 @@ export class WorkflowRunStore {
     }
   }
 
-  private ensureFollowUpQueue(runId: string, now: number): string {
-    const resourceId = this.mutations.ensureResource("follow_up_queue", runId, now);
-    this.state.connection
-      .prepare(
-        `INSERT INTO workflow_follow_up_queues(
-           run_id, resource_id, created_at, updated_at
-         ) VALUES (?, ?, ?, ?)
-         ON CONFLICT(run_id) DO NOTHING`,
-      )
-      .run(runId, resourceId, now, now);
-    return resourceId;
-  }
-
   private logicalOriginRunId(runId: string): string {
     let current = runId;
     for (let depth = 0; depth < 100; depth += 1) {
@@ -2833,30 +2923,6 @@ export class WorkflowRunStore {
     }
   }
 
-  private followUpQueueRow(runId: string): FollowUpQueueRow | undefined {
-    const row = this.state.connection
-      .prepare(
-        `SELECT q.run_id AS runId, q.resource_id AS resourceId,
-                q.origin_session_id AS originSessionId,
-                q.presentation_state AS presentationState,
-                q.presentation_entry_id AS presentationEntryId,
-                q.presentation_assistant_entry_id AS presentationAssistantEntryId,
-                q.presentation_reason_hash AS presentationReasonHash,
-                r.revision
-         FROM workflow_follow_up_queues q
-         JOIN resources r ON r.resource_id = q.resource_id
-         WHERE q.run_id = ?`,
-      )
-      .get(runId);
-    return isFollowUpQueueRow(row) ? row : undefined;
-  }
-
-  private requireFollowUpQueueRow(runId: string): FollowUpQueueRow {
-    const row = this.followUpQueueRow(runId);
-    if (row === undefined) throw new Error(`Workflow follow-up queue not found: ${runId}`);
-    return row;
-  }
-
   private followUpRowByRequest(runId: string, requestId: string): FollowUpRow | undefined {
     const row = this.state.connection
       .prepare(`${FOLLOW_UP_ROW_SELECT} WHERE f.run_id = ? AND f.request_id = ?`)
@@ -2891,11 +2957,9 @@ export class WorkflowRunStore {
       source: row.sourceType,
       prompt: this.readText(row.promptHash),
       state: assertFollowUpState(row.status),
-      ...(row.sessionEntryId !== null ? { sessionEntryId: row.sessionEntryId } : {}),
       ...(row.reasonHash !== null ? { reason: this.readText(row.reasonHash) } : {}),
       createdAt: new Date(row.createdAt).toISOString(),
       updatedAt: new Date(row.updatedAt).toISOString(),
-      ...(row.sentAt !== null ? { sentAt: new Date(row.sentAt).toISOString() } : {}),
     };
   }
 
@@ -2929,13 +2993,6 @@ export class WorkflowRunStore {
     throw new Error("Workflow follow-up can be removed only by its source or a verified human");
   }
 
-  private hasLiveLease(resourceId: string): boolean {
-    const row = this.state.connection
-      .prepare("SELECT expires_at AS expiresAt FROM leases WHERE resource_id = ?")
-      .get(resourceId);
-    return isLeaseExpiryRow(row) && row.expiresAt !== null && row.expiresAt > Date.now();
-  }
-
   private nextFollowUpOrder(runId: string): number {
     const row = this.state.connection
       .prepare(
@@ -2968,55 +3025,51 @@ export class WorkflowRunStore {
 
   private transitionFollowUpsForRunState(
     state: WorkflowRunState,
-    event: WorkflowTraceEventDraft,
+    _event: WorkflowTraceEventDraft,
     now: number,
   ): void {
-    if (state.status === "running" || state.status === "waiting") return;
-    const queue = this.followUpQueueRow(state.runId);
-    if (queue === undefined || queue.presentationState !== "none") return;
-    let presentationState: WorkflowPresentationState = "not-needed";
-    let followUpState: WorkflowFollowUpState = "cancelled";
-    let reasonHash: Buffer | null = null;
-    if (state.status === "completed") {
-      const required = event.payload.presentationRequired === true;
-      presentationState = required ? "pending" : "not-needed";
-      followUpState = required ? "pending_presentation" : "ready";
-    } else {
-      reasonHash = this.state.putText(
-        state.error ?? `Workflow ended with status ${state.status}`,
-        now,
-      );
+    if (state.status === "running" || state.status === "waiting" || state.status === "completed") {
+      return;
     }
-    this.state.connection
-      .prepare(
-        `UPDATE workflow_follow_up_queues
-         SET presentation_state = ?, presentation_updated_at = ?, updated_at = ?
-         WHERE run_id = ? AND presentation_state = 'none'`,
-      )
-      .run(presentationState, now, now, state.runId);
-    this.state.connection
+    const rows = this.state.connection
       .prepare(
-        `UPDATE workflow_follow_ups
-         SET status = ?, reason_hash = ?, updated_at = ?
-         WHERE run_id = ? AND status IN ('queued', 'pending_presentation', 'ready')`,
+        `${FOLLOW_UP_ROW_SELECT}
+         WHERE f.run_id IN (
+           WITH RECURSIVE ancestors(run_id, parent_run_id) AS (
+             SELECT run_id, parent_run_id FROM runs WHERE run_id = ?
+             UNION ALL
+             SELECT parent.run_id, parent.parent_run_id
+             FROM runs parent JOIN ancestors ON ancestors.parent_run_id = parent.run_id
+           )
+           SELECT run_id FROM ancestors
+         ) AND f.status = 'queued'`,
       )
-      .run(followUpState, reasonHash, now, state.runId);
-    const revision = this.requireResourceRevision(queue.resourceId);
-    this.bumpResource(queue.resourceId, revision, now);
-    const payloadHash = this.state.putJson(
-      { runId: state.runId, state: presentationState, followUps: followUpState },
-      now,
-    );
-    insertGenericEvent(
-      this.state,
-      queue.resourceId,
-      revision + 1,
-      "follow-up.run-finished",
-      "system",
-      null,
-      payloadHash,
-      now,
-    );
+      .all(state.runId)
+      .filter(isFollowUpRow);
+    for (const row of rows) {
+      const reason = state.error ?? `Workflow ended with status ${state.status}`;
+      const reasonHash = this.state.putText(reason, now);
+      const update = this.state.connection
+        .prepare(
+          `UPDATE workflow_follow_ups
+           SET status = 'cancelled', reason_hash = ?, updated_at = ?
+           WHERE follow_up_id = ? AND status = 'queued'`,
+        )
+        .run(reasonHash, now, row.followUpId);
+      if (update.changes !== 1) continue;
+      this.workflowMessages.cancelPendingForSource(row.followUpId, "followUp", now);
+      this.bumpResource(row.resourceId, row.revision, now);
+      insertGenericEvent(
+        this.state,
+        row.resourceId,
+        row.revision + 1,
+        "follow-up.cancelled",
+        "system",
+        null,
+        this.state.putJson({ runId: state.runId, status: state.status, reason }, now),
+        now,
+      );
+    }
   }
 
   private syncNodeAttempts(
@@ -3213,7 +3266,7 @@ export class WorkflowRunStore {
          JOIN session_segments s ON s.segment_id = e.segment_id
          JOIN blobs b ON b.blob_hash = e.entry_hash
          WHERE s.run_id = ?
-           AND json_extract(CAST(b.content AS TEXT), '$.customType') = 'pi-workflows-agent-step'
+           AND json_extract(CAST(b.content AS TEXT), '$.customType') = 'pi-workflows-step'
            AND json_extract(CAST(b.content AS TEXT), '$.details.contract.attemptId') = ?
          ORDER BY e.recorded_at DESC LIMIT 1`,
       )
@@ -3407,13 +3460,37 @@ export class WorkflowRunStore {
 
   private readRunState(row: RunRow, snapshot: WorkflowDefinitionSnapshot): WorkflowRunState {
     const steps = this.readSteps(row.runId);
+    return this.buildRunState(
+      row,
+      snapshot,
+      steps,
+      steps,
+      this.readUpdates(row.runId).updates ?? [],
+    );
+  }
+
+  private buildRunState(
+    row: RunRow,
+    snapshot: WorkflowDefinitionSnapshot,
+    projectionSteps: WorkflowStepRecord[],
+    visibleSteps: WorkflowStepRecord[],
+    visibleUpdates: WorkflowUpdateRecord[],
+  ): WorkflowRunState {
     const sources = this.readRunSources(row.runId, snapshot);
     const carriedStepCount = this.carriedStepCount(row.runId);
-    const activeAttempt = row.status === "running" ? this.readActiveAttempt(row.runId) : undefined;
+    const activeAttempt =
+      row.status === "running" || row.status === "waiting"
+        ? this.readActiveAttempt(row.runId)
+        : undefined;
+    const runningAttempt = row.status === "running" ? activeAttempt : undefined;
+    const waitingNode =
+      row.status === "waiting"
+        ? (activeAttempt?.nodeId ?? projectionSteps.at(-1)?.nodeId)
+        : undefined;
     const humanDecision = this.readHumanDecisionReceipt(row.runId);
     const outputs: Record<string, unknown> = {};
     const results: Record<string, WorkflowNodeResult> = {};
-    for (const step of steps) {
+    for (const step of projectionSteps) {
       const result = resultForStep(step);
       results[step.nodeId] = result;
       if (step.outcome === "ok") outputs[step.nodeId] = step.output;
@@ -3449,9 +3526,9 @@ export class WorkflowRunStore {
       input: this.state.readJson(row.inputHash),
       outputs,
       results,
-      steps,
-      ...this.readUpdates(row.runId),
-      ...(activeAttempt === undefined ? {} : { currentNode: activeAttempt.nodeId }),
+      steps: visibleSteps,
+      ...(visibleUpdates.length === 0 ? {} : { updates: visibleUpdates }),
+      ...(runningAttempt === undefined ? {} : { currentNode: runningAttempt.nodeId }),
       ...(activeAttempt === undefined ? {} : { currentAttemptId: activeAttempt.attemptId }),
       ...(activeAttempt?.startedAt === null || activeAttempt === undefined
         ? {}
@@ -3472,9 +3549,7 @@ export class WorkflowRunStore {
       ...(row.statusDetail === null ? {} : { statusDetail: row.statusDetail }),
       ...(humanDecision === undefined ? {} : { humanDecision }),
       ...(row.paused === 0 ? {} : { paused: true }),
-      ...(row.status === "waiting" && steps.at(-1) !== undefined
-        ? { waitingOn: steps.at(-1)?.nodeId as string }
-        : {}),
+      ...(waitingNode === undefined ? {} : { waitingOn: waitingNode }),
       ...(row.finalOutputHash === null
         ? {}
         : { finalOutput: this.state.readJson(row.finalOutputHash) }),
@@ -3483,42 +3558,65 @@ export class WorkflowRunStore {
   }
 
   private readSteps(runId: string): WorkflowStepRecord[] {
+    const rows = this.state.connection
+      .prepare(`${STEP_ROW_SELECT} WHERE s.run_id = ? ORDER BY s.step_index`)
+      .all(runId)
+      .filter(isStepRow);
+    return this.mapStepRows(runId, rows, 0);
+  }
+
+  private readStepRange(runId: string, range: WorkflowRunViewRange): WorkflowStepRecord[] {
+    const rows = this.state.connection
+      .prepare(`${STEP_ROW_SELECT} WHERE s.run_id = ? ORDER BY s.step_index LIMIT ? OFFSET ?`)
+      .all(runId, range.limit, range.start)
+      .filter(isStepRow);
+    return this.mapStepRows(runId, rows, range.start);
+  }
+
+  private readLatestSteps(runId: string, through?: number): WorkflowStepRecord[] {
+    const throughClause = through === undefined ? "" : " AND s2.step_index <= ?";
+    const params = through === undefined ? [runId, runId] : [runId, runId, through];
     const rows = this.state.connection
       .prepare(
-        `SELECT s.step_index AS stepIndex, a.attempt_id AS attemptId, a.node_id AS nodeId,
-                a.node_type AS nodeType, a.status,
-                a.prompt_hash AS promptHash, a.output_hash AS outputHash,
-                s.output_override_hash AS outputOverrideHash,
-                a.receipt_hash AS receiptHash, a.error_hash AS errorHash,
-                prompt_entry.entry_hash AS promptEntryHash,
-                response_entry.entry_hash AS responseEntryHash,
-                first_link.entry_id AS firstEntryId, last_link.entry_id AS lastEntryId,
-                a.settings_scope_id AS settingsScopeId,
-                a.settings_change_number AS settingsChangeNumber,
-                a.settings_hash AS settingsHash,
-                a.started_at AS startedAt, a.finished_at AS finishedAt
-         FROM run_steps s
-         JOIN node_attempts a ON a.attempt_id = s.attempt_id
-         LEFT JOIN attempt_entries prompt_link
-           ON prompt_link.attempt_id = a.attempt_id AND prompt_link.role = 'prompt'
-         LEFT JOIN session_entries prompt_entry
-           ON prompt_entry.segment_id = prompt_link.segment_id
-          AND prompt_entry.entry_id = prompt_link.entry_id
-         LEFT JOIN attempt_entries response_link
-           ON response_link.attempt_id = a.attempt_id AND response_link.role = 'response'
-         LEFT JOIN session_entries response_entry
-           ON response_entry.segment_id = response_link.segment_id
-          AND response_entry.entry_id = response_link.entry_id
-         LEFT JOIN attempt_entries first_link
-           ON first_link.attempt_id = a.attempt_id AND first_link.role = 'first'
-         LEFT JOIN attempt_entries last_link
-           ON last_link.attempt_id = a.attempt_id AND last_link.role = 'last'
-         WHERE s.run_id = ? ORDER BY s.step_index`,
+        `${STEP_ROW_SELECT}
+         WHERE s.run_id = ? AND s.step_index IN (
+           SELECT max(s2.step_index) FROM run_steps s2
+           JOIN node_attempts a2 ON a2.attempt_id = s2.attempt_id
+           WHERE s2.run_id = ?${throughClause} GROUP BY a2.node_id
+         ) ORDER BY s.step_index`,
       )
-      .all(runId)
+      .all(...params)
       .filter(isStepRow);
+    return this.mapStepRows(runId, rows);
+  }
+
+  private readTakenTransitions(runId: string, through: number): string[] {
+    const rows = this.state.connection
+      .prepare(
+        `WITH ordered AS (
+           SELECT s.step_index, a.node_id AS nodeId,
+                  lag(a.node_id) OVER (ORDER BY s.step_index) AS previousNodeId
+           FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
+           WHERE s.run_id = ? AND s.step_index <= ?
+         )
+         SELECT DISTINCT previousNodeId, nodeId FROM ordered
+         WHERE previousNodeId IS NOT NULL ORDER BY previousNodeId, nodeId`,
+      )
+      .all(runId, through);
+    return rows.flatMap((row) =>
+      isRecord(row) && typeof row.previousNodeId === "string" && typeof row.nodeId === "string"
+        ? [`${row.previousNodeId}->${row.nodeId}`]
+        : [],
+    );
+  }
+
+  private mapStepRows(
+    runId: string,
+    rows: StepRow[],
+    expectedStart?: number,
+  ): WorkflowStepRecord[] {
     return rows.map((row, index) => {
-      if (row.stepIndex !== index)
+      if (expectedStart !== undefined && row.stepIndex !== expectedStart + index)
         throw new Error(`Workflow run step sequence has a gap: ${runId}`);
       const receipt =
         row.receiptHash === null ? {} : this.readJsonAs<StoredAttemptReceipt>(row.receiptHash);
@@ -3706,6 +3804,41 @@ export class WorkflowRunStore {
     return updates === undefined ? {} : { updates };
   }
 
+  private readCurrentUpdates(runId: string, range?: WorkflowRunViewRange): WorkflowUpdateRecord[] {
+    const rangeClause = range === undefined ? "" : " LIMIT ? OFFSET ?";
+    const params = range === undefined ? [runId] : [runId, range.limit, range.start];
+    const rows = this.state.connection
+      .prepare(
+        `WITH ranked AS (
+           SELECT u.update_id AS updateId, u.run_revision AS runRevision,
+                  a.node_id AS nodeId, u.attempt_id AS attemptId,
+                  u.update_type AS updateType, u.update_key AS updateKey,
+                  u.data_hash AS dataHash, u.recorded_at AS recordedAt,
+                  row_number() OVER (
+                    PARTITION BY u.update_type, u.update_key ORDER BY u.run_revision DESC
+                  ) AS rank
+           FROM workflow_updates u
+           JOIN node_attempts a ON a.attempt_id = u.attempt_id
+           WHERE a.run_id = ?
+         )
+         SELECT updateId, runRevision, nodeId, attemptId, updateType, updateKey, dataHash, recordedAt
+         FROM ranked WHERE rank = 1 ORDER BY runRevision${rangeClause}`,
+      )
+      .all(...params)
+      .filter(isUpdateRow);
+    return rows.map((row) => ({
+      updateId: row.updateId,
+      seq: row.runRevision,
+      at: new Date(row.recordedAt).toISOString(),
+      runId,
+      nodeId: row.nodeId,
+      attemptId: row.attemptId,
+      type: row.updateType,
+      key: row.updateKey,
+      data: this.readJsonAs<Record<string, unknown>>(row.dataHash),
+    }));
+  }
+
   private readJsonAs<T>(hash: Buffer): T {
     return this.state.readJson(hash) as T;
   }
@@ -3726,14 +3859,17 @@ export class WorkflowRunStore {
     return value as WorkflowDefinitionSnapshot;
   }
 
-  private traceEvents(run: RunRow): WorkflowTraceEvent[] {
+  private traceEvents(run: RunRow, range?: WorkflowRunViewRange): WorkflowTraceEvent[] {
+    const rangeClause = range === undefined ? "" : " LIMIT ? OFFSET ?";
+    const params =
+      range === undefined ? [run.resourceId] : [run.resourceId, range.limit, range.start];
     const rows = this.state.connection
       .prepare(
         `SELECT resource_revision AS resourceRevision, event_type AS eventType,
                 payload_hash AS payloadHash, recorded_at AS recordedAt
-         FROM events WHERE resource_id = ? ORDER BY resource_revision`,
+         FROM events WHERE resource_id = ? ORDER BY resource_revision${rangeClause}`,
       )
-      .all(run.resourceId);
+      .all(...params);
     const events: WorkflowTraceEvent[] = [];
     for (const row of rows) {
       /* istanbul ignore if -- exact schema and internal query shape */
@@ -3787,7 +3923,11 @@ export class WorkflowRunStore {
     return row;
   }
 
-  private loadSegment(segment: SegmentRow, runState: WorkflowRunState): SessionCaptureSegment {
+  private loadSegment(
+    segment: SegmentRow,
+    runState: WorkflowRunState,
+    ranges?: { entries: WorkflowRunViewRange; events: WorkflowRunViewRange },
+  ): SessionCaptureSegment {
     const binding =
       segment.bindingHash === null
         ? null
@@ -3795,9 +3935,15 @@ export class WorkflowRunStore {
     const entries = this.state.connection
       .prepare(
         `SELECT entry_seq AS entrySeq, entry_hash AS entryHash, recorded_at AS recordedAt
-         FROM session_entries WHERE segment_id = ? ORDER BY entry_seq`,
+         FROM session_entries WHERE segment_id = ? ORDER BY entry_seq${
+           ranges === undefined ? "" : " LIMIT ? OFFSET ?"
+         }`,
+      )
+      .all(
+        ...(ranges === undefined
+          ? [segment.segmentId]
+          : [segment.segmentId, ranges.entries.limit, ranges.entries.start]),
       )
-      .all(segment.segmentId)
       .filter(isSessionEntryRow)
       .map((row) => ({
         seq: row.entrySeq,
@@ -3810,9 +3956,15 @@ export class WorkflowRunStore {
                 attempt_id AS attemptId, turn_id AS turnId, message_id AS messageId,
                 tool_call_id AS toolCallId, payload_hash AS payloadHash,
                 recorded_at AS recordedAt
-         FROM session_events WHERE segment_id = ? ORDER BY event_seq`,
+         FROM session_events WHERE segment_id = ? ORDER BY event_seq${
+           ranges === undefined ? "" : " LIMIT ? OFFSET ?"
+         }`,
+      )
+      .all(
+        ...(ranges === undefined
+          ? [segment.segmentId]
+          : [segment.segmentId, ranges.events.limit, ranges.events.start]),
       )
-      .all(segment.segmentId)
       .filter(isSessionEventRow)
       .map((row) => ({
         seq: row.eventSeq,
@@ -3839,7 +3991,17 @@ export class WorkflowRunStore {
       ...(failure === undefined ? {} : { failure }),
     };
     const diagnostics: string[] = [];
-    if (entries.length !== segment.entryCount || events.length !== segment.eventCount) {
+    const durableCounts =
+      ranges === undefined
+        ? { entries: entries.length, events: events.length }
+        : {
+            entries: sessionRecordCount(this.state, "session_entries", segment.segmentId),
+            events: sessionRecordCount(this.state, "session_events", segment.segmentId),
+          };
+    if (
+      durableCounts.entries !== segment.entryCount ||
+      durableCounts.events !== segment.eventCount
+    ) {
       diagnostics.push("session capture counts do not match durable rows");
     }
     if (runState.status !== "running" && segment.status === "recording") {
@@ -4219,6 +4381,17 @@ function workflowSourceFromRow(row: RunSourceRow): WorkflowSource {
     : { kind: "file", path: row.sourceRef, hash: row.sourceRevision };
 }
 
+function sessionRecordCount(
+  state: StateDatabase,
+  table: "session_entries" | "session_events",
+  segmentId: string,
+): number {
+  const row = state.connection
+    .prepare(`SELECT count(*) AS count FROM ${table} WHERE segment_id = ?`)
+    .get(segmentId);
+  return isCountRow(row) ? row.count : 0;
+}
+
 function segmentIdFor(runId: string, attemptId?: string): string {
   return `segment-${createHash("sha256")
     .update(`${runId}\0${attemptId ?? ""}`)
@@ -4421,32 +4594,12 @@ function assertActorType(value: string): ActorType {
 }
 
 function assertFollowUpState(value: string): WorkflowFollowUpState {
-  if (
-    value !== "queued" &&
-    value !== "pending_presentation" &&
-    value !== "ready" &&
-    value !== "sent" &&
-    value !== "removed" &&
-    value !== "cancelled"
-  ) {
+  if (value !== "queued" && value !== "removed" && value !== "cancelled") {
     throw new Error(`Unknown workflow follow-up state: ${value}`);
   }
   return value;
 }
 
-function assertPresentationState(value: string): WorkflowPresentationState {
-  if (
-    value !== "none" &&
-    value !== "not-needed" &&
-    value !== "pending" &&
-    value !== "settled" &&
-    value !== "unavailable"
-  ) {
-    throw new Error(`Unknown workflow presentation state: ${value}`);
-  }
-  return value;
-}
-
 function isSettingsScopeRow(value: unknown): value is SettingsScopeRow {
   return (
     isRecord(value) &&
@@ -4500,27 +4653,11 @@ function isSettingsChangeRow(value: unknown): value is SettingsChangeRow {
   );
 }
 
-function isFollowUpQueueRow(value: unknown): value is FollowUpQueueRow {
-  return (
-    isRecord(value) &&
-    typeof value.runId === "string" &&
-    typeof value.resourceId === "string" &&
-    (typeof value.originSessionId === "string" || value.originSessionId === null) &&
-    typeof value.presentationState === "string" &&
-    (typeof value.presentationEntryId === "string" || value.presentationEntryId === null) &&
-    (typeof value.presentationAssistantEntryId === "string" ||
-      value.presentationAssistantEntryId === null) &&
-    (Buffer.isBuffer(value.presentationReasonHash) || value.presentationReasonHash === null) &&
-    typeof value.revision === "number"
-  );
-}
-
 function isFollowUpRow(value: unknown): value is FollowUpRow {
   return (
     isRecord(value) &&
     typeof value.followUpId === "string" &&
     typeof value.resourceId === "string" &&
-    typeof value.queueResourceId === "string" &&
     typeof value.runId === "string" &&
     typeof value.requestId === "string" &&
     typeof value.orderNumber === "number" &&
@@ -4530,11 +4667,9 @@ function isFollowUpRow(value: unknown): value is FollowUpRow {
     typeof value.sourceType === "string" &&
     Buffer.isBuffer(value.promptHash) &&
     typeof value.status === "string" &&
-    (typeof value.sessionEntryId === "string" || value.sessionEntryId === null) &&
     (Buffer.isBuffer(value.reasonHash) || value.reasonHash === null) &&
     typeof value.createdAt === "number" &&
     typeof value.updatedAt === "number" &&
-    (typeof value.sentAt === "number" || value.sentAt === null) &&
     typeof value.revision === "number"
   );
 }
@@ -4543,6 +4678,14 @@ function isParentRunRow(value: unknown): value is { parentRunId: string | null }
   return isRecord(value) && (typeof value.parentRunId === "string" || value.parentRunId === null);
 }
 
+function isRunLineageRow(value: unknown): value is { rootRunId: string; restartNumber: number } {
+  return (
+    isRecord(value) &&
+    typeof value.rootRunId === "string" &&
+    typeof value.restartNumber === "number"
+  );
+}
+
 function isStatusRow(value: unknown): value is { status: string } {
   return isRecord(value) && typeof value.status === "string";
 }
@@ -4555,10 +4698,6 @@ function isStepIndexRow(value: unknown): value is { stepIndex: number } {
   return isRecord(value) && typeof value.stepIndex === "number";
 }
 
-function isLeaseExpiryRow(value: unknown): value is { expiresAt: number | null } {
-  return isRecord(value) && (typeof value.expiresAt === "number" || value.expiresAt === null);
-}
-
 function isNextOrderRow(value: unknown): value is { nextOrder: number } {
   return isRecord(value) && typeof value.nextOrder === "number";
 }