deepline 0.1.153 → 0.1.155

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import {
   createRuntimePool,
   createRuntimeOneShotQueryClient,
+  canReuseRuntimePostgresPoolsAcrossRequests,
   isRuntimeOneShotQueryFactoryRegistered,
   type RuntimePool,
   type RuntimePoolClient,
@@ -15,7 +16,6 @@ import type {
 import type { PlayBundleArtifact } from '../plays/artifact-types';
 import {
   augmentSheetContractWithDatasetFields,
-  outputFieldsFromSheetContract,
   outputPhysicalSheetColumnNames,
   outputPhysicalSheetColumnProjections,
   physicalSheetColumnNames,
@@ -57,7 +57,10 @@ import {
   type WorkReceipt,
   type WorkReceiptClaim,
 } from './work-receipts';
-import { stringifyPostgresJson } from './postgres-json';
+import {
+  sanitizePostgresJsonValue,
+  stringifyPostgresJson,
+} from './postgres-json';
 import { RECEIPT_STATUS_CODE, receiptStatusFromCode } from './receipt-status';
 import type { MapRowOutcome } from './durability-store';
 import {
@@ -69,12 +72,7 @@ import {
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
-import {
-  DEEPLINE_CELL_META_FIELD,
-  cellPolicyFields,
-  shouldRecomputeCell,
-  type CellStalenessPolicyByField,
-} from './cell-staleness';
+import { DEEPLINE_CELL_META_FIELD } from './cell-staleness';
 import type { PlayArtifactKind } from './backend';
 
 type RuntimeApiContext = {
@@ -126,6 +124,8 @@ const RUNTIME_POSTGRES_PREWARM_MAX_ATTEMPTS = 4;
 const RUNTIME_POSTGRES_PREWARM_RETRY_DELAYS_MS = [250, 750, 1_500] as const;
 const RUNTIME_POSTGRES_CONNECT_MAX_ATTEMPTS = 4;
 const RUNTIME_POSTGRES_CONNECT_RETRY_DELAYS_MS = [250, 750, 1_500] as const;
+const RUNTIME_WORK_RECEIPT_QUERY_MAX_ATTEMPTS = 3;
+const RUNTIME_WORK_RECEIPT_QUERY_RETRY_DELAYS_MS = [250, 750] as const;
 // Runtime DB sessions are minted against the pooled tenant endpoint. A healthy
 // connect is sub-second; spending minutes on one sandbox dial only hides a
 // broken route and stalls the whole play. Keep retries bounded and loud.
@@ -140,6 +140,20 @@ const RECEIPT_STATUS_COMPLETED = RECEIPT_STATUS_CODE.completed;
 const RECEIPT_STATUS_FAILED = RECEIPT_STATUS_CODE.failed;
 const RECEIPT_STATUS_SKIPPED = RECEIPT_STATUS_CODE.skipped;
 
+function runtimeSummaryTotalSql(input: {
+  currentTotal: string;
+  totalDelta: string;
+  queued: string;
+  running: string;
+  completed: string;
+  failed: string;
+}): string {
+  return `GREATEST(
+    GREATEST(${input.currentTotal} + ${input.totalDelta}, 0),
+    (${input.queued}) + (${input.running}) + (${input.completed}) + (${input.failed})
+  )`;
+}
+
 export type ResolvedRuntimePlay = {
   playId: string;
   sourceCode?: string | null;
@@ -1068,6 +1082,27 @@ function isTransientRuntimePostgresConnectionError(error: unknown): boolean {
   );
 }
 
+function isTransientRuntimePostgresOperationError(error: unknown): boolean {
+  if (isTransientRuntimePostgresConnectionError(error)) {
+    return true;
+  }
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const nestedErrors = (error as { errors?: unknown }).errors;
+  if (
+    Array.isArray(nestedErrors) &&
+    nestedErrors.some(isTransientRuntimePostgresOperationError)
+  ) {
+    return true;
+  }
+  const name = 'name' in error ? String(error.name) : '';
+  const message = 'message' in error ? String(error.message) : '';
+  return /fetch failed|network error|socket hang up|connection (terminated|timeout|timed out|closed|reset)|ETIMEDOUT|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT/i.test(
+    `${name} ${message} ${String(error)}`,
+  );
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1129,8 +1164,12 @@ function getPostgresPool(postgresUrl: string, cachePool = true): RuntimePool {
   return pool;
 }
 
-function canReuseRuntimePostgresPoolsAcrossRequests(): boolean {
-  return true;
+async function resetRuntimePostgresPool(postgresUrl: string): Promise<void> {
+  const pool = postgresPools.get(postgresUrl);
+  postgresPools.delete(postgresUrl);
+  if (pool) {
+    await Promise.resolve(pool.end()).catch(() => {});
+  }
 }
 
 async function withRuntimePostgres<T>(
@@ -1528,15 +1567,41 @@ async function withRuntimeWorkReceiptClient<T>(
     }
   };
 
-  if (isRuntimeOneShotQueryFactoryRegistered()) {
-    return await withRuntimeOneShotPostgres(session, runWithSelfHeal);
+  for (
+    let attempt = 1;
+    attempt <= RUNTIME_WORK_RECEIPT_QUERY_MAX_ATTEMPTS;
+    attempt += 1
+  ) {
+    try {
+      return isRuntimeOneShotQueryFactoryRegistered()
+        ? await withRuntimeOneShotPostgres(session, runWithSelfHeal)
+        : await withRuntimePostgres(
+            session,
+            (client) => runWithSelfHeal(client),
+            { cachePool: !context.disablePostgresPoolCache },
+          );
+    } catch (error) {
+      if (
+        attempt >= RUNTIME_WORK_RECEIPT_QUERY_MAX_ATTEMPTS ||
+        !isTransientRuntimePostgresOperationError(error)
+      ) {
+        throw error;
+      }
+      if (
+        !isRuntimeOneShotQueryFactoryRegistered() &&
+        !context.disablePostgresPoolCache
+      ) {
+        await resetRuntimePostgresPool(session.postgresUrl);
+      }
+      await sleep(
+        RUNTIME_WORK_RECEIPT_QUERY_RETRY_DELAYS_MS[attempt - 1] ??
+          RUNTIME_WORK_RECEIPT_QUERY_RETRY_DELAYS_MS[
+            RUNTIME_WORK_RECEIPT_QUERY_RETRY_DELAYS_MS.length - 1
+          ],
+      );
+    }
   }
-
-  return await withRuntimePostgres(
-    session,
-    (client) => runWithSelfHeal(client),
-    { cachePool: !context.disablePostgresPoolCache },
-  );
+  throw new Error('Runtime work receipt query failed after retries.');
 }
 
 const PLAY_INTERNAL_SHEET_VERSION_SEQUENCE = '_deepline_sheet_version_seq';
@@ -1596,6 +1661,8 @@ function isSystemSheetColumn(columnName: string): boolean {
     case '__has_failed':
     case '__deeplineCsvProjectedFields':
     case '__deeplineCsvProjectedValues':
+    case '__deeplineSourceRowIndex':
+    case '__deeplineOriginalSourceRowIndex':
       return true;
     default:
       return false;
@@ -1652,49 +1719,33 @@ function mapRuntimePostgresRow(input: {
   };
 }
 
-function mapRuntimeProjectedRows(
-  rows: readonly Record<string, unknown>[],
-  outputColumns: readonly PhysicalSheetColumnProjection[],
-): RuntimeApiRowRecord[] {
-  return rows.map((raw) => {
-    const key = String(raw._key ?? '');
-    const data = Object.fromEntries(
-      outputColumns
-        .filter((column) =>
-          Object.prototype.hasOwnProperty.call(raw, column.fieldName),
-        )
-        .map((column) => [column.fieldName, raw[column.fieldName]]),
-    );
-    return { key, data };
-  });
-}
-
-function cachedRuntimeCellMetaPatch(runId: string): Record<string, unknown> {
-  return {
-    status: 'cached',
-    runId,
-    reused: true,
-  };
-}
-
-function cachedRuntimeCellMetaUpdateSql(
-  tableAlias: string,
-  outputFields: readonly string[],
-  patchSql: string,
-): string {
-  const uniqueFields = [...new Set(outputFields)];
-  if (uniqueFields.length === 0) {
-    return `${tableAlias}._cell_meta`;
+function completedRuntimeCellMetaPatch(input: {
+  runId: string;
+  outputFields: readonly string[];
+  rowPatch?: Record<string, unknown>;
+}): Record<string, unknown> {
+  const patch: Record<string, unknown> = {};
+  const completedAt = Date.now();
+  for (const field of input.outputFields) {
+    const existing =
+      input.rowPatch?.[field] &&
+      typeof input.rowPatch[field] === 'object' &&
+      !Array.isArray(input.rowPatch[field])
+        ? (input.rowPatch[field] as Record<string, unknown>)
+        : {};
+    patch[field] = {
+      status: 'completed',
+      runId: input.runId,
+      completedAt,
+      ...existing,
+    };
+  }
+  for (const [field, meta] of Object.entries(input.rowPatch ?? {})) {
+    if (!Object.hasOwn(patch, field)) {
+      patch[field] = meta;
+    }
   }
-  return uniqueFields.reduce((expression, field) => {
-    const fieldLiteral = quoteLiteral(field);
-    return `jsonb_set(
-              ${expression},
-              ARRAY[${fieldLiteral}]::text[],
-              coalesce(${tableAlias}._cell_meta -> ${fieldLiteral}, '{}'::jsonb) || ${patchSql},
-              true
-            )`;
-  }, `coalesce(${tableAlias}._cell_meta, '{}'::jsonb)`);
+  return patch;
 }
 
 function mergeRuntimeCellMetaPatchSql(
@@ -1710,166 +1761,6 @@ function mergeRuntimeCellMetaPatchSql(
   )`;
 }
 
-async function insertCachedRuntimeColumnSummaryDelta(
-  client: RuntimeQueryClient,
-  session: RuntimePostgresSession,
-  input: {
-    tableNamespace: string;
-    outputFields: readonly string[];
-    cached: number;
-  },
-): Promise<void> {
-  const uniqueFields = [...new Set(input.outputFields)];
-  if (uniqueFields.length === 0 || input.cached <= 0) {
-    return;
-  }
-  const normalizedPlayName = normalizePlayNameForSheet(session.playName);
-  const normalizedTableNamespace = normalizeTableNamespace(
-    input.tableNamespace,
-  );
-  await client.query(
-    `
-      INSERT INTO ${columnSummaryTable(session)} AS target (
-        play_name,
-        table_namespace,
-        field,
-        cached
-      )
-      SELECT $1::text, $2::text, field_values.field, $3::int
-      FROM unnest($4::text[]) AS field_values(field)
-      ON CONFLICT (play_name, table_namespace, field) DO UPDATE
-      SET cached = GREATEST(target.cached + EXCLUDED.cached, 0),
-          _updated_at = now()
-    `,
-    [normalizedPlayName, normalizedTableNamespace, input.cached, uniqueFields],
-  );
-}
-
-async function markAndReadRuntimeCompletedRowsCached(
-  client: RuntimeQueryClient,
-  session: RuntimePostgresSession,
-  input: {
-    tableNamespace: string;
-    keys: string[];
-    runId: string;
-    outputFields: string[];
-    sheetContract: PlaySheetContract;
-  },
-): Promise<RuntimeApiRowRecord[]> {
-  if (input.keys.length === 0) {
-    return [];
-  }
-  const cellMetaSql = cachedRuntimeCellMetaUpdateSql(
-    'target',
-    input.outputFields,
-    '$3::jsonb',
-  );
-
-  const { rows } = await client.query<Record<string, unknown>>(
-    `
-      WITH updated_rows AS (
-        UPDATE ${sheetTable(session)} AS target
-        SET _run_id = $2::text,
-            _updated_at = now(),
-            _version = ${nextRuntimeSheetVersionExpression(session)},
-            _cell_meta = ${cellMetaSql}
-        WHERE target._key = ANY($1::text[])
-          AND target._status = 'enriched'
-        RETURNING target.*
-      )
-      SELECT *
-      FROM updated_rows
-      ORDER BY _input_index ASC NULLS LAST, _created_at ASC, _key ASC
-    `,
-    [
-      input.keys,
-      input.runId,
-      JSON.stringify(cachedRuntimeCellMetaPatch(input.runId)),
-    ],
-  );
-  await insertCachedRuntimeColumnSummaryDelta(client, session, {
-    tableNamespace: input.tableNamespace,
-    outputFields: input.outputFields,
-    cached: rows.length,
-  });
-  return rows.map((raw) =>
-    mapRuntimePostgresRow({ raw, sheetContract: input.sheetContract }),
-  );
-}
-
-async function markAndReadRuntimeCompletedRowsCachedProjection(
-  client: RuntimeQueryClient,
-  session: RuntimePostgresSession,
-  input: {
-    tableNamespace: string;
-    keys: string[];
-    runId: string;
-    outputFields: string[];
-    outputColumns: PhysicalSheetColumnProjection[];
-    timings?: RuntimeSheetTiming[];
-  },
-): Promise<RuntimeApiRowRecord[]> {
-  if (input.keys.length === 0) {
-    return [];
-  }
-  const cellMetaSql = cachedRuntimeCellMetaUpdateSql(
-    'target',
-    input.outputFields,
-    '$3::jsonb',
-  );
-  const outputReturnSql =
-    input.outputColumns.length > 0
-      ? `, ${input.outputColumns
-          .map(
-            (column) =>
-              `target.${quoteIdentifier(column.sqlName)} AS ${quoteIdentifier(
-                column.fieldName,
-              )}`,
-          )
-          .join(', ')}`
-      : '';
-
-  const queryStartedAt = Date.now();
-  const { rows } = await client.query<Record<string, unknown>>(
-    `
-      WITH updated_rows AS (
-        UPDATE ${sheetTable(session)} AS target
-        SET _run_id = $2::text,
-            _updated_at = now(),
-            _version = ${nextRuntimeSheetVersionExpression(session)},
-            _cell_meta = ${cellMetaSql}
-        WHERE target._key = ANY($1::text[])
-          AND target._status = 'enriched'
-        RETURNING target._key${outputReturnSql}
-      )
-      SELECT *
-      FROM updated_rows
-    `,
-    [
-      input.keys,
-      input.runId,
-      JSON.stringify(cachedRuntimeCellMetaPatch(input.runId)),
-    ],
-  );
-  input.timings?.push({
-    phase: 'cached_fast_path.mark_read_projected_query',
-    ms: Date.now() - queryStartedAt,
-    rows: input.keys.length,
-    completed: rows.length,
-    cached: true,
-  });
-
-  const mapStartedAt = Date.now();
-  const mapped = mapRuntimeProjectedRows(rows, input.outputColumns);
-  input.timings?.push({
-    phase: 'cached_fast_path.map_projected_rows',
-    ms: Date.now() - mapStartedAt,
-    rows: mapped.length,
-    cached: true,
-  });
-  return mapped;
-}
-
 async function readRuntimeRowsByKey(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
@@ -2012,13 +1903,20 @@ async function readRuntimeSummary(
   );
   return await withRuntimePostgres(session, async (client) => {
     const { rows } = await client.query(
-      `SELECT total
+      `SELECT total, queued, running, completed, failed
        FROM ${summaryTable(session)}
        WHERE play_name = $1 AND table_namespace = $2
        LIMIT 1`,
       [normalizedPlayName, normalizedTableNamespace],
     );
-    return { stats: { total: Number(rows[0]?.total ?? 0) } };
+    const row = rows[0];
+    const total = Number(row?.total ?? 0);
+    const partitionTotal =
+      Number(row?.queued ?? 0) +
+      Number(row?.running ?? 0) +
+      Number(row?.completed ?? 0) +
+      Number(row?.failed ?? 0);
+    return { stats: { total: Math.max(total, partitionTotal) } };
   });
 }
 
@@ -2190,8 +2088,15 @@ async function writeRuntimeRows(
               FROM inserted_count_cte
              WHERE c > 0
             ON CONFLICT (play_name, table_namespace) DO UPDATE SET
-              total = ${summaryTable(session)}.total + EXCLUDED.total,
               queued = ${summaryTable(session)}.queued + EXCLUDED.queued,
+              total = ${runtimeSummaryTotalSql({
+                currentTotal: `${summaryTable(session)}.total`,
+                totalDelta: 'EXCLUDED.total',
+                queued: `${summaryTable(session)}.queued + EXCLUDED.queued`,
+                running: `${summaryTable(session)}.running`,
+                completed: `${summaryTable(session)}.completed`,
+                failed: `${summaryTable(session)}.failed`,
+              })},
               _updated_at = now()
             RETURNING 1
           )
@@ -2369,9 +2274,16 @@ async function prepareRuntimeSheetDatasetRows(
           FROM summary_counts
           WHERE inserted_count > 0 OR missing_output_count > 0
           ON CONFLICT (play_name, table_namespace) DO UPDATE SET
-            total = GREATEST(target.total + EXCLUDED.total, 0),
             queued = GREATEST(target.queued + EXCLUDED.queued, 0),
             completed = GREATEST(target.completed + EXCLUDED.completed, 0),
+            total = ${runtimeSummaryTotalSql({
+              currentTotal: 'target.total',
+              totalDelta: 'EXCLUDED.total',
+              queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
+              running: 'target.running',
+              completed: 'GREATEST(target.completed + EXCLUDED.completed, 0)',
+              failed: 'target.failed',
+            })},
             _updated_at = now()
           RETURNING 1
         )
@@ -2398,83 +2310,6 @@ async function prepareRuntimeSheetDatasetRows(
   return { inserted, pendingKeys };
 }
 
-async function tryPrepareRuntimeSheetDatasetRowsCachedOnly(
-  client: RuntimeQueryClient,
-  session: RuntimePostgresSession,
-  input: {
-    chunks: RuntimeDatasetRowEntry[][];
-    outputPhysicalColumns: string[];
-    timings?: RuntimeSheetTiming[];
-  },
-): Promise<{ prepared: { inserted: number; pendingKeys: string[] } | null }> {
-  const pendingKeys: string[] = [];
-  const startedAt = Date.now();
-  for (const chunk of input.chunks) {
-    const chunkKeys = chunk.map((entry) => entry.key);
-    const chunkInputIndexes = chunk.map((entry) => entry.inputIndex);
-    const existingMissingOutputSql = missingOutputCellSql(
-      'existing',
-      input.outputPhysicalColumns,
-    );
-    const { rows } = await client.query(
-      `
-        WITH input_rows AS (
-          SELECT DISTINCT ON (key_values._key)
-                 key_values._key, index_values._input_index
-          FROM unnest($1::text[]) WITH ORDINALITY AS key_values(_key, ord)
-          JOIN unnest($2::bigint[]) WITH ORDINALITY AS index_values(_input_index, ord)
-            ON index_values.ord = key_values.ord
-          ORDER BY key_values._key, key_values.ord
-        ),
-        existing_rows AS (
-          UPDATE ${sheetTable(session)} AS target
-          SET _input_index = input_rows._input_index,
-              _updated_at = now(),
-              _version = ${nextRuntimeSheetVersionExpression(session)}
-          FROM input_rows
-          WHERE target._key = input_rows._key
-            AND target._input_index IS DISTINCT FROM input_rows._input_index
-          RETURNING target._key
-        ),
-        pending_rows AS (
-          SELECT input_rows._key
-          FROM input_rows
-          LEFT JOIN ${sheetTable(session)} AS existing
-            ON existing._key = input_rows._key
-          WHERE existing._key IS NULL
-             OR existing._status IN ('pending', 'running', 'failed', 'stale')
-             OR (
-               existing._status = 'enriched'
-               AND (${existingMissingOutputSql})
-             )
-        )
-        SELECT
-          coalesce((SELECT array_agg(_key) FROM pending_rows), '{}'::text[]) AS pending_keys,
-          (SELECT count(*)::int FROM existing_rows) AS reordered_count
-      `,
-      [chunkKeys, chunkInputIndexes],
-    );
-    if (Array.isArray(rows[0]?.pending_keys)) {
-      pendingKeys.push(...(rows[0]?.pending_keys as string[]));
-    }
-  }
-  input.timings?.push({
-    phase:
-      pendingKeys.length === 0
-        ? 'cached_fast_path.prepare_probe'
-        : 'cached_fast_path.prepare_probe_fallback',
-    ms: Date.now() - startedAt,
-    rows: input.chunks.reduce((sum, chunk) => sum + chunk.length, 0),
-    chunks: input.chunks.length,
-    pending: pendingKeys.length,
-    cached: pendingKeys.length === 0,
-  });
-  if (pendingKeys.length > 0) {
-    return { prepared: null };
-  }
-  return { prepared: { inserted: 0, pendingKeys: [] } };
-}
-
 async function buildRuntimeSheetDatasetStartResult(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
@@ -2483,227 +2318,165 @@ async function buildRuntimeSheetDatasetStartResult(
     sourceRowsLength: number;
     rowEntries: RuntimeDatasetRowEntry[];
     sheetContract: PlaySheetContract;
+    normalizedPlayName: string;
+    normalizedTableNamespace: string;
     runId: string;
     inserted: number;
     pendingKeys: string[];
-    cellPolicies?: CellStalenessPolicyByField;
     timings?: RuntimeSheetTiming[];
   },
 ): Promise<PrepareRuntimeSheetResult> {
-  const outputFields = outputFieldsFromSheetContract(input.sheetContract);
-  const hasCellPolicies = cellPolicyFields(input.cellPolicies).length > 0;
-  if (input.pendingKeys.length === 0 && !hasCellPolicies) {
-    const fastPathStartedAt = Date.now();
-    const outputColumns = outputPhysicalSheetColumnProjections(
-      input.sheetContract,
-    );
-    const completedRowsByKey = new Map(
-      (
-        await markAndReadRuntimeCompletedRowsCachedProjection(client, session, {
-          tableNamespace: input.tableNamespace,
-          keys: input.rowEntries.map((entry) => entry.key),
-          runId: input.runId,
-          outputFields,
-          outputColumns,
-          timings: input.timings,
-        })
-      ).map((row) => [row.key, row.data]),
+  void input.pendingKeys;
+  if (input.inserted === input.rowEntries.length) {
+    const datasetFields = input.sheetContract.columns.flatMap((column) =>
+      column.source === 'datasetColumn' && typeof column.field === 'string'
+        ? [column.field]
+        : [],
     );
-    if (completedRowsByKey.size === input.rowEntries.length) {
-      await insertCachedRuntimeColumnSummaryDelta(client, session, {
-        tableNamespace: input.tableNamespace,
-        outputFields,
-        cached: completedRowsByKey.size,
-      });
-      input.timings?.push({
-        phase: 'cached_fast_path.total',
-        ms: Date.now() - fastPathStartedAt,
-        rows: input.rowEntries.length,
-        completed: completedRowsByKey.size,
-        cached: true,
-      });
-      return {
-        inserted: input.inserted,
-        skipped:
-          input.rowEntries.length -
-          input.inserted +
-          (input.sourceRowsLength - input.rowEntries.length),
-        pendingRows: [],
-        completedRows: input.rowEntries.map((entry) => ({
-          ...mergeRuntimeCompletedRow({
-            inputRow: entry.row,
-            completedData: stripRuntimeCellMeta(
-              completedRowsByKey.get(entry.key) ?? {},
-            ),
-            sheetContract: input.sheetContract,
-          }),
-          ...mapRowOutcomeRuntimeFields({ key: entry.key }),
-        })),
-        tableNamespace: input.tableNamespace,
-      };
-    }
-    input.timings?.push({
-      phase: 'cached_fast_path.fallback_incomplete',
-      ms: Date.now() - fastPathStartedAt,
-      rows: input.rowEntries.length,
-      completed: completedRowsByKey.size,
-      cached: true,
-    });
+    return {
+      inserted: input.inserted,
+      skipped: input.sourceRowsLength - input.rowEntries.length,
+      pendingRows: input.rowEntries.map((entry) => {
+        const row: Record<string, unknown> = {
+          ...sanitizePostgresJsonValue(entry.row),
+          __deeplineRowKey: entry.key,
+        };
+        for (const field of datasetFields) {
+          if (!Object.prototype.hasOwnProperty.call(row, field)) {
+            row[field] = null;
+          }
+        }
+        return row;
+      }),
+      completedRows: [],
+      tableNamespace: input.tableNamespace,
+    };
   }
-  const pendingKeySet = new Set(input.pendingKeys);
-  const initiallyPendingRows = input.rowEntries.filter((entry) =>
-    pendingKeySet.has(entry.key),
-  );
-  const initiallyCompletedEntries = input.rowEntries.filter(
-    (entry) => !pendingKeySet.has(entry.key),
-  );
-  const initiallyCompletedRows = await readRuntimeRowsByKey(
+
+  const startedAt = Date.now();
+  await markRuntimeRowsPendingForRecompute(client, session, {
+    keys: input.rowEntries.map((entry) => entry.key),
+    runId: input.runId,
+    normalizedPlayName: input.normalizedPlayName,
+    normalizedTableNamespace: input.normalizedTableNamespace,
+  });
+  const persistedPendingRows = await readRuntimeRowsByKey(
     client,
     session,
-    initiallyCompletedEntries.map((entry) => entry.key),
+    input.rowEntries.map((entry) => entry.key),
     input.sheetContract,
   );
-  const initiallyCompletedRowsByKey = new Map(
-    initiallyCompletedRows.map((row) => [row.key, row]),
-  );
-  const staleKeySet = new Set<string>();
-  for (const entry of initiallyCompletedEntries) {
-    const completedRow = initiallyCompletedRowsByKey.get(entry.key);
-    if (!completedRow) {
-      staleKeySet.add(entry.key);
-      continue;
-    }
-    const cellMeta =
-      completedRow.data[DEEPLINE_CELL_META_FIELD] &&
-      typeof completedRow.data[DEEPLINE_CELL_META_FIELD] === 'object'
-        ? (completedRow.data[DEEPLINE_CELL_META_FIELD] as Record<
-            string,
-            unknown
-          >)
-        : {};
-    for (const field of outputFields) {
-      const decision = shouldRecomputeCell({
-        hasValue:
-          Object.prototype.hasOwnProperty.call(completedRow.data, field) &&
-          completedRow.data[field] !== null &&
-          completedRow.data[field] !== undefined &&
-          !(
-            typeof completedRow.data[field] === 'string' &&
-            completedRow.data[field].length === 0
-          ),
-        value: completedRow.data[field],
-        meta:
-          cellMeta[field] && typeof cellMeta[field] === 'object'
-            ? (cellMeta[field] as {
-                status?: string;
-                completedAt?: number;
-                staleAt?: number | null;
-                staleAfterSeconds?: number | null;
-              })
-            : null,
-        policy: input.cellPolicies?.[field],
-      });
-      if (decision.action === 'recompute') {
-        staleKeySet.add(entry.key);
-        break;
-      }
-    }
-  }
-  const pendingRows = [
-    ...initiallyPendingRows,
-    ...initiallyCompletedEntries.filter((entry) => staleKeySet.has(entry.key)),
-  ];
-  if (staleKeySet.size > 0) {
-    await markRuntimeRowsPendingForCellStaleness(client, session, {
-      keys: [...staleKeySet],
-      runId: input.runId,
-    });
-  }
-  const completedKeys = initiallyCompletedEntries
-    .filter((entry) => !staleKeySet.has(entry.key))
-    .map((entry) => entry.key);
-  const existingPendingRowsByKey = new Map(
-    (
-      await readRuntimeRowsByKey(
-        client,
-        session,
-        pendingRows.map((entry) => entry.key),
-        input.sheetContract,
-      )
-    ).map((row) => [row.key, row.data]),
-  );
-  const completedRowsByKey = new Map(
-    (
-      await markAndReadRuntimeCompletedRowsCached(client, session, {
-        tableNamespace: input.tableNamespace,
-        keys: completedKeys,
-        runId: input.runId,
-        outputFields,
-        sheetContract: input.sheetContract,
-      })
-    ).map((row) => [row.key, row.data]),
+  const persistedRowsByKey = new Map(
+    persistedPendingRows.map((row) => [row.key, row.data]),
   );
-  const completedKeySet = new Set(completedKeys);
-  const completedRows = input.rowEntries
-    .filter((entry) => completedKeySet.has(entry.key))
-    .map((entry) => ({
-      ...mergeRuntimeCompletedRow({
-        inputRow: entry.row,
-        completedData: stripRuntimeCellMeta(
-          completedRowsByKey.get(entry.key) ?? {},
-        ),
-        sheetContract: input.sheetContract,
-      }),
-      ...mapRowOutcomeRuntimeFields({ key: entry.key }),
-    }));
+  input.timings?.push({
+    phase: 'mark_rows_pending_for_recompute',
+    ms: Date.now() - startedAt,
+    rows: input.rowEntries.length,
+  });
   return {
     inserted: input.inserted,
-    skipped:
-      completedKeys.length + (input.sourceRowsLength - input.rowEntries.length),
-    pendingRows: pendingRows.map((entry) => ({
-      ...mergeRuntimeCompletedRow({
-        inputRow: entry.row,
-        completedData: existingPendingRowsByKey.get(entry.key) ?? {},
-        sheetContract: input.sheetContract,
-      }),
-      ...mapRowOutcomeRuntimeFields({ key: entry.key }),
-    })),
-    completedRows,
+    skipped: input.sourceRowsLength - input.rowEntries.length,
+    pendingRows: input.rowEntries.map((entry) => {
+      const merged = { ...entry.row };
+      for (const [field, value] of Object.entries(
+        persistedRowsByKey.get(entry.key) ?? {},
+      )) {
+        if (
+          value !== null ||
+          !Object.prototype.hasOwnProperty.call(merged, field)
+        ) {
+          merged[field] = value;
+        }
+      }
+      return {
+        ...merged,
+        __deeplineRowKey: entry.key,
+      };
+    }),
+    completedRows: [],
     tableNamespace: input.tableNamespace,
   };
 }
 
-async function markRuntimeRowsPendingForCellStaleness(
+async function markRuntimeRowsPendingForRecompute(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
   input: {
     keys: string[];
     runId: string;
+    normalizedPlayName: string;
+    normalizedTableNamespace: string;
   },
 ): Promise<void> {
   if (input.keys.length === 0) return;
   await client.query(
-    `UPDATE ${sheetTable(session)} AS target
+    `WITH target_rows AS (
+       SELECT _key, _status
+         FROM ${sheetTable(session)}
+        WHERE _key = ANY($1::text[])
+        FOR UPDATE
+     ),
+     updated AS (
+       UPDATE ${sheetTable(session)} AS target
         SET _status = 'pending',
             _run_id = $2::text,
             _updated_at = now(),
             _version = ${nextRuntimeSheetVersionExpression(session)}
-      WHERE target._key = ANY($1::text[])`,
-    [input.keys, input.runId],
+        FROM target_rows
+      WHERE target._key = target_rows._key
+         AND (target._run_id IS NULL OR target._run_id <= $2::text)
+         AND (
+           target._status <> 'pending'
+           OR target._run_id IS DISTINCT FROM $2::text
+         )
+       RETURNING target_rows._status AS previous_status
+     ),
+     summary_counts AS (
+       SELECT
+         count(*) FILTER (WHERE previous_status = 'enriched')::int AS completed_to_pending,
+         count(*) FILTER (WHERE previous_status = 'failed')::int AS failed_to_pending,
+         count(*) FILTER (WHERE previous_status = 'running')::int AS running_to_pending
+       FROM updated
+     ),
+     summary_delta AS (
+       INSERT INTO ${summaryTable(session)} AS target (play_name, table_namespace, total, queued, running, completed, failed)
+       SELECT
+         $3::text,
+         $4::text,
+         0,
+         completed_to_pending + failed_to_pending + running_to_pending,
+         -running_to_pending,
+         -completed_to_pending,
+         -failed_to_pending
+       FROM summary_counts
+       WHERE completed_to_pending > 0 OR failed_to_pending > 0 OR running_to_pending > 0
+       ON CONFLICT (play_name, table_namespace) DO UPDATE SET
+         queued = GREATEST(target.queued + EXCLUDED.queued, 0),
+         running = GREATEST(target.running + EXCLUDED.running, 0),
+         completed = GREATEST(target.completed + EXCLUDED.completed, 0),
+         failed = GREATEST(target.failed + EXCLUDED.failed, 0),
+         total = ${runtimeSummaryTotalSql({
+           currentTotal: 'target.total',
+           totalDelta: 'EXCLUDED.total',
+           queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
+           running: 'GREATEST(target.running + EXCLUDED.running, 0)',
+           completed: 'GREATEST(target.completed + EXCLUDED.completed, 0)',
+           failed: 'GREATEST(target.failed + EXCLUDED.failed, 0)',
+         })},
+         _updated_at = now()
+       RETURNING 1
+     )
+     SELECT 1`,
+    [
+      input.keys,
+      input.runId,
+      input.normalizedPlayName,
+      input.normalizedTableNamespace,
+    ],
   );
 }
 
-function stripRuntimeCellMeta(
-  data: Record<string, unknown>,
-): Record<string, unknown> {
-  if (!Object.prototype.hasOwnProperty.call(data, DEEPLINE_CELL_META_FIELD)) {
-    return data;
-  }
-  const { [DEEPLINE_CELL_META_FIELD]: _cellMeta, ...publicData } = data;
-  void _cellMeta;
-  return publicData;
-}
-
 async function getRuntimeWorkReceiptSession(
   context: RuntimeApiContext,
   input: {
@@ -2737,6 +2510,27 @@ async function getRuntimeWorkReceiptSession(
   return session;
 }
 
+async function getRuntimeWorkReceiptSessionForKeys(
+  context: RuntimeApiContext,
+  input: {
+    playName: string;
+    keys: string[];
+  },
+): Promise<RuntimePostgresSession> {
+  const firstKey = input.keys.find((key) => key.trim());
+  if (!firstKey) {
+    throw new Error('Runtime work receipt batch requires at least one key.');
+  }
+  const session = await getRuntimeWorkReceiptSession(context, {
+    playName: input.playName,
+    key: firstKey,
+  });
+  for (const key of input.keys) {
+    validateRuntimeWorkReceiptKeyScope(session, { key });
+  }
+  return session;
+}
+
 async function readRuntimeWorkReceipt(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
@@ -2767,6 +2561,49 @@ export async function getRuntimeWorkReceipt(
   );
 }
 
+export async function getRuntimeWorkReceipts(
+  context: RuntimeApiContext,
+  input: {
+    playName: string;
+    keys: string[];
+  },
+): Promise<WorkReceipt[]> {
+  const keys = [
+    ...new Set(input.keys.map((key) => key.trim()).filter(Boolean)),
+  ];
+  if (keys.length === 0) return [];
+  const session = await getRuntimeWorkReceiptSessionForKeys(context, {
+    playName: input.playName,
+    keys,
+  });
+  return await withRuntimeWorkReceiptClient(
+    context,
+    session,
+    async (client) => {
+      const { rows } = await client.query<Record<string, unknown>>(
+        `
+      WITH input_keys AS (
+        SELECT key_values.key_hex, key_values.ord
+        FROM unnest($1::text[]) WITH ORDINALITY AS key_values(key_hex, ord)
+      )
+      SELECT convert_from(receipts.k, 'UTF8') AS k,
+             receipts.status,
+             receipts.output,
+             receipts.error,
+             receipts.run_id,
+             receipts.updated_at
+        FROM input_keys
+        JOIN ${workReceiptTable(session)} AS receipts
+          ON receipts.k = decode(input_keys.key_hex, 'hex')
+       ORDER BY input_keys.ord
+    `,
+        [keys.map(workReceiptKeyHex)],
+      );
+      return rows.map(mapRuntimeWorkReceiptRow);
+    },
+  );
+}
+
 export async function claimRuntimeWorkReceipt(
   context: RuntimeApiContext,
   input: {
@@ -2774,6 +2611,7 @@ export async function claimRuntimeWorkReceipt(
     runId: string;
     key: string;
     reclaimRunning?: boolean;
+    forceRefresh?: boolean;
   },
 ): Promise<WorkReceiptClaim> {
   const session = await getRuntimeWorkReceiptSession(context, {
@@ -2784,6 +2622,21 @@ export async function claimRuntimeWorkReceipt(
     context,
     session,
     async (client) => {
+      const claimableStatuses = input.forceRefresh
+        ? [
+            RECEIPT_STATUS_PENDING,
+            RECEIPT_STATUS_FAILED,
+            RECEIPT_STATUS_RUNNING,
+            RECEIPT_STATUS_COMPLETED,
+            RECEIPT_STATUS_SKIPPED,
+          ]
+        : input.reclaimRunning
+          ? [
+              RECEIPT_STATUS_PENDING,
+              RECEIPT_STATUS_FAILED,
+              RECEIPT_STATUS_RUNNING,
+            ]
+          : [RECEIPT_STATUS_PENDING, RECEIPT_STATUS_FAILED];
       const { rows } = await client.query<Record<string, unknown>>(
         `
         WITH claimed AS (
@@ -2795,7 +2648,7 @@ export async function claimRuntimeWorkReceipt(
               run_id = $3,
               error = NULL,
               updated_at = now()
-          WHERE ${workReceiptTable(session)}.status IN ($5::smallint, $6::smallint)
+          WHERE ${workReceiptTable(session)}.status = ANY($5::smallint[])
           RETURNING convert_from(k, 'UTF8') AS k, status, output, error, run_id, updated_at
         )
         SELECT k, status, output, error, run_id, updated_at
@@ -2806,8 +2659,7 @@ export async function claimRuntimeWorkReceipt(
           RECEIPT_STATUS_RUNNING,
           input.runId,
           RECEIPT_STATUS_RUNNING,
-          RECEIPT_STATUS_PENDING,
-          RECEIPT_STATUS_FAILED,
+          claimableStatuses,
         ],
       );
       const claimed = rows[0] ? mapRuntimeWorkReceiptRow(rows[0]) : null;
@@ -2832,6 +2684,132 @@ export async function claimRuntimeWorkReceipt(
   );
 }
 
+export async function claimRuntimeWorkReceipts(
+  context: RuntimeApiContext,
+  input: {
+    playName: string;
+    runId: string;
+    keys: string[];
+    reclaimRunning?: boolean;
+    forceRefresh?: boolean;
+  },
+): Promise<WorkReceiptClaim[]> {
+  const keys = [
+    ...new Set(input.keys.map((key) => key.trim()).filter(Boolean)),
+  ];
+  if (keys.length === 0) return [];
+  const session = await getRuntimeWorkReceiptSessionForKeys(context, {
+    playName: input.playName,
+    keys,
+  });
+  return await withRuntimeWorkReceiptClient(
+    context,
+    session,
+    async (client) => {
+      const keyHexes = keys.map(workReceiptKeyHex);
+      const reclaimStatuses = input.forceRefresh
+        ? [
+            RECEIPT_STATUS_PENDING,
+            RECEIPT_STATUS_FAILED,
+            RECEIPT_STATUS_RUNNING,
+            RECEIPT_STATUS_COMPLETED,
+            RECEIPT_STATUS_SKIPPED,
+          ]
+        : input.reclaimRunning
+          ? [
+              RECEIPT_STATUS_PENDING,
+              RECEIPT_STATUS_FAILED,
+              RECEIPT_STATUS_RUNNING,
+            ]
+          : [RECEIPT_STATUS_PENDING, RECEIPT_STATUS_FAILED];
+      const { rows } = await client.query<Record<string, unknown>>(
+        `
+      WITH input_keys AS (
+        SELECT key_values.key_hex, key_values.ord
+        FROM unnest($1::text[]) WITH ORDINALITY AS key_values(key_hex, ord)
+      ),
+      claimed AS (
+        INSERT INTO ${workReceiptTable(session)} (k, status, run_id, updated_at)
+        SELECT decode(input_keys.key_hex, 'hex'), $2::smallint, $3::text, now()
+          FROM input_keys
+        ON CONFLICT (k) DO UPDATE
+        SET status = $4::smallint,
+            output = NULL,
+            run_id = $3::text,
+            error = NULL,
+            updated_at = now()
+        WHERE ${workReceiptTable(session)}.status = ANY($5::smallint[])
+        RETURNING k, status, output, error, run_id, updated_at
+      ),
+      latest AS (
+        SELECT receipts.k,
+               receipts.status,
+               receipts.output,
+               receipts.error,
+               receipts.run_id,
+               receipts.updated_at,
+               input_keys.ord,
+               false AS claimed
+          FROM input_keys
+          JOIN ${workReceiptTable(session)} AS receipts
+            ON receipts.k = decode(input_keys.key_hex, 'hex')
+         WHERE NOT EXISTS (
+           SELECT 1 FROM claimed WHERE claimed.k = receipts.k
+         )
+      ),
+      returned AS (
+        SELECT claimed.k,
+               claimed.status,
+               claimed.output,
+               claimed.error,
+               claimed.run_id,
+               claimed.updated_at,
+               input_keys.ord,
+               true AS claimed
+          FROM claimed
+          JOIN input_keys ON claimed.k = decode(input_keys.key_hex, 'hex')
+        UNION ALL
+        SELECT k, status, output, error, run_id, updated_at, ord, claimed
+          FROM latest
+      )
+      SELECT convert_from(k, 'UTF8') AS k,
+             status,
+             output,
+             error,
+             run_id,
+             updated_at,
+             claimed
+        FROM returned
+       ORDER BY ord
+    `,
+        [
+          keyHexes,
+          RECEIPT_STATUS_RUNNING,
+          input.runId,
+          RECEIPT_STATUS_RUNNING,
+          reclaimStatuses,
+        ],
+      );
+      return rows.map((row) => {
+        const receipt = mapRuntimeWorkReceiptRow(row);
+        if (row.claimed === true) {
+          return { disposition: 'claimed', receipt } satisfies WorkReceiptClaim;
+        }
+        if (isReusableWorkReceipt(receipt)) {
+          return { disposition: 'reused', receipt } satisfies WorkReceiptClaim;
+        }
+        if (receipt.status === 'running') {
+          return { disposition: 'running', receipt } satisfies WorkReceiptClaim;
+        }
+        if (receipt.status === 'failed') {
+          return { disposition: 'failed', receipt } satisfies WorkReceiptClaim;
+        }
+        return { disposition: 'running', receipt } satisfies WorkReceiptClaim;
+      });
+    },
+  );
+}
+
 export async function completeRuntimeWorkReceipt(
   context: RuntimeApiContext,
   input: {
@@ -2859,7 +2837,8 @@ export async function completeRuntimeWorkReceipt(
               run_id = $4,
               updated_at = now()
           WHERE k = decode($1, 'hex')
-            AND (run_id IS NULL OR run_id <= $4)
+            AND status = $5::smallint
+            AND run_id = $4
           RETURNING convert_from(k, 'UTF8') AS k, status, output, error, run_id, updated_at
         ),
         latest AS (
@@ -2877,6 +2856,7 @@ export async function completeRuntimeWorkReceipt(
           RECEIPT_STATUS_COMPLETED,
           input.output === null ? null : stringifyPostgresJson(input.output),
           input.runId,
+          RECEIPT_STATUS_RUNNING,
         ],
       );
       return rows[0] ? mapRuntimeWorkReceiptRow(rows[0]) : null;
@@ -2884,6 +2864,95 @@ export async function completeRuntimeWorkReceipt(
   );
 }
 
+export async function completeRuntimeWorkReceipts(
+  context: RuntimeApiContext,
+  input: {
+    playName: string;
+    receipts: Array<{ runId: string; key: string; output: unknown }>;
+  },
+): Promise<WorkReceipt[]> {
+  const receipts = input.receipts.filter((receipt) => receipt.key.trim());
+  if (receipts.length === 0) return [];
+  const session = await getRuntimeWorkReceiptSessionForKeys(context, {
+    playName: input.playName,
+    keys: receipts.map((receipt) => receipt.key),
+  });
+  return await withRuntimeWorkReceiptClient(
+    context,
+    session,
+    async (client) => {
+      const { rows } = await client.query<Record<string, unknown>>(
+        `
+      WITH inputs AS (
+        SELECT key_values.key_hex,
+               run_values.run_id,
+               output_values.output,
+               key_values.ord
+          FROM unnest($1::text[]) WITH ORDINALITY AS key_values(key_hex, ord)
+          JOIN unnest($2::text[]) WITH ORDINALITY AS run_values(run_id, ord)
+            ON run_values.ord = key_values.ord
+          JOIN jsonb_array_elements($3::jsonb) WITH ORDINALITY AS output_values(output, ord)
+            ON output_values.ord = key_values.ord
+      ),
+      completed AS (
+        UPDATE ${workReceiptTable(session)} AS target
+           SET status = $4::smallint,
+               output = inputs.output,
+               error = NULL,
+               run_id = inputs.run_id,
+               updated_at = now()
+          FROM inputs
+         WHERE target.k = decode(inputs.key_hex, 'hex')
+           AND target.status = $5::smallint
+           AND target.run_id = inputs.run_id
+        RETURNING target.k, target.status, target.output, target.error, target.run_id, target.updated_at, inputs.ord
+      ),
+      latest AS (
+        SELECT receipts.k,
+               receipts.status,
+               receipts.output,
+               receipts.error,
+               receipts.run_id,
+               receipts.updated_at,
+               inputs.ord
+          FROM inputs
+          JOIN ${workReceiptTable(session)} AS receipts
+            ON receipts.k = decode(inputs.key_hex, 'hex')
+         WHERE NOT EXISTS (
+           SELECT 1 FROM completed WHERE completed.k = receipts.k
+         )
+      ),
+      returned AS (
+        SELECT k, status, output, error, run_id, updated_at, ord FROM completed
+        UNION ALL
+        SELECT k, status, output, error, run_id, updated_at, ord FROM latest
+      )
+      SELECT convert_from(returned.k, 'UTF8') AS k,
+             returned.status,
+             returned.output,
+             returned.error,
+             returned.run_id,
+             returned.updated_at
+        FROM returned
+       ORDER BY returned.ord
+    `,
+        [
+          receipts.map((receipt) => workReceiptKeyHex(receipt.key)),
+          receipts.map((receipt) => receipt.runId),
+          stringifyPostgresJson(
+            receipts.map((receipt) =>
+              receipt.output === null ? null : receipt.output,
+            ),
+          ),
+          RECEIPT_STATUS_COMPLETED,
+          RECEIPT_STATUS_RUNNING,
+        ],
+      );
+      return rows.map(mapRuntimeWorkReceiptRow);
+    },
+  );
+}
+
 export async function failRuntimeWorkReceipt(
   context: RuntimeApiContext,
   input: {
@@ -2911,9 +2980,8 @@ export async function failRuntimeWorkReceipt(
               run_id = $4,
               updated_at = now()
           WHERE k = decode($1, 'hex')
-            AND status <> $5::smallint
-            AND status <> $6::smallint
-            AND (run_id IS NULL OR run_id <= $4)
+            AND status = $5::smallint
+            AND run_id = $4
           RETURNING convert_from(k, 'UTF8') AS k, status, output, error, run_id, updated_at
         ),
         latest AS (
@@ -2931,8 +2999,7 @@ export async function failRuntimeWorkReceipt(
           RECEIPT_STATUS_FAILED,
           input.error,
           input.runId,
-          RECEIPT_STATUS_COMPLETED,
-          RECEIPT_STATUS_SKIPPED,
+          RECEIPT_STATUS_RUNNING,
         ],
       );
       return rows[0] ? mapRuntimeWorkReceiptRow(rows[0]) : null;
@@ -2940,6 +3007,91 @@ export async function failRuntimeWorkReceipt(
   );
 }
 
+export async function failRuntimeWorkReceipts(
+  context: RuntimeApiContext,
+  input: {
+    playName: string;
+    receipts: Array<{ runId: string; key: string; error: string }>;
+  },
+): Promise<WorkReceipt[]> {
+  const receipts = input.receipts.filter((receipt) => receipt.key.trim());
+  if (receipts.length === 0) return [];
+  const session = await getRuntimeWorkReceiptSessionForKeys(context, {
+    playName: input.playName,
+    keys: receipts.map((receipt) => receipt.key),
+  });
+  return await withRuntimeWorkReceiptClient(
+    context,
+    session,
+    async (client) => {
+      const { rows } = await client.query<Record<string, unknown>>(
+        `
+      WITH inputs AS (
+        SELECT key_values.key_hex,
+               run_values.run_id,
+               error_values.error,
+               key_values.ord
+          FROM unnest($1::text[]) WITH ORDINALITY AS key_values(key_hex, ord)
+          JOIN unnest($2::text[]) WITH ORDINALITY AS run_values(run_id, ord)
+            ON run_values.ord = key_values.ord
+          JOIN unnest($3::text[]) WITH ORDINALITY AS error_values(error, ord)
+            ON error_values.ord = key_values.ord
+      ),
+      failed AS (
+        UPDATE ${workReceiptTable(session)} AS target
+           SET status = $4::smallint,
+               output = NULL,
+               error = inputs.error,
+               run_id = inputs.run_id,
+               updated_at = now()
+          FROM inputs
+         WHERE target.k = decode(inputs.key_hex, 'hex')
+           AND target.status = $5::smallint
+           AND target.run_id = inputs.run_id
+        RETURNING target.k, target.status, target.output, target.error, target.run_id, target.updated_at, inputs.ord
+      ),
+      latest AS (
+        SELECT receipts.k,
+               receipts.status,
+               receipts.output,
+               receipts.error,
+               receipts.run_id,
+               receipts.updated_at,
+               inputs.ord
+          FROM inputs
+          JOIN ${workReceiptTable(session)} AS receipts
+            ON receipts.k = decode(inputs.key_hex, 'hex')
+         WHERE NOT EXISTS (
+           SELECT 1 FROM failed WHERE failed.k = receipts.k
+         )
+      ),
+      returned AS (
+        SELECT k, status, output, error, run_id, updated_at, ord FROM failed
+        UNION ALL
+        SELECT k, status, output, error, run_id, updated_at, ord FROM latest
+      )
+      SELECT convert_from(returned.k, 'UTF8') AS k,
+             returned.status,
+             returned.output,
+             returned.error,
+             returned.run_id,
+             returned.updated_at
+        FROM returned
+       ORDER BY returned.ord
+    `,
+        [
+          receipts.map((receipt) => workReceiptKeyHex(receipt.key)),
+          receipts.map((receipt) => receipt.runId),
+          receipts.map((receipt) => receipt.error),
+          RECEIPT_STATUS_FAILED,
+          RECEIPT_STATUS_RUNNING,
+        ],
+      );
+      return rows.map(mapRuntimeWorkReceiptRow);
+    },
+  );
+}
+
 export async function skipRuntimeWorkReceipt(
   context: RuntimeApiContext,
   input: {
@@ -2967,7 +3119,8 @@ export async function skipRuntimeWorkReceipt(
               run_id = $4,
               updated_at = now()
           WHERE k = decode($1, 'hex')
-            AND (run_id IS NULL OR run_id <= $4)
+            AND status = $5::smallint
+            AND run_id = $4
           RETURNING convert_from(k, 'UTF8') AS k, status, output, error, run_id, updated_at
         ),
         latest AS (
@@ -2985,6 +3138,7 @@ export async function skipRuntimeWorkReceipt(
           RECEIPT_STATUS_SKIPPED,
           input.output === null ? null : stringifyPostgresJson(input.output),
           input.runId,
+          RECEIPT_STATUS_RUNNING,
         ],
       );
       return rows[0] ? mapRuntimeWorkReceiptRow(rows[0]) : null;
@@ -3002,7 +3156,6 @@ export async function startRuntimeSheetDataset(
     rows: Record<string, unknown>[];
     runId: string;
     inputOffset?: number;
-    cellPolicies?: CellStalenessPolicyByField;
   },
 ): Promise<PrepareRuntimeSheetResult> {
   const totalStartedAt = Date.now();
@@ -3115,25 +3268,15 @@ export async function startRuntimeSheetDataset(
     },
     async (client) => {
       const prepareStartedAt = Date.now();
-      const hasCellPolicies = cellPolicyFields(input.cellPolicies).length > 0;
-      const cachedProbe = hasCellPolicies
-        ? { prepared: null }
-        : await tryPrepareRuntimeSheetDatasetRowsCachedOnly(client, session, {
-            chunks,
-            outputPhysicalColumns,
-            timings,
-          });
-      const prepared =
-        cachedProbe.prepared ??
-        (await prepareRuntimeSheetDatasetRows(client, session, {
-          chunks,
-          runId: input.runId,
-          normalizedPlayName,
-          normalizedTableNamespace,
-          physicalInsertColumnsSql,
-          physicalInsertValuesSql,
-          outputPhysicalColumns,
-        }));
+      const prepared = await prepareRuntimeSheetDatasetRows(client, session, {
+        chunks,
+        runId: input.runId,
+        normalizedPlayName,
+        normalizedTableNamespace,
+        physicalInsertColumnsSql,
+        physicalInsertValuesSql,
+        outputPhysicalColumns,
+      });
       timings.push({
         phase: 'prepare_rows_sql',
         ms: Date.now() - prepareStartedAt,
@@ -3148,8 +3291,9 @@ export async function startRuntimeSheetDataset(
         sourceRowsLength: input.rows.length,
         rowEntries,
         sheetContract: input.sheetContract,
+        normalizedPlayName,
+        normalizedTableNamespace,
         runId: input.runId,
-        cellPolicies: input.cellPolicies,
         timings,
         ...prepared,
       });
@@ -3178,18 +3322,217 @@ export async function startRuntimeSheetDataset(
   return { ...result, timings };
 }
 
+type CompleteRuntimeMapRowChunksInput = {
+  chunks: RuntimePreparedCompletedRow[][];
+  physicalUpdateSetSql: string;
+  physicalColumnProjections: PhysicalSheetColumnProjection[];
+  runId: string;
+  normalizedPlayName: string;
+  normalizedTableNamespace: string;
+  outputFields: string[];
+};
+
 async function completeRuntimeMapRowChunks(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
-  input: {
-    chunks: RuntimePreparedCompletedRow[][];
-    physicalUpdateSetSql: string;
-    physicalColumnProjections: PhysicalSheetColumnProjection[];
-    runId: string;
-    normalizedPlayName: string;
-    normalizedTableNamespace: string;
-    outputFields: string[];
-  },
+  input: CompleteRuntimeMapRowChunksInput,
+): Promise<{ updated: number }> {
+  let updated = 0;
+  for (const chunk of input.chunks) {
+    const chunkKeys = chunk.map((row) => row.key);
+    const chunkInputIndexes = chunk.map((row) => row.input_index);
+    const chunkDataPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.data_patch),
+    );
+    const chunkCellMetaPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.cell_meta_patch),
+    );
+    const targetChangedPatchedCellSql = changedPatchedCellSql(
+      'target',
+      'updates.data_patch',
+      input.physicalColumnProjections,
+    );
+    const { rows } = await client.query<{
+      updated: number;
+      matched_keys: string[];
+    }>(
+      `WITH updates AS (
+         SELECT key_values._key,
+                input_index_values.input_index,
+                data_values.data_patch,
+                cell_meta_values.cell_meta_patch
+         FROM unnest($1::text[]) WITH ORDINALITY AS key_values(_key, ord)
+         JOIN unnest($2::bigint[]) WITH ORDINALITY AS input_index_values(input_index, ord)
+           ON input_index_values.ord = key_values.ord
+         JOIN unnest($3::jsonb[]) WITH ORDINALITY AS data_values(data_patch, ord)
+           ON data_values.ord = key_values.ord
+         JOIN unnest($4::jsonb[]) WITH ORDINALITY AS cell_meta_values(cell_meta_patch, ord)
+           ON cell_meta_values.ord = key_values.ord
+       ),
+       matched_updates AS (
+         SELECT target._key AS matched_key,
+                target._status AS prev_status,
+                target._cell_meta AS prev_cell_meta,
+                updates.input_index,
+                updates.data_patch,
+                updates.cell_meta_patch
+           FROM updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates._key
+       ),
+       applied_rows AS (
+         UPDATE ${sheetTable(session)} AS target
+         SET _status = 'enriched',
+             _run_id = $5::text,
+             _error = NULL,
+             _updated_at = now(),
+             _version = ${nextRuntimeSheetVersionExpression(session)},
+             _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
+         FROM matched_updates AS updates
+         WHERE target._key = updates.matched_key
+           AND (target._run_id IS NULL OR target._run_id <= $5::text)
+           AND (
+             target._status <> 'enriched'
+             OR (${targetChangedPatchedCellSql})
+             OR EXISTS (
+               SELECT 1
+                 FROM unnest($8::text[]) AS field_values(field)
+                WHERE coalesce(target._cell_meta -> field_values.field ->> 'status', '') <> 'completed'
+             )
+           )
+         RETURNING target._key, updates.prev_status, updates.prev_cell_meta
+       ),
+       applied_count AS (
+         SELECT count(*)::bigint AS c,
+                count(*) FILTER (WHERE prev_status = 'failed')::bigint AS from_failed,
+                count(*) FILTER (WHERE prev_status = 'running')::bigint AS from_running,
+                count(*) FILTER (WHERE prev_status <> 'enriched')::bigint AS newly_completed
+           FROM applied_rows
+       ),
+       summary_counts AS (
+         SELECT newly_completed,
+                from_failed,
+                from_running,
+                GREATEST(newly_completed - from_failed - from_running, 0)::bigint AS from_queued
+           FROM applied_count
+       ),
+       summary_delta AS (
+         INSERT INTO ${summaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           total,
+           queued,
+           running,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                0,
+                (-from_queued)::int,
+                (-from_running)::int,
+                newly_completed::int,
+                (-from_failed)::int
+           FROM summary_counts
+          WHERE newly_completed > 0 OR from_failed > 0
+         ON CONFLICT (play_name, table_namespace) DO UPDATE SET
+           queued = GREATEST(target.queued + EXCLUDED.queued, 0),
+           running = GREATEST(target.running + EXCLUDED.running, 0),
+           completed = GREATEST(target.completed + EXCLUDED.completed, 0),
+           failed = GREATEST(target.failed + EXCLUDED.failed, 0),
+           total = ${runtimeSummaryTotalSql({
+             currentTotal: 'target.total',
+             totalDelta: 'EXCLUDED.total',
+             queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
+             running: 'GREATEST(target.running + EXCLUDED.running, 0)',
+             completed: 'GREATEST(target.completed + EXCLUDED.completed, 0)',
+             failed: 'GREATEST(target.failed + EXCLUDED.failed, 0)',
+           })},
+           _updated_at = now()
+         RETURNING 1
+       ),
+       completed_cell_delta AS (
+         SELECT field_values.field, count(*)::bigint AS c
+           FROM applied_rows
+           JOIN unnest($8::text[]) AS field_values(field)
+             ON applied_rows.prev_status <> 'enriched'
+             OR coalesce(applied_rows.prev_cell_meta -> field_values.field ->> 'status', '') <> 'completed'
+          GROUP BY field_values.field
+       ),
+       prev_failed_cells AS (
+         SELECT field_values.field, count(*)::bigint AS c
+           FROM applied_rows
+           JOIN unnest($8::text[]) AS field_values(field)
+             ON coalesce(applied_rows.prev_cell_meta -> field_values.field ->> 'status', '') = 'failed'
+          GROUP BY field_values.field
+       ),
+       column_delta AS (
+         INSERT INTO ${columnSummaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           field,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                coalesce(completed_cell_delta.field, prev_failed_cells.field),
+                coalesce(completed_cell_delta.c, 0)::int,
+                (-coalesce(prev_failed_cells.c, 0))::int
+           FROM completed_cell_delta
+           FULL JOIN prev_failed_cells
+             ON prev_failed_cells.field = completed_cell_delta.field
+          WHERE coalesce(completed_cell_delta.c, 0) > 0
+             OR coalesce(prev_failed_cells.c, 0) > 0
+         ON CONFLICT (play_name, table_namespace, field) DO UPDATE SET
+           completed = GREATEST(target.completed + EXCLUDED.completed, 0),
+           failed = GREATEST(target.failed + EXCLUDED.failed, 0),
+           _updated_at = now()
+         RETURNING 1
+       )
+       SELECT
+         (SELECT count(*)::int FROM applied_rows) AS updated,
+         coalesce((SELECT array_agg(matched_key) FROM matched_updates), '{}'::text[]) AS matched_keys,
+         (SELECT count(*)::int FROM summary_delta) AS summary_delta_count,
+         (SELECT count(*)::int FROM column_delta) AS column_delta_count`,
+      [
+        chunkKeys,
+        chunkInputIndexes,
+        chunkDataPatches,
+        chunkCellMetaPatches,
+        input.runId,
+        input.normalizedPlayName,
+        input.normalizedTableNamespace,
+        [...new Set(input.outputFields)],
+      ],
+    );
+    updated += Number(rows[0]?.updated ?? 0);
+
+    const matchedKeys = new Set(rows[0]?.matched_keys ?? []);
+    if (matchedKeys.size === chunk.length) {
+      continue;
+    }
+
+    const repairChunk = chunk.filter(
+      (row) => !matchedKeys.has(row.key) && row.input_index !== null,
+    );
+    if (repairChunk.length === 0) {
+      continue;
+    }
+    const repaired = await completeRuntimeMapRowChunksWithInputIndexRepair(
+      client,
+      session,
+      { ...input, chunks: [repairChunk] },
+    );
+    updated += repaired.updated;
+  }
+  return { updated };
+}
+
+async function completeRuntimeMapRowChunksWithInputIndexRepair(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  input: CompleteRuntimeMapRowChunksInput,
 ): Promise<{ updated: number }> {
   let updated = 0;
   for (const chunk of input.chunks) {
@@ -3261,9 +3604,17 @@ async function completeRuntimeMapRowChunks(
        applied_count AS (
          SELECT count(*)::bigint AS c,
                 count(*) FILTER (WHERE prev_status = 'failed')::bigint AS from_failed,
+                count(*) FILTER (WHERE prev_status = 'running')::bigint AS from_running,
                 count(*) FILTER (WHERE prev_status <> 'enriched')::bigint AS newly_completed
            FROM applied_rows
        ),
+       summary_counts AS (
+         SELECT newly_completed,
+                from_failed,
+                from_running,
+                GREATEST(newly_completed - from_failed - from_running, 0)::bigint AS from_queued
+           FROM applied_count
+       ),
        summary_delta AS (
          INSERT INTO ${summaryTable(session)} AS target (
            play_name,
@@ -3274,13 +3625,28 @@ async function completeRuntimeMapRowChunks(
            completed,
            failed
          )
-         SELECT $6::text, $7::text, 0, 0, 0, newly_completed::int, (-from_failed)::int
-           FROM applied_count
+         SELECT $6::text,
+                $7::text,
+                0,
+                (-from_queued)::int,
+                (-from_running)::int,
+                newly_completed::int,
+                (-from_failed)::int
+           FROM summary_counts
           WHERE newly_completed > 0 OR from_failed > 0
          ON CONFLICT (play_name, table_namespace) DO UPDATE SET
-           queued = GREATEST(target.queued - (EXCLUDED.completed + EXCLUDED.failed), 0),
+           queued = GREATEST(target.queued + EXCLUDED.queued, 0),
+           running = GREATEST(target.running + EXCLUDED.running, 0),
            completed = GREATEST(target.completed + EXCLUDED.completed, 0),
            failed = GREATEST(target.failed + EXCLUDED.failed, 0),
+           total = ${runtimeSummaryTotalSql({
+             currentTotal: 'target.total',
+             totalDelta: 'EXCLUDED.total',
+             queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
+             running: 'GREATEST(target.running + EXCLUDED.running, 0)',
+             completed: 'GREATEST(target.completed + EXCLUDED.completed, 0)',
+             failed: 'GREATEST(target.failed + EXCLUDED.failed, 0)',
+           })},
            _updated_at = now()
          RETURNING 1
        ),
@@ -3441,9 +3807,16 @@ async function failRuntimeMapRowChunks(
        ),
        applied_count AS (
          SELECT count(*)::bigint AS c,
-                count(*) FILTER (WHERE prev_status = 'failed')::bigint AS already_failed
+                count(*) FILTER (WHERE prev_status = 'failed')::bigint AS already_failed,
+                count(*) FILTER (WHERE prev_status = 'running')::bigint AS from_running
            FROM applied_rows
        ),
+       summary_counts AS (
+         SELECT (c - already_failed)::bigint AS newly_failed,
+                from_running,
+                GREATEST(c - already_failed - from_running, 0)::bigint AS from_queued
+           FROM applied_count
+       ),
        summary_delta AS (
          INSERT INTO ${summaryTable(session)} AS target (
            play_name,
@@ -3454,12 +3827,27 @@ async function failRuntimeMapRowChunks(
            completed,
            failed
          )
-         SELECT $7::text, $8::text, 0, 0, 0, 0, (c - already_failed)::int
-           FROM applied_count
-          WHERE c > 0
+         SELECT $7::text,
+                $8::text,
+                0,
+                (-from_queued)::int,
+                (-from_running)::int,
+                0,
+                newly_failed::int
+           FROM summary_counts
+          WHERE newly_failed > 0
          ON CONFLICT (play_name, table_namespace) DO UPDATE SET
-           queued = GREATEST(target.queued - EXCLUDED.failed, 0),
+           queued = GREATEST(target.queued + EXCLUDED.queued, 0),
+           running = GREATEST(target.running + EXCLUDED.running, 0),
            failed = GREATEST(target.failed + EXCLUDED.failed, 0),
+           total = ${runtimeSummaryTotalSql({
+             currentTotal: 'target.total',
+             totalDelta: 'EXCLUDED.total',
+             queued: 'GREATEST(target.queued + EXCLUDED.queued, 0)',
+             running: 'GREATEST(target.running + EXCLUDED.running, 0)',
+             completed: 'target.completed',
+             failed: 'GREATEST(target.failed + EXCLUDED.failed, 0)',
+           })},
            _updated_at = now()
          RETURNING 1
        ),