@osolmaz/pi-workflows 0.16.4 → 0.16.6

package/src/server/state.ts

@@ -5,6 +5,7 @@ import {
   type ClientRequest,
   type ClientResponse,
 } from "../client/protocol.js";
+import { AttemptTime, type AttemptClock } from "../state/attempt-time.js";
 import { StateDatabase } from "../state/database.js";
 import { canonicalJson, type JsonValue } from "../state/json.js";
 import { tokenHash } from "../state/mutation.js";
@@ -13,8 +14,15 @@ import {
   workflowMessageIdFor,
   type WorkflowStepReason,
 } from "../state/workflow-messages.js";
+import {
+  ensureWorkflowRequest,
+  readWorkflowRequest,
+  recordWorkflowSubmission,
+  type InteractiveRequestRecord,
+} from "../workflows/requests.js";
 import {
   decisionWorkflowMessageContent,
+  checkpointWorkflowMessageContent,
   stepWorkflowMessageContent,
 } from "../workflows/workflow-message-content.js";
 import type { WorkflowRunnerMessage, WorkflowRunnerResponse } from "./workflow-runner-protocol.js";
@@ -69,29 +77,16 @@ export type InteractiveSubmissionRecord = {
   submittedAt: string;
 };
 
-export type InteractiveRequestRecord = {
-  requestId: string;
-  runId: string;
-  attemptId: string;
-  targetSessionId: string;
-  kind: "agent" | "assistant" | "decision";
-  contract: JsonValue;
-  revision: number;
-  status: "pending" | "settled" | "cancelled";
-  unproductiveTurnEnds: number;
-  acceptedSubmissionId: string | null;
-  createdAt: string;
-  updatedAt: string;
-  settledAt: string | null;
-  consumedAt: string | null;
-};
-
 export class ServerStateStore {
   readonly state: StateDatabase;
   private readonly ownsState: boolean;
   readonly workflowMessages: WorkflowMessageStore;
+  private readonly attemptTime: AttemptTime;
 
-  constructor(databasePath: string, options: { state?: StateDatabase; readOnly?: boolean } = {}) {
+  constructor(
+    databasePath: string,
+    options: { state?: StateDatabase; readOnly?: boolean; clock?: AttemptClock } = {},
+  ) {
     this.ownsState = options.state === undefined;
     this.state =
       options.state ??
@@ -100,6 +95,7 @@ export class ServerStateStore {
         mode: options.readOnly === true ? "read-only" : "read-write",
       });
     this.workflowMessages = new WorkflowMessageStore(this.state);
+    this.attemptTime = new AttemptTime(this.state, options.clock);
   }
 
   close(): void {
@@ -443,54 +439,10 @@ export class ServerStateStore {
     kind: InteractiveRequestRecord["kind"];
     contract: JsonValue;
   }): InteractiveRequestRecord {
-    const now = Date.now();
     return this.state.transaction(() => {
-      const existing = this.interactiveRequest(options.requestId);
-      if (existing !== undefined) {
-        if (
-          existing.runId !== options.runId ||
-          existing.attemptId !== options.attemptId ||
-          canonicalJson(existing.contract) !== canonicalJson(options.contract)
-        ) {
-          throw new Error(`Interactive request conflicts: ${options.requestId}`);
-        }
-        if (existing.status === "settled" && existing.consumedAt === null) {
-          this.state.connection
-            .prepare(
-              `UPDATE interactive_requests
-               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);
-          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);
-      this.state.connection
-        .prepare(
-          `INSERT INTO interactive_requests(
-             request_id, run_id, attempt_id, target_session_id, kind, contract_hash,
-             revision, status, created_at, updated_at
-           ) VALUES (?, ?, ?, ?, ?, ?, 1, 'pending', ?, ?)`,
-        )
-        .run(
-          options.requestId,
-          options.runId,
-          options.attemptId,
-          options.targetSessionId,
-          options.kind,
-          contractHash,
-          now,
-          now,
-        );
-      const created = this.requireInteractiveRequest(options.requestId);
-      this.ensureInteractionMessage(created, "initial", now);
-      return created;
+      const request = ensureWorkflowRequest(this.state, options);
+      if (request.status === "pending") this.ensureInteractionMessage(request, "initial");
+      return request;
     });
   }
 
@@ -499,12 +451,14 @@ export class ServerStateStore {
     reason: WorkflowStepReason,
     now: number = Date.now(),
   ) {
-    const kind = request.kind === "decision" ? "decision" : "step";
+    const kind = request.kind === "decision" || request.kind === "checkpoint" ? "decision" : "step";
     const idempotencyKey = `${request.revision}:${reason}`;
     const workflowMessageId = workflowMessageIdFor(kind, request.requestId, idempotencyKey);
     const content =
       kind === "decision"
-        ? decisionWorkflowMessageContent({
+        ? (request.kind === "checkpoint"
+            ? checkpointWorkflowMessageContent
+            : decisionWorkflowMessageContent)({
             workflowMessageId,
             requestId: request.requestId,
             runId: request.runId,
@@ -538,7 +492,7 @@ export class ServerStateStore {
         .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;
+      if (current.kind === "decision" || current.kind === "checkpoint") return current;
       this.workflowMessages.cancelPendingForSource(current.requestId, "step", now);
       const changed = this.state.connection
         .prepare(
@@ -553,144 +507,92 @@ export class ServerStateStore {
     });
   }
 
-  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,
-    );
+  syncActiveTime(): void {
+    this.attemptTime.sample();
   }
 
-  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;
+  beginInteractionModelTurn(requestId: string): void {
+    const request = this.requireInteractiveRequest(requestId);
+    if (request.status !== "pending" || !["agent", "assistant"].includes(request.kind)) {
+      throw new Error("Only a pending agent request can start active model time");
+    }
+    const run = this.state.connection
+      .prepare("SELECT paused FROM runs WHERE run_id = ?")
+      .get(request.runId) as { paused: number };
+    if (run.paused !== 0) throw new Error("Paused workflow cannot start active model time");
+    this.attemptTime.start(request.attemptId);
   }
 
-  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);
+  endInteractionModelTurn(requestId: string): void {
+    this.attemptTime.stop(this.requireInteractiveRequest(requestId).attemptId);
   }
 
-  markSessionModelTurnsInactive(targetSessionId: string, now: number = Date.now()): void {
-    this.state.connection
+  resumeInteractionModelTurn(runId: string): void {
+    const rows = 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'
-         )`,
+        `SELECT DISTINCT i.attempt_id AS attemptId FROM interactive_requests i
+       JOIN runs r ON r.run_id = i.run_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.run_id = ? AND i.status = 'pending' AND r.paused = 0`,
       )
-      .run(now, targetSessionId);
+      .all(runId) as { attemptId: string }[];
+    for (const row of rows) {
+      this.attemptTime.start(row.attemptId);
+      this.state.connection
+        .prepare("UPDATE node_attempts SET status = 'waiting' WHERE attempt_id = ?")
+        .run(row.attemptId);
+    }
   }
 
-  recoverInactiveModelTurns(
-    previousHeartbeatAt: number | undefined,
-    now: number = Date.now(),
-  ): void {
+  markSessionModelTurnsInactive(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.status = 'pending'
-         GROUP BY i.attempt_id`,
+        `SELECT DISTINCT i.attempt_id AS attemptId 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'`,
       )
-      .all()
-      .filter(isInactiveInteractionTimeoutRow);
+      .all(targetSessionId) as { attemptId: string }[];
     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.attemptTime.stop(row.attemptId);
       this.state.connection
         .prepare(
-          `UPDATE node_attempts SET status = 'interrupted', updated_at = ?
-           WHERE attempt_id = ? AND status IN ('pending', 'running', 'waiting', 'interrupted')`,
+          "UPDATE node_attempts SET status = 'interrupted', updated_at = ? WHERE attempt_id = ?",
         )
         .run(now, row.attemptId);
     }
   }
 
+  recoverInactiveModelTurns(now: number = Date.now()): void {
+    this.attemptTime.recover();
+    this.state.connection
+      .prepare(
+        `UPDATE node_attempts SET status = 'interrupted', updated_at = ? WHERE attempt_id IN (
+         SELECT 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.status = 'pending'
+       )`,
+      )
+      .run(now);
+  }
+
   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`,
+        `SELECT DISTINCT i.attempt_id AS attemptId FROM interactive_requests i
+       JOIN runs r ON r.run_id = i.run_id
+       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 r.paused = 0 AND a.status = 'interrupted'`,
       )
-      .all(targetSessionId)
-      .filter(isInactiveInteractionTimeoutRow);
+      .all(targetSessionId) as { attemptId: string }[];
     for (const row of rows) {
-      this.shiftInteractionTimeout(row, Math.max(0, now - row.updatedAt), now);
+      this.attemptTime.start(row.attemptId);
       this.state.connection
-        .prepare(
-          `UPDATE node_attempts SET status = 'waiting', updated_at = ?
-           WHERE attempt_id = ? AND status = 'interrupted'`,
-        )
+        .prepare("UPDATE node_attempts SET status = 'waiting', updated_at = ? WHERE attempt_id = ?")
         .run(now, row.attemptId);
     }
   }
@@ -760,14 +662,18 @@ export class ServerStateStore {
     };
   }
 
-  validatingInteractionRunIds(): string[] {
+  readyInteractionRunIds(): string[] {
     return this.state.connection
       .prepare(
         `SELECT i.run_id AS runId
          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 = 'pending' AND s.outcome = 'validating'
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         WHERE ((i.status = 'pending' AND s.outcome = 'validating')
+             OR (i.status = 'settled' AND i.accepted_submission_id = s.submission_id
+                 AND s.outcome = 'accepted' AND i.consumed_at IS NULL))
+           AND a.status IN ('pending', 'running', 'waiting', 'interrupted')
            AND q.status NOT IN ('done', 'failed', 'cancelled')
          GROUP BY i.run_id
          ORDER BY MIN(s.submitted_at), i.run_id`,
@@ -776,26 +682,21 @@ export class ServerStateStore {
       .flatMap((row) => (isRunIdRow(row) ? [row.runId] : []));
   }
 
-  expiredInteractionRuns(now: number = Date.now()): ExpiredInteractionRunRow[] {
+  expiredInteractionRuns(): ExpiredInteractionRunRow[] {
     return this.state.connection
       .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 = 'pending' AND r.paused = 0
-           AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
-           AND q.status NOT IN ('done', 'failed', 'cancelled')
-           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`,
+       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 = 'pending' AND r.paused = 0 AND a.timeout_ms > 0
+         AND (SELECT COALESCE(SUM(elapsed_ms), 0) FROM attempt_active_intervals t
+              WHERE t.attempt_id = a.attempt_id) >= a.timeout_ms
+         AND q.status NOT IN ('done', 'failed', 'cancelled')
+       GROUP BY i.run_id, i.target_session_id ORDER BY MIN(a.started_at), i.run_id`,
       )
-      .all(now)
+      .all()
       .filter(isExpiredInteractionRunRow);
   }
 
@@ -803,20 +704,17 @@ export class ServerStateStore {
     const row = this.state.connection
       .prepare(
         `SELECT i.request_id AS requestId, i.attempt_id AS attemptId, a.node_id AS nodeId
-         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
-         WHERE i.run_id = ? AND i.status = 'cancelled' AND r.status = 'running'
-           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`,
+       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
+       WHERE i.run_id = ? AND i.status = 'cancelled' AND r.status = 'running'
+         AND r.paused = 0 AND a.timeout_ms > 0
+         AND (SELECT COALESCE(SUM(elapsed_ms), 0) FROM attempt_active_intervals t
+              WHERE t.attempt_id = a.attempt_id) >= a.timeout_ms
+         AND a.status IN ('pending', 'running', 'waiting', 'interrupted', 'timed_out')
+       ORDER BY a.started_at, i.request_id LIMIT 1`,
       )
-      .get(runId, Date.now());
+      .get(runId);
     return isTimedOutInteractionRow(row) ? row : undefined;
   }
 
@@ -890,17 +788,6 @@ export class ServerStateStore {
     });
   }
 
