@hicaru/pi-rlm 0.3.21 → 0.3.22

package/README.md

@@ -5,7 +5,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/@hicaru/pi-rlm"><img src="https://img.shields.io/npm/v/@hicaru/pi-rlm?color=cb3837&logo=npm" alt="npm version"></a>
   <a href="https://github.com/openzebra/rlm.pi/blob/master/pi-plugin/rlm/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
-  <a href="https://github.com/earendil-works/pi"><img src="https://img.shields.io/badge/for-Pi-7c3aed" alt="Built for Pi"></a>
+  <a href="https://github.com/earendil-works/pi"><img src="https://img.shields.io/badge/for-Pi%20%C2%B7%20omp-7c3aed" alt="Built for Pi and oh-my-pi"></a>
 </p>
 
 <p align="center">
@@ -17,17 +17,17 @@
 ## Install
 
 ```bash
-pi install npm:@hicaru/pi-rlm
+pi install npm:@hicaru/pi-rlm        # Pi
+omp plugin install @hicaru/pi-rlm    # oh-my-pi
 ```
 
-Run `/reload` in Pi — `/rlm`, `/rlm-config`, `/rlm-stop` appear under **[Extensions]**.
-Toggle with `Ctrl+Shift+R` or `/rlm`.
+Then `/reload` (or restart) — `/rlm`, `/rlm-config`, `/rlm-stop` appear under
+**[Extensions]**. Toggle with `Ctrl+Shift+R` or `/rlm`.
 
-To remove it later:
-
-```bash
-pi uninstall npm:@hicaru/pi-rlm
-```
+|              | install                             | upgrade                                     | remove                                |
+| ------------ | ----------------------------------- | ------------------------------------------- | ------------------------------------- |
+| **Pi**       | `pi install npm:@hicaru/pi-rlm`     | `pi install npm:@hicaru/pi-rlm --force`     | `pi uninstall npm:@hicaru/pi-rlm`     |
+| **oh-my-pi** | `omp plugin install @hicaru/pi-rlm` | `omp plugin install @hicaru/pi-rlm --force` | `omp plugin uninstall @hicaru/pi-rlm` |
 
 <p align="center">
   <img src="https://github.com/openzebra/rlm.pi/blob/master/assets/hero.png?raw=true" width="100%" alt="rlm.pi — OOLONG benchmark results">
@@ -46,14 +46,17 @@ models, recursively. Same Pi session, same tools, same keys: `/rlm` and go. Read
 **OOLONG (oolong-synth)** — paper-tier long-context suite (the only suite); latest
 journal per model, cost per task from real `costUsd`:
 
-| Model | Score | Avg. cost/task |
-|-------|-------|----------------|
-| `zai/glm-4.7` | **83%** | $0.0000 * |
-| `qwen/qwen3.8-27b` | 49% | $0.1038 |
-| `inception/mercury-2.5` | 38% | $0.0052 |
+| Model                              | Score             | Avg. tokens/task | Avg. cost/task |
+| ---------------------------------- | ----------------- | ---------------- | -------------- |
+| `zai/glm-4.7`                      | **91.7%** (22/24) | ~36k             | $0.0000 *      |
+| `openrouter/qwen/qwen3.8-27b`      | 49%               | ~36k             | $0.1038        |
+| `openrouter/inception/mercury-2.5` | 38%               | ~36k             | $0.0052        |
 
 \* glm-4.7 runs on Z.ai's coding-plan endpoint — subscription billing, `costUsd` stays $0.
 
