deepline 0.3.200 → 0.3.202

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

@@ -88,7 +88,6 @@ import {
   activeRuntimeSheetAttemptFenceSql,
   newerTerminalRuntimeSheetRowSql,
   releasableRuntimeSheetAttemptFenceSql,
-  sameOwnerTerminalAttemptEpochSql,
 } from './sheet-attempt-sql';
 import type { MapRowOutcome } from './durability-store';
 import { RUNTIME_CAPACITY_POLICY } from './runtime-capacity-policy';
@@ -3688,7 +3687,9 @@ async function prepareRuntimeSheetDatasetRows(
           ORDER BY key_values._key, key_values.ord
        ),
        preexisting_rows AS (
-          SELECT target._key
+          -- Force is new intent across runs, not across scheduler attempts of
+          -- one run. Capture the owner before versioned updates restamp it.
+          SELECT target._key, target._run_id
           FROM ${sheetTable(session)} AS target
           JOIN input_rows ON input_rows._key = target._key
        ),
@@ -3705,7 +3706,7 @@ async function prepareRuntimeSheetDatasetRows(
             AND target._status = 'enriched'
             AND COALESCE(target._write_version, 0) < $12::bigint
           RETURNING target._key,
-                    ($11::boolean OR (${targetMissingOutputSql})) AS needs_recompute
+                    (${targetMissingOutputSql}) AS missing_output
        ),
        versioned_failed_rows AS (
           UPDATE ${sheetTable(session)} AS target
@@ -3750,7 +3751,13 @@ async function prepareRuntimeSheetDatasetRows(
               )
             )
             AND (
-              $11::boolean
+              (
+                $11::boolean
+                AND (
+                  target._status <> 'enriched'
+                  OR target._run_id IS DISTINCT FROM $4::text
+                )
+              )
               OR target._input_index IS DISTINCT FROM input_rows._input_index
             )
           RETURNING target._key