-  consumeAcceptedInteraction(runId: string, attemptId: string, now: number = Date.now()): boolean {
-    const changed = this.state.connection
-      .prepare(
-        `UPDATE interactive_requests SET consumed_at = ?, updated_at = ?
-         WHERE run_id = ? AND attempt_id = ? AND status = 'settled'
-           AND accepted_submission_id IS NOT NULL AND consumed_at IS NULL`,
-      )
-      .run(now, now, runId, attemptId);
-    return changed.changes === 1;
-  }
-
   listPendingInteractions(sessionId: string): InteractiveRequestRecord[] {
     return this.state.connection
       .prepare(
@@ -941,13 +828,23 @@ export class ServerStateStore {
     outcome: "accepted" | "adopted";
     receipt: JsonValue;
   } {
-    return this.recordInteractionSubmission({
+    return recordWorkflowSubmission(this.state, {
       ...options,
       outcome: options.accepted ? "accepted" : "rejected",
       settle: options.accepted,
     });
   }
 
+  hasInteractionSubmission(requestId: string, idempotencyKey: string): boolean {
+    return (
+      this.state.connection
+        .prepare(
+          "SELECT 1 FROM interactive_submissions WHERE request_id = ? AND idempotency_key = ?",
+        )
+        .get(requestId, idempotencyKey) !== undefined
+    );
+  }
+
   beginInteractionValidation(options: {
     requestId: string;
     submissionId: string;
@@ -961,111 +858,13 @@ export class ServerStateStore {
     outcome: "accepted" | "adopted";
     receipt: JsonValue;
   } {
-    return this.recordInteractionSubmission({
+    return recordWorkflowSubmission(this.state, {
       ...options,
       outcome: "validating",
       settle: false,
     });
   }
 
-  private recordInteractionSubmission(options: {
-    requestId: string;
-    submissionId: string;
-    idempotencyKey: string;
-    expectedRevision: number;
-    payload: JsonValue;
-    outcome: InteractiveSubmissionRecord["outcome"];
-    settle: boolean;
-    receipt?: JsonValue;
-  }): {
-    interaction: InteractiveRequestRecord;
-    submissionId: string;
-    outcome: "accepted" | "adopted";
-    receipt: JsonValue;
-  } {
-    const now = Date.now();
-    return this.state.transaction(() => {
-      const existing = this.state.connection
-        .prepare(
-          `SELECT submission_id AS submissionId, payload_hash AS payloadHash,
-                  outcome, receipt_hash AS receiptHash
-           FROM interactive_submissions WHERE request_id = ? AND idempotency_key = ?`,
-        )
-        .get(options.requestId, options.idempotencyKey);
-      const payloadHash = createHash("sha256").update(canonicalJson(options.payload)).digest();
-      if (isSubmissionRow(existing)) {
-        if (!existing.payloadHash.equals(payloadHash)) {
-          throw new Error("Interactive submission idempotency key conflicts");
-        }
-        return {
-          interaction: this.requireInteractiveRequest(options.requestId),
-          submissionId: existing.submissionId,
-          outcome: "adopted",
-          receipt:
-            existing.receiptHash === null
-              ? { requestId: options.requestId, submissionId: existing.submissionId }
-              : this.state.readJson(existing.receiptHash),
-        };
-      }
-      if (options.outcome === "validating") {
-        const active = this.state.connection
-          .prepare(
-            `SELECT submission_id AS submissionId FROM interactive_submissions
-             WHERE request_id = ? AND outcome = 'validating' LIMIT 1`,
-          )
-          .get(options.requestId);
-        if (isSubmissionIdRow(active)) {
-          throw new Error("Interactive submission validation is already active");
-        }
-      }
-      const request = this.requireInteractiveRequest(options.requestId);
-      if (request.revision !== options.expectedRevision || request.status !== "pending") {
-        throw new Error("Interactive request revision conflict");
-      }
-      const savedPayloadHash = this.state.putJson(options.payload, now);
-      const receiptHash =
-        options.receipt === undefined ? null : this.state.putJson(options.receipt, now);
-      this.state.connection
-        .prepare(
-          `INSERT INTO interactive_submissions(
-             submission_id, request_id, idempotency_key, request_revision,
-             payload_hash, outcome, receipt_hash, submitted_at
-           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-        )
-        .run(
-          options.submissionId,
-          options.requestId,
-          options.idempotencyKey,
-          options.expectedRevision,
-          savedPayloadHash,
-          options.outcome,
-          receiptHash,
-          now,
-        );
-      if (options.settle) {
-        this.state.connection
-          .prepare(
-            `UPDATE interactive_requests
-             SET status = 'settled', accepted_submission_id = ?, revision = revision + 1,
-                 updated_at = ?, settled_at = ?
-             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,
-          submissionId: options.submissionId,
-        },
-      };
-    });
-  }
-
   private serverRow(): ServerRow {
     const row = this.state.connection
       .prepare(
@@ -1097,50 +896,7 @@ export class ServerStateStore {
   }
 
   private interactiveRequest(requestId: string): InteractiveRequestRecord | undefined {
-    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, 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 = ?`,
-      )
-      .get(requestId);
-    if (!isInteractiveRequestRow(row)) return undefined;
-    return {
-      requestId: row.requestId,
-      runId: row.runId,
-      attemptId: row.attemptId,
-      targetSessionId: row.targetSessionId,
-      kind: row.kind,
-      contract: this.state.readJson(row.contractHash),
-      revision: row.revision,
-      status: row.status,
-      unproductiveTurnEnds: row.unproductiveTurnEnds,
-      acceptedSubmissionId: row.acceptedSubmissionId,
-      createdAt: new Date(row.createdAt).toISOString(),
-      updatedAt: new Date(row.updatedAt).toISOString(),
-      settledAt: iso(row.settledAt),
-      consumedAt: iso(row.consumedAt),
-    };
-  }
-
-  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");
+    return readWorkflowRequest(this.state, requestId);
   }
 
   private requireInteractiveRequest(requestId: string): InteractiveRequestRecord {
@@ -1191,13 +947,6 @@ type CommandRow = {
 type IdempotentCommandRow = CommandRow & { requestId: string };
 type RequestIdRow = { requestId: string };
 type RunIdRow = { runId: string };
-type SubmissionRow = {
-  submissionId: string;
-  payloadHash: Buffer;
-  outcome: string;
-  receiptHash: Buffer | null;
-};
-type SubmissionIdRow = { submissionId: string };
 type SubmissionDetailRow = {
   requestId: string;
   submissionId: string;
@@ -1221,44 +970,12 @@ type AcceptedInteractionRow = {
   submissionId: string;
   payloadHash: Buffer;
 };
+type ExpiredInteractionRunRow = { runId: string; targetSessionId: string };
 type TimedOutInteractionRow = {
   requestId: string;
   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;
-  attemptId: string;
-  targetSessionId: string;
-  kind: InteractiveRequestRecord["kind"];
-  contractHash: Buffer;
-  revision: number;
-  status: InteractiveRequestRecord["status"];
-  unproductiveTurnEnds: number;
-  acceptedSubmissionId: string | null;
-  createdAt: number;
-  updatedAt: number;
-  settledAt: number | null;
-  consumedAt: number | null;
-};
 
 function isServerRow(value: unknown): value is ServerRow {
   return (
@@ -1332,53 +1049,12 @@ 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) &&
-    typeof value.submissionId === "string" &&
-    Buffer.isBuffer(value.payloadHash) &&
-    typeof value.outcome === "string" &&
-    (value.receiptHash === null || Buffer.isBuffer(value.receiptHash))
-  );
-}
-
-function isSubmissionIdRow(value: unknown): value is SubmissionIdRow {
-  return isRecord(value) && typeof value.submissionId === "string";
-}
-
 function isSubmissionDetailRow(value: unknown): value is SubmissionDetailRow {
   return (
     isRecord(value) &&
@@ -1392,26 +1068,6 @@ function isSubmissionDetailRow(value: unknown): value is SubmissionDetailRow {
   );
 }
 
-function isInteractiveRequestRow(value: unknown): value is InteractiveRequestRow {
-  return (
-    isRecord(value) &&
-    typeof value.requestId === "string" &&
-    typeof value.runId === "string" &&
-    typeof value.attemptId === "string" &&
-    typeof value.targetSessionId === "string" &&
-    ["agent", "assistant", "decision"].includes(value.kind as string) &&
-    Buffer.isBuffer(value.contractHash) &&
-    typeof value.revision === "number" &&
-    ["pending", "settled", "cancelled"].includes(value.status as string) &&
-    typeof value.unproductiveTurnEnds === "number" &&
-    nullableString(value.acceptedSubmissionId) &&
-    typeof value.createdAt === "number" &&
-    typeof value.updatedAt === "number" &&
-    nullableNumber(value.settledAt) &&
-    nullableNumber(value.consumedAt)
-  );
-}
-
 function runnerMessageFingerprint(message: WorkflowRunnerMessage): Buffer {
   return createHash("sha256").update(canonicalJson(message)).digest();
 }