V48 Gate 3 (implementation-only): live stall visibility on the synthesis telemetry processing indicator

The processing indicator showed a static "Processing" label with no signal of
what was running or whether it had stalled — during the depository-search
agent hangs (F25/F28-class), the log goes silent while a call is in flight and
there is no way to tell live whether it is progressing or stuck. The indicator
now shows the last known Phase→Agent→Step→Failsafe→Thricified context plus
elapsed seconds since the last streamed event, ticking every second, and flips
to an amber warning once elapsed time reaches the BITCODE_LLM_CALL_TIMEOUT_MS
default (90s) — past that point a live call should already have timed out
server-side, so continued silence is a genuine-hang signal. Does not add a new
formal log-line kind (F19's "exactly LLM calls + Tool uses" row contract is
unchanged) — purely additive to the existing processing indicator.

buildProcessingStallLabel is a pure, exported helper (unit tested: no prior
line, normal elapsed time, past-threshold warning, invalid/missing timestamp).

Author: geraldarthurdavis

uapi/components/base/bitcode/execution/pipeline-execution-log.tsx

@@ -397,6 +397,37 @@ export function buildRawLogCopyText(args: {
   ].join('');
 }
 
+// Matches the default BITCODE_LLM_CALL_TIMEOUT_MS (AgentLLMsRegistry /
+// PipelineLLMRegistry) — past this many seconds with no new row, an in-flight
+// LLM call should already have timed out server-side, so continued silence is
+// a genuine-hang signal rather than a merely slow generation.
+const LIKELY_STALL_SECONDS = 90;
+
+/**
+ * Build the live "Running: {hierarchy} · Ns since last update" label for the
+ * processing indicator, from the last known log line + the current tick. Pure
+ * + exported for unit testing. Returns the bare fallback label when there is no
+ * prior line yet (nothing streamed since the run started).
+ */
+export function buildProcessingStallLabel(
+  lastLine: Pick<LogLine, 'phase' | 'agent' | 'step' | 'failsafe' | 'generation' | 'timestamp'> | undefined,
+  nowMs: number,
+): { label: string; likelyStalled: boolean } {
+  if (!lastLine?.timestamp) return { label: 'Processing', likelyStalled: false };
+  const lastMs = new Date(lastLine.timestamp).getTime();
+  if (!Number.isFinite(lastMs)) return { label: 'Processing', likelyStalled: false };
+
+  const elapsedSeconds = Math.max(0, Math.round((nowMs - lastMs) / 1000));
+  const hierarchy = [lastLine.phase, lastLine.agent, lastLine.step, lastLine.failsafe, lastLine.generation]
+    .filter(Boolean)
+    .join(' → ');
+  const likelyStalled = elapsedSeconds >= LIKELY_STALL_SECONDS;
+  const label = hierarchy
+    ? `Running: ${hierarchy} · ${elapsedSeconds}s since last update`
+    : `Processing · ${elapsedSeconds}s since last update`;
+  return { label, likelyStalled };
+}
+
 /**
  * Copy text to the clipboard, returning whether it succeeded. Tries the modern
  * `navigator.clipboard` (requires a secure context) and, when that is unavailable or
@@ -446,6 +477,20 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
   const containerRef = useRef<HTMLDivElement | null>(null);
   const [autoCompact, setAutoCompact] = useState(false);
 
+  // Live "stalled since" signal (QA debug aid, V48 Gate 3): while processing, tick
+  // once a second so the processing indicator can show elapsed time since the
+  // last streamed event. This does NOT add a new formal log-line kind (F19's
+  // "exactly LLM calls + Tool uses" contract is unchanged) — it only makes an
+  // in-flight call's silence visible in real time, so a genuine hang (e.g. past
+  // BITCODE_LLM_CALL_TIMEOUT_MS with no new row) is distinguishable from a slow
+  // but progressing run instead of an unexplained blank gap.
+  const [nowTick, setNowTick] = useState(() => Date.now());
+  useEffect(() => {
+    if (!isProcessing) return;
+    const id = setInterval(() => setNowTick(Date.now()), 1000);
+    return () => clearInterval(id);
+  }, [isProcessing]);
+
   // "Copy raw logs": copy this run's full information (all streamed logs + inputs).
   const [copiedRaw, setCopiedRaw] = useState(false);
   const handleCopyRaw = async () => {
@@ -876,8 +921,13 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
           ),
         )}
 
-        {/* Processing indicator */}
-        {isProcessing && <ProcessingIndicator />}
+        {/* Processing indicator — shows the last known Phase→Agent→Step→Failsafe→
+            Thricified context + elapsed time since the last streamed event, so a
+            genuine hang is visible live instead of an unexplained blank gap. */}
+        {isProcessing && (() => {
+          const { label, likelyStalled } = buildProcessingStallLabel(flatLines[flatLines.length - 1], nowTick);
+          return <ProcessingIndicator label={label} stalled={likelyStalled} />;
+        })()}
       </div>
     </div>
     </div>

