V48 Gate 3 (implementation-only): telemetry display sweep — naming laws, detail-gated chevrons, DIV iteration markers, deterministic tool-row names

Naming laws (display only; machine/wire names unchanged):
- Agent pills drop the 'Agent' suffix and the ':deposit'/':read' lens
  qualifier ('ASSET PACK MEASURE ABSOLUTES AGENT:DEPOSIT' -> 'ASSET PACK
  MEASURE ABSOLUTES'); the processing sentence reads 'agent Input
  Comprehension is Trying' (agent-prefixed clause, suffix trimmed).
- 'Inherent Regurgitation' displays as 'Training Regurgitation'.
- Failsafe pills: 'handle large inputs' -> 'Handle Prompts', 'handle large
  outputs' -> 'Handle Completions' (sentence nouns follow: 'Reasoning over
  Prompts', 'Judging the Completions').
- Thinkings pill: 'Structured Output' -> 'Structure'.
- CS badges follow SC's xN pattern: '· chunk ×N' beside '· stitch ×N'.

Log rows:
- The Initializing empty-state renders as a regular collapsed row (was a
  mismatched sky-tinted block) and rows show a chevron / toggle only when a
  detail payload exists.
- DIV-loop iteration (1-based, latched from phase/iteration //
  pipeline/currentIteration stores, cleared at Finish) stamps onto every
  row ('iter N' beside the timestamp) and renders beside the run clock in
  /deposit's Telemetry header.
- Tool rows take their name from the execution node id ('…/tool:<Name>')
  deterministically: run 61c3b0cf's events show same-millisecond scrambling
  delivering a call's tool/name store after its result, which left rows
  named just 'tool' (no duplication — all rows were registry-level events).

ReadyToFinish verify (no change needed): the DIV loop re-iterates ONLY while
the gate returns false; the default gate reads the cross-phase
validation:readyToFinish artifact's finalApproval (plus validation:passed /
threaded passed|ready|finalApproval), and the agent's prompts frame a binary
admit-into-Finish vs short-circuit decision — a satisfied first pass exits
after one iteration.

Verified: uapi 155 suites / 605 tests green (new pins for every rename, the
node-id tool naming, and the iteration latch/stamp/clear); tsc clean.

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

Author: geraldarthurdavis

uapi/app/deposit/DepositPageClient.tsx

