V48 Gate 3 (implementation-only): pre-first-row processing indicator reads the live call chain — no more header/log mismatch at run start

The header tracker latches Phase→Agent→Step pills from store events the
moment the run starts, but log rows only appear for COMPLETED LLM/tool
calls (F19) — so until the first row lands the log read 'Initializing' +
a bare 'Processing' while the header already showed 'SETUP · INPUT
COMPREHENSION · PLAN'. The two surfaces now tell one story: /deposit passes
its live context into PipelineExecutionLog, and before the first row the
processing indicator renders the same sentence the pills describe ('While
Depositing, during Setup, agent Input Comprehension is Planning'); once
rows stream, the existing last-row stall label takes over unchanged.

Verified: uapi 155 suites / 609 tests green (pre-first-row sentence +
bare-'Processing' fallback pinned); tsc clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: geraldarthurdavis

uapi/app/deposit/DepositPageClient.tsx

@@ -1534,6 +1534,7 @@ export default function DepositPageClient() {
                     userHasScrolled={synthesisLogScrolled}
                     setUserHasScrolled={setSynthesisLogScrolled}
                     pipelineMode="deposit"
+                    liveContext={synthesisLiveContext}
                     copyData={{
                       runId: synthesisRunId,
                       status: synthesisStatus,

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

@@ -118,6 +118,20 @@ interface PipelineRunLogProps {
    * the sentence renders without the prefix.
    */
   pipelineMode?: SynthesisPipelineMode | null;
+  /**
+   * The CURRENT live call chain (the same rolling context the page's header
+   * tracker renders). Rows only appear for COMPLETED LLM/tool calls, so before
+   * the first row lands the processing indicator would otherwise read a bare
+   * 'Processing' while the header already shows Phase→Agent→Step pills — this
+   * keeps the two surfaces telling one story.
+   */
+  liveContext?: {
+    phase: string | null;
+    agent: string | null;
+    step: string | null;
+    failsafe: string | null;
+    generation: string | null;
+  } | null;
 }
 
 // Threshold (in px) below which we switch to compact layout automatically.
@@ -599,7 +613,8 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
   setUserHasScrolled,
   compact: compactProp,
   copyData,
-  pipelineMode
+  pipelineMode,
+  liveContext
 }, ref) => {
   // Automatic compact detection via container width
   const containerRef = useRef<HTMLDivElement | null>(null);
@@ -1076,9 +1091,17 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
 
         {/* Processing indicator — shows the last known Phase→Agent→Step→Failsafe→
             Thinkings context + elapsed time since the last streamed event, so a
-            genuine hang is visible live instead of an unexplained blank gap. */}
+            genuine hang is visible live instead of an unexplained blank gap.
+            Before the FIRST row lands (rows are completed calls only), fall
+            back to the page's live call-chain context so this line and the
+            header pills tell one story instead of a bare 'Processing'. */}
         {isProcessing && (() => {
-          const { label, likelyStalled } = buildProcessingStallLabel(flatLines[flatLines.length - 1], nowTick, pipelineMode);
+          const lastLine = flatLines[flatLines.length - 1];
+          if (!lastLine && liveContext) {
+            const sentence = describeExecutionContext({ ...liveContext, mode: pipelineMode ?? null });
+            if (sentence) return <ProcessingIndicator label={sentence} stalled={false} />;
+          }
+          const { label, likelyStalled } = buildProcessingStallLabel(lastLine, nowTick, pipelineMode);
           return <ProcessingIndicator label={label} stalled={likelyStalled} />;
         })()}
       </div>

uapi/tests/pipelineExecutionLogTelemetryUx.test.tsx

@@ -453,6 +453,53 @@ describe('TelemetryExplainerTrigger — specific section above generic', () => {
 // Pill placement — the pills render to the RIGHT of the chevron + title on
 // the SAME line (one flex row), not on a row above the title.
 // ---------------------------------------------------------------------------
+describe('PipelineExecutionLog — pre-first-row processing indicator', () => {
+  it('reads the live call-chain sentence before any row lands, matching the header pills', () => {
+    render(
+      <PipelineExecutionLog
+        output=""
+        isProcessing
+        error={null}
+        outputDetails={{}}
+        onRetry={() => {}}
+        onDismissError={() => {}}
+        userHasScrolled={false}
+        setUserHasScrolled={() => {}}
+        compact
+        pipelineMode="deposit"
+        liveContext={{
+          phase: 'setup',
+          agent: 'DepositInputComprehensionAgent',
+          step: 'plan',
+          failsafe: null,
+          generation: null,
+        }}
+      />,
+    );
+    expect(
+      screen.getByText('While Depositing, during Setup, agent Input Comprehension is Planning'),
+    ).toBeInTheDocument();
+  });
+
+  it("falls back to bare 'Processing' when no live context exists yet", () => {
+    render(
+      <PipelineExecutionLog
+        output=""
+        isProcessing
+        error={null}
+        outputDetails={{}}
+        onRetry={() => {}}
+        onDismissError={() => {}}
+        userHasScrolled={false}
+        setUserHasScrolled={() => {}}
+        compact
+        pipelineMode="deposit"
+      />,
+    );
+    expect(screen.getByText('Processing')).toBeInTheDocument();
+  });
+});
+
 describe('PipelineExecutionLog — pills inline with the title line', () => {
   const line = 'LLM call observed';
   const outputDetails = {