@hicaru/pi-rlm 0.3.15 → 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,38 +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
-
-E2E runs of the real engine against OpenRouter chat models — the lite suite
-(`needle` multi-needle recall, `codeqa` repo-QA, `coding` fix task; 7 tasks × 2 passes
-per model). Deterministic graders (recall / gold containment / regex), no LLM-as-judge.
-
-Latest results — small models (≤32B parameters, paid tier):
-
-| Model | Params | Score | Accuracy | Latency/task |
-|-------|--------|-------|----------|--------------|
-| `qwen/qwen3-30b-a3b-instruct-2507` | MoE 30B / 3B active | **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 |
-
-Raw per-task rows (correct, recall, latency, tokens, cost) live in
-`bench/runs/bench-<ts>.jsonl` — one JSONL row per task, committed as history.
-
-### Run the benchmarks
-
-```bash
-export OPENROUTER_API_KEY=sk-or-...        # required — env vars are the only key transport
-
-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)
-```
-
-Suites: `all` (lite, default) · `needle` · `codeqa` · `coding` · `paper` · `s_niah` ·
-`oolong` · `browsecomp` · `codeqa_lb`.
-
 ## Security
 
 - **Key isolation** — provider keys live in TypeScript only; sandbox receives prompts, returns text.
@@ -182,12 +218,6 @@ Suites: `all` (lite, default) · `needle` · `codeqa` · `coding` · `paper` ·
 - **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,6 +132,43 @@ 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);
