@hicaru/pi-rlm 0.3.5 → 0.3.8

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/openzebra/rlm.pi/master/assets/plugin-cover.png" width="100%" alt="pi-rlm — Recursive Language Model plugin for Pi">
+  <img src="https://github.com/openzebra/rlm.pi/blob/master/assets/plugin-cover.png?raw=true" width="100%" alt="pi-rlm — Recursive Language Model plugin for Pi">
 </p>
 
 <p align="center">

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hicaru/pi-rlm",
-	"version": "0.3.5",
+	"version": "0.3.8",
 	"author": "hicaru",
 	"repository": {
 		"type": "git",
@@ -37,7 +37,7 @@
 		"extensions": [
 			"./src/index.ts"
 		],
-		"image": "https://raw.githubusercontent.com/openzebra/rlm.pi/master/assets/plugin-cover.png"
+		"image": "https://github.com/openzebra/rlm.pi/blob/master/assets/plugin-cover.png?raw=true"
 	},
 	"publishConfig": {
 		"access": "public"

package/src/bridge/handlers/llm-query.ts

@@ -6,11 +6,12 @@ import type { Usage } from "@earendil-works/pi-ai";
 import { modelRef } from "../../config/settings.ts";
 import { complete1, type Complete1Deps } from "./completion.ts";
 import { emitting, summarizeBatch } from "./emitting.ts";
-import { formatError, isErrorText } from "../../util/errors.ts";
+import { formatError, isErrorText, errorMessage } from "../../util/errors.ts";
 import { previewText } from "../../text/preview.ts";
 import type { SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
+import { ECHO_STUB, taskKey, type TaskLedger } from "../../core/ledger.ts";
 
 const UNWIRED = formatError("RLM bridge not wired for this invocation");
 
@@ -34,6 +35,45 @@ function displayModel(deps: SubcallHandlerDeps): string | undefined {
   }
 }
 
+/** The ledger active for leaf calls — undefined when disabled by config or not threaded in. */
+function activeLedger(deps: SubcallHandlerDeps): TaskLedger | undefined {
+  return deps.getConfig().enableLedger ? deps.ledger : undefined;
+}
+
+/** v5 TaskLedger routing for ONE leaf prompt (audit H3 — shared by llm_query and every
+ *  llm_batch item, which v5 routed through `_spawn_single` too): echo → stub string,
+ *  coalesce → the twin's result (bounded wait), run → caller executes then finish/fail.
+ *  Exported for tests. */
+export async function runClaimedLeaf(
+  ledger: TaskLedger | undefined,
+  key: string | undefined,
+  prompt: string,
+  depth: number,
+  exec: () => Promise<string>,
+): Promise<string> {
+  if (ledger === undefined || key === undefined) return exec();
+  const decision = ledger.tryClaim({ kind: "llm", prompt, paths: [], depth }, key);
+  if (decision.type === "echo") return ECHO_STUB;
+  if (decision.type === "coalesce") {
+    return ledger.waitFor(decision.key).catch((err: unknown): string => formatError(errorMessage(err)));
+  }
+  ledger.markRunning(key);
+  try {
+    const out = await exec();
+    ledger.finish(key, out);
+    return out;
+  } catch (err: unknown) {
+    ledger.fail(key, errorMessage(err));
+    throw err;
+  }
+}
+
+export function leafClaimKey(deps: SubcallHandlerDeps, prompt: string): string | undefined {
+  const ledger = activeLedger(deps);
+  if (ledger === undefined) return undefined;
+  return taskKey("llm", prompt, [], displayModel(deps) ?? "", "");
+}
+
 export function createLlmQueryHandler(
   deps: SubcallHandlerDeps,
   sd: SpawnDeps,
@@ -57,25 +97,28 @@ export function createLlmQueryHandler(
     }
 
     const cdeps = completeDeps(deps);
+    const runLeaf = (): Promise<string> =>
+      emitting(
+        inv,
+        {
+          kind: "llm",
+          label: "llm_query",
+          args: `prompt: ${previewText(prompt)}`,
+          model: displayModel(deps),
+        },
+        (track: (u: Usage) => void) => complete1(inv, prompt, track, cdeps),
+        (out) => ({
+          preview: previewText(out),
+          error: isErrorText(out) ? out : undefined,
+        }),
+      );
+    // v5 TaskLedger for leaves: identical prompts coalesce onto one completion (key has no
+    // context — a leaf's entire world is the prompt text itself).
     return spawnAndRun(
       sd,
       "llm",
       1,
-      () =>
-        emitting(
-          inv,
-          {
-            kind: "llm",
-            label: "llm_query",
-            args: `prompt: ${previewText(prompt)}`,
-            model: displayModel(deps),
-          },
-          (track: (u: Usage) => void) => complete1(inv, prompt, track, cdeps),
-          (out) => ({
-            preview: previewText(out),
-            error: isErrorText(out) ? out : undefined,
-          }),
-        ),
+      () => runClaimedLeaf(activeLedger(deps), leafClaimKey(deps, prompt), prompt, inv.depth, runLeaf),
       deps.trackDetached,
       opts.detached,
     );
@@ -105,6 +148,7 @@ export function createLlmBatchHandler(
     }
 
     const cdeps = completeDeps(deps);
+    const ledger = activeLedger(deps);
     return spawnAndRun(
       sd,
       "llm_batch",
@@ -119,8 +163,20 @@ export function createLlmBatchHandler(
             model: displayModel(deps),
           },
           // NO outer gate — complete1 takes the single leaf slot per prompt.
+          // v5 (audit H3): every item routes through the ledger — duplicate prompts inside
+          // one batch (or twins of other in-flight leaves) coalesce instead of paying N times.
           (track: (u: Usage) => void) =>
-            Promise.all(prompts.map((p) => complete1(inv, p, track, cdeps))),
+            Promise.all(
+              prompts.map((p) =>
+                runClaimedLeaf(
+                  ledger,
+                  ledger === undefined ? undefined : leafClaimKey(deps, p),
+                  p,
+                  inv.depth,
+                  () => complete1(inv, p, track, cdeps),
+                ),
+              ),
+            ),
           summarizeBatch,
         ),
       deps.trackDetached,

package/src/bridge/handlers/rlm-query.ts

@@ -10,10 +10,14 @@ import { filterContextByPaths } from "../../context/merge.ts";
 import { previewText } from "../../text/preview.ts";
 import type { RlmInput, RlmResult } from "../../core/types.ts";
 import { checkResourceLimits } from "../../core/resource-limits.ts";
+import { contextSig, ECHO_STUB, taskKey } from "../../core/ledger.ts";
 import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
 import { complete1, type Complete1Deps } from "./completion.ts";
+import { emitting } from "./emitting.ts";
+import { isErrorText } from "../../util/errors.ts";
+import { leafClaimKey, runClaimedLeaf } from "./llm-query.ts";
 
 const UNWIRED = formatError("RLM bridge not wired for this invocation");
 const NO_UNMATCHED: readonly string[] = Object.freeze([]);
@@ -64,9 +68,20 @@ function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
   };
 }
 
