@osolmaz/pi-workflows 0.16.0 → 0.16.2

package/dist/host/state.d.ts

@@ -1,6 +1,7 @@
 import { type ClientRequest, type ClientResponse } from "../client/protocol.js";
 import { StateDatabase } from "../state/database.js";
 import { type JsonValue } from "../state/json.js";
+import { WorkflowMessageStore, type WorkflowStepReason } from "../state/workflow-messages.js";
 import type { WorkerMessage, WorkerResponse } from "./worker-protocol.js";
 export type HostClaim = {
     hostId: string;
@@ -49,10 +50,8 @@ export type InteractiveRequestRecord = {
     kind: "agent" | "assistant" | "decision";
     contract: JsonValue;
     revision: number;
-    status: "pending" | "presenting" | "settled" | "cancelled";
-    presenterId: string | null;
-    presentationClaimExpiresAt: string | null;
-    presentationSessionEntryId: string | null;
+    status: "pending" | "settled" | "cancelled";
+    unproductiveTurnEnds: number;
     acceptedSubmissionId: string | null;
     createdAt: string;
     updatedAt: string;
@@ -62,6 +61,7 @@ export type InteractiveRequestRecord = {
 export declare class HostStateStore {
     readonly state: StateDatabase;
     private readonly ownsState;
+    readonly workflowMessages: WorkflowMessageStore;
     constructor(databasePath: string, options?: {
         state?: StateDatabase;
         readOnly?: boolean;
@@ -100,6 +100,14 @@ export declare class HostStateStore {
         kind: InteractiveRequestRecord["kind"];
         contract: JsonValue;
     }): InteractiveRequestRecord;
+    ensureInteractionMessage(request: InteractiveRequestRecord, reason: WorkflowStepReason, now?: number): import("../state/workflow-messages.js").WorkflowMessage;
+    resumePendingInteraction(runId: string, now?: number): InteractiveRequestRecord;
+    beginInteractionModelTurn(requestId: string, now?: number): void;
+    interactionPauseStartedAt(runId: string): number | undefined;
+    resumeInteractionModelTurn(runId: string, pausedAt: number | undefined, now?: number): void;
+    markSessionModelTurnsInactive(targetSessionId: string, now?: number): void;
+    recoverInactiveModelTurns(previousHeartbeatAt: number | undefined, now?: number): void;
+    resumeSessionModelTurns(targetSessionId: string, now?: number): void;
     getInteraction(requestId: string): InteractiveRequestRecord | undefined;
     acceptedInteraction(runId: string): {
         requestId: string;
@@ -116,7 +124,7 @@ export declare class HostStateStore {
         payload: JsonValue;
     } | undefined;
     validatingInteractionRunIds(): string[];
-    expiredInteractionRunIds(now?: number): string[];
+    expiredInteractionRuns(now?: number): ExpiredInteractionRunRow[];
     timedOutInteraction(runId: string): TimedOutInteractionRow | undefined;
     interactionSubmission(requestId: string, submissionId: string): InteractiveSubmissionRecord | undefined;
     finishInteractionValidation(options: {
@@ -127,17 +135,7 @@ export declare class HostStateStore {
     }): InteractiveSubmissionRecord;
     consumeAcceptedInteraction(runId: string, attemptId: string, now?: number): boolean;
     listPendingInteractions(sessionId: string): InteractiveRequestRecord[];
-    claimInteractionPresentation(options: {
-        requestId: string;
-        expectedRevision: number;
-        presenterId: string;
-        leaseMs: number;
-    }): InteractiveRequestRecord;
-    markInteractionPresented(options: {
-        requestId: string;
-        expectedRevision: number;
-        sessionEntryId: string;
-    }): InteractiveRequestRecord;
+    listPendingDecisionInteractions(): InteractiveRequestRecord[];
     submitInteraction(options: {
         requestId: string;
         submissionId: string;
@@ -169,6 +167,7 @@ export declare class HostStateStore {
     private hostRow;
     private commandResponse;
     private interactiveRequest;
+    private shiftInteractionTimeout;
     private requireInteractiveRequest;
 }
 type TimedOutInteractionRow = {
@@ -176,4 +175,8 @@ type TimedOutInteractionRow = {
     attemptId: string;
     nodeId: string;
 };
+type ExpiredInteractionRunRow = {
+    runId: string;
+    targetSessionId: string;
+};
 export {};

package/dist/host/state.js

@@ -3,9 +3,12 @@ import { CLIENT_PROTOCOL_SCHEMA, clientRequestFingerprint, } from "../client/pro
 import { StateDatabase } from "../state/database.js";
 import { canonicalJson } from "../state/json.js";
 import { tokenHash } from "../state/mutation.js";
+import { WorkflowMessageStore, workflowMessageIdFor, } from "../state/workflow-messages.js";
+import { decisionWorkflowMessageContent, stepWorkflowMessageContent, } from "../workflows/workflow-message-content.js";
 export class HostStateStore {
     state;
     ownsState;
+    workflowMessages;
     constructor(databasePath, options = {}) {
         this.ownsState = options.state === undefined;
         this.state =
@@ -14,6 +17,7 @@ export class HostStateStore {
                     filePath: databasePath,
                     mode: options.readOnly === true ? "read-only" : "read-write",
                 });
+        this.workflowMessages = new WorkflowMessageStore(this.state);
     }
     close() {
         if (this.ownsState)
@@ -242,14 +246,16 @@ export class HostStateStore {
                 if (existing.status === "settled" && existing.consumedAt === null) {
                     this.state.connection
                         .prepare(`UPDATE interactive_requests
-               SET status = 'pending', presenter_id = NULL,
-                   presentation_claim_expires_at = NULL, presentation_session_entry_id = NULL,
-                   accepted_submission_id = NULL, settled_at = NULL, consumed_at = NULL,
-                   revision = revision + 1, updated_at = ?
+               SET status = 'pending', accepted_submission_id = NULL,
+                   settled_at = NULL, consumed_at = NULL, revision = revision + 1, updated_at = ?
                WHERE request_id = ? AND status = 'settled' AND consumed_at IS NULL`)
                         .run(now, options.requestId);
-                    return this.requireInteractiveRequest(options.requestId);
+                    const reopened = this.requireInteractiveRequest(options.requestId);
+                    this.ensureInteractionMessage(reopened, "resumed", now);
+                    return reopened;
                 }
+                if (existing.status === "pending")
+                    this.ensureInteractionMessage(existing, "initial", now);
                 return existing;
             }
             const contractHash = this.state.putJson(options.contract, now);
@@ -259,9 +265,172 @@ export class HostStateStore {
              revision, status, created_at, updated_at
            ) VALUES (?, ?, ?, ?, ?, ?, 1, 'pending', ?, ?)`)
                 .run(options.requestId, options.runId, options.attemptId, options.targetSessionId, options.kind, contractHash, now, now);
-            return this.requireInteractiveRequest(options.requestId);
+            const created = this.requireInteractiveRequest(options.requestId);
+            this.ensureInteractionMessage(created, "initial", now);
+            return created;
         });
     }
+    ensureInteractionMessage(request, reason, now = Date.now()) {
+        const kind = request.kind === "decision" ? "decision" : "step";
+        const idempotencyKey = `${request.revision}:${reason}`;
+        const workflowMessageId = workflowMessageIdFor(kind, request.requestId, idempotencyKey);
+        const content = kind === "decision"
+            ? decisionWorkflowMessageContent({
+                workflowMessageId,
+                requestId: request.requestId,
+                runId: request.runId,
+                contract: request.contract,
+            })
+            : stepWorkflowMessageContent({
+                workflowMessageId,
+                requestId: request.requestId,
+                contract: request.contract,
+                reason,
+            });
+        return this.workflowMessages.create({
+            workflowMessageId,
+            runId: request.runId,
+            targetSessionId: request.targetSessionId,
+            kind,
+            sourceId: request.requestId,
+            idempotencyKey,
+            content,
+            now,
+        });
+    }
+    resumePendingInteraction(runId, now = Date.now()) {
+        return this.state.transaction(() => {
+            const row = this.state.connection
+                .prepare(`SELECT request_id AS requestId FROM interactive_requests
+           WHERE run_id = ? AND status = 'pending' ORDER BY created_at LIMIT 1`)
+                .get(runId);
+            if (!isRequestIdRow(row))
+                throw new Error("Pending workflow interaction is missing");
+            const current = this.requireInteractiveRequest(row.requestId);
+            if (current.kind === "decision")
+                return current;
+            this.workflowMessages.cancelPendingForSource(current.requestId, "step", now);
+            const changed = this.state.connection
+                .prepare(`UPDATE interactive_requests SET revision = revision + 1, updated_at = ?
+           WHERE request_id = ? AND status = 'pending'`)
+                .run(now, row.requestId);
+            if (changed.changes !== 1)
+                throw new Error("Pending workflow interaction resume is stale");
+            const request = this.requireInteractiveRequest(row.requestId);
+            this.ensureInteractionMessage(request, "resumed", now);
+            return request;
+        });
+    }
+    beginInteractionModelTurn(requestId, now = Date.now()) {
+        const row = this.state.connection
+            .prepare(`SELECT i.attempt_id AS attemptId, i.created_at AS createdAt,
+                a.started_at AS startedAt, a.deadline_at AS deadlineAt,
+                (SELECT MAX(t.ended_at)
+                 FROM workflow_messages m
+                 JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+                 WHERE m.source_id = i.request_id AND m.kind = 'step'
+                   AND t.state = 'ended') AS previousTurnEndedAt
+         FROM interactive_requests i
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         WHERE i.request_id = ? AND i.status = 'pending'`)
+            .get(requestId);
+        if (!isInteractionTimeoutRow(row)) {
+            throw new Error("Pending workflow interaction timeout is missing");
+        }
+        this.shiftInteractionTimeout(row, Math.max(0, now - (row.previousTurnEndedAt ?? row.startedAt ?? row.createdAt)), now);
+    }
+    interactionPauseStartedAt(runId) {
+        const row = this.state.connection
+            .prepare(`SELECT r.updated_at AS pausedAt
+         FROM runs r
+         JOIN interactive_requests i ON i.run_id = r.run_id AND i.status = 'pending'
+         WHERE r.run_id = ? AND r.paused = 1 LIMIT 1`)
+            .get(runId);
+        return isPausedAtRow(row) ? row.pausedAt : undefined;
+    }
+    resumeInteractionModelTurn(runId, pausedAt, now = Date.now()) {
+        if (pausedAt === undefined)
+            return;
+        const row = this.state.connection
+            .prepare(`SELECT i.attempt_id AS attemptId, i.created_at AS createdAt,
+                a.started_at AS startedAt, a.deadline_at AS deadlineAt,
+                t.ended_at AS previousTurnEndedAt
+         FROM interactive_requests i
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+         WHERE i.run_id = ? AND i.status = 'pending' AND t.started_at <= ?
+           AND (t.ended_at IS NULL OR t.ended_at > ?)
+         ORDER BY t.started_at DESC LIMIT 1`)
+            .get(runId, pausedAt, pausedAt);
+        if (!isInteractionTimeoutRow(row))
+            return;
+        const modelTurnStoppedAt = Math.min(now, row.previousTurnEndedAt ?? now);
+        this.shiftInteractionTimeout(row, Math.max(0, modelTurnStoppedAt - pausedAt), now);
+    }
+    markSessionModelTurnsInactive(targetSessionId, now = Date.now()) {
+        this.state.connection
+            .prepare(`UPDATE node_attempts SET status = 'interrupted', updated_at = ?
+         WHERE status <> 'interrupted' AND attempt_id IN (
+           SELECT DISTINCT i.attempt_id
+           FROM interactive_requests i
+           JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+           JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+                                AND t.state = 'started'
+           WHERE i.target_session_id = ? AND i.status = 'pending'
+         )`)
+            .run(now, targetSessionId);
+    }
+    recoverInactiveModelTurns(previousHeartbeatAt, now = Date.now()) {
+        const rows = this.state.connection
+            .prepare(`SELECT i.attempt_id AS attemptId, a.status, a.started_at AS startedAt,
+                a.deadline_at AS deadlineAt, a.updated_at AS updatedAt,
+                MAX(t.started_at) AS turnStartedAt
+         FROM interactive_requests i
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+                              AND t.state = 'started'
+         WHERE i.status = 'pending'
+         GROUP BY i.attempt_id`)
+            .all()
+            .filter(isInactiveInteractionTimeoutRow);
+        for (const row of rows) {
+            const inactiveAt = row.status === "interrupted"
+                ? row.updatedAt
+                : previousHeartbeatAt === undefined
+                    ? row.updatedAt
+                    : Math.max(previousHeartbeatAt, row.turnStartedAt);
+            this.shiftInteractionTimeout(row, Math.max(0, now - inactiveAt), now);
+            this.state.connection
+                .prepare(`UPDATE node_attempts SET status = 'interrupted', updated_at = ?
+           WHERE attempt_id = ? AND status IN ('pending', 'running', 'waiting', 'interrupted')`)
+                .run(now, row.attemptId);
+        }
+    }
+    resumeSessionModelTurns(targetSessionId, now = Date.now()) {
+        const rows = this.state.connection
+            .prepare(`SELECT i.attempt_id AS attemptId, a.status, a.started_at AS startedAt,
+                a.deadline_at AS deadlineAt, a.updated_at AS updatedAt,
+                MAX(t.started_at) AS turnStartedAt
+         FROM interactive_requests i
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+                              AND t.state = 'started'
+         WHERE i.target_session_id = ? AND i.status = 'pending'
+           AND a.status = 'interrupted'
+         GROUP BY i.attempt_id`)
+            .all(targetSessionId)
+            .filter(isInactiveInteractionTimeoutRow);
+        for (const row of rows) {
+            this.shiftInteractionTimeout(row, Math.max(0, now - row.updatedAt), now);
+            this.state.connection
+                .prepare(`UPDATE node_attempts SET status = 'waiting', updated_at = ?
+           WHERE attempt_id = ? AND status = 'interrupted'`)
+                .run(now, row.attemptId);
+        }
+    }
     getInteraction(requestId) {
         return this.interactiveRequest(requestId);
     }
@@ -292,7 +461,7 @@ export class HostStateStore {
          FROM interactive_requests i
          JOIN node_attempts a ON a.attempt_id = i.attempt_id
          JOIN interactive_submissions s ON s.request_id = i.request_id
-         WHERE i.run_id = ? AND i.status IN ('pending', 'presenting')
+         WHERE i.run_id = ? AND i.status = 'pending'
            AND s.outcome = 'validating'
          ORDER BY s.submitted_at DESC LIMIT 1`)
             .get(runId);
@@ -312,26 +481,32 @@ export class HostStateStore {
          FROM interactive_requests i
          JOIN interactive_submissions s ON s.request_id = i.request_id
          JOIN run_queue q ON q.run_id = i.run_id
-         WHERE i.status IN ('pending', 'presenting') AND s.outcome = 'validating'
+         WHERE i.status = 'pending' AND s.outcome = 'validating'
            AND q.status NOT IN ('done', 'failed', 'cancelled')
          GROUP BY i.run_id
          ORDER BY MIN(s.submitted_at), i.run_id`)
             .all()
             .flatMap((row) => (isRunIdRow(row) ? [row.runId] : []));
     }
-    expiredInteractionRunIds(now = Date.now()) {
+    expiredInteractionRuns(now = Date.now()) {
         return this.state.connection
-            .prepare(`SELECT i.run_id AS runId
+            .prepare(`SELECT i.run_id AS runId, i.target_session_id AS targetSessionId
          FROM interactive_requests i
          JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         JOIN runs r ON r.run_id = i.run_id
          JOIN run_queue q ON q.run_id = i.run_id
-         WHERE i.status IN ('pending', 'presenting')
+         WHERE i.status = 'pending' AND r.paused = 0
            AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
            AND q.status NOT IN ('done', 'failed', 'cancelled')
-         GROUP BY i.run_id
+           AND EXISTS (
+             SELECT 1 FROM workflow_messages m
+             JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+             WHERE m.source_id = i.request_id AND m.kind = 'step' AND t.state = 'started'
+           )
+         GROUP BY i.run_id, i.target_session_id
          ORDER BY MIN(a.deadline_at), i.run_id`)
             .all(now)
-            .flatMap((row) => (isRunIdRow(row) ? [row.runId] : []));
+            .filter(isExpiredInteractionRunRow);
     }
     timedOutInteraction(runId) {
         const row = this.state.connection
@@ -340,8 +515,13 @@ export class HostStateStore {
          JOIN node_attempts a ON a.attempt_id = i.attempt_id
          JOIN runs r ON r.run_id = i.run_id
          WHERE i.run_id = ? AND i.status = 'cancelled' AND r.status = 'running'
-           AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
-           AND a.status IN ('pending', 'running', 'waiting', 'interrupted')
+           AND r.paused = 0 AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
+           AND a.status IN ('pending', 'running', 'waiting', 'interrupted', 'timed_out')
+           AND EXISTS (
+             SELECT 1 FROM workflow_messages m
+             JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
+             WHERE m.source_id = i.request_id AND m.kind = 'step' AND t.state = 'started'
+           )
          ORDER BY a.deadline_at, i.request_id LIMIT 1`)
             .get(runId, Date.now());
         return isTimedOutInteractionRow(row) ? row : undefined;
@@ -384,13 +564,14 @@ export class HostStateStore {
             if (options.accepted) {
                 const changed = this.state.connection
                     .prepare(`UPDATE interactive_requests
-             SET status = 'settled', presenter_id = NULL,
-                 presentation_claim_expires_at = NULL, accepted_submission_id = ?,
+             SET status = 'settled', accepted_submission_id = ?,
                  revision = revision + 1, updated_at = ?, settled_at = ?
-             WHERE request_id = ? AND revision = ? AND status IN ('pending', 'presenting')`)
+             WHERE request_id = ? AND revision = ? AND status = 'pending'`)
                     .run(options.submissionId, now, now, options.requestId, request.revision);
                 if (changed.changes !== 1)
                     throw new Error("Interactive request validation is stale");
+                this.workflowMessages.cancelPendingForSource(options.requestId, "step", now);
+                this.workflowMessages.cancelPendingForSource(options.requestId, "decision", now);
             }
             const settled = this.interactionSubmission(options.requestId, options.submissionId);
             if (settled === undefined)
@@ -409,40 +590,18 @@ export class HostStateStore {
     listPendingInteractions(sessionId) {
         return this.state.connection
             .prepare(`SELECT request_id AS requestId FROM interactive_requests
-         WHERE target_session_id = ? AND status IN ('pending', 'presenting')
+         WHERE target_session_id = ? AND status = 'pending'
          ORDER BY created_at, request_id`)
             .all(sessionId)
             .flatMap((row) => isRequestIdRow(row) ? [this.requireInteractiveRequest(row.requestId)] : []);
     }
-    claimInteractionPresentation(options) {
-        requireLeaseMs(options.leaseMs);
-        const now = Date.now();
-        const changed = this.state.connection
-            .prepare(`UPDATE interactive_requests
-         SET status = 'presenting', presenter_id = ?, presentation_claim_expires_at = ?,
-             revision = revision + 1, updated_at = ?
-         WHERE request_id = ? AND revision = ? AND presentation_session_entry_id IS NULL
-           AND (
-             status = 'pending'
-             OR (status = 'presenting' AND presentation_claim_expires_at <= ?)
-           )`)
-            .run(options.presenterId, now + options.leaseMs, now, options.requestId, options.expectedRevision, now);
-        if (changed.changes !== 1)
-            throw new Error("Interactive request presentation claim conflict");
-        return this.requireInteractiveRequest(options.requestId);
-    }
-    markInteractionPresented(options) {
-        const now = Date.now();
-        const changed = this.state.connection
-            .prepare(`UPDATE interactive_requests
-         SET status = 'presenting', presenter_id = NULL, presentation_claim_expires_at = NULL,
-             presentation_session_entry_id = ?, revision = revision + 1, updated_at = ?
-         WHERE request_id = ? AND revision = ? AND status IN ('pending', 'presenting')
-           AND (presentation_session_entry_id IS NULL OR presentation_session_entry_id = ?)`)
-            .run(options.sessionEntryId, now, options.requestId, options.expectedRevision, options.sessionEntryId);
-        if (changed.changes !== 1)
-            throw new Error("Interactive request presentation conflict");
-        return this.requireInteractiveRequest(options.requestId);
+    listPendingDecisionInteractions() {
+        return this.state.connection
+            .prepare(`SELECT request_id AS requestId FROM interactive_requests
+         WHERE kind = 'decision' AND status = 'pending'
+         ORDER BY created_at, request_id`)
+            .all()
+            .flatMap((row) => isRequestIdRow(row) ? [this.requireInteractiveRequest(row.requestId)] : []);
     }
     submitInteraction(options) {
         return this.recordInteractionSubmission({
@@ -490,8 +649,7 @@ export class HostStateStore {
                 }
             }
             const request = this.requireInteractiveRequest(options.requestId);
-            if (request.revision !== options.expectedRevision ||
-                !["pending", "presenting"].includes(request.status)) {
+            if (request.revision !== options.expectedRevision || request.status !== "pending") {
                 throw new Error("Interactive request revision conflict");
             }
             const savedPayloadHash = this.state.putJson(options.payload, now);
@@ -505,11 +663,12 @@ export class HostStateStore {
             if (options.settle) {
                 this.state.connection
                     .prepare(`UPDATE interactive_requests
-             SET status = 'settled', presenter_id = NULL, presentation_claim_expires_at = NULL,
-                 accepted_submission_id = ?, revision = revision + 1,
+             SET status = 'settled', accepted_submission_id = ?, revision = revision + 1,
                  updated_at = ?, settled_at = ?
-             WHERE request_id = ? AND revision = ? AND status IN ('pending', 'presenting')`)
+             WHERE request_id = ? AND revision = ? AND status = 'pending'`)
                     .run(options.submissionId, now, now, options.requestId, options.expectedRevision);
+                this.workflowMessages.cancelPendingForSource(options.requestId, "step", now);
+                this.workflowMessages.cancelPendingForSource(options.requestId, "decision", now);
             }
             return {
                 interaction: this.requireInteractiveRequest(options.requestId),
@@ -552,9 +711,7 @@ export class HostStateStore {
         const row = this.state.connection
             .prepare(`SELECT request_id AS requestId, run_id AS runId, attempt_id AS attemptId,
                 target_session_id AS targetSessionId, kind, contract_hash AS contractHash,
-                revision, status, presenter_id AS presenterId,
-                presentation_claim_expires_at AS presentationClaimExpiresAt,
-                presentation_session_entry_id AS presentationSessionEntryId,
+                revision, status, unproductive_turn_ends AS unproductiveTurnEnds,
                 accepted_submission_id AS acceptedSubmissionId, created_at AS createdAt,
                 updated_at AS updatedAt, settled_at AS settledAt, consumed_at AS consumedAt
          FROM interactive_requests WHERE request_id = ?`)
@@ -570,9 +727,7 @@ export class HostStateStore {
             contract: this.state.readJson(row.contractHash),
             revision: row.revision,
             status: row.status,
-            presenterId: row.presenterId,
-            presentationClaimExpiresAt: iso(row.presentationClaimExpiresAt),
-            presentationSessionEntryId: row.presentationSessionEntryId,
+            unproductiveTurnEnds: row.unproductiveTurnEnds,
             acceptedSubmissionId: row.acceptedSubmissionId,
             createdAt: new Date(row.createdAt).toISOString(),
             updatedAt: new Date(row.updatedAt).toISOString(),
@@ -580,6 +735,18 @@ export class HostStateStore {
             consumedAt: iso(row.consumedAt),
         };
     }
+    shiftInteractionTimeout(row, idleMs, now) {
+        if (idleMs === 0 || row.deadlineAt === null)
+            return;
+        const changed = this.state.connection
+            .prepare(`UPDATE node_attempts
+         SET started_at = CASE WHEN started_at IS NULL THEN NULL ELSE started_at + ? END,
+             deadline_at = deadline_at + ?, updated_at = ?
+         WHERE attempt_id = ? AND deadline_at = ?`)
+            .run(idleMs, idleMs, now, row.attemptId, row.deadlineAt);
+        if (changed.changes !== 1)
+            throw new Error("Workflow interaction timeout changed concurrently");
+    }
     requireInteractiveRequest(requestId) {
         const request = this.interactiveRequest(requestId);
         if (request === undefined)
@@ -655,6 +822,29 @@ function isTimedOutInteractionRow(value) {
         typeof value.attemptId === "string" &&
         typeof value.nodeId === "string");
 }
+function isInteractionTimeoutRow(value) {
+    return (isRecord(value) &&
+        typeof value.attemptId === "string" &&
+        typeof value.createdAt === "number" &&
+        nullableNumber(value.startedAt) &&
+        nullableNumber(value.deadlineAt) &&
+        nullableNumber(value.previousTurnEndedAt));
+}
+function isInactiveInteractionTimeoutRow(value) {
+    return (isRecord(value) &&
+        typeof value.attemptId === "string" &&
+        ["pending", "running", "waiting", "interrupted"].includes(value.status) &&
+        nullableNumber(value.startedAt) &&
+        nullableNumber(value.deadlineAt) &&
+        typeof value.updatedAt === "number" &&
+        typeof value.turnStartedAt === "number");
+}
+function isExpiredInteractionRunRow(value) {
+    return (isRecord(value) && typeof value.runId === "string" && typeof value.targetSessionId === "string");
+}
+function isPausedAtRow(value) {
+    return isRecord(value) && typeof value.pausedAt === "number";
+}
 function isSubmissionRow(value) {
     return (isRecord(value) &&
         typeof value.submissionId === "string" &&
@@ -684,10 +874,8 @@ function isInteractiveRequestRow(value) {
         ["agent", "assistant", "decision"].includes(value.kind) &&
         Buffer.isBuffer(value.contractHash) &&
         typeof value.revision === "number" &&
-        ["pending", "presenting", "settled", "cancelled"].includes(value.status) &&
-        nullableString(value.presenterId) &&
-        nullableNumber(value.presentationClaimExpiresAt) &&
-        nullableString(value.presentationSessionEntryId) &&
+        ["pending", "settled", "cancelled"].includes(value.status) &&
+        typeof value.unproductiveTurnEnds === "number" &&
         nullableString(value.acceptedSubmissionId) &&
         typeof value.createdAt === "number" &&
         typeof value.updatedAt === "number" &&