@osolmaz/pi-workflows 0.16.5 → 0.16.7

package/dist/workflows/store.js

@@ -1,10 +1,11 @@
 import { createHash, randomUUID } from "node:crypto";
+import { closeAttemptTime, closeRunTime } from "../state/attempt-time.js";
 import { StateDatabase, workflowStatePath } from "../state/database.js";
 import { canonicalJson, parseJson } from "../state/json.js";
 import { StateMutationStore, StaleResourceError, resourceIdFor, tokenHash, } from "../state/mutation.js";
 import { initializeViewerRun, recordViewerDeltas, viewerTailPatch, VIEWER_PAGE_SIZE, } 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";
@@ -22,7 +23,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,
@@ -63,6 +63,9 @@ export function createRunId(workflowName, now = new Date()) {
     const safeName = workflowName.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 80) || "workflow";
     return `${now.toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z")}-${safeName}-${randomUUID().slice(0, 8)}`;
 }
+/** The state boundary used by workflow code, including out-of-process runners. */
+import { acceptedRequestOutput, ensureWorkflowRequest, requestForAttempt, } from "./requests.js";
+import { applyExecutionTransition, executionTransition, } from "./transitions.js";
 export class WorkflowRunStore {
     databasePath;
     state;
@@ -105,11 +108,23 @@ export class WorkflowRunStore {
         }
         return revision;
     }
