@hicaru/pi-rlm 0.3.19 → 0.3.20

package/src/core/compaction.ts

@@ -38,12 +38,45 @@ export function shouldCompact(history: ChatMsg[]): boolean {
   return estimateMessageTokens(history) >= COMPACTION_CEILING_TOKENS;
 }
 
+/**
+ * P3.2 (plan §3.4): never elide an ANSWER FRAME — `answer['content'] = …` is the run's only
+ * durable output, and dropping it from history is how a finished run still reports empty.
+ */
+const ANSWER_FRAME_RE = /answer\[\s*['"](?:content|ready)['"]\s*\]|answers\s*\.\s*update\s*\(/;
+
+/** Identifier shape used by the last-reference scan (`counter_a`, `rows_by_label`, …). */
+const REF_TOKEN_RE = /[A-Za-z_][A-Za-z0-9_]{2,}/g;
+/** Bounds: per-payload ids and the growing "future" set stay tiny (O(T·N) with small N). */
+const PAYLOAD_TOKEN_CAP = 64;
+const REF_TOKEN_CAP = 512;
+
+/** Whitespace-collapsed body skeleton — two identical page dumps share it even when the
+ *  turn banner differs (P3.2 "按内容签名去重"). Exact text, NOT digit-normalised: two
+ *  `counter_a=875` / `counter_a=499` payloads are different conclusions and must not collapse. */
+function payloadSignature(content: string): string {
+  return content.replace(/\s+/g, " ").trim().slice(0, 400) + "#" + content.length;
+}
+
+function payloadTokens(content: string, into: Set<string>): void {
+  let n = 0;
+  REF_TOKEN_RE.lastIndex = 0;
+  for (let m = REF_TOKEN_RE.exec(content); m !== null; m = REF_TOKEN_RE.exec(content)) {
+    into.add(m[0]);
+    if (++n >= PAYLOAD_TOKEN_CAP) return;
+  }
+}
+
 /**
  * v5 G1: elide old tool/repl payload bodies, keep the head (system) and the working-set tail
  * intact. Runs BEFORE `shouldCompact` — v3 measured −97% tokens on coding tasks with this
  * alone, often avoiding the summarizer entirely. Head-ONLY elision was a measured v3 bug
  * (turns grew 3→8): the tail carries the current working set, so the last `keepTurns` turns
  * are never touched.
+ *
+ * P3.2 adds a whitelist on top of the volume rule (which stays as the floor — dedup and
+ * exemptions only ever REMOVE bytes, never add them back):
+ *  - answer frames and payloads whose identifiers a later turn still mentions are kept verbatim;
+ *  - a payload byte-identical to an earlier one collapses to a one-line stub.
  */
 export function elideOldToolPayloads(
   history: ChatMsg[],
@@ -65,17 +98,60 @@ export function elideOldToolPayloads(
     }
   }
   if (tailStart === 0) return history; // fewer turns than keepTurns — nothing to elide
+
+  // Last-reference scan (descending): `future` holds the identifiers mentioned by everything
+  // AFTER the message we are looking at — the working set the model still has in hand.
+  const future = new Set<string>();
+  const referenced = new Array<boolean>(history.length).fill(false);
+  const ids = new Set<string>();
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (m.role === "assistant") {
+      if (future.size < REF_TOKEN_CAP) payloadTokens(m.content, future);
+      continue;
+    }
+    if (m.role !== "user" || i >= tailStart || m.content.length <= toolChars) continue;
+    if (ANSWER_FRAME_RE.test(m.content)) continue; // answer frames are kept anyway
+    ids.clear();
+    payloadTokens(m.content.slice(0, 2_000), ids);
+    for (const id of ids) {
+      if (future.has(id)) {
+        referenced[i] = true;
+        break;
+      }
+    }
+  }
+
   let changed = false;
-  const marker = "\n…[elided v5-G1]…";
+  const marker =
+    "\n…[elided v5-G1 — your repl sandbox is INTACT: variables/answers persist; re-run or " +
+    "print(answers) in the next repl to re-derive this content]…";
+  const dupMarker =
+    "\n…[dup v5-G1 — byte-identical payload already in this history; sandbox INTACT: " +
+    "print(<expr>) to inspect it again]…";
+  const signatures = new Set<string>();
   const out: ChatMsg[] = new Array<ChatMsg>(history.length); // pre-allocated
   for (let i = 0; i < history.length; i++) {
     const m = history[i];
-    if (
-      i < tailStart &&
-      m.role === "user" &&
-      m.content.length > toolChars
-    ) {
-      out[i] = { role: "user", content: m.content.slice(0, toolChars) + marker };
+    if (i < tailStart && m.role === "user" && m.content.length > toolChars) {
+      if (ANSWER_FRAME_RE.test(m.content)) {
+        out[i] = m; // never touch the answer frame
+        continue;
+      }
+      const sig = payloadSignature(m.content);
+      if (signatures.has(sig)) {
+        out[i] = { role: "user", content: dupMarker.trimStart() };
+        changed = true;
+        continue;
+      }
+      signatures.add(sig);
+      if (referenced[i]) {
+        out[i] = m; // a later turn still names what this payload produced
+        continue;
+      }
+      // Elided message is capped at exactly toolChars total (§5.3 preview + marker).
+      const body = m.content.slice(0, Math.max(0, toolChars - marker.length));
+      out[i] = { role: "user", content: body + marker };
       changed = true;
     } else {
       out[i] = m;

package/src/core/engine.ts

@@ -28,7 +28,7 @@ import { pinContext, type PinnedContext } from "../sandbox/context-file.ts";
 import { previewStdout, previewText } from "../text/preview.ts";
 import { findReplBlocks, stripStateFences } from "../text/parsing.ts";
 import { contextLength, contextSizeStats, contextTypeLabel } from "../text/tokens.ts";
-import { finalAnswerOf, formatReplOutputs, latestAnswerContentOf, turnHadError } from "./answer.ts";
+import { finalAnswerOf, formatReplOutputs, latestAnswerContentOf, latestStdoutOf, turnHadError } from "./answer.ts";
 import { compactHistory, elideOldToolPayloads, rebaseWithState, shouldCompact } from "./compaction.ts";
 import { applyStatePatches, freshRunState, runStateTurnBlock, type RunState, type RunStateMode } from "./run-state.ts";
 import { findStatePatches } from "../text/parsing.ts";
@@ -141,8 +141,8 @@ export function createEngine(deps: EngineDeps): RunRlm {
           limits.addUsage(u);
           deps.onUsage?.(u, "sub");
         },
-        addRaw: (costUsd, inputTokens, outputTokens) => {
-          limits.addRaw(costUsd, inputTokens, outputTokens);
+        addRaw: (inputTokens, outputTokens) => {
+          limits.addRaw(inputTokens, outputTokens);
         },
       },
     };
@@ -269,6 +269,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
       await previous?.release();
     };
     let best = "";
+    // P2 §3.4: last non-empty repl stdout across the whole run — recovered by the bench when
+    // the run ends with no `answer[…]` frame (the value was printed, just never submitted).
+    let lastStdout = "";
     let lastAnswer = "";
     let compactions = 0;
     let completedTurns = 0;
@@ -412,7 +415,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
             verificationNudgePending ? VERIFICATION_NUDGE : undefined,
             // One-shot (turn 0 only): thinking tokens share the completion budget — mirror of
             // the bench's doubling rule. Advisory; never fatal, never repeated.
-            i === 0 && rootSampling.reasoning !== undefined && (rootSampling.maxTokens ?? 16_384) < 8_192
+            // P3.1a (plan §3.4): `<= 8_192` — the bench pins maxTokens = 8192 exactly, so the old
+            // strict `<` made this a dead condition and REASONING_BUDGET_HINT never fired.
+            i === 0 && rootSampling.reasoning !== undefined && (rootSampling.maxTokens ?? 16_384) <= 8_192
               ? REASONING_BUDGET_HINT
               : undefined,
           ]
@@ -427,6 +432,9 @@ export function createEngine(deps: EngineDeps): RunRlm {
           sampling: rootSampling,
           retry: deps.complete === undefined ? retryPolicy(deps.config) : undefined,
           signal: deps.signal,
+          // Long-context providers: bigmodel.cn TTFB scales ~1 min per 10k ctx chars; the
+          // pi-ai default idle cap aborts such turns as "Request timed out". One knob, both seams.
+          timeoutMs: deps.config.requestTimeoutMs,
           complete: deps.complete,
           onPhase: reportPhase,
         });
