@hicaru/pi-rlm 0.3.18 → 0.3.20

package/src/text/parsing.ts

@@ -49,10 +49,55 @@ export type StateFenceResult =
 
 const STATE_FENCE = /(`{3,})[ \t]*state[ \t]*\r?\n([\s\S]*?)\1/g;
 
+/** Tolerant fallback: a payload object whose FIRST key is the patch key, emitted without a
+ *  (well-formed) fence — soak keeps catching `...report.state {"state_patch": …}}` blobs from
+ *  small models that mangle the opening backticks. Matched literally so ordinary prose or
+ *  example JSON never trips the scanner. */
+const BARE_PATCH = /\{"state_patch"\s*:/g;
+
+/** String-aware balanced-brace scan from `start` (an index of `{`). Honors string literals and
+ *  backslash escapes so braces inside JSON strings cannot unbalance the count. Returns the
+ *  complete object slice, or undefined when braces never balance before EOF. */
+function balancedJsonObject(text: string, start: number): string | undefined {
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return undefined;
+}
+
+/** A dangling opener/closer pair after the fence body was mangled (e.g. `.state {…}}` followed
+ *  by a lone ``` line) — cosmetic residue we scrub alongside the object itself. */
+const ORPHAN_FENCE = /^ {0,3}`{3,}[ \t]*\r?$/gm;
+
+/** Bookkeeping transport, never content: remove well-formed ```state fences AND the bare
+ *  {"state_patch"…} objects models leak when they botch the fence syntax (both directions —
+ *  parse for Σ harvest, strip for user-visible answers). Order: well-formed fences out first,
+ *  then the bare-object scan over the remainder can never double-count the same payload. */
+function sansFences(text: string): string {
+  return text.replace(STATE_FENCE, "");
+}
+
 /**
  * Workstream A: extract ```state fences (model-proposed ΔΣ_t) from a response, in document
- * order. ```repl parsing is untouched — the two fences coexist in one response. Malformed
- * JSON is surfaced as an error result for the retry loop, never thrown.
+ * order. ```repl parsing is untouched — the two fences coexist in one response. Well-formed
+ * fences yield parsed payloads or a parse error (error-as-observation for the retry ladder);
+ * malformed-fence payloads are recovered by the tolerant bare-object scanner, so a mangled
+ * opening fence never orphans a valid delta.
  */
 export function findStatePatches(text: string): readonly StateFenceResult[] {
   const out: StateFenceResult[] = [];
@@ -67,9 +112,50 @@ export function findStatePatches(text: string): readonly StateFenceResult[] {
       out.push({ ok: false, error: errorMessage(err) });
     }
   }
+  // Tolerant harvest over fence-free remainder (well-formed payloads already taken above).
+  const rest = sansFences(text);
+  BARE_PATCH.lastIndex = 0;
+  while ((m = BARE_PATCH.exec(rest)) !== null) {
+    const obj = balancedJsonObject(rest, m.index);
+    if (obj === undefined) continue;
+    try {
+      out.push({ ok: true, value: JSON.parse(obj) as unknown });
+    } catch (err: unknown) {
+      out.push({ ok: false, error: errorMessage(err) });
+    }
+  }
   return out;
 }
 
+/** Strip ```state fences from free text. A Σ fence is bookkeeping, never content — but models
+ *  that finalize right after a Σ splice tend to echo the fence verbatim as their final output,
+ *  which leaked raw state JSON into RlmResult.answer (bench graders scored JSON, reports showed
+ *  bookkeeping). Deterministic scrub on the answer path; parse semantics stay in findStatePatches.
+ *  Also removes bare {"state_patch"…} objects (mangled-fence leaks), a `state` token glued to
+ *  preceding prose, and orphan ``` lines left behind by the mangled pair. */
+export function stripStateFences(text: string): string {
+  let out = sansFences(text);
+  const parts: string[] = [];
+  let cursor = 0;
+  BARE_PATCH.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = BARE_PATCH.exec(out)) !== null) {
+    const obj = balancedJsonObject(out, m.index);
+    if (obj === undefined) continue;
+    // Glom any immediately-preceding bare `state`/`.state` token (prose like "...report.state {").
+    const before = out.slice(cursor, m.index).replace(/\s*(?:\.?state)\s*$/i, "");
+    parts.push(before);
+    cursor = m.index + obj.length;
+    BARE_PATCH.lastIndex = cursor;
+  }
+  // No bare objects → leave the text exactly as the well-formed pass left it (a lone ```
+  // line can be a legitimate unclosed code fence in real content; only scrub residue that
+  // our own removal created).
+  if (parts.length === 0) return out.trim();
+  parts.push(out.slice(cursor));
+  return parts.join("").replace(ORPHAN_FENCE, "").trim();
+}
+
 /** Truncate REPL stdout for the model's context window (head + tail, with an elision note).
  *  `mark` lets callers specialize the wording (root elision cites the session log) while the
  *  head/tail math stays the one implementation. */