+возможность берётся из реестра, а не из конфига.
+
 ## Логи запусков
 
 

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`) 中；沙箱

package/package.json

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

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/engine.ts

@@ -20,7 +20,7 @@ import { TaskLedger, contextSig, taskKey } from "./ledger.ts";
 import { type MemoryStore, rootContextPaths } from "./memory.ts";
 import { type ChatMsg, modelComplete } from "../bridge/model.ts";
 import { buildRlmSystemPrompt } from "../prompts/system.ts";
-import { buildTurnPrompt, FINALIZE_PROMPT, RETRIEVAL_NUDGE } from "../prompts/user.ts";
+import { buildTurnPrompt, FINALIZE_PROMPT, RETRIEVAL_NUDGE, REASONING_BUDGET_HINT, VERIFICATION_NUDGE } from "../prompts/user.ts";
 import type { RlmEmitter } from "../tool/rlm-events.ts";
 import type { SubcallPhase } from "../tool/rlm-details.ts";
 import { PythonSandbox, SANDBOX_WATCHDOG_HEARTBEAT_MS } from "../sandbox/sandbox.ts";
@@ -46,6 +46,9 @@ import { createSubcallGates, type SubcallGates } from "../util/concurrency.ts";
  * hold a finished run open on work whose result nobody can receive.
  */
 const DETACHED_SETTLE_MS = 5_000;
+/** Verification nudge (enableVerificationNudge): only an EARLY finalize is suspicious — from
+ *  turn 4 on, a bare answer is just... an answer. "Before iteration ~4", per the bench data. */
+const VERIFICATION_NUDGE_TURN_CAP = 4;
 /** H6 (audit): root episodes snapshot at most this many real files — replay invalidation for
  *  the disk-backed slice of the context without hashing an unbounded repository. */
 const ROOT_HASH_MAX = 64;
@@ -253,6 +256,10 @@ export function createEngine(deps: EngineDeps): RunRlm {
     // H3: retrieval-discipline coach — one-shot per run; children inherit it via the same loop.
     let sawRetrieval = false;
     let retrievalNudged = false;
+    // Verification-discipline coach (enableVerificationNudge, default OFF): one coached redo
+    // when an early finalize looks like the confident-wrong bench shape.
+    let verificationNudged = false;
+    let verificationNudgePending = false;
 
     try {
       const meta = {
@@ -320,6 +327,13 @@ export function createEngine(deps: EngineDeps): RunRlm {
       liveContext = input.context ?? [];
       contextPin = await pinContext(liveContext);
       await sandbox.loadContextPinned(contextPin);
+
+      // rootSampling fields win; smartReasoning is the default reasoning when not overridden.
+      // Loop-invariant — built once here; finalize() applies the same merge to its own turn.
+      const rootSampling: Sampling = {
+        reasoning: deps.config.smartReasoning,
+        ...deps.config.rootSampling,
+      };
       for (let i = 0; i < deps.config.maxIterations; i++) {
         limits.checkTimeout();
         if (selfReportId) emitter.emitSubcallUpdated({ id: selfReportId, detail: `turn ${i + 1}/${deps.config.maxIterations}` });
@@ -369,16 +383,18 @@ export function createEngine(deps: EngineDeps): RunRlm {
             ledgerBlock === "" ? undefined : ledgerBlock,
             memoryBlock === "" ? undefined : memoryBlock,
             nudgeNow ? RETRIEVAL_NUDGE : undefined,
+            verificationNudgePending ? VERIFICATION_NUDGE : undefined,
+            // One-shot (turn 0 only): thinking tokens share the completion budget — mirror of
+            // the bench's doubling rule. Advisory; never fatal, never repeated.
+            i === 0 && rootSampling.reasoning !== undefined && (rootSampling.maxTokens ?? 16_384) < 8_192
+              ? REASONING_BUDGET_HINT
+              : undefined,
           ]
             .filter((s): s is string => s !== undefined)
             .join("\n\n") || undefined;
+        verificationNudgePending = false;
         appendUserMessage(history, buildTurnPrompt(i, deps.config.maxIterations, notes));
 
-        // rootSampling fields win; smartReasoning is the default reasoning when not overridden.
-        const rootSampling: Sampling = {
-          reasoning: deps.config.smartReasoning,
-          ...deps.config.rootSampling,
-        };
         const turn = await runTurn(history, sandbox, {
           model: model,
           registry: deps.registry,
@@ -414,10 +430,19 @@ export function createEngine(deps: EngineDeps): RunRlm {
         completedTurns = i + 1;
         const final = finalAnswerOf(turn.results);
         if (final != null) {
-          const done = result(final, i + 1, limits);
-          persistRoot(done.answer);
-          lastAnswer = done.answer;
-          return done;
+          // Verification-discipline nudge (enableVerificationNudge, default OFF): an early
+          // finalize whose answer is a bare number / short label is the confident-wrong shape
+          // that dominated bench failures. ONE coached redo, then the answer is accepted.
+          if (deps.config.enableVerificationNudge === true && !verificationNudged
+            && completedTurns < VERIFICATION_NUDGE_TURN_CAP && isBareAnswer(final)) {
+            verificationNudged = true;
+            verificationNudgePending = true;
+          } else {
+            const done = result(final, i + 1, limits);
+            persistRoot(done.answer);
+            lastAnswer = done.answer;
+            return done;
+          }
         }
 
         limits.observe(turnHadError(turn.results));
@@ -535,6 +560,13 @@ function contextWindowOrFallback(model: Model<Api>, registry: ModelContextRegist
   return registry.limitFor(`${model.provider}/${model.id}`);
 }
 
+/** Bare number / short label — the early-confident answer shape the verification nudge
+ *  targets (28/33 bench failures were early confident wrong answers). */
+function isBareAnswer(answer: string): boolean {
+  const t = answer.trim();
+  return t.length <= 12 || /^[-+$(€£¥]?\d+(?:[.,]\d+)*\s*%?$/.test(t);
+}
+
 /** Out of turns: ask the model for its best final answer. FINALIZE_PROMPT asks for a fenced
  *  ```repl``` block, so execute it like any turn and prefer the captured answer (H2) — a raw
  *  fence echoed verbatim must never become the run answer. Plain text stays the fallback. */
@@ -548,10 +580,19 @@ async function finalize(
   const finalHistory = [...history];
   appendUserMessage(finalHistory, FINALIZE_PROMPT);
   const complete = deps.complete ?? modelComplete;
+  // Same merge rule as the main loop (the `rootSampling` construction in run()): rootSampling
+  // wins, smartReasoning is the reasoning default. Finalize is a root turn — it must obey the
+  // user's sampling too, or the last turn of every run silently reverts to provider defaults.
+  const rootSampling: Sampling = {
+    reasoning: deps.config.smartReasoning,
+    ...deps.config.rootSampling,
+  };
   const { text, usage } = await complete(finalHistory, {
     model,
     registry: deps.registry,
-    reasoning: deps.config.smartReasoning,
+    maxTokens: rootSampling.maxTokens,
+    temperature: rootSampling.temperature,
+    reasoning: rootSampling.reasoning,
     signal: deps.signal,
   });
   limits.addUsage(usage);

package/src/core/types.ts

@@ -110,6 +110,11 @@ export interface RlmConfig {
   /** v5 doctrine: "delegation" = child engines get llm/memory/ledger only (no repo retrieval);
    *  "legacy" keeps today's full child surface as a one-flip rollback. */
   readonly childSurface: "delegation" | "legacy";
+  /** Verification-discipline nudge (default OFF — it changes interactive behavior): when the
+   *  root finalizes before turn 4 with a bare number / short label, it gets ONE coached redo
+   *  ("recompute and sanity-check in Python") instead of accepting the answer. Opt-in via
+   *  rlm.json; evidence: 28/33 bench failures were early confident wrong answers. */
+  readonly enableVerificationNudge?: boolean;
 }
 
 /** Input to a (headless) RLM run. */

package/src/prompts/user.ts

@@ -34,3 +34,20 @@ export const RETRIEVAL_NUDGE =
   "[coach] You have not inspected the external context yet — it is NOT included in this " +
   "chat, and guessing is useless: the text is padding. On THIS turn, call search(\"...\") " +
   "or grep_context(\"...\") inside a ```repl block before answering.";
