V48 Gate 3 (specification-implementation): telemetry pill icons + reduce rows to the LLM-call layer (F21)

Two telemetry-consistency fixes:

Pill icons (PathPill.tsx): the Agent pill had no icon, and Step/Failsafe/Thricified pills frequently had none because the icon maps were keyed by labels that don't match the real values (Try, read-comprehension, synthesis, structured_output). Now every pill type renders a guaranteed icon — a per-type default (Agent = person, Tool = sliders) refined by a substring match on the normalized label — so PTRR steps, Thricified generations, failsafe stages, and custom step names always resolve an icon. Colors and the compact top/bottom order already matched the role contract (Phase grey + Agent blue on top; Step/Failsafe/Thricified on the bottom).

Row reduction (terminal-run-activity.ts): the formal-log-line classifier now returns ONLY 'llm' and 'tool'. Informational status, phase banners, and completion/error notices are no longer accordion rows — run completion is surfaced by the processing indicator and errors by the log's error banner. Dead normalizeEventMessage helper removed.

Spec records the tightened log-line contract + the pill role/icon mapping; QA ledger records F21. uapi tsc 0; terminalTransactionActivity (tightened to assert only the LLM-call row) + 7-suite telemetry batch green; spec checker green.

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

Author: geraldarthurdavis

BITCODE_SPEC_V48_NOTES.md

@@ -208,13 +208,18 @@ Accepted V48 architecture law (decided 2026-06-25):
   `min-w-0` so a long line truncates within its row rather than x-overflowing the
   page (QA F18).
 - **Formal telemetry log-line contract** (QA F19): the rich telemetry renders