@@ -1450,6 +1450,14 @@ export default function DepositPageClient() {
                       endedAtMs={synthesisRunEndMs}
                       className="font-mono text-[0.72rem] text-emerald-100/90"
                     />
+                    {typeof synthesisActivity.currentIteration === "number" && (
+                      <span
+                        title="DIV loop iteration (Discovery → Implementation → Validation)"
+                        className="border border-emerald-300/15 bg-emerald-300/10 px-3 py-2 font-mono text-[0.62rem] uppercase tracking-[0.16em] text-emerald-100"
+                      >
+                        iter {synthesisActivity.currentIteration}
+                      </span>
+                    )}
                     <span className="border border-white/10 bg-black/30 px-3 py-2 font-mono text-[0.62rem] text-neutral-400">
                       {synthesisRunId}
                     </span>

uapi/app/terminal/terminal-run-activity.ts

@@ -28,6 +28,12 @@ export interface TerminalRunActivitySnapshot {
    * Null until the store event arrives.
    */
   mode: 'deposit' | 'read' | null;
+  /**
+   * The DIV loop's CURRENT iteration (1-based, latched from the
+   * pipeline/currentIteration store) — null before the loop starts and once
+   * the finish phase begins. Drives the header's 'iter N' marker.
+   */
+  currentIteration: number | null;
   /**
    * The CURRENT active call-chain: the rolling Phase→Agent→Step→Failsafe→
    * Generation context after the last streamed event — drives live header
@@ -104,6 +110,8 @@ interface ExecContext {
   step?: string | null;
   failsafe?: string | null;
   generation?: string | null;
+  /** DIV-loop iteration (1-based), latched from pipeline/currentIteration. */
+  iteration?: number | null;
 }
 
 function readEventExecutionState(payload: any): ExecContext {
@@ -145,6 +153,17 @@ function updateRollingContext(ctx: ExecContext, payload: any): void {
   }
   if (payload?.type === 'phase' && payload?.phase) ctx.phase = String(payload.phase);
   if (payload?.type === 'agent' && payload?.agent) ctx.agent = String(payload.agent);
+
+  // DIV-loop iteration (1-based): the SDIVF executor variant stores
+  // phase/iteration at each observed D/I/V phase start; the classic variant
+  // stores pipeline/currentIteration at the top of each pass. Setup precedes
+  // the first store and Finish runs outside the loop, so clear the latch once
+  // the finish phase starts.
+  if ((ns === 'phase' && key === 'iteration') || (ns === 'pipeline' && key === 'currentIteration')) {
+    const iteration = Number(value);
+    if (Number.isFinite(iteration) && iteration > 0) ctx.iteration = iteration;
+  }
+  if (String(ctx.phase || '').toLowerCase().includes('finish')) ctx.iteration = null;
 }
 
 type FormalLogLineKind = 'llm' | 'tool';
@@ -311,6 +330,7 @@ export function buildTerminalRunActivityFromEvents(
         step: own.step ?? rollingContext.step ?? null,
         failsafe: own.failsafe ?? null,
         generation: own.generation ?? null,
+        iteration: rollingContext.iteration ?? null,
       };
       const text = String(payload?.message || payload?.status?.message || '[content withheld — source-safe]');
       pushRow(text, stampExecutionState(merged, { ...payload, type: 'generation' }, deriveFailsafeRepairMarkers(payload)));
@@ -319,13 +339,27 @@ export function buildTerminalRunActivityFromEvents(
 
     if (kind === 'tool') {
       const acc = toolByNode.get(nodeId) || {};
+      // The execution node id carries the tool identity ('…/tool:<Name>')
+      // deterministically; the name-store accumulator is only a fallback —
+      // same-millisecond event scrambling can deliver a call's 'name' store
+      // after its 'result', which used to leave rows named just 'tool'.
+      const nodeToolSegment = nodeId
+        .split('/')
+        .reverse()
+        .find((segment) => segment.startsWith('tool:'));
+      const toolNameFromNode = nodeToolSegment ? nodeToolSegment.slice('tool:'.length) : '';
       const toolName =
-        acc.name || payload?.data?.tool || payload?.metadata?.toolName || (key === 'error' ? 'tool (failed)' : 'tool');
+        toolNameFromNode ||
+        acc.name ||
+        payload?.data?.tool ||
+        payload?.metadata?.toolName ||
+        (key === 'error' ? 'tool (failed)' : 'tool');
       // Tool uses have Phase/Agent/Step but no Failsafe/Thinkings.
       const merged: ExecContext = {
         phase: rollingContext.phase ?? null,
         agent: rollingContext.agent ?? null,
         step: rollingContext.step ?? null,
+        iteration: rollingContext.iteration ?? null,
       };
       const enriched = stampExecutionState(merged, { ...payload, type: 'tool-use' }, { tool: toolName });
       enriched.metadata = {
@@ -366,6 +400,7 @@ export function buildTerminalRunActivityFromEvents(
         generation: rollingContext.generation ?? null,
       }
       : null,
+    currentIteration: rollingContext.iteration ?? null,
   };
 }
 
@@ -397,5 +432,6 @@ export function buildTerminalRunActivityFromMock(
     iterationUpdates: snapshot.iterationUpdates || [],
     mode: null,
     latestContext: null,
+    currentIteration: null,
   };
 }

uapi/components/base/bitcode/execution/ExecutionContextPillRow.tsx

@@ -31,9 +31,10 @@ export interface ExecutionContextPillRowProps {
 }
 
 /**
- * Badge real failsafe-handling work on the pill label: 'stitch ×N' marks the
- * Nth stitch repair; 'chunk N' a chunk task generation; 'sum' the chunk
- * summing generation. Absent markers = the non-triggering path.
+ * Badge real failsafe-handling work on the pill label with one shared ×N
+ * pattern: CS counts chunks ('chunk ×N' = the Nth chunk task generation,
+ * 'sum' the combining generation), SC counts stitches ('stitch ×N' = the Nth
+ * repair). Absent markers = the non-triggering path.
  */
 export function buildFailsafePillLabel(args: {
   failsafe: string;
@@ -47,7 +48,7 @@ export function buildFailsafePillLabel(args: {
   } else if (args.chunkSum) {
     label = `${label} · sum`;
   } else if (typeof args.chunkIndex === 'number') {
-    label = `${label} · chunk ${args.chunkIndex}`;
+    label = `${label} · chunk ×${args.chunkIndex}`;
   }
   return label;
 }

uapi/components/base/bitcode/execution/execution-telemetry-format.ts

@@ -45,23 +45,24 @@ export function humanizeNounPhrase(value: string): string {
   return titleCaseWords(value.replace(/[_-]/g, ' '));
 }
 
-// Client-side normalized failsafe names: ChunkThenSum handles LARGE INPUTS,
-// StitchComplete handles LARGE OUTPUTS; PrepareConciseContext displays as
-// 'Prepare Context' (the 'Concise' qualifier is an internal naming detail,
-// dropped from the label). The log title-line (pill) reads 'handle large
-// inputs'; the processing sentence reads title-cased without 'handle'
-// ('Reasoning over Large Inputs'). PrepareConciseContext reads simply
-// 'Context' in the sentence ('Reasoning over Context').
+// Client-side normalized failsafe names: ChunkThenSum handles the PROMPT side
+// (oversized requests), StitchComplete the COMPLETION side (incomplete
+// responses); PrepareConciseContext displays as 'Prepare Context' (the
+// 'Concise' qualifier is an internal naming detail, dropped from the label).
+// The log title-line (pill) reads 'Handle Prompts' / 'Handle Completions';
+// the processing sentence reads the bare noun ('Reasoning over Prompts',
+// 'Judging the Completions'). PrepareConciseContext reads simply 'Context'
+// in the sentence ('Reasoning over Context').
 export const FAILSAFE_PILL_NAMES: Record<string, string> = {
   prepare_concise_context: 'Prepare Context',
-  chunk_then_sum: 'handle large inputs',
-  stitch_until_complete: 'handle large outputs',
+  chunk_then_sum: 'Handle Prompts',
+  stitch_until_complete: 'Handle Completions',
 };
 
 export const FAILSAFE_SENTENCE_NAMES: Record<string, string> = {
   prepare_concise_context: 'Context',
-  chunk_then_sum: 'Large Inputs',
-  stitch_until_complete: 'Large Outputs',
+  chunk_then_sum: 'Prompts',
+  stitch_until_complete: 'Completions',
 };
 
 function normalizeFailsafeKey(value: string): string {
@@ -76,9 +77,15 @@ export function formatFailsafeSentenceName(value: string): string {
   return FAILSAFE_SENTENCE_NAMES[normalizeFailsafeKey(value)] || humanizeNounPhrase(value);
 }
 
-// "structured_output" -> "Structured Output" for the generation pill.
+// Thinkings generation pill names: 'structured_output' reads 'Structure';
+// 'reason'/'judge' humanize to 'Reason'/'Judge'.
+export const GENERATION_PILL_NAMES: Record<string, string> = {
+  structured_output: 'Structure',
+};
+
 export function formatGenerationName(value: string): string {
-  return humanizeNounPhrase(value);
+  const key = value.trim().toLowerCase().replace(/[\s-]+/g, '_');
+  return GENERATION_PILL_NAMES[key] || humanizeNounPhrase(value);
 }
 
 /**
@@ -103,32 +110,53 @@ export function trimPipelineAgentName(value: string): string {
   return trimmed || String(value || '');
 }
 
-// Pill label: pipeline prefix trimmed AND CamelCase split into words, keeping
-// the trailing 'Agent' — 'DepositInputComprehensionAgent' -> 'Input
-// Comprehension Agent' (the pill's CSS uppercases it to word-spaced caps).
+// Display-name overrides applied after humanization (raw/machine agent names
+// are unchanged): the regurgitation lens displays as TRAINING regurgitation.
+const AGENT_DISPLAY_OVERRIDES: Record<string, string> = {
+  'inherent regurgitation': 'Training Regurgitation',
+};
+
+function applyAgentDisplayOverrides(spacedName: string): string {
+  return AGENT_DISPLAY_OVERRIDES[spacedName.trim().toLowerCase()] || spacedName;
+}
+
+// Strip display-noise suffixes from an already pipeline-trimmed agent name:
+// the ':deposit'/':read' lens qualifier and the trailing 'Agent' word (every
+// pill/sentence names agents WITHOUT the 'Agent' suffix).
+function stripAgentSuffixes(value: string): string {
+  return value
+    .replace(/:[a-z][a-z0-9_-]*$/i, '')
+    .replace(/Agent$/, '')
+    .replace(/[-_]agent$/i, '')
+    .trim();
+}
+
+// Pill label: pipeline prefix + ':lens' qualifier + trailing 'Agent' trimmed,
+// CamelCase split into words — 'DepositInputComprehensionAgent' -> 'Input
+// Comprehension'; 'AssetPackMeasureAbsolutesAgent:deposit' -> 'Asset Pack
+// Measure Absolutes' (the pill's CSS uppercases it to word-spaced caps).
 export function formatAgentPillName(value: string): string {
-  const trimmed = trimPipelineAgentName(value);
+  const trimmed = stripAgentSuffixes(trimPipelineAgentName(value));
   const spaced = trimmed
     .replace(/[_-]/g, ' ')
     .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
     .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
     .replace(/\s{2,}/g, ' ')
     .trim();
-  return spaced || trimmed;
+  return applyAgentDisplayOverrides(spaced || trimmed);
 }
 
-// "DepositInputComprehensionAgent" -> "Input Comprehension" (pipeline prefix
-// trimmed, trailing "Agent" stripped — the sentence template appends the
-// literal word "Agent").
+// "DepositInputComprehensionAgent" -> "Input Comprehension" (pipeline prefix,
+// ':lens' qualifier, and trailing "Agent" stripped — the sentence template
+// prefixes the literal word "agent").
 export function humanizeAgentName(value: string): string {
-  const withoutPipeline = trimPipelineAgentName(value);
-  const withoutTrailingAgent = withoutPipeline.replace(/Agent$/, '').replace(/-agent$/, '');
-  const spaced = withoutTrailingAgent
+  const withoutSuffixes = stripAgentSuffixes(trimPipelineAgentName(value));
+  const spaced = withoutSuffixes
     .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);
+  return applyAgentDisplayOverrides(titleCaseWords(spaced || withoutSuffixes));
 }
 
 export function gerundFor(map: Record<string, string>, raw: string): string {
@@ -214,7 +242,7 @@ export function normalizePhaseName(phase: string | undefined): string {
 
 /**
  * Render the live execution context as a natural-language sentence:
- * "While {Depositing|Reading}, during {Phase}, {Agent} Agent is {Step-ing},
+ * "While {Depositing|Reading}, during {Phase}, agent {Name} is {Step-ing},
  * by {Thinkings-ing} the {Failsafe}." The 'While {Pipeline}, ' prefix is only
  * added when the pipeline mode is known (latched from the stream or passed by
  * the page); without it the sentence starts at 'During {Phase}, '. Degrades
@@ -233,7 +261,7 @@ export function describeExecutionContext(ctx: {
   if (!ctx.phase || !ctx.agent || !ctx.step) return null;
   const modeKey = String(ctx.mode || '').trim().toLowerCase() as SynthesisPipelineMode;
   const pipelineGerund = PIPELINE_GERUNDS[modeKey];
-  const during = `uring ${humanizeNounPhrase(ctx.phase)}, ${humanizeAgentName(ctx.agent)} Agent is ${gerundFor(STEP_GERUNDS, ctx.step)}`;
+  const during = `uring ${humanizeNounPhrase(ctx.phase)}, agent ${humanizeAgentName(ctx.agent)} is ${gerundFor(STEP_GERUNDS, ctx.step)}`;
   let sentence = pipelineGerund ? `While ${pipelineGerund}, d${during}` : `D${during}`;
   if (ctx.generation && ctx.failsafe) {
     sentence += `, by ${thinkingsGerundPhrase(ctx.generation)} ${formatFailsafeSentenceName(ctx.failsafe)}`;