uapi/components/base/bitcode/indicators/ProcessingIndicator.tsx

@@ -3,7 +3,14 @@
 import React, { useEffect, useRef } from 'react';
 import '@/styles/processing-indicator.css';
 
-export function ProcessingIndicator({ label = 'Processing' }: { label?: string }) {
+export function ProcessingIndicator({
+  label = 'Processing',
+  stalled = false,
+}: {
+  label?: string;
+  /** True once elapsed time since the last event suggests a genuine hang (vs. a slow but live call) — swaps the label to an amber warning tone. */
+  stalled?: boolean;
+}) {
   const orbRef = useRef<HTMLDivElement>(null);
   const textRef = useRef<HTMLDivElement>(null);
 
@@ -26,7 +33,12 @@ export function ProcessingIndicator({ label = 'Processing' }: { label?: string }
         </div>
       </div>
       <div className="relative">
-        <div ref={textRef} className="processing-text text-brand-emerald text-neon">{intelligentLabel}</div>
+        <div
+          ref={textRef}
+          className={`processing-text text-neon ${stalled ? 'text-amber-400' : 'text-brand-emerald'}`}
+        >
+          {intelligentLabel}
+        </div>
         <div className="processing-underline w-full" />
       </div>
     </div>

uapi/tests/pipelineExecutionLogCopy.test.tsx

@@ -9,6 +9,7 @@ jest.mock('@/components/base/bitcode/execution/FileDiffViewer', () => ({
 
 import {
   buildRawLogCopyText,
+  buildProcessingStallLabel,
   copyTextToClipboard,
 } from '@/components/base/bitcode/execution/pipeline-execution-log';
 
@@ -49,6 +50,49 @@ describe('PipelineExecutionLog — Copy raw logs (buildRawLogCopyText)', () => {
   });
 });
 
+describe('buildProcessingStallLabel — live stall visibility (QA debug aid)', () => {
+  it('falls back to a bare label when there is no prior line yet', () => {
+    expect(buildProcessingStallLabel(undefined, Date.now())).toEqual({
+      label: 'Processing',
+      likelyStalled: false,
+    });
+  });
+
+  it('renders the hierarchy + elapsed seconds since the last line, not stalled under the threshold', () => {
+    const lastLine = {
+      phase: 'Discovery',
+      agent: 'DepositDepositorySearchAgent',
+      step: 'try',
+      failsafe: 'chunk_then_sum',
+      generation: 'structured_output',
+      timestamp: new Date(1_000_000).toISOString(),
+    };
+    const { label, likelyStalled } = buildProcessingStallLabel(lastLine, 1_000_000 + 30_000);
+    expect(label).toBe(
+      'Running: Discovery → DepositDepositorySearchAgent → try → chunk_then_sum → structured_output · 30s since last update',
+    );
+    expect(likelyStalled).toBe(false);
+  });
+
+  it('flags likelyStalled once elapsed time reaches the LLM call timeout default (90s)', () => {
+    const lastLine = { phase: 'Discovery', agent: 'DepositDepositorySearchAgent', timestamp: new Date(0).toISOString() };
+    const { likelyStalled, label } = buildProcessingStallLabel(lastLine, 90_000);
+    expect(likelyStalled).toBe(true);
+    expect(label).toContain('90s since last update');
+  });
+
+  it('handles a missing/invalid timestamp without throwing', () => {
+    expect(buildProcessingStallLabel({ phase: 'Discovery', timestamp: undefined } as any, Date.now())).toEqual({
+      label: 'Processing',
+      likelyStalled: false,
+    });
+    expect(buildProcessingStallLabel({ phase: 'Discovery', timestamp: 'not-a-date' } as any, Date.now())).toEqual({
+      label: 'Processing',
+      likelyStalled: false,
+    });
+  });
+});
+
 describe('copyTextToClipboard — modern + insecure-context fallback', () => {
   const originalClipboard = (navigator as any).clipboard;
   const originalExec = (document as any).execCommand;