@osolmaz/pi-workflows 0.16.5 → 0.16.7

package/src/server/view.ts

@@ -10,14 +10,14 @@ import {
   type WorkflowRunView,
   type WorkflowSessionView,
 } from "../client/view.js";
-import type {
-  SqliteResourceManagerStore,
-  WorkflowRunQueueRecord,
-  WorkflowRunQueueViewRecord,
-} from "../resource-managers/sqlite.js";
 import type { StateDatabase } from "../state/database.js";
 import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
 import { WorkflowMessageStore, type WorkflowMessage } from "../state/workflow-messages.js";
+import type {
+  WorkflowRunQueueStore,
+  WorkflowRunQueueRecord,
+  WorkflowRunQueueViewRecord,
+} from "../workflows/queue.js";
 import type { WorkflowRunDisplayState, WorkflowRunStore } from "../workflows/store.js";
 import type {
   WorkflowRunState,
@@ -74,7 +74,7 @@ export class ServerViewStore {
 
   constructor(
     private readonly state: StateDatabase,
-    private readonly queue: SqliteResourceManagerStore,
+    private readonly queue: WorkflowRunQueueStore,
     private readonly serverState: ServerStateStore,
     private readonly runs: WorkflowRunStore,
     private readonly hasLiveRunner: (runId: string) => boolean,
@@ -274,6 +274,7 @@ export class ServerViewStore {
       schema: RUN_VIEW_SCHEMA,
       runId,
       revision,
+      runRevision: this.runs.runRevision(runId),
       display,
       manifest: manifest(queue, display.status),
       state: this.projectState(runId, loaded.state, stepPage.items, updatePage.items),
@@ -643,11 +644,7 @@ export class ServerViewStore {
       }
       if (message.status === "pending") return message.runId;
       if (message.status !== "sent") continue;
-      const turn = this.workflowMessages.latestTurnForMessage(message.workflowMessageId);
-      if (turn === undefined || turn.state === "started") return message.runId;
-      if (turn.endedAt !== null && Date.parse(turn.endedAt) + TERMINAL_VIEW_RETENTION_MS > now) {
-        return message.runId;
-      }
+      if (Date.parse(message.updatedAt) + TERMINAL_VIEW_RETENTION_MS > now) return message.runId;
     }
     return undefined;
   }
@@ -686,15 +683,15 @@ export class ServerViewStore {
     ) {
       return false;
     }
-    const leaf = this.terminalChainLeaf(source.runId);
-    if (leaf === undefined || leaf.status !== "completed") return false;
+    const run = this.state.connection
+      .prepare("SELECT status FROM runs WHERE run_id = ?")
+      .get(source.runId);
+    if (!isObjectRecord(run) || run.status !== "completed") return false;
     const terminal = this.workflowMessages
-      .listRun(leaf.runId)
+      .listRun(source.runId)
       .filter((candidate) => candidate.kind === "terminal" && candidate.status === "sent")
       .at(-1);
     if (terminal === undefined) return false;
-    const terminalTurn = this.workflowMessages.latestTurnForMessage(terminal.workflowMessageId);
-    if (terminalTurn?.state !== "ended") return false;
     const prior = this.state.connection
       .prepare(
         `SELECT follow_up_id AS followUpId, status FROM workflow_follow_ups
@@ -729,24 +726,6 @@ export class ServerViewStore {
     return reservation === undefined;
   }
 
-  private terminalChainLeaf(runId: string): { runId: string; status: string } | undefined {
-    const row = this.state.connection
-      .prepare(
-        `WITH RECURSIVE chain(run_id, status, depth, created_at) AS (
-           SELECT run_id, status, 0, created_at FROM runs WHERE run_id = ?
-           UNION ALL
-           SELECT child.run_id, child.status, chain.depth + 1, child.created_at
-           FROM runs child JOIN chain ON child.parent_run_id = chain.run_id
-         )
-         SELECT run_id AS runId, status FROM chain
-         ORDER BY depth DESC, created_at DESC LIMIT 1`,
-      )
-      .get(runId);
-    return isObjectRecord(row) && typeof row.runId === "string" && typeof row.status === "string"
-      ? { runId: row.runId, status: row.status }
-      : undefined;
-  }
-
   private openWorkflowMessage(messages: readonly WorkflowMessage[]): WorkflowMessage | undefined {
     for (const message of [...messages].reverse()) {
       if (message.status !== "sent") continue;
@@ -760,7 +739,7 @@ export class ServerViewStore {
         if (isObjectRecord(request) && request.status === "pending" && request.paused === 0) {
           return message;
         }
-      } else if (message.kind === "terminal" || message.kind === "followUp") {
+      } else if (message.kind === "followUp") {
         const turn = this.workflowMessages.latestTurnForMessage(message.workflowMessageId);
         if (turn === undefined || turn.state === "started") return message;
       }
@@ -794,7 +773,8 @@ export class ServerViewStore {
       ambiguous: this.hasAmbiguousEffect(queue.runId),
       runnerActive: this.hasLiveRunner(queue.runId),
       originTurnActive: this.hasActivity(queue.runId),
-      pendingInteraction: this.hasPendingInteraction(queue.runId),
+      pendingRequestKind: this.pendingRequestKind(queue.runId),
+      requestDeliveryConfirmed: this.requestDeliveryConfirmed(queue.runId),
       errorMessage: state?.error ?? queue.errorMessage,
     });
   }
@@ -805,7 +785,7 @@ export class ServerViewStore {
         `SELECT t.target_session_id AS targetSessionId FROM workflow_turns t
          JOIN workflow_messages m ON m.workflow_message_id = t.workflow_message_id
          WHERE t.run_id = ? AND t.state = 'started'
-           AND m.kind IN ('step', 'terminal', 'followUp') LIMIT 1`,
+           AND m.kind IN ('step', 'followUp') LIMIT 1`,
       )
       .get(runId);
     return (
@@ -815,14 +795,25 @@ export class ServerViewStore {
     );
   }
 
-  private hasPendingInteraction(runId: string): boolean {
+  private pendingRequestKind(runId: string): WorkflowDisplayFacts["pendingRequestKind"] {
+    const row = this.state.connection
+      .prepare("SELECT kind FROM interactive_requests WHERE run_id = ? AND status = 'pending'")
+      .get(runId) as
+      | { kind: Exclude<WorkflowDisplayFacts["pendingRequestKind"], null> }
+      | undefined;
+    return row?.kind ?? null;
+  }
+
+  private requestDeliveryConfirmed(runId: string): boolean {
     const row = this.state.connection
       .prepare(
-        `SELECT 1 AS present FROM interactive_requests
-         WHERE run_id = ? AND status = 'pending' LIMIT 1`,
+        `SELECT m.status FROM interactive_requests i
+       JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+       WHERE i.run_id = ? AND i.status = 'pending'
+       ORDER BY m.order_number DESC LIMIT 1`,
       )
-      .get(runId);
-    return row !== undefined;
+      .get(runId) as { status: string } | undefined;
+    return row?.status === "sent";
   }
 
   private hasAmbiguousEffect(runId: string): boolean {
@@ -857,7 +848,8 @@ export class ServerViewStore {
       this.workflowActivityRevision(),
       this.hasLiveRunner(runId),
       this.hasActivity(runId),
-      this.hasPendingInteraction(runId),
+      this.pendingRequestKind(runId),
+      this.requestDeliveryConfirmed(runId),
       this.hasAmbiguousEffect(runId),
     ].join(":");
   }
@@ -890,35 +882,54 @@ export type WorkflowDisplayFacts = {
   ambiguous: boolean;
   runnerActive: boolean;
   originTurnActive: boolean;
-  pendingInteraction: boolean;
+  pendingRequestKind: "agent" | "assistant" | "checkpoint" | "decision" | null;
+  requestDeliveryConfirmed: boolean;
   errorMessage: string | null;
 };
 
 export function reduceWorkflowDisplay(facts: WorkflowDisplayFacts): WorkflowDisplay {
   let status: WorkflowDisplayStatus;
-  let activity: WorkflowDisplay["activity"] = null;
+  const activity: WorkflowDisplay["activity"] = facts.runnerActive
+    ? "supervised_runner"
+    : facts.originTurnActive
+      ? "origin_turn"
+      : null;
   let reason: string | null = null;
 
-  if (facts.ambiguous) {
-    status = "ambiguous";
-    reason = "An external effect needs explicit recovery.";
-  } else if (facts.runnerActive || facts.originTurnActive) {
-    status = "running";
-    activity = facts.runnerActive ? "supervised_runner" : "origin_turn";
-  } else if (
+  if (
     facts.durableStatus === "completed" ||
     facts.durableStatus === "failed" ||
     facts.durableStatus === "timed_out" ||
     facts.durableStatus === "cancelled"
   ) {
     status = facts.durableStatus;
-    reason = facts.errorMessage;
+    reason = facts.ambiguous
+      ? "The run is terminal, but an external effect still needs explicit recovery."
+      : facts.errorMessage;
+  } else if (facts.ambiguous) {
+    status = "ambiguous";
+    reason = "An external effect needs explicit recovery.";
   } else if (facts.paused) {
     status = "paused";
     reason = "The workflow is durably paused.";
-  } else if (facts.pendingInteraction || facts.durableStatus === "waiting") {
+  } else if (facts.pendingRequestKind !== null || facts.durableStatus === "waiting") {
     status = "waiting";
-    reason = "The workflow is waiting for origin-session input.";
+    reason =
+      facts.pendingRequestKind === "decision"
+        ? "The workflow needs a protected human decision."
+        : facts.pendingRequestKind === "checkpoint"
+          ? "The workflow needs a checkpoint answer."
+          : facts.pendingRequestKind === "agent"
+            ? "The workflow needs its assigned agent result."
+            : facts.pendingRequestKind === "assistant"
+              ? "The workflow needs its assigned visible response."
+              : "The workflow is waiting.";
+    if (facts.pendingRequestKind === "agent" || facts.pendingRequestKind === "assistant") {
+      if (facts.originTurnActive) reason = "The agent is working on the workflow step.";
+      else if (!facts.requestDeliveryConfirmed) reason = "Workflow step delivery is not confirmed.";
+    }
+  } else if (activity !== null) {
+    status = "running";
   } else if (facts.queueStatus === "parked" || facts.queueStatus === "queued") {
     status = "queued";
     reason =
@@ -941,8 +952,12 @@ export function reduceWorkflowDisplay(facts: WorkflowDisplayFacts): WorkflowDisp
     if (facts.queueStatus === "parked") controls.push("resume");
     controls.push("cancel");
   }
-  if (status === "waiting") controls.push("answer");
-  if (status === "ambiguous") controls.push("review");
+  if (status === "waiting") {
+    if (facts.pendingRequestKind === "checkpoint") controls.push("answer");
+    if (facts.pendingRequestKind === "decision") controls.push("human-answer");
+    if (facts.pendingRequestKind === "agent") controls.push("update", "submit");
+  }
+  if (facts.ambiguous) controls.push("review");
   return { status, activity, controls, reason };
 }
 
@@ -983,7 +998,7 @@ function projectQueue(
     rootRunId: run.rootRunId,
     lineageKind: run.lineageKind,
     restartNumber: run.restartNumber,
-    parentTerminalFingerprint: run.parentTerminalFingerprint,
+    parentRunRevision: run.parentRunRevision,
     errorCode: run.errorCode,
     createdAt: run.createdAt,
     updatedAt: run.updatedAt,

package/src/server/workflow-runner-entry.ts

@@ -18,10 +18,8 @@ import type {
   AgentStepExecutor,
   AgentStepRequest,
   AgentStepSubmission,
-  ResolvedHumanDecision,
   WorkflowDefinition,
   WorkflowMountedSource,
-  WorkflowRunState,
   WorkflowSource,
 } from "../workflows/types.js";
 import { RpcStepExecutor } from "./rpc-executor.js";
@@ -43,7 +41,6 @@ import {
 } from "./workflow-runner-store.js";
 
 const STARTUP_ENV = "PI_WORKFLOWS_WORKFLOW_RUNNER_LAUNCH";
-const PRESENTATION_TIMEOUT_MS = 30_000;
 
 type WorkflowRunnerBootstrap = {
   command: WorkflowRunnerCommand;
@@ -198,7 +195,7 @@ class StdioRunnerTransport implements WorkflowRunnerStoreTransport {
 
 class InteractiveExecutor implements AgentStepExecutor {
   readonly assistantMessageMode = "visible" as const;
-  readonly preservesDeadlineWhileParked = true;
+  readonly preservesActiveTimeBudget = true;
 
   constructor(
     private readonly store: ServerBackedWorkflowStore,
@@ -317,7 +314,7 @@ export function validateAcceptedAssistantSubmission(
 }
 
 export async function executeRunnerRunCommand(
-  engine: Pick<WorkflowEngine, "run" | "resumeRun" | "continueRun">,
+  engine: Pick<WorkflowEngine, "run" | "resumeRun">,
   workflow: WorkflowDefinition,
   runId: string,
   workflowSource: WorkflowSource,
@@ -334,14 +331,6 @@ export async function executeRunnerRunCommand(
           ? {}
           : { resumeInteractionAttemptId: command.resumeInteractionAttemptId }),
       });
-    case "continue":
-      return await engine.continueRun(workflow, command.parentRunId, command.input, {
-        runId,
-        workflowSource,
-        ...(command.humanDecision === undefined
-          ? {}
-          : { humanDecision: command.humanDecision as ResolvedHumanDecision }),
-      });
   }
 }
 
@@ -421,11 +410,6 @@ export async function runWorkflowRunner(): Promise<number> {
       notificationSink: {
         notify: async (request) => await store.requestNotification(request),
       },
-      onRunFinishing: async (_runId, state) => {
-        if (state.status !== "completed" || workflow.presentationPrompt === undefined) return;
-        const instructions = await resolvePresentationInstructions(workflow, state);
-        await store.requestPresentation(instructions);
-      },
     });
     try {
       const result = await executeRunnerRunCommand(
@@ -448,43 +432,6 @@ export async function runWorkflowRunner(): Promise<number> {
   }
 }
 
-async function resolvePresentationInstructions(
-  workflow: WorkflowDefinition,
-  state: WorkflowRunState,
-): Promise<string> {
-  const fallback = "Summarize the completed workflow result for the user in a normal response.";
-  if (typeof workflow.presentationPrompt === "string") {
-    return workflow.presentationPrompt.trim() || fallback;
-  }
-  if (workflow.presentationPrompt === undefined) return fallback;
-  const controller = new AbortController();
-  const timer = setTimeout(
-    () => controller.abort(new Error("Workflow presentation prompt timed out")),
-    PRESENTATION_TIMEOUT_MS,
-  );
-  timer.unref?.();
-  const snapshot = structuredClone(state);
-  try {
-    const instructions = await Promise.race([
-      workflow.presentationPrompt({
-        state: snapshot,
-        finalOutput: snapshot.finalOutput,
-        signal: controller.signal,
-      }),
-      new Promise<never>((_resolve, reject) => {
-        controller.signal.addEventListener("abort", () => reject(controller.signal.reason), {
-          once: true,
-        });
-      }),
-    ]);
-    return instructions?.trim() || fallback;
-  } catch {
-    return fallback;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 type WorkflowRunnerSources = {
   root: WorkflowSource;
   mounted: WorkflowMountedSource[];

package/src/server/workflow-runner-protocol.ts

@@ -11,12 +11,6 @@ export const WORKFLOW_RUNNER_CONTENT_CHUNK_SCHEMA = "pi-workflows.worker-content
 export type WorkflowRunnerCommand =
   | { kind: "start"; input: JsonValue }
   | { kind: "resume"; resumeInteractionAttemptId?: string }
-  | {
-      kind: "continue";
-      parentRunId: string;
-      input: JsonValue;
-      humanDecision?: JsonValue;
-    }
   | { kind: "restart"; input: JsonValue };
 
 export const WORKFLOW_RUNNER_MESSAGE_KINDS = [
@@ -31,7 +25,6 @@ export const WORKFLOW_RUNNER_MESSAGE_KINDS = [
   "interaction.accepted",
   "interaction.rejected",
   "notification.requested",
-  "presentation.requested",
   "effect.reserve",
   "effect.settle",
   "runner.progress",
@@ -43,13 +36,12 @@ export const WORKFLOW_RUNNER_STORE_OPERATIONS = [
   "store.initializeRun",
   "store.prepareRunResume",
   "store.readRunState",
-  "store.writeSnapshot",
+  "store.commitTransition",
   "store.publishUpdate",
   "store.findSettingsScope",
   "store.ensureSettingsScope",
   "store.getSettingsScopeAtChange",
-  "store.createHumanDecisionRequest",
-  "store.readResolvedHumanDecision",
+  "store.readCheckpoint",
   "store.reserveEffect",
   "store.settleEffect",
   "content.read",
@@ -59,7 +51,6 @@ export const WORKFLOW_RUNNER_STORE_OPERATIONS = [
   "interaction.accept",
   "interaction.reject",
   "notification.request",
-  "presentation.request",
 ] as const;
 export type WorkflowRunnerStoreOperation = (typeof WORKFLOW_RUNNER_STORE_OPERATIONS)[number];
 const WORKFLOW_RUNNER_CONTROL_OPERATIONS = ["runner.ready", "runner.exiting"] as const;
@@ -142,15 +133,14 @@ export function runnerKindForOperation(
   if (operation === "store.publishUpdate") return "node.update";
   if (operation === "store.reserveEffect") return "effect.reserve";
   if (operation === "store.settleEffect") return "effect.settle";
-  if (operation === "store.createHumanDecisionRequest" || operation === "interaction.request") {
+  if (operation === "interaction.request") {
     return "interaction.requested";
   }
   if (operation === "interaction.accept") return "interaction.accepted";
   if (operation === "interaction.reject") return "interaction.rejected";
   if (operation === "notification.request") return "notification.requested";
-  if (operation === "presentation.request") return "presentation.requested";
-  if (operation === "store.writeSnapshot") {
-    const event = payload.event;
+  if (operation === "store.commitTransition") {
+    const event = isRecord(payload.transition) ? payload.transition.event : undefined;
     const eventType = isRecord(event) && typeof event.type === "string" ? event.type : "";
     if (eventType === "node_started") return "node.started";
     if (eventType === "node_finished") return "node.finished";

package/src/server/workflow-runner-store.ts

@@ -6,9 +6,8 @@ import {
   type InitializeWorkflowRunOptions,
   type WorkflowExecutionStore,
 } from "../workflows/store.js";
+import type { WorkflowTransition } from "../workflows/transitions.js";
 import type {
-  HumanDecisionRequest,
-  ResolvedHumanDecision,
   WorkflowDefinition,
   WorkflowEffectRecovery,
   WorkflowEffectReservation,
@@ -16,7 +15,6 @@ import type {
   WorkflowNotificationRequest,
   WorkflowRunState,
   WorkflowTraceEvent,
-  WorkflowTraceEventDraft,
   WorkflowUpdateInput,
   WorkflowUpdateRecord,
 } from "../workflows/types.js";
@@ -71,28 +69,26 @@ export class ServerBackedWorkflowStore implements WorkflowExecutionStore {
     return await this.call<WorkflowRunState | null>("store.readRunState", { runId });
   }
 
-  async writeSnapshot(
+  async commitTransition(
     runId: string,
-    state: WorkflowRunState,
-    event: WorkflowTraceEventDraft,
+    transition: WorkflowTransition,
   ): Promise<WorkflowTraceEvent> {
     return await this.call<WorkflowTraceEvent>(
-      "store.writeSnapshot",
-      { runId, state, event },
-      event.attemptId,
+      "store.commitTransition",
+      { runId, transition },
+      transition.event.attemptId,
     );
   }
 
   async publishUpdate(
     runId: string,
-    state: WorkflowRunState,
     nodeId: string,
     attemptId: string,
     update: WorkflowUpdateInput,
   ): Promise<{ event: WorkflowTraceEvent; record: WorkflowUpdateRecord }> {
     return await this.call<{ event: WorkflowTraceEvent; record: WorkflowUpdateRecord }>(
       "store.publishUpdate",
-      { runId, state, nodeId, attemptId, update },
+      { runId, nodeId, attemptId, update },
       attemptId,
     );
   }
@@ -128,18 +124,11 @@ export class ServerBackedWorkflowStore implements WorkflowExecutionStore {
     );
   }
 
-  async createHumanDecisionRequest(request: HumanDecisionRequest): Promise<"created" | "adopted"> {
-    return await this.call<"created" | "adopted">(
-      "store.createHumanDecisionRequest",
-      { request },
-      request.attemptId,
-    );
-  }
-
-  async readResolvedHumanDecision(decisionId: string): Promise<ResolvedHumanDecision | null> {
-    return await this.call<ResolvedHumanDecision | null>("store.readResolvedHumanDecision", {
-      decisionId,
-    });
+  async readCheckpoint(runId: string, attemptId: string) {
+    const value = await this.call<
+      import("../workflows/requests.js").WorkflowCheckpointState | null
+    >("store.readCheckpoint", { runId, attemptId }, attemptId);
+    return value ?? undefined;
   }
 
   async reserveEffect(options: {
@@ -204,10 +193,6 @@ export class ServerBackedWorkflowStore implements WorkflowExecutionStore {
     );
   }
 
-  async requestPresentation(instructions: string): Promise<void> {
-    await this.call("presentation.request", { instructions });
-  }
-
   private async call<T>(
     operation: WorkflowRunnerStoreOperation,
     payload: Record<string, unknown>,

package/src/state/attempt-time.ts

@@ -0,0 +1,122 @@
+import { performance } from "node:perf_hooks";
+import type { StateDatabase } from "./database.js";
+
+export type AttemptClock = { now(): number; monotonic(): number };
+const realClock: AttemptClock = { now: () => Date.now(), monotonic: () => performance.now() };
+
+type Interval = { attemptId: string; intervalNumber: number; elapsedMs: number };
+
+/** Records active execution in the existing database. Wall time never determines the budget. */
+export class AttemptTime {
+  private readonly anchors = new Map<string, number>();
+
+  constructor(
+    private readonly state: StateDatabase,
+    private readonly clock: AttemptClock = realClock,
+  ) {}
+
+  start(attemptId: string): void {
+    this.state.transaction(() => {
+      const open = this.openIntervals().find((interval) => interval.attemptId === attemptId);
+      if (open !== undefined) {
+        if (!this.anchors.has(intervalKey(open))) {
+          throw new Error(
+            "Recover the previous host's active intervals before starting model work",
+          );
+        }
+        return;
+      }
+      const row = this.state.connection
+        .prepare(
+          "SELECT COALESCE(MAX(interval_number), 0) + 1 AS next FROM attempt_active_intervals WHERE attempt_id = ?",
+        )
+        .get(attemptId) as { next: number };
+      const now = this.clock.now();
+      this.state.connection
+        .prepare(
+          "INSERT INTO attempt_active_intervals(attempt_id, interval_number, started_at, observed_at) VALUES (?, ?, ?, ?)",
+        )
+        .run(attemptId, row.next, now, now);
+      this.anchors.set(
+        intervalKey({ attemptId, intervalNumber: row.next }),
+        this.clock.monotonic(),
+      );
+    });
+  }
+
+  sample(): void {
+    const nested = this.state.connection.inTransaction;
+    const open = this.openIntervals();
+    this.state.transaction(() => {
+      for (const interval of open) this.sampleInterval(interval);
+    });
+    if (!nested) {
+      const active = new Set(open.map(intervalKey));
+      for (const key of this.anchors.keys()) {
+        if (!active.has(key)) this.anchors.delete(key);
+      }
+    }
+  }
+
+  stop(attemptId: string): void {
+    this.state.transaction(() => {
+      const interval = this.openIntervals().find((candidate) => candidate.attemptId === attemptId);
+      if (interval === undefined) return;
+      this.sampleInterval(interval);
+      closeAttemptTime(this.state, attemptId);
+    });
+  }
+
+  recover(): void {
+    // A crashed host can prove only the last saved sample, not time spent while offline.
+    this.state.connection
+      .prepare("UPDATE attempt_active_intervals SET ended_at = observed_at WHERE ended_at IS NULL")
+      .run();
+    this.anchors.clear();
+  }
+
+  private sampleInterval(interval: Interval): void {
+    const anchor = this.anchors.get(intervalKey(interval));
+    if (anchor === undefined) {
+      throw new Error("Active interval belongs to a previous host; recover it before sampling");
+    }
+    const elapsedMs = Math.max(interval.elapsedMs, this.clock.monotonic() - anchor, 0);
+    this.state.connection
+      .prepare(
+        `UPDATE attempt_active_intervals SET elapsed_ms = ?, observed_at = ?
+       WHERE attempt_id = ? AND interval_number = ? AND ended_at IS NULL`,
+      )
+      .run(elapsedMs, this.clock.now(), interval.attemptId, interval.intervalNumber);
+  }
+
+  private openIntervals(): Interval[] {
+    return this.state.connection
+      .prepare(
+        `SELECT attempt_id AS attemptId, interval_number AS intervalNumber, elapsed_ms AS elapsedMs
+       FROM attempt_active_intervals WHERE ended_at IS NULL`,
+      )
+      .all() as Interval[];
+  }
+}
+
+function intervalKey(interval: Pick<Interval, "attemptId" | "intervalNumber">): string {
+  return JSON.stringify([interval.attemptId, interval.intervalNumber]);
+}
+
+export function closeRunTime(state: StateDatabase, runId: string): void {
+  state.connection
+    .prepare(
+      `UPDATE attempt_active_intervals SET ended_at = observed_at
+     WHERE ended_at IS NULL AND attempt_id IN (SELECT attempt_id FROM node_attempts WHERE run_id = ?)`,
+    )
+    .run(runId);
+}
+
+/** Freeze the last host sample when an attempt settles outside its model turn. */
+export function closeAttemptTime(state: StateDatabase, attemptId: string): void {
+  state.connection
+    .prepare(
+      "UPDATE attempt_active_intervals SET ended_at = observed_at WHERE attempt_id = ? AND ended_at IS NULL",
+    )
+    .run(attemptId);
+}

package/src/state/json.ts

@@ -1,5 +1,6 @@
 export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+export type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+export type JsonObject = { [key: string]: JsonValue };
 
 export function canonicalJson(value: unknown): string {
   return JSON.stringify(normalizeJson(value));