@@ -3856,13 +3863,20 @@ async function prepareRuntimeSheetDatasetRows(
           SELECT _key
           FROM claimed_existing_rows
           UNION
-          SELECT _key
+          SELECT existing_rows._key
           FROM existing_rows
+          JOIN preexisting_rows USING (_key)
           WHERE $11::boolean
+            AND preexisting_rows._run_id IS DISTINCT FROM $4::text
           UNION
-          SELECT _key
-          FROM versioned_completed_rows
-          WHERE needs_recompute
+          SELECT completed._key
+          FROM versioned_completed_rows AS completed
+          JOIN preexisting_rows USING (_key)
+          WHERE completed.missing_output
+            OR (
+              $11::boolean
+              AND preexisting_rows._run_id IS DISTINCT FROM $4::text
+            )
           UNION
           SELECT _key FROM versioned_failed_rows
           UNION
@@ -3901,14 +3915,23 @@ async function prepareRuntimeSheetDatasetRows(
           FROM ${sheetTable(session)} AS existing
           JOIN input_rows ON input_rows._key = existing._key
           WHERE existing._status = 'enriched'
-            AND NOT ($11::boolean)
+            AND (
+              NOT ($11::boolean)
+              OR existing._run_id = $4::text
+            )
             AND NOT (${existingMissingOutputSql})
             AND NOT EXISTS (
               SELECT 1 FROM pending_rows WHERE pending_rows._key = existing._key
             )
           UNION
-          SELECT _key FROM versioned_completed_rows
-          WHERE NOT needs_recompute
+          SELECT completed._key
+          FROM versioned_completed_rows AS completed
+          JOIN preexisting_rows USING (_key)
+          WHERE NOT completed.missing_output
+            AND (
+              NOT ($11::boolean)
+              OR preexisting_rows._run_id = $4::text
+            )
         ),
         blocked_rows AS (
           SELECT input_rows._key
@@ -4217,12 +4240,42 @@ async function buildRuntimeSheetDatasetStartResult(
     });
   }
   if (input.force === true) {
+    // A force flag expresses a new refresh only across runs. A scheduler
+    // resume of that same forced run must return its completed siblings with
+    // their durable output, while pending rows still start from fresh input.
+    const completedKeys = input.rowEntries.flatMap((entry) =>
+      dispositionsByKey.get(entry.key) === 'completed' ? [entry.key] : [],
+    );
+    const completedData = completedKeys.length
+      ? await readRuntimeRowsByKey(
+          client,
+          session,
+          completedKeys,
+          input.sheetContract,
+        )
+      : [];
+    const completedDataByKey = new Map(
+      completedData.map((row) => [row.key, row.data]),
+    );
     const pendingRows: Record<string, unknown>[] = [];
+    const completedRows: Record<string, unknown>[] = [];
     const blockedRows: Record<string, unknown>[] = [];
     for (const entry of input.rowEntries) {
       const disposition = dispositionsByKey.get(entry.key) ?? 'blocked';
       if (disposition === 'pending') {
         pendingRows.push(buildFreshRow(entry));
+      } else if (disposition === 'completed') {
+        const stored = completedDataByKey.get(entry.key);
+        if (!stored) {
+          throw new Error(
+            `Forced run resume lost completed Runtime Sheet row ${entry.key}.`,
+          );
+        }
+        completedRows.push({
+          ...entry.row,
+          ...stored,
+          __deeplineRowKey: entry.key,
+        });
       } else if (disposition === 'blocked') {
         blockedRows.push(buildFreshRow(entry));
       }
@@ -4231,7 +4284,7 @@ async function buildRuntimeSheetDatasetStartResult(
       inserted: input.inserted,
       skipped: input.sourceRowsLength - input.rowEntries.length,
       pendingRows,
-      completedRows: [],
+      completedRows,
       blockedRows,
       tableNamespace: input.tableNamespace,
       writeVersion: input.writeVersion,
@@ -7120,7 +7173,6 @@ export type RuntimeMapRowsWriteResult = {
 type RuntimeMapRowsMutationResult = {
   updated: number;
   fencedRows: RuntimeMapRowsStaleRow[];
-  conflictKeys: string[];
 };
 
 const RUNTIME_MAP_ROWS_STALE_REASONS: ReadonlySet<RuntimeMapRowsStaleReason> =
@@ -7310,7 +7362,6 @@ async function completeRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7338,7 +7389,6 @@ async function completeRuntimeMapRowChunks(
       updated: number;
       matched_keys: string[];
       fenced_rows: unknown;
-      conflict_keys: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -7355,6 +7405,7 @@ async function completeRuntimeMapRowChunks(
        ),
        matched_updates AS (
          SELECT target._key AS matched_key,
+                updates._key AS submitted_key,
                 target._status AS prev_status,
                 target._cell_meta AS prev_cell_meta,
                 updates.input_index,
@@ -7364,40 +7415,6 @@ async function completeRuntimeMapRowChunks(
            JOIN ${sheetTable(session)} AS target
              ON target._key = updates._key
        ),
-       same_version_conflicts AS (
-         SELECT updates.matched_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $13::bigint IS NOT NULL
-            AND target._write_version = $13::bigint
-            AND target._run_id = $5::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($8::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-                AND COALESCE(target._attempt_seq, 0) = $12::integer
-              )
-            )
-            AND (
-              target._status <> 'enriched'
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
-            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
-            AND NOT (
-              $10::text IS NOT NULL
-              AND $12::integer IS NOT NULL
-              AND target._status = 'enriched'
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-              AND COALESCE(target._attempt_seq, 0) = $12::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7414,7 +7431,6 @@ async function completeRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates
          WHERE target._key = updates.matched_key
-                   AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
 		           AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
                    AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
@@ -7424,14 +7440,27 @@ async function completeRuntimeMapRowChunks(
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
 		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
            )
-           -- First terminal wins: skip UPDATE for already-terminal same-owner+epoch row.
-           -- Even though we excluded from conflicts, we still no-op here for idempotency.
+           -- A same-version enriched row is already the durable result for this
+           -- logical run. Provider retries may produce a different payload or
+           -- timestamp; preserve the first terminal value. Input-index repair
+           -- remains writable when the submitted key itself changed.
            AND NOT (
-             $10::text IS NOT NULL
-             AND $12::integer IS NOT NULL
+             $13::bigint IS NOT NULL
+             AND target._write_version = $13::bigint
+             AND target._run_id = $5::text
              AND target._status = 'enriched'
-             AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-             AND COALESCE(target._attempt_seq, 0) = $12::integer
+             AND updates.submitted_key = target._key
+             AND (
+               EXISTS (
+                 SELECT 1
+                   FROM unnest($8::text[]) AS field_values(field)
+                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+               )
+               OR (
+                 $10::text IS NOT NULL
+                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
+               )
+             )
            )
            AND (
              target._status <> 'enriched'
@@ -7564,7 +7593,6 @@ async function completeRuntimeMapRowChunks(
          (SELECT count(*)::int FROM applied_rows) AS updated,
          coalesce((SELECT array_agg(matched_key) FROM matched_updates), '{}'::text[]) AS matched_keys,
          coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys,
          (SELECT count(*)::int FROM summary_delta) AS summary_delta_count,
          (SELECT count(*)::int FROM column_delta) AS column_delta_count`,
       [
@@ -7585,19 +7613,12 @@ async function completeRuntimeMapRowChunks(
     );
     const matchedKeys = new Set(rows[0]?.matched_keys ?? []);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
-    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     // An exact-version replay that already produced the same terminal value is
     // accepted idempotently even when SQL has no physical mutation to apply.
     // Stale versions remain excluded through fenced_rows.
     const appliedCount = Number(rows[0]?.updated ?? 0);
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
-    conflictKeys.push(...chunkConflictKeys);
-
-    if (chunkConflictKeys.length > 0) {
-      continue;
-    }
-
     if (matchedKeys.size === chunk.length) {
       continue;
     }
@@ -7615,9 +7636,8 @@ async function completeRuntimeMapRowChunks(
     );
     updated += repaired.updated;
     fencedRows.push(...repaired.fencedRows);
-    conflictKeys.push(...repaired.conflictKeys);
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 async function completeRuntimeMapRowChunksWithInputIndexRepair(
@@ -7627,7 +7647,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7647,7 +7666,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     const { rows } = await client.query<{
       _key?: string;
       fenced_rows?: unknown;
-      conflict_keys?: string[];
       updated?: number;
     }>(
       `WITH updates AS (
@@ -7679,40 +7697,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
-       same_version_conflicts AS (
-         SELECT updates.submitted_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $13::bigint IS NOT NULL
-            AND target._write_version = $13::bigint
-            AND target._run_id = $5::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($8::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-                AND COALESCE(target._attempt_seq, 0) = $12::integer
-              )
-            )
-            AND (
-              target._status <> 'enriched'
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
-            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
-            AND NOT (
-              $10::text IS NOT NULL
-              AND $12::integer IS NOT NULL
-              AND target._status = 'enriched'
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-              AND COALESCE(target._attempt_seq, 0) = $12::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7730,14 +7714,31 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
            AND prev._key = target._key
-           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
            AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
            AND (
              ($9::text IS NULL AND target._run_id = $5::text)
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
-		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
+           OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
+           )
+           AND NOT (
+             $13::bigint IS NOT NULL
+             AND target._write_version = $13::bigint
+             AND target._run_id = $5::text
+             AND target._status = 'enriched'
+             AND updates.submitted_key = target._key
+             AND (
+               EXISTS (
+                 SELECT 1
+                   FROM unnest($8::text[]) AS field_values(field)
+                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+               )
+               OR (
+                 $10::text IS NOT NULL
+                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
+               )
+             )
            )
            AND (
              target._status <> 'enriched'
@@ -7866,8 +7867,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -7886,9 +7886,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     );
     updated += Number(rows[0]?.updated ?? 0);
     fencedRows.push(...parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows));
-    conflictKeys.push(...(rows[0]?.conflict_keys ?? []));
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 async function insertMissingCompletedMapRowChunks(
@@ -8084,7 +8083,6 @@ async function failRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -8117,7 +8115,6 @@ async function failRuntimeMapRowChunks(
     const { rows } = await client.query<{
       updated?: number;
       fenced_rows?: unknown;
-      conflict_keys?: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -8138,6 +8135,7 @@ async function failRuntimeMapRowChunks(
        matched_updates AS (
          SELECT DISTINCT ON (target._key)
                 target._key AS matched_key,
+                updates._key AS submitted_key,
                 updates.data_patch,
                 updates.cell_meta_patch,
                 updates.error
@@ -8151,42 +8149,6 @@ async function failRuntimeMapRowChunks(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
-       same_version_conflicts AS (
-         SELECT updates.matched_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $16::bigint IS NOT NULL
-            AND target._write_version = $16::bigint
-            AND target._run_id = $6::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($9::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $6::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-                AND COALESCE(target._attempt_seq, 0) = $14::integer
-              )
-            )
-            AND (
-              target._status <> 'failed'
-              OR target._error IS DISTINCT FROM updates.error
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- Same-owner terminal replay is not a conflict. Normal replay
-            -- preserves the first value below; explicit force-failure may update it.
-            -- Different owners and attempt epochs still conflict.
-            AND NOT (
-              $12::text IS NOT NULL
-              AND $14::integer IS NOT NULL
-              AND target._status IN ('failed', 'enriched')
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-              AND COALESCE(target._attempt_seq, 0) = $14::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'failed',
@@ -8203,7 +8165,6 @@ async function failRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
-           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($16::bigint IS NULL OR target._write_version = $16::bigint)
            AND prev._key = target._key
            AND ($15::boolean OR target._status <> 'enriched')
@@ -8212,15 +8173,16 @@ async function failRuntimeMapRowChunks(
              ($11::text IS NULL AND target._run_id = $6::text)
              OR ($11::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$11::text', '$12::text', '$13::timestamptz', '$14::integer')})
 	           )
-           -- First terminal wins for failed rows too, BUT only when NOT force-failing.
-           -- Normal replay: no-op when already-failed OR already-enriched from same owner+epoch.
+           -- Normal replay preserves the first terminal value for an exact
+           -- same-version key. Force-failure is the explicit teardown escape
+           -- hatch and may still overwrite it.
            AND NOT (
              $15::boolean = FALSE
-             AND $12::text IS NOT NULL
-             AND $14::integer IS NOT NULL
+             AND $16::bigint IS NOT NULL
+             AND target._write_version = $16::bigint
+             AND target._run_id = $6::text
              AND target._status IN ('failed', 'enriched')
-             AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-             AND COALESCE(target._attempt_seq, 0) = $14::integer
+             AND updates.submitted_key = target._key
            )
          RETURNING target._key, prev._status AS prev_status
        ),
@@ -8317,8 +8279,7 @@ async function failRuntimeMapRowChunks(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -8340,12 +8301,10 @@ async function failRuntimeMapRowChunks(
     );
     const appliedCount = Number(rows[0]?.updated ?? 0);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
-    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
-    conflictKeys.push(...chunkConflictKeys);
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 /**
@@ -8556,10 +8515,9 @@ export async function completeRuntimeMapRows(
               return {
                 updated: updated.updated + inserted.inserted,
                 fencedRows: updated.fencedRows,
-                conflictKeys: updated.conflictKeys,
               };
             })()
-          : { updated: 0, fencedRows: [], conflictKeys: [] };
+          : { updated: 0, fencedRows: [] };
       const failed =
         failedRows.length > 0
           ? await failRuntimeMapRowChunks(client, session, {
@@ -8578,17 +8536,7 @@ export async function completeRuntimeMapRows(
                 input.tableNamespace,
               ),
             })
-          : { updated: 0, fencedRows: [], conflictKeys: [] };
-      const conflictKeys = [...completed.conflictKeys, ...failed.conflictKeys];
-      if (conflictKeys.length > 0) {
-        throw new Error(
-          `Runtime Sheet received the same write version with a different terminal payload for row(s): ${[
-            ...new Set(conflictKeys),
-          ]
-            .slice(0, 10)
-            .join(', ')}.`,
-        );
-      }
+          : { updated: 0, fencedRows: [] };
       return classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
         updated: completed.updated + failed.updated,

package/dist/bundling-sources/shared_libs/play-runtime/runtime-work-counters.ts

@@ -0,0 +1,37 @@
+/** Fixed-size terminal accounting retained even when detailed runtime telemetry is too large. */
+export type RuntimeWorkCounters = {
+  logicalCalls: number;
+  providerRequests: number;
+};
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function count(value: unknown): number | null {
+  return Number.isSafeInteger(value) && (value as number) >= 0
+    ? (value as number)
+    : null;
+}
+
+export function runtimeWorkCountersFromResources(
+  resources: unknown,
+): RuntimeWorkCounters | null {
+  const root = record(resources);
+  const phases = record(root?.phases);
+  const logicalCalls = count(record(phases?.toolCallLogicalWall)?.count);
+  const providers = record(root?.providers);
+  if (logicalCalls === null || !providers) return null;
+
+  let providerRequests = 0;
+  for (const [key, value] of Object.entries(providers)) {
+    if (!key.startsWith('tool:')) continue;
+    const requests = count(record(record(value)?.residence)?.count);
+    if (requests === null) return null;
+    providerRequests += requests;
+    if (!Number.isSafeInteger(providerRequests)) return null;
+  }
+  return { logicalCalls, providerRequests };
+}