test(agents-server-ui): cover the orphaned-spinner staleness logic [review #4605]

The orphan-clearing logic added to CompactionIndicator had no test, and a
regression where rows stop carrying `timestamp` would silently revert to the
lingering-spinner bug (NaN → not orphaned → spinner stays). This package has no
React-render harness, so extract the decision into a pure
`isRunningCheckpointOrphaned(timestamp, now)` helper (with STALE_RUNNING_MS) in
lib/ and unit-test it: fresh → shown, just under the deadline → shown, at/past
the deadline → hidden, and missing/unparseable timestamp → shown (documented).
The component now imports the helper, so the tested logic is exactly what runs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kevin-dp

packages/agents-server-ui/src/components/CompactionIndicator.tsx

@@ -1,6 +1,10 @@
 import { useEffect, useMemo, useState } from 'react'
 import { useLiveQuery } from '@tanstack/react-db'
 import type { EntityStreamDBWithActions } from '@electric-ax/agents-runtime/client'
+import {
+  STALE_RUNNING_MS,
+  isRunningCheckpointOrphaned,
+} from '../lib/compactionIndicator'
 import styles from './CompactionIndicator.module.css'
 
 /**
@@ -16,12 +20,9 @@ import styles from './CompactionIndicator.module.css'
  * always written, so a `running` row that lingers well past that is orphaned —
  * its process crashed before writing the terminal row. We stop showing the
  * spinner for such a row (and self-clear via a timer so it disappears even with
- * no further events).
+ * no further events). See `lib/compactionIndicator` for the staleness rule.
  */
 
-/** Beyond this age a still-`running` checkpoint is treated as orphaned/crashed. */
-const STALE_RUNNING_MS = 150_000
-
 interface CheckpointRow {
   _seq?: number
   timestamp?: string
@@ -70,10 +71,7 @@ export function CompactionIndicator({
   }, [latest, runningSince])
 
   if (!latest) return null
-  const orphaned =
-    Number.isFinite(runningSince) &&
-    Date.now() - runningSince >= STALE_RUNNING_MS
-  if (orphaned) return null
+  if (isRunningCheckpointOrphaned(latest.timestamp, Date.now())) return null
 
   // Background compaction is non-blocking, so it's shown subtly and distinctly
   // from the blocking (sync, mid-turn) "Compacting context…".

packages/agents-server-ui/src/lib/compactionIndicator.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import {
+  STALE_RUNNING_MS,
+  isRunningCheckpointOrphaned,
+} from './compactionIndicator'
+
+describe(`isRunningCheckpointOrphaned`, () => {
+  const now = 1_000_000_000_000
+  const iso = (ms: number) => new Date(ms).toISOString()
+
+  it(`is NOT orphaned for a fresh running checkpoint`, () => {
+    expect(isRunningCheckpointOrphaned(iso(now), now)).toBe(false)
+    expect(isRunningCheckpointOrphaned(iso(now - 30_000), now)).toBe(false)
+  })
+
+  it(`is NOT orphaned just under the staleness deadline`, () => {
+    expect(
+      isRunningCheckpointOrphaned(iso(now - (STALE_RUNNING_MS - 1)), now)
+    ).toBe(false)
+  })
+
+  it(`IS orphaned at/after the staleness deadline (crashed mid-summarize)`, () => {
+    expect(isRunningCheckpointOrphaned(iso(now - STALE_RUNNING_MS), now)).toBe(
+      true
+    )
+    expect(
+      isRunningCheckpointOrphaned(iso(now - STALE_RUNNING_MS * 10), now)
+    ).toBe(true)
+  })
+
+  it(`treats a missing or unparseable timestamp as NOT orphaned`, () => {
+    // We can't prove staleness, so we keep showing the spinner rather than hide
+    // a possibly-live compaction. (insertContext always stamps a timestamp.)
+    expect(isRunningCheckpointOrphaned(undefined, now)).toBe(false)
+    expect(isRunningCheckpointOrphaned(``, now)).toBe(false)
+    expect(isRunningCheckpointOrphaned(`not-a-date`, now)).toBe(false)
+  })
+})

packages/agents-server-ui/src/lib/compactionIndicator.ts

@@ -0,0 +1,30 @@
+/**
+ * Staleness logic for the "Compacting…" indicator, extracted so it can be unit
+ * tested without a DOM/render harness (this package has no React-render test
+ * setup).
+ */
+
+/**
+ * Beyond this age a still-`running` compaction checkpoint is treated as orphaned
+ * (its process crashed before writing a terminal `complete`/`failed` row). A
+ * summarize is bounded by a ~120s hard timeout after which a terminal row is
+ * always written, so 150s comfortably clears only genuinely-crashed runs.
+ */
+export const STALE_RUNNING_MS = 150_000
+
+/**
+ * Whether a `running` checkpoint with the given `timestamp` (ISO string) should
+ * be treated as orphaned at `now` (ms). A missing or unparseable timestamp is
+ * treated as NOT orphaned — we can't prove staleness, and hiding a genuinely
+ * in-flight compaction is worse than briefly over-showing one. (insertContext
+ * always stamps a timestamp, so this only guards against a schema regression.)
+ */
+export function isRunningCheckpointOrphaned(
+  timestamp: string | undefined,
+  now: number
+): boolean {
+  if (!timestamp) return false
+  const since = Date.parse(timestamp)
+  if (!Number.isFinite(since)) return false
+  return now - since >= STALE_RUNNING_MS
+}