+/** Ledger active for this call — undefined when disabled by config or not threaded in. */
+function activeLedger(deps: SubcallHandlerDeps) {
+  return deps.getConfig().enableLedger ? deps.ledger : undefined;
+}
+
+function claimKeyFor(deps: SubcallHandlerDeps, kind: "llm" | "rlm", prompt: string, paths: readonly string[], ctx: string): string {
+  const rootModel = deps.getModel?.();
+  const modelId = rootModel === undefined ? "" : (modelRef(rootModel) ?? rootModel.id);
+  return taskKey(kind, prompt, paths, modelId, ctx);
+}
+
 /**
- * One child RLM run: depth cap → resource guard → depth gate → spawn engine → debit parent.
- * Emits its own subcall node (do not wrap in emitting()).
+ * One child RLM run: depth cap → resource guard → ledger gate → depth gate → spawn engine →
+ * debit parent. Emits its own subcall node (do not wrap in emitting()).
  */
 async function childRun(
   deps: SubcallHandlerDeps,
@@ -91,23 +106,74 @@ async function childRun(
   const limitError = checkResourceLimits({ timeoutMs: remTimeout });
   if (limitError !== undefined) return emptyResult(limitError);
 
+  const child = childContextFor(deps, prompt, paths);
+  const rootPrompt =
+    child.unmatched.length === 0
+      ? prompt
+      : `${prompt}\n\n[rlm] paths=${child.unmatched.join(", ")} matched no files; you received the full context.`;
+
+  // ── v5 memory replay: an identical, still-fresh child answer replays for zero API calls ──
+  const memory = deps.memory;
+  const sig = contextSig(child.context);
+  const key = claimKeyFor(deps, "rlm", prompt, paths ?? [], sig);
+  if (memory !== undefined && deps.getConfig().enableMemory !== false) {
+    const hit = memory.replay(key);
+    if (hit !== undefined) {
+      const replayId = inv.emitter.emitSubcallCreated({
+        kind: "rlm",
+        parentId: inv.parentId,
+        label: "rlm_query (replay)",
+        detail: prompt.slice(0, 60),
+        depth: childDepth,
+      });
+      inv.emitter.emitSubcallUpdated({ id: replayId, status: "done", resultPreview: hit.result.slice(0, 200) });
+      return {
+        answer: hit.result,
+        iterations: 0,
+        costUsd: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        durationMs: 0,
+      };
+    }
+  }
+
+  // ── v5 TaskLedger: echo → stub; duplicate → coalesce onto the existing runner ──────
+  const ledger = activeLedger(deps);
+  const claimKey = ledger === undefined ? undefined : key;
+  const decision =
+    ledger !== undefined && claimKey !== undefined
+      ? ledger.tryClaim({ kind: "rlm", prompt, paths: paths ?? [], depth: childDepth }, claimKey)
+      : undefined;
+
+  // ONE subcall node per childRun (audit C2 / DRY #5): the decision branch reuses it, the
+  // run branch reports the engine's turns/cost on it. Never a second emit below.
   const rootModel = deps.getModel?.();
   const modelLabel =
     rootModel === undefined ? undefined : (modelRef(rootModel) ?? rootModel.id);
   const subId = inv.emitter.emitSubcallCreated({
     kind: "rlm",
     parentId: inv.parentId,
-    label: "rlm_query",
+    label: decision === undefined || decision.type === "run" ? "rlm_query" : `rlm_query (${decision.type})`,
     model: modelLabel,
     detail: prompt.slice(0, 60),
     depth: childDepth,
   });
 
-  const child = childContextFor(deps, prompt, paths);
-  const rootPrompt =
-    child.unmatched.length === 0
-      ? prompt
-      : `${prompt}\n\n[rlm] paths=${child.unmatched.join(", ")} matched no files; you received the full context.`;
+  if (decision?.type === "echo") {
+    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: ECHO_STUB.slice(0, 80) });
+    return emptyResult(ECHO_STUB);
+  }
+  if (decision?.type === "coalesce" && ledger !== undefined) {
+    const twin = await ledger
+      .waitFor(decision.key)
+      .catch((err: unknown) => errorMessage(err));
+    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(String(twin).slice(0, 80)) });
+    return emptyResult(String(twin));
+  }
+  if (ledger !== undefined && claimKey !== undefined) {
+    ledger.markRunning(claimKey);
+  }
 
   const input: RlmInput = {
     rootPrompt,
@@ -115,12 +181,27 @@ async function childRun(
     depth: childDepth,
     parentNodeId: subId,
     remainingTimeoutMs: remTimeout,
+    ledger, // DRY #6: the one seam — children share the parent's blackboard
   };
 
   try {
     const res = await deps.gates.rlm.at(childDepth).run(() => run(input, inv));
     inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
     deps.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
+    if (ledger !== undefined && claimKey !== undefined) ledger.finish(claimKey, res.answer);
+    // v5: child answers persist unconditionally — this is what later identical runs replay.
+    if (memory !== undefined && deps.getConfig().enableMemory !== false) {
+      memory.recordEpisode({
+        key,
+        kind: "rlm",
+        model: modelLabel ?? "",
+        prompt,
+        paths: paths ?? [],
+        result: res.answer,
+        tokensIn: res.inputTokens,
+        tokensOut: res.outputTokens,
+      });
+    }
     inv.emitter.emitSubcallUpdated({
       id: subId,
       status: "done",
@@ -129,6 +210,7 @@ async function childRun(
     return res;
   } catch (err: unknown) {
     const msg = errorMessage(err);
+    if (ledger !== undefined && claimKey !== undefined) ledger.fail(claimKey, msg);
     inv.emitter.emitSubcallUpdated({ id: subId, status: "error", detail: msg });
     return emptyResult(formatError(`child RLM failed - ${msg}`));
   }
@@ -155,6 +237,46 @@ export function createRlmQueryHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
 
     const pathArg = opts.paths;
 
+    // v5 rlmBudget demotion: once the ledger has started `rlmBudget` real rlm runs, extra
+    // rlm_query spawns demote to the leaf path (batch spawns are exempt — v5 `_spawn_single`).
+    const ledger = activeLedger(deps);
+    const rlmBudget = deps.getConfig().rlmBudget;
+    if (
+      ledger !== undefined &&
+      rlmBudget !== undefined &&
+      rlmBudget > 0 &&
+      ledger.rlmCount() >= rlmBudget
+    ) {
+      return spawnAndRun(
+        sd,
+        "llm",
+        1,
+        () =>
+          runClaimedLeaf(
+            ledger,
+            leafClaimKey(deps, task),
+            task,
+            inv.depth,
+            () =>
+              emitting(
+                inv,
+                {
+                  kind: "llm",
+                  label: "rlm_query→llm (demoted)",
+                  args: previewText(task),
+                },
+                (track) => complete1(inv, task, track, completeDeps(deps)),
+                (out) => ({
+                  preview: previewText(out),
+                  error: isErrorText(out) ? out : undefined,
+                }),
+              ),
+          ),
+        deps.trackDetached,
+        opts.detached,
+      );
+    }
+
     return spawnAndRun(
       sd,
       "rlm",

package/src/bridge/handlers/types.ts

@@ -12,6 +12,8 @@ import type { RlmInput, RlmResult, Sampling } from "../../core/types.ts";
 import type { SubcallGates } from "../../util/concurrency.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import type { RlmEmitter } from "../../tool/rlm-events.ts";
+import type { TaskLedger } from "../../core/ledger.ts";
+import type { MemoryStore } from "../../core/memory.ts";
 
 // ---------------------------------------------------------------------------
 // Spawn / Await / Finish — the three shapes the model sees
@@ -85,6 +87,12 @@ export interface SubcallConfig {
   readonly maxDepth: number;
   readonly subSampling?: Sampling;
   readonly subSystemPrompt?: string;
+  /** v5 TaskLedger: claim/coalesce/echo gates (optional — unwired callers keep ledger off). */
+  readonly enableLedger?: boolean;
+  /** v5: real rlm spawns before demotion to llm (0 = never demote). */
+  readonly rlmBudget?: number;
+  /** v5 durable memory gates (optional; omitted → memory off). */
+  readonly enableMemory?: boolean;
 }
 
 export interface SubcallHandlerDeps {
@@ -104,6 +112,10 @@ export interface SubcallHandlerDeps {
   readonly degrade?: (prompt: string, depth: number) => Promise<string>;
   readonly onChildUsage?: (costUsd: number, inputTokens: number, outputTokens: number) => void;
   readonly trackDetached?: <T>(run: () => Promise<T>) => Promise<T>;
+  /** v5 TaskLedger blackboard shared across the whole run tree (claim/coalesce/echo/demote). */
+  readonly ledger?: TaskLedger;
+  /** v5 durable memory (session-wide store) for child replay + episode persistence. */
+  readonly memory?: MemoryStore;
 }
 
 // ---------------------------------------------------------------------------

package/src/config/defaults.ts

@@ -31,4 +31,21 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   rootSampling: Object.freeze({ maxTokens: 16_384 }),
   subSystemPrompt: DEFAULT_SUB_SYSTEM_PROMPT,
   subSampling: Object.freeze({ maxTokens: 8192 }),
+  // v5 token budget cascade — the primary run-length control (wall-clock stays a hang backstop).
+  enableTokenBudget: true,
+  budgetShare: 0.25,
+  budgetSoftFrac: 0.8,
+  budgetTaskCap: 400_000,
+  budgetMaxContinuations: 2,
+  budgetHandoffChars: 4_000,
+  // v5 TaskLedger blackboard
+  enableLedger: true,
+  rlmBudget: 8,
+  // v5 durable memory
+  enableMemory: true,
+  injectNoteTokens: 2_000,
+  evolveEvery: 8,
+  memoryDir: null,
+  // v5 role separation: children delegate (llm + memory/ledger); "legacy" = full child surface.
+  childSurface: "delegation",
 });

package/src/config/settings.ts

@@ -45,7 +45,9 @@ function validateThinkingLevel(v: unknown): ThinkingLevel | undefined {
   return typeof v === "string" && Object.hasOwn(THINKING_LEVELS, v) ? (v as ThinkingLevel) : undefined;
 }
 
-function validateConfig(raw: unknown): Partial<RlmConfig> {
+/** Validate an unknown (e.g. hand-edited rlm.json) config blob into a partial — the single
+ *  validation seam; exported for tests. */
+export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (typeof raw !== "object" || raw === null) return {};
   const r = raw as Record<string, unknown>;
   const out: MutablePartialRlmConfig = {};
@@ -90,6 +92,47 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (contextLoader !== undefined) out.contextLoader = contextLoader;
   const autoSeedCwd = validateBoolean(r.autoSeedCwd);
   if (autoSeedCwd !== undefined) out.autoSeedCwd = autoSeedCwd;
+  // v5 token budget cascade
+  const enableTokenBudget = validateBoolean(r.enableTokenBudget);
+  if (enableTokenBudget !== undefined) out.enableTokenBudget = enableTokenBudget;
+  const budgetShare = validateNumber(r.budgetShare, 0.01);
+  if (budgetShare !== undefined && budgetShare <= 1) out.budgetShare = budgetShare;
+  const budgetSoftFrac = validateNumber(r.budgetSoftFrac, 0.5);
+  if (budgetSoftFrac !== undefined && budgetSoftFrac < 1) out.budgetSoftFrac = budgetSoftFrac;
+  const budgetTaskCap = validateNumber(r.budgetTaskCap, 0);
+  if (budgetTaskCap !== undefined) out.budgetTaskCap = budgetTaskCap;
+  const budgetMaxContinuations = validateNumber(r.budgetMaxContinuations, 0);
+  if (budgetMaxContinuations !== undefined) out.budgetMaxContinuations = budgetMaxContinuations;
+  const budgetHandoffChars = validateNumber(r.budgetHandoffChars, 500);
+  if (budgetHandoffChars !== undefined) out.budgetHandoffChars = budgetHandoffChars;
+  // v5 TaskLedger blackboard
+  const enableLedger = validateBoolean(r.enableLedger);
+  if (enableLedger !== undefined) out.enableLedger = enableLedger;
+  const rlmBudget = validateNumber(r.rlmBudget, 0);
+  if (rlmBudget !== undefined) out.rlmBudget = rlmBudget;
+  // v5 durable memory
+  const enableMemory = validateBoolean(r.enableMemory);
+  if (enableMemory !== undefined) out.enableMemory = enableMemory;
+  const injectNoteTokens = validateNumber(r.injectNoteTokens, 100);
+  if (injectNoteTokens !== undefined) out.injectNoteTokens = injectNoteTokens;
+  const evolveEvery = validateNumber(r.evolveEvery, 0);
+  if (evolveEvery !== undefined) out.evolveEvery = evolveEvery;
+  if (r.memoryDir === null) out.memoryDir = null;
+  else {
+    const memoryDir = validateString(r.memoryDir);
+    if (memoryDir !== undefined) out.memoryDir = memoryDir;
+  }
+  // v5 provider concurrency caps: { provider: minConcurrent }
+  if (typeof r.providerMaxConcurrent === "object" && r.providerMaxConcurrent !== null) {
+    const caps: Record<string, number> = {};
+    for (const [provider, cap] of Object.entries(r.providerMaxConcurrent as Record<string, unknown>)) {
+      const n = validateNumber(cap, 1);
+      if (n !== undefined) caps[provider] = n;
+    }
+    if (Object.keys(caps).length > 0) out.providerMaxConcurrent = Object.freeze(caps);
+  }
+  // v5 child surface doctrine
+  if (r.childSurface === "delegation" || r.childSurface === "legacy") out.childSurface = r.childSurface;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
     const ss = r.subSampling as Record<string, unknown>;
     const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};
@@ -99,7 +142,7 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
     if (temperature !== undefined) sampling.temperature = temperature;
     const ssReasoning = validateThinkingLevel(ss.reasoning);
     if (ssReasoning !== undefined) sampling.reasoning = ssReasoning;
-    out.subSampling = sampling;
+    out.subSampling = Object.freeze(sampling);
   }
   if (typeof r.rootSampling === "object" && r.rootSampling !== null) {
     const rs = r.rootSampling as Record<string, unknown>;

package/src/core/answer.ts

@@ -1,7 +1,7 @@
 /** Helpers for detecting and formatting the RLM final answer from a turn's REPL results. */
 
 import type { ReplResult } from "../sandbox/protocol.ts";
-import { truncateOutput } from "../text/parsing.ts";
+import { formatReplStderr } from "../text/repl-output.ts";
 
 /** First non-null final answer across a turn's executed blocks, or null. */
 export function finalAnswerOf(results: readonly ReplResult[]): string | null {
@@ -29,9 +29,10 @@ export function turnHadError(results: readonly ReplResult[]): boolean {
 const SMALL_STDOUT_LIMIT = 800;
 const STDOUT_PREVIEW_LIMIT = 200;
 const STDOUT_TAIL_LIMIT = 200;
-const STDERR_LIMIT = 8_000;
 
-/** The REPL output fed back to the model as the next user message. */
+/** The REPL output fed back to the model as the next user message. Prefixed `REPL stdout:`
+ *  (v5 parity, audit C4): `distillTrajectory` keys on this needle to harvest the working
+ *  set for a budget-capped continuation — without it a hard-cap chain starts blind. */
 export function formatReplOutputs(results: readonly ReplResult[], skippedBlocks = 0): string {
   if (results.length === 0) {
     return "No ```repl``` block found in your response. Write one to interact with the REPL.";
@@ -44,21 +45,21 @@ export function formatReplOutputs(results: readonly ReplResult[], skippedBlocks
     const head = multi ? `[block ${i + 1}]\n` : "";
     const { text, elided } = formatStdout(r);
     hadElision ||= elided;
-    parts[i] = `${head}${text}${formatStderr(r)}`;
+    parts[i] = `${head}${text}${formatReplStderr(r.stderr)}`;
   }
   const body = parts.join("\n\n");
   const skipNote = skippedBlocks > 0
     ? `\n\n[${skippedBlocks} later \`\`\`repl\`\`\` block(s) skipped because an earlier block raised — fix and re-run them]`
     : "";
   // Orientation hint only when the model lost output to elision — otherwise it sees everything.
-  if (!hadElision) return `${body}${skipNote}`;
+  if (!hadElision) return `REPL stdout:\n${body}${skipNote}`;
   // The REPL namespace is persistent across blocks in a turn, so the last block's varNames reflect
   // every variable created in any earlier block too.
   const varNames = results.at(-1)?.varNames ?? [];
   const hint = varNames.length > 0
     ? `REPL vars: ${varNames.join(", ")}`
     : `No REPL vars yet — assign results to variables before printing large outputs.`;
-  return `${body}${skipNote}\n\n${hint}`;
+  return `REPL stdout:\n${body}${skipNote}\n\n${hint}`;
 }
 
 /** Stdout ≤ SMALL_STDOUT_LIMIT flows through verbatim; larger output keeps a short head + a note
@@ -78,7 +79,3 @@ function formatStdout(r: ReplResult): { text: string; elided: boolean } {
   };
 }
 
-function formatStderr(r: ReplResult): string {
-  const err = r.stderr.trim();
-  return err ? `\n[stderr]\n${truncateOutput(err, STDERR_LIMIT)}` : "";
-}