@hicaru/pi-rlm 0.1.8 → 0.2.0

package/src/tool/rlm-aggregator.ts

@@ -6,14 +6,14 @@
  * getState(): RlmDetails for direct access (spinner loop, final return).
  *
  * Subcall storage and totals are delegated to SubcallStore. Root-level state
- * (status, prompt, turns, answer, edits) is kept in the aggregator.
+ * (status, prompt, turns, answer, warnings) is kept in the aggregator.
  *
  * Replaces RlmToolBridge's internal state accumulation. The emitter is pure
  * dispatch; the aggregator is pure state. Separated for independent testing.
  */
 
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, EditsEvent, StatusEvent, RootPromptEvent } from "./rlm-events.ts";
+import type { RlmEmitter, TurnEvent, RootUsageEvent, AnswerEvent, StatusEvent, RootPromptEvent, WarningsEvent } from "./rlm-events.ts";
 import type { RlmDetails, RlmRunStatus } from "./rlm-details.ts";
 import { EmitterListener } from "./emitter-listener.ts";
 import { SubcallStore } from "./subcall-store.ts";
@@ -27,7 +27,7 @@ export class RlmEventAggregator extends EmitterListener {
   private turnCurrent = 0;
   private turnMax = 0;
   private answer?: string;
-  private edits: RlmDetails["edits"] = [];
+  private warnings?: readonly string[];
 
   constructor(
     emitter: RlmEmitter,
@@ -40,7 +40,7 @@ export class RlmEventAggregator extends EmitterListener {
       emitter.onTurn((e) => this.handleTurn(e)),
       emitter.onRootUsage((e) => this.handleRootUsage(e)),
       emitter.onAnswer((e) => this.handleAnswer(e)),
-      emitter.onEdits((e) => this.handleEdits(e)),
+      emitter.onWarnings((e) => this.handleWarnings(e)),
       emitter.onStatus((e) => this.handleStatus(e)),
       emitter.onRootPrompt((e) => this.handleRootPrompt(e)),
     ]);
@@ -64,8 +64,8 @@ export class RlmEventAggregator extends EmitterListener {
     this.notify();
   }
 
-  private handleEdits(event: EditsEvent): void {
-    this.edits = event.edits;
+  private handleWarnings(event: WarningsEvent): void {
+    this.warnings = event.warnings;
     this.notify();
   }
 
@@ -90,7 +90,7 @@ export class RlmEventAggregator extends EmitterListener {
       subcalls: this.store.getSubcalls(),
       totals: this.store.getTotals(),
       answer: this.answer,
-      edits: this.edits,
+      warnings: this.warnings,
     };
   }
 

package/src/tool/rlm-details.ts

@@ -6,8 +6,6 @@
  * after every mutation, enabling Pi's built-in progressive TUI re-render.
  */
 
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-
 export type SubcallKind = "root" | "rlm" | "llm" | "batch" | "tool";
 export type SubcallStatus = "running" | "done" | "error";
 export type RlmRunStatus = "running" | "done" | "error" | "aborted";
@@ -29,6 +27,10 @@ export interface RlmSubcall {
   readonly endedAt?: number;
   readonly costUsd: number;
   readonly tokens: number;
+  /** For batch subcalls: failed prompt count (partial failure). */
+  readonly failedCount?: number;
+  /** For batch subcalls: total prompt count. */
+  readonly totalCount?: number;
 }
 
 export interface RlmDetails {
@@ -38,16 +40,7 @@ export interface RlmDetails {
   readonly subcalls: readonly RlmSubcall[];
   readonly totals: { readonly costUsd: number; readonly tokens: number };
   readonly answer?: string;
-  readonly edits?: readonly ProposedEdit[];
+  /** Advisory diagnostics — surfaced to the user, never a failure. */
+  readonly warnings?: readonly string[];
 }
 
-export interface SubcallInit {
-  readonly parentId?: string;
-  readonly kind: SubcallKind;
-  readonly label: string;
-  readonly model?: string;
-  readonly detail?: string;
-  readonly args?: string;
-  /** Recursion depth. Required — all call sites pass this. */
-  readonly depth: number;
-}

package/src/tool/rlm-events.ts

@@ -12,7 +12,6 @@
 
 import { EventEmitter } from "node:events";
 import type { SubcallKind, SubcallStatus, RlmRunStatus } from "./rlm-details.ts";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
 
 // ── Event payloads ──
 
@@ -40,6 +39,14 @@ export interface SubcallUpdatedEvent {
   readonly costUsd?: number;
   /** Delta — additive on both the subcall and running totals. */
   readonly tokens?: number;
+  /** For batch subcalls: failed prompt count. */
+  readonly failedCount?: number;
+  /** For batch subcalls: total prompt count. */
+  readonly totalCount?: number;
+}
+
+export interface WarningsEvent {
+  readonly warnings: readonly string[];
 }
 
 export interface TurnEvent {
@@ -56,10 +63,6 @@ export interface AnswerEvent {
   readonly text: string;
 }
 
-export interface EditsEvent {
-  readonly edits: readonly ProposedEdit[];
-}
-
 export interface StatusEvent {
   readonly status: RlmRunStatus;
 }
@@ -110,9 +113,9 @@ export class RlmEmitter {
     this.ee.emit("answer", { text } satisfies AnswerEvent);
   }
 
-  /** Set proposed edits (root-only). */
-  emitEdits(edits: readonly ProposedEdit[]): void {
-    this.ee.emit("edits", { edits } satisfies EditsEvent);
+  /** Set advisory warnings (root-only; never a failure). */
+  emitWarnings(warnings: readonly string[]): void {
+    this.ee.emit("warnings", { warnings } satisfies WarningsEvent);
   }
 
   /** Set the root run status (done/error/aborted). */
@@ -152,9 +155,9 @@ export class RlmEmitter {
     return () => { this.ee.off("answer", handler); };
   }
 
-  onEdits(handler: (event: EditsEvent) => void): () => void {
-    this.ee.on("edits", handler);
-    return () => { this.ee.off("edits", handler); };
+  onWarnings(handler: (event: WarningsEvent) => void): () => void {
+    this.ee.on("warnings", handler);
+    return () => { this.ee.off("warnings", handler); };
   }
 
   onStatus(handler: (event: StatusEvent) => void): () => void {

package/src/tool/rlm-tool.ts

@@ -5,23 +5,29 @@
  * onUpdate(partialResult) for progressive TUI re-rendering.
  */
 
-import { getMarkdownTheme, type Theme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Theme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text, type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import type { RlmController, StartInput } from "../mode/rlm-mode.ts";
-import { formatCost, formatTokens, spinnerFrame } from "../ui/theme.ts";
+import { spinnerFrame } from "../ui/theme.ts";
+import { markdownTheme } from "../ui/theme-adapter.ts";
+import { previewText } from "../text/preview.ts";
 import { errorMessage } from "../util/errors.ts";
 import { type RlmDetails } from "./rlm-details.ts";
 import { RlmEmitter } from "./rlm-events.ts";
 import { RlmEventAggregator } from "./rlm-aggregator.ts";
 import {
-  headlineStatusGlyph,
-  renderCollapsedSubcallTree,
+  cardHeader,
+  cardStatsLine,
+  renderCollapsedCard,
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 
+/** Chars of the prompt shown on the tool call line. */
+const CALL_PREVIEW_CHARS = 80;
+
 // ── Parameter schema ──
 
 export const RlmToolParams = Object.freeze(Type.Object({
@@ -32,11 +38,8 @@ export const RlmToolParams = Object.freeze(Type.Object({
 // ── Rendering helpers ──
 
 function rootStats(details: RlmDetails, theme: Theme): string {
-  const parts: string[] = [];
-  parts.push(formatCost(details.totals.costUsd));
-  parts.push(`${formatTokens(details.totals.tokens)} tok`);
-  if (details.turns.current > 0) parts.push(`${details.turns.current} turn${details.turns.current > 1 ? "s" : ""}`);
-  return theme.fg("dim", parts.join(" · "));
+  const turns = details.turns.current;
+  return cardStatsLine(details.totals, theme, turns > 0 ? `${turns} turn${turns > 1 ? "s" : ""}` : undefined);
 }
 
 // ── Tool definition ──
@@ -110,18 +113,14 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
       }
     },
 
-    renderCall(args, theme, _context) {
-      const preview = args.prompt.length > 80
-        ? `${args.prompt.slice(0, 80)}...`
-        : args.prompt;
+    renderCall(args, theme) {
       return new Text(
-        theme.fg("toolTitle", theme.bold("rlm ")) +
-        theme.fg("dim", preview.replace(/\n/g, " ")),
+        theme.fg("toolTitle", theme.bold("rlm ")) + theme.fg("dim", previewText(args.prompt, CALL_PREVIEW_CHARS)),
         0, 0,
       );
     },
 
-    renderResult(result, { expanded, isPartial: _isPartial }, theme, _context) {
+    renderResult(result, { expanded }, theme) {
       const details = result.details as RlmDetails | undefined;
       if (!details) {
         const text = result.content[0];
@@ -139,10 +138,7 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
 
 function renderExpanded(details: RlmDetails, theme: Theme): Component {
   const container = new Container();
-
-  const glyph = headlineStatusGlyph(details.status, theme);
-  const header = `${glyph} ${theme.fg("toolTitle", theme.bold("RLM"))} · ${rootStats(details, theme)}`;
-  container.addChild(new Text(header, 0, 0));
+  container.addChild(new Text(cardHeader("RLM", details.status, rootStats(details, theme), theme), 0, 0));
 
   if (details.subcalls.length > 0) {
     container.addChild(new Spacer(1));
@@ -153,17 +149,12 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
   if (details.answer) {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", "─── Answer ───"), 0, 0));
-    container.addChild(new Markdown(details.answer, 0, 0, getMarkdownTheme()));
+    container.addChild(new Markdown(details.answer, 0, 0, markdownTheme(theme)));
   }
 
-  if (details.edits && details.edits.length > 0) {
+  if (details.warnings && details.warnings.length > 0) {
     container.addChild(new Spacer(1));
-    const editFiles = new Set(details.edits.map(e => e.path));
-    container.addChild(new Text(
-      theme.fg("muted", "─── Edits ───") +
-      `\n  ${theme.fg("dim", `${details.edits.length} edit${details.edits.length > 1 ? "s" : ""} proposed across ${editFiles.size} file${editFiles.size > 1 ? "s" : ""}`)}`,
-      0, 0,
-    ));
+    container.addChild(new Text(theme.fg("muted", details.warnings.join("\n")), 0, 0));
   }
 
   return container;
@@ -172,14 +163,5 @@ function renderExpanded(details: RlmDetails, theme: Theme): Component {
 // ── Collapsed view ──
 
 function renderCollapsed(details: RlmDetails, theme: Theme): Text {
-  const glyph = headlineStatusGlyph(details.status, theme);
-  const header = `${glyph} ${theme.fg("toolTitle", theme.bold("RLM"))} · ${rootStats(details, theme)}`;
-
-  let body = "";
-  if (details.subcalls.length > 0) {
-    body = `\n${renderCollapsedSubcallTree(details.subcalls, theme)}`;
-  }
-
-  const expandHint = details.status === "running" ? "" : `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
-  return new Text(`${header}${body}${expandHint}`, 0, 0);
+  return renderCollapsedCard("RLM", details.status, rootStats(details, theme), details.subcalls, theme);
 }

package/src/tool/subcall-render.ts

@@ -7,15 +7,17 @@
  */
 
 import { Container, Text, type Component } from "@earendil-works/pi-tui";
+import { keyText } from "@earendil-works/pi-coding-agent";
 import type { RlmSubcall, SubcallStatus } from "./rlm-details.ts";
 import { formatCost, formatDuration, formatTokens, spinnerFrame } from "../ui/theme.ts";
+import { previewText } from "../text/preview.ts";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
-// ── Glyphs ──
+/** Preview budgets for the expanded tree (args are terse, results get more room). */
+const ARGS_PREVIEW_CHARS = 80;
+const RESULT_PREVIEW_CHARS = 120;
 
-export function subcallRunningGlyph(theme: Theme): string {
-  return theme.fg("warning", spinnerFrame());
-}
+// ── Glyphs ──
 
 export function subcallStatusGlyph(sc: Pick<RlmSubcall, "status">, theme: Theme): string {
   if (sc.status === "running") return theme.fg("warning", "⏳");
@@ -38,10 +40,62 @@ export function subcallStatsLine(sc: Pick<RlmSubcall, "costUsd" | "tokens" | "en
   const parts: string[] = [];
   if (sc.costUsd > 0) parts.push(formatCost(sc.costUsd));
   if (sc.tokens > 0) parts.push(`${formatTokens(sc.tokens)} tok`);
-  if (sc.endedAt && sc.startedAt) parts.push(formatDuration(sc.endedAt - sc.startedAt));
+  // Explicit undefined checks: a 0 timestamp is falsy but legitimate (fixtures, epoch clocks).
+  if (sc.endedAt !== undefined && sc.startedAt !== undefined) parts.push(formatDuration(sc.endedAt - sc.startedAt));
   return parts.join(" · ");
 }
 
+// ── Shared card scaffolding (rlm + repl render the same shape) ──
+
+/** The `$0.0123 · 4.2k tok · 812ms` run of a card header. Omits any zero component. */
+export function cardStatsLine(
+  totals: { readonly costUsd: number; readonly tokens: number },
+  theme: Theme,
+  extra?: string,
+): string {
+  const parts: string[] = [formatCost(totals.costUsd)];
+  if (totals.tokens > 0) parts.push(`${formatTokens(totals.tokens)} tok`);
+  if (extra) parts.push(extra);
+  return theme.fg("dim", parts.join(" · "));
+}
+
+/** `<glyph> <TITLE> <stats>` — the first line of both tools' collapsed and expanded views. */
+export function cardHeader(
+  title: string,
+  status: SubcallStatus | "aborted" | "done",
+  stats: string,
+  theme: Theme,
+): string {
+  return `${headlineStatusGlyph(status, theme)} ${theme.fg("toolTitle", theme.bold(title))} ${stats}`;
+}
+
+/**
+ * The expand hint, using the user's actual binding rather than a hardcoded "Ctrl+O".
+ *
+ * Deliberately `keyText` + the injected theme rather than pi's `keyHint`: `keyHint` colours via
+ * pi's module-global theme, which throws when that global is uninitialized — the same jiti
+ * hazard `ui/theme-adapter.ts` exists to avoid. `keyText` only reads the keybinding registry.
+ */
+function expandHint(theme: Theme): string {
+  // Empty outside a live pi session (the app installs the real binding registry at startup) —
+  // the phrase stays the same, only the key prefix drops out.
+  const key = keyText("app.tools.expand");
+  return theme.fg("muted", key ? `${key} to expand` : "to expand");
+}
+
+/** The collapsed card: header, the sub-call tree, and the expand hint. */
+export function renderCollapsedCard(
+  title: string,
+  status: SubcallStatus | "aborted" | "done",
+  stats: string,
+  subcalls: readonly RlmSubcall[],
+  theme: Theme,
+): Text {
+  const body = subcalls.length > 0 ? `\n${renderCollapsedSubcallTree(subcalls, theme)}` : "";
+  const hint = status === "running" ? "" : `\n${expandHint(theme)}`;
+  return new Text(`${cardHeader(title, status, stats, theme)}${body}${hint}`, 0, 0);
+}
+
 // ── Tree building ──
 
 function buildParentMap(subcalls: readonly RlmSubcall[]): Map<string | undefined, RlmSubcall[]> {
@@ -104,14 +158,12 @@ export function renderExpandedSubcallTree(
     let line = `${pad}${sGlyph} ${sKind}${sModel}${sStats}`;
 
     if (sc.args) {
-      const ap = sc.args.length > 80 ? `${sc.args.slice(0, 80)}...` : sc.args;
-      line += `\n${pad}  ${theme.fg("dim", ap)}`;
+      line += `\n${pad}  ${theme.fg("dim", previewText(sc.args, ARGS_PREVIEW_CHARS))}`;
     }
     if (sc.status === "error" && sc.detail) {
       line += `\n${pad}  ${theme.fg("error", `✗ ${sc.detail}`)}`;
     } else if (sc.resultPreview) {
-      const rp = sc.resultPreview.length > 120 ? `${sc.resultPreview.slice(0, 120)}...` : sc.resultPreview;
-      line += `\n${pad}  ${theme.fg("toolOutput", rp)}`;
+      line += `\n${pad}  ${theme.fg("toolOutput", previewText(sc.resultPreview, RESULT_PREVIEW_CHARS))}`;
     }
 
     container.addChild(new Text(line, 0, 0));

package/src/tool/subcall-store.ts

@@ -7,7 +7,7 @@
  * subcall accumulation logic.
  */
 import type { RlmEmitter, SubcallCreatedEvent, SubcallUpdatedEvent } from "./rlm-events.ts";
-import type { RlmSubcall, SubcallStatus } from "./rlm-details.ts";
+import type { RlmSubcall } from "./rlm-details.ts";
 import { EmitterListener } from "./emitter-listener.ts";
 
 type MutableSubcall = {
@@ -66,13 +66,15 @@ export class SubcallStore extends EmitterListener {
       sc.tokens += event.tokens;
       this.totalTokens += event.tokens;
     }
+    if (event.failedCount !== undefined) sc.failedCount = event.failedCount;
+    if (event.totalCount !== undefined) sc.totalCount = event.totalCount;
   }
 
   // ── Read ──
 
   /** Snapshot subcall array. Allocates a new array from Map values. */
   getSubcalls(): RlmSubcall[] {
-    return Array.from(this.subcalls.values(), (subcall) => Object.freeze({ ...subcall, status: subcall.status as SubcallStatus }));
+    return Array.from(this.subcalls.values(), (subcall) => Object.freeze({ ...subcall }));
   }
 
   /** Snapshot running totals. O(1). */

package/src/ui/config-panel.ts

@@ -18,8 +18,10 @@ const CHOICES = Object.freeze({
   pipeline: Object.freeze(["on", "off"]),
   maxBackwardJumps: Object.freeze(["0", "1", "2", "3"]),
   compaction: Object.freeze(["on", "off"]),
+  compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
+  requestTimeoutMs: Object.freeze(["2", "5", "10", "20"]),
   askUserQuestion: Object.freeze(["on", "off"]),
   todo: Object.freeze(["on", "off"]),
   libraryLoader: Object.freeze(["on", "off"]),
@@ -29,8 +31,13 @@ function item(id: string, label: string, currentValue: string, values: readonly
   return { id, label, currentValue, values: [...values], description };
 }
 
-export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig): Promise<void> {
-  if (ctx.mode !== "tui") return;
+/**
+ * Show the settings panel and resolve with the edited config.
+ * `config` is never mutated — each change produces a new frozen object.
+ */
+export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig): Promise<RlmConfig> {
+  if (ctx.mode !== "tui") return config;
+  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."),
@@ -41,15 +48,17 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxTokens", "Token ceiling", config.maxTokens != null ? String(config.maxTokens) : "none", CHOICES.maxTokens, "Total input+output token cap for the whole recursive tree."),
     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("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable artifact-gated phases: clarify→research→blueprint→implement fanout→validate (clarify needs Ask user on)."),
+    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable artifact-gated phases: clarify→research→blueprint→validate (read-only plan pipeline; clarify needs Ask user on)."),
     item("maxBackwardJumps", "Max validate→blueprint loops", String(config.maxBackwardJumps), CHOICES.maxBackwardJumps, "Bounded corrective re-entries when validation reports blockers_count > 0."),
     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("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("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
+    item("requestTimeoutMs", "Sandbox request timeout (min)", String(Math.round(config.requestTimeoutMs / 60_000)), CHOICES.requestTimeoutMs, "Parent-side watchdog per sandbox request; on breach the Python worker is killed."),
     item("askUserQuestion", "[Interactive] Ask user", config.askUserQuestion ? "on" : "off", CHOICES.askUserQuestion, "Allow root REPL code to present structured ask_user_question dialogs."),
     item("todo", "[Interactive] Todo", config.todo ? "on" : "off", CHOICES.todo, "Allow REPL code to manage a visible todo task list."),
     item("libraryLoader", "Library loader", config.libraryLoader ? "on" : "off", CHOICES.libraryLoader,
-      "Allow load_library() to pull an external dir, file, or git repo into a new context_N slot."),
+      "Allow load_library() to pull an external dir, file, or git repo into the shared context list."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 
@@ -65,7 +74,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
           done();
           return;
         }
-        applySetting(config, id, value);
+        edited = applySetting(edited, id, value);
       },
       () => done(),
     );
@@ -77,26 +86,37 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
       handleInput: (data) => list.handleInput?.(data),
     };
   });
+  return edited;
 }
 
-function applySetting(config: RlmConfig, id: string, value: string): void {
+/** Optional numeric field: the literal "none" clears it. */
+function optionalNumber(value: string, scale = 1): number | undefined {
+  return value === "none" ? undefined : Number(value) * scale;
+}
+
+/** Pure: returns a new frozen config with `id` set to `value`; unknown ids pass through. */
+export function applySetting(config: RlmConfig, id: string, value: string): RlmConfig {
   switch (id) {
-    case "maxDepth": config.maxDepth = Number(value); break;
-    case "maxIterations": config.maxIterations = Number(value); break;
-    case "execTimeoutS": config.execTimeoutS = Number(value); break;
-    case "maxConcurrentSubcalls": config.maxConcurrentSubcalls = Number(value); break;
-    case "maxBudgetUsd": config.maxBudgetUsd = value === "none" ? undefined : Number(value); break;
-    case "maxTimeoutMs": config.maxTimeoutMs = value === "none" ? undefined : Number(value) * 60_000; break;
-    case "maxTokens": config.maxTokens = value === "none" ? undefined : Number(value); break;
-    case "maxErrors": config.maxErrors = value === "none" ? undefined : Number(value); break;
-    case "orchestrator": config.orchestrator = value === "on"; break;
-    case "pipeline": config.pipeline = value === "on"; break;
-    case "maxBackwardJumps": config.maxBackwardJumps = Number(value); break;
-    case "compaction": config.compaction = value === "on"; break;
-    case "rootSamplingMaxTokens": config.rootSampling = Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }); break;
-    case "sandboxInitTimeoutMs": config.sandboxInitTimeoutMs = Number(value); break;
-    case "askUserQuestion": config.askUserQuestion = value === "on"; break;
-    case "todo": config.todo = value === "on"; break;
-    case "libraryLoader": config.libraryLoader = value === "on"; break;
+    case "maxDepth": return Object.freeze({ ...config, maxDepth: Number(value) });
+    case "maxIterations": return Object.freeze({ ...config, maxIterations: Number(value) });
+    case "execTimeoutS": return Object.freeze({ ...config, execTimeoutS: Number(value) });
+    case "maxConcurrentSubcalls": return Object.freeze({ ...config, maxConcurrentSubcalls: Number(value) });
+    case "maxBudgetUsd": return Object.freeze({ ...config, maxBudgetUsd: optionalNumber(value) });
+    case "maxTimeoutMs": return Object.freeze({ ...config, maxTimeoutMs: optionalNumber(value, 60_000) });
+    case "maxTokens": return Object.freeze({ ...config, maxTokens: optionalNumber(value) });
+    case "maxErrors": return Object.freeze({ ...config, maxErrors: optionalNumber(value) });
+    case "orchestrator": return Object.freeze({ ...config, orchestrator: value === "on" });
+    case "pipeline": return Object.freeze({ ...config, pipeline: value === "on" });
+    case "maxBackwardJumps": return Object.freeze({ ...config, maxBackwardJumps: Number(value) });
+    case "compaction": return Object.freeze({ ...config, compaction: value === "on" });
+    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 "sandboxInitTimeoutMs": return Object.freeze({ ...config, sandboxInitTimeoutMs: Number(value) });
+    case "requestTimeoutMs": return Object.freeze({ ...config, requestTimeoutMs: Number(value) * 60_000 });
+    case "askUserQuestion": return Object.freeze({ ...config, askUserQuestion: value === "on" });
+    case "todo": return Object.freeze({ ...config, todo: value === "on" });
+    case "libraryLoader": return Object.freeze({ ...config, libraryLoader: value === "on" });
+    default: return config;
   }
 }

package/src/ui/intro.ts

@@ -15,7 +15,8 @@ export const RLM_GUIDE = `# RLM mode
 - \`/rlm-stop\` — cancel the current run but stay in RLM mode (use /rlm or Ctrl+Shift+R to leave)
 - \`/rlm-help\` — show this guide again
 
-When RLM mode is ON, plain messages route to RLM. The footer/status line shows the current state.`;
+When RLM mode is ON, \`read\`/\`grep\` are disabled and the agent reads the repository through the
+\`repl\` tool, delegating bulk analysis to sub-LLMs. The footer/status line shows the current state.`;
 
 export function postRlmGuide(pi: ExtensionAPI, controller: RlmController): void {
   const content = RLM_GUIDE.replace("{state}", formatRlmStateLine(controller));

package/src/ui/status.ts

@@ -1,6 +1,6 @@
 /** Footer status line for RLM mode and active runs. */
 
-import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import type { ContextUsage, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { RlmController } from "../mode/rlm-mode.ts";
 
@@ -10,15 +10,18 @@ export function modelLabel(model: Model<Api> | undefined, fallback: string): str
   return model ? `${model.provider}/${model.id}` : fallback;
 }
 
-export function formatRlmStateLine(controller: RlmController): string {
+export function formatRlmStateLine(controller: RlmController, contextUsage?: ContextUsage): string {
   if (!controller.enabled) return "○ RLM OFF";
   const worker = modelLabel(controller.workerModel, controller.savedWorkerRef ?? "cheapest");
   const workerSuffix = controller.config.subSampling.reasoning ? `:${controller.config.subSampling.reasoning}` : "";
-  return `● RLM ON · worker=${worker}${workerSuffix}`;
+  // `percent` is null right after a compaction, before the next assistant response reports usage.
+  const percent = contextUsage?.percent;
+  const ctxSuffix = percent === null || percent === undefined ? "" : ` · ctx ${Math.round(percent)}%`;
+  return `● RLM ON · worker=${worker}${workerSuffix}${ctxSuffix}`;
 }
 
-export function setRlmModeStatus(ui: ExtensionUIContext, controller: RlmController): void {
-  ui.setStatus(KEY, formatRlmStateLine(controller));
+export function setRlmModeStatus(ui: ExtensionUIContext, controller: RlmController, contextUsage?: ContextUsage): void {
+  ui.setStatus(KEY, formatRlmStateLine(controller, contextUsage));
 }
 
 export function clearRlmStatus(ui: ExtensionUIContext): void {

package/src/ui/theme-adapter.ts

@@ -0,0 +1,36 @@
+/**
+ * Theme adapters bound to an *injected* Theme instance.
+ *
+ * Pi's own `getMarkdownTheme()` closes over a module-global `theme` singleton. Extensions are
+ * loaded through jiti, which gives them a separate module cache, so that global can be
+ * `undefined` inside a plugin — pi documents this footgun on `DynamicBorder`. Every renderer
+ * pi calls hands us a live `Theme`, so we build the adapter from that instead of the global.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+
+/**
+ * A `MarkdownTheme` derived from the theme pi passed to this render pass.
+ *
+ * `highlightCode` is deliberately omitted: pi's implementation also reads the module global,
+ * and it is optional on `MarkdownTheme` — code blocks render uncoloured rather than crashing.
+ */
+export function markdownTheme(theme: Theme): MarkdownTheme {
+  return {
+    heading: (text) => theme.fg("mdHeading", text),
+    link: (text) => theme.fg("mdLink", text),
+    linkUrl: (text) => theme.fg("mdLinkUrl", text),
+    code: (text) => theme.fg("mdCode", text),
+    codeBlock: (text) => theme.fg("mdCodeBlock", text),
+    codeBlockBorder: (text) => theme.fg("mdCodeBlockBorder", text),
+    quote: (text) => theme.fg("mdQuote", text),
+    quoteBorder: (text) => theme.fg("mdQuoteBorder", text),
+    hr: (text) => theme.fg("mdHr", text),
+    listBullet: (text) => theme.fg("mdListBullet", text),
+    bold: (text) => theme.bold(text),
+    italic: (text) => theme.italic(text),
+    underline: (text) => theme.underline(text),
+    strikethrough: (text) => theme.strikethrough(text),
+  };
+}

package/src/ui/theme.ts

@@ -1,36 +1,11 @@
 /** Small presentation helpers shared by the RLM widgets (glyphs, spinner, formatting). */
 
-import type { SubcallKind, SubcallStatus } from "../tool/rlm-details.ts";
-
 export const SPINNER = Object.freeze(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]);
 
 export function spinnerFrame(): string {
   return SPINNER[Math.floor(Date.now() / 100) % SPINNER.length] ?? "⠋";
 }
 
-/** Glyph for a node's status. */
-export function statusGlyph(status: SubcallStatus): string {
-  if (status === "done") return "✓";
-  if (status === "error") return "✗";
-  return spinnerFrame();
-}
-
-/** Short role label for a node kind. */
-export function kindLabel(kind: SubcallKind): string {
-  switch (kind) {
-    case "root":
-      return "RLM ▸ root";
-    case "rlm":
-      return "rlm_query";
-    case "batch":
-      return "llm_query×";
-    case "tool":
-      return "tool";
-    default:
-      return "llm_query";
-  }
-}
-
 export function formatCost(usd: number): string {
   return `$${usd.toFixed(usd < 1 ? 4 : 2)}`;
 }