@hicaru/pi-rlm 0.1.9 → 0.2.0

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 = {
@@ -74,7 +74,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). */

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)}`;
 }

package/src/mode/input-router.ts

@@ -1,23 +0,0 @@
-import type { InputSource } from "@earendil-works/pi-coding-agent";
-
-export interface InputRouteState {
-  readonly enabled: boolean;
-  readonly busy: boolean;
-}
-
-export interface InputRouteEvent {
-  readonly source: InputSource;
-  readonly text: string;
-}
-
-export type InputRouteDecision = "continue" | "route" | "busy";
-
-export function decideRlmInputRoute(event: InputRouteEvent, state: InputRouteState): InputRouteDecision {
-  const eligible = state.enabled && event.source === "interactive" && !event.text.trimStart().startsWith("/");
-  if (!eligible) return "continue";
-  return state.busy ? "busy" : "route";
-}
-
-export function shouldRouteRlmInput(event: InputRouteEvent, state: InputRouteState): boolean {
-  return decideRlmInputRoute(event, state) === "route";
-}