V48 Gate 3 (implementation-only): telemetry label correctness (Retry no longer renders 'Try'; 'Prepare Context'), 'Copy terse logs', call-ordered raw-LLM-IO sidecar

- Fix the 'retry'.includes('try') label-collision class: normalizeStepName
  (agent-generics + the operative uapi copy) now tests 'retry' before 'try';
  same fix in the PTRR-snapshot step inference and the PathPill step-icon
  rules; the header strip normalizes its step chips. A Retry step rendering
  as 'Try' after Refine presented as a PTRR sequencing bug — the engine order
  plan→try→refine→retry is checker-pinned canon (protocol V38_PTRR_STEP_IDS)
  and is unchanged. Retry rows now label, tooltip (STEP_SPECIFICS.retry was
  unreachable), icon, gerund ('Retrying'), and selector-highlight as Retry.
- Normalize the PrepareConciseContext display label to 'Prepare Context':
  FAILSAFE_PILL_NAMES entry, tooltip title override + generic failsafe copy,
  and the PTRR-snapshot raw machine-id leak now formats through formatMeta.
  Machine ids (prepare_concise_context et al.) unchanged.
- Add 'Copy terse logs' beside 'Copy raw logs': events compact to
  timestamp/type/namespace/key/call-chain/usage/message/error rows (error and
  message fields keep a 2000-char budget; other strings 200-char previews);
  the outputDetails duplication is omitted. A much smaller payload that keeps
  ordering, hierarchy, and failure forensics.
- writeRawLLMIO claims its monotonic sequence number before any await so
  fire-and-forget concurrent writes cannot swap on-disk file numbers (the
  judge-request-before-reason-response interleavings in run sidecars were
  logging artifacts, not engine concurrency).

Verified: uapi jest 155 suites / 597 tests green; agent-generics 19 suites /
99 tests green; uapi tsc --noEmit clean; eslint clean on touched files.

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

Author: geraldarthurdavis

packages/agent-generics/src/phaseHelpers/normalizeStepName.ts

