@osolmaz/pi-workflows 0.13.2 → 0.13.4

package/dist/workflows/store.js

@@ -1,8 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
 import { StateDatabase, workflowStatePath } from "../state/database.js";
 import { canonicalJson } from "../state/json.js";
-import { resourceIdFor, tokenHash } from "../state/mutation.js";
+import { StateMutationStore, StaleResourceError, resourceIdFor, tokenHash, } from "../state/mutation.js";
 import { compositionMetadata } from "./composition.js";
+import { applyJsonPatch, validateJsonPatch } from "./json-patch.js";
+import { applyWorkflowSettingsPatch, workflowSettingsScopeId, } from "./settings.js";
 import { MAX_CURRENT_UPDATES, createUpdateId, updateProjection } from "./updates.js";
 export const RUN_STATE_SCHEMA = "pi-workflows.run-state.v1";
 export const DEFINITION_SNAPSHOT_SCHEMA = "pi-workflows.definition-snapshot.v1";
@@ -10,6 +12,18 @@ export const SESSION_BINDING_SCHEMA = "pi-workflows.session-binding.v1";
 export const SESSION_EVENT_SCHEMA = "pi-workflows.session-event.v1";
 export const SESSION_CAPTURE_SCHEMA = "pi-workflows.session-capture.v1";
 export const SESSION_EVENT_MAX_BYTES = 1024 * 1024;
+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.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
+  FROM workflow_follow_ups f
+  JOIN resources r ON r.resource_id = f.resource_id`;
 export function workflowStateDatabasePath(homeDir) {
     return workflowStatePath(homeDir);
 }
@@ -23,6 +37,7 @@ export class WorkflowRunStore {
     authorityProvider;
     contexts = new Map();
     ownsState;
+    mutations;
     constructor(databasePath = workflowStatePath(), options = {}) {
         this.authorityProvider = options.authorityProvider;
         this.ownsState = options.state === undefined;
@@ -34,12 +49,13 @@ export class WorkflowRunStore {
                     checkLegacyState: databasePath === workflowStatePath(),
                 });
         this.databasePath = this.state.filePath;
+        this.mutations = new StateMutationStore(this.state);
     }
     close() {
         if (this.ownsState)
             this.state.close();
     }
-    async initializeRun(workflow, state) {
+    async initializeRun(workflow, state, options = {}) {
         assertValidRunId(state.runId);
         if (!this.contexts.has(state.runId)) {
             const reserved = this.readRunRow(state.runId);
@@ -79,7 +95,9 @@ export class WorkflowRunStore {
                         payload: { workflowName: workflow.name },
                     });
                     this.persistRunState(reserved, state, revision, now);
+                    this.initializeRunSettingsAndFollowUps(state, options.initialSettings ?? [], now);
                     this.syncNodeAttempts(state, snapshot, now);
+                    this.syncContinuationIdentity(state);
                     context.revision = revision;
                     return;
                 }
@@ -101,38 +119,463 @@ export class WorkflowRunStore {
                 state.traceSeq = 1;
                 state.updatedAt = at;
                 const inputHash = this.state.putJson(state.input, now);
-                const workflowSourceHash = this.state.putJson(state.workflowSource ?? source, now);
                 const launchOptionsHash = this.state.putJson({}, now);
-                const workflowSourcesHash = state.workflowSources === undefined
-                    ? null
-                    : this.state.putJson(state.workflowSources, now);
-                const humanDecisionHash = state.humanDecision === undefined ? null : this.state.putJson(state.humanDecision, now);
                 const finalOutputHash = state.finalOutput === undefined ? null : this.state.putJson(state.finalOutput, now);
                 const errorHash = state.error === undefined ? null : this.state.putText(state.error, now);
                 this.state.connection
                     .prepare(`INSERT INTO runs(
                run_id, resource_id, project_id, parent_run_id, definition_digest,
-               workflow_ref, workflow_source_hash, launch_options_hash,
-               source_type, source_ref, source_revision, title, status, paused,
-               status_detail, input_hash, workflow_sources_hash, human_decision_hash,
-               final_output_hash, error_hash, carried_step_count, current_node,
-               current_attempt_id, current_node_started_at, waiting_on,
+               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, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                    .run(state.runId, resourceId, state.parentRunId ?? null, definitionDigest, state.workflowName, workflowSourceHash, launchOptionsHash, source.type, source.ref, source.revision, state.runTitle ?? null, state.status, state.paused === true ? 1 : 0, state.statusDetail ?? null, inputHash, workflowSourcesHash, humanDecisionHash, finalOutputHash, errorHash, state.carriedStepCount ?? 0, state.currentNode ?? null, state.currentAttemptId ?? null, state.currentNodeStartedAt === undefined
-                    ? null
-                    : Date.parse(state.currentNodeStartedAt), state.waitingOn ?? null, Date.parse(state.startedAt), now, state.finishedAt === undefined ? null : Date.parse(state.finishedAt));
+             ) VALUES (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(state.runId, resourceId, state.parentRunId ?? null, 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));
+                this.insertRunSources(state.runId, source, state.workflowSources ?? []);
+                this.syncContinuationIdentity(state);
                 insertRunEvent(this.state, resourceId, 1, at, {
                     scope: "run",
                     type: "run_created",
                     payload: { workflowName: workflow.name },
                 });
+                this.initializeRunSettingsAndFollowUps(state, options.initialSettings ?? [], now);
                 this.syncNodeAttempts(state, snapshot, now);
             });
             this.contexts.set(state.runId, { revision: acceptedRevision, lock: Promise.resolve() });
             return state.runId;
         });
     }
