@osolmaz/pi-workflows 0.15.3 → 0.16.1

package/src/host/state.ts

@@ -1,9 +1,22 @@
 import { createHash, randomBytes } from "node:crypto";
+import {
+  CLIENT_PROTOCOL_SCHEMA,
+  clientRequestFingerprint,
+  type ClientRequest,
+  type ClientResponse,
+} from "../client/protocol.js";
 import { StateDatabase } from "../state/database.js";
 import { canonicalJson, type JsonValue } from "../state/json.js";
 import { tokenHash } from "../state/mutation.js";
-import type { HostRequest, HostResponse } from "./protocol.js";
-import { requestFingerprint } from "./protocol.js";
+import {
+  WorkflowMessageStore,
+  workflowMessageIdFor,
+  type WorkflowStepReason,
+} from "../state/workflow-messages.js";
+import {
+  decisionWorkflowMessageContent,
+  stepWorkflowMessageContent,
+} from "../workflows/workflow-message-content.js";
 import type { WorkerMessage, WorkerResponse } from "./worker-protocol.js";
 
 export type HostClaim = {
@@ -64,10 +77,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;
@@ -78,6 +89,7 @@ export type InteractiveRequestRecord = {
 export class HostStateStore {
   readonly state: StateDatabase;
   private readonly ownsState: boolean;
+  readonly workflowMessages: WorkflowMessageStore;
 
   constructor(databasePath: string, options: { state?: StateDatabase; readOnly?: boolean } = {}) {
     this.ownsState = options.state === undefined;
@@ -87,6 +99,7 @@ export class HostStateStore {
         filePath: databasePath,
         mode: options.readOnly === true ? "read-only" : "read-write",
       });
+    this.workflowMessages = new WorkflowMessageStore(this.state);
   }
 
   close(): void {
@@ -201,53 +214,65 @@ export class HostStateStore {
     };
   }
 
-  readCommand(request: HostRequest): HostResponse | undefined {
+  readCommand(request: ClientRequest): ClientResponse | undefined {
     const row = this.state.connection
       .prepare(
-        `SELECT request_fingerprint AS requestFingerprint, outcome, accepted_revision AS revision,
+        `SELECT request_fingerprint AS clientRequestFingerprint, outcome, accepted_revision AS revision,
                 receipt_hash AS receiptHash, error_hash AS errorHash
          FROM host_commands WHERE request_id = ?`,
       )
       .get(request.requestId);
     if (!isCommandRow(row)) return undefined;
-    if (!row.requestFingerprint.equals(requestFingerprint(request))) {
+    if (!row.clientRequestFingerprint.equals(clientRequestFingerprint(request))) {
       return conflictResponse(request.requestId, "Request ID was reused with another payload");
     }
     return this.commandResponse(request.requestId, row);
   }
 
-  executeCommand(
-    request: HostRequest,
-    hostEpoch: number,
-    operation: () => Omit<HostResponse, "schema" | "requestId">,
-  ): HostResponse {
+  adoptCommand(request: ClientRequest): ClientResponse | undefined {
     const existing = this.readCommand(request);
     if (existing !== undefined) {
-      return existing.outcome === "conflict" ? existing : { ...existing, outcome: "adopted" };
+      return existing.outcome === "accepted" || existing.outcome === "adopted"
+        ? { ...existing, outcome: "adopted" }
+        : existing;
+    }
+    const idempotent = this.state.connection
+      .prepare(
+        `SELECT request_id AS requestId, request_fingerprint AS clientRequestFingerprint,
+                outcome, accepted_revision AS revision, receipt_hash AS receiptHash,
+                error_hash AS errorHash
+         FROM host_commands WHERE client_id = ? AND idempotency_key = ?`,
+      )
+      .get(request.clientId, request.idempotencyKey);
+    if (!isIdempotentCommandRow(idempotent)) return undefined;
+    if (!idempotent.clientRequestFingerprint.equals(clientRequestFingerprint(request))) {
+      return conflictResponse(request.requestId, "Idempotency key was reused with another payload");
     }
+    const adopted = this.commandResponse(idempotent.requestId, idempotent);
+    return {
+      ...adopted,
+      requestId: request.requestId,
+      ...(adopted.outcome === "accepted" || adopted.outcome === "adopted"
+        ? { outcome: "adopted" as const }
+        : {}),
+    };
+  }
+
+  executeCommand(
+    request: ClientRequest,
+    hostEpoch: number,
+    operation: () => Omit<ClientResponse, "schema" | "type" | "requestId">,
+  ): ClientResponse {
+    const existing = this.adoptCommand(request);
+    if (existing !== undefined) return existing;
     return this.state.transaction(() => {
-      const idempotent = this.state.connection
-        .prepare(
-          `SELECT request_id AS requestId, request_fingerprint AS requestFingerprint,
-                  outcome, accepted_revision AS revision, receipt_hash AS receiptHash,
-                  error_hash AS errorHash
-           FROM host_commands WHERE client_id = ? AND idempotency_key = ?`,
-        )
-        .get(request.clientId, request.idempotencyKey);
-      if (isIdempotentCommandRow(idempotent)) {
-        if (!idempotent.requestFingerprint.equals(requestFingerprint(request))) {
-          return conflictResponse(
-            request.requestId,
-            "Idempotency key was reused with another payload",
-          );
-        }
-        const adopted = this.commandResponse(idempotent.requestId, idempotent);
-        return { ...adopted, requestId: request.requestId, outcome: "adopted" };
-      }
+      const idempotent = this.adoptCommand(request);
+      if (idempotent !== undefined) return idempotent;
 
       const result = operation();
-      const response: HostResponse = {
-        schema: "pi-workflows.host-response.v1",
+      const response: ClientResponse = {
+        schema: CLIENT_PROTOCOL_SCHEMA,
+        type: "response",
         requestId: request.requestId,
         ...result,
       };
@@ -269,7 +294,7 @@ export class HostStateStore {
           request.clientId,
           request.operation,
           request.idempotencyKey,
-          requestFingerprint(request),
+          clientRequestFingerprint(request),
           request.runId ?? null,
           response.revision ?? null,
           response.outcome,
@@ -352,13 +377,13 @@ export class HostStateStore {
   readWorkerMessage(message: WorkerMessage): WorkerResponse | undefined {
     const row = this.state.connection
       .prepare(
-        `SELECT request_fingerprint AS requestFingerprint, outcome,
+        `SELECT request_fingerprint AS clientRequestFingerprint, outcome,
                 accepted_revision AS revision, result_hash AS resultHash, error_hash AS errorHash
          FROM worker_messages WHERE worker_epoch = ? AND message_id = ?`,
       )
       .get(message.workerEpoch, message.messageId);
     if (!isWorkerMessageRow(row)) return undefined;
-    if (!row.requestFingerprint.equals(workerMessageFingerprint(message))) {
+    if (!row.clientRequestFingerprint.equals(workerMessageFingerprint(message))) {
       return {
         schema: "pi-workflows.worker-response.v1",
         messageId: message.messageId,
@@ -422,15 +447,16 @@ export class HostStateStore {
           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);
@@ -451,10 +477,213 @@ export class HostStateStore {
           now,
           now,
         );
-      return this.requireInteractiveRequest(options.requestId);
+      const created = this.requireInteractiveRequest(options.requestId);
+      this.ensureInteractionMessage(created, "initial", now);
+      return created;
+    });
+  }
+
+  ensureInteractionMessage(
+    request: InteractiveRequestRecord,
+    reason: WorkflowStepReason,
+    now: number = 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: string, now: number = Date.now()): InteractiveRequestRecord {
+    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: string, now: number = Date.now()): void {
+    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: string): number | undefined {
+    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: string,
+    pausedAt: number | undefined,
+    now: number = Date.now(),
+  ): void {
+    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: string, now: number = Date.now()): void {
+    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: number | undefined,
+    now: number = Date.now(),
+  ): void {
+    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: string, now: number = Date.now()): void {
+    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: string): InteractiveRequestRecord | undefined {
     return this.interactiveRequest(requestId);
   }
@@ -505,7 +734,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`,
       )
@@ -527,7 +756,7 @@ 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`,
@@ -536,21 +765,27 @@ export class HostStateStore {
       .flatMap((row) => (isRunIdRow(row) ? [row.runId] : []));
   }
 
-  expiredInteractionRunIds(now: number = Date.now()): string[] {
+  expiredInteractionRuns(now: number = Date.now()): ExpiredInteractionRunRow[] {
     return this.state.connection
       .prepare(
-        `SELECT i.run_id AS runId
+        `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: string): TimedOutInteractionRow | undefined {
@@ -561,8 +796,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());
@@ -624,13 +864,14 @@ export class HostStateStore {
         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) throw new Error("Interactive submission result is missing");
@@ -653,7 +894,7 @@ export class HostStateStore {
     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)
@@ -662,60 +903,17 @@ export class HostStateStore {
       );
   }
 
-  claimInteractionPresentation(options: {
-    requestId: string;
-    expectedRevision: number;
-    presenterId: string;
-    leaseMs: number;
-  }): InteractiveRequestRecord {
-    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: {
-    requestId: string;
-    expectedRevision: number;
-    sessionEntryId: string;
-  }): InteractiveRequestRecord {
-    const now = Date.now();
-    const changed = this.state.connection
+  listPendingDecisionInteractions(): InteractiveRequestRecord[] {
+    return 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 = ?)`,
+        `SELECT request_id AS requestId FROM interactive_requests
+         WHERE kind = 'decision' AND status = 'pending'
+         ORDER BY created_at, request_id`,
       )
-      .run(
-        options.sessionEntryId,
-        now,
-        options.requestId,
-        options.expectedRevision,
-        options.sessionEntryId,
+      .all()
+      .flatMap((row) =>
+        isRequestIdRow(row) ? [this.requireInteractiveRequest(row.requestId)] : [],
       );
-    if (changed.changes !== 1) throw new Error("Interactive request presentation conflict");
-    return this.requireInteractiveRequest(options.requestId);
   }
 
   submitInteraction(options: {
@@ -728,6 +926,7 @@ export class HostStateStore {
     receipt?: JsonValue;
   }): {
     interaction: InteractiveRequestRecord;
+    submissionId: string;
     outcome: "accepted" | "adopted";
     receipt: JsonValue;
   } {
@@ -747,6 +946,7 @@ export class HostStateStore {
     receipt?: JsonValue;
   }): {
     interaction: InteractiveRequestRecord;
+    submissionId: string;
     outcome: "accepted" | "adopted";
     receipt: JsonValue;
   } {
@@ -768,6 +968,7 @@ export class HostStateStore {
     receipt?: JsonValue;
   }): {
     interaction: InteractiveRequestRecord;
+    submissionId: string;
     outcome: "accepted" | "adopted";
     receipt: JsonValue;
   } {
@@ -787,6 +988,7 @@ export class HostStateStore {
         }
         return {
           interaction: this.requireInteractiveRequest(options.requestId),
+          submissionId: existing.submissionId,
           outcome: "adopted",
           receipt:
             existing.receiptHash === null
@@ -806,10 +1008,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);
@@ -836,15 +1035,17 @@ export class HostStateStore {
         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),
+        submissionId: options.submissionId,
         outcome: "accepted",
         receipt: options.receipt ?? {
           requestId: options.requestId,
@@ -867,14 +1068,15 @@ export class HostStateStore {
     return row;
   }
 
-  private commandResponse(requestId: string, row: CommandRow): HostResponse {
+  private commandResponse(requestId: string, row: CommandRow): ClientResponse {
     const receipt = row.receiptHash === null ? undefined : this.state.readJson(row.receiptHash);
     const error =
       row.errorHash === null
         ? undefined
         : this.state.readBlob(row.errorHash)?.content.toString("utf8");
     return {
-      schema: "pi-workflows.host-response.v1",
+      schema: CLIENT_PROTOCOL_SCHEMA,
+      type: "response",
       requestId,
       outcome: row.outcome,
       ...(row.revision === null ? {} : { revision: row.revision }),
@@ -888,9 +1090,7 @@ export class HostStateStore {
       .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 = ?`,
@@ -906,9 +1106,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(),
@@ -917,6 +1115,23 @@ export class HostStateStore {
     };
   }
 
+  private shiftInteractionTimeout(
+    row: Pick<InteractionTimeoutRow, "attemptId" | "startedAt" | "deadlineAt">,
+    idleMs: number,
+    now: number,
+  ): void {
+    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");
+  }
+
   private requireInteractiveRequest(requestId: string): InteractiveRequestRecord {
     const request = this.interactiveRequest(requestId);
     if (request === undefined) throw new Error(`Interactive request not found: ${requestId}`);
@@ -924,8 +1139,14 @@ export class HostStateStore {
   }
 }
 
-function conflictResponse(requestId: string, error: string): HostResponse {
-  return { schema: "pi-workflows.host-response.v1", requestId, outcome: "conflict", error };
+function conflictResponse(requestId: string, error: string): ClientResponse {
+  return {
+    schema: CLIENT_PROTOCOL_SCHEMA,
+    type: "response",
+    requestId,
+    outcome: "conflict",
+    error,
+  };
 }
 
 function requireLeaseMs(value: number): void {
@@ -949,8 +1170,8 @@ type HostRow = {
 };
 
 type CommandRow = {
-  requestFingerprint: Buffer;
-  outcome: HostResponse["outcome"];
+  clientRequestFingerprint: Buffer;
+  outcome: ClientResponse["outcome"];
   revision: number | null;
   receiptHash: Buffer | null;
   errorHash: Buffer | null;
@@ -976,7 +1197,7 @@ type SubmissionDetailRow = {
   submittedAt: number;
 };
 type WorkerMessageRow = {
-  requestFingerprint: Buffer;
+  clientRequestFingerprint: Buffer;
   outcome: WorkerResponse["outcome"];
   revision: number | null;
   resultHash: Buffer | null;
@@ -994,6 +1215,23 @@ type TimedOutInteractionRow = {
   attemptId: string;
   nodeId: string;
 };
+type InteractionTimeoutRow = {
+  attemptId: string;
+  createdAt: number;
+  startedAt: number | null;
+  deadlineAt: number | null;
+  previousTurnEndedAt: number | null;
+};
+type InactiveInteractionTimeoutRow = {
+  attemptId: string;
+  status: "pending" | "running" | "waiting" | "interrupted";
+  startedAt: number | null;
+  deadlineAt: number | null;
+  updatedAt: number;
+  turnStartedAt: number;
+};
+type ExpiredInteractionRunRow = { runId: string; targetSessionId: string };
+type PausedAtRow = { pausedAt: number };
 type InteractiveRequestRow = {
   requestId: string;
   runId: string;
@@ -1003,9 +1241,7 @@ type InteractiveRequestRow = {
   contractHash: Buffer;
   revision: number;
   status: InteractiveRequestRecord["status"];
-  presenterId: string | null;
-  presentationClaimExpiresAt: number | null;
-  presentationSessionEntryId: string | null;
+  unproductiveTurnEnds: number;
   acceptedSubmissionId: string | null;
   createdAt: number;
   updatedAt: number;
@@ -1030,7 +1266,7 @@ function isHostRow(value: unknown): value is HostRow {
 function isCommandRow(value: unknown): value is CommandRow {
   return (
     isRecord(value) &&
-    Buffer.isBuffer(value.requestFingerprint) &&
+    Buffer.isBuffer(value.clientRequestFingerprint) &&
     typeof value.outcome === "string" &&
     nullableNumber(value.revision) &&
     (value.receiptHash === null || Buffer.isBuffer(value.receiptHash)) &&
@@ -1057,7 +1293,7 @@ function isRunIdRow(value: unknown): value is RunIdRow {
 function isWorkerMessageRow(value: unknown): value is WorkerMessageRow {
   return (
     isRecord(value) &&
-    Buffer.isBuffer(value.requestFingerprint) &&
+    Buffer.isBuffer(value.clientRequestFingerprint) &&
     ["accepted", "adopted", "rejected", "claimLost"].includes(value.outcome as string) &&
     nullableNumber(value.revision) &&
     (value.resultHash === null || Buffer.isBuffer(value.resultHash)) &&
@@ -1085,6 +1321,39 @@ function isTimedOutInteractionRow(value: unknown): value is TimedOutInteractionR
   );
 }
 
+function isInteractionTimeoutRow(value: unknown): value is InteractionTimeoutRow {
+  return (
+    isRecord(value) &&
+    typeof value.attemptId === "string" &&
+    typeof value.createdAt === "number" &&
+    nullableNumber(value.startedAt) &&
+    nullableNumber(value.deadlineAt) &&
+    nullableNumber(value.previousTurnEndedAt)
+  );
+}
+
+function isInactiveInteractionTimeoutRow(value: unknown): value is InactiveInteractionTimeoutRow {
+  return (
+    isRecord(value) &&
+    typeof value.attemptId === "string" &&
+    ["pending", "running", "waiting", "interrupted"].includes(value.status as string) &&
+    nullableNumber(value.startedAt) &&
+    nullableNumber(value.deadlineAt) &&
+    typeof value.updatedAt === "number" &&
+    typeof value.turnStartedAt === "number"
+  );
+}
+
+function isExpiredInteractionRunRow(value: unknown): value is ExpiredInteractionRunRow {
+  return (
+    isRecord(value) && typeof value.runId === "string" && typeof value.targetSessionId === "string"
+  );
+}
+
+function isPausedAtRow(value: unknown): value is PausedAtRow {
+  return isRecord(value) && typeof value.pausedAt === "number";
+}
+
 function isSubmissionRow(value: unknown): value is SubmissionRow {
   return (
     isRecord(value) &&
@@ -1122,10 +1391,8 @@ function isInteractiveRequestRow(value: unknown): value is InteractiveRequestRow
     ["agent", "assistant", "decision"].includes(value.kind as string) &&
     Buffer.isBuffer(value.contractHash) &&
     typeof value.revision === "number" &&
-    ["pending", "presenting", "settled", "cancelled"].includes(value.status as string) &&
-    nullableString(value.presenterId) &&
-    nullableNumber(value.presentationClaimExpiresAt) &&
-    nullableString(value.presentationSessionEntryId) &&
+    ["pending", "settled", "cancelled"].includes(value.status as string) &&
+    typeof value.unproductiveTurnEnds === "number" &&
     nullableString(value.acceptedSubmissionId) &&
     typeof value.createdAt === "number" &&
     typeof value.updatedAt === "number" &&