@hicaru/pi-rlm 0.3.14 → 0.3.16

package/README.md

@@ -1,6 +1,6 @@
-<p align="center">
-  <img src="https://github.com/openzebra/rlm.pi/blob/master/assets/plugin-cover.png?raw=true" width="100%" alt="pi-rlm — Recursive Language Model plugin for Pi">
-</p>
+# rlm.pi PI plugin
+
+> pi-rlm — Large contexts on cheap models: Recursive Language Model (RLM) for Pi
 
 <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>
@@ -14,45 +14,78 @@
   <a href="https://www.npmjs.com/package/@hicaru/pi-rlm">📦 npm</a>
 </p>
 
----
+## Install
+
+```bash
+pi install npm:@hicaru/pi-rlm
+```
+
+Run `/reload` in Pi — `/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
+```
+
+<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">
+</p>
+
+## What is pi-rlm?
 
-**The ONLY Recursive Language Model plugin for Pi.** No new agent to learn, no
-separate CLI, no YAML workflows — just `/rlm` and your existing Pi session becomes a
-recursive orchestration engine — your best model orchestrates, cheap worker models
-do the reading.
+A Pi plugin that turns your session into a **Recursive Language Model (RLM)**: instead of
+stuffing a huge document into the prompt, the context lives in a Python REPL and your best
+model orchestrates it — searching, decomposing, and delegating leaf reads to cheap worker
+models, recursively. Same Pi session, same tools, same keys: `/rlm` and go. Reads
+`.pdf` `.docx` `.xlsx` `.epub` and more, works with any OpenRouter model, 100% local.
 
-> **One install. One toggle. Infinite context.**
+## Benchmarks
 
-## Why pi-rlm?
+<p align="center">
+  <img src="https://github.com/openzebra/rlm.pi/blob/master/assets/hero.png?raw=true" width="100%" alt="OOLONG benchmark — latest results">
+</p>
 
-| Advantage | What it means |
-|-----------|---------------|
-| 🔌 **Plugin, not a new agent** | Stays inside Pi. You keep your keybindings, your theme, your tools, your muscle memory. |
-| 📄 **Reads ANY document** | `.pdf` `.docx` `.pptx` `.xlsx` `.epub` `.rtf` `.odt` `.csv` `.html` `.xml` — drop them in, they become Markdown in `context`. |
-| 🪶 **Unix-style — tiny & composable** | Does ONE thing (RLM orchestration). Pair it with any other Pi plugin. No lock-in. |
-| 🧠 **Smartest model orchestrates, cheapest model researches** | Root uses your best model; workers auto-pick the cheapest. Recursive children inherit the full `context` for free. |
-| ⏳ **Long-running with goals** | Toggle `/rlm` on, set a goal, let it loop. Runs survive across chat turns — go make coffee. |
-| 🔒 **100% local, 100% private** | No servers. Your API keys never leave your machine. One `python3` subprocess — that's it. |
+**OOLONG (oolong-synth)** — paper-tier long-context suite; latest journal per model,
+cost per task from real `costUsd` (older journals estimated at OpenRouter list prices):
 
-## See it in action
+| Model | Score | Avg. cost/task |
+|-------|-------|----------------|
+| `qwen/qwen3.8-27b` | **100%** | $0.0127 |
+| `google/gemma-3-27b-it` | 83.3% | $0.0013 |
+| `qwen/qwen3-30b-a3b-instruct-2507` | 66.7% | $0.0009 |
+| `mistralai/mistral-small-3.2-24b-instruct` | 66.7% | $0.0025 |
 
-<div align="center">
+Lite suite — `needle` multi-needle recall, `codeqa` repo-QA, `coding` fix task
+(7 tasks × 2 passes per model, deterministic graders, no LLM-as-judge):
 
-<video src="https://github.com/openzebra/rlm.pi/raw/refs/heads/master/animation/rlm_pi_explainer.mp4" controls width="854" poster="https://raw.githubusercontent.com/openzebra/rlm.pi/master/assets/hero.png"></video>
+| Model | Score | Accuracy |
+|-------|-------|----------|
+| `qwen/qwen3-30b-a3b-instruct-2507` | **14/14** | **100%** |
+| `google/gemma-3-27b-it` | 12/14 | 86% |
+| `mistralai/mistral-small-3.2-24b-instruct` | 12/14 | 86% |
 
-</div>
+Raw per-task rows (correct, recall, latency, tokens, cost) live in
+`bench/runs/*.jsonl` — one JSONL row per task, committed as history.
 
