@@ -25,7 +25,7 @@ import {
 } from '@/lib/core/execution-limits'
 import { withResourceOutboundScope } from '@/lib/core/network/resource-scope.server'
 import { RateLimiter } from '@/lib/core/rate-limiter/rate-limiter'
-import { withDatabaseReadRetry, withIdempotentWriteRetry } from '@/lib/db/read-retry'
+import { withDatabaseReadRetry } from '@/lib/db/read-retry'
 import {
   registerManualExecutionAborter,
   unregisterManualExecutionAborter,
@@ -422,16 +422,15 @@ export async function runRowCascadeLoop(
   } catch (err) {
     const { tableId, rowId } = payload
     const { terminalizeUnclaimedRowMarkers } = await import('@/lib/table/cell-write')
-    await withIdempotentWriteRetry(
-      () => terminalizeUnclaimedRowMarkers(tableId, rowId, CELL_STOPPED_MESSAGE),
-      { label: 'terminalizeUnclaimedRowMarkers', ...CELL_DATABASE_RETRY }
-    ).catch((markerErr) => {
-      logger.error('Failed to terminalize the unclaimed markers of a failed row', {
-        tableId,
-        rowId,
-        cause: describeError(markerErr),
-      })
-    })
+    await terminalizeUnclaimedRowMarkers(tableId, rowId, CELL_STOPPED_MESSAGE).catch(
+      (markerErr) => {
+        logger.error('Failed to terminalize the unclaimed markers of a failed row', {
+          tableId,
+          rowId,
+          cause: describeError(markerErr),
+        })
+      }
+    )
     throw err
   }
 }
 
@@ -433,6 +433,33 @@ describe('a durable cell state write around a lost connection', { timeout: 90_00
     expect(tableEventsMockFns.mockAppendTableEvent).toHaveBeenCalledOnce()
   })
 
+  it('tells open tables to refetch when the reply to failing the markers is lost', async () => {
+    const { tableId, rowId } = await createCell({ pickedUp: false })
+    await writeExecutionsPatch(db, tableId, rowId, {
+      [groupId]: {
+        status: 'pending',
+        executionId: null,
+        jobId: null,
+        workflowId: 'workflow-1',
+        error: null,
+      },
+    })
+    /** An unprepared statement waits on a reply before it executes, so the commit is applied here. */
+    interception = {
+      match: /update "table_row_executions"/i,
+      forward: false,
+      beforeReset: async () => {
+        await control`UPDATE table_row_executions SET status = 'error' WHERE row_id = ${rowId}`
+      },
+    }
+
+    await terminalizeUnclaimedRowMarkers(tableId, rowId, 'Stopped')
+
+    expect((await readCell(rowId)).status).toBe('error')
+    expect(tableEventsMockFns.mockAppendTableEvent).not.toHaveBeenCalled()
+    expect(tableEventsMockFns.mockSignalTableRowsChanged).toHaveBeenCalledWith(tableId)
+  })
+
   it('does not repeat a cancel stamp, which could kill a run the user just started', async () => {
     const { ctx, rowId } = await createCell()
     interception = {
 
@@ -16,7 +16,7 @@ import { getValueAtPath } from '@sim/utils/object'
 import { and, eq, isNull } from 'drizzle-orm'
 import { withIdempotentWriteRetry } from '@/lib/db/read-retry'
 import { CELL_DATABASE_RETRY } from '@/lib/table/constants'
-import { appendTableEvent } from '@/lib/table/events'
+import { appendTableEvent, signalTableRowsChanged } from '@/lib/table/events'
 import { TableRowNotFoundError } from '@/lib/table/rows/errors'
 import { loadExecutionsForRow, writeExecutionsPatch } from '@/lib/table/rows/executions'
 import {
@@ -204,24 +204,32 @@ export async function confirmWorkflowGroupStateCommitted(
  * Fails every marker on a row that no worker has claimed. `executionId` stays null, so a carrier
  * still queued for one of them can claim it and run. Claimed, cancelled, and finished cells are
  * untouched, and so is a paused one, which holds an execution id.
+ *
+ * Open tables are told to refetch too: a repeat after a lost reply finds nothing left to update, so
+ * it cannot name the cells the lost attempt failed.
  */
 export async function terminalizeUnclaimedRowMarkers(
   tableId: string,
   rowId: string,
   error: string
 ): Promise<void> {
-  const failed = await db
-    .update(tableRowExecutions)
-    .set({ status: 'error', jobId: null, error, runningBlockIds: [], updatedAt: new Date() })
-    .where(
-      and(
-        eq(tableRowExecutions.tableId, tableId),
-        eq(tableRowExecutions.rowId, rowId),
-        eq(tableRowExecutions.status, 'pending'),
-        isNull(tableRowExecutions.executionId)
-      )
-    )
-    .returning({ groupId: tableRowExecutions.groupId })
+  const failed = await withIdempotentWriteRetry(
+    () =>
+      db
+        .update(tableRowExecutions)
+        .set({ status: 'error', jobId: null, error, runningBlockIds: [], updatedAt: new Date() })
+        .where(
+          and(
+            eq(tableRowExecutions.tableId, tableId),
+            eq(tableRowExecutions.rowId, rowId),
+            eq(tableRowExecutions.status, 'pending'),
+            isNull(tableRowExecutions.executionId)
+          )
+        )
+        .returning({ groupId: tableRowExecutions.groupId }),
+    { label: 'terminalizeUnclaimedRowMarkers', ...CELL_DATABASE_RETRY }
+  )
+  signalTableRowsChanged(tableId)
   for (const { groupId } of failed) {
     void appendTableEvent({
       kind: 'cell',
 
@@ -523,8 +523,9 @@ export function generateUniqueTableName(existingNames: string[]): string {
  * How a cell rides out lost database connections. A reset takes individual sockets and a fresh one
  * works, but resets arrive in bursts of about a second, so backoff totals about four seconds to
  * outlast one. A reset can also stall the replacement connection until `connect_timeout`, so
- * `maxElapsedMs` admits one more attempt after such a stall and no more, which bounds how long each
- * failing operation holds the cell's concurrency slot and cascade lock.
+ * `maxElapsedMs` leaves room to try again after such a stall. It only decides whether another attempt
+ * starts, so one operation can hold the cell's concurrency slot and cascade lock for up to
+ * `maxElapsedMs` plus a final stall, about 70 seconds.
  */
 export const CELL_DATABASE_RETRY = {
   maxAttempts: 5,