+
+/** One-shot budget hint (engine-owned, turn 0 only): reasoning tokens share the completion
+ *  budget with the answer, mirroring the bench's doubling rule — a reasoning root with a
+ *  small output cap risks truncated thought. Advisory only; never fatal. */
+export const REASONING_BUDGET_HINT =
+  "[budget] Reasoning is on while the root output cap is below 8192 tokens: thinking shares " +
+  "the completion budget with the answer, so long thought may be cut off mid-reasoning. " +
+  "Keep thought concise, or raise rootSampling.maxTokens.";
+
+/** One-shot verification-discipline nudge (default OFF — enableVerificationNudge): fired when
+ *  the root finalizes suspiciously early with a bare number / short label. The model gets ONE
+ *  coached redo instead of having the answer accepted. */
+export const VERIFICATION_NUDGE =
+  "[coach] That answer was submitted suspiciously early and looks under-verified. Before " +
+  "finalizing: recompute the key quantity inside a ```repl block (show the actual computation, " +
+  "not a restatement), sanity-check it against the source material, and only then set " +
+  "answer[\"content\"] again.";

package/src/sandbox/py/retrieval.py

@@ -235,7 +235,10 @@ def grep_context(
     `counts` is complete even when `hits` is capped.
     """
     try:
-        rx = re.compile(pattern)
+        # MULTILINE: the doc-level gate below must not veto line-anchored patterns (^/$) —
+        # without it, `^foo` on a multi-line doc never matches outside position 0 and every
+        # line hit is silently filtered out (grep is line-oriented; match that).
+        rx = re.compile(pattern, re.MULTILINE)
     except re.error as e:
         return {"hits": [], "counts": {}, "total": 0, "truncated": False, "error": f"bad regex: {e}"}
     try:

package/src/sandbox/sandbox.ts

@@ -344,6 +344,8 @@ export class PythonSandbox {
         frame: msg.type,
         id: "id" in msg ? msg.id : undefined,
         rid: "rid" in msg ? msg.rid : undefined,
+        // Post-mortem needs the payload, not just the shape (mirrors repl-tool's 400-char cap).
+        ...(msg.type === "exec" ? { chars: msg.code.length, code: msg.code.slice(0, 400) } : {}),
       });
     }
     // Never write to a corpse. The write would fail asynchronously and, historically, take the
@@ -423,7 +425,18 @@ export class PythonSandbox {
           prompts: "prompts" in msg ? msg.prompts?.length : 1,
         });
       } else {
-        trace("frame.in", { frame: "response", id: msg.id, ok: msg.ok });
+        trace("frame.in", {
+          frame: "response",
+          id: msg.id,
+          ok: msg.ok,
+          ...(msg.ok
+            ? {
+                stdout: msg.stdout?.slice(0, 300),
+                finalAnswer: msg.final_answer ?? undefined,
+                vars: msg.var_names?.length,
+              }
+            : { error: msg.error?.slice(0, 200) }),
+        });
       }
     }
     if (isInterrupt(msg)) {

package/src/ui/config-panel.ts

@@ -1,9 +1,11 @@
 /** Config panel TUI — toggle RLM run parameters with descriptions. */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
 import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 import { Container, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
 import type { RlmConfig } from "../core/types.ts";
+import { THINKING_LEVELS } from "../config/settings.ts";
 
 const CHOICES = Object.freeze({
   maxDepth: Object.freeze(["1", "2", "3", "4"]),
@@ -18,6 +20,10 @@ const CHOICES = Object.freeze({
   compaction: Object.freeze(["on", "off"]),
   compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
+  rootSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
+  smartReasoning: Object.freeze(["default", ...Object.keys(THINKING_LEVELS)]),
+  subSamplingMaxTokens: Object.freeze(["1024", "2048", "4096", "8192"]),
+  subSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
   requestTimeoutMs: Object.freeze(["2", "5", "10", "15", "20"]),
   contextLoader: Object.freeze(["on", "off"]),
@@ -48,6 +54,14 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     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("rootSamplingTemperature", "Root sampling temperature", config.rootSampling?.temperature === undefined ? "default" : String(config.rootSampling?.temperature), CHOICES.rootSamplingTemperature,
+      "Sampling temperature for RLM root turns, finalize included — 0 = deterministic (the r3 reproducibility setting); 'default' = provider default. Applies to RLM-mode runs, rlm() delegation and child recursion; the native Pi agent loop follows Pi's own session settings."),
+    item("smartReasoning", "Root reasoning effort", config.smartReasoning ?? "default", CHOICES.smartReasoning,
+      "Thinking effort for the root model ('default' = none). Only models whose registry entry supports reasoning will think; others silently run without it. Reasoning tokens share the output cap — raise the root output cap when thinking is on."),
+    item("subSamplingMaxTokens", "Worker output cap (tok)", String(config.subSampling?.maxTokens ?? 8192), CHOICES.subSamplingMaxTokens,
+      "Max output tokens per leaf sub-call (llm_query / llm_batch / map_files)."),
+    item("subSamplingTemperature", "Worker sampling temperature", config.subSampling?.temperature === undefined ? "default" : String(config.subSampling?.temperature), CHOICES.subSamplingTemperature,
+      "Sampling temperature for leaf sub-calls; 'default' = provider default. Deterministic extraction (temp 0) is what made the r3 bench stable."),
     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("contextLoader", "Context loader", config.contextLoader ? "on" : "off", CHOICES.contextLoader,
@@ -89,6 +103,13 @@ function optionalNumber(value: string, scale = 1): number | undefined {
   return value === "none" ? undefined : Number(value) * scale;
 }
 
+/** Optional temperature: the literal "default" clears it (provider default); else [0, 2]. */
+function optionalTemperature(value: string): number | undefined {
+  if (value === "default") return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 && n <= 2 ? n : undefined;
+}
+
 /** 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) {
@@ -105,6 +126,24 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
     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 "rootSamplingTemperature": {
+      const t = optionalTemperature(value);
+      // Reject invalid values (NaN / out of range) — keep the current setting.
+      if (t === undefined && value !== "default") return config;
+      return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, temperature: t }) });
+    }
+    case "smartReasoning":
+      if (value === "default") return Object.freeze({ ...config, smartReasoning: undefined });
+      return Object.hasOwn(THINKING_LEVELS, value)
+        ? Object.freeze({ ...config, smartReasoning: value as ThinkingLevel })
+        : config;
+    case "subSamplingMaxTokens":
+      return Object.freeze({ ...config, subSampling: Object.freeze({ ...config.subSampling, maxTokens: Number(value) }) });
+    case "subSamplingTemperature": {
+      const st = optionalTemperature(value);
+      if (st === undefined && value !== "default") return config;
+      return Object.freeze({ ...config, subSampling: Object.freeze({ ...config.subSampling, temperature: st }) });
+    }
     case "sandboxInitTimeoutMs": return Object.freeze({ ...config, sandboxInitTimeoutMs: Number(value) });
     case "requestTimeoutMs": return Object.freeze({ ...config, requestTimeoutMs: Number(value) * 60_000 });
     case "contextLoader": return Object.freeze({ ...config, contextLoader: value === "on" });