package/src/tool/repl-details.ts

@@ -18,8 +18,8 @@ export interface ReplDetails {
   readonly executionTimeMs: number;
   /** Sub-calls triggered during this execution (llm_query, rlm_query, etc.). */
   readonly subcalls: readonly RlmSubcall[];
-  /** Running totals for this repl() call (cost + tokens from sub-LLM calls). */
-  readonly totals: { readonly costUsd: number; readonly tokens: number };
+  /** Running totals for this repl() call (tokens from sub-LLM calls). */
+  readonly totals: { readonly tokens: number };
   /** Final answer submitted through answer["ready"] without echoing it to the model. */
   readonly finalAnswer?: string;
   /** Detached spawn() sub-calls still running when this call returned. Absent when none. */

package/src/tool/repl-tool.ts

@@ -270,7 +270,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         stderr: errors,
         executionTimeMs: 0,
         subcalls: [],
-        totals: { costUsd: 0, tokens: 0 },
+        totals: { tokens: 0 },
       }));
       if (!validation.ok) return validation.error;
       const params = validation.value;
@@ -318,7 +318,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
             stderr: capturedStderr,
             executionTimeMs: Date.now() - startedAt,
             subcalls: live.length > 0 ? [...store.getSubcalls(), ...live] : store.getSubcalls(),
-            totals: { costUsd: own.costUsd + bg.costUsd, tokens: own.tokens + bg.tokens },
+            totals: { tokens: own.tokens + bg.tokens },
             backgroundPending: background.pending > 0 ? background.pending : undefined,
           };
         },