-    async createHumanDecisionRequest(request) {
-        return await new HumanDecisionStore(this.databasePath, { state: this.state }).createRequest(request);
-    }
-    async readResolvedHumanDecision(decisionId) {
-        return await new HumanDecisionStore(this.databasePath, { state: this.state }).readResolved(decisionId);
+    async readCheckpoint(runId, attemptId) {
+        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) {
         return await this.withRunLock(options.runId, async () => this.state.transaction(() => {
@@ -279,7 +294,7 @@ export class WorkflowRunStore {
             .run(effectId, attemptNumber, authority?.ownerId ?? "system", authority?.generation ?? 1, now);
     }
     async initializeRun(workflow, state, options = {}) {
-        return await this.initializeRunFromSnapshot(createDefinitionSnapshot(workflow), workflow.name, state, options);
+        return await this.initializeRunFromSnapshot(createDefinitionSnapshot(compileWorkflowDefinition(workflow)), workflow.name, state, options);
     }
     async initializeRunFromSnapshot(snapshot, workflowName, state, options = {}) {
         assertValidRunId(state.runId);
@@ -331,19 +346,12 @@ export class WorkflowRunStore {
                     }
                     this.syncNodeAttempts(state, snapshot, now);
                     recordViewerDeltas(this.state, state.runId, [...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(`INSERT INTO workflow_definitions(
@@ -368,15 +376,14 @@ export class WorkflowRunStore {
                 this.state.connection
                     .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
              ) 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, state.runTitle ?? null, state.status, state.paused === true ? 1 : 0, state.statusDetail ?? null, inputHash, finalOutputHash, errorHash, Date.parse(state.startedAt), now, state.finishedAt === undefined ? null : Date.parse(state.finishedAt));
+                    .run(state.runId, resourceId, null, state.runId, null, 0, definitionDigest, state.workflowName, launchOptionsHash, state.runTitle ?? null, state.status, state.paused === true ? 1 : 0, state.statusDetail ?? null, inputHash, finalOutputHash, errorHash, Date.parse(state.startedAt), now, state.finishedAt === undefined ? null : Date.parse(state.finishedAt));
                 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",
@@ -396,7 +403,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) {
@@ -462,7 +469,7 @@ export class WorkflowRunStore {
             .map((row) => this.settingsScopeRecord(row));
     }
     settingsScopesForRunView(runId) {
-        const originRunId = this.logicalOriginRunId(runId);
+        const originRunId = 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,
@@ -478,7 +485,7 @@ export class WorkflowRunStore {
             .map((row) => this.settingsScopeRecord(row));
     }
     readSettingsScopeRange(runId, range) {
-        const originRunId = this.logicalOriginRunId(runId);
+        const originRunId = 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,
@@ -712,9 +719,29 @@ export class WorkflowRunStore {
         return { runId, originSessionId, followUps };
     }
     async prepareRunResume(runId) {
-        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}`);
         }
@@ -764,27 +791,34 @@ 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, {
+        await this.commitTransition(runId, executionTransition(loaded.state, {
             scope: "run",
             type: "run_interrupted",
             payload: { error: reason },
-        });
+        }));
         return this.readRun(runId, { includeTrace: true });
     }
-    async publishUpdate(runId, state, nodeId, attemptId, update, options = {}) {
-        return await this.withRunLock(runId, async () => this.publishUpdateSynchronous(runId, state, nodeId, attemptId, update, options));
+    async publishUpdate(runId, nodeId, attemptId, update, options = {}) {
+        return await this.withRunLock(runId, async () => this.publishUpdateSynchronous(runId, nodeId, attemptId, update, options));
     }
     /** Server-only synchronous form for an already serialized command transaction. */
-    publishUpdateSynchronous(runId, state, nodeId, attemptId, update, options = {}) {
+    publishUpdateSynchronous(runId, nodeId, attemptId, update, options = {}) {
         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);
         if (!exists && (state.updates?.length ?? 0) >= MAX_CURRENT_UPDATES) {
             throw new Error(`workflow run supports at most ${MAX_CURRENT_UPDATES} current updates`);
@@ -845,7 +879,7 @@ export class WorkflowRunStore {
         }
         return { event: acceptedEvent, record: acceptedRecord };
     }
-    async writeSnapshot(runId, state, event) {
+    async commitTransition(runId, transition) {
         return await this.withRunLock(runId, async () => {
             let accepted;
             this.state.transaction(() => {
@@ -856,6 +890,62 @@ 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;
+                        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);
+                    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 = { seq: revision, at, runId, ...event };
                 state.traceSeq = revision;
@@ -864,6 +954,13 @@ 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,
@@ -1274,15 +1371,6 @@ export class WorkflowRunStore {
         const row = this.readRunRow(runId);
         return row?.errorHash == null ? null : this.readText(row.errorHash);
     }
-    readPresentationInstructions(runId) {
-        const row = this.state.connection
-            .prepare("SELECT presentation_prompt_hash AS hash FROM runs WHERE run_id = ?")
-            .get(runId);
-        if (row?.hash == null) {
-            return "Explain the final workflow result to the user in a normal response.";
-        }
-        return this.readText(row.hash);
-    }
     readTerminalData(runId) {
         const row = this.state.connection
             .prepare(`SELECT status, status_detail AS statusDetail, restart_number AS restartNumber
@@ -1300,7 +1388,6 @@ export class WorkflowRunStore {
             input: this.readRunInput(runId),
             finalOutput: this.readRunFinalOutput(runId),
             error: this.readRunError(runId),
-            presentationInstructions: this.readPresentationInstructions(runId),
             restartNumber: row.restartNumber,
         };
     }
@@ -1310,6 +1397,15 @@ export class WorkflowRunStore {
             return null;
         return this.materializeRunState(row, this.readDefinition(row.definitionHash));
     }
+    runRevision(runId) {
+        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);
+        if (row === undefined)
+            throw new Error(`Workflow run not found: ${runId}`);
+        return row.revision;
+    }
     readRun(runId, options = {}) {
         const row = this.readRunRow(runId);
         if (row === undefined)
@@ -1338,7 +1434,7 @@ export class WorkflowRunStore {
         if (row === undefined)
             return null;
         const segment = this.segmentRow(segmentIdFor(runId));
-        const settingsOrigin = this.logicalOriginRunId(runId);
+        const settingsOrigin = runId;
         const scalar = (sql, ...params) => {
             const count = this.state.connection.prepare(sql).get(...params);
             return isCountRow(count) ? count.count : 0;
@@ -1637,7 +1733,10 @@ export class WorkflowRunStore {
             .run(state.runTitle ?? null, state.status, state.paused === true ? 1 : 0, state.statusDetail ?? null, finalOutputHash, errorHash, now, state.finishedAt === undefined ? null : Date.parse(state.finishedAt), 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);
         }
     }
@@ -1737,11 +1836,6 @@ export class WorkflowRunStore {
         ];
     }
     initializeRunSettingsAndFollowUps(state, initialSettings, now) {
-        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);
@@ -1749,7 +1843,7 @@ export class WorkflowRunStore {
         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);
@@ -1762,20 +1856,6 @@ export class WorkflowRunStore {
                 .run(scopeId, resourceId, originRunId, state.runId, scope.mountPath, scope.invocation, settingsHash, settingsHash, now, now);
         }
     }
-    logicalOriginRunId(runId) {
-        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}`);
-    }
     requireRunAcceptsSettings(runId, allowWaiting) {
         const row = this.state.connection
             .prepare("SELECT status FROM runs WHERE run_id = ?")
@@ -1982,15 +2062,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);
         for (const row of rows) {
@@ -2009,7 +2081,8 @@ export class WorkflowRunStore {
         }
     }
     syncNodeAttempts(state, snapshot, now) {
-        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
                 ? this.state.putText(step.prompt, now)
@@ -2049,21 +2122,17 @@ 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 = ?
+                    .prepare(`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);
     }
-    syncRunSteps(state, now) {
+    syncRunSteps(state) {
         const existingRows = this.state.connection
             .prepare(`SELECT step_index AS stepIndex, attempt_id AS attemptId
          FROM run_steps WHERE run_id = ? ORDER BY step_index`)
@@ -2082,15 +2151,15 @@ export class WorkflowRunStore {
             /* 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);
+            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 (?, ?, ?, ?)`)
-                .run(state.runId, stepIndex, step.attemptId, outputOverrideHash);
+                .prepare(`INSERT INTO run_steps(run_id, step_index, attempt_id)
+           VALUES (?, ?, ?)`)
+                .run(state.runId, stepIndex, step.attemptId);
         }
     }
     syncAttemptEntries(runId, step, promptEntryId) {
@@ -2145,26 +2214,6 @@ export class WorkflowRunStore {
             .get(runId, attemptId);
         return isEntryIdentityRow(row) ? row.entryId : undefined;
     }
-    readAttemptOutput(attemptId) {
-        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(row.receiptHash);
-        return assistantOutputFromEntry(this.state.readJson(row.responseEntryHash), receipt.assistantMessage?.maxChars);
-    }
     ensureAttempt(state, nodeId, attemptId, now, snapshot) {
         const existing = this.state.connection
             .prepare("SELECT attempt_id AS attemptId FROM node_attempts WHERE attempt_id = ?")
@@ -2227,28 +2276,6 @@ export class WorkflowRunStore {
             insert.run(runId, item.mountPath.join("/"), source.type, source.ref, source.revision);
         }
     }
-    syncContinuationIdentity(state) {
-        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");
-        }
-    }
     readRunRow(runId) {
         const row = this.state.connection
             .prepare(`SELECT r.run_id AS runId, r.resource_id AS resourceId,
@@ -2276,7 +2303,6 @@ export class WorkflowRunStore {
     }
     buildRunState(row, snapshot, projectionSteps, visibleSteps, visibleUpdates) {
         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)
             : undefined;
@@ -2310,13 +2336,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(),
@@ -2331,12 +2354,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, activeAttempt?.settingsChangeNumber ?? null, activeAttempt?.settingsHash ?? null),
             ...(row.statusDetail === null ? {} : { statusDetail: row.statusDetail }),
@@ -2402,7 +2424,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)
                 : row.responseEntryHash === null
@@ -2453,18 +2475,13 @@ export class WorkflowRunStore {
         }));
         return { ...(root === undefined ? {} : { root }), mounted };
     }
-    carriedStepCount(runId) {
-        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;
-    }
     readActiveAttempt(runId) {
         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
@@ -2472,14 +2489,14 @@ export class WorkflowRunStore {
             .get(runId);
         return isActiveAttemptRow(row) ? row : undefined;
     }
-    readHumanDecisionReceipt(runId) {
+    readHumanDecisionReceipt(runId, decisionId) {
         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'`)
-            .get(runId);
+         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, decisionId ?? null, decisionId ?? null);
         if (!isDecisionReceiptRow(row))
             return undefined;
         const request = this.readJsonAs(row.requestHash);
@@ -2823,8 +2840,8 @@ function runViewerTargets(state, traceEvent) {
         },
         {
             op: "add",
-            path: "/state/currentNodeDeadlineAt",
-            value: state.currentNodeDeadlineAt ?? null,
+            path: "/state/currentNodeTimeoutMs",
+            value: state.currentNodeTimeoutMs ?? null,
         },
         {
             op: "add",
@@ -3241,14 +3258,6 @@ function isFollowUpRow(value) {
         typeof value.updatedAt === "number" &&
         typeof value.revision === "number");
 }
-function isParentRunRow(value) {
-    return isRecord(value) && (typeof value.parentRunId === "string" || value.parentRunId === null);
-}
-function isRunLineageRow(value) {
-    return (isRecord(value) &&
-        typeof value.rootRunId === "string" &&
-        typeof value.restartNumber === "number");
-}
 function isStatusRow(value) {
     return isRecord(value) && typeof value.status === "string";
 }
@@ -3350,18 +3359,12 @@ function isSegmentIdentityRow(value) {
 function isEntryIdentityRow(value) {
     return isRecord(value) && typeof value.entryId === "string";
 }
-function isAttemptValueRow(value) {
-    return isRecord(value);
-}
 function isActiveAttemptRow(value) {
     return isRecord(value);
 }
 function isDecisionReceiptRow(value) {
     return (isRecord(value) && Buffer.isBuffer(value.requestHash) && Buffer.isBuffer(value.responseHash));
 }
-function isContinuationIdentityRow(value) {
-    return isRecord(value);
-}
 function isUpdateRow(value) {
     return isRecord(value);
 }