@osolmaz/pi-workflows 0.16.5 → 0.16.7

package/src/workflows/store.ts

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { closeAttemptTime, closeRunTime } from "../state/attempt-time.js";
 import { StateDatabase, workflowStatePath } from "../state/database.js";
 import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
 import {
@@ -18,7 +19,7 @@ import {
   type ViewerDeltaDraft,
 } from "../state/viewer.js";
 import { WorkflowMessageStore, workflowMessageIdFor } from "../state/workflow-messages.js";
-import { compositionMetadata } from "./composition.js";
+import { compileWorkflowDefinition, compositionMetadata } from "./composition.js";
 import { ClaimLostError } from "./errors.js";
 import { HumanDecisionStore } from "./human-decision.js";
 import { applyJsonPatch, validateJsonPatch } from "./json-patch.js";
@@ -49,7 +50,6 @@ import type {
   WorkflowEffectReservation,
   HumanDecisionReceipt,
   HumanDecisionRequest,
-  ResolvedHumanDecision,
   WorkflowNodeDefinition,
   WorkflowNodeResult,
   WorkflowNodeSnapshot,
@@ -82,7 +82,6 @@ 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,
@@ -150,7 +149,6 @@ export type WorkflowRunTerminalData = {
   input: JsonValue;
   finalOutput: JsonValue | null;
   error: string | null;
-  presentationInstructions: string;
   restartNumber: number;
 };
 
@@ -171,6 +169,18 @@ export type WorkflowRunStoreOptions = {
 };
 
 /** The state boundary used by workflow code, including out-of-process runners. */
+import {
+  acceptedRequestOutput,
+  ensureWorkflowRequest,
+  requestForAttempt,
+  type WorkflowCheckpointState,
+} from "./requests.js";
+import {
+  applyExecutionTransition,
+  executionTransition,
+  type WorkflowTransition,
+} from "./transitions.js";
+
 export interface WorkflowExecutionStore {
   readonly databasePath: string;
   initializeRun(
@@ -180,14 +190,9 @@ export interface WorkflowExecutionStore {
   ): Promise<string>;
   prepareRunResume(runId: string): Promise<WorkflowRunState>;
   readRunState(runId: string): WorkflowRunState | null | Promise<WorkflowRunState | null>;
-  writeSnapshot(
-    runId: string,
-    state: WorkflowRunState,
-    event: WorkflowTraceEventDraft,
-  ): Promise<WorkflowTraceEvent>;
+  commitTransition(runId: string, transition: WorkflowTransition): Promise<WorkflowTraceEvent>;
   publishUpdate(
     runId: string,
-    state: WorkflowRunState,
     nodeId: string,
     attemptId: string,
     update: WorkflowUpdateInput,
@@ -208,8 +213,7 @@ export interface WorkflowExecutionStore {
     scopeId: string,
     changeNumber: number,
   ): WorkflowSettingsScopeRecord | undefined | Promise<WorkflowSettingsScopeRecord | undefined>;
-  createHumanDecisionRequest(request: HumanDecisionRequest): Promise<"created" | "adopted">;
-  readResolvedHumanDecision(decisionId: string): Promise<ResolvedHumanDecision | null>;
+  readCheckpoint(runId: string, attemptId: string): Promise<WorkflowCheckpointState | undefined>;
   reserveEffect(options: {
     runId: string;
     attemptId: string;
@@ -269,7 +273,6 @@ type StepRow = {
   status: string;
   promptHash: Buffer | null;
   outputHash: Buffer | null;
-  outputOverrideHash: Buffer | null;
   receiptHash: Buffer | null;
   promptEntryHash: Buffer | null;
   responseEntryHash: Buffer | null;
@@ -535,16 +538,25 @@ export class WorkflowRunStore {
     return revision;
   }
 
-  async createHumanDecisionRequest(request: HumanDecisionRequest): Promise<"created" | "adopted"> {
-    return await new HumanDecisionStore(this.databasePath, { state: this.state }).createRequest(
-      request,
-    );
-  }
-
-  async readResolvedHumanDecision(decisionId: string): Promise<ResolvedHumanDecision | null> {
-    return await new HumanDecisionStore(this.databasePath, { state: this.state }).readResolved(
-      decisionId,
-    );
+  async readCheckpoint(
+    runId: string,
+    attemptId: string,
+  ): Promise<WorkflowCheckpointState | undefined> {
+    const request = requestForAttempt(this.state, runId, attemptId);
+    if (request === undefined) return undefined;
+    if (request.kind !== "checkpoint" && request.kind !== "decision") {
+      throw new Error("The attempt does not own a checkpoint request");
+    }
+    if (request.status !== "settled") return { request };
+    const output = acceptedRequestOutput(this.state, request);
+    const humanDecision =
+      request.kind === "decision"
+        ? this.readHumanDecisionReceipt(runId, request.requestId)
+        : undefined;
+    if (request.kind === "decision" && humanDecision === undefined) {
+      throw new Error("The checkpoint has no verified human decision receipt");
+    }
+    return { request, output, ...(humanDecision === undefined ? {} : { humanDecision }) };
   }
 
   async reserveEffect(options: {
@@ -832,7 +844,7 @@ export class WorkflowRunStore {
     options: InitializeWorkflowRunOptions = {},
   ): Promise<string> {
     return await this.initializeRunFromSnapshot(
-      createDefinitionSnapshot(workflow),
+      createDefinitionSnapshot(compileWorkflowDefinition(workflow)),
       workflow.name,
       state,
       options,
@@ -904,22 +916,12 @@ export class WorkflowRunStore {
             [...runViewerTargets(state, traceEvent), ...this.viewerInspectorTargets(state.runId)],
             now,
           );
-          this.syncContinuationIdentity(state);
           context.revision = revision;
           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}`);
+        if (state.parentRunId !== undefined) {
+          throw new Error("A restart must have an explicit host reservation");
         }
         this.state.connection
           .prepare(
@@ -950,7 +952,7 @@ export class WorkflowRunStore {
           .prepare(
             `INSERT INTO runs(
                run_id, resource_id, project_id, parent_run_id, root_run_id, lineage_kind,
-               restart_number, parent_terminal_fingerprint, definition_digest,
+               restart_number, parent_run_revision, 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
@@ -959,10 +961,10 @@ export class WorkflowRunStore {
           .run(
             state.runId,
             resourceId,
-            state.parentRunId ?? null,
-            isRunLineageRow(parentLineage) ? parentLineage.rootRunId : state.runId,
-            state.parentRunId === undefined ? null : "continuation",
-            isRunLineageRow(parentLineage) ? parentLineage.restartNumber : 0,
+            null,
+            state.runId,
+            null,
+            0,
             definitionDigest,
             state.workflowName,
             launchOptionsHash,
@@ -979,7 +981,6 @@ export class WorkflowRunStore {
           );
         initializeViewerRun(this.state, state.runId, now);
         this.insertRunSources(state.runId, source, state.workflowSources ?? []);
-        this.syncContinuationIdentity(state);
         insertRunEvent(this.state, resourceId, 1, at, {
           scope: "run",
           type: "run_created",
@@ -1010,7 +1011,7 @@ export class WorkflowRunStore {
     const now = Date.now();
     return this.state.transaction(() => {
       this.requireRunAcceptsSettings(options.runId, false);
-      const originRunId = this.logicalOriginRunId(options.runId);
+      const originRunId = options.runId;
       const scopeId = workflowSettingsScopeId(originRunId, options.mountPath, options.invocation);
       const existing = this.settingsScopeRow(scopeId);
       if (existing !== undefined) {
@@ -1106,7 +1107,7 @@ export class WorkflowRunStore {
   }
 
   private settingsScopesForRunView(runId: string): WorkflowSettingsScopeRecord[] {
-    const originRunId = this.logicalOriginRunId(runId);
+    const originRunId = runId;
     return this.state.connection
       .prepare(
         `SELECT s.scope_id AS scopeId, s.resource_id AS resourceId,
@@ -1128,7 +1129,7 @@ export class WorkflowRunStore {
     runId: string,
     range: WorkflowRunViewRange,
   ): WorkflowSettingsScopeRecord[] {
-    const originRunId = this.logicalOriginRunId(runId);
+    const originRunId = runId;
     return this.state.connection
       .prepare(
         `SELECT s.scope_id AS scopeId, s.resource_id AS resourceId,
@@ -1464,8 +1465,27 @@ export class WorkflowRunStore {
   }
 
   async prepareRunResume(runId: string): Promise<WorkflowRunState> {
-    const state = this.readRunState(runId);
+    let state = this.readRunState(runId);
     if (state === null) throw new Error(`Cannot resume unreadable workflow run: ${runId}`);
+    if (state.status === "waiting" && state.currentAttemptId !== undefined) {
+      const checkpoint = await this.readCheckpoint(runId, state.currentAttemptId);
+      if (checkpoint?.request.status === "settled") {
+        if (state.waitingOn === undefined)
+          throw new Error("Accepted checkpoint has no waiting node");
+        await this.commitTransition(runId, {
+          kind: "resumeInteraction",
+          event: {
+            scope: "node",
+            type: "interaction_accepted",
+            nodeId: state.waitingOn,
+            attemptId: state.currentAttemptId,
+            payload: { requestId: checkpoint.request.requestId },
+          },
+        });
+        state = this.readRunState(runId);
+        if (state === null) throw new Error(`Workflow run became unreadable: ${runId}`);
+      }
+    }
     if (state.status !== "running") {
       throw new Error(`Cannot resume workflow run ${runId} with status ${state.status}`);
     }
@@ -1519,37 +1539,39 @@ export class WorkflowRunStore {
     delete loaded.state.currentNode;
     delete loaded.state.currentAttemptId;
     delete loaded.state.currentNodeStartedAt;
-    delete loaded.state.currentNodeDeadlineAt;
+    delete loaded.state.currentNodeTimeoutMs;
+    delete loaded.state.currentNodeElapsedMs;
     delete loaded.state.currentSettingsScopeId;
     delete loaded.state.currentSettingsChangeNumber;
     delete loaded.state.currentSettingsHash;
     delete loaded.state.statusDetail;
     delete loaded.state.paused;
-    await this.writeSnapshot(runId, loaded.state, {
-      scope: "run",
-      type: "run_interrupted",
-      payload: { error: reason },
-    });
+    await this.commitTransition(
+      runId,
+      executionTransition(loaded.state, {
+        scope: "run",
+        type: "run_interrupted",
+        payload: { error: reason },
+      }),
+    );
     return this.readRun(runId, { includeTrace: true });
   }
 
   async publishUpdate(
     runId: string,
-    state: WorkflowRunState,
     nodeId: string,
     attemptId: string,
     update: WorkflowUpdateInput,
     options: { signal?: AbortSignal } = {},
   ): Promise<{ event: WorkflowTraceEvent; record: WorkflowUpdateRecord }> {
     return await this.withRunLock(runId, async () =>
-      this.publishUpdateSynchronous(runId, state, nodeId, attemptId, update, options),
+      this.publishUpdateSynchronous(runId, nodeId, attemptId, update, options),
     );
   }
 
   /** Server-only synchronous form for an already serialized command transaction. */
   publishUpdateSynchronous(
     runId: string,
-    state: WorkflowRunState,
     nodeId: string,
     attemptId: string,
     update: WorkflowUpdateInput,
@@ -1558,6 +1580,14 @@ export class WorkflowRunStore {
     if (options.signal?.aborted === true) {
       throw options.signal.reason ?? new Error("workflow update attempt is no longer active");
     }
+    const state = this.readRunState(runId);
+    if (
+      state === null ||
+      state.currentAttemptId !== attemptId ||
+      (state.currentNode ?? state.waitingOn) !== nodeId
+    ) {
+      throw new Error("Workflow update does not match the active attempt");
+    }
     const exists = (state.updates ?? []).some(
       (record) => record.type === update.type && record.key === update.key,
     );
@@ -1632,10 +1662,9 @@ export class WorkflowRunStore {
     return { event: acceptedEvent, record: acceptedRecord };
   }
 
-  async writeSnapshot(
+  async commitTransition(
     runId: string,
-    state: WorkflowRunState,
-    event: WorkflowTraceEventDraft,
+    transition: WorkflowTransition,
   ): Promise<WorkflowTraceEvent> {
     return await this.withRunLock(runId, async () => {
       let accepted: WorkflowTraceEvent | undefined;
@@ -1647,6 +1676,79 @@ export class WorkflowRunStore {
         const now = Date.now();
         const at = new Date(now).toISOString();
         const snapshot = this.readDefinition(run.definitionHash);
+        const current = this.materializeRunState(run, snapshot);
+        const state = applyExecutionTransition(current, snapshot, transition, at);
+        if (
+          transition.kind === "finishAttempt" &&
+          transition.step.nodeType === "checkpoint" &&
+          transition.step.outcome === "ok"
+        ) {
+          const request = requestForAttempt(this.state, runId, transition.step.attemptId);
+          if (
+            request === undefined ||
+            request.status !== "settled" ||
+            canonicalJson(acceptedRequestOutput(this.state, request)) !==
+              canonicalJson(transition.step.output)
+          ) {
+            throw new Error("Checkpoint completion requires its exact accepted response");
+          }
+        }
+        if (transition.kind === "waitForInput") {
+          const node = snapshot.nodes[transition.event.nodeId ?? ""];
+          if ((node?.humanDecision !== undefined) !== (transition.requestKind === "decision")) {
+            throw new Error("Checkpoint response authority does not match its definition");
+          }
+          if (transition.requestKind === "decision") {
+            const decision = transition.contract as unknown as HumanDecisionRequest;
+            if (
+              decision.runId !== runId ||
+              decision.attemptId !== transition.event.attemptId ||
+              decision.nodeId !== transition.event.nodeId ||
+              decision.decisionId !== transition.requestId
+            ) {
+              throw new Error("Human decision does not match the active checkpoint");
+            }
+            new HumanDecisionStore(this.databasePath, { state: this.state }).createRequest(
+              decision,
+            );
+          }
+          const binding = this.state.connection
+            .prepare("SELECT origin_session_id AS sessionId FROM run_bindings WHERE run_id = ?")
+            .get(runId) as { sessionId: string | null } | undefined;
+          ensureWorkflowRequest(
+            this.state,
+            {
+              requestId: transition.requestId,
+              runId,
+              attemptId: transition.event.attemptId ?? "",
+              targetSessionId: binding?.sessionId ?? "",
+              kind: transition.requestKind,
+              contract: transition.contract,
+            },
+            now,
+          );
+        }
+        if (
+          transition.kind === "resume" &&
+          transition.attemptId === undefined &&
+          current.currentAttemptId !== undefined
+        ) {
+          const request = this.state.connection
+            .prepare(
+              "SELECT 1 FROM interactive_requests WHERE attempt_id = ? AND status = 'pending'",
+            )
+            .get(current.currentAttemptId);
+          if (request !== undefined)
+            throw new Error("A pending request must resume its exact attempt");
+          const retired = this.state.connection
+            .prepare(
+              `UPDATE node_attempts SET status = 'cancelled', finished_at = ?, updated_at = ?
+             WHERE attempt_id = ? AND run_id = ? AND status = 'interrupted'`,
+            )
+            .run(now, now, current.currentAttemptId, runId);
+          if (retired.changes !== 1) throw new Error("Only an interrupted attempt can be replaced");
+        }
+        const event = transition.event;
         this.assertSettingsRouteCurrent(event, snapshot);
         const traceEvent: WorkflowTraceEvent = { seq: revision, at, runId, ...event };
         state.traceSeq = revision;
@@ -1655,6 +1757,15 @@ export class WorkflowRunStore {
         this.persistRunState(run, state, revision, now);
         this.transitionFollowUpsForRunState(state, event, now);
         this.syncNodeAttempts(state, snapshot, now);
+        if (transition.kind === "finishAttempt") {
+          this.state.connection
+            .prepare(
+              `UPDATE interactive_requests SET consumed_at = ?, updated_at = ?
+             WHERE run_id = ? AND attempt_id = ? AND status = 'settled'
+               AND accepted_submission_id IS NOT NULL AND consumed_at IS NULL`,
+            )
+            .run(now, now, runId, transition.step.attemptId);
+        }
         recordViewerDeltas(this.state, runId, runViewerTargets(state, traceEvent), now);
         this.snapshotLifecycle?.({
           runId,
@@ -2205,16 +2316,6 @@ export class WorkflowRunStore {
     return row?.errorHash == null ? null : this.readText(row.errorHash);
   }
 
-  readPresentationInstructions(runId: string): string {
-    const row = this.state.connection
-      .prepare("SELECT presentation_prompt_hash AS hash FROM runs WHERE run_id = ?")
-      .get(runId) as { hash?: Buffer | null } | undefined;
-    if (row?.hash == null) {
-      return "Explain the final workflow result to the user in a normal response.";
-    }
-    return this.readText(row.hash);
-  }
-
   readTerminalData(runId: string): WorkflowRunTerminalData | null {
     const row = this.state.connection
       .prepare(
@@ -2238,7 +2339,6 @@ export class WorkflowRunStore {
       input: this.readRunInput(runId) as JsonValue,
       finalOutput: this.readRunFinalOutput(runId),
       error: this.readRunError(runId),
-      presentationInstructions: this.readPresentationInstructions(runId),
       restartNumber: row.restartNumber,
     };
   }
@@ -2249,6 +2349,17 @@ export class WorkflowRunStore {
     return this.materializeRunState(row, this.readDefinition(row.definitionHash));
   }
 
+  runRevision(runId: string): number {
+    const row = this.state.connection
+      .prepare(
+        `SELECT resources.revision FROM resources
+       JOIN runs ON runs.resource_id = resources.resource_id WHERE runs.run_id = ?`,
+      )
+      .get(runId) as { revision: number } | undefined;
+    if (row === undefined) throw new Error(`Workflow run not found: ${runId}`);
+    return row.revision;
+  }
+
   readRun(runId: string, options: ReadWorkflowRunOptions = {}): LoadedWorkflowRun | null {
     const row = this.readRunRow(runId);
     if (row === undefined) return null;
@@ -2276,7 +2387,7 @@ export class WorkflowRunStore {
     const row = this.readRunRow(runId);
     if (row === undefined) return null;
     const segment = this.segmentRow(segmentIdFor(runId));
-    const settingsOrigin = this.logicalOriginRunId(runId);
+    const settingsOrigin = runId;
     const scalar = (sql: string, ...params: unknown[]): number => {
       const count = this.state.connection.prepare(sql).get(...params);
       return isCountRow(count) ? count.count : 0;
@@ -2652,7 +2763,10 @@ export class WorkflowRunStore {
         state.runId,
       );
     if (update.changes !== 1) throw new Error(`Workflow run is missing: ${state.runId}`);
-    if (state.status !== "running") {
+    if (state.paused || ["completed", "failed", "cancelled"].includes(state.status)) {
+      closeRunTime(this.state, state.runId);
+    }
+    if (state.status !== "running" && state.status !== run.status) {
       this.enqueueRunSettlementEffect(run.resourceId, expectedRevision, state, now);
     }
   }
@@ -2793,20 +2907,13 @@ export class WorkflowRunStore {
     initialSettings: InitialWorkflowSettingsScope[],
     now: number,
   ): void {
-    if (state.parentRunId !== undefined) {
-      this.state.connection
-        .prepare(
-          `UPDATE workflow_settings SET active_run_id = ?, updated_at = ? WHERE active_run_id = ?`,
-        )
-        .run(state.runId, now, state.parentRunId);
-    }
     const existing = this.state.connection
       .prepare("SELECT COUNT(*) AS count FROM workflow_settings WHERE active_run_id = ?")
       .get(state.runId);
     const hasSettings = isCountRow(existing) && existing.count > 0;
     if (hasSettings) return;
     for (const scope of initialSettings) {
-      const originRunId = this.logicalOriginRunId(state.runId);
+      const originRunId = state.runId;
       const scopeId = workflowSettingsScopeId(originRunId, scope.mountPath, scope.invocation);
       const resourceId = this.mutations.ensureResource("settings", scopeId, now);
       const settingsHash = this.state.putJson(scope.settings, now);
@@ -2833,19 +2940,6 @@ export class WorkflowRunStore {
     }
   }
 
-  private logicalOriginRunId(runId: string): string {
-    let current = runId;
-    for (let depth = 0; depth < 100; depth += 1) {
-      const row = this.state.connection
-        .prepare("SELECT parent_run_id AS parentRunId FROM runs WHERE run_id = ?")
-        .get(current);
-      if (!isParentRunRow(row)) return current;
-      if (row.parentRunId === null) return current;
-      current = row.parentRunId;
-    }
-    throw new Error(`Workflow continuation chain is too deep for run ${runId}`);
-  }
-
   private requireRunAcceptsSettings(runId: string, allowWaiting: boolean): void {
     const row = this.state.connection
       .prepare("SELECT status FROM runs WHERE run_id = ?")
@@ -3101,15 +3195,7 @@ export class WorkflowRunStore {
     const rows = this.state.connection
       .prepare(
         `${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'`,
+         WHERE f.run_id = ? AND f.status = 'queued'`,
       )
       .all(state.runId)
       .filter(isFollowUpRow);
@@ -3144,7 +3230,8 @@ export class WorkflowRunStore {
     snapshot: WorkflowDefinitionSnapshot,
     now: number,
   ): void {
-    for (const step of state.steps.slice(state.carriedStepCount ?? 0)) {
+    for (const step of state.steps) {
+      closeAttemptTime(this.state, step.attemptId);
       const promptEntryId = this.findAttemptPromptEntry(state.runId, step.attemptId);
       const promptHash =
         promptEntryId === undefined && step.prompt !== null
@@ -3219,25 +3306,20 @@ export class WorkflowRunStore {
     }
     if (state.currentAttemptId !== undefined && state.currentNode !== undefined) {
       this.ensureAttempt(state, state.currentNode, state.currentAttemptId, now, snapshot);
-      if (state.currentNodeDeadlineAt !== undefined) {
-        const deadlineAt =
-          state.currentNodeDeadlineAt === null ? null : Date.parse(state.currentNodeDeadlineAt);
-        if (deadlineAt !== null && !Number.isFinite(deadlineAt)) {
-          throw new Error("Workflow node deadline is invalid");
-        }
+      if (state.currentNodeTimeoutMs !== undefined) {
         this.state.connection
           .prepare(
-            `UPDATE node_attempts SET deadline_at = ?, updated_at = ?
-             WHERE attempt_id = ? AND run_id = ?
+            `UPDATE node_attempts SET timeout_ms = ?, updated_at = ?
+             WHERE attempt_id = ? AND run_id = ? AND timeout_ms IS NULL
                AND status IN ('pending', 'running', 'waiting', 'interrupted')`,
           )
-          .run(deadlineAt, now, state.currentAttemptId, state.runId);
+          .run(state.currentNodeTimeoutMs ?? 0, now, state.currentAttemptId, state.runId);
       }
     }
-    this.syncRunSteps(state, now);
+    this.syncRunSteps(state);
   }
 
-  private syncRunSteps(state: WorkflowRunState, now: number): void {
+  private syncRunSteps(state: WorkflowRunState): void {
     const existingRows = this.state.connection
       .prepare(
         `SELECT step_index AS stepIndex, attempt_id AS attemptId
@@ -3257,18 +3339,16 @@ export class WorkflowRunStore {
       const step = state.steps[stepIndex];
       /* istanbul ignore if -- array index follows a checked bound */
       if (step === undefined) throw new Error("Workflow run step became unavailable");
-      const attemptOutput = this.readAttemptOutput(step.attemptId);
-      const carried = stepIndex < (state.carriedStepCount ?? 0);
-      const outputOverrideHash =
-        carried && canonicalJson(attemptOutput) !== canonicalJson(step.output)
-          ? this.state.putJson(step.output, now)
-          : null;
+      const attempt = this.state.connection
+        .prepare("SELECT run_id AS runId FROM node_attempts WHERE attempt_id = ?")
+        .get(step.attemptId) as { runId: string } | undefined;
+      if (attempt?.runId !== state.runId) throw new Error("A run cannot own another run's step");
       this.state.connection
         .prepare(
-          `INSERT INTO run_steps(run_id, step_index, attempt_id, output_override_hash)
-           VALUES (?, ?, ?, ?)`,
+          `INSERT INTO run_steps(run_id, step_index, attempt_id)
+           VALUES (?, ?, ?)`,
         )
-        .run(state.runId, stepIndex, step.attemptId, outputOverrideHash);
+        .run(state.runId, stepIndex, step.attemptId);
     }
   }
 
@@ -3341,31 +3421,6 @@ export class WorkflowRunStore {
     return isEntryIdentityRow(row) ? row.entryId : undefined;
   }
 
-  private readAttemptOutput(attemptId: string): unknown {
-    const row = this.state.connection
-      .prepare(
-        `SELECT a.output_hash AS outputHash, a.receipt_hash AS receiptHash,
-                e.entry_hash AS responseEntryHash
-         FROM node_attempts a
-         LEFT JOIN attempt_entries l ON l.attempt_id = a.attempt_id AND l.role = 'response'
-         LEFT JOIN session_entries e
-           ON e.segment_id = l.segment_id AND e.entry_id = l.entry_id
-         WHERE a.attempt_id = ?`,
-      )
-      .get(attemptId);
-    if (!isAttemptValueRow(row)) {
-      throw new Error(`Workflow node attempt is missing: ${attemptId}`);
-    }
-    if (row.outputHash !== null) return this.state.readJson(row.outputHash);
-    if (row.responseEntryHash === null) return null;
-    const receipt =
-      row.receiptHash === null ? {} : this.readJsonAs<StoredAttemptReceipt>(row.receiptHash);
-    return assistantOutputFromEntry(
-      this.state.readJson(row.responseEntryHash),
-      receipt.assistantMessage?.maxChars,
-    );
-  }
-
   private ensureAttempt(
     state: WorkflowRunState,
     nodeId: string,
@@ -3473,34 +3528,6 @@ export class WorkflowRunStore {
     }
   }
 
-  private syncContinuationIdentity(state: WorkflowRunState): void {
-    if (state.parentRunId === undefined || state.humanDecision === undefined) return;
-    const createdAt = Date.parse(state.humanDecision.acceptedAt);
-    this.state.connection
-      .prepare(
-        `INSERT INTO continuations(
-           decision_id, parent_run_id, continuation_run_id, created_at
-         ) VALUES (?, ?, ?, ?)
-         ON CONFLICT(decision_id) DO NOTHING`,
-      )
-      .run(state.humanDecision.decisionId, state.parentRunId, state.runId, createdAt);
-    const row = this.state.connection
-      .prepare(
-        `SELECT parent_run_id AS parentRunId, continuation_run_id AS continuationRunId,
-                created_at AS createdAt
-         FROM continuations WHERE decision_id = ?`,
-      )
-      .get(state.humanDecision.decisionId);
-    if (
-      !isContinuationIdentityRow(row) ||
-      row.parentRunId !== state.parentRunId ||
-      row.continuationRunId !== state.runId ||
-      row.createdAt !== createdAt
-    ) {
-      throw new Error("Immutable human decision continuation conflicts");
-    }
-  }
-
   private readRunRow(runId: string): RunRow | undefined {
     const row = this.state.connection
       .prepare(
@@ -3544,7 +3571,6 @@ export class WorkflowRunStore {
     visibleUpdates: WorkflowUpdateRecord[],
   ): WorkflowRunState {
     const sources = this.readRunSources(row.runId, snapshot);
-    const carriedStepCount = this.carriedStepCount(row.runId);
     const activeAttempt =
       row.status === "running" || row.status === "waiting"
         ? this.readActiveAttempt(row.runId)
@@ -3579,13 +3605,10 @@ export class WorkflowRunStore {
       runId: row.runId,
       workflowName: row.workflowRef,
       ...(row.parentRunId === null ? {} : { parentRunId: row.parentRunId }),
-      ...(carriedStepCount === 0 ? {} : { carriedStepCount }),
       ...(row.title === null ? {} : { runTitle: row.title }),
       ...(sources.root === undefined ? {} : { workflowSource: sources.root }),
       ...(sources.mounted.length === 0 ? {} : { workflowSources: sources.mounted }),
-      ...(sources.mounted.length !== 0 || snapshot.composition?.mounts.length
-        ? { definitionDigest: `sha256:${row.definitionDigest.toString("hex")}` }
-        : {}),
+      definitionDigest: `sha256:${row.definitionDigest.toString("hex")}`,
       startedAt: new Date(row.createdAt).toISOString(),
       ...(row.finishedAt === null ? {} : { finishedAt: new Date(row.finishedAt).toISOString() }),
       updatedAt: new Date(row.updatedAt).toISOString(),
@@ -3600,13 +3623,11 @@ export class WorkflowRunStore {
       ...(activeAttempt?.startedAt === null || activeAttempt === undefined
         ? {}
         : { currentNodeStartedAt: new Date(activeAttempt.startedAt).toISOString() }),
-      ...(activeAttempt === undefined
+      ...(activeAttempt === undefined || activeAttempt.timeoutMs === null
         ? {}
         : {
-            currentNodeDeadlineAt:
-              activeAttempt.deadlineAt === null
-                ? null
-                : new Date(activeAttempt.deadlineAt).toISOString(),
+            currentNodeTimeoutMs: activeAttempt.timeoutMs === 0 ? null : activeAttempt.timeoutMs,
+            currentNodeElapsedMs: activeAttempt.activeElapsedMs,
           }),
       ...savedCurrentSettingsBinding(
         activeAttempt?.settingsScopeId ?? null,
@@ -3693,7 +3714,7 @@ export class WorkflowRunStore {
           : row.promptHash === null
             ? null
             : this.readText(row.promptHash);
-      const outputHash = row.outputOverrideHash ?? row.outputHash;
+      const outputHash = row.outputHash;
       const output =
         outputHash !== null
           ? this.state.readJson(outputHash)
@@ -3763,23 +3784,13 @@ export class WorkflowRunStore {
     return { ...(root === undefined ? {} : { root }), mounted };
   }
 
-  private carriedStepCount(runId: string): number {
-    const row = this.state.connection
-      .prepare(
-        `SELECT count(*) AS count
-         FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
-         WHERE s.run_id = ? AND a.run_id <> s.run_id`,
-      )
-      .get(runId);
-    return isCountRow(row) ? row.count : 0;
-  }
-
   private readActiveAttempt(runId: string):
     | {
         attemptId: string;
         nodeId: string;
         startedAt: number | null;
-        deadlineAt: number | null;
+        timeoutMs: number | null;
+        activeElapsedMs: number;
         settingsScopeId: string | null;
         settingsChangeNumber: number | null;
         settingsHash: Buffer | null;
@@ -3788,7 +3799,10 @@ export class WorkflowRunStore {
     const row = this.state.connection
       .prepare(
         `SELECT attempt_id AS attemptId, node_id AS nodeId, started_at AS startedAt,
-                deadline_at AS deadlineAt, settings_scope_id AS settingsScopeId,
+                timeout_ms AS timeoutMs,
+                (SELECT COALESCE(SUM(elapsed_ms), 0) FROM attempt_active_intervals i
+                 WHERE i.attempt_id = node_attempts.attempt_id) AS activeElapsedMs,
+                settings_scope_id AS settingsScopeId,
                 settings_change_number AS settingsChangeNumber,
                 settings_hash AS settingsHash
          FROM node_attempts
@@ -3798,16 +3812,19 @@ export class WorkflowRunStore {
     return isActiveAttemptRow(row) ? row : undefined;
   }
 
-  private readHumanDecisionReceipt(runId: string): HumanDecisionReceipt | undefined {
+  private readHumanDecisionReceipt(
+    runId: string,
+    decisionId?: string,
+  ): HumanDecisionReceipt | undefined {
     const row = this.state.connection
       .prepare(
         `SELECT d.request_hash AS requestHash, r.response_hash AS responseHash
-         FROM continuations c
-         JOIN human_decisions d ON d.decision_id = c.decision_id
-         JOIN human_decision_resolutions r ON r.decision_id = c.decision_id
-         WHERE c.continuation_run_id = ? AND r.outcome = 'accepted'`,
+         FROM human_decisions d
+         JOIN human_decision_resolutions r ON r.decision_id = d.decision_id
+         WHERE d.run_id = ? AND r.outcome = 'accepted' AND (? IS NULL OR d.decision_id = ?)
+         ORDER BY r.resolved_at DESC, d.decision_id DESC LIMIT 1`,
       )
-      .get(runId);
+      .get(runId, decisionId ?? null, decisionId ?? null);
     if (!isDecisionReceiptRow(row)) return undefined;
     const request = this.readJsonAs<Record<string, unknown>>(row.requestHash);
     const decision = this.readJsonAs<Record<string, unknown>>(row.responseHash);
@@ -4210,8 +4227,8 @@ function runViewerTargets(
     },
     {
       op: "add",
-      path: "/state/currentNodeDeadlineAt",
-      value: state.currentNodeDeadlineAt ?? null,
+      path: "/state/currentNodeTimeoutMs",
+      value: state.currentNodeTimeoutMs ?? null,
     },
     {
       op: "add",
@@ -4741,18 +4758,6 @@ function isFollowUpRow(value: unknown): value is FollowUpRow {
   );
 }
 
-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";
 }
@@ -4891,19 +4896,12 @@ function isEntryIdentityRow(value: unknown): value is { entryId: string } {
   return isRecord(value) && typeof value.entryId === "string";
 }
 
-function isAttemptValueRow(value: unknown): value is {
-  outputHash: Buffer | null;
-  receiptHash: Buffer | null;
-  responseEntryHash: Buffer | null;
-} {
-  return isRecord(value);
-}
-
 function isActiveAttemptRow(value: unknown): value is {
   attemptId: string;
   nodeId: string;
   startedAt: number | null;
-  deadlineAt: number | null;
+  timeoutMs: number | null;
+  activeElapsedMs: number;
   settingsScopeId: string | null;
   settingsChangeNumber: number | null;
   settingsHash: Buffer | null;
@@ -4920,14 +4918,6 @@ function isDecisionReceiptRow(value: unknown): value is {
   );
 }
 
-function isContinuationIdentityRow(value: unknown): value is {
-  parentRunId: string;
-  continuationRunId: string;
-  createdAt: number;
-} {
-  return isRecord(value);
-}
-
 function isUpdateRow(value: unknown): value is UpdateRow {
   return isRecord(value);
 }