-## Install (30 seconds)
+### Run the benchmarks
 
 ```bash
-pi install npm:@hicaru/pi-rlm
-```
+export OPENROUTER_API_KEY=sk-or-...        # required — env vars are the only key transport
 
-Run `/reload` in Pi. Done. `/rlm`, `/rlm-config`, `/rlm-stop` appear under **[Extensions]**.
+bun run bench                              # lite suite: needle + codeqa + coding
+bun run bench --suite needle --limit 1     # one suite, first task only
+bun run bench --model openrouter/qwen/qwen3-30b-a3b-instruct-2507
+bun run bench --list                       # print tasks, no engine / no key
+bun run bench --suite paper                # paper tier: s_niah, oolong, browsecomp, codeqa_lb (downloads datasets)
+```
 
-Toggle with `Ctrl+Shift+R` or `/rlm` — plain prompts now route through the RLM engine.
+Suites: `all` (lite, default) · `needle` · `codeqa` · `coding` · `paper` · `s_niah` ·
+`oolong` · `browsecomp` · `codeqa_lb`. Regenerate the hero chart:
+`python3 bench/hero.py` (needs `matplotlib`).
 
-## What you get
+## How it works
 
 ```
           ┌─────────────────────────┐
@@ -106,10 +139,6 @@ 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.
 
-**This is the only plugin that brings true RLM recursion to Pi.** Prime Agent and
-the reference Python library are separate agents you must switch to. pi-rlm lives
-inside Pi — same session, same tools, same everything.
-
 ## Commands
 
 | Command | Shortcut | What it does |
@@ -129,6 +158,45 @@ inside Pi — same session, same tools, same everything.
 | REPL timeout | `120`s | Bump for slow computations |
 | Max concurrent subs | `16` | More parallelism (costs RAM) |
 
+## Sampling & reproducibility
+
+The r3 bench showed the biggest capability lever is not the model — it is the sampling:
+temperature 0 took OOLONG from 71% pooled / 40% flips to 91.7–100% all-stable for $1.74
+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 |
+
+**Reproducibility recipe (validated by r3):**
+
+```json
+{
+  "config": {
+    "rootSampling": { "maxTokens": 8192, "temperature": 0, "reasoning": "high" }
+  }
+}
+```
+
+Reasoning tokens share the completion budget with the answer — with thinking on, keep
+`maxTokens` generous (the bench doubles it to 8192; the engine warns once on turn 0 when it
+is tight).
+
+**Scope boundary:** `rlm.json` sampling applies to RLM-mode runs, `rlm()` delegation, and
+child recursion at any depth (same engine function). The native Pi agent loop follows Pi's
+own session settings — rlm.json never touches it.
+
+**Model capability:** reasoning requires a model whose registry entry has `reasoning: true`.
+Anything else has the level dropped before it reaches the provider (pi-ai clamps unsupported
+levels to off); capability comes from the registry, so OpenRouter hybrids like
+`qwen/qwen3.8-27b` just work.
+
 ## Prompt Architecture
 
 The system prompt follows a **contract / routing / examples / rules** pattern
@@ -142,22 +210,6 @@ The system prompt follows a **contract / routing / examples / rules** pattern
 **Key insight:** children see `Recursion depth: N` and calibrate ambition —
 delegating only when their task genuinely decomposes further.
 
-## Benchmarks
-
-Tested against `rlm-lab` prompt bake-off and full dual-mode RLM runtime benchmarks
-on `poolside/laguna-xs-2.1:free` (a free ~32B model):
-
-| Benchmark | Mode | Result |
-|-----------|------|--------|
-| Main orchestrator (7 scenarios) | prompt bake-off | **0.958** mean score (v3 fewshot arm) |
-| RLM worker (4 scenarios) | prompt bake-off | **0.94** mean score (v2 contract arm) |
-| Needle-in-haystack (3 needles) | classic RLM | **recall 1.0** |
-| CodeQA timeout | classic RLM | **correct** (~3.7k tokens) |
-| Coding (retry fix) | orchestrator | **correct** (file edited) |
-| Live smoke needle | classic RLM | **hit** (~5k tokens) |
-
-> On a *free* model. Frontier models do even better.
-
 ## Security
 
 - **Key isolation** — provider keys live in TypeScript only; sandbox receives prompts, returns text.
