fix(tables,knowledge): spare a live window, and restore the truncation notice

A lease needs its heartbeat interval to sit well under its TTL. The dispatch
heartbeat is stamped between windows, not during them, and `batchTriggerAndWait`
checkpoints the loop for the whole window — so the interval is really "one
window", which nothing bounds: the window ends when its cells do, and the
in-process path has no ceiling at all. A window outliving the stale threshold
had its dispatch cancelled while it was plainly alive.

Its cells carry the signal the checkpointed parent cannot — `updatedAt` on every
in-flight row execution, written by the cell tasks themselves. Both signals must
be stale before a dispatch is reclaimed, so a slow window is spared for as long
as its cells keep reporting while a run with nothing beating and nothing
executing is still collected. The subquery rides the partial `(table_id,
status)` index that already covers exactly those three statuses.

Bounding the workbook conversion also made its truncation notice unreachable:
the converted length can no longer exceed the window it was compared against, so
every sheet larger than the preview cap silently stopped reporting that it had
been cut. Compared against the declared row count instead, which is what the
comparison meant before the conversion was bounded.

Author: waleedlatif1

apps/sim/lib/file-parsers/xlsx-parser.ts

@@ -176,9 +176,15 @@ export class XlsxParser implements FileParser {
           contentSize += chunkContent.length
         }
 
-        if (actualRowCount > rowsToProcess) {
+        /**
+         * Compared against the DECLARED row count, not the converted one. The
+         * conversion is now bounded to the preview window, so the converted
+         * length can never exceed it — comparing the two made this unreachable
+         * and silently dropped the notice from every sheet larger than the cap.
+         */
+        if (rowCount > rowsToProcess) {
           content += truncationNotice(
-            `${actualRowCount.toLocaleString()} total rows, showing first ${rowsToProcess.toLocaleString()}`
+            `${rowCount.toLocaleString()} total rows, showing first ${rowsToProcess.toLocaleString()}`
           )
           truncated = true
         }

apps/sim/lib/file-parsers/xlsx-preview-bound.test.ts

@@ -67,4 +67,16 @@ describe('XlsxParser preview bound', () => {
     expect(result.content).toContain('header-a')
     expect(result.content).toContain('row-2-b')
   })
+
+  it('still reports truncation for a sheet larger than the preview window', async () => {
+    const result = await new XlsxParser().parseBuffer(inflatedRangeWorkbook())
+
+    /**
+     * Bounding the conversion made the converted length equal the window, so
+     * comparing it against the window could never be true — the notice silently
+     * disappeared from exactly the large sheets it exists for.
+     */
+    expect(result.metadata?.truncated).toBe(true)
+    expect(result.content).toContain('200,000 total rows')
+  })
 })

apps/sim/lib/table/dispatcher.ts

@@ -826,10 +826,35 @@ export async function cancelStaleDispatches(
   staleBefore: Date,
   limit: number
 ): Promise<DispatchRow[]> {
+  /**
+   * Dead means nothing about the dispatch has moved — neither the loop nor the
+   * work it is waiting on.
+   *
+   * The dispatch's own heartbeat is stamped between windows, not during them,
+   * and `batchTriggerAndWait` checkpoints the loop for the whole window, so a
+   * long window leaves the heartbeat untouched while the dispatch is plainly
+   * alive. A lease needs its heartbeat interval to sit well under its TTL; this
+   * one cannot promise that, because the window is bounded by the cells' own
+   * timeouts and the in-process path has no ceiling at all.
+   *
+   * Its cells carry the signal the checkpointed parent cannot: `updatedAt` on
+   * every in-flight row execution, written by the cell tasks themselves. Both
+   * must be stale before a dispatch is reclaimed, so a slow window is spared for
+   * as long as its cells keep reporting, and a genuinely dead run — nothing
+   * beating, nothing executing — is still collected. The subquery rides the
+   * partial `(table_id, status)` index that already covers exactly these three
+   * statuses.
+   */
   const isStale = () =>
     and(
       inArray(tableRunDispatches.status, [...ACTIVE_DISPATCH_STATUSES]),
-      sql`COALESCE(${tableRunDispatches.heartbeatAt}, ${tableRunDispatches.requestedAt}) < ${sql.param(staleBefore, tableRunDispatches.heartbeatAt)}`
+      sql`COALESCE(${tableRunDispatches.heartbeatAt}, ${tableRunDispatches.requestedAt}) < ${sql.param(staleBefore, tableRunDispatches.heartbeatAt)}`,
+      sql`NOT EXISTS (
+        SELECT 1 FROM ${tableRowExecutions}
+        WHERE ${tableRowExecutions.tableId} = ${tableRunDispatches.tableId}
+          AND ${tableRowExecutions.status} IN ('queued', 'running', 'pending')
+          AND ${tableRowExecutions.updatedAt} >= ${sql.param(staleBefore, tableRowExecutions.updatedAt)}
+      )`
     )
 
   // Claimed as explicit ids first, then updated by id, so the bound is evaluated

apps/sim/lib/table/stale-dispatch-recovery.test.ts

@@ -100,6 +100,22 @@ describe('cancelStaleDispatches', () => {
     expect(chunks).toContain('tableRunDispatches.requestedAt')
   })
 
+  it('spares a dispatch whose cells are still reporting', async () => {
+    await cancelStaleDispatches(STALE_BEFORE, 200)
+
+    const chunks = collectChunks(dbChainMockFns.where.mock.calls[0][0])
+    /**
+     * The dispatch's own heartbeat is stamped between windows, not during them,
+     * and the loop is checkpointed for the whole window — so a long window
+     * leaves it untouched while the dispatch is plainly alive. Its cells carry
+     * the signal the checkpointed parent cannot, and both have to be stale
+     * before the row is reclaimed.
+     */
+    expect(chunks.some((chunk) => chunk.includes('NOT EXISTS'))).toBe(true)
+    expect(chunks).toContain('tableRowExecutions.updatedAt')
+    expect(chunks).toContain('tableRowExecutions.tableId')
+  })
+
   it('emits the terminal event so a stuck client overlay clears', async () => {
     await cancelStaleDispatches(STALE_BEFORE, 200)