@@ -400,12 +400,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           ? [...store.getSubcalls(), ...adopted.subcalls]
           : store.getSubcalls();
         const totals = {
-          costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
           tokens: store.getTotals().tokens + adopted.totals.tokens,
         };
         const subUsage: Usage = {
           input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: totals.tokens,
-          cost: { total: totals.costUsd, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          cost: { total: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         };
         onUsage?.(subUsage, "sub");
 
@@ -453,7 +452,6 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           executionTimeMs: 0,
           subcalls: [...store.getSubcalls(), ...adopted.subcalls],
           totals: {
-            costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
             tokens: store.getTotals().tokens + adopted.totals.tokens,
           },
           backgroundPending: background.pending > 0 ? background.pending : undefined,

package/src/tool/rlm-aggregator.ts

@@ -55,7 +55,7 @@ export class RlmEventAggregator extends EmitterListener {
   }
 
   private handleRootUsage(event: RootUsageEvent): void {
-    this.store.addRootUsage(event.costUsd, event.tokens, event.tokensIn, event.tokensOut);
+    this.store.addRootUsage(event.tokens, event.tokensIn, event.tokensOut);
     this.notify();
   }
 

package/src/tool/rlm-details.ts

@@ -31,7 +31,6 @@ export interface RlmSubcall {
   readonly resultPreview?: string;
   readonly startedAt: number;
   readonly endedAt?: number;
-  readonly costUsd: number;
   readonly tokens: number;
   /** In/out split (input / output) — mirrors tokens. */
   readonly tokensIn: number;
@@ -49,7 +48,7 @@ export interface RlmDetails {
   readonly rootPrompt: string;
   readonly turns: { readonly current: number; readonly max: number };
   readonly subcalls: readonly RlmSubcall[];
-  readonly totals: { readonly costUsd: number; readonly tokens: number; readonly tokensIn: number; readonly tokensOut: number };
+  readonly totals: { readonly tokens: number; readonly tokensIn: number; readonly tokensOut: number };
   readonly answer?: string;
 }
 

package/src/tool/rlm-events.ts

@@ -38,8 +38,6 @@ export interface SubcallUpdatedEvent {
   readonly args?: string;
   readonly resultPreview?: string;
   /** Delta — additive on both the subcall and running totals. */
-  readonly costUsd?: number;
-  /** Delta — additive on both the subcall and running totals. */
   readonly tokens?: number;
   /** Deltas for the in/out split shown in the tree (input / output). Additive like tokens. */
   readonly tokensIn?: number;
@@ -56,7 +54,6 @@ export interface TurnEvent {
 }
 
 export interface RootUsageEvent {
-  readonly costUsd: number;
   readonly tokens: number;
   readonly tokensIn?: number;
   readonly tokensOut?: number;
@@ -108,7 +105,7 @@ export class RlmEmitter {
     return id;
   }
 
-  /** Update an existing sub-call. All fields are partial. costUsd/tokens are additive. */
+  /** Update an existing sub-call. All fields are partial. tokens are additive. */
   emitSubcallUpdated(event: SubcallUpdatedEvent): void {
     this.ee.emit("subcall:updated", event);
   }
@@ -119,8 +116,8 @@ export class RlmEmitter {
   }
 
   /** Accumulate usage directly to root-level totals. */
-  emitRootUsage(costUsd: number, tokens: number, tokensIn?: number, tokensOut?: number): void {
-    this.ee.emit("root-usage", { costUsd, tokens, tokensIn, tokensOut } satisfies RootUsageEvent);
+  emitRootUsage(tokens: number, tokensIn?: number, tokensOut?: number): void {
+    this.ee.emit("root-usage", { tokens, tokensIn, tokensOut } satisfies RootUsageEvent);
   }
 
   /** Set the final answer text (root-only). */

package/src/tool/rlm-tool.ts

@@ -51,7 +51,7 @@ export function createRlmTool(controller: RlmController, runRegistry?: RunRegist
         rootPrompt: "",
         turns: { current: 0, max: 0 },
         subcalls: [],
-        totals: { costUsd: 0, tokens: 0, tokensIn: 0, tokensOut: 0 },
+        totals: { tokens: 0, tokensIn: 0, tokensOut: 0 },
       }));
       if (!validation.ok) return validation.error;
       const params = validation.value;

package/src/tool/subcall-store.ts

@@ -14,9 +14,8 @@ type MutableSubcall = {
   -readonly [Key in keyof RlmSubcall]: RlmSubcall[Key];
 };
 
-/** Accumulated cost/tokens, shared by getTotals() and takeSettledSubtrees(). */
+/** Accumulated tokens, shared by getTotals() and takeSettledSubtrees(). */
 export interface SubcallTotals {
-  readonly costUsd: number;
   readonly tokens: number;
   /** In/out split (input / output) — mirrors tokens, shown separately in the tree. */
   readonly tokensIn: number;
@@ -26,11 +25,9 @@ export interface SubcallTotals {
 export class SubcallStore extends EmitterListener {
   private readonly subcalls = new Map<string, MutableSubcall>();
 
-  private totalCostUsd = 0;
   private totalTokens = 0;
   private totalTokensIn = 0;
   private totalTokensOut = 0;
-  private rootCostUsd = 0;
   private rootTokens = 0;
   private rootTokensIn = 0;
   private rootTokensOut = 0;
@@ -57,7 +54,6 @@ export class SubcallStore extends EmitterListener {
       detail: event.detail,
       args: event.args,
       startedAt: Date.now(),
-      costUsd: 0,
       tokens: 0,
       tokensIn: 0,
       tokensOut: 0,
@@ -76,10 +72,6 @@ export class SubcallStore extends EmitterListener {
     if (event.detail !== undefined) sc.detail = event.detail;
     if (event.args !== undefined) sc.args = event.args;
     if (event.resultPreview !== undefined) sc.resultPreview = event.resultPreview;
-    if (event.costUsd !== undefined) {
-      sc.costUsd += event.costUsd;
-      this.totalCostUsd += event.costUsd;
-    }
     if (event.tokens !== undefined) {
       sc.tokens += event.tokens;
       this.totalTokens += event.tokens;
@@ -105,7 +97,7 @@ export class SubcallStore extends EmitterListener {
 
   /** Snapshot running totals. O(1). */
   getTotals(): SubcallTotals {
-    return { costUsd: this.totalCostUsd, tokens: this.totalTokens, tokensIn: this.totalTokensIn, tokensOut: this.totalTokensOut };
+    return { tokens: this.totalTokens, tokensIn: this.totalTokensIn, tokensOut: this.totalTokensOut };
   }
 
   /**
@@ -141,7 +133,6 @@ export class SubcallStore extends EmitterListener {
     };
 
     const taken: RlmSubcall[] = [];
-    let costUsd = 0;
     let tokens = 0;
     let tokensIn = 0;
     let tokensOut = 0;
@@ -149,7 +140,6 @@ export class SubcallStore extends EmitterListener {
       const subtree = settledSubtree(root);
       if (subtree === undefined) continue;
       for (const node of subtree) {
-        costUsd += node.costUsd;
         tokens += node.tokens;
         tokensIn += node.tokensIn;
         tokensOut += node.tokensOut;
@@ -157,22 +147,19 @@ export class SubcallStore extends EmitterListener {
         this.subcalls.delete(node.id);
       }
     }
-    this.totalCostUsd -= costUsd;
     this.totalTokens -= tokens;
     this.totalTokensIn -= tokensIn;
     this.totalTokensOut -= tokensOut;
-    return { subcalls: taken, totals: { costUsd, tokens, tokensIn, tokensOut } };
+    return { subcalls: taken, totals: { tokens, tokensIn, tokensOut } };
   }
 
   // ── Root usage (delegated from RlmEventAggregator) ──
 
   /** Accumulate root-level usage into shared totals. Called by aggregator. */
-  addRootUsage(costUsd: number, tokens: number, tokensIn = 0, tokensOut = 0): void {
-    this.totalCostUsd += costUsd;
+  addRootUsage(tokens: number, tokensIn = 0, tokensOut = 0): void {
     this.totalTokens += tokens;
     this.totalTokensIn += tokensIn;
     this.totalTokensOut += tokensOut;
-    this.rootCostUsd += costUsd;
     this.rootTokens += tokens;
     this.rootTokensIn += tokensIn;
     this.rootTokensOut += tokensOut;
@@ -180,6 +167,6 @@ export class SubcallStore extends EmitterListener {
 
   /** Root engine's OWN spend (driver-model turns only) — never blends sub-call models. */
   getRootUsage(): SubcallTotals {
-    return { costUsd: this.rootCostUsd, tokens: this.rootTokens, tokensIn: this.rootTokensIn, tokensOut: this.rootTokensOut };
+    return { tokens: this.rootTokens, tokensIn: this.rootTokensIn, tokensOut: this.rootTokensOut };
   }
 }

package/src/ui/config-panel.ts

@@ -9,7 +9,7 @@ import { THINKING_LEVELS } from "../config/settings.ts";
 
 const CHOICES = Object.freeze({
   maxDepth: Object.freeze(["1", "2", "3", "4"]),
-  maxIterations: Object.freeze(["10", "20", "30", "50"]),
+  maxIterations: Object.freeze(["100", "200", "500", "1000"]),
   execTimeoutS: Object.freeze(["30", "60", "120", "300"]),
   maxConcurrentSubcalls: Object.freeze(["2", "4", "8", "16", "32"]),
   maxConcurrentChildren: Object.freeze(["1", "2", "3", "4", "6", "8"]),
@@ -20,7 +20,6 @@ const CHOICES = Object.freeze({
   compaction: Object.freeze(["on", "off"]),
   compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
-  rootSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
   smartReasoning: Object.freeze(["default", ...Object.keys(THINKING_LEVELS)]),
   subSamplingMaxTokens: Object.freeze(["1024", "2048", "4096", "8192"]),
   subSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
@@ -43,7 +42,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
   let edited = config;
   const items: SettingItem[] = [
     item("maxDepth", "Max recursion depth", String(config.maxDepth), CHOICES.maxDepth, "rlm_query past this depth degrades to plain llm_query (1 = no recursion)."),
-    item("maxIterations", "Max iterations", String(config.maxIterations), CHOICES.maxIterations, "Maximum root REPL turns before RLM asks the model for a final answer."),
+    item("maxIterations", "Max iterations", String(config.maxIterations), CHOICES.maxIterations, "Maximum root REPL turns before RLM asks the model for a final answer. Large by design — runs end on FINAL/errors/wall-clock first."),
     item("execTimeoutS", "REPL block timeout (s)", String(config.execTimeoutS), CHOICES.execTimeoutS, "Wall-clock limit for one model-authored Python REPL block."),
     item("maxConcurrentSubcalls", "Max concurrent sub-calls", String(config.maxConcurrentSubcalls), CHOICES.maxConcurrentSubcalls, "Concurrency pool size for llm_batch and rlm_batch."),
     item("maxConcurrentChildren", "Max concurrent children", String(config.maxConcurrentChildren), CHOICES.maxConcurrentChildren, "Concurrent rlm_query child engines per depth. Each is a Python process holding its own copy of the inherited context."),
@@ -52,10 +51,8 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxErrors", "Max consecutive errors", config.maxErrors != null ? String(config.maxErrors) : "none", CHOICES.maxErrors, "Stop after this many consecutive failing turns; none disables the guard."),
     item("orchestrator", "Orchestrator addendum", config.orchestrator ? "on" : "off", CHOICES.orchestrator, "Append extra divide-and-conquer guidance to the root model system prompt."),
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
-    item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "Compact once estimated history tokens reach this share of the root model's context window."),
+    item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "DEPRECATED — ignored: compaction uses the absolute 256k ceiling (COMPACTION_CEILING_TOKENS)."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
-    item("rootSamplingTemperature", "Root sampling temperature", config.rootSampling?.temperature === undefined ? "default" : String(config.rootSampling?.temperature), CHOICES.rootSamplingTemperature,
-      "Sampling temperature for RLM root turns, finalize included — 0 = deterministic (the r3 reproducibility setting); 'default' = provider default. Applies to RLM-mode runs, rlm() delegation and child recursion; the native Pi agent loop follows Pi's own session settings."),
     item("smartReasoning", "Root reasoning effort", config.smartReasoning ?? "default", CHOICES.smartReasoning,
       "Thinking effort for the root model ('default' = none). Only models whose registry entry supports reasoning will think; others silently run without it. Reasoning tokens share the output cap — raise the root output cap when thinking is on."),
     item("subSamplingMaxTokens", "Worker output cap (tok)", String(config.subSampling?.maxTokens ?? 8192), CHOICES.subSamplingMaxTokens,
@@ -68,12 +65,6 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
       "Allow add_context() to pull an external dir, file, document, or git repo into context."),
     item("autoSeedCwd", "Auto-seed cwd", config.autoSeedCwd ? "on" : "off", CHOICES.autoSeedCwd,
       "Seed the working directory into context on the first repl() call (otherwise starts empty)."),
-    // R0 (/tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the SKILL.state / Root Σ paradigm flags are
-    // ENFORCED — rendered as a read-only badge so the truth is visible instead of hidden.
-    // No toggle exists: applySetting has no case for them and the validator forces true.
-    item("__sigma_enforced__", "SKILL.state / Root Σ", "enforced", ["enforced"],
-      "ENFORCED (no opt-out): run state, skill state + distill, root context transform, state fences, digest compaction. " +
-        "Override attempts in rlm.json are traced (skillstate.override-ignored) and ignored; RLM_BENCH_NO_ROOTCONTEXT=1 is the dev-only measurement hatch."),
     // R5: the window calibrations are rlm.json-only knobs — shown read-only with live values.
     item("__sigma_window__", "Root Σ window (calibration)",
       `keepTurns=${config.rootContextKeepTurns} · elide=${config.rootContextElideChars} · snapshot=${config.rootContextSnapshot ? "on" : "off"}`,
@@ -138,12 +129,6 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
     case "compactionThresholdPct": return Object.freeze({ ...config, compactionThresholdPct: Number(value) / 100 });
     case "rootSamplingMaxTokens":
       return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }) });
-    case "rootSamplingTemperature": {
-      const t = optionalTemperature(value);
-      // Reject invalid values (NaN / out of range) — keep the current setting.
-      if (t === undefined && value !== "default") return config;
-      return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, temperature: t }) });
-    }
     case "smartReasoning":
       if (value === "default") return Object.freeze({ ...config, smartReasoning: undefined });
       return Object.hasOwn(THINKING_LEVELS, value)

package/src/ui/panel/run-registry.ts

@@ -20,7 +20,7 @@ interface RunRegistration {
   readonly label: string;
   readonly emitter: RlmEmitter;
   readonly subcalls: () => readonly RlmSubcall[];
-  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  readonly totals: () => { readonly tokens: number };
   /** Live root state; defaults: running, no phase, no turns. */
   readonly rootStatus?: () => RlmRunStatus;
   readonly rootPhase?: () => SubcallPhase | undefined;
@@ -40,7 +40,7 @@ export interface RunEntry {
   readonly label: string;
   readonly timeline: TimelineStore;
   readonly subcalls: () => readonly RlmSubcall[];
-  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  readonly totals: () => { readonly tokens: number };
   readonly rootStatus: () => RlmRunStatus;
   readonly rootPhase: () => SubcallPhase | undefined;
   readonly turns: () => { readonly current: number; readonly max: number };

package/src/ui/tree/tree-model.ts

@@ -6,11 +6,14 @@
  *
  * Nothing is ever hidden: every sub-call renders as its own row (parity with
  * pi, which shows each concurrent tool call individually) — except runs of
- * IDENTICAL sibling leaves (same label+model+status), which collapse into one
- * expandable "label ×N" group row so a 20-item llm_batch is one line, not 20.
- * Error leaves are NEVER grouped — each keeps its own row and reason.
- * Collapsed subtrees are skipped at the user's explicit request (chevron flips).
- * Token rows are own-spend only — a row never blends models.
+ * CONSECUTIVE IDENTICAL sibling leaves (same label+model+status), which
+ * collapse into one expandable "label ×N" group row so a 20-item llm_batch is
+ * one line, not 20 and a wholesale batch failure is one `✗ label ×N` line.
+ * Errors group exactly like successes; distinct failures keep their own rows
+ * and reasons, and singletons render as plain rows. Interleaved siblings (✗ ✓
+ * ✗ with different keys between) stay in encounter order — position is never
+ * rewritten. Collapsed subtrees are skipped at the user's explicit request
+ * (chevron flips). Token rows are own-spend only — a row never blends models.
  */
 
 import type { RlmSubcall, RlmRunStatus, SubcallPhase, SubcallStatus } from "../../tool/rlm-details.ts";
@@ -81,9 +84,13 @@ type Entry =
   | { readonly type: "node"; readonly sc: RlmSubcall }
   | { readonly type: "group"; readonly key: string; readonly label: string; readonly model?: string; readonly status: SubcallStatus; readonly members: RlmSubcall[] };
 
-/** Errors never group — each keeps its own row and its own reason. */
+/**
+ * Any childless llm leaf may group — errors included. groupKey pins status, so
+ * only runs of identical failures merge; per-item reasons stay in the detail
+ * modal (expand the group).
+ */
 const groupable = (sc: RlmSubcall, byParent: ReadonlyMap<string | undefined, RlmSubcall[]>): boolean =>
-  sc.kind === "llm" && sc.status !== "error" && (byParent.get(sc.id)?.length ?? 0) === 0;
+  sc.kind === "llm" && (byParent.get(sc.id)?.length ?? 0) === 0;
 
 const groupKey = (sc: RlmSubcall): string => `${sc.label}|${sc.model ?? ""}|${sc.status}`;