@@ -166,12 +218,6 @@ on `poolside/laguna-xs-2.1:free` (a free ~32B model):
 - **Per-block timeout** — SIGALRM + parent watchdog (SIGKILL on hang).
 - **Trust** — project-local install requires Pi project trust.
 
-## Uninstall
-
-```bash
-pi uninstall npm:@hicaru/pi-rlm
-```
-
 ## License
 
 MIT — see [LICENSE](./LICENSE).

package/README.ru.md

@@ -132,9 +132,78 @@ rm -rf ~/.pi/agent/extensions/rlm
 
 > **Примечание по параллелизму:** каждый дочерний `rlm_query` запускает собственного worker `python3` (~50–150 мс «холодного старта»). В худшем случае количество параллельных интерпретаторов ≈ `maxConcurrentSubcalls`^(depth−1); при настройках по умолчанию (глубина 4, параллелизм 4) это 4³ = 64 в патологическом случае. Лимиты бюджета и ошибок (см. выше) ограничивают общие затраты независимо от степени разветвления.
 
+## Сэмплинг и воспроизводимость
+
+Бенчмарк r3 показал: самый большой рычаг качества — не модель, а сэмплинг. Temperature 0
+перевела OOLONG с 71% (pooled) / 40% (flips) на 91.7–100% all-stable за $1.74 суммарно.
+Эти ручки — полноправные поля `rlm.json` (`~/.pi/agent/rlm.json`) и панели `/rlm-config`:
+
+| Поле | Где | По умолчанию | За что отвечает |
+|---|---|---|---|
+| `rootSampling.maxTokens` | rlm.json, панель | `16384` | Лимит вывода на ход корневой модели (включая finalize) |
+| `rootSampling.temperature` | rlm.json, панель | провайдер | Температура корневых ходов и finalize; `0` = детерминированно |
+| `smartReasoning` | rlm.json, панель | нет | Усилие «размышления» корневой модели |
+| `subSampling.maxTokens` | rlm.json, панель | `8192` | Лимит вывода одного листового вызова (`llm_query`, `llm_batch`, `map_files`) |
+| `subSampling.temperature` | rlm.json, панель | провайдер | Температура листовых вызовов |
+| `enableVerificationNudge` | rlm.json | выкл | Один повтор с подсказкой, если корень рано финализирует «голым числом» |
+
+**Рецепт воспроизводимости (проверен r3):**
+
+```json
+{
+  "config": {
+    "rootSampling": { "maxTokens": 8192, "temperature": 0, "reasoning": "high" }
+  }
+}
+```
+
+Токены размышлений делят бюджет завершения с ответом — при включённом thinking держите
+`maxTokens` щедрым (бенчмарк удваивает его до 8192; движок один раз предупредит на ходе 0,
+если лимит тесный).
+
+**Граница действия:** сэмплинг из `rlm.json` управляет запусками RLM-режима, делегированием
+`rlm()` и рекурсией на любой глубине (тот же движок). Собственный цикл агента Pi следует
+настройкам сессии Pi — rlm.json его не касается.
+
+**Возможности модели:** reasoning требует модель с `reasoning: true` в записи реестра.
+Для остальных уровень отбрасывается до отправки провайдеру (pi-ai приводит его к off);
+возможность берётся из реестра, а не из конфига.
+
 ## Логи запусков
 
 
+## Бенчмарки
+
+E2E-прогоны реального движка против моделей OpenRouter — lite-сьют (`needle` поиск игл в
+куче, `codeqa` вопросы по коду, `coding` задача-фикс; 7 задач × 2 прохода на модель).
+Детерминированные грейдеры (recall / вхождение эталона / regex), без LLM-судьи.
+
+Актуальные результаты — маленькие модели (≤32B параметров, платный тариф):
+
+| Модель | Параметры | Счёт | Точность | Latency/задача |
+|--------|-----------|------|----------|----------------|
+| `qwen/qwen3-30b-a3b-instruct-2507` | MoE 30B / 3B активных | **14/14** | **100%** | ~15s |
+| `google/gemma-3-27b-it` | dense 27B | 12/14 | 86% | ~26s |
+| `mistralai/mistral-small-3.2-24b-instruct` | dense 24B | 12/14 | 86% | ~28s |
+
+Построчные результаты (correct, recall, latency, токены, цена) — в
+`bench/runs/bench-<ts>.jsonl`, одна JSONL-строка на задачу.
+
+### Как запустить
+
+```bash
+export OPENROUTER_API_KEY=sk-or-...        # обязателен — ключи ходят только через env
+
+bun run bench                              # lite-сьют: needle + codeqa + coding
+bun run bench --suite needle --limit 1     # один сьют, первая задача
+bun run bench --model openrouter/qwen/qwen3-30b-a3b-instruct-2507
+bun run bench --list                       # показать задачи, без движка и ключа
+bun run bench --suite paper                # paper-сьют: s_niah, oolong, browsecomp, codeqa_lb (скачивает датасеты)
+```
+
+Сьюты: `all` (lite, по умолчанию) · `needle` · `codeqa` · `coding` · `paper` · `s_niah` ·
+`oolong` · `browsecomp` · `codeqa_lb`.
+
 ## Безопасность
 
 - **Изоляция ключей**: ключи провайдеров хранятся только в TypeScript (`AuthStorage`); песочница получает промпты и возвращает текст, но никогда не получает ключи.