@@ -14,9 +14,11 @@ export function normalizeStepName(step?: string): string {
   const lower = step.toLowerCase();
 
   if (lower.includes('plan')) return 'Plan';
+  // 'retry' must be tested before 'try': 'retry'.includes('try') is true, so
+  // the broader match would relabel every Retry step as Try.
+  if (lower.includes('retry')) return 'Retry';
   if (lower.includes('try')) return 'Try';
   if (lower.includes('refine')) return 'Refine';
-  if (lower.includes('retry')) return 'Retry';
   if (lower.includes('generate')) return 'Try';
   if (lower.includes('intensify')) return 'Retry';
 

packages/logger/src/logger.ts

@@ -265,11 +265,14 @@ export async function writeRawLLMIO(opts: {
     // exercises this same LLM-substep code path with mocked LLMs.
     if (process?.env?.NODE_ENV === 'test') return undefined;
 
-    const runDir = joinPath(RAW_LLM_LOG_BASE_DIR, sanitizeId(opts.executionId || 'run'));
-    try { await fs.mkdir(runDir, { recursive: true }); } catch {}
-
+    // Claim the sequence number before any await: callers fire-and-forget, so
+    // an await ahead of the increment lets concurrent writes swap numbers and
+    // the on-disk ordering stops reflecting call order.
     const safe = (s: any) => String(s || '').toLowerCase().replace(/[^a-z0-9-_]+/g, '-').slice(0, 160) || 'na';
     const seq = String(++__rawLLMIOSeq).padStart(5, '0');
+
+    const runDir = joinPath(RAW_LLM_LOG_BASE_DIR, sanitizeId(opts.executionId || 'run'));
+    try { await fs.mkdir(runDir, { recursive: true }); } catch {}
     const filename = joinPath(runDir, `${seq}-${safe(opts.pathKey)}.${opts.kind}.json`);
 
     const payload = opts.kind === 'error'

uapi/app/deposit/deposit-explainers.ts

@@ -146,11 +146,12 @@ export const DEPOSIT_SECTION_EXPLAINERS = {
     summary:
       'A live, source-safe stream of the SynthesizeAssetPacks pipeline actually running — every phase, agent, step, and LLM/tool call, with prompt and response content withheld by law.',
     detail:
-      'Rows appear only for completed LLM calls and tool uses, each carrying its full Phase→Agent→Step→Failsafe→Thinkings hierarchy; the processing indicator underneath shows what is currently running and how long since the last update, so a genuine stall is visible instead of an unexplained gap. Use "Copy raw logs" to grab the full run for support/debugging.',
+      'Rows appear only for completed LLM calls and tool uses, each carrying its full Phase→Agent→Step→Failsafe→Thinkings hierarchy; the processing indicator underneath shows what is currently running and how long since the last update, so a genuine stall is visible instead of an unexplained gap. Use "Copy raw logs" to grab the full run for support/debugging, or "Copy terse logs" for a compact distillation (hierarchy, ordering, usage, and errors — long bodies truncated).',
     points: [
       'Watch which phase/agent is running in real time',
       'The processing indicator flags a likely stall after ~90s of silence',
       'Copy raw logs exports the full source-safe run for debugging',
+      'Copy terse logs exports a compact distillation — call chains, ordering, usage, errors',
     ],
     references: {
       source: [

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

@@ -65,11 +65,13 @@ const PHASE_ICON_RULES: IconRule[] = [
 
 const STEP_ICON_RULES: IconRule[] = [
   ['plan', ClipboardIcon],
+  // 'retry' must precede 'try': rules are substring-matched in order and
+  // 'retry'.includes('try'), so the broader rule would claim Retry labels.
+  ['retry', LightningBoltIcon],
+  ['intensify', LightningBoltIcon],
   ['try', MagicWandIcon],
   ['generate', MagicWandIcon],
   ['refine', MixerHorizontalIcon],
-  ['retry', LightningBoltIcon],
-  ['intensify', LightningBoltIcon],
 ];
 
 const FAILSAFE_ICON_RULES: IconRule[] = [

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

@@ -40,19 +40,20 @@ export function titleCaseWords(value: string): string {
     .join(' ');
 }
 
-// "prepare_concise_context" -> "Prepare Concise Context"; "Discovery" -> "Discovery".
+// "chunk_then_sum" -> "Chunk Then Sum"; "Discovery" -> "Discovery".
 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 keeps its
-// descriptive name on the pill. The log title-line (pill) reads 'handle large
+// 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') while the pill keeps
-// the full 'Prepare Concise Context' name.
+// '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',
 };
@@ -146,9 +147,11 @@ export function normalizeStepName(step: string | undefined): string {
   const stepLower = step.toLowerCase();
 
   if (stepLower.includes('plan')) return 'Plan';
+  // 'retry' must be tested before 'try': 'retry'.includes('try') is true, so
+  // the broader match would relabel every Retry step as Try.
+  if (stepLower.includes('retry')) return 'Retry';
   if (stepLower.includes('try')) return 'Try';
   if (stepLower.includes('refine')) return 'Refine';
-  if (stepLower.includes('retry')) return 'Retry';
   if (stepLower.includes('generate')) return 'Try';
   if (stepLower.includes('intensify')) return 'Retry';
   if (stepLower.includes('initialize')) return 'Initialize';

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

@@ -1,6 +1,7 @@
 import React from 'react';
 
 import { ExecutionPhase, ExecutionStep, FailsafeStep, GenerationStep } from '@bitcode/streams';
+import { normalizeStepName } from './execution-telemetry-format';
 import styles from './pipeline-execution-log-header.module.css';
 
 interface PipelineRunLogHeaderProps {
@@ -127,7 +128,7 @@ export function PipelineExecutionLogHeader({
               {/* Show current step if available and different from agent name */}
               {step && step !== agent && (
                 <span className="text-xs font-medium bg-emerald-500/10 text-emerald-400 px-2 py-0.5 rounded whitespace-nowrap">
-                  {step}
+                  {normalizeStepName(step)}
                 </span>
               )}
             </div>
@@ -146,7 +147,7 @@ export function PipelineExecutionLogHeader({
 
                 {/* Step */}
                 <span className="px-1.5 py-0.5 rounded bg-gray-800 text-gray-300 font-medium border border-gray-700/50 text-[0.65rem]">
-                  {step || "Step NA"}
+                  {step ? normalizeStepName(step) : "Step NA"}
                 </span>
 
                 <svg className="w-2.5 h-2.5 text-gray-600 flex-shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor">

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

@@ -11,6 +11,7 @@ import {
   ExclamationTriangleIcon,
   InfoCircledIcon,
   ChevronRightIcon,
+  ListBulletIcon,
 } from '@radix-ui/react-icons';
 import FileDiffViewer from './FileDiffViewer';
 import type { FileDiff, FileTreeChange } from '@bitcode/streams';
@@ -362,6 +363,162 @@ export function buildRawLogCopyText(args: {
   ].join('');
 }
 
+// "Copy terse logs" string budgets: ordinary string fields truncate to
+// TERSE_STRING_LIMIT; fields whose key looks error-ish (error/message/stack)
+// keep TERSE_ERROR_STRING_LIMIT so failure forensics survive the distillation.
+const TERSE_STRING_LIMIT = 200;
+const TERSE_ERROR_STRING_LIMIT = 2000;
+const TERSE_ERROR_KEY = /error|message|stack/i;
+
+/**
+ * Recursively distill a copy payload for the "Copy terse logs" button: every
+ * string over its budget is truncated to a preview + '… [+N chars]' marker,
+ * while structure, ordering, counts, numbers, and short fields (the run's
+ * phase/agent/step/failsafe hierarchy, statuses, usage, timestamps) survive
+ * whole. Pure + exported for unit testing.
+ */
+export function distillTerseValue(value: unknown, keyHint?: string): unknown {
+  if (typeof value === 'string') {
+    const limit = keyHint && TERSE_ERROR_KEY.test(keyHint) ? TERSE_ERROR_STRING_LIMIT : TERSE_STRING_LIMIT;
+    return value.length > limit ? `${value.slice(0, limit)}… [+${value.length - limit} chars]` : value;
+  }
+  if (Array.isArray(value)) return value.map((item) => distillTerseValue(item, keyHint));
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+      out[key] = distillTerseValue(entry, key);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Compact one streamed run event ({id, created_at, event} or a bare payload)
+ * into a terse row: timestamp, canonical type, store identity (namespace/key),
+ * the full Phase→Agent→Step→Failsafe→Generation call chain + repair markers,
+ * provider/model/usage, a bounded message preview, and (near-)complete error
+ * bodies. Everything else — the raw stored values, executionState duplicates,
+ * metadata snapshots — is the payload bulk and is dropped.
+ */
+export function compactTerseEvent(entry: unknown): Record<string, unknown> {
+  const record = entry && typeof entry === 'object' ? (entry as Record<string, any>) : null;
+  const payload = record && 'event' in record ? record.event : entry;
+  const compact: Record<string, unknown> = {};
+  if (record?.created_at) compact.created_at = record.created_at;
+  if (!payload || typeof payload !== 'object') {
+    if (payload !== undefined && payload !== null) compact.value = distillTerseValue(payload);
+    return compact;
+  }
+  if (payload.type) compact.type = payload.type;
+  // Store identity: names WHAT was stored — tiny and load-bearing for ordering
+  // forensics (which agent/step/failsafe emitted what, in what sequence).
+  if (payload.namespace) compact.namespace = payload.namespace;
+  if (payload.key) compact.key = payload.key;
+  const executionState = extractExecutionState(payload) || {};
+  const CHAIN_FIELDS = [
+    'pipeline',
+    'phase',
+    'agent',
+    'step',
+    'failsafe',
+    'generation',
+    'tool',
+    'ptrrStepName',
+    'promptTemplateId',
+    'outputSchema',
+    'returnType',
+  ] as const;
+  for (const field of CHAIN_FIELDS) {
+    const value = executionState[field];
+    if (value !== undefined && value !== null && value !== '') compact[field] = value;
+  }
+  if (typeof executionState.stitchIteration === 'number') compact.stitchIteration = executionState.stitchIteration;
+  if (typeof executionState.chunkIndex === 'number') compact.chunkIndex = executionState.chunkIndex;
+  if (executionState.chunkSum === true) compact.chunkSum = true;
+  const status = payload.status || {};
+  // The source-safe stream projection carries its metadata under `data`
+  // (provider/model/tool/phase/agent/step/generation, plus contentChars for
+  // withheld bodies); `llm:usage` store events carry the usage object AS data.
+  const data = payload.data && typeof payload.data === 'object' ? payload.data : {};
+  for (const field of ['phase', 'agent', 'step', 'generation', 'tool'] as const) {
+    if (compact[field] === undefined && data[field] !== undefined && data[field] !== null && data[field] !== '') {
+      compact[field] = data[field];
+    }
+  }
+  const provider = payload.provider ?? status.provider ?? data.provider ?? executionState.provider;
+  const model = payload.model ?? status.model ?? data.model ?? executionState.model;
+  const usage =
+    payload.usage ??
+    status.usage ??
+    (payload.namespace === 'llm' && payload.key === 'usage' ? payload.data : undefined) ??
+    executionState.usage;
+  if (provider) compact.provider = provider;
+  if (model) compact.model = model;
+  if (usage !== undefined && usage !== null) compact.usage = distillTerseValue(usage);
+  if (typeof data.contentChars === 'number') compact.contentChars = data.contentChars;
+  if (typeof data.ok === 'boolean') compact.ok = data.ok;
+  const message = payload.message ?? status.message ?? payload.text;
+  // 'message' keyHint: event messages carry stall/failure text, so they get
+  // the larger error budget the __terse note promises for message fields.
+  if (typeof message === 'string' && message) compact.message = distillTerseValue(message, 'message');
+  const errorBody = payload.error ?? status.error;
+  if (errorBody !== undefined && errorBody !== null) compact.error = distillTerseValue(errorBody, 'error');
+  return compact;
+}
+
+/**
+ * Build the text the "Copy terse logs" button copies: the same run payload as
+ * "Copy raw logs", distilled to a much smaller but still debugging-useful
+ * form. When `copyData` carries an `events` array (the /deposit shape), every
+ * event compacts to its terse row (`compactTerseEvent`) and the
+ * `outputDetails` duplication is omitted; other payload fields keep their
+ * structure with long strings truncated (`distillTerseValue`) — error bodies
+ * keep a much larger budget. Pure + exported for unit testing.
+ */
+export function buildTerseLogCopyText(args: {
+  copyData?: unknown;
+  output?: string;
+  outputDetails?: Record<string, any>;
+  error?: string | null;
+}): string {
+  const { copyData, output, outputDetails, error } = args;
+  const note =
+    `Terse copy: run events are compacted to timestamp/type/call-chain/usage/error rows and long strings ` +
+    `are truncated to a preview + '… [+N chars]' (error/message/stack fields keep up to ` +
+    `${TERSE_ERROR_STRING_LIMIT} chars); ordering and counts are complete. Use 'Copy raw logs' for full bodies.`;
+  if (
+    copyData !== undefined &&
+    copyData &&
+    typeof copyData === 'object' &&
+    !Array.isArray(copyData) &&
+    Array.isArray((copyData as Record<string, any>).events)
+  ) {
+    const { events, outputDetails: duplicatedDetails, ...header } = copyData as Record<string, any>;
+    void duplicatedDetails;
+    const wrapped = {
+      __terse: note,
+      ...(distillTerseValue(header) as Record<string, unknown>),
+      outputDetails: '[omitted — duplicates the events; use Copy raw logs for full bodies]',
+      eventCount: events.length,
+      firstEventAt: events[0]?.created_at ?? null,
+      lastEventAt: events[events.length - 1]?.created_at ?? null,
+      events: events.map(compactTerseEvent),
+    };
+    return JSON.stringify(wrapped, null, 2);
+  }
+  const source =
+    copyData !== undefined
+      ? copyData
+      : { output: output || '', outputDetails: outputDetails ?? {}, error: error ?? null };
+  const distilled = distillTerseValue(typeof source === 'string' ? { output: source } : source);
+  const wrapped =
+    distilled && typeof distilled === 'object' && !Array.isArray(distilled)
+      ? { __terse: note, ...(distilled as Record<string, unknown>) }
+      : { __terse: note, data: distilled };
+  return JSON.stringify(wrapped, null, 2);
+}
+
 // Matches the default BITCODE_LLM_CALL_TIMEOUT_MS (AgentLLMsRegistry /
 // PipelineLLMRegistry) — past this many seconds with no new row, an in-flight
 // LLM call should already have timed out server-side, so continued silence is
@@ -471,6 +628,19 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
     }
   };
 
+  // "Copy terse logs": the same run payload distilled — long strings truncated,
+  // hierarchy/ordering/errors kept — for a much smaller but still useful copy.
+  const [copiedTerse, setCopiedTerse] = useState(false);
+  const handleCopyTerse = async () => {
+    const ok = await copyTextToClipboard(
+      buildTerseLogCopyText({ copyData, output, outputDetails, error }),
+    );
+    if (ok) {
+      setCopiedTerse(true);
+      setTimeout(() => setCopiedTerse(false), 1500);
+    }
+  };
+
   useLayoutEffect(() => {
     if (typeof window === 'undefined' || typeof ResizeObserver === 'undefined') return;
     if (!containerRef.current) return;
@@ -828,19 +998,34 @@ export const PipelineExecutionLog = forwardRef<HTMLDivElement, PipelineRunLogPro
 
   return (
     <div className="relative w-full">
-      <button
-        type="button"
-        onClick={handleCopyRaw}
-        title="Copy raw logs"
-        aria-label="Copy raw logs"
-        className="absolute top-2 right-2 z-30 flex h-7 w-7 items-center justify-center rounded-md border border-white/10 bg-black/40 text-neutral-300 backdrop-blur-sm transition hover:border-emerald-300/40 hover:text-emerald-200 focus:outline-none"
-      >
-        {copiedRaw ? (
-          <CheckIcon className="h-4 w-4 text-emerald-300" />
-        ) : (
-          <ClipboardCopyIcon className="h-4 w-4" />
-        )}
-      </button>
+      <div className="absolute top-2 right-2 z-30 flex items-center gap-1">
+        <button
+          type="button"
+          onClick={handleCopyTerse}
+          title="Copy terse logs"
+          aria-label="Copy terse logs"
+          className="flex h-7 w-7 items-center justify-center rounded-md border border-white/10 bg-black/40 text-neutral-300 backdrop-blur-sm transition hover:border-emerald-300/40 hover:text-emerald-200 focus:outline-none"
+        >
+          {copiedTerse ? (
+            <CheckIcon className="h-4 w-4 text-emerald-300" />
+          ) : (
+            <ListBulletIcon className="h-4 w-4" />
+          )}
+        </button>
+        <button
+          type="button"
+          onClick={handleCopyRaw}
+          title="Copy raw logs"
+          aria-label="Copy raw logs"
+          className="flex h-7 w-7 items-center justify-center rounded-md border border-white/10 bg-black/40 text-neutral-300 backdrop-blur-sm transition hover:border-emerald-300/40 hover:text-emerald-200 focus:outline-none"
+        >
+          {copiedRaw ? (
+            <CheckIcon className="h-4 w-4 text-emerald-300" />
+          ) : (
+            <ClipboardCopyIcon className="h-4 w-4" />
+          )}
+        </button>
+      </div>
       <div
         ref={(node) => {
           containerRef.current = node;
@@ -1448,10 +1633,11 @@ function renderLogLine(
                   try {
                     const stores = logLine.details?.status?.metadata?.stores || logLine.details?.metadata?.stores;
                     const stepLower = String(logLine.step || '').toLowerCase();
+                    // 'retry' must be tested before 'try' ('retry'.includes('try')).
                     const stepName = stepLower.includes('plan') ? 'plan'
+                      : stepLower.includes('retry') || stepLower.includes('intensify') ? 'retry'
                       : stepLower.includes('try') || stepLower.includes('generate') ? 'try'
                       : stepLower.includes('refine') ? 'refine'
-                      : stepLower.includes('retry') || stepLower.includes('intensify') ? 'retry'
                       : undefined;
                     if (!stores || !logLine.phase || !logLine.agent || !stepName) return null;
                     const vm = buildStepViewModel({ phase: logLine.phase, agent: logLine.agent, step: stepName as any }, stores);
@@ -1465,7 +1651,7 @@ function renderLogLine(
                           <div>
                             <span className="text-gray-500 mr-1">Failsafes:</span>
                             {vm.failsafes.map(f => (
-                              <span key={f.failsafe} className="inline-block mr-2 text-emerald-300">{f.failsafe}</span>
+                              <span key={f.failsafe} className="inline-block mr-2 text-emerald-300">{formatMeta(f.failsafe)}</span>
                             ))}
                           </div>
                           {vm.tools.used.length > 0 && (