@hicaru/pi-rlm 0.1.9 → 0.2.1

package/src/tool/rlm-details.ts

@@ -44,13 +44,3 @@ export interface RlmDetails {
   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

@@ -76,18 +76,26 @@ export interface RootPromptEvent {
 /**
  * Typed wrapper around a Node.js EventEmitter for RLM lifecycle events.
  *
- * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`.
+ * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`, with a
+ * configurable prefix so a second emitter's IDs cannot collide with the default ones.
  * Provides typed `on*` methods that return unsubscribe functions.
  */
 export class RlmEmitter {
   private readonly ee = new EventEmitter();
   private seq = 0;
 
+  /**
+   * `idPrefix` namespaces generated IDs. The counter is per-instance, so two emitters
+   * would both start at `s1`; a distinct prefix is what lets one emitter's subcalls be
+   * merged into another's tree without colliding IDs or corrupting parentId links.
+   */
+  constructor(private readonly idPrefix = "s") {}
+
   // ── Emit ──
 
   /** Create a new sub-call entry. Returns the auto-generated ID. */
   emitSubcallCreated(init: Omit<SubcallCreatedEvent, "id">): string {
-    const id = `s${++this.seq}`;
+    const id = `${this.idPrefix}${++this.seq}`;
     const event: SubcallCreatedEvent = { id, ...init };
     this.ee.emit("subcall:created", event);
     return id;

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,7 +149,7 @@ 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.warnings && details.warnings.length > 0) {
@@ -167,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,72 @@ 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,
+  backgroundPending?: number,
+): string {
+  const parts: string[] = [formatCost(totals.costUsd)];
+  if (totals.tokens > 0) parts.push(`${formatTokens(totals.tokens)} tok`);
+  if (extra) parts.push(extra);
+  const line = theme.fg("dim", parts.join(" · "));
+  // The one thing no tree can show: spawned work that may outlive this block.
+  return backgroundPending !== undefined && backgroundPending > 0
+    ? `${line} ${theme.fg("warning", `↯${backgroundPending} bg`)}`
+    : line;
+}
+
+/** Detached nodes carry BackgroundTasks' "bg" id prefix (RlmEmitter("bg")). */
+function backgroundTag(sc: RlmSubcall, theme: Theme): string {
+  return sc.id.startsWith("bg") ? ` ${theme.fg("warning", "↯bg")}` : "";
+}
+
+/** `<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[]> {
@@ -74,7 +138,8 @@ export function renderCollapsedSubcallTree(
       const branch = isLast ? "└─" : "├─";
       const gGlyph = subcallStatusGlyph(sc, theme);
       const gStats = subcallStatsLine(sc);
-      lines.push(`${prefix}${branch} ${sc.label}  ${gGlyph}  ${gStats}`);
+      const gBg = backgroundTag(sc, theme);
+      lines.push(`${prefix}${branch} ${sc.label}  ${gGlyph}  ${gStats}${gBg}`);
       const childPrefix = prefix + (isLast ? "   " : "│  ");
       lines.push(...walk(sc.id, childPrefix));
     }
@@ -101,17 +166,16 @@ export function renderExpandedSubcallTree(
     const sKind = theme.fg("muted", sc.label);
     const sModel = sc.model ? theme.fg("dim", ` ${sc.model}`) : "";
     const sStats = sc.endedAt ? `  ${theme.fg("dim", subcallStatsLine(sc))}` : "";
-    let line = `${pad}${sGlyph} ${sKind}${sModel}${sStats}`;
+    const sBg = backgroundTag(sc, theme);
+    let line = `${pad}${sGlyph} ${sKind}${sModel}${sStats}${sBg}`;
 
     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

@@ -14,6 +14,12 @@ type MutableSubcall = {
   -readonly [Key in keyof RlmSubcall]: RlmSubcall[Key];
 };
 
+/** Accumulated cost/tokens, shared by getTotals() and takeSettledSubtrees(). */
+export interface SubcallTotals {
+  readonly costUsd: number;
+  readonly tokens: number;
+}
+
 export class SubcallStore extends EmitterListener {
   private readonly subcalls = new Map<string, MutableSubcall>();
 
@@ -74,7 +80,7 @@ export class SubcallStore extends EmitterListener {
 
   /** 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). */
@@ -82,6 +88,56 @@ export class SubcallStore extends EmitterListener {
     return { costUsd: this.totalCostUsd, tokens: this.totalTokens };
   }
 
+  /**
+   * Remove and return every fully-settled root subtree, with its cost/tokens subtracted
+   * from the running totals so the caller can add them without double-counting.
+   *
+   * A root whose subtree still has a running node stays put. That matters because
+   * `renderCollapsedSubcallTree` walks down from `parentId === undefined`: a subcall handed
+   * over without its parent has no path from a root and is silently dropped from the tree.
+   * Handing over whole subtrees is what keeps adopted nodes renderable.
+   */
+  takeSettledSubtrees(): { readonly subcalls: readonly RlmSubcall[]; readonly totals: SubcallTotals } {
+    const children = new Map<string | undefined, MutableSubcall[]>();
+    for (const sc of this.subcalls.values()) {
+      const siblings = children.get(sc.parentId);
+      if (siblings === undefined) children.set(sc.parentId, [sc]);
+      else siblings.push(sc);
+    }
+
+    // Collect a root's subtree, or undefined when any node in it is still running.
+    const settledSubtree = (root: MutableSubcall): MutableSubcall[] | undefined => {
+      const collected: MutableSubcall[] = [];
+      const stack: MutableSubcall[] = [root];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined) continue;
+        if (node.status === "running") return undefined;
+        collected.push(node);
+        const kids = children.get(node.id);
+        if (kids !== undefined) stack.push(...kids);
+      }
+      return collected;
+    };
+
+    const taken: RlmSubcall[] = [];
+    let costUsd = 0;
+    let tokens = 0;
+    for (const root of children.get(undefined) ?? []) {
+      const subtree = settledSubtree(root);
+      if (subtree === undefined) continue;
+      for (const node of subtree) {
+        costUsd += node.costUsd;
+        tokens += node.tokens;
+        taken.push(Object.freeze({ ...node, status: node.status as SubcallStatus }));
+        this.subcalls.delete(node.id);
+      }
+    }
+    this.totalCostUsd -= costUsd;
+    this.totalTokens -= tokens;
+    return { subcalls: taken, totals: { costUsd, tokens } };
+  }
+
   // ── Root usage (delegated from RlmEventAggregator) ──
 
   /** Accumulate root-level usage into shared totals. Called by aggregator. */

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."),
@@ -44,8 +51,10 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     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,
@@ -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)}`;
 }