fix(table): no typewriter flash; Run-row skips completed workflows

- Typewriter: reset the revealed text synchronously during render when the
  value changes (not in an effect), so a cell going from running→value no
  longer flashes the full text for one frame before animating.
- Run row / manual incomplete runs now treat a `completed` group as done even
  if an output column is blank — only "Run all" re-runs completed cells. The
  auto cascade keeps re-filling blank outputs (completedAndFilled). Client
  optimistic stamp mirrors: incomplete skips `completed` cells.

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx

@@ -303,33 +303,35 @@ const TYPEWRITER_MS_PER_CHAR = 15
  */
 function useTypewriter(text: string | null): string | null {
   const [revealed, setRevealed] = useState<string | null>(text)
-  const isFirstRunRef = useRef(true)
   const prevTextRef = useRef<string | null>(text)
+  const mountedRef = useRef(false)
+  const animateRef = useRef(false)
 
-  useEffect(() => {
-    if (isFirstRunRef.current) {
-      isFirstRunRef.current = false
-      prevTextRef.current = text
-      setRevealed(text)
-      return
-    }
-    if (prevTextRef.current === text) return
+  // Reset synchronously during render when `text` changes (not on first mount)
+  // so no frame ever shows the full new value before the animation begins —
+  // an effect-based reset lands one frame late and flashes the whole text.
+  if (prevTextRef.current !== text) {
     prevTextRef.current = text
+    const animate = mountedRef.current && text !== null && text.length > 0
+    animateRef.current = animate
+    setRevealed(animate ? '' : text)
+  }
 
-    if (text === null || text.length === 0) {
-      setRevealed(text)
-      return
-    }
+  useEffect(() => {
+    mountedRef.current = true
+  }, [])
 
-    const full = text
+  useEffect(() => {
+    if (!animateRef.current) return
+    animateRef.current = false
+    const full = text as string
     const start = performance.now()
     let raf = 0
     const tick = (now: number) => {
       const chars = Math.min(full.length, Math.floor((now - start) / TYPEWRITER_MS_PER_CHAR))
       setRevealed(full.slice(0, chars))
       if (chars < full.length) raf = requestAnimationFrame(tick)
     }
-    setRevealed('')
     raf = requestAnimationFrame(tick)
     return () => cancelAnimationFrame(raf)
   }, [text])

apps/sim/hooks/queries/tables.ts

@@ -73,7 +73,6 @@ import type {
 } from '@/lib/table'
 import {
   areGroupDepsSatisfied,
-  areOutputsFilled,
   isExecInFlight,
   optimisticallyScheduleNewlyEligibleGroups,
 } from '@/lib/table/deps'
@@ -1418,12 +1417,10 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
           // dispatcher regardless of mode. Stamping pending here would leave
           // the cell flashing Queued indefinitely (no SSE event will arrive).
           if (group && !areGroupDepsSatisfied(group, r)) continue
-          // Mirror server eligibility for `mode: 'incomplete'`: skip cells whose
-          // outputs are filled, regardless of exec status. A cancelled/error
-          // cell with a leftover value from a prior run was rendering as filled
-          // but flipping to "queued" optimistically here even though the server
-          // would skip it.
-          if (runMode === 'incomplete' && group && areOutputsFilled(group, r)) continue
+          // Mirror server eligibility for manual `mode: 'incomplete'`: a
+          // `completed` group is done (even with a blank output) — only "Run
+          // all" re-runs it. error/cancelled/never-run cells still re-run.
+          if (runMode === 'incomplete' && exec?.status === 'completed') continue
           next[groupId] = buildPendingExec(exec)
           // Mirror the server-side bulk clear: wipe output values so the cell
           // doesn't render the stale completed value behind a pending badge.

apps/sim/lib/table/workflow-columns.ts

@@ -93,7 +93,14 @@ export function classifyEligibility(
   if (!isManualRun && completedAndFilled) return 'completed-on-auto'
   if (!isManualRun && status === 'error') return 'error-on-auto'
   if (!isManualRun && status === 'cancelled') return 'cancelled-on-auto'
-  if (mode === 'incomplete' && completedAndFilled) return 'completed-on-incomplete'
+  // Manual incomplete-mode runs (Run row / Run incomplete) treat a `completed`
+  // group as done even if an output is blank — only "Run all" re-runs it. The
+  // auto cascade still re-fills blank outputs (completedAndFilled).
+  if (mode === 'incomplete') {
+    if (isManualRun ? status === 'completed' : completedAndFilled) {
+      return 'completed-on-incomplete'
+    }
+  }
 
   if (isManualRun && group.autoRun === false) return 'manual-bypass'
   return areGroupDepsSatisfied(group, row) ? 'eligible' : 'deps-unmet'