+In the [RLM paper](https://arxiv.org/abs/2512.24601), GPT-5-mini driven as an RLM outperforms
+GPT-o3 on OOLONG — recursion beats raw context, at a fraction of the price.
+
 Raw per-task rows (correct, recall, latency, tokens, cost) live in
 `bench/runs/*.jsonl` — one JSONL row per task, committed as history.
 
@@ -99,17 +102,17 @@ One suite (`oolong`). Regenerate the hero chart:
 
 Drop ANY of these into `add_context()` — they auto-convert to Markdown and land in `context`:
 
-| Category | Formats |
-|----------|---------|
-| **Word** | `.docx` |
-| **PDF** | `.pdf` |
-| **PowerPoint** | `.pptx` |
-| **Excel** | `.xlsx` |
-| **EPUB** | `.epub` |
-| **Rich Text** | `.rtf` |
-| **OpenDocument** | `.odt` |
-| **CSV / TSV** | `.csv` `.tsv` |
-| **HTML / XML** | `.html` `.htm` `.xml` `.rss` `.atom` |
+| Category              | Formats                                                                    |
+| --------------------- | -------------------------------------------------------------------------- |
+| **Word**              | `.docx`                                                                    |
+| **PDF**               | `.pdf`                                                                     |
+| **PowerPoint**        | `.pptx`                                                                    |
+| **Excel**             | `.xlsx`                                                                    |
+| **EPUB**              | `.epub`                                                                    |
+| **Rich Text**         | `.rtf`                                                                     |
+| **OpenDocument**      | `.odt`                                                                     |
+| **CSV / TSV**         | `.csv` `.tsv`                                                              |
+| **HTML / XML**        | `.html` `.htm` `.xml` `.rss` `.atom`                                       |
 | **+ Pandoc fallback** | `.doc` `.ppt` `.xls` `.pptm` `.xlsm` `.xlsb` `.ppsm` `.docm` `.odp` `.ods` |
 
 ```python
@@ -126,24 +129,33 @@ A **Recursive Language Model (RLM)** replaces `llm.completion(prompt)` with
 launch sub-LLM and sub-RLM calls as ordinary Python functions — decomposing,
 delegating, and synthesizing across a tree of models, not a single context window.
 
+Each step of a run is one validated state transition (paper §3.2, §5.7):
+
+```
+A_t = (P, Σ_t, O_t)          fixed prompt + execution state Σ_t + tool surface
+ΔΣ_t = μ(A_t)                the model emits a repl() patch, not prose
+V(ΔΣ_t, Σ_t)                 deterministic validator — no crash paths
+Σ_{t+1} = Σ_t ⊕ ΔΣ_t         deep merge, null = delete
+```
+
 ## Commands
 
-| Command | Shortcut | What it does |
-|---------|----------|--------------|
-| `/rlm` | `Ctrl+Shift+R` | Toggle RLM mode on/off |
-| `/rlm-stop` | | Abort current run |
-| `/rlm-config` | | Pick models, tune limits |
+| Command       | Shortcut       | What it does             |
+| ------------- | -------------- | ------------------------ |
+| `/rlm`        | `Ctrl+Shift+R` | Toggle RLM mode on/off   |
+| `/rlm-stop`   |                | Abort current run        |
+| `/rlm-config` |                | Pick models, tune limits |
 
 ## Settings (`/rlm-config`)
 
-| Setting | Default | Why you'd change it |
-|---------|---------|---------------------|
-| Smart model | Pi's active | Use your best model as orchestrator |
-| Worker model | cheapest available | Free/cheap model for leaf `llm_query` calls |
-| Max recursion depth | `4` | Deeper trees for harder problems |
-| Max iterations | `30` | Longer runs for complex tasks |
-| REPL timeout | `120`s | Bump for slow computations |
-| Max concurrent subs | `16` | More parallelism (costs RAM) |
+| Setting             | Default            | Why you'd change it                         |
+| ------------------- | ------------------ | ------------------------------------------- |
+| Smart model         | Pi's active        | Use your best model as orchestrator         |
+| Worker model        | cheapest available | Free/cheap model for leaf `llm_query` calls |
+| Max recursion depth | `4`                | Deeper trees for harder problems            |
+| Max iterations      | `30`               | Longer runs for complex tasks               |
+| REPL timeout        | `120`s             | Bump for slow computations                  |
+| Max concurrent subs | `16`               | More parallelism (costs RAM)                |
 
 ## Sampling & reproducibility
 
@@ -152,14 +164,14 @@ temperature 0 took OOLONG from 71% pooled / 40% flips to 91.7–100% all-stable
 total. Those knobs are first-class in `rlm.json` (`~/.pi/agent/rlm.json`) and on the
 `/rlm-config` panel:
 
-| Field | Where | Default | What it governs |
-|-------|-------|---------|-----------------|
-| `rootSampling.maxTokens` | rlm.json, panel | `16384` | Output cap per root-model turn (finalize included) |
-| `rootSampling.temperature` | rlm.json, panel | provider default | Root + finalize sampling temperature; `0` = deterministic |
-| `smartReasoning` | rlm.json, panel | none | Thinking effort for the root model |
-| `subSampling.maxTokens` | rlm.json, panel | `8192` | Output cap per leaf sub-call (`llm_query`, `llm_batch`, `map_files`) |
-| `subSampling.temperature` | rlm.json, panel | provider default | Leaf sampling temperature |
-| `enableVerificationNudge` | rlm.json | off | One coached redo when the root finalizes early with a bare number / short label |
+| Field                      | Where           | Default          | What it governs                                                                 |
+| -------------------------- | --------------- | ---------------- | ------------------------------------------------------------------------------- |
+| `rootSampling.maxTokens`   | rlm.json, panel | `16384`          | Output cap per root-model turn (finalize included)                              |
+| `rootSampling.temperature` | rlm.json, panel | provider default | Root + finalize sampling temperature; `0` = deterministic                       |
+| `smartReasoning`           | rlm.json, panel | none             | Thinking effort for the root model                                              |
+| `subSampling.maxTokens`    | rlm.json, panel | `8192`           | Output cap per leaf sub-call (`llm_query`, `llm_batch`, `map_files`)            |
+| `subSampling.temperature`  | rlm.json, panel | provider default | Leaf sampling temperature                                                       |
+| `enableVerificationNudge`  | rlm.json        | off              | One coached redo when the root finalizes early with a bare number / short label |
 
 **Reproducibility recipe (validated by r3):**
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hicaru/pi-rlm",
-	"version": "0.3.21",
+	"version": "0.3.22",
 	"author": "hicaru",
 	"repository": {
 		"type": "git",

package/src/ui/theme-adapter.ts

@@ -5,19 +5,87 @@
  * 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.
+ *
+ * Fork hosts (oh-my-pi) remap `@earendil-works/pi-tui` to their own bundled copy, whose
+ * `Markdown` requires a nested `symbols` record on the theme (`theme.symbols.table/hrChar/
+ * quoteBorder/colorSwatch`) in addition to the upstream render functions. Their `Theme.md`
+ * getter is NOT a MarkdownTheme — it is a flat symbol-string partial
+ * (`{ quoteBorder, hrChar, bullet, colorSwatch }`), so returning it raw amputates the render
+ * functions and the host crashes (`this.#r.heading is not a function`). Hence the merge
+ * below: base functions from the injected theme, function-valued host overrides on top,
+ * and the flat strings folded into a complete `symbols` record with safe defaults.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { MarkdownTheme } from "@earendil-works/pi-tui";
 
+/** The `symbols` record fork hosts read off a MarkdownTheme (upstream has no such key). */
+interface MarkdownThemeSymbols {
+  readonly colorSwatch: string;
+  readonly hrChar: string;
+  readonly quoteBorder: string;
+  readonly bullet?: string;
+  readonly table: Readonly<Record<string, string>>;
+}
+
+/** Safe defaults covering every symbol a fork's `Markdown` dereferences (omp: table/hrChar/quoteBorder/colorSwatch). */
+const FALLBACK_SYMBOLS: MarkdownThemeSymbols = Object.freeze({
+  colorSwatch: "●",
+  hrChar: "─",
+  quoteBorder: "▌",
+  table: Object.freeze({
+    horizontal: "─",
+    vertical: "│",
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    teeUp: "┴",
+    teeDown: "┬",
+    teeLeft: "├",
+    teeRight: "┤",
+    cross: "┼",
+  }),
+});
+
+type MarkdownThemeWithSymbols = MarkdownTheme & { symbols?: MarkdownThemeSymbols };
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null;
+const asNonEmptyString = (v: unknown): string | undefined =>
+  typeof v === "string" && v.length > 0 ? v : undefined;
+
+/**
+ * Fold the host's symbol surface into one complete `symbols` record. Forks expose the same
+ * chars in two shapes — nested (`theme.md.symbols.colorSwatch`) or flat
+ * (`theme.md.colorSwatch`) — and the host's values win over our safe defaults. `host.md`
+ * flat strings are also NOT spread over the base: `quoteBorder`/`hrChar` exist on the base
+ * as FUNCTIONS, so a naive spread would corrupt them.
+ */
+function hostSymbols(md: Record<string, unknown>): MarkdownThemeSymbols {
+  const nested = isRecord(md.symbols) ? md.symbols : {};
+  const fallback = FALLBACK_SYMBOLS as unknown as Record<string, unknown>;
+  const fallbackString = (k: string): string => (typeof fallback[k] === "string" ? fallback[k] : "");
+  const pick = (k: string): string => asNonEmptyString(nested[k]) ?? asNonEmptyString(md[k]) ?? fallbackString(k);
+  const hostTable = isRecord(nested.table) ? nested.table : {};
+  const table: Record<string, string> = { ...FALLBACK_SYMBOLS.table };
+  for (const k of Object.keys(table)) {
+    const v = asNonEmptyString(hostTable[k]);
+    if (v !== undefined) table[k] = v;
+  }
+  const bullet = asNonEmptyString(nested.bullet) ?? asNonEmptyString(md.bullet);
+  return Object.freeze({ colorSwatch: pick("colorSwatch"), hrChar: pick("hrChar"), quoteBorder: pick("quoteBorder"), bullet, table: Object.freeze(table) });
+}
+
 /**
  * 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.
+ * `highlightCode`/`resolveMermaidAscii` come through only if the host itself provides them
+ * as functions on `theme.md` — pi's own global-based implementation reads the broken
+ * module global and is deliberately never reconstructed here.
  */
 export function markdownTheme(theme: Theme): MarkdownTheme {
-  return {
+  const base: MarkdownTheme = {
     heading: (text) => theme.fg("mdHeading", text),
     link: (text) => theme.fg("mdLink", text),
     linkUrl: (text) => theme.fg("mdLinkUrl", text),
@@ -33,4 +101,18 @@ export function markdownTheme(theme: Theme): MarkdownTheme {
     underline: (text) => theme.underline(text),
     strikethrough: (text) => theme.strikethrough(text),
   };
+  const md: unknown = (theme as Theme & { md?: unknown }).md;
+  if (!isRecord(md)) {
+    const bare: MarkdownThemeWithSymbols = { ...base, symbols: hostSymbols({}) };
+    return bare;
+  }
+  // Function-valued host fields override the base (a real host MarkdownTheme wins);
+  // flat symbol strings stay out of the function surface and fold into `symbols`.
+  const hostFns: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(md)) {
+    if (typeof v === "function") hostFns[k] = v;
+  }
+  const merged = { ...base, ...hostFns } as MarkdownTheme & { symbols?: MarkdownThemeSymbols };
+  merged.symbols = hostSymbols(md);
+  return merged;
 }