@hicaru/pi-rlm 0.3.19 → 0.3.20

package/README.md

@@ -48,9 +48,11 @@ journal per model, cost per task from real `costUsd`:
 
 | Model | Score | Avg. cost/task |
 |-------|-------|----------------|
-| `qwen/qwen3.8-27b` | **87.5%** | $0.0460 |
-| `google/gemma-3-27b-it` | 50.0% | $0.0011 |
-| `inception/mercury-2.5` | — | — |
+| `zai/glm-4.7` | **83%** | $0.0000 * |
+| `qwen/qwen3.8-27b` | 49% | $0.1038 |
+| `inception/mercury-2.5` | 38% | $0.0052 |
+
+\* glm-4.7 runs on Z.ai's coding-plan endpoint — subscription billing, `costUsd` stays $0.
 
 Raw per-task rows (correct, recall, latency, tokens, cost) live in
 `bench/runs/*.jsonl` — one JSONL row per task, committed as history.
@@ -58,10 +60,11 @@ Raw per-task rows (correct, recall, latency, tokens, cost) live in
 ### Run the benchmarks
 
 ```bash
-export OPENROUTER_API_KEY=sk-or-...        # required — env vars are the only key transport
+export OPENROUTER_API_KEY=sk-or-...        # required for openrouter/* models
+export ZAI_API_KEY=...                     # required for zai/* models (coding endpoint)
 
 bun run bench                              # oolong suite, default model (qwen3.8-27b)
-bun run bench --model openrouter/google/gemma-3-27b-it
+bun run bench --model zai/glm-4.7
 bun run bench --model openrouter/inception/mercury-2.5
 bun run bench --list                       # print tasks, no engine / no key
 ```

package/package.json

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

package/src/bridge/handlers/completion.ts

@@ -83,6 +83,9 @@ export async function complete1(
         onThrottlePark: hooks?.onThrottlePark,
         onThrottleRelease: hooks?.onThrottleRelease,
         signal: deps.signal,
+        // Long-context providers (zai bigmodel TTFB ~1 min per 10k ctx chars) need the
+        // per-request wall cap raised from the pi-ai default.
+        timeoutMs: config.requestTimeoutMs,
       }),
     );
     inv.limits.addUsage(res.usage);

package/src/bridge/handlers/emitting.ts

@@ -54,12 +54,10 @@ export async function emitting<T>(
     inv.emitter.emitSubcallUpdated({ id, ...u });
   };
 
