@osolmaz/pi-workflows 0.16.4 → 0.16.6

package/src/state/prune.ts

@@ -5,16 +5,38 @@ import { StateDatabase } from "./database.js";
 
 const TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "timed_out", "cancelled"]);
 const LIVE_QUEUE_STATUSES = ["queued", "starting", "running", "parked"];
+const ACTIVE_RUNNER_STATUSES = ["starting", "ready", "running"];
+const ACTIVE_ATTEMPT_STATUSES = ["pending", "running", "waiting", "interrupted"];
 const UNSETTLED_EFFECT_STATUSES = ["pending", "applying", "ambiguous"];
 
+export const AUTOMATIC_STATE_RETENTION_MS = 30 * 24 * 60 * 60 * 1_000;
+export const AUTOMATIC_STATE_PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1_000;
+export const AUTOMATIC_STATE_VACUUM_MIN_BYTES = 64 * 1024 * 1024;
+export const AUTOMATIC_STATE_VACUUM_MIN_FREE_RATIO = 0.2;
+
 type RunAgeRow = {
   runId: string;
   parentRunId: string | null;
+  rootRunId: string;
   launchOptionsHash: Buffer;
   status: string;
   finishedAt: number | null;
 };
 
+type SelectedRunTree = {
+  rootRunId: string;
+  runIds: string[];
+  signature: string;
+};
+
+type RunTreeSelection = {
+  candidateTrees: number;
+  blockedTrees: number;
+  trees: SelectedRunTree[];
+  runIds: string[];
+  signature: string;
+};
+
 export type StatePruneOptions = {
   before: string;
   apply: boolean;
@@ -34,6 +56,38 @@ export type StatePruneReport = {
   applied: boolean;
 };
 
+export type AutomaticStatePruneOptions = {
+  now?: number;
+  activeBlobHashes?: () => readonly Buffer[];
+  shouldContinue?: () => boolean;
+  yieldControl?: () => Promise<void>;
+  vacuumMinBytes?: number;
+  vacuumMinFreeRatio?: number;
+  vacuum?: (database: Database.Database) => void;
+};
+
+export type AutomaticStatePruneReport = StatePruneReport & {
+  completed: boolean;
+  compacted: boolean;
+  pageCount: number;
+  freePageCount: number;
+  pageSize: number;
+  reclaimableBytes: number;
+  freePageRatio: number;
+  compactionError?: string;
+};
+
+type DatabasePageMetrics = Pick<
+  AutomaticStatePruneReport,
+  "pageCount" | "freePageCount" | "pageSize" | "reclaimableBytes" | "freePageRatio"
+>;
+
+type DeletedState = {
+  deletedRows: number;
+  deletedBlobs: number;
+  deletedBlobBytes: number;
+};
+
 export function validateStatePruneOptions(options: StatePruneOptions): void {
   parseCutoff(options.before);
   if (options.apply && options.backupPath === undefined) {
@@ -57,13 +111,7 @@ export async function pruneState(
   try {
     const selection = selectRunTrees(state, cutoff);
     const sizeBefore = databaseBytes(databasePath);
-    const base = {
-      cutoff: new Date(cutoff).toISOString(),
-      candidateTrees: selection.candidateTrees,
-      blockedTrees: selection.blockedTrees,
-      selectedRuns: selection.runIds.length,
-      databaseBytesBefore: sizeBefore,
-    };
+    const base = reportBase(cutoff, selection, sizeBefore);
     if (!options.apply) {
       return {
         ...base,
@@ -81,46 +129,14 @@ export async function pruneState(
     }
     await state.backup(backupPath);
 
-    let deletedRows = 0;
-    let deletedBlobs = 0;
-    let deletedBlobBytes = 0;
+    let deleted: DeletedState;
     state.connection.exec("BEGIN EXCLUSIVE");
     try {
       const checked = selectRunTrees(state, cutoff);
-      if (
-        checked.runIds.join("\0") !== selection.runIds.join("\0") ||
-        checked.signature !== selection.signature
-      ) {
+      if (!sameSelection(checked, selection)) {
         throw new Error("Prune selection changed after backup; run the command again");
       }
-      const beforeChanges = totalChanges(state.connection);
-      if (checked.runIds.length !== 0) {
-        deleteRunAggregates(state.connection, checked.runIds);
-      }
-      state.connection
-        .prepare(
-          `DELETE FROM workflow_definitions
-         WHERE NOT EXISTS (
-           SELECT 1 FROM runs WHERE runs.definition_digest = workflow_definitions.definition_digest
-         )`,
-        )
-        .run();
-      state.connection
-        .prepare(
-          `DELETE FROM projects
-         WHERE NOT EXISTS (SELECT 1 FROM runs WHERE runs.project_id = projects.project_id)
-           AND NOT EXISTS (
-             SELECT 1 FROM controller_resources
-             WHERE controller_resources.project_id = projects.project_id
-           )`,
-        )
-        .run();
-      const retainedBlobHashes = activeBlobHashes();
-      const blobStats = unreferencedBlobStats(state.connection, retainedBlobHashes);
-      deleteUnreferencedBlobs(state.connection, retainedBlobHashes);
-      deletedRows = totalChanges(state.connection) - beforeChanges;
-      deletedBlobs = blobStats.count;
-      deletedBlobBytes = blobStats.bytes;
+      deleted = deleteSelectedState(state.connection, checked.runIds, activeBlobHashes());
       state.connection.exec("COMMIT");
     } catch (error) {
       if (state.connection.inTransaction) state.connection.exec("ROLLBACK");
@@ -132,25 +148,160 @@ export async function pruneState(
     state.integrityCheck();
     return {
       ...base,
+      ...deleted,
+      databaseBytesAfter: databaseBytes(databasePath),
+      applied: true,
+    };
+  } finally {
+    if (lock !== undefined) releaseMaintenanceLock(lockPath, lock);
+  }
+}
+
+export async function pruneStateAutomatically(
+  state: StateDatabase,
+  databasePath: string,
+  options: AutomaticStatePruneOptions = {},
+): Promise<AutomaticStatePruneReport> {
+  const now = options.now ?? Date.now();
+  const cutoff = now - AUTOMATIC_STATE_RETENTION_MS;
+  const shouldContinue = options.shouldContinue ?? (() => true);
+  const yieldControl = options.yieldControl ?? yieldToEventLoop;
+  const activeBlobHashes = options.activeBlobHashes ?? (() => []);
+  const sizeBefore = databaseBytes(databasePath);
+  const lockPath = `${databasePath}.maintenance.lock`;
+  const lock = acquireMaintenanceLock(lockPath);
+  let initial = emptySelection();
+  let deletedRows = 0;
+  let deletedBlobs = 0;
+  let deletedBlobBytes = 0;
+  let completed = true;
+  let compacted = false;
+  let compactionError: string | undefined;
+  let metrics: DatabasePageMetrics = {
+    pageCount: 0,
+    freePageCount: 0,
+    pageSize: 0,
+    reclaimableBytes: 0,
+    freePageRatio: 0,
+  };
+
+  try {
+    metrics = databasePageMetrics(state.connection);
+    initial = selectRunTrees(state, cutoff, now);
+    for (const selectedTree of initial.trees) {
+      if (!shouldContinue()) {
+        completed = false;
+        break;
+      }
+      state.connection.exec("BEGIN IMMEDIATE");
+      try {
+        const checked = selectRunTrees(state, cutoff, now).trees.find(
+          (tree) => tree.rootRunId === selectedTree.rootRunId,
+        );
+        if (checked === undefined || !sameTree(checked, selectedTree)) {
+          completed = false;
+          state.connection.exec("ROLLBACK");
+          break;
+        }
+        const beforeChanges = totalChanges(state.connection);
+        deleteRunAggregates(state.connection, checked.runIds);
+        deleteUnusedDefinitionsAndProjects(state.connection);
+        deletedRows += totalChanges(state.connection) - beforeChanges;
+        state.connection.exec("COMMIT");
+      } catch (error) {
+        if (state.connection.inTransaction) state.connection.exec("ROLLBACK");
+        throw error;
+      }
+      await yieldControl();
+    }
+
+    if (completed && shouldContinue()) {
+      state.connection.exec("BEGIN IMMEDIATE");
+      try {
+        const beforeChanges = totalChanges(state.connection);
+        deleteUnusedDefinitionsAndProjects(state.connection);
+        const retainedBlobHashes = activeBlobHashes();
+        const blobStats = unreferencedBlobStats(state.connection, retainedBlobHashes);
+        deleteUnreferencedBlobs(state.connection, retainedBlobHashes);
+        deletedRows += totalChanges(state.connection) - beforeChanges;
+        deletedBlobs = blobStats.count;
+        deletedBlobBytes = blobStats.bytes;
+        state.connection.exec("COMMIT");
+      } catch (error) {
+        if (state.connection.inTransaction) state.connection.exec("ROLLBACK");
+        throw error;
+      }
+    } else {
+      completed = false;
+    }
+
+    if (completed && shouldContinue()) {
+      try {
+        state.connection.pragma("wal_checkpoint(TRUNCATE)");
+        metrics = databasePageMetrics(state.connection);
+        if (
+          shouldContinue() &&
+          shouldVacuumStateAutomatically(
+            metrics,
+            options.vacuumMinBytes ?? AUTOMATIC_STATE_VACUUM_MIN_BYTES,
+            options.vacuumMinFreeRatio ?? AUTOMATIC_STATE_VACUUM_MIN_FREE_RATIO,
+          )
+        ) {
+          (options.vacuum ?? vacuumDatabase)(state.connection);
+          compacted = true;
+          state.connection.pragma("wal_checkpoint(TRUNCATE)");
+          metrics = databasePageMetrics(state.connection);
+        }
+      } catch (error) {
+        compactionError = errorMessage(error);
+        metrics = databasePageMetrics(state.connection);
+      }
+    }
+
+    return {
+      ...reportBase(cutoff, initial, sizeBefore),
       deletedRows,
       deletedBlobs,
       deletedBlobBytes,
       databaseBytesAfter: databaseBytes(databasePath),
       applied: true,
+      completed,
+      compacted,
+      ...metrics,
+      ...(compactionError === undefined ? {} : { compactionError }),
     };
   } finally {
-    if (lock !== undefined) releaseMaintenanceLock(lockPath, lock);
+    releaseMaintenanceLock(lockPath, lock);
   }
 }
 
+export function shouldVacuumStateAutomatically(
+  metrics: DatabasePageMetrics,
+  minimumBytes: number = AUTOMATIC_STATE_VACUUM_MIN_BYTES,
+  minimumFreeRatio: number = AUTOMATIC_STATE_VACUUM_MIN_FREE_RATIO,
+): boolean {
+  return metrics.reclaimableBytes >= minimumBytes && metrics.freePageRatio >= minimumFreeRatio;
+}
+
+function reportBase(cutoff: number, selection: RunTreeSelection, databaseBytesBefore: number) {
+  return {
+    cutoff: new Date(cutoff).toISOString(),
+    candidateTrees: selection.candidateTrees,
+    blockedTrees: selection.blockedTrees,
+    selectedRuns: selection.runIds.length,
+    databaseBytesBefore,
+  };
+}
+
 function selectRunTrees(
   state: StateDatabase,
   cutoff: number,
-): { candidateTrees: number; blockedTrees: number; runIds: string[]; signature: string } {
+  observedAt: number = Date.now(),
+): RunTreeSelection {
   const { connection: database } = state;
   const rows = database
     .prepare(
-      `SELECT run_id AS runId, parent_run_id AS parentRunId,
+      `SELECT run_id AS runId, parent_run_id AS parentRunId, root_run_id AS rootRunId,
               launch_options_hash AS launchOptionsHash, status, finished_at AS finishedAt
        FROM runs ORDER BY created_at, run_id`,
     )
@@ -166,47 +317,64 @@ function selectRunTrees(
       )
       .map((row) => row.runId),
   );
-  const children = new Map<string, string[]>();
-  const parents = new Map<string, string[]>();
+  const rowIds = new Set(rows.map((row) => row.runId));
+  const links = new Map(rows.map((row) => [row.runId, new Set<string>()]));
   for (const row of rows) {
-    const runParents = new Set<string>();
-    if (row.parentRunId !== null) runParents.add(row.parentRunId);
-    const restartParentRunId = restartParentFromLaunchOptions(
-      state.readJson(row.launchOptionsHash),
+    linkRuns(links, rowIds, row.runId, row.parentRunId);
+    linkRuns(links, rowIds, row.runId, row.rootRunId);
+    linkRuns(
+      links,
+      rowIds,
+      row.runId,
+      restartParentFromLaunchOptions(state.readJson(row.launchOptionsHash)),
     );
-    if (restartParentRunId !== null) runParents.add(restartParentRunId);
-    parents.set(row.runId, [...runParents]);
-    for (const parentRunId of runParents) {
-      const values = children.get(parentRunId) ?? [];
-      values.push(row.runId);
-      children.set(parentRunId, values);
-    }
   }
-  const roots = rows.filter(
-    (row) =>
-      eligible.has(row.runId) &&
-      (parents.get(row.runId) ?? []).every((parentRunId) => !eligible.has(parentRunId)),
-  );
-  const selected = new Set<string>();
+
+  const components: string[][] = [];
+  const visited = new Set<string>();
+  for (const row of rows) {
+    if (visited.has(row.runId)) continue;
+    const component = descendants(row.runId, links);
+    for (const runId of component) visited.add(runId);
+    components.push(component.sort());
+  }
+
+  const trees: SelectedRunTree[] = [];
+  let candidateTrees = 0;
   let blockedTrees = 0;
-  for (const root of roots) {
-    const tree = descendants(root.runId, children);
-    if (tree.some((runId) => !eligible.has(runId)) || treeHasBlocker(database, tree)) {
+  for (const runIds of components) {
+    if (!runIds.some((runId) => eligible.has(runId))) continue;
+    candidateTrees += 1;
+    if (
+      runIds.some((runId) => !eligible.has(runId)) ||
+      treeHasBlocker(database, runIds, observedAt)
+    ) {
       blockedTrees += 1;
       continue;
     }
-    for (const runId of tree) selected.add(runId);
+    const rootRunId = chooseRootRunId(rows, runIds);
+    trees.push({
+      rootRunId,
+      runIds,
+      signature: selectionSignature(database, runIds),
+    });
   }
-  const runIds = [...selected].sort();
+  trees.sort((left, right) => left.rootRunId.localeCompare(right.rootRunId));
+  const runIds = trees.flatMap((tree) => tree.runIds).sort();
   return {
-    candidateTrees: roots.length,
+    candidateTrees,
     blockedTrees,
+    trees,
     runIds,
-    signature: selectionSignature(database, runIds),
+    signature: JSON.stringify(trees),
   };
 }
 
-function treeHasBlocker(database: Database.Database, runIds: string[]): boolean {
+function treeHasBlocker(
+  database: Database.Database,
+  runIds: string[],
+  observedAt: number,
+): boolean {
   const values = placeholders(runIds);
   if (
     hasRow(
@@ -214,6 +382,55 @@ function treeHasBlocker(database: Database.Database, runIds: string[]): boolean
       `SELECT 1 FROM run_queue WHERE run_id IN (${values}) AND status IN (${placeholders(LIVE_QUEUE_STATUSES)})`,
       [...runIds, ...LIVE_QUEUE_STATUSES],
     ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM run_workers
+       WHERE run_id IN (${values}) AND status IN (${placeholders(ACTIVE_RUNNER_STATUSES)})`,
+      [...runIds, ...ACTIVE_RUNNER_STATUSES],
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM node_attempts
+       WHERE run_id IN (${values}) AND status IN (${placeholders(ACTIVE_ATTEMPT_STATUSES)})`,
+      [...runIds, ...ACTIVE_ATTEMPT_STATUSES],
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM session_segments WHERE run_id IN (${values}) AND status = 'recording'`,
+      runIds,
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM interactive_requests WHERE run_id IN (${values}) AND status = 'pending'`,
+      runIds,
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM human_decisions d
+       LEFT JOIN human_decision_resolutions r ON r.decision_id = d.decision_id
+       WHERE d.run_id IN (${values}) AND r.decision_id IS NULL`,
+      runIds,
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM workflow_messages WHERE run_id IN (${values}) AND status = 'pending'`,
+      runIds,
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM workflow_turns WHERE run_id IN (${values}) AND state = 'started'`,
+      runIds,
+    ) ||
+    hasRow(
+      database,
+      `SELECT 1 FROM run_bindings b
+       WHERE b.run_id IN (${values}) AND b.execution_mode = 'interactive'
+         AND NOT EXISTS (
+           SELECT 1 FROM workflow_messages m
+           WHERE m.run_id = b.run_id AND m.kind = 'terminal' AND m.status = 'sent'
+         )`,
+      runIds,
+    ) ||
     hasRow(
       database,
       `SELECT 1 FROM workflow_follow_ups
@@ -229,14 +446,8 @@ function treeHasBlocker(database: Database.Database, runIds: string[]): boolean
     hasRow(
       database,
       `SELECT 1 FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
-       WHERE a.run_id IN (${values}) AND s.run_id NOT IN (${values})`,
-      [...runIds, ...runIds],
-    ) ||
-    hasRow(
-      database,
-      `SELECT 1 FROM continuations
-       WHERE (parent_run_id IN (${values}) AND continuation_run_id NOT IN (${values}))
-          OR (continuation_run_id IN (${values}) AND parent_run_id NOT IN (${values}))`,
+       WHERE (a.run_id IN (${values}) AND s.run_id NOT IN (${values}))
+          OR (s.run_id IN (${values}) AND a.run_id NOT IN (${values}))`,
       [...runIds, ...runIds, ...runIds, ...runIds],
     ) ||
     hasRow(
@@ -251,12 +462,12 @@ function treeHasBlocker(database: Database.Database, runIds: string[]): boolean
   }
   const resources = relatedResourceIds(database, runIds);
   const resourceValues = placeholders(resources);
-  if (
+  return (
     hasRow(
       database,
       `SELECT 1 FROM leases
        WHERE resource_id IN (${resourceValues}) AND owner_id IS NOT NULL AND expires_at > ?`,
-      [...resources, Date.now()],
+      [...resources, observedAt],
     ) ||
     hasRow(
       database,
@@ -271,10 +482,45 @@ function treeHasBlocker(database: Database.Database, runIds: string[]): boolean
        WHERE d.run_id IN (${values})`,
       runIds,
     )
-  ) {
-    return true;
-  }
-  return false;
+  );
+}
+
+function deleteSelectedState(
+  database: Database.Database,
+  runIds: string[],
+  retainedBlobHashes: readonly Buffer[],
+): DeletedState {
+  const beforeChanges = totalChanges(database);
+  if (runIds.length !== 0) deleteRunAggregates(database, runIds);
+  deleteUnusedDefinitionsAndProjects(database);
+  const blobStats = unreferencedBlobStats(database, retainedBlobHashes);
+  deleteUnreferencedBlobs(database, retainedBlobHashes);
+  return {
+    deletedRows: totalChanges(database) - beforeChanges,
+    deletedBlobs: blobStats.count,
+    deletedBlobBytes: blobStats.bytes,
+  };
+}
+
+function deleteUnusedDefinitionsAndProjects(database: Database.Database): void {
+  database
+    .prepare(
+      `DELETE FROM workflow_definitions
+       WHERE NOT EXISTS (
+         SELECT 1 FROM runs WHERE runs.definition_digest = workflow_definitions.definition_digest
+       )`,
+    )
+    .run();
+  database
+    .prepare(
+      `DELETE FROM projects
+       WHERE NOT EXISTS (SELECT 1 FROM runs WHERE runs.project_id = projects.project_id)
+         AND NOT EXISTS (
+           SELECT 1 FROM controller_resources
+           WHERE controller_resources.project_id = projects.project_id
+         )`,
+    )
+    .run();
 }
 
 function deleteRunAggregates(database: Database.Database, runIds: string[]): void {
@@ -292,12 +538,6 @@ function deleteRunAggregates(database: Database.Database, runIds: string[]): voi
     const effectValues = placeholders(effectIds);
     database.prepare(`DELETE FROM effects WHERE effect_id IN (${effectValues})`).run(...effectIds);
   }
-  database
-    .prepare(
-      `DELETE FROM continuations
-       WHERE parent_run_id IN (${values}) OR continuation_run_id IN (${values})`,
-    )
-    .run(...runIds, ...runIds);
   const allResources = [...new Set([...resources, ...effectRows.map((row) => row.resourceId)])];
   if (allResources.length !== 0) {
     database
@@ -408,7 +648,60 @@ function blobReferencePredicate(database: Database.Database, retainedBlobCount:
   return `${unreferenced} AND blob_hash NOT IN (${retainedPlaceholders})`;
 }
 
-function descendants(root: string, children: Map<string, string[]>): string[] {
+function vacuumDatabase(database: Database.Database): void {
+  database.exec("VACUUM");
+}
+
+function databasePageMetrics(database: Database.Database): DatabasePageMetrics {
+  const pageCount = pragmaNumber(database, "page_count");
+  const freePageCount = pragmaNumber(database, "freelist_count");
+  const pageSize = pragmaNumber(database, "page_size");
+  return {
+    pageCount,
+    freePageCount,
+    pageSize,
+    reclaimableBytes: freePageCount * pageSize,
+    freePageRatio: pageCount === 0 ? 0 : freePageCount / pageCount,
+  };
+}
+
+function pragmaNumber(database: Database.Database, name: string): number {
+  const value = database.pragma(name, { simple: true });
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`SQLite ${name} returned an invalid value`);
+  }
+  return value;
+}
+
+function sameSelection(left: RunTreeSelection, right: RunTreeSelection): boolean {
+  return left.runIds.join("\0") === right.runIds.join("\0") && left.signature === right.signature;
+}
+
+function sameTree(left: SelectedRunTree, right: SelectedRunTree): boolean {
+  return left.runIds.join("\0") === right.runIds.join("\0") && left.signature === right.signature;
+}
+
+function chooseRootRunId(rows: RunAgeRow[], runIds: string[]): string {
+  const runIdSet = new Set(runIds);
+  const candidates = rows
+    .filter((row) => runIdSet.has(row.runId) && row.rootRunId === row.runId)
+    .map((row) => row.runId)
+    .sort();
+  return candidates[0] ?? runIds[0] ?? "";
+}
+
+function linkRuns(
+  links: Map<string, Set<string>>,
+  rowIds: Set<string>,
+  left: string,
+  right: string | null,
+): void {
+  if (right === null || right === left || !rowIds.has(right)) return;
+  links.get(left)?.add(right);
+  links.get(right)?.add(left);
+}
+
+function descendants(root: string, links: Map<string, Set<string>>): string[] {
   const result: string[] = [];
   const seen = new Set<string>();
   const pending = [root];
@@ -417,7 +710,7 @@ function descendants(root: string, children: Map<string, string[]>): string[] {
     if (seen.has(runId)) continue;
     seen.add(runId);
     result.push(runId);
-    pending.push(...(children.get(runId) ?? []));
+    pending.push(...(links.get(runId) ?? []));
   }
   return result;
 }
@@ -444,6 +737,10 @@ function databaseBytes(databasePath: string): number {
     .reduce((total, filePath) => total + fs.statSync(filePath).size, 0);
 }
 
+function emptySelection(): RunTreeSelection {
+  return { candidateTrees: 0, blockedTrees: 0, trees: [], runIds: [], signature: "" };
+}
+
 function acquireMaintenanceLock(lockPath: string): number {
   try {
     return fs.openSync(lockPath, "wx", 0o600);
@@ -478,12 +775,28 @@ function quoteIdentifier(value: string): string {
   return `"${value.replaceAll('"', '""')}"`;
 }
 
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function yieldToEventLoop(): Promise<void> {
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 function isRunAgeRow(value: unknown): value is RunAgeRow {
-  return isRecord(value);
+  return (
+    isRecord(value) &&
+    typeof value.runId === "string" &&
+    (value.parentRunId === null || typeof value.parentRunId === "string") &&
+    typeof value.rootRunId === "string" &&
+    Buffer.isBuffer(value.launchOptionsHash) &&
+    typeof value.status === "string" &&
+    (value.finishedAt === null || typeof value.finishedAt === "number")
+  );
 }
 
 function isResourceRow(value: unknown): value is { resourceId: string } {