package/README.zh-CN.md

@@ -141,6 +141,40 @@ rm -rf ~/.pi/agent/extensions/rlm
 > 默认设置下 (深度 4, 并发 4)，极端情况下为 4³ = 64。预算和错误
 > 上限 (见上文) 无论扇出 (fan-out) 如何都会限制总支出。
 
+## 采样与可复现性
+
+r3 基准测试表明：最大的能力杠杆不是模型，而是采样。仅 temperature 0 就让 OOLONG 从
+71% (pooled) / 40% (flips) 提升到 91.7–100% all-stable，总计仅花费 $1.74。这些旋钮在
+`rlm.json` (`~/.pi/agent/rlm.json`) 和 `/rlm-config` 面板中都是一等公民：
+
+| 字段 | 位置 | 默认值 | 作用范围 |
+|---|---|---|---|
+| `rootSampling.maxTokens` | rlm.json, 面板 | `16384` | 根模型每轮的输出上限 (包括 finalize) |
+| `rootSampling.temperature` | rlm.json, 面板 | 提供商默认 | 根轮次与 finalize 的采样温度；`0` = 确定性 |
+| `smartReasoning` | rlm.json, 面板 | 无 | 根模型的思考强度 |
+| `subSampling.maxTokens` | rlm.json, 面板 | `8192` | 每个叶子子调用 (`llm_query`, `llm_batch`, `map_files`) 的输出上限 |
+| `subSampling.temperature` | rlm.json, 面板 | 提供商默认 | 叶子调用的采样温度 |
+| `enableVerificationNudge` | rlm.json | 关 | 当根节点过早以“裸数字”定稿时，给予一次带提示的重做 |
+
+**可复现性配方 (经 r3 验证)：**
+
+```json
+{
+  "config": {
+    "rootSampling": { "maxTokens": 8192, "temperature": 0, "reasoning": "high" }
+  }
+}
+```
+
+思考 token 与答案共享补全预算——开启 thinking 时请保持充裕的 `maxTokens`
+(基准测试将其翻倍至 8192；若过紧，引擎会在第 0 轮警告一次)。
+
+**作用边界：** `rlm.json` 的采样适用于 RLM 模式运行、`rlm()` 委托以及任意深度的子递归
+(同一个引擎函数)。Pi 原生代理循环遵循 Pi 自身的会话设置——rlm.json 不会触及它。
+
+**模型能力：** reasoning 要求模型的注册表条目为 `reasoning: true`。其他情况会在发送给
+提供商之前丢弃该级别 (pi-ai 会将不支持的级别钳制为 off)；能力来自注册表，而非配置。
+
 ## 运行日志
 
 - **密钥隔离**：供应商密钥仅存在于 TypeScript (`AuthStorage`) 中；沙箱
@@ -157,6 +191,38 @@ rm -rf ~/.pi/agent/extensions/rlm
   连续错误上限。
 - **信任**：本地安装需要 Pi 项目信任。
 