-  EXACTLY two formal log-line kinds, plus a few terminal/high-level signals —
-  nothing else. (1) **LLM calls** — the inference leaf, canonically the Thricified
-  substep output (`llm/output`, stream type `generation`), carrying the full
-  hierarchy Phase→Agent→Step→Failsafe→Thricified + source-safe content +
+  EXACTLY two formal log-line kinds — the ultimate LLM-call layer and Tool uses,
+  nothing else (informational status, phase banners, and completion/error notices
+  are NOT rows: run completion shows via the processing indicator and errors via
+  the log's error banner). (1) **LLM calls** — the inference leaf, canonically the
+  Thricified substep output (`llm/output`, stream type `generation`), carrying the
+  full hierarchy Phase→Agent→Step→Failsafe→Thricified + source-safe content +
   provider/model/usage, each level its own pill. (2) **Tool uses** —
   `tool|tools:result|error`, carrying Phase→Agent→Step + tool name/arguments (no
-  Failsafe/Thricified). Every other store event (step/agent/phase name stores,
+  Failsafe/Thricified). Pills map by fixed role: Phase (grey, phase icon) top-left,
+  Agent (blue, agent icon) top-2nd; Step / Failsafe / Thricified bottom 1-2-3, each
+  with a guaranteed icon (per-type default refined by a label substring match).
+  Every other store event (step/agent/phase name stores,
   prompt-side llm keys, the `llm/response` registry copy, cwd paths, generation
   markers, tool sub-keys) is intermediate CONTEXT: the activity builder folds it
   into a rolling `{phase, agent, step, failsafe, generation}` context (so the next

BITCODE_V48_QA.md

@@ -209,6 +209,16 @@ Track 3-4 scripts (BTD ledger, settlement, pack journaling) get added when those
 - Cause: `factorySDIVFExecutorPipeline` composes the phases with `sequential`, which runs preprocess and every phase on ISOLATED sibling child executions (`execution.child('seq-N')`). `factoryPreprocess` stored the resolved mode on its own child (`seq-0`); the phases run on `seq-1`/`seq-2` and resolve the mode with `synthesizeAssetPacksModeFromExecution`, which only walks ANCESTORS — never sideways to `seq-0`. So every phase resolved `null → 'read'`, took the read branch, and resolved the init-registered read agents. The agents registry is already shared (the read implementation agent is registered by the phase and resolves), so the only gap was the mode.
 - Repair (2026-06-26, `index.ts`): the `factorySynthesizeAssetPacksPipeline` wrapper now resolves the mode and stores it on the shared outer execution (the parent of all `seq-N` phase children) before running the SDIVF executor, so every phase resolves it via the upward walk. Once the phases see `deposit`, their mode-conditional registrations (setup comprehension override, deposit Discovery agents, deposit Implementation/Validation) take effect on the shared registry and the deposit-lens agents run — which also makes the telemetry verbiage deposit-correct at the root. Read mode is unchanged (default was already read). Regression test added (sibling isolation reproduced; shared-parent storage resolves). Needs a live deposit run to confirm end-to-end.
 
+### F21 — Telemetry pill icons + reduce rows to the ultimate LLM-call layer
+
+- Severity: low (telemetry consistency).
+- Observed (2026-06-26): the Agent pill had no icon; Step/Failsafe/Thricified pills frequently had no icon (the icon maps were keyed by labels that don't match the real values — `Try`, `read-comprehension`, `synthesis`, `structured_output`). Informational rows ("AssetPacksSynthesis started", "Building source inventory", "Inventory ready…", "Running SynthesizeAssetPacks…", "Pipeline yielded no admissible options…") still rendered alongside the LLM-call rows.
+- Contract: pills map by fixed role — Phase (grey, phase icon) top-left, Agent (blue, agent icon) top-2nd; Step / Failsafe / Thricified bottom 1-2-3 (each with its icon). The rich log renders ONLY the ultimate LLM-call layer + Tool uses; nothing else is a row.
+- Repair (2026-06-26):
+  - `PathPill.tsx` — every pill type renders a guaranteed icon: a per-type default (Agent = person, Tool = sliders) refined by a substring match on the normalized label, so PTRR steps / Thricified generations / failsafe stages / custom step names always resolve an icon. Colors and the compact top/bottom pill order already matched the role contract.
+  - `terminal-run-activity.ts` — the formal-log-line classifier now returns only `llm` and `tool`; informational status / completion / error rows are dropped from the accordion (run completion is shown by the processing indicator, errors by the log's error banner). The dead `normalizeEventMessage` helper is removed.
+- Verified: uapi tsc 0; terminalTransactionActivity (tightened) + 7-suite telemetry batch green.
+
 ## Track 1 — Identity / Authentication / Auxillaries — COMPLETE 2026-06-12 (email deferred by decision; F2/F9 and legacy eradication queued for gates)
 
 - [x] Sign up / sign in via Connect Wallet (nav CTA → SignUpWindow → wallet signature on testnet4 → `custom:bitcode-bitcoin` session → `/tps/supabase/callback`) — verified 2026-06-12 after F5 fix; lands on `/packs`. Re-verified from fully nuked state (purged user + cleared site data): created 19:29:21 → session 19:29:25 → binding auto-written 19:29:29 by the bridge on `/packs` mount with no Auxillaries visit; UI consistent across nav, Wallet, and Profile panes.

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

@@ -54,40 +54,6 @@ function toSafeSingleLine(value: string): string {
     : collapsed;
 }
 
-function normalizeEventMessage(payload: any) {
-  if (!payload || typeof payload !== 'object') return null;
-
-  if (payload?.status?.message) {
-    return { text: String(payload.status.message), key: `status:${String(payload.status.message)}` };
-  }
-
-  if (payload?.message) {
-    return { text: String(payload.message), key: `message:${String(payload.message)}` };
-  }
-
-  if (payload?.type === 'pipeline') {
-    return { text: `[pipeline:${payload.status}]`, key: `pipeline:${payload.status}:${payload.timestamp || ''}` };
-  }
-
-  if (payload?.type === 'phase') {
-    return { text: `[phase:${payload.status}] ${payload.phase}`, key: `phase:${payload.phase}:${payload.status}:${payload.timestamp || ''}` };
-  }
-
-  if (payload?.type === 'agent') {
-    return { text: `[agent:${payload.status}] ${payload.agent}`, key: `agent:${payload.agent}:${payload.status}:${payload.timestamp || ''}` };
-  }
-
-  if (payload?.type === 'error') {
-    return { text: `[error] ${payload.error || payload.message || 'Unknown error'}`, key: `error:${payload.error || payload.message || ''}:${payload.timestamp || ''}` };
-  }
-
-  if (payload?.type === 'completion') {
-    return { text: '[completion]', key: `completion:${payload.timestamp || ''}` };
-  }
-
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // Formal telemetry log-line contract (V48, QA F19)
 //
@@ -163,13 +129,20 @@ function updateRollingContext(ctx: ExecContext, payload: any): void {
   if (payload?.type === 'agent' && payload?.agent) ctx.agent = String(payload.agent);
 }
 
-type FormalLogLineKind = 'llm' | 'tool' | 'signal' | 'status';
+type FormalLogLineKind = 'llm' | 'tool';
 
 function classifyFormalLogLine(payload: any): FormalLogLineKind | null {
   const type = String(payload?.type || '');
   const ns = String(payload?.namespace || '');
   const key = String(payload?.key || '');
 
+  // The rich telemetry renders ONLY the ultimate LLM-call layer and Tool uses —
+  // each with its complete hierarchy (LLM: Phase/Agent/Step/Failsafe/Thricified;
+  // Tool: Phase/Agent/Step + tool). Everything else (informational status, phase
+  // banners, completion/error notices) advances the rolling context but never
+  // becomes a row; run completion is surfaced by the processing indicator and
+  // errors by the log's error banner, not by accordion rows.
+
   // Formal LLM call: the Thricified substep output is canonical (full hierarchy).
   if (type === 'generation') return 'llm';
   if (ns === 'llm' && key === 'output') return 'llm';
@@ -178,14 +151,6 @@ function classifyFormalLogLine(payload: any): FormalLogLineKind | null {
   if (type === 'tool-use') return 'tool';
   if ((ns === 'tool' || ns === 'tools') && (key === 'result' || key === 'error')) return 'tool';
 
-  // Terminal signals — not fragments; keep them as informational rows.
-  if (type === 'completion' || type === 'error') return 'signal';
-
-  // High-level status emitted via emitEvent (no store namespace), e.g. "Pipeline
-  // execution started". onStore fragment status events always carry a namespace
-  // and are suppressed (context only).
-  if (type === 'status' && !ns) return 'status';
-
   return null;
 }
 
@@ -307,11 +272,6 @@ export function buildTerminalRunActivityFromEvents(
       if (nodeId) toolByNode.delete(nodeId);
       continue;
     }
-
-    // Terminal/high-level signal — keep as an informational row.
-    const normalized = normalizeEventMessage(payload);
-    if (!normalized) continue;
-    pushRow(normalized.text, payload);
   }
 
   const latestStatusEvent = statusEvents[statusEvents.length - 1];

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

@@ -29,7 +29,12 @@ const typeToClasses: Record<PillType, string> = {
   generation: `${BASE} bg-gradient-to-r from-amber-600/40 to-amber-600/10 text-amber-100 ring-amber-500/40`,
   tool: `${BASE} bg-gradient-to-r from-indigo-600/40 to-indigo-600/10 text-indigo-100 ring-indigo-500/40`,
 };
-// Optional icon per pill value ------------------------------------------------
+// Icon per pill — every pill TYPE renders a consistent icon. The icon is a
+// per-type default, refined by a substring match on the (normalized) label.
+// Labels drift across the pipeline — PTRR steps (Plan/Try/Refine/Retry),
+// Thricified generations (reason/judge/structured_output), failsafe stages, and
+// custom step names like `read-comprehension`/`synthesis` — so matching is by
+// substring and ALWAYS falls back to the type default, guaranteeing an icon.
 import {
   GearIcon,
   MagnifyingGlassIcon,
@@ -41,50 +46,74 @@ import {
   MixerHorizontalIcon,
   LightningBoltIcon,
   StackIcon,
-  ArrowLeftIcon,
-  ArrowRightIcon,
+  PersonIcon,
   ChatBubbleIcon,
   ScissorsIcon,
   LayersIcon,
 } from '@radix-ui/react-icons';
 
-const PhaseIcon: Record<string, React.ComponentType<any>> = {
-  Setup: GearIcon,
-  Discovery: MagnifyingGlassIcon,
-  Implementation: Pencil2Icon,
-  Validation: CheckCircledIcon,
-  Finish: RocketIcon,
-};
+type IconComponent = React.ComponentType<any>;
+type IconRule = [match: string, Icon: IconComponent];
 
-const StepIcon: Record<string, React.ComponentType<any>> = {
-  Plan: ClipboardIcon,
-  Generate: MagicWandIcon,
-  Refine: MixerHorizontalIcon,
-  Intensify: LightningBoltIcon,
-};
+const PHASE_ICON_RULES: IconRule[] = [
+  ['setup', GearIcon],
+  ['discovery', MagnifyingGlassIcon],
+  ['implementation', Pencil2Icon],
+  ['validation', CheckCircledIcon],
+  ['finish', RocketIcon],
+];
 
-const FailsafeIcon: Record<string, React.ComponentType<any>> = {
-  'Prepare Context': StackIcon,
-  'Handle Input': ArrowLeftIcon,
-  'Handle Output': ArrowRightIcon,
-};
+const STEP_ICON_RULES: IconRule[] = [
+  ['plan', ClipboardIcon],
+  ['try', MagicWandIcon],
+  ['generate', MagicWandIcon],
+  ['refine', MixerHorizontalIcon],
+  ['retry', LightningBoltIcon],
+  ['intensify', LightningBoltIcon],
+];
+
+const FAILSAFE_ICON_RULES: IconRule[] = [
+  ['prepare', StackIcon],
+  ['chunk', ScissorsIcon],
+  ['stitch', LayersIcon],
+];
 
-const GenerationIcon: Record<string, React.ComponentType<any>> = {
-  Reason: ChatBubbleIcon,
-  Judge: ScissorsIcon,
-  Structure: LayersIcon,
+const GENERATION_ICON_RULES: IconRule[] = [
+  ['reason', ChatBubbleIcon],
+  ['judge', ScissorsIcon],
+  ['structur', LayersIcon], // matches "structure" / "structured_output"
+];
+
+const TYPE_DEFAULT_ICON: Record<PillType, IconComponent> = {
+  phase: GearIcon,
+  agent: PersonIcon,
+  step: ClipboardIcon,
+  failsafe: StackIcon,
+  generation: ChatBubbleIcon,
+  tool: MixerHorizontalIcon,
 };
 
-function getIcon(type: PillType, label: string): React.ComponentType<any> | null {
+function matchIcon(rules: IconRule[], label: string): IconComponent | null {
+  const lower = label.toLowerCase();
+  for (const [match, Icon] of rules) {
+    if (lower.includes(match)) return Icon;
+  }
+  return null;
+}
+
+function getIcon(type: PillType, label: string): IconComponent | null {
   switch (type) {
     case 'phase':
-      return PhaseIcon[label as keyof typeof PhaseIcon] || null;
+      return matchIcon(PHASE_ICON_RULES, label) ?? TYPE_DEFAULT_ICON.phase;
     case 'step':
-      return StepIcon[label as keyof typeof StepIcon] || null;
+      return matchIcon(STEP_ICON_RULES, label) ?? TYPE_DEFAULT_ICON.step;
     case 'failsafe':
-      return FailsafeIcon[label as keyof typeof FailsafeIcon] || null;
+      return matchIcon(FAILSAFE_ICON_RULES, label) ?? TYPE_DEFAULT_ICON.failsafe;
     case 'generation':
-      return GenerationIcon[label as keyof typeof GenerationIcon] || null;
+      return matchIcon(GENERATION_ICON_RULES, label) ?? TYPE_DEFAULT_ICON.generation;
+    case 'agent':
+    case 'tool':
+      return TYPE_DEFAULT_ICON[type];
     default:
       return null;
   }

uapi/tests/terminalTransactionActivity.test.ts

@@ -39,8 +39,12 @@ describe('terminal-run-activity helpers', () => {
       null,
     );
 
-    expect(snapshot.output).toContain('Preparing run');
-    expect(snapshot.output).toContain('[completion]');
+    // Only the LLM-call layer becomes a row; informational status and the
+    // completion notice are dropped from the log (surfaced via the processing
+    // indicator / executionState / isStreamingComplete instead).
+    expect(snapshot.output).toContain('Model call completed');
+    expect(snapshot.output).not.toContain('Preparing run');
+    expect(snapshot.output).not.toContain('[completion]');
     expect(snapshot.executionState.phase).toBe('Discovery');
     expect(snapshot.isStreamingComplete).toBe(true);
     expect(snapshot.generationCount).toBe(1);