V48 Gate 3 (specification-implementation): lock rich telemetry to LLM calls + Tool uses; consolidate hierarchy pills (F19)

After F18 the raw-content rows were gone, but the synthesis telemetry still rendered intermediate store values as standalone rows (`try`, `setup-plan`, `thricified-generation`, a cwd path, a bare agent name) and split the hierarchy across rows instead of consolidating it onto one rich log line.

Formal log-line contract (now enforced): the rich telemetry renders EXACTLY two formal kinds, plus a few terminal/high-level signals — nothing else.
- LLM call: the inference leaf (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.
- Tool use: tool|tools:result|error carrying Phase->Agent->Step + tool name/arguments (no Failsafe/Thricified).
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: it advances a rolling hierarchy but never becomes a row.

Implementation:
- terminal-run-activity.ts: buildTerminalRunActivityFromEvents maintains a rolling {phase, agent, step, failsafe, generation} context updated from every event, classifies each event, and emits a row ONLY for LLM calls / Tool uses / terminal signals. LLM rows stamp their own 5-field hierarchy; tool rows stamp Phase/Agent/Step from context + the tool name/args accumulated per tool-execution node (tool stores carry no hierarchy and use the singular `tool` namespace). Distinct calls that share withheld text stay distinct via a unique null-separated row key (TELEMETRY_ROW_KEY_SEP).
- pipeline-execution-log.tsx: derive displayText from the row key (text before the null separator), look up details by the full key, run text heuristics on displayText, and bypass message de-dup for uniquely-keyed rows so distinct LLM/tool calls never collapse.

Spec (BITCODE_SPEC_V48_NOTES.md) records the formal log-line contract; QA ledger records F19. uapi tsc 0; new F19 contract test (fragments suppressed; LLM row = 5-pill hierarchy; tool row = Phase/Agent/Step + tool) + 10-suite telemetry/terminal/deposit regression batch (38 tests) green; spec checker green.

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

Author: geraldarthurdavis

BITCODE_SPEC_V48_NOTES.md

@@ -201,6 +201,23 @@ Accepted V48 architecture law (decided 2026-06-25):
   row, never fragmented by embedded newlines) and the log row title spans carry
   `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 +
+  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,
+  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
+  LLM/tool row is stamped with its full hierarchy) but never emits it as a row.
+  Distinct calls that share withheld text stay distinct rows via a unique
+  null-separated row key; the renderer displays the text before the separator,
+  keys details by the full key, and bypasses de-dup for uniquely-keyed rows. This
+  is what removes the `try`/`setup-plan`/`thricified-generation`/path fragments
+  and stabilizes the pipeline↔UI payload contract.
 - **OTF (on-the-fly instructions) is eradicated entirely** as legacy residue:
   the dead telemetry types (`otf_instructions`/`otf_adherence`), the unused
   `setOnTheFly` prompt primitive, the live instruction-injection feature (the

BITCODE_V48_QA.md

@@ -190,6 +190,17 @@ Track 3-4 scripts (BTD ledger, settlement, pack journaling) get added when those
   - `pipeline-execution-log.tsx` + `DepositPageClient.tsx` — `min-w-0` on the compact/desktop title spans and on the telemetry panel section/wrapper (+ `overflow-hidden` on the panel) so a long line truncates within its row instead of x-overflowing the page.
 - Related observation (not yet filed): the deposit run executes `ReadFitsFindingSynthesisSetupPlanAgent` planning a "Read-Need" — a read-lens setup agent running under the deposit lens. Telemetry is now source-safe regardless, but the deposit setup-plan agent identity should be confirmed/queued as a separate correctness finding.
 
+### F19 — Rich telemetry fragments the hierarchy across rows; lock it to LLM calls + Tool uses only
+
+- Severity: medium (telemetry correctness + pipeline↔UI contract stability).
+- Observed (2026-06-26): after F18 the raw-content rows were gone, but the Synthesis run telemetry still rendered intermediate store values as standalone rows — `try`, `setup-plan`, `thricified-generation`, a cwd path, a bare agent name — and the hierarchy was split across rows (Phase on one, Step+Generation on another, Agent on a third) instead of consolidated onto one rich log line.
+- Contract (decided 2026-06-26): the rich telemetry renders EXACTLY two formal log-line kinds, nothing else — (a) **LLM calls**, which carry the full hierarchy Phase→Agent→Step→Failsafe→Thricified + source-safe content + provider/model/usage; (b) **Tool uses**, which carry Phase→Agent→Step + tool name/arguments (no Failsafe/Thricified). Every other store event (step/agent/phase name stores, prompt-side llm keys, `llm/response` registry copies, paths, generation markers, tool sub-keys) is intermediate context that advances the rolling hierarchy but never becomes a row.
+- Cause: `ExecutionStreamAdapter.onStore` emits one event per `execution.store(...)`, and `buildTerminalRunActivityFromEvents` turned any event with a non-empty message into a row. The canonical LLM-call event (`llm/output`, type `generation`) already carries the full hierarchy in its value, but tool stores use the singular `tool` namespace with no hierarchy (and `inferEventType` only recognized plural `tools`), so tool calls were mis-typed and hierarchy-less.
+- Repair (2026-06-26, `terminal-run-activity.ts` + `pipeline-execution-log.tsx`):
+  - The activity builder maintains a rolling `{phase, agent, step, failsafe, generation}` context updated from every event, and emits a row ONLY for LLM calls (`generation` / `llm:output`), Tool uses (`tool|tools:result|error`), and terminal/high-level signals (`completion`/`error`/no-namespace status). LLM rows stamp their own 5-field hierarchy; tool rows stamp Phase/Agent/Step from the rolling context + the tool name/args accumulated per tool-execution node.
+  - Distinct calls that share withheld text are kept distinct via a unique null-separated row key (`TELEMETRY_ROW_KEY_SEP`); the renderer displays only the text before the separator, looks up details by the full key, and bypasses message de-dup for uniquely-keyed rows.
+- Verified: uapi tsc 0; F19 contract test (fragments suppressed, LLM row carries 5-pill hierarchy, tool row carries Phase/Agent/Step + tool) + 10-suite telemetry/terminal/deposit regression batch (38 tests) 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

@@ -88,6 +88,107 @@ function normalizeEventMessage(payload: any) {
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// Formal telemetry log-line contract (V48, QA F19)
+//
+// The rich telemetry renders EXACTLY two formal log-line kinds, plus a few
+// terminal/high-level signals — nothing else:
+//   • LLM call  — the inference leaf. Canonically the Thricified substep output
+//     (`llm/output`, stream type `generation`), whose value carries the full
+//     hierarchy {phase, agent, step, failsafe, generation}. Rendered with all
+//     five pills + source-safe content + provider/model/usage metadata.
+//   • Tool use  — a tool invocation inside a step (`tool/result` on success,
+//     `tool/error` on failure). Carries Phase/Agent/Step (from the rolling
+//     context — tool stores don't embed the hierarchy) + tool name/arguments.
+// Every other store event (step/agent/phase name stores, prompt-side llm keys,
+// `llm/response` registry copies, cwd paths, generation markers, tool sub-keys)
+// is intermediate CONTEXT: it updates the rolling hierarchy but never becomes a
+// row. This is what stops `try` / `setup-plan` / `thricified-generation` / path
+// fragments from fragmenting the log and stabilizes the pipeline↔UI contract.
+// ---------------------------------------------------------------------------
+
+// A null byte separates a row's display text from a unique row key in the
+// `output` string. The renderer splits each line on it: text before, key after.
+// Distinct LLM/tool calls that share withheld text (e.g. two `[content withheld]`
+// reason calls in one step) therefore stay distinct rows instead of collapsing
+// under the renderer's text-keyed de-dup.
+export const TELEMETRY_ROW_KEY_SEP = '\u0000';
+
+interface ExecContext {
+  phase?: string | null;
+  agent?: string | null;
+  step?: string | null;
+  failsafe?: string | null;
+  generation?: string | null;
+}
+
+function readEventExecutionState(payload: any): ExecContext {
+  const es =
+    (payload?.status?.executionState && typeof payload.status.executionState === 'object'
+      ? payload.status.executionState
+      : null) ||
+    (payload?.executionState && typeof payload.executionState === 'object' ? payload.executionState : null) ||
+    {};
+  const data = payload?.data && typeof payload.data === 'object' ? payload.data : {};
+  return {
+    phase: es.phase ?? data.phase ?? null,
+    agent: es.agent ?? data.agent ?? null,
+    step: es.step ?? data.step ?? null,
+    failsafe: es.failsafe ?? data.failsafe ?? null,
+    generation: es.generation ?? data.generation ?? null,
+  };
+}
+
+// Merge a freshly observed context into the rolling one (non-null wins). Name
+// stores (`phase/current`, `agent/name`, `step/name`) and the live-stream
+// `phase`/`agent` transition events carry the hierarchy as a bare value rather
+// than in executionState, so fold those in explicitly.
+function updateRollingContext(ctx: ExecContext, payload: any): void {
+  const es = readEventExecutionState(payload);
+  if (es.phase) ctx.phase = es.phase;
+  if (es.agent) ctx.agent = es.agent;
+  if (es.step) ctx.step = es.step;
+  if (es.failsafe) ctx.failsafe = es.failsafe;
+  if (es.generation) ctx.generation = es.generation;
+
+  const ns = String(payload?.namespace || '');
+  const key = String(payload?.key || '');
+  const value = payload?.data;
+  if (typeof value === 'string') {
+    if (ns === 'phase' && (key === 'current' || key === 'name')) ctx.phase = value;
+    if (ns === 'agent' && key === 'name') ctx.agent = value;
+    if (ns === 'step' && key === 'name') ctx.step = value;
+  }
+  if (payload?.type === 'phase' && payload?.phase) ctx.phase = String(payload.phase);
+  if (payload?.type === 'agent' && payload?.agent) ctx.agent = String(payload.agent);
+}
+
+type FormalLogLineKind = 'llm' | 'tool' | 'signal' | 'status';
+
+function classifyFormalLogLine(payload: any): FormalLogLineKind | null {
+  const type = String(payload?.type || '');
+  const ns = String(payload?.namespace || '');
+  const key = String(payload?.key || '');
+
+  // Formal LLM call: the Thricified substep output is canonical (full hierarchy).
+  if (type === 'generation') return 'llm';
+  if (ns === 'llm' && key === 'output') return 'llm';
+
+  // Formal tool use: one row per completed tool call (result | error).
+  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;
+}
+
 export function buildTerminalRunActivityFromEvents(
   events: ExecutionEvent[],
   latestWorkUpdate: any | null,
@@ -110,6 +211,33 @@ export function buildTerminalRunActivityFromEvents(
     }
   }
 
+  // Rolling hierarchy + per-tool-node accumulators drive the formal log-line
+  // contract: only LLM calls and Tool uses (plus terminal/high-level signals)
+  // become rows; every other event just advances the rolling context.
+  const rollingContext: ExecContext = {};
+  const toolByNode = new Map<string, { name?: string; input?: unknown }>();
+  let rowSeq = 0;
+
+  const pushRow = (displayText: string, enriched: any) => {
+    const text = toSafeSingleLine(displayText);
+    if (!text) return;
+    // Unique key keeps distinct LLM/tool calls from collapsing under the
+    // renderer's text-keyed de-dup; the renderer strips everything from the
+    // separator on for display.
+    const rowKey = `${text}${TELEMETRY_ROW_KEY_SEP}${rowSeq++}`;
+    outputLines.push(rowKey);
+    outputDetails[rowKey] = enriched;
+  };
+
+  const stampExecutionState = (state: ExecContext, payload: any, extra?: Record<string, unknown>) => ({
+    ...payload,
+    executionState: { ...state, ...(extra || {}) },
+    status: {
+      ...(payload?.status && typeof payload.status === 'object' ? payload.status : {}),
+      executionState: { ...state, ...(extra || {}) },
+    },
+  });
+
   for (const entry of events) {
     const payload = entry.event || {};
     if (payload?.type === 'work-update' && payload.update) {
@@ -119,12 +247,71 @@ export function buildTerminalRunActivityFromEvents(
       continue;
     }
 
+    // Every event advances the rolling hierarchy before we decide whether it is
+    // itself a formal log line.
+    updateRollingContext(rollingContext, payload);
+
+    // Accumulate tool name/arguments per tool-execution node so the eventual
+    // result/error row can render the complete tool-use line.
+    const ns = String(payload?.namespace || '');
+    const key = String(payload?.key || '');
+    const nodeId = String(payload?.executionNodeId || '');
+    if ((ns === 'tool' || ns === 'tools') && nodeId) {
+      if (key === 'name' && typeof payload?.data === 'string') {
+        const acc = toolByNode.get(nodeId) || {};
+        acc.name = payload.data;
+        toolByNode.set(nodeId, acc);
+      } else if (key === 'input' || key === 'arguments') {
+        const acc = toolByNode.get(nodeId) || {};
+        acc.input = payload?.data ?? null;
+        toolByNode.set(nodeId, acc);
+      }
+    }
+
+    const kind = classifyFormalLogLine(payload);
+    if (!kind) continue;
+
+    if (kind === 'llm') {
+      // The LLM call carries the full hierarchy itself; fall back to the rolling
+      // context only for any field the event omits.
+      const own = readEventExecutionState(payload);
+      const merged: ExecContext = {
+        phase: own.phase ?? rollingContext.phase ?? null,
+        agent: own.agent ?? rollingContext.agent ?? null,
+        step: own.step ?? rollingContext.step ?? null,
+        failsafe: own.failsafe ?? null,
+        generation: own.generation ?? null,
+      };
+      const text = String(payload?.message || payload?.status?.message || '[content withheld — source-safe]');
+      pushRow(text, stampExecutionState(merged, { ...payload, type: 'generation' }));
+      continue;
+    }
+
+    if (kind === 'tool') {
+      const acc = toolByNode.get(nodeId) || {};
+      const toolName =
+        acc.name || payload?.data?.tool || payload?.metadata?.toolName || (key === 'error' ? 'tool (failed)' : 'tool');
+      // Tool uses have Phase/Agent/Step but no Failsafe/Thricified.
+      const merged: ExecContext = {
+        phase: rollingContext.phase ?? null,
+        agent: rollingContext.agent ?? null,
+        step: rollingContext.step ?? null,
+      };
+      const enriched = stampExecutionState(merged, { ...payload, type: 'tool-use' }, { tool: toolName });
+      enriched.metadata = {
+        ...(payload?.metadata && typeof payload.metadata === 'object' ? payload.metadata : {}),
+        toolName,
+        toolInput: acc.input ?? null,
+      };
+      pushRow(toolName, enriched);
+      if (nodeId) toolByNode.delete(nodeId);
+      continue;
+    }
+
+    // Terminal/high-level signal — keep as an informational row.
     const normalized = normalizeEventMessage(payload);
     if (!normalized) continue;
-    const safeText = toSafeSingleLine(normalized.text);
-    if (!safeText) continue;
-    outputLines.push(safeText);
-    outputDetails[safeText] = payload;
+    pushRow(normalized.text, payload);
   }
 
   const latestStatusEvent = statusEvents[statusEvents.length - 1];