+## 基准测试
+
+针对 OpenRouter 聊天模型对真实引擎进行端到端测试 —— 精简套件（`needle` 多针召回、
+`codeqa` 代码库问答、`coding` 修复任务；每个模型 7 个任务 × 2 轮）。确定性评分
+（召回率 / 标准答案包含 / 正则），无 LLM 评审。
+
+最新结果 —— 小型模型（≤32B 参数，付费额度）：
+
+| 模型 | 参数 | 得分 | 准确率 | 每任务延迟 |
+|------|------|------|--------|------------|
+| `qwen/qwen3-30b-a3b-instruct-2507` | MoE 30B / 3B 激活 | **14/14** | **100%** | ~15s |
+| `google/gemma-3-27b-it` | dense 27B | 12/14 | 86% | ~26s |
+| `mistralai/mistral-small-3.2-24b-instruct` | dense 24B | 12/14 | 86% | ~28s |
+
+逐任务原始数据（正确性、召回率、延迟、token、成本）位于 `bench/runs/bench-<ts>.jsonl`
+—— 每个任务一行 JSONL，作为历史记录提交。
+
+### 运行基准测试
+
+```bash
+export OPENROUTER_API_KEY=sk-or-...        # 必需 —— 密钥仅通过环境变量传递
+
+bun run bench                              # 精简套件：needle + codeqa + coding
+bun run bench --suite needle --limit 1     # 单个套件，仅第一个任务
+bun run bench --model openrouter/qwen/qwen3-30b-a3b-instruct-2507
+bun run bench --list                       # 仅列出任务，无需引擎和密钥
+bun run bench --suite paper                # paper 套件：s_niah, oolong, browsecomp, codeqa_lb（需下载数据集）
+```
+
+套件：`all`（精简版，默认） · `needle` · `codeqa` · `coding` · `paper` · `s_niah` ·
+`oolong` · `browsecomp` · `codeqa_lb`。
+
 ## 项目布局
 
 ```

package/package.json

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

package/src/bridge/handlers/emitting.ts

@@ -56,9 +56,13 @@ export async function emitting<T>(
 
   let costUsd = 0;
   let tokens = 0;
+  let tokensIn = 0;
+  let tokensOut = 0;
   const track = (u: Usage): void => {
     costUsd += u.cost.total;
     tokens += u.totalTokens;
+    tokensIn += u.input;
+    tokensOut += u.output;
   };
 
   try {
@@ -70,6 +74,8 @@ export async function emitting<T>(
       resultPreview: summary.preview,
       costUsd,
       tokens,
+      tokensIn,
+      tokensOut,
       detail: summary.error,
       failedCount: summary.failed,
       totalCount: summary.total,
@@ -83,6 +89,8 @@ export async function emitting<T>(
       resultPreview: msg,
       costUsd,
       tokens,
+      tokensIn,
+      tokensOut,
       detail: msg,
     });
     throw err;

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

@@ -206,6 +206,8 @@ async function childRun(
       id: subId,
       status: "done",
       resultPreview: res.answer.slice(0, 200),
+      tokensIn: res.inputTokens,
+      tokensOut: res.outputTokens,
     });
     return res;
   } catch (err: unknown) {

package/src/bridge/model.ts

@@ -9,6 +9,7 @@
  * RLM root (full history).
  */
 
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
 import { type Api, completeSimple, type Message, type Model, type ThinkingLevel, type Usage } from "@earendil-works/pi-ai/compat";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { completeWithRetry, DEFAULT_RETRY_POLICY, type RetryPolicy } from "../util/retry.ts";
@@ -68,6 +69,19 @@ function toPiMessages(messages: readonly ChatMsg[], model: Model<Api>): { readon
   return { systemPrompt, messages: out };
 }
 
+/**
+ * Explicit reasoning gate. pi-ai clamps unsupported levels too (a model with `reasoning:
+ * false` supports only "off", so any requested level clamps to it and nothing goes out on
+ * the wire) — owning the gate here makes the behavior engine policy, testable without a
+ * provider, and drops the option outright instead of forwarding a level the model cannot
+ * honor. Capability comes from the registry entry, never from config.
+ */
+export function effectiveReasoning(model: Model<Api>, level: ThinkingLevel | undefined): ThinkingLevel | undefined {
+  if (level === undefined) return undefined;
+  const clamped = clampThinkingLevel(model, level);
+  return clamped === "off" ? undefined : clamped;
+}
+
 /** Extract the assistant's plain text from a completion. */
 function extractText(content: readonly { readonly type: string; readonly text?: string }[]): string {
   return content
@@ -97,7 +111,7 @@ export async function modelComplete(messages: readonly ChatMsg[], opts: Complete
           headers: auth.headers,
           maxTokens: opts.maxTokens,
           temperature: opts.temperature,
-          reasoning: opts.reasoning,
+          reasoning: effectiveReasoning(opts.model, opts.reasoning),
           signal: opts.signal,
           onResponse: (res) => { note(res.status, res.headers); },
         },

package/src/config/defaults.ts

@@ -58,4 +58,7 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   memoryDir: null,
   // v5 role separation: children delegate (llm + memory/ledger); "legacy" = full child surface.
   childSurface: "delegation",
+  // Verification-discipline nudge — deliberately OFF (plan guardrail): when on, an early
+  // bare-number finalize gets one coached redo instead of being accepted. Opt-in via rlm.json.
+  enableVerificationNudge: false,
 });

package/src/config/settings.ts

@@ -38,9 +38,10 @@ function validateString(v: unknown): string | undefined {
 /**
  * Every value pi-ai accepts for `reasoning`. Keyed by the union so a new level added upstream
  * is a compile error here rather than a silently-rejected setting. Note `off` is NOT a
- * ThinkingLevel — a hand-edited rlm.json carrying one is dropped, not forwarded.
+ * ThinkingLevel — a hand-edited rlm.json carrying one is dropped, not forwarded. Exported so
+ * the config panel derives its choices from the same source of truth.
  */
-const THINKING_LEVELS: Readonly<Record<ThinkingLevel, true>> = Object.freeze({
+export const THINKING_LEVELS: Readonly<Record<ThinkingLevel, true>> = Object.freeze({
   minimal: true, low: true, medium: true, high: true, xhigh: true, max: true,
 });
 
@@ -149,6 +150,9 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   }
   // v5 child surface doctrine
   if (r.childSurface === "delegation" || r.childSurface === "legacy") out.childSurface = r.childSurface;
+  // Verification-discipline nudge (default OFF).
+  const enableVerificationNudge = validateBoolean(r.enableVerificationNudge);
+  if (enableVerificationNudge !== undefined) out.enableVerificationNudge = enableVerificationNudge;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
     const ss = r.subSampling as Record<string, unknown>;
     const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};

package/src/core/answer.ts

@@ -3,9 +3,12 @@
 import type { ReplResult } from "../sandbox/protocol.ts";
 import { formatReplStderr } from "../text/repl-output.ts";
 
-/** First non-null final answer across a turn's executed blocks, or null. */
+/** First non-blank final answer across a turn's executed blocks, or null. A blank capture counts
+ *  as absent (H2): an empty `answer.ready` flip must never terminate a run with "". */
 export function finalAnswerOf(results: readonly ReplResult[]): string | null {
-  for (const r of results) if (r.finalAnswer != null) return r.finalAnswer;
+  for (const r of results) {
+    if (r.finalAnswer != null && r.finalAnswer.trim() !== "") return r.finalAnswer;
+  }
   return null;
 }
 

package/src/core/budget.ts

@@ -107,8 +107,30 @@ export class TokenBudget {
 }
 
 /** Cap derivation (v5 `resolve_budget`): share × context window, clamped by the task cap. */
+/**
+ * Minimum context window (tokens) for the token-budget cascade to engage at all.
+ *
+ * The formula (window × budgetShare) assumes the window is large enough that a fraction of it
+ * is a meaningful working budget. Below this floor the derived cap shrinks below a task's FIXED
+ * overhead (system prompt + per-turn history re-send + sub-LLM calls) and strangles the run —
+ * a 32k window would cap a task at 8k tokens, less than the protocol scaffolding alone.
+ * So for smaller windows the rule does not apply: the budget is effectively unbounded and runs
+ * stay bounded by maxIterations / maxErrors / wall-clock instead.
+ */
+export const BUDGET_WINDOW_FLOOR = 250_000;
+
+/** An effective budget that can never trigger — the cascade "switched off" without changing
+ *  any call-site types (budget: TokenBudget | undefined). */
+function unboundedBudget(config: RlmConfig): TokenBudget {
+  return new TokenBudget(Number.MAX_SAFE_INTEGER, {
+    softFrac: config.budgetSoftFrac,
+    maxContinuations: config.budgetMaxContinuations,
+  });
+}
+
 export function resolveBudget(contextWindow: number | undefined, config: RlmConfig): TokenBudget {
   const ctx = contextWindow !== undefined && contextWindow > 0 ? contextWindow : 32_000;
+  if (ctx < BUDGET_WINDOW_FLOOR) return unboundedBudget(config);
   const shareCap = Math.floor(ctx * config.budgetShare);
   const cap = config.budgetTaskCap > 0 ? Math.min(shareCap, config.budgetTaskCap) : shareCap;
   return new TokenBudget(Math.max(cap, 1), {