@osolmaz/pi-workflows 0.16.0 → 0.16.1

package/src/host/state.ts

@@ -8,6 +8,15 @@ import {
 import { StateDatabase } from "../state/database.js";
 import { canonicalJson, type JsonValue } from "../state/json.js";
 import { tokenHash } from "../state/mutation.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 = {
@@ -68,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;
@@ -82,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;
@@ -91,6 +99,7 @@ export class HostStateStore {
         filePath: databasePath,
         mode: options.readOnly === true ? "read-only" : "read-write",
       });
+    this.workflowMessages = new WorkflowMessageStore(this.state);
   }
 
   close(): void {
@@ -438,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);
@@ -467,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);
   }
@@ -521,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`,
       )
@@ -543,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`,
@@ -552,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 {
@@ -577,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());
@@ -640,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");
@@ -669,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)
@@ -678,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: {
@@ -826,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);
@@ -856,12 +1035,13 @@ 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),
@@ -910,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 = ?`,
@@ -928,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(),
@@ -939,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}`);
@@ -1022,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;
@@ -1031,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;
@@ -1113,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) &&
@@ -1150,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" &&