@@ -441,18 +449,21 @@ export function createEngine(deps: EngineDeps): RunRlm {
         if (selfReportId) {
           emitter.emitSubcallUpdated({
             id: selfReportId,
-            costUsd: turn.usage.cost.total,
             tokens: turn.usage.totalTokens,
             tokensIn: turn.usage.input,
             tokensOut: turn.usage.output,
           });
         } else {
-          emitter.emitRootUsage(turn.usage.cost.total, turn.usage.totalTokens, turn.usage.input, turn.usage.output);
+          emitter.emitRootUsage(turn.usage.totalTokens, turn.usage.input, turn.usage.output);
         }
         deps.onUsage?.(turn.usage, "root");
         const answerContent = latestAnswerContentOf(turn.results);
         if (answerContent) best = answerContent;
         else if (!best && turn.response.trim()) best = turn.response;
+        // Stdout fallback floor (P2 §3.4): keep the newest non-empty block output, always —
+        // cheapest possible recovery for a run that never submits a final frame.
+        const turnStdout = latestStdoutOf(turn.results);
+        if (turnStdout) lastStdout = turnStdout;
         completedTurns = i + 1;
         const final = finalAnswerOf(turn.results);
         if (final != null) {
@@ -464,7 +475,7 @@ export function createEngine(deps: EngineDeps): RunRlm {
             verificationNudged = true;
             verificationNudgePending = true;
           } else {
-            const done = result(final, i + 1, limits);
+            const done = result(final, i + 1, limits, lastStdout);
             lastAnswer = done.answer;
             return done;
           }
@@ -546,7 +557,6 @@ export function createEngine(deps: EngineDeps): RunRlm {
                 iterations: inner.iterations + completedTurns,
                 inputTokens: inner.inputTokens + u.inputTokens,
                 outputTokens: inner.outputTokens + u.outputTokens,
-                costUsd: inner.costUsd + u.costUsd,
               };
               // R2: lastAnswer must be set before return — `finally` emitAnswer reads it.
               lastAnswer = chained.answer;
@@ -558,19 +568,19 @@ export function createEngine(deps: EngineDeps): RunRlm {
         }
       }
       if (pendingReplOutputs) appendUserMessage(history, pendingReplOutputs);
-      const finalized = result(await finalize(history, model, deps, limits, sandbox), deps.config.maxIterations, limits);
+      const finalized = result(await finalize(history, model, deps, limits, sandbox), completedTurns, limits, lastStdout);
       lastAnswer = finalized.answer;
       return finalized;
     } catch (err) {
       // Abort is a user action — resolve with the best partial, not an error.
       if (deps.signal?.aborted) {
-        const aborted = result(best.trim() || "(aborted)", completedTurns, limits);
+        const aborted = result(best.trim() || "(aborted)", completedTurns, limits, lastStdout);
         lastAnswer = aborted.answer;
         return aborted;
       }
       if (err instanceof LimitError) {
         nodeStatus = "error";
-        const stopped = result(best.trim() || `(stopped: ${err.message})`, completedTurns, limits);
+        const stopped = result(best.trim() || `(stopped: ${err.message})`, completedTurns, limits, lastStdout);
         lastAnswer = stopped.answer;
         return stopped;
       }
@@ -601,14 +611,21 @@ export function createEngine(deps: EngineDeps): RunRlm {
   return run;
 }
 
-function result(answer: string, iterations: number, limits: LimitGuard): RlmResult {
+function result(answer: string, iterations: number, limits: LimitGuard, lastStdout: string): RlmResult {
   // State fences are a Σ transport, never user-visible output (§7): scrub them from the
   // FINAL answer. A fence-only answer means the model spent its last turn committing state
   // and never re-answered — surface the stub instead of a raw patch JSON.
   const clean = stripStateFences(answer);
   const final = clean.trim().length > 0 ? clean.trim() : "(no final answer — last turn committed state only; see Σ)";
   const u = limits.usage();
-  return { answer: final, iterations, costUsd: u.costUsd, inputTokens: u.inputTokens, outputTokens: u.outputTokens, durationMs: u.durationMs };
+  return {
+    answer: final,
+    iterations,
+    inputTokens: u.inputTokens,
+    outputTokens: u.outputTokens,
+    durationMs: u.durationMs,
+    lastStdout,
+  };
 }
 
 /** Model metadata window, else the offline registry fallback (disk cache → table → 32k). */

package/src/core/iteration.ts

@@ -30,6 +30,9 @@ interface TurnDeps {
   readonly registry: ModelRegistry;
   readonly sampling?: Sampling;
   readonly signal?: AbortSignal;
+  /** Wall-clock cap per provider request (ms) — forwarded to the modelComplete seam.
+   *  Long-context providers (zai bigmodel TTFB ~1 min per 10k ctx chars) need it raised. */
+  readonly timeoutMs?: number;
   /** Test-only override for model completion (scripted responses). */
   readonly complete?: CompleteFn;
   /** v5.1 retry policy for modelComplete (rate-limit resilience); defaults apply when omitted. */
@@ -52,6 +55,7 @@ export async function runTurn(history: readonly ChatMsg[], sandbox: PythonSandbo
     onThrottlePark: deps.onPhase ? () => deps.onPhase?.("queued") : undefined,
     onThrottleRelease: deps.onPhase ? () => deps.onPhase?.("thinking") : undefined,
     signal: deps.signal,
+    timeoutMs: deps.timeoutMs,
   });
 
   const blocks = findReplBlocks(text);

package/src/core/limits.ts

@@ -3,19 +3,20 @@
  * (ported from rlm/core/rlm.py `_check_timeout` / `_check_iteration_limits`). Any breach throws
  * a LimitError; the engine catches it and returns the best partial answer it has.
  *
- * Cost is tracked for reporting only — there is no USD spend ceiling.
+ * Cost is NOT tracked: there is no USD spend ceiling and no cost reporting.
  */
 
 import type { Usage } from "@earendil-works/pi-ai";
 
 /**
- * Absolute working ceiling (LO rule 2025-09-09): model windows AT/BELOW this value are never
- * compacted or budget-amputated — the agent runs its full window. Windows ABOVE it are
- * compacted/budgeted exactly AT the ceiling (e.g. a 1M-context model works up to ~256k tokens
- * of history, then rebases/compacts). Single source of truth for budget.ts (resolveBudget)
- * and compaction.ts (shouldCompact + rebaseWithState token bound).
+ * Absolute working ceiling (LO rule 2025-09-09, raised 2025-09-10): model windows AT/BELOW
+ * this value are never compacted or budget-amputated — the agent runs its full window, and
+ * tree-wide spend (root turns + sub-LLM calls) is NOT metered against it. Windows ABOVE it
+ * are budgeted exactly AT the ceiling — an outlier context-fit guard, not a cost meter.
+ * Single source of truth for budget.ts (resolveBudget) and compaction.ts (shouldCompact +
+ * rebaseWithState token bound).
  */
-export const COMPACTION_CEILING_TOKENS = 256_000;
+export const COMPACTION_CEILING_TOKENS = 1_000_000;
 
 export interface Limits {
   readonly maxTimeoutMs?: number;
@@ -36,7 +37,6 @@ export function limitsFromConfig(config: Limits): Limits {
 interface UsageSnapshot {
   readonly inputTokens: number;
   readonly outputTokens: number;
-  readonly costUsd: number;
   readonly durationMs: number;
 }
 
@@ -54,7 +54,6 @@ export class LimitGuard {
   private start: number;
   private inputTokens = 0;
   private outputTokens = 0;
-  private costUsd = 0;
   private consecutiveErrors = 0;
 
   constructor(private readonly limits: Limits = {}, seedElapsedMs = 0) {
@@ -73,12 +72,10 @@ export class LimitGuard {
   addUsage(usage: Usage): void {
     this.inputTokens += usage.input;
     this.outputTokens += usage.output;
-    this.costUsd += usage.cost.total;
   }
 
-  /** Fold a recursive child run's total cost/tokens into this guard. */
-  addRaw(costUsd: number, inputTokens: number, outputTokens: number): void {
-    this.costUsd += costUsd;
+  /** Fold a recursive child run's total tokens into this guard. */
+  addRaw(inputTokens: number, outputTokens: number): void {
     this.inputTokens += inputTokens;
     this.outputTokens += outputTokens;
   }
@@ -99,7 +96,6 @@ export class LimitGuard {
     return {
       inputTokens: this.inputTokens,
       outputTokens: this.outputTokens,
-      costUsd: this.costUsd,
       durationMs: Date.now() - this.start,
     };
   }

package/src/core/root-context.ts

@@ -31,7 +31,7 @@ export interface ElideOptions {
   readonly elideChars: number;
 }
 
-const ELIDE_MARK = "chars elided — full result in session log";
+const ELIDE_MARK = "chars elided — repl sandbox persists: print(answers[k]) or re-run repl to re-derive";
 
 /**
  * WS-3a: elide stale turns. The newest `keepTurns` assistant turns and the final user message
@@ -109,7 +109,18 @@ function elideRange(
     if (i === lastUser) continue; // paranoia: the final user message is never touched
     if (m.role === "assistant") {
       staleAssistants -= 1; // turns AFTER this one = count minus itself
-      messages[i] = { ...m, content: [{ type: "text", text: ROOT_TURN_ELIDED_LINE }] } as RootMessage;
+      // Provider pairing invariant: Anthropic requires every tool_result to follow the
+      // assistant message carrying its tool_use; OpenAI requires each tool/function_call_output
+      // to pair with its tool_call/function_call. Eliding the toolCall blocks here orphaned the
+      // surviving toolResults and broke the request. Elide only the prose — keep toolCall blocks.
+      const toolCalls = Array.isArray(m.content)
+        ? (m.content as Array<{ type?: string }>).filter((b) => b?.type === "toolCall")
+        : [];
+      const content: unknown[] =
+        toolCalls.length > 0
+          ? [...toolCalls, { type: "text", text: ROOT_TURN_ELIDED_LINE }]
+          : [{ type: "text", text: ROOT_TURN_ELIDED_LINE }];
+      messages[i] = { ...m, content } as RootMessage;
       elided += 1;
       continue;
     }

package/src/core/types.ts

@@ -13,7 +13,8 @@ export interface RlmConfig {
   readonly enabled: boolean;
   /** Max recursion depth. depth >= maxDepth ⇒ rlm_query falls back to a plain llm_query. */
   readonly maxDepth: number;
-  /** Max turns before the engine must finalize. */
+  /** Max turns before the engine must finalize. Deliberately large — runs end on FINAL
+   *  answer, errors, or wall-clock long before this bites. */
   readonly maxIterations: number;
   /** Per-`repl`-block wall-clock timeout inside the worker (seconds).
    *  v5 doctrine: content limits are the token budget's job — this is a HANG backstop only. */
@@ -181,10 +182,14 @@ export interface RlmInput {
 export interface RlmResult {
   readonly answer: string;
   readonly iterations: number;
-  readonly costUsd: number;
   readonly inputTokens: number;
   readonly outputTokens: number;
   readonly durationMs: number;
+  /** Last non-empty repl stdout of the run (capped, P2 §3.4). The engine itself never reads
+   *  it: a run that ends without `answer[...]` (no final frame) would otherwise score as an
+   *  empty submission even though the winning value was printed. The bench/grader recovers
+   *  that value from here instead of re-running the whole task. */
+  readonly lastStdout: string;
 }
 
 /** A function that runs an RLM to completion — used to wire recursion (rlm_query). */

package/src/prompts/glossary.ts

@@ -63,9 +63,11 @@ export const SKILL_RECALL_LINE =
   "Recall more anytime inside repl: `skill_search(query, k=8)` → [{id, text, tags, score}].";
 
 /** R5 (G4, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the one-line replacement for assistant prose
- *  older than the keep window — durable facts live in Σ, the full text in the session log. */
+ *  older than the keep window — durable facts live in Σ; the repl sandbox (answers/vars) is
+ *  the model-reachable recovery channel — the session log is host-side only, never re-openable
+ *  by the model, so stubs must not promise it. */
 export const ROOT_TURN_ELIDED_LINE =
-  "… turn elided — durable facts live in Σ; full text in session log";
+  "… turn elided — durable facts live in Σ; your repl sandbox persists: print(answers) / SHOW_VARS() to re-derive";
 
 export function skillStateLines(noteCount: number, body: string): string {
   return [

package/src/prompts/user.ts

@@ -21,7 +21,8 @@ export function buildTurnPrompt(
 
 /** Asked once when the engine runs out of turns without a submitted answer. Same finalize
  *  dialect as the budget wrap-up note (audit M6): answer-ready first, plain text only as an
- *  explicit fallback the engine still accepts. */
+ *  explicit fallback the engine still accepts. Deliberately near-unreachable: the cap is
+ *  large by design (the old 16-cap all-failed oolong mid-retrieval). */
 export const FINALIZE_PROMPT =
   "You are out of turns. Finalize NOW: set `answer[\"content\"]` and `answer[\"ready\"] = True` " +
     "(fenced ```repl```) with your best final answer from everything you have gathered. " +

package/src/sandbox/sandbox.ts

@@ -92,7 +92,10 @@ export class PythonSandbox {
   private scanOffset = 0;
   private seq = 0;
   private readonly pending = new Map<string, Pending>();
-  private readonly handlers: SubLlmHandlers;
+  // Not readonly: the engine's continuation handoff re-installs a successor run's closures
+  // on a live worker (installHandlers) instead of respawning it — respawn would destroy the
+  // pinned context accumulator, which is exactly what the chain must preserve.
+  private handlers: SubLlmHandlers;
   private readonly requestTimeoutMs: number;
   private readonly initTimeoutMs: number;
   /** Bounded stderr tail (chunks, newest last) — avoids rebuilding the buffer per chunk. */
@@ -224,6 +227,15 @@ export class PythonSandbox {
     return res.index ?? 0;
   }
 
+  /**
+   * Continuation handoff (engine chain): re-install a successor run's sub-call handlers on
+   * THIS live worker so a chained engine run can adopt it without a respawn. Respawning
+   * would destroy the pinned context accumulator — the one thing the chain must preserve.
+   */
+  installHandlers(handlers: SubLlmHandlers): void {
+    this.handlers = { ...REJECT, ...handlers };
+  }
+
   async exec(code: string, signal?: AbortSignal): Promise<ReplResult> {
     const res = await this.request({ type: "exec", code }, signal);
     if (!res.ok) throw new Error(res.error ?? "exec failed");

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;