-  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;
@@ -72,7 +70,6 @@ export async function emitting<T>(
       id,
       status: summary.error !== undefined ? "error" : "done",
       resultPreview: summary.preview,
-      costUsd,
       tokens,
       tokensIn,
       tokensOut,
@@ -87,7 +84,6 @@ export async function emitting<T>(
       id,
       status: "error",
       resultPreview: msg,
-      costUsd,
       tokens,
       tokensIn,
       tokensOut,

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

@@ -24,10 +24,10 @@ function emptyResult(answer: string): RlmResult {
   return {
     answer,
     iterations: 0,
-    costUsd: 0,
     inputTokens: 0,
     outputTokens: 0,
     durationMs: 0,
+    lastStdout: "",
   };
 }
 
@@ -149,8 +149,8 @@ async function childRun(
 
   try {
     const res = await deps.gates.rlm.at(childDepth).run(() => run(input, inv));
-    inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
-    deps.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
+    inv.limits.addRaw(res.inputTokens, res.outputTokens);
+    deps.onChildUsage?.(res.inputTokens, res.outputTokens);
     if (ledger !== undefined && claimKey !== undefined) ledger.finish(claimKey, res.answer);
     inv.emitter.emitSubcallUpdated({
       id: subId,

package/src/bridge/handlers/task-registry.ts

@@ -54,17 +54,19 @@ interface Waiter {
   timer?: ReturnType<typeof setTimeout>;
 }
 
-function notify(waiters: Map<string, Waiter>, taskId: string, entry: TaskEntry): void {
-  const w = waiters.get(taskId);
-  if (w === undefined) return;
-  if (w.timer !== undefined) clearTimeout(w.timer);
-  w.resolve(entry);
+function notify(waiters: Map<string, Waiter[]>, taskId: string, entry: TaskEntry): void {
+  const list = waiters.get(taskId);
+  if (list === undefined) return;
   waiters.delete(taskId);
+  for (const w of list) {
+    if (w.timer !== undefined) clearTimeout(w.timer);
+    w.resolve(entry);
+  }
 }
 
 export function createTaskRegistry(): TaskRegistry {
   const tasks = new Map<string, TaskEntry>();
-  const waiters = new Map<string, Waiter>();
+  const waiters = new Map<string, Waiter[]>();
   let counter = 0;
 
   const spawnDeps: SpawnDeps = {
@@ -92,7 +94,9 @@ export function createTaskRegistry(): TaskRegistry {
     },
     resolve(taskId, result) {
       const entry = tasks.get(taskId);
-      if (entry === undefined) return;
+      // Settle-once: a late resolve after a timeout/reject must not flip status or
+      // double-notify; the entry is terminal the moment it leaves "pending".
+      if (entry === undefined || entry.status !== "pending") return;
       entry.status = "done";
       if (typeof result === "string") {
         entry.result = result;
@@ -103,14 +107,17 @@ export function createTaskRegistry(): TaskRegistry {
     },
     reject(taskId, error) {
       const entry = tasks.get(taskId);
-      if (entry === undefined) return;
+      // Settle-once (mirror of resolve): reject after resolve/timeout is a no-op.
+      if (entry === undefined || entry.status !== "pending") return;
       entry.status = "error";
       entry.error = error;
-      const w = waiters.get(taskId);
-      if (w !== undefined) {
-        if (w.timer !== undefined) clearTimeout(w.timer);
-        w.reject(new Error(error));
+      const list = waiters.get(taskId);
+      if (list !== undefined) {
         waiters.delete(taskId);
+        for (const w of list) {
+          if (w.timer !== undefined) clearTimeout(w.timer);
+          w.reject(new Error(error));
+        }
       }
     },
   };
@@ -124,19 +131,39 @@ export function createTaskRegistry(): TaskRegistry {
           resolve(entry);
           return;
         }
-        const timer =
+        const w: Waiter = { resolve, reject };
+        w.timer =
           timeoutMs !== undefined
             ? setTimeout(() => {
-                waiters.delete(taskId);
-                const e = tasks.get(taskId);
-                if (e !== undefined && e.status === "pending") {
-                  e.status = "timeout";
-                  e.error = `Timeout after ${timeoutMs}ms`;
+                w.timer = undefined;
+                // Remove only THIS waiter — a sibling wait() on the same task stays parked.
+                const list = waiters.get(taskId);
+                let lastWaiter = true;
+                if (list !== undefined) {
+                  const i = list.indexOf(w);
+                  if (i >= 0) {
+                    list.splice(i, 1);
+                    lastWaiter = list.length === 0;
+                    if (lastWaiter) waiters.delete(taskId);
+                  }
+                }
+                // Timeout is a per-waiter event, not a task property: only when the LAST
+                // waiter gives up does the shared entry record "timeout" (settle-once then
+                // keeps a late resolve from resurrecting it). While a sibling stays parked,
+                // the entry remains pending and resolve() still wakes it.
+                if (lastWaiter) {
+                  const e = tasks.get(taskId);
+                  if (e !== undefined && e.status === "pending") {
+                    e.status = "timeout";
+                    e.error = `Timeout after ${timeoutMs}ms`;
+                  }
                 }
                 reject(new Error(`Timeout waiting for task ${taskId}`));
               }, timeoutMs)
             : undefined;
-        waiters.set(taskId, { resolve, reject, timer });
+        const list = waiters.get(taskId);
+        if (list === undefined) waiters.set(taskId, [w]);
+        else list.push(w);
       });
     },
     unawaitedIds: () => {

package/src/bridge/handlers/types.ts

@@ -57,7 +57,7 @@ export interface FinishResult {
 export interface InvocationLimits {
   remainingTimeoutMs(): number | undefined;
   addUsage(usage: Usage): void;
-  addRaw(costUsd: number, inputTokens: number, outputTokens: number): void;
+  addRaw(inputTokens: number, outputTokens: number): void;
 }
 
 export function limitsFromRemaining(
@@ -66,7 +66,7 @@ export function limitsFromRemaining(
   return Object.freeze({
     remainingTimeoutMs: () => remaining?.().timeoutMs,
     addUsage: (_usage: Usage) => {},
-    addRaw: (_costUsd: number, _inputTokens: number, _outputTokens: number) => {},
+    addRaw: (_inputTokens: number, _outputTokens: number) => {},
   });
 }
 
@@ -86,6 +86,9 @@ export interface SubcallConfig {
   readonly maxDepth: number;
   readonly subSampling?: Sampling;
   readonly subSystemPrompt?: string;
+  /** Per-request wall cap (ms) for the llm tier — long-context providers (zai bigmodel TTFB
+   *  ~1 min per 10k ctx chars) abort under the pi-ai default without it. */
+  readonly requestTimeoutMs: number;
   /** v5 TaskLedger: claim/coalesce/echo gates (optional — unwired callers keep ledger off). */
   readonly enableLedger?: boolean;
   /** v5: real rlm spawns before demotion to llm (0 = never demote). */
@@ -114,7 +117,7 @@ export interface SubcallHandlerDeps {
   readonly getChildContext?: () => unknown;
   readonly getModel?: () => Model<Api>;
   readonly degrade?: (prompt: string, depth: number) => Promise<string>;
-  readonly onChildUsage?: (costUsd: number, inputTokens: number, outputTokens: number) => void;
+  readonly onChildUsage?: (inputTokens: number, outputTokens: number) => void;
   readonly trackDetached?: <T>(run: () => Promise<T>) => Promise<T>;
   /** v5 TaskLedger blackboard shared across the whole run tree (claim/coalesce/echo/demote). */
   readonly ledger?: TaskLedger;

package/src/bridge/model.ts

@@ -28,6 +28,9 @@ export interface CompleteOptions {
   readonly temperature?: number;
   readonly reasoning?: ThinkingLevel;
   readonly signal?: AbortSignal;
+  /** Wall-clock cap for ONE provider request (ms); omitted = pi-ai default. Long-context
+   *  providers (zai bigmodel: ~1 min per 10k ctx chars TTFB) need this raised per config. */
+  readonly timeoutMs?: number;
   /** Retry + adaptive throttle for transient 429/5xx; defaults apply when omitted. */
   readonly retry?: RetryPolicy;
   /** v5.1 UX: fired while parked on the rate-limit cooldown ("queued") / when released. */
@@ -116,6 +119,7 @@ export async function modelComplete(messages: readonly ChatMsg[], opts: Complete
           temperature: opts.temperature,
           reasoning: effectiveReasoning(opts.model, opts.reasoning),
           signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
           onResponse: (res) => { note(res.status, res.headers); },
         },
       );

package/src/config/defaults.ts

@@ -12,7 +12,10 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // Max-long runs: the engine may keep iterating until budget/compaction walls hit. The budget
   // cascade and compactionThresholdPct are the real length controls; this ceiling only stops
   // truly runaway loops. Was 30 — capped long tasks prematurely.
-  maxIterations: 200,
+  // Strongly oversized on purpose: runs end on FINAL answer / errors / wall-clock long
+  // before this bites. History: 30 capped long tasks; the bench's 16 all-failed oolong
+  // mid-retrieval. 1000 ≈ 5× the old interactive default, effectively a runaway backstop.
+  maxIterations: 1_000,
   execTimeoutS: 120,
   requestTimeoutMs: 15 * 60_000,
   // Session-wide, not per-batch: spawn() puts many requests on the wire at once, so this is
@@ -53,9 +56,11 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   enableTokenBudget: true,
   budgetShare: 0.25,
   budgetSoftFrac: 0.8,
-  budgetTaskCap: 400_000,
+  budgetTaskCap: 1_000_000,
   budgetMaxContinuations: 2,
-  budgetHandoffChars: 4_000,
+  // 24K: the handoff must carry Σ + findings + query verbatim — a 4K skeleton is what made
+  // long research runs "lose context" on hard-budget continuation (amputated, not lost).
+  budgetHandoffChars: 24_000,
   // v5 TaskLedger blackboard
   enableLedger: true,
   rlmBudget: 8,

package/src/config/settings.ts

@@ -197,11 +197,9 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   }
   if (typeof r.rootSampling === "object" && r.rootSampling !== null) {
     const rs = r.rootSampling as Record<string, unknown>;
-    const rootSampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};
+    const rootSampling: { maxTokens?: number; reasoning?: ThinkingLevel } = {};
     const rsMaxTokens = validateNumber(rs.maxTokens, 1);
     if (rsMaxTokens !== undefined) rootSampling.maxTokens = rsMaxTokens;
-    const rsTemperature = validateNumber(rs.temperature, 0);
-    if (rsTemperature !== undefined) rootSampling.temperature = rsTemperature;
     const rsReasoning = validateThinkingLevel(rs.reasoning);
     if (rsReasoning !== undefined) rootSampling.reasoning = rsReasoning;
     out.rootSampling = Object.freeze(rootSampling);

package/src/context/merge.ts

@@ -37,12 +37,19 @@ export function filterContextByPaths(context: unknown, prefixes: readonly string
   for (let i = 0; i < context.length; i++) {
     const entry: unknown = context[i];
     if (!isContextFile(entry)) continue;
+    let matched = false;
     for (let p = 0; p < prefixes.length; p++) {
-      if (!entry.path.startsWith(prefixes[p])) continue;
+      // Path-boundary match: exact file, or a directory prefix ending at a separator.
+      // Bare startsWith would let "src/cont" match "src/context/x.ts" (sibling leak).
+      const prefix = prefixes[p];
+      const bounded = prefix.endsWith("/") ? prefix : `${prefix}/`;
+      if (entry.path !== prefix && !entry.path.startsWith(bounded)) continue;
       hit[p] = true;
-      out[n++] = entry;
-      break;
+      matched = true;
     }
+    // Emit once even when several prefixes matched the same file (exact + its dir),
+    // but every matching prefix still counts as "matched" for the unmatched report.
+    if (matched) out[n++] = entry;
   }
   out.length = n;
   const unmatched = new Array<string>(prefixes.length); // pre-allocated, no .push()

package/src/context/namespace.ts

@@ -126,8 +126,12 @@ export function namespaceContextFiles(
   return namespaceContextFilesWithChars(payload, sourceId).files;
 }
 
+/** Regex SOURCE for the `ctx/<id>/` namespace — single literal; CTX_PREFIX_RE and the
+ *  sandbox exec-code (Python, refresh.ts) both derive from it. Never inline a copy. */
+export const CTX_PREFIX_PATTERN_SOURCE = "ctx/[^/]+/";
+
 /** The one `ctx/<id>/` matcher. Never re-declare this regex; use the helpers below. */
-const CTX_PREFIX_RE = /^(ctx\/[^/]+\/)/;
+const CTX_PREFIX_RE = new RegExp(`^(${CTX_PREFIX_PATTERN_SOURCE})`);
 
 /** Narrow an unknown context entry to a ContextFile. Type guard, never a cast. */
 export function isContextFile(entry: unknown): entry is ContextFile {
@@ -142,7 +146,7 @@ export function contextEntryPath(entry: unknown): string | undefined {
 }
 
 /** The `ctx/<id>/` prefix owning this path, or undefined. Skips the legacy catch-all. */
-function ctxPrefixOf(path: string): string | undefined {
+export function ctxPrefixOf(path: string): string | undefined {
   const prefix = CTX_PREFIX_RE.exec(path)?.[1];
   // `ctx/unknown/` is the legacy catch-all: never treat it as an identity.
   return prefix === undefined || prefix === LEGACY_UNKNOWN_PREFIX ? undefined : prefix;

package/src/context/refresh.ts

@@ -7,6 +7,7 @@
 import { readFile } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
 import { estimateTokens } from "../text/tokens.ts";
+import { ctxPrefixOf } from "./namespace.ts";
 import type { ContextFile } from "./types.ts";
 
 /** Paths that look like tool file targets. */
@@ -38,8 +39,12 @@ function pathMatches(entryPath: string, target: string, cwd: string): boolean {
   const a = normalizeContextPath(entryPath, cwd);
   const b = normalizeContextPath(target, cwd);
   if (a === b) return true;
-  // suffix match for namespaced entries
-  return entryPath.endsWith("/" + target) || entryPath.endsWith(target);
+  // Namespaced entries (`ctx/<id>/…`) must match on the FULL remainder after the
+  // namespace — never a bare suffix: "/src/a.ts" also ends "ctx/A/other/src/a.ts",
+  // which would refresh an unrelated deeper file (wrong-entry overwrite). The prefix
+  // regex itself is owned by namespace.ts (single matcher, DRY).
+  const ns = ctxPrefixOf(entryPath);
+  return ns !== undefined && entryPath.slice(ns.length) === b;
 }
 
 /**
@@ -72,8 +77,12 @@ export function upsertContextFile(
       typeof (item).path === "string" &&
       pathMatches((item as { path: string }).path, path, cwd)
     ) {
-      next[n++] = entry;
-      replaced = true;
+      // First match replaces; later duplicates of the same logical file are absorbed,
+      // otherwise two matching payload entries would emit the replacement twice.
+      if (!replaced) {
+        next[n++] = entry;
+        replaced = true;
+      }
     } else if (
       item !== null &&
       typeof item === "object" &&
@@ -123,15 +132,27 @@ _tokens = ${tokens}
 _old = context if isinstance(context, list) else []
 _next = []
 _found = False
+def _ns_matches(p, t):
+    # Anchored namespace match, mirrors host ctxPrefixOf: full remainder after
+    # the ctx/<id>/ prefix must EQUAL the target — suffix endswith also hits
+    # deeper paths like ctx/A/other/src/a.ts for target src/a.ts (wrong-entry).
+    if not p.startswith("ctx/"):
+        return False
+    rest = p[4:]
+    i = rest.find("/")
+    if i < 0:
+        return False
+    return rest[i + 1:] == t
 for _e in _old:
     if isinstance(_e, dict) and str(_e.get("path", "")) in (_path, _path.replace("\\\\", "/")):
-        _next.append({"path": _path, "content": _content, "tokens": _tokens})
-        _found = True
-    elif isinstance(_e, dict) and (
-        str(_e.get("path", "")).endswith("/" + _path) or str(_e.get("path", "")).endswith(_path)
-    ):
-        _next.append({"path": str(_e.get("path")), "content": _content, "tokens": _tokens})
-        _found = True
+        if not _found:
+            _next.append({"path": _path, "content": _content, "tokens": _tokens})
+            _found = True
+    elif isinstance(_e, dict) and _ns_matches(str(_e.get("path", "")), _path):
+        # First match replaces; later duplicates are absorbed (dedup mirrors host upsert).
+        if not _found:
+            _next.append({"path": str(_e.get("path")), "content": _content, "tokens": _tokens})
+            _found = True
     else:
         _next.append(_e)
 if not _found:

package/src/core/answer.ts

@@ -21,6 +21,21 @@ export function latestAnswerContentOf(results: readonly ReplResult[]): string |
   return null;
 }
 
+/** Cap for the recovered-stdout fallback (P2 §3.4) — it rides `RlmResult`, not history. */
+const LAST_STDOUT_CAP = 4_000;
+
+/** Last non-empty stdout across a turn's blocks, capped. P2 §3.4: a run that ends without an
+ *  `answer[...]` frame still printed its winning value, and re-running the whole task to get it
+ *  is a waste (and non-deterministic). The bench recovers from here and marks the row
+ *  `recovered: true`; the engine itself never treats stdout as an answer. */
+export function latestStdoutOf(results: readonly ReplResult[]): string {
+  for (let i = results.length - 1; i >= 0; i--) {
+    const out = results[i]?.stdout.trim();
+    if (out) return out.length > LAST_STDOUT_CAP ? out.slice(-LAST_STDOUT_CAP) : out;
+  }
+  return "";
+}
+
 /** True if any block in the turn raised an exception. Plain stderr does not count. */
 export function turnHadError(results: readonly ReplResult[]): boolean {
   return results.some((r) => r.raised);

package/src/core/budget.ts

@@ -1,12 +1,13 @@
 /**
  * Token budget cascade (port of the v4/v5 `budget.py` engine).
  *
- * The budget is the PRIMARY run-length control: above COMPACTION_CEILING_TOKENS the cap is
+ * The budget is an OUTLIER CEILING, not a progress control (progress = maxIterations):
+ * windows at/below COMPACTION_CEILING_TOKENS are never metered; above it the cap is
  * max(ceiling, budgetShare × model context window) — the share can only stretch the working
- * budget further out, never cut under the ceiling;
- * one soft wrap-up turn at `softFrac` of the cap, and at the hard cap a deterministic
- * handoff (`distillTrajectory`) is handed to a fresh continuation run — chain-capped at
- * `maxContinuations`. Wall-clock timeouts stay only as hang backstops.
+ * budget further out, never cut under the ceiling. One soft wrap-up turn at `softFrac` of
+ * the cap, and at the hard cap a deterministic handoff (`distillTrajectory`) is handed to
+ * a fresh continuation run — chain-capped at `maxContinuations`. Wall-clock timeouts stay
+ * only as hang backstops.
  *
  * v5 counts the whole tree (root turns + sub-LLM usage) against the cap; the engine feeds
  * the run's LimitGuard totals in via `observeTotal` after every turn. Each continuation
@@ -30,22 +31,25 @@ type BudgetState = "" | "soft" | "hard";
 
 /** v5 verbatim: the soft wrap-up note prepended to the single turn after crossing soft. */
 export const WRAP_UP_BUDGET: string =
-  "[budget] ~80% of your token cap — ONE turn left. If the task is answerable NOW, finalize " +
-    '(set answer["ready"] = True). Otherwise print a compact findings dump: what is confirmed, ' +
-    "current file/line or search position, and the exact next step — a fresh continuation picks " +
-    "it up. Do not start new exploration.";
+  "[budget] ~80% of this run's outlier cap — ONE turn left. If the task is answerable NOW, " +
+    'finalize (set answer["ready"] = True). Otherwise print a compact findings dump IN THE ' +
+    "NOTES: what is confirmed, current file/line or search position, and the exact next " +
+    "step — a continuation picks it up. The task, the packed context and the ledger carry " +
+    "over; only repl variables are re-derived. Do not start new exploration.";
 
 export const DEFAULT_NEXT_STEP: string =
   "continue the probing that was in flight, then finalize";
 
 /** v5 verbatim template (adapting the finalize spelling to this plugin's REPL). */
 const HANDOFF_TEMPLATE: string =
-  "A prior RLM run hit its token cap mid-task.\n" +
+  "A prior RLM run hit its outlier token ceiling mid-task.\n" +
     "You are its continuation — pick up EXACTLY where it stopped.\n\n" +
     "ORIGINAL TASK:\n{query}\n\n" +
     "CONFIRMED FINDINGS SO FAR:\n{findings}\n\n" +
     "CURRENT STATE / LAST ACTIONS:\n{state}\n\n" +
     "NEXT STEP: {next}\n" +
+    "NOTE: repl variables are re-derived, but the task, the packed context and the ledger " +
+    "carry over. `add_context()` the same external sources again if you still need them.\n" +
     "Do not re-do confirmed work; continue from the NEXT STEP and finalize as\n" +
     'soon as the task is answerable (answer["ready"] = True).';
 
@@ -137,10 +141,14 @@ function unboundedBudget(config: RlmConfig): TokenBudget {
 
 export function resolveBudget(contextWindow: number | undefined, config: RlmConfig): TokenBudget {
   const ctx = contextWindow !== undefined && contextWindow > 0 ? contextWindow : 32_000;
-  if (ctx <= COMPACTION_CEILING_TOKENS) return unboundedBudget(config);
   // The share only stretches the budget BEYOND the absolute ceiling — never under it.
   const shareCap = Math.max(COMPACTION_CEILING_TOKENS, Math.floor(ctx * config.budgetShare));
   const cap = config.budgetTaskCap > 0 ? Math.min(shareCap, config.budgetTaskCap) : shareCap;
+  // LO rule (2025-09-10): small windows are never budget-amputated — but an EXPLICIT
+  // budgetTaskCap that actually binds (below shareCap) must still be honored. The old
+  // early-return swallowed the explicit cap on windows ≤ the ceiling (task-cap bug).
+  const userCapped = config.budgetTaskCap > 0 && config.budgetTaskCap < shareCap;
+  if (!userCapped && ctx <= COMPACTION_CEILING_TOKENS) return unboundedBudget(config);
   return makeBudget(config, Math.max(cap, 1));
 }
 
@@ -150,17 +158,27 @@ export function resolveBudget(contextWindow: number | undefined, config: RlmConf
  */
 export function truncateMid(text: string, maxChars: number): string {
   if (text.length <= maxChars) return text;
-  const half = Math.max(0, maxChars - ELISION_MARK.length) >> 1;
+  // Reserve for the WORST-CASE rendered mark, not the shortest (FINDING-5): the elision
+  // count is substituted at render time, so a 2+ digit count grows the mark past the
+  // length `half` was budgeted from. digits(text.length) upper-bounds digits(elided) —
+  // one pass, and the output can never exceed maxChars.
+  const reserve = maxChars - (ELISION_MARK.length - 1 + String(text.length).length);
+  if (reserve <= 0) {
+    // Cap smaller than even a mark-only render: head-truncate to keep the exact
+    // ≤ maxChars guarantee instead of emitting an oversized degenerate mark.
+    return text.slice(0, maxChars);
+  }
+  const half = reserve >> 1;
   const elided = text.length - (half * 2);
   return text.slice(0, half) + ELISION_MARK.replace("N", String(elided)) + text.slice(text.length - half);
 }
 
 /** Digest/handoff section caps — ONE source: budget.ts's handoff distillation and the root
  *  digest (core/root-digest.ts) must never drift apart on the same trajectory heuristics. */
-export const FINDINGS_MAX = 6;
+export const FINDINGS_MAX = 12; // aligns with RUN_STATE_LIMITS.findings — Σ and handoff agree
 export const FINDINGS_MIN_CHARS = 20;
 export const STATE_MAX = 8;
-const QUERY_CHARS = 800;
+const QUERY_CHARS = 4_000; // full task statement fits; 800 forced the model to "forget" its own goal
 const STATE_NEEDLE = "REPL stdout";
 /** Next-step probe shared by the engine handoff and the root digest (one wording source). */
 export const NEXT_STEP_RE = /next|then|will |todo/i;