V48 Gate 3 (implementation-only): normalize the processing-indicator label to a plain-English sentence

The stall indicator's raw "Phase → Agent → Step → Failsafe → Thricified"
hierarchy string read as machine dump, not guidance. Rewrote it as: "During
{Phase}, {Agent} Agent is {Step-ing}, by {Thricified-ing} the {Failsafe}." —
e.g. "During Setup, Deposit Input Comprehension Agent is Planning, by
Judging the Prepare Concise Context." Degrades gracefully: with no
Failsafe/Thricified yet (a Tool-use context only ever carries Phase/Agent/
Step, per F19) it ends after the Step clause; with no Phase/Agent/Step at
all it falls back to the bare "Processing" sentence, both still suffixed
with "· Ns since last update".

PTRR steps and Thricified generation sub-steps map through small fixed
gerund lookup tables (plan/try/refine/retry; reason/judge/structured_output
-> Structuring); Phase/Failsafe render as humanized noun phrases
(underscores -> spaces, title case); Agent names have a trailing "Agent"
stripped and camelCase split before the template appends the literal word
"Agent" back.

Updated/added unit tests: the full sentence exactly matches the requested
template + example, the Tool-use partial-context degrade, and the bare
Processing fallback. uapi tsc 0; 24/24 across the touched suites.

Author: geraldarthurdavis

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

@@ -403,11 +403,78 @@ export function buildRawLogCopyText(args: {
 // a genuine-hang signal rather than a merely slow generation.
 const LIKELY_STALL_SECONDS = 90;
 
+// PTRR step -> present-continuous verb ("Plan" -> "Planning").
+const STEP_GERUNDS: Record<string, string> = {
+  plan: 'Planning',
+  try: 'Trying',
+  refine: 'Refining',
+  retry: 'Retrying',
+};
+
+// Thricified generation sub-step -> present-continuous verb (GenerationSubMetaSubStep).
+const THRICIFIED_GERUNDS: Record<string, string> = {
+  reason: 'Reasoning',
+  judge: 'Judging',
+  structured_output: 'Structuring',
+};
+
+function titleCaseWords(value: string): string {
+  return value
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ');
+}
+
+// "prepare_concise_context" -> "Prepare Concise Context"; "Discovery" -> "Discovery".
+function humanizeNounPhrase(value: string): string {
+  return titleCaseWords(value.replace(/_/g, ' '));
+}
+
+// "DepositInputComprehensionAgent" -> "Deposit Input Comprehension" (trailing
+// "Agent" stripped — the sentence template appends the literal word "Agent").
+function humanizeAgentName(value: string): string {
+  const withoutTrailingAgent = value.replace(/Agent$/, '');
+  const spaced = withoutTrailingAgent
+    .replace(/_/g, ' ')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .trim();
+  return titleCaseWords(spaced || withoutTrailingAgent);
+}
+
+function gerundFor(map: Record<string, string>, raw: string): string {
+  return map[raw.trim().toLowerCase()] || humanizeNounPhrase(raw);
+}
+
 /**
- * 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).
+ * Render the live execution context as a natural-language sentence: "During
+ * {Phase}, {Agent} Agent is {Step-ing}, by {Thricified-ing} the {Failsafe}."
+ * Degrades gracefully as fields are unknown (e.g. a Tool-use context only ever
+ * carries Phase/Agent/Step, never Failsafe/Thricified — F19). Returns null
+ * when there isn't enough context yet to say anything meaningful.
+ */
+function describeExecutionContext(ctx: {
+  phase?: string | null;
+  agent?: string | null;
+  step?: string | null;
+  failsafe?: string | null;
+  generation?: string | null;
+}): string | null {
+  if (!ctx.phase || !ctx.agent || !ctx.step) return null;
+  let sentence = `During ${humanizeNounPhrase(ctx.phase)}, ${humanizeAgentName(ctx.agent)} Agent is ${gerundFor(STEP_GERUNDS, ctx.step)}`;
+  if (ctx.generation && ctx.failsafe) {
+    sentence += `, by ${gerundFor(THRICIFIED_GERUNDS, ctx.generation)} the ${humanizeNounPhrase(ctx.failsafe)}`;
+  }
+  return sentence;
+}
+
+/**
+ * Build the live "During {Phase}, {Agent} Agent is {Step}... · 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) or not enough context to describe.
  */
 export function buildProcessingStallLabel(
   lastLine: Pick<LogLine, 'phase' | 'agent' | 'step' | 'failsafe' | 'generation' | 'timestamp'> | undefined,
@@ -418,12 +485,10 @@ export function buildProcessingStallLabel(
   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 sentence = describeExecutionContext(lastLine);
   const likelyStalled = elapsedSeconds >= LIKELY_STALL_SECONDS;
-  const label = hierarchy
-    ? `Running: ${hierarchy} · ${elapsedSeconds}s since last update`
+  const label = sentence
+    ? `${sentence} · ${elapsedSeconds}s since last update`
     : `Processing · ${elapsedSeconds}s since last update`;
   return { label, likelyStalled };
 }

uapi/tests/pipelineExecutionLogCopy.test.tsx

@@ -58,7 +58,7 @@ describe('buildProcessingStallLabel — live stall visibility (QA debug aid)', (
     });
   });
 
-  it('renders the hierarchy + elapsed seconds since the last line, not stalled under the threshold', () => {
+  it('renders a natural-language sentence + elapsed seconds since the last line, not stalled under the threshold', () => {
     const lastLine = {
       phase: 'Discovery',
       agent: 'DepositDepositorySearchAgent',
@@ -69,11 +69,43 @@ describe('buildProcessingStallLabel — live stall visibility (QA debug aid)', (
     };
     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',
+      'During Discovery, Deposit Depository Search Agent is Trying, by Structuring the Chunk Then Sum · 30s since last update',
     );
     expect(likelyStalled).toBe(false);
   });
 
+  it('matches the "During {Phase}, {Agent} Agent is {Step}, by {Thricified} the {Failsafe}" template exactly', () => {
+    const lastLine = {
+      phase: 'Setup',
+      agent: 'DepositInputComprehensionAgent',
+      step: 'plan',
+      failsafe: 'prepare_concise_context',
+      generation: 'judge',
+      timestamp: new Date(0).toISOString(),
+    };
+    const { label } = buildProcessingStallLabel(lastLine, 21_000);
+    expect(label).toBe(
+      'During Setup, Deposit Input Comprehension Agent is Planning, by Judging the Prepare Concise Context · 21s since last update',
+    );
+  });
+
+  it('degrades to just the Phase/Agent/Step clause when there is no Failsafe/Thricified yet (e.g. a Tool-use context)', () => {
+    const lastLine = {
+      phase: 'Discovery',
+      agent: 'DepositCodebaseComprehensionAgent',
+      step: 'try',
+      timestamp: new Date(0).toISOString(),
+    };
+    const { label } = buildProcessingStallLabel(lastLine, 5_000);
+    expect(label).toBe('During Discovery, Deposit Codebase Comprehension Agent is Trying · 5s since last update');
+  });
+
+  it('falls back to the bare "Processing" sentence when Phase/Agent/Step are not yet known', () => {
+    const lastLine = { phase: 'Discovery', agent: 'DepositDepositorySearchAgent', timestamp: new Date(0).toISOString() };
+    const { label } = buildProcessingStallLabel(lastLine, 5_000);
+    expect(label).toBe('Processing · 5s since last update');
+  });
+
   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);