+    ensureSettingsScope(options) {
+        const now = Date.now();
+        return this.state.transaction(() => {
+            this.requireRunAcceptsSettings(options.runId, false);
+            const originRunId = this.logicalOriginRunId(options.runId);
+            const scopeId = workflowSettingsScopeId(originRunId, options.mountPath, options.invocation);
+            const existing = this.settingsScopeRow(scopeId);
+            if (existing !== undefined) {
+                if (existing.activeRunId !== options.runId) {
+                    throw new Error(`Workflow settings scope belongs to another active run: ${scopeId}`);
+                }
+                return this.settingsScopeRecord(existing);
+            }
+            const resourceId = this.mutations.ensureResource("settings", scopeId, now);
+            const settingsHash = this.state.putJson(options.settings, now);
+            this.state.connection
+                .prepare(`INSERT INTO workflow_settings(
+             scope_id, resource_id, origin_run_id, active_run_id, mount_path, invocation,
+             initial_hash, current_hash, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(scopeId, resourceId, originRunId, options.runId, options.mountPath, options.invocation, settingsHash, settingsHash, now, now);
+            return this.settingsScopeRecord(this.requireSettingsScopeRow(scopeId));
+        });
+    }
+    getSettingsScope(scopeId) {
+        const row = this.settingsScopeRow(scopeId);
+        return row === undefined ? undefined : this.settingsScopeRecord(row);
+    }
+    getSettingsScopeAtChange(scopeId, changeNumber) {
+        if (!Number.isInteger(changeNumber) || changeNumber < 0) {
+            throw new Error("Workflow settings change number must be a non-negative integer");
+        }
+        const row = this.settingsScopeRow(scopeId);
+        if (row === undefined)
+            return undefined;
+        if (changeNumber > row.revision) {
+            throw new Error(`Workflow settings change ${changeNumber} does not exist for ${scopeId}`);
+        }
+        if (changeNumber === row.revision)
+            return this.settingsScopeRecord(row);
+        const saved = changeNumber === 0
+            ? this.state.connection
+                .prepare("SELECT initial_hash AS settingsHash FROM workflow_settings WHERE scope_id = ?")
+                .get(scopeId)
+            : this.state.connection
+                .prepare(`SELECT after_hash AS settingsHash FROM workflow_setting_changes
+               WHERE scope_id = ? AND change_number = ?`)
+                .get(scopeId, changeNumber);
+        if (!isRecord(saved) || !Buffer.isBuffer(saved.settingsHash)) {
+            throw new Error(`Workflow settings change ${changeNumber} is missing for ${scopeId}`);
+        }
+        return this.settingsScopeRecord(row, changeNumber, saved.settingsHash);
+    }
+    listSettingsScopes(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.active_run_id = ?
+         ORDER BY s.mount_path, s.invocation`)
+            .all(runId)
+            .filter(isSettingsScopeRow)
+            .map((row) => this.settingsScopeRecord(row));
+    }
+    settingsScopesForRunView(runId) {
+        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`)
+            .all(originRunId, runId)
+            .filter(isSettingsScopeRow)
+            .map((row) => this.settingsScopeRecord(row));
+    }
+    findSettingsScope(runId, mountPath, invocation) {
+        const row = 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.active_run_id = ? AND s.mount_path = ? AND s.invocation = ?`)
+            .get(runId, mountPath, invocation);
+        return isSettingsScopeRow(row) ? this.settingsScopeRecord(row) : undefined;
+    }
+    async changeSettings(definition, request) {
+        assertRequestId(request.requestId);
+        assertSourceType(request.source);
+        const patch = validateJsonPatch(request.patch);
+        const patchJson = canonicalJson(patch);
+        const patchDigest = createHash("sha256").update(patchJson).digest();
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const prior = this.settingsChangeRow(request.scopeId, request.requestId);
+            if (prior !== undefined) {
+                this.assertSameSettingsChange(prior, request, patchDigest);
+                return {
+                    scope: this.settingsScopeRecord(this.requireSettingsScopeRow(request.scopeId)),
+                    change: this.settingsChangeRecord(prior),
+                    adopted: true,
+                };
+            }
+            const scope = this.requireSettingsScopeRow(request.scopeId);
+            if (scope.activeRunId !== request.runId) {
+                throw new Error(`Workflow settings scope is not active for run ${request.runId}`);
+            }
+            this.requireRunAcceptsSettings(request.runId, true);
+            if (request.expectedChangeNumber !== undefined &&
+                request.expectedChangeNumber !== scope.revision) {
+                throw new StaleResourceError(`Workflow settings changed: expected ${request.expectedChangeNumber}, current ${scope.revision}`);
+            }
+            const before = this.state.readJson(scope.currentHash);
+            const applied = await applyWorkflowSettingsPatch(definition, before, patch, request.actor, request.source);
+            const beforeHash = scope.currentHash;
+            const afterHash = createHash("sha256").update(canonicalJson(applied.json)).digest();
+            try {
+                const mutation = this.mutations.mutate({
+                    resourceId: scope.resourceId,
+                    operation: "settings.change",
+                    actor: request.actor,
+                    expectedRevision: scope.revision,
+                }, "settings.changed", ({ database, nextRevision, now }) => {
+                    this.requireRunAcceptsSettings(request.runId, true);
+                    const current = this.requireSettingsScopeRow(request.scopeId);
+                    if (current.activeRunId !== request.runId || !current.currentHash.equals(beforeHash)) {
+                        throw new StaleResourceError("Workflow settings changed before the patch committed");
+                    }
+                    const patchHash = database.putJson(applied.patch, now);
+                    const savedAfterHash = database.putJson(applied.json, now);
+                    const changeId = `setting-change-${randomUUID()}`;
+                    database.connection
+                        .prepare(`INSERT INTO workflow_setting_changes(
+                   change_id, scope_id, request_id, change_number,
+                   actor_type, actor_id, source_type, patch_hash,
+                   before_hash, after_hash, accepted_at
+                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .run(changeId, request.scopeId, request.requestId, nextRevision, request.actor.type, request.actor.id ?? null, request.source, patchHash, beforeHash, savedAfterHash, now);
+                    database.connection
+                        .prepare(`UPDATE workflow_settings SET current_hash = ?, updated_at = ? WHERE scope_id = ?`)
+                        .run(savedAfterHash, now, request.scopeId);
+                    return changeId;
+                }, {
+                    payload: {
+                        scopeId: request.scopeId,
+                        requestId: request.requestId,
+                        source: request.source,
+                        beforeHash: beforeHash.toString("hex"),
+                        afterHash: afterHash.toString("hex"),
+                    },
+                });
+                const row = this.settingsChangeRow(request.scopeId, request.requestId);
+                if (row === undefined || row.changeId !== mutation.value) {
+                    throw new Error("Accepted workflow settings change is missing");
+                }
+                return {
+                    scope: this.settingsScopeRecord(this.requireSettingsScopeRow(request.scopeId)),
+                    change: this.settingsChangeRecord(row),
+                    adopted: false,
+                };
+            }
+            catch (error) {
+                if (!(error instanceof StaleResourceError) || request.expectedChangeNumber !== undefined) {
+                    throw error;
+                }
+            }
+        }
+        throw new StaleResourceError("Workflow settings kept changing; retry with an expected number");
+    }
+    queueFollowUp(request) {
+        assertRequestId(request.requestId);
+        assertSourceType(request.source);
+        if (typeof request.prompt !== "string" || request.prompt.trim().length === 0) {
+            throw new Error("Workflow follow-up prompt must be a non-empty string");
+        }
+        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) {
+            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);
+                    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;
+            }
+        }
+        throw new StaleResourceError("Workflow follow-up queue kept changing; retry the request");
+    }
+    removeFollowUp(request) {
+        assertSourceType(request.source);
+        const row = this.requireFollowUpRow(request.followUpId);
+        if (row.runId !== request.runId) {
+            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}`);
+        }
+        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 reason = "Removed before delivery";
+        this.mutations.mutate({
+            resourceId: row.resourceId,
+            operation: "follow-up.remove",
+            actor: request.actor,
+            expectedRevision: row.revision,
+        }, "follow-up.removed", ({ database, now }) => {
+            const reasonHash = database.putText(reason, now);
+            const update = database.connection
+                .prepare(`UPDATE workflow_follow_ups
+             SET status = 'removed', reason_hash = ?, updated_at = ?
+             WHERE follow_up_id = ? AND status IN ('queued', 'pending_presentation', 'ready')`)
+                .run(reasonHash, now, request.followUpId);
+            if (update.changes !== 1) {
+                throw new StaleResourceError("Workflow follow-up changed before removal");
+            }
+        }, { payload: { followUpId: request.followUpId, source: request.source } });
+        return this.followUpRecord(this.requireFollowUpRow(request.followUpId));
+    }
+    originSessionId(runId) {
+        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
+         WHERE r.run_id = ?`)
+            .get(runId);
+        return isRecord(row) && typeof row.originSessionId === "string"
+            ? row.originSessionId
+            : undefined;
+    }
+    readFollowUpQueue(runId) {
+        const queue = this.followUpQueueRow(runId);
+        if (queue === 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,
+        };
+    }
+    listPendingPresentations(targetSessionId) {
+        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) {
+        const queue = this.requireFollowUpQueueRow(options.runId);
+        if (queue.presentationState === options.state) {
+            return this.readFollowUpQueue(options.runId);
+        }
+        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, 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);
+            }, { 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);
+                }
+            }
+            throw error;
+        }
+        return this.readFollowUpQueue(options.runId);
+    }
+    claimNextFollowUp(targetSessionId, ownerId, leaseMs = 30_000) {
+        const rows = 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`)
+            .all(targetSessionId)
+            .filter(isFollowUpRow);
+        for (const row of rows) {
+            let claim;
+            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, claim, sessionEntryId) {
+        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");
+            }
+        }, { payload: { followUpId, sessionEntryId } });
+        return this.followUpRecord(this.requireFollowUpRow(followUpId));
+    }
+    releaseFollowUpClaim(claim) {
+        const revision = this.requireResourceRevision(claim.resourceId);
+        this.mutations.release(claim, revision);
+    }
     async prepareRunResume(runId) {
         const loaded = this.readRun(runId, { includeTrace: true });
         if (loaded === null)
@@ -140,6 +583,7 @@ export class WorkflowRunStore {
         if (loaded.state.status !== "running") {
             throw new Error(`Cannot resume workflow run ${runId} with status ${loaded.state.status}`);
         }
+        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");
@@ -152,9 +596,9 @@ export class WorkflowRunStore {
             const at = new Date(now).toISOString();
             this.state.connection
                 .prepare(`UPDATE node_attempts
-           SET status = 'cancelled', finished_at = ?, updated_at = ?
+           SET status = 'interrupted', updated_at = ?
            WHERE run_id = ? AND status IN ('pending', 'running', 'waiting')`)
-                .run(now, now, runId);
+                .run(now, runId);
             insertRunEvent(this.state, row.resourceId, nextRevision, at, {
                 scope: "run",
                 type: "run_resume_prepared",
@@ -181,6 +625,9 @@ export class WorkflowRunStore {
         delete loaded.state.currentNode;
         delete loaded.state.currentAttemptId;
         delete loaded.state.currentNodeStartedAt;
+        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, {
@@ -264,12 +711,14 @@ export class WorkflowRunStore {
                 const revision = context.revision + 1;
                 const now = Date.now();
                 const at = new Date(now).toISOString();
+                const snapshot = this.readDefinition(run.definitionHash);
+                this.assertSettingsRouteCurrent(event, snapshot);
                 const traceEvent = { seq: revision, at, runId, ...event };
                 state.traceSeq = revision;
                 state.updatedAt = at;
                 insertRunEvent(this.state, run.resourceId, revision, at, traceEvent);
                 this.persistRunState(run, state, revision, now);
-                const snapshot = this.readDefinition(run.definitionHash);
+                this.transitionFollowUpsForRunState(state, event, now);
                 this.syncNodeAttempts(state, snapshot, now);
                 context.revision = revision;
                 accepted = traceEvent;
@@ -325,6 +774,11 @@ export class WorkflowRunStore {
              VALUES (?, ?, 'interactive', ?)
              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();
                 insertRunEvent(this.state, run.resourceId, revision, at, {
@@ -363,7 +817,7 @@ export class WorkflowRunStore {
                 .prepare("UPDATE session_segments SET entry_count = ? WHERE segment_id = ?")
                 .run(sequence, segment.segmentId);
             this.bumpResource(segmentResourceId(segment), revision, now);
-            insertGenericEvent(this.state, segmentResourceId(segment), revision + 1, "session.entry_appended", "session", segment.sessionId, entryHash, now);
+            insertGenericEvent(this.state, segmentResourceId(segment), revision + 1, "session.entry_appended", "session", segment.sessionId, null, now);
             return sequence;
         });
     }
@@ -450,6 +904,8 @@ export class WorkflowRunStore {
             sessionCapture: flat.capture,
             sessionIntegrity: flat.integrity,
             sessionSegments: segments.filter((segment) => segment.attemptId !== ""),
+            settingsScopes: this.settingsScopesForRunView(runId),
+            followUpQueue: this.readFollowUpQueue(runId) ?? null,
         };
     }
     listRuns(options = {}) {
@@ -554,18 +1010,14 @@ export class WorkflowRunStore {
     }
     persistRunState(run, state, expectedRevision, now) {
         this.bumpResource(run.resourceId, expectedRevision - 1, now);
-        const workflowSourcesHash = state.workflowSources === undefined ? null : this.state.putJson(state.workflowSources, now);
-        const humanDecisionHash = state.humanDecision === undefined ? null : this.state.putJson(state.humanDecision, now);
         const finalOutputHash = state.finalOutput === undefined ? null : this.state.putJson(state.finalOutput, now);
         const errorHash = state.error === undefined ? null : this.state.putText(state.error, now);
         const update = this.state.connection
             .prepare(`UPDATE runs
          SET title = ?, status = ?, paused = ?, status_detail = ?,
-             workflow_sources_hash = ?, human_decision_hash = ?, final_output_hash = ?,
-             error_hash = ?, carried_step_count = ?, current_node = ?, current_attempt_id = ?,
-             current_node_started_at = ?, waiting_on = ?, updated_at = ?, finished_at = ?
+             final_output_hash = ?, error_hash = ?, updated_at = ?, finished_at = ?
          WHERE run_id = ?`)
-            .run(state.runTitle ?? null, state.status, state.paused === true ? 1 : 0, state.statusDetail ?? null, workflowSourcesHash, humanDecisionHash, finalOutputHash, errorHash, state.carriedStepCount ?? 0, state.currentNode ?? null, state.currentAttemptId ?? null, state.currentNodeStartedAt === undefined ? null : Date.parse(state.currentNodeStartedAt), state.waitingOn ?? null, now, state.finishedAt === undefined ? null : Date.parse(state.finishedAt), state.runId);
+            .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") {
@@ -606,13 +1058,341 @@ export class WorkflowRunStore {
             .run(effectId, effectResourceId, runResourceId, sourceRevision, effectType, idempotencyKey, payloadHash, now, now);
         insertGenericEvent(this.state, effectResourceId, 1, "effect.created", "system", null, payloadHash, now);
     }
+    initializeRunSettingsAndFollowUps(state, initialSettings, now) {
+        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 = ?`)
+                .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 scopeId = workflowSettingsScopeId(originRunId, scope.mountPath, scope.invocation);
+            const resourceId = this.mutations.ensureResource("settings", scopeId, now);
+            const settingsHash = this.state.putJson(scope.settings, now);
+            this.state.connection
+                .prepare(`INSERT INTO workflow_settings(
+             scope_id, resource_id, origin_run_id, active_run_id, mount_path, invocation,
+             initial_hash, current_hash, created_at, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(scope_id) DO NOTHING`)
+                .run(scopeId, resourceId, originRunId, state.runId, scope.mountPath, scope.invocation, settingsHash, settingsHash, now, now);
+        }
+    }
+    ensureFollowUpQueue(runId, now) {
+        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;
+    }
+    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 = ?")
+            .get(runId);
+        if (!isStatusRow(row))
+            throw new Error(`Workflow run is missing: ${runId}`);
+        if (row.status !== "running" && !(allowWaiting && row.status === "waiting")) {
+            throw new Error(`Workflow run ${runId} does not accept changes with status ${row.status}`);
+        }
+    }
+    verifySettingsProjections(runId) {
+        const scopes = this.state.connection
+            .prepare(`SELECT s.scope_id AS scopeId, s.initial_hash AS initialHash,
+                s.current_hash AS currentHash, r.revision
+         FROM workflow_settings s
+         JOIN resources r ON r.resource_id = s.resource_id
+         WHERE s.active_run_id = ?`)
+            .all(runId);
+        for (const value of scopes) {
+            if (!isSettingsProjectionRow(value)) {
+                throw new Error("Workflow settings projection row is invalid");
+            }
+            let current = this.state.readJson(value.initialHash);
+            let currentHash = value.initialHash;
+            const changes = this.state.connection
+                .prepare(`SELECT change_number AS changeNumber, patch_hash AS patchHash,
+                  before_hash AS beforeHash, after_hash AS afterHash
+           FROM workflow_setting_changes WHERE scope_id = ? ORDER BY change_number`)
+                .all(value.scopeId);
+            let expected = 1;
+            for (const change of changes) {
+                if (!isSettingsProjectionChangeRow(change) || change.changeNumber !== expected) {
+                    throw new Error(`Workflow settings changes are not contiguous for ${value.scopeId}`);
+                }
+                if (!change.beforeHash.equals(currentHash)) {
+                    throw new Error(`Workflow settings change has a wrong old value for ${value.scopeId}`);
+                }
+                current = applyJsonPatch(current, this.state.readJson(change.patchHash));
+                currentHash = createHash("sha256").update(canonicalJson(current)).digest();
+                if (!currentHash.equals(change.afterHash)) {
+                    throw new Error(`Workflow settings change has a wrong new value for ${value.scopeId}`);
+                }
+                expected += 1;
+            }
+            if (value.revision !== expected - 1 || !value.currentHash.equals(currentHash)) {
+                throw new Error(`Workflow settings projection does not match saved changes for ${value.scopeId}`);
+            }
+        }
+    }
+    settingsScopeRow(scopeId) {
+        const row = 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.scope_id = ?`)
+            .get(scopeId);
+        return isSettingsScopeRow(row) ? row : undefined;
+    }
+    requireSettingsScopeRow(scopeId) {
+        const row = this.settingsScopeRow(scopeId);
+        if (row === undefined)
+            throw new Error(`Workflow settings scope not found: ${scopeId}`);
+        return row;
+    }
+    settingsScopeRecord(row, changeNumber = row.revision, settingsHash = row.currentHash) {
+        return {
+            scopeId: row.scopeId,
+            originRunId: row.originRunId,
+            activeRunId: row.activeRunId,
+            mountPath: row.mountPath,
+            invocation: row.invocation,
+            changeNumber,
+            settings: this.state.readJson(settingsHash),
+            settingsHash: settingsHash.toString("hex"),
+            createdAt: new Date(row.createdAt).toISOString(),
+            updatedAt: new Date(row.updatedAt).toISOString(),
+        };
+    }
+    settingsChangeRow(scopeId, requestId) {
+        const row = this.state.connection
+            .prepare(`SELECT change_id AS changeId, scope_id AS scopeId, request_id AS requestId,
+                change_number AS changeNumber, actor_type AS actorType, actor_id AS actorId,
+                source_type AS sourceType, patch_hash AS patchHash,
+                before_hash AS beforeHash, after_hash AS afterHash,
+                accepted_at AS acceptedAt
+         FROM workflow_setting_changes WHERE scope_id = ? AND request_id = ?`)
+            .get(scopeId, requestId);
+        return isSettingsChangeRow(row) ? row : undefined;
+    }
+    settingsChangeRecord(row) {
+        return {
+            changeId: row.changeId,
+            scopeId: row.scopeId,
+            requestId: row.requestId,
+            changeNumber: row.changeNumber,
+            actor: {
+                type: assertActorType(row.actorType),
+                ...(row.actorId !== null ? { id: row.actorId } : {}),
+            },
+            source: row.sourceType,
+            patch: validateJsonPatch(this.state.readJson(row.patchHash)),
+            beforeHash: row.beforeHash.toString("hex"),
+            afterHash: row.afterHash.toString("hex"),
+            acceptedAt: new Date(row.acceptedAt).toISOString(),
+        };
+    }
+    assertSameSettingsChange(row, request, patchDigest) {
+        if (!row.patchHash.equals(patchDigest) ||
+            row.actorType !== request.actor.type ||
+            row.actorId !== (request.actor.id ?? null) ||
+            row.sourceType !== request.source) {
+            throw new Error(`Workflow settings request ID was reused with different content`);
+        }
+    }
+    followUpQueueRow(runId) {
+        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;
+    }
+    requireFollowUpQueueRow(runId) {
+        const row = this.followUpQueueRow(runId);
+        if (row === undefined)
+            throw new Error(`Workflow follow-up queue not found: ${runId}`);
+        return row;
+    }
+    followUpRowByRequest(runId, requestId) {
+        const row = this.state.connection
+            .prepare(`${FOLLOW_UP_ROW_SELECT} WHERE f.run_id = ? AND f.request_id = ?`)
+            .get(runId, requestId);
+        return isFollowUpRow(row) ? row : undefined;
+    }
+    followUpRow(followUpId) {
+        const row = this.state.connection
+            .prepare(`${FOLLOW_UP_ROW_SELECT} WHERE f.follow_up_id = ?`)
+            .get(followUpId);
+        return isFollowUpRow(row) ? row : undefined;
+    }
+    requireFollowUpRow(followUpId) {
+        const row = this.followUpRow(followUpId);
+        if (row === undefined)
+            throw new Error(`Workflow follow-up not found: ${followUpId}`);
+        return row;
+    }
+    followUpRecord(row) {
+        return {
+            followUpId: row.followUpId,
+            runId: row.runId,
+            requestId: row.requestId,
+            order: row.orderNumber,
+            targetSessionId: row.targetSessionId,
+            actor: {
+                type: assertActorType(row.actorType),
+                ...(row.actorId !== null ? { id: row.actorId } : {}),
+            },
+            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() } : {}),
+        };
+    }
+    assertSameFollowUp(row, request) {
+        const promptHash = createHash("sha256").update(request.prompt).digest();
+        if (!row.promptHash.equals(promptHash) ||
+            row.targetSessionId !== request.targetSessionId ||
+            row.actorType !== request.actor.type ||
+            row.actorId !== (request.actor.id ?? null) ||
+            row.sourceType !== request.source) {
+            throw new Error("Workflow follow-up request ID was reused with different content");
+        }
+    }
+    assertFollowUpRemovalAuthority(row, actor, source) {
+        if (actor.type === "human")
+            return;
+        if ((actor.type === "session" || actor.type === "controller") &&
+            row.actorType === actor.type &&
+            row.actorId === (actor.id ?? null) &&
+            row.sourceType === source) {
+            return;
+        }
+        throw new Error("Workflow follow-up can be removed only by its source or a verified human");
+    }
+    hasLiveLease(resourceId) {
+        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();
+    }
+    nextFollowUpOrder(runId) {
+        const row = this.state.connection
+            .prepare(`SELECT COALESCE(MAX(order_number), 0) + 1 AS nextOrder
+         FROM workflow_follow_ups WHERE run_id = ?`)
+            .get(runId);
+        if (!isNextOrderRow(row))
+            throw new Error("Could not allocate workflow follow-up order");
+        return row.nextOrder;
+    }
+    assertSettingsRouteCurrent(event, snapshot) {
+        if (event.type !== "node_finished" || event.nodeId === undefined)
+            return;
+        if (snapshot.nodes[event.nodeId]?.settingsRoute !== true)
+            return;
+        const scopeId = event.payload.settingsScopeId;
+        const changeNumber = event.payload.settingsChangeNumber;
+        if (typeof scopeId !== "string" || typeof changeNumber !== "number") {
+            throw new Error(`Settings route ${event.nodeId} has no saved settings binding`);
+        }
+        const scope = this.requireSettingsScopeRow(scopeId);
+        if (scope.revision !== changeNumber) {
+            throw new StaleResourceError(`Settings route ${event.nodeId} used change ${changeNumber}, current change is ${scope.revision}`);
+        }
+    }
+    transitionFollowUpsForRunState(state, event, now) {
+        if (state.status === "running" || state.status === "waiting")
+            return;
+        const queue = this.followUpQueueRow(state.runId);
+        if (queue === undefined || queue.presentationState !== "none")
+            return;
+        let presentationState = "not-needed";
+        let followUpState = "cancelled";
+        let reasonHash = 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);
+        }
+        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
+            .prepare(`UPDATE workflow_follow_ups
+         SET status = ?, reason_hash = ?, updated_at = ?
+         WHERE run_id = ? AND status IN ('queued', 'pending_presentation', 'ready')`)
+            .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);
+    }
     syncNodeAttempts(state, snapshot, now) {
         for (const step of state.steps.slice(state.carriedStepCount ?? 0)) {
-            const metadata = stepMetadata(step);
-            const stepMetadataHash = Object.keys(metadata).length === 0 ? null : this.state.putJson(metadata, now);
+            const promptEntryId = this.findAttemptPromptEntry(state.runId, step.attemptId);
+            const promptHash = promptEntryId === undefined && step.prompt !== null
+                ? this.state.putText(step.prompt, now)
+                : null;
+            const receipt = attemptReceipt(step);
+            const receiptHash = Object.keys(receipt).length === 0 ? null : this.state.putJson(receipt, now);
             const outputHash = step.output === undefined ? null : this.state.putJson(step.output, now);
             const errorHash = step.error === undefined ? null : this.state.putText(step.error, now);
-            const promptHash = step.prompt === null ? null : this.state.putJson(step.prompt, now);
             const existing = this.state.connection
                 .prepare("SELECT attempt_id AS attemptId FROM node_attempts WHERE attempt_id = ?")
                 .get(step.attemptId);
@@ -621,18 +1401,25 @@ export class WorkflowRunStore {
                 this.state.connection
                     .prepare(`INSERT INTO node_attempts(
                attempt_id, run_id, node_id, attempt_number, node_type, status,
-               prompt_hash, output_hash, step_metadata_hash, error_hash,
+               prompt_hash, output_hash, receipt_hash, error_hash,
+               settings_scope_id, settings_change_number, settings_hash,
                started_at, finished_at, created_at, updated_at
-             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                    .run(step.attemptId, state.runId, step.nodeId, attemptNumber, step.nodeType, outcomeStatus(step.outcome), promptHash, outputHash, stepMetadataHash, errorHash, Date.parse(step.startedAt), Date.parse(step.finishedAt), Date.parse(step.startedAt), now);
+             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(step.attemptId, state.runId, step.nodeId, attemptNumber, step.nodeType, outcomeStatus(step.outcome), promptHash, outputHash, receiptHash, errorHash, step.settingsScopeId ?? null, step.settingsChangeNumber ?? null, step.settingsHash === undefined ? null : Buffer.from(step.settingsHash, "hex"), Date.parse(step.startedAt), Date.parse(step.finishedAt), Date.parse(step.startedAt), now);
             }
             else {
                 this.state.connection
                     .prepare(`UPDATE node_attempts
-             SET status = ?, prompt_hash = ?, output_hash = ?, step_metadata_hash = ?,
-                 error_hash = ?, finished_at = ?, updated_at = ?
+             SET status = ?, prompt_hash = ?, output_hash = ?, receipt_hash = ?, error_hash = ?,
+                 settings_scope_id = ?, settings_change_number = ?,
+                 settings_hash = ?, finished_at = ?, updated_at = ?
              WHERE attempt_id = ?`)
-                    .run(outcomeStatus(step.outcome), promptHash, outputHash, stepMetadataHash, errorHash, Date.parse(step.finishedAt), now, step.attemptId);
+                    .run(outcomeStatus(step.outcome), promptHash, outputHash, receiptHash, errorHash, step.settingsScopeId ?? null, step.settingsChangeNumber ?? null, step.settingsHash === undefined ? null : Buffer.from(step.settingsHash, "hex"), Date.parse(step.finishedAt), now, step.attemptId);
+            }
+            if (this.syncAttemptEntries(state.runId, step, promptEntryId)) {
+                this.state.connection
+                    .prepare("UPDATE node_attempts SET output_hash = NULL WHERE attempt_id = ?")
+                    .run(step.attemptId);
             }
         }
         if (state.currentAttemptId !== undefined && state.currentNode !== undefined) {
@@ -659,16 +1446,9 @@ export class WorkflowRunStore {
             /* istanbul ignore if -- array index follows a checked bound */
             if (step === undefined)
                 throw new Error("Workflow run step became unavailable");
-            const attempt = this.state.connection
-                .prepare("SELECT output_hash AS outputHash FROM node_attempts WHERE attempt_id = ?")
-                .get(step.attemptId);
-            if (!isAttemptOutputRow(attempt)) {
-                throw new Error(`Workflow node attempt is missing: ${step.attemptId}`);
-            }
+            const attemptOutput = this.readAttemptOutput(step.attemptId);
             const carried = stepIndex < (state.carriedStepCount ?? 0);
-            const outputOverrideHash = carried &&
-                (attempt.outputHash === null ||
-                    canonicalJson(this.state.readJson(attempt.outputHash)) !== canonicalJson(step.output))
+            const outputOverrideHash = carried && canonicalJson(attemptOutput) !== canonicalJson(step.output)
                 ? this.state.putJson(step.output, now)
                 : null;
             this.state.connection
@@ -677,6 +1457,78 @@ export class WorkflowRunStore {
                 .run(state.runId, stepIndex, step.attemptId, outputOverrideHash);
         }
     }
+    syncAttemptEntries(runId, step, promptEntryId) {
+        const links = [];
+        if (promptEntryId !== undefined)
+            links.push(["prompt", promptEntryId]);
+        if (step.conversation !== undefined) {
+            links.push(["first", step.conversation.firstEntryId], ["last", step.conversation.lastEntryId]);
+        }
+        if (step.assistantMessage?.entryId !== undefined) {
+            links.push(["response", step.assistantMessage.entryId]);
+        }
+        let responseLinked = false;
+        for (const [role, entryId] of links) {
+            const row = this.state.connection
+                .prepare(`SELECT e.segment_id AS segmentId, e.entry_hash AS entryHash
+           FROM session_entries e
+           JOIN session_segments s ON s.segment_id = e.segment_id
+           WHERE s.run_id = ? AND e.entry_id = ?
+           ORDER BY e.recorded_at DESC LIMIT 1`)
+                .get(runId, entryId);
+            if (!isSegmentIdentityRow(row))
+                continue;
+            if (role === "response") {
+                const output = assistantOutputFromEntry(this.state.readJson(row.entryHash), step.assistantMessage?.maxChars);
+                if (canonicalJson(output) !== canonicalJson(step.output) ||
+                    createHash("sha256").update(output).digest("hex") !== step.assistantMessage?.sha256) {
+                    throw new Error(`Assistant response entry conflicts with attempt ${step.attemptId}`);
+                }
+            }
+            this.state.connection
+                .prepare(`INSERT INTO attempt_entries(attempt_id, role, segment_id, entry_id)
+           VALUES (?, ?, ?, ?)
+           ON CONFLICT(attempt_id, role) DO UPDATE SET
+             segment_id = excluded.segment_id, entry_id = excluded.entry_id`)
+                .run(step.attemptId, role, row.segmentId, entryId);
+            if (role === "response")
+                responseLinked = true;
+        }
+        return responseLinked;
+    }
+    findAttemptPromptEntry(runId, attemptId) {
+        const row = this.state.connection
+            .prepare(`SELECT e.entry_id AS entryId
+         FROM session_entries e
+         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), '$.details.contract.attemptId') = ?
+         ORDER BY e.recorded_at DESC LIMIT 1`)
+            .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 = ?")
@@ -684,18 +1536,31 @@ export class WorkflowRunStore {
         const status = state.status === "waiting" ? "waiting" : "running";
         if (existing !== undefined) {
             this.state.connection
-                .prepare("UPDATE node_attempts SET status = ?, updated_at = ? WHERE attempt_id = ?")
-                .run(status, now, attemptId);
+                .prepare(`UPDATE node_attempts
+           SET status = ?, settings_scope_id = ?, settings_change_number = ?,
+               settings_hash = ?, updated_at = ?
+           WHERE attempt_id = ?`)
+                .run(status, state.currentSettingsScopeId ?? null, state.currentSettingsChangeNumber ?? null, state.currentSettingsHash === undefined
+                ? null
+                : Buffer.from(state.currentSettingsHash, "hex"), now, attemptId);
             return;
         }
         const definition = snapshot ?? this.readDefinition(this.requireRunRow(state.runId).definitionHash);
         const nodeType = definition.nodes[nodeId]?.nodeType ?? "agent";
+        this.state.connection
+            .prepare(`UPDATE node_attempts
+         SET status = 'cancelled', finished_at = COALESCE(finished_at, ?), updated_at = ?
+         WHERE run_id = ? AND status = 'interrupted'`)
+            .run(now, now, state.runId);
         this.state.connection
             .prepare(`INSERT INTO node_attempts(
            attempt_id, run_id, node_id, attempt_number, node_type, status,
+           settings_scope_id, settings_change_number, settings_hash,
            started_at, created_at, updated_at
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(attemptId, state.runId, nodeId, this.nextAttemptNumber(state.runId, nodeId), nodeType, status, state.currentNodeStartedAt === undefined ? now : Date.parse(state.currentNodeStartedAt), now, now);
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(attemptId, state.runId, nodeId, this.nextAttemptNumber(state.runId, nodeId), nodeType, status, state.currentSettingsScopeId ?? null, state.currentSettingsChangeNumber ?? null, state.currentSettingsHash === undefined
+            ? null
+            : Buffer.from(state.currentSettingsHash, "hex"), state.currentNodeStartedAt === undefined ? now : Date.parse(state.currentNodeStartedAt), now, now);
     }
     nextAttemptNumber(runId, nodeId) {
         const row = this.state.connection
@@ -717,19 +1582,45 @@ export class WorkflowRunStore {
             throw new Error("Could not allocate workflow update sequence");
         return row.updateSeq;
     }
+    insertRunSources(runId, root, mounted) {
+        const insert = this.state.connection.prepare(`INSERT INTO run_sources(run_id, mount_path, source_type, source_ref, source_revision)
+       VALUES (?, ?, ?, ?, ?)`);
+        insert.run(runId, "", root.type, root.ref, root.revision);
+        for (const item of mounted) {
+            const source = sourceParts(item.source);
+            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,
                 d.definition_hash AS definitionHash, r.definition_digest AS definitionDigest,
-                d.workflow_name AS workflowRef, r.source_ref AS sourceRef,
-                r.workflow_source_hash AS workflowSourceHash,
-                r.workflow_sources_hash AS workflowSourcesHash, r.parent_run_id AS parentRunId,
+                d.workflow_name AS workflowRef, r.parent_run_id AS parentRunId,
                 r.title, r.status, r.paused, r.status_detail AS statusDetail,
-                r.input_hash AS inputHash, r.human_decision_hash AS humanDecisionHash,
-                r.final_output_hash AS finalOutputHash, r.error_hash AS errorHash,
-                r.carried_step_count AS carriedStepCount, r.current_node AS currentNode,
-                r.current_attempt_id AS currentAttemptId,
-                r.current_node_started_at AS currentNodeStartedAt, r.waiting_on AS waitingOn,
+                r.input_hash AS inputHash, r.final_output_hash AS finalOutputHash,
+                r.error_hash AS errorHash,
                 r.created_at AS createdAt, r.updated_at AS updatedAt, r.finished_at AS finishedAt
          FROM runs r
          JOIN workflow_definitions d ON d.definition_digest = r.definition_digest
@@ -745,6 +1636,10 @@ export class WorkflowRunStore {
     }
     readRunState(row, snapshot) {
         const steps = this.readSteps(row.runId);
+        const sources = this.readRunSources(row.runId, snapshot);
+        const carriedStepCount = this.carriedStepCount(row.runId);
+        const activeAttempt = row.status === "running" ? this.readActiveAttempt(row.runId) : undefined;
+        const humanDecision = this.readHumanDecisionReceipt(row.runId);
         const outputs = {};
         const results = {};
         for (const step of steps) {
@@ -770,15 +1665,11 @@ export class WorkflowRunStore {
             runId: row.runId,
             workflowName: row.workflowRef,
             ...(row.parentRunId === null ? {} : { parentRunId: row.parentRunId }),
-            ...(row.carriedStepCount === 0 ? {} : { carriedStepCount: row.carriedStepCount }),
+            ...(carriedStepCount === 0 ? {} : { carriedStepCount }),
             ...(row.title === null ? {} : { runTitle: row.title }),
-            ...(row.sourceRef.startsWith("inline:")
-                ? {}
-                : { workflowSource: this.readJsonAs(row.workflowSourceHash) }),
-            ...(row.workflowSourcesHash === null
-                ? {}
-                : { workflowSources: this.readJsonAs(row.workflowSourcesHash) }),
-            ...(row.workflowSourcesHash !== null || snapshot.composition?.mounts.length
+            ...(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")}` }
                 : {}),
             startedAt: new Date(row.createdAt).toISOString(),
@@ -790,17 +1681,18 @@ export class WorkflowRunStore {
             results,
             steps,
             ...this.readUpdates(row.runId),
-            ...(row.currentNode === null ? {} : { currentNode: row.currentNode }),
-            ...(row.currentAttemptId === null ? {} : { currentAttemptId: row.currentAttemptId }),
-            ...(row.currentNodeStartedAt === null
+            ...(activeAttempt === undefined ? {} : { currentNode: activeAttempt.nodeId }),
+            ...(activeAttempt === undefined ? {} : { currentAttemptId: activeAttempt.attemptId }),
+            ...(activeAttempt?.startedAt === null || activeAttempt === undefined
                 ? {}
-                : { currentNodeStartedAt: new Date(row.currentNodeStartedAt).toISOString() }),
+                : { currentNodeStartedAt: new Date(activeAttempt.startedAt).toISOString() }),
+            ...savedCurrentSettingsBinding(activeAttempt?.settingsScopeId ?? null, activeAttempt?.settingsChangeNumber ?? null, activeAttempt?.settingsHash ?? null),
             ...(row.statusDetail === null ? {} : { statusDetail: row.statusDetail }),
-            ...(row.humanDecisionHash === null
-                ? {}
-                : { humanDecision: this.readJsonAs(row.humanDecisionHash) }),
+            ...(humanDecision === undefined ? {} : { humanDecision }),
             ...(row.paused === 0 ? {} : { paused: true }),
-            ...(row.waitingOn === null ? {} : { waitingOn: row.waitingOn }),
+            ...(row.status === "waiting" && steps.at(-1) !== undefined
+                ? { waitingOn: steps.at(-1)?.nodeId }
+                : {}),
             ...(row.finalOutputHash === null
                 ? {}
                 : { finalOutput: this.state.readJson(row.finalOutputHash) }),
@@ -810,25 +1702,55 @@ export class WorkflowRunStore {
     readSteps(runId) {
         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.step_metadata_hash AS stepMetadataHash, a.error_hash AS errorHash,
+                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`)
             .all(runId)
             .filter(isStepRow);
         return rows.map((row, index) => {
             if (row.stepIndex !== index)
                 throw new Error(`Workflow run step sequence has a gap: ${runId}`);
-            const metadata = row.stepMetadataHash === null
-                ? {}
-                : this.readJsonAs(row.stepMetadataHash);
-            const prompt = row.promptHash === null ? null : this.readJsonAs(row.promptHash);
+            const receipt = row.receiptHash === null ? {} : this.readJsonAs(row.receiptHash);
+            const prompt = row.promptEntryHash !== null
+                ? promptFromEntry(this.state.readJson(row.promptEntryHash))
+                : row.promptHash === null
+                    ? null
+                    : this.readText(row.promptHash);
             const outputHash = row.outputOverrideHash ?? row.outputHash;
-            const output = outputHash === null ? null : this.state.readJson(outputHash);
+            const output = outputHash !== null
+                ? this.state.readJson(outputHash)
+                : row.responseEntryHash === null
+                    ? null
+                    : assistantOutputFromEntry(this.state.readJson(row.responseEntryHash), receipt.assistantMessage?.maxChars);
             const error = row.errorHash === null ? undefined : this.readText(row.errorHash);
+            const conversation = row.firstEntryId === null || row.lastEntryId === null
+                ? undefined
+                : { firstEntryId: row.firstEntryId, lastEntryId: row.lastEntryId };
             return {
                 attemptId: row.attemptId,
                 nodeId: row.nodeId,
@@ -839,10 +1761,94 @@ export class WorkflowRunStore {
                 prompt,
                 output,
                 ...(error === undefined ? {} : { error }),
-                ...metadata,
+                ...savedStepSettingsBinding(row.settingsScopeId, row.settingsChangeNumber, row.settingsHash),
+                ...receipt,
+                ...(conversation === undefined ? {} : { conversation }),
             };
         });
     }
+    readRunSources(runId, snapshot) {
+        const rows = this.state.connection
+            .prepare(`SELECT mount_path AS mountPath, source_type AS sourceType,
+                source_ref AS sourceRef, source_revision AS sourceRevision
+         FROM run_sources WHERE run_id = ? ORDER BY mount_path`)
+            .all(runId)
+            .filter(isRunSourceRow);
+        const rootRow = rows.find((row) => row.mountPath === "");
+        const root = rootRow === undefined ||
+            (rootRow.sourceType === "file" && rootRow.sourceRef.startsWith("inline:"))
+            ? undefined
+            : workflowSourceFromRow(rootRow);
+        const mountNames = new Map((snapshot.composition?.mounts ?? []).map((mount) => [
+            mount.mountPath.join("/"),
+            mount.workflowName,
+        ]));
+        const mounted = rows
+            .filter((row) => row.mountPath !== "")
+            .map((row) => ({
+            mountPath: row.mountPath.split("/"),
+            workflowName: mountNames.get(row.mountPath) ?? row.mountPath,
+            source: workflowSourceFromRow(row),
+        }));
+        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,
+                settings_scope_id AS settingsScopeId,
+                settings_change_number AS settingsChangeNumber,
+                settings_hash AS settingsHash
+         FROM node_attempts
+         WHERE run_id = ? AND status IN ('pending', 'running', 'waiting', 'interrupted')`)
+            .get(runId);
+        return isActiveAttemptRow(row) ? row : undefined;
+    }
+    readHumanDecisionReceipt(runId) {
+        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);
+        if (!isDecisionReceiptRow(row))
+            return undefined;
+        const request = this.readJsonAs(row.requestHash);
+        const decision = this.readJsonAs(row.responseHash);
+        if (typeof request.decisionId !== "string" ||
+            typeof request.requestDigest !== "string" ||
+            typeof request.nodeId !== "string" ||
+            typeof decision.provenance !== "string" ||
+            typeof decision.acceptedAt !== "string" ||
+            typeof decision.answerDigest !== "string" ||
+            typeof decision.subjectDigest !== "string" ||
+            typeof decision.presentationDigest !== "string" ||
+            typeof decision.revision !== "number" ||
+            decision.response === undefined) {
+            throw new Error(`Human decision receipt is invalid for run ${runId}`);
+        }
+        return {
+            schema: "pi-workflows.human-decision-receipt.v1",
+            decisionId: request.decisionId,
+            requestDigest: request.requestDigest,
+            nodeId: request.nodeId,
+            response: decision.response,
+            provenance: decision.provenance === "timeout" ? "timeout" : "human",
+            acceptedAt: decision.acceptedAt,
+            answerDigest: decision.answerDigest,
+            subjectDigest: decision.subjectDigest,
+            presentationDigest: decision.presentationDigest,
+            revision: decision.revision,
+        };
+    }
     readUpdates(runId) {
         const rows = this.state.connection
             .prepare(`SELECT u.update_id AS updateId, u.run_revision AS runRevision,
@@ -1088,8 +2094,15 @@ function insertRunEvent(state, resourceId, revision, at, event) {
     insertGenericEvent(state, resourceId, revision, event.type, "system", null, payloadHash, Date.parse(at));
 }
 function compactTracePayload(eventType, payload) {
-    if ((eventType === "node_finished" || eventType === "include_exited") &&
-        Object.hasOwn(payload, "output")) {
+    if (eventType === "agent_prompt_sent" && Object.hasOwn(payload, "prompt")) {
+        const { prompt: _prompt, ...rest } = payload;
+        return { ...rest, promptStored: true };
+    }
+    if (eventType === "node_finished" || eventType === "node_failed") {
+        const { output: _output, action: _action, assistantMessage: _assistantMessage, conversation: _conversation, error: _error, ...rest } = payload;
+        return { ...rest, ...(Object.hasOwn(payload, "output") ? { outputStored: true } : {}) };
+    }
+    if (eventType === "include_exited" && Object.hasOwn(payload, "output")) {
         const { output: _output, ...rest } = payload;
         return { ...rest, outputStored: true };
     }
@@ -1123,6 +2136,16 @@ function sourceForState(state, definitionDigest) {
         revision: definitionDigest.toString("hex"),
     };
 }
+function sourceParts(source) {
+    return source.kind === "builtin"
+        ? { type: "builtin", ref: source.id, revision: source.revision }
+        : { type: "file", ref: source.path, revision: source.hash };
+}
+function workflowSourceFromRow(row) {
+    return row.sourceType === "builtin"
+        ? { kind: "builtin", id: row.sourceRef, revision: row.sourceRevision }
+        : { kind: "file", path: row.sourceRef, hash: row.sourceRevision };
+}
 function segmentIdFor(runId, attemptId) {
     return `segment-${createHash("sha256")
         .update(`${runId}\0${attemptId ?? ""}`)
@@ -1158,13 +2181,46 @@ function outcomeForStatus(status) {
             throw new Error(`Workflow step has nonterminal status: ${status}`);
     }
 }
-function stepMetadata(step) {
+function attemptReceipt(step) {
     return {
         ...(step.action === undefined ? {} : { action: step.action }),
         ...(step.assistantMessage === undefined ? {} : { assistantMessage: step.assistantMessage }),
-        ...(step.conversation === undefined ? {} : { conversation: step.conversation }),
     };
 }
+function promptFromEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const content = value.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    return content
+        .filter(isRecord)
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .filter((text) => text.length !== 0)
+        .join("\n");
+}
+function assistantOutputFromEntry(value, maxChars) {
+    if (!isRecord(value) || !isRecord(value.message)) {
+        throw new Error("Assistant response entry is invalid");
+    }
+    const message = value.message;
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+        throw new Error("Assistant response entry does not contain an assistant message");
+    }
+    const text = message.content
+        .filter(isRecord)
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+    if (text.trim().length === 0)
+        throw new Error("Assistant response entry has no visible text");
+    if (maxChars !== undefined && text.length > maxChars) {
+        throw new Error(`Assistant response exceeds its stored limit of ${maxChars} characters`);
+    }
+    return text;
+}
 function resultForStep(step) {
     return {
         attemptId: step.attemptId,
@@ -1229,6 +2285,143 @@ function validateSessionCapture(capture) {
         throw new Error("Only failed session capture may contain failure details");
     }
 }
+function followUpIdFor(runId, requestId) {
+    const digest = createHash("sha256").update(`${runId}\0${requestId}`).digest("hex").slice(0, 40);
+    return `follow-up-${digest}`;
+}
+function assertRequestId(requestId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u.test(requestId)) {
+        throw new Error("Workflow request ID must be a stable identifier of at most 512 characters");
+    }
+}
+function assertSourceType(source) {
+    if (typeof source !== "string" || source.trim().length === 0 || source.length > 128) {
+        throw new Error("Workflow change source must be a non-empty string of at most 128 characters");
+    }
+}
+function assertActorType(value) {
+    if (value !== "session" &&
+        value !== "host" &&
+        value !== "controller" &&
+        value !== "channel" &&
+        value !== "human" &&
+        value !== "policy" &&
+        value !== "control" &&
+        value !== "system") {
+        throw new Error(`Unknown saved actor type: ${value}`);
+    }
+    return value;
+}
+function assertFollowUpState(value) {
+    if (value !== "queued" &&
+        value !== "pending_presentation" &&
+        value !== "ready" &&
+        value !== "sent" &&
+        value !== "removed" &&
+        value !== "cancelled") {
+        throw new Error(`Unknown workflow follow-up state: ${value}`);
+    }
+    return value;
+}
+function assertPresentationState(value) {
+    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) {
+    return (isRecord(value) &&
+        typeof value.scopeId === "string" &&
+        typeof value.resourceId === "string" &&
+        typeof value.originRunId === "string" &&
+        typeof value.activeRunId === "string" &&
+        typeof value.mountPath === "string" &&
+        typeof value.invocation === "number" &&
+        Buffer.isBuffer(value.currentHash) &&
+        typeof value.revision === "number" &&
+        typeof value.createdAt === "number" &&
+        typeof value.updatedAt === "number");
+}
+function isSettingsProjectionRow(value) {
+    return (isRecord(value) &&
+        typeof value.scopeId === "string" &&
+        Buffer.isBuffer(value.initialHash) &&
+        Buffer.isBuffer(value.currentHash) &&
+        typeof value.revision === "number");
+}
+function isSettingsProjectionChangeRow(value) {
+    return (isRecord(value) &&
+        typeof value.changeNumber === "number" &&
+        Buffer.isBuffer(value.patchHash) &&
+        Buffer.isBuffer(value.beforeHash) &&
+        Buffer.isBuffer(value.afterHash));
+}
+function isSettingsChangeRow(value) {
+    return (isRecord(value) &&
+        typeof value.changeId === "string" &&
+        typeof value.scopeId === "string" &&
+        typeof value.requestId === "string" &&
+        typeof value.changeNumber === "number" &&
+        typeof value.actorType === "string" &&
+        (typeof value.actorId === "string" || value.actorId === null) &&
+        typeof value.sourceType === "string" &&
+        Buffer.isBuffer(value.patchHash) &&
+        Buffer.isBuffer(value.beforeHash) &&
+        Buffer.isBuffer(value.afterHash) &&
+        typeof value.acceptedAt === "number");
+}
+function isFollowUpQueueRow(value) {
+    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) {
+    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" &&
+        typeof value.targetSessionId === "string" &&
+        typeof value.actorType === "string" &&
+        (typeof value.actorId === "string" || value.actorId === null) &&
+        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");
+}
+function isParentRunRow(value) {
+    return isRecord(value) && (typeof value.parentRunId === "string" || value.parentRunId === null);
+}
+function isStatusRow(value) {
+    return isRecord(value) && typeof value.status === "string";
+}
+function isCountRow(value) {
+    return isRecord(value) && typeof value.count === "number";
+}
+function isLeaseExpiryRow(value) {
+    return isRecord(value) && (typeof value.expiresAt === "number" || value.expiresAt === null);
+}
+function isNextOrderRow(value) {
+    return isRecord(value) && typeof value.nextOrder === "number";
+}
 function assertValidRunId(runId) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/.test(runId)) {
         throw new Error(`Invalid workflow run id: ${JSON.stringify(runId)}`);
@@ -1240,18 +2433,60 @@ function isRecord(value) {
 function isRunRow(value) {
     return isRecord(value);
 }
+function savedCurrentSettingsBinding(scopeId, changeNumber, settingsHash) {
+    if (scopeId === null && changeNumber === null && settingsHash === null)
+        return {};
+    if (scopeId === null || changeNumber === null || settingsHash === null) {
+        throw new Error("Saved current workflow settings binding is incomplete");
+    }
+    return {
+        currentSettingsScopeId: scopeId,
+        currentSettingsChangeNumber: changeNumber,
+        currentSettingsHash: settingsHash.toString("hex"),
+    };
+}
+function savedStepSettingsBinding(scopeId, changeNumber, settingsHash) {
+    if (scopeId === null && changeNumber === null && settingsHash === null)
+        return {};
+    if (scopeId === null || changeNumber === null || settingsHash === null) {
+        throw new Error("Saved workflow step settings binding is incomplete");
+    }
+    return {
+        settingsScopeId: scopeId,
+        settingsChangeNumber: changeNumber,
+        settingsHash: settingsHash.toString("hex"),
+    };
+}
 function isRunIdRow(value) {
     return isRecord(value);
 }
 function isRunStepIdentityRow(value) {
     return isRecord(value);
 }
-function isAttemptOutputRow(value) {
-    return isRecord(value) && (value.outputHash === null || Buffer.isBuffer(value.outputHash));
-}
 function isStepRow(value) {
     return isRecord(value);
 }
+function isRunSourceRow(value) {
+    return isRecord(value);
+}
+function isSegmentIdentityRow(value) {
+    return isRecord(value) && typeof value.segmentId === "string" && Buffer.isBuffer(value.entryHash);
+}
+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);
 }
@@ -1280,7 +2515,15 @@ function isLeaseAuthorityRow(value) {
     return isRecord(value);
 }
 export function createDefinitionSnapshot(workflow) {
-    const composition = compositionMetadata(workflow)?.snapshot;
+    const metadata = compositionMetadata(workflow);
+    const composition = metadata?.snapshot;
+    const settingsScopes = Object.values(metadata?.scopes ?? {})
+        .filter((scope) => scope.path !== "" && scope.settings !== undefined)
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((scope) => ({
+        mountPath: scope.path.split("/"),
+        settings: snapshotSettings(scope.settings),
+    }));
     return {
         schema: DEFINITION_SNAPSHOT_SCHEMA,
         name: workflow.name,
@@ -1292,6 +2535,8 @@ export function createDefinitionSnapshot(workflow) {
         ])),
         edges: structuredClone(workflow.edges),
         ...(composition !== undefined ? { composition: structuredClone(composition) } : {}),
+        ...(workflow.settings !== undefined ? { settings: snapshotSettings(workflow.settings) } : {}),
+        ...(settingsScopes.length > 0 ? { settingsScopes } : {}),
     };
 }
 function snapshotNode(workflow, nodeId, node) {
@@ -1326,6 +2571,9 @@ function snapshotNode(workflow, nodeId, node) {
     if (node.nodeType === "agent" && node.expectedOutput !== undefined) {
         common.expectedOutput = node.expectedOutput;
     }
+    if (node.nodeType === "compute" && node.settingsRoute === true) {
+        common.settingsRoute = true;
+    }
     if (node.nodeType === "notify")
         common.summary = node.kind ?? "progress";
     if (node.nodeType === "checkpoint" && node.summary !== undefined)
@@ -1346,4 +2594,16 @@ function snapshotNode(workflow, nodeId, node) {
         common.actionExecution = "exec" in node ? "shell" : "function";
     return common;
 }
+function snapshotSettings(settings) {
+    return {
+        ...(settings.description !== undefined ? { description: settings.description } : {}),
+        paths: settings.paths.map((rule) => ({
+            path: rule.path,
+            permissions: Object.fromEntries(Object.entries(rule.permissions).map(([permission, actors]) => [
+                permission,
+                actors === undefined ? [] : [...actors],
+            ])),
+        })),
+    };
+}
 //# sourceMappingURL=store.js.map