@hicaru/pi-rlm 0.3.19 → 0.3.21

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.21",
 	"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/commands/rlm.ts

@@ -4,7 +4,12 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { RlmController } from "../mode/rlm-mode.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 
-export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController): void {
+/**
+ * `stopNative` aborts the native-mode session work (repl cells, child engines, detached
+ * spawn() tasks) and reports whether any was in flight. Optional so tests can register the
+ * bare command; production wires the closure accessors from src/index.ts.
+ */
+export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController, stopNative?: () => boolean): void {
   pi.registerCommand("rlm", {
     description: "Toggle persistent RLM mode (route plain prompts through the RLM engine).",
     handler: async (_args, ctx) => {
@@ -15,14 +20,16 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
   });
 
   pi.registerCommand("rlm-stop", {
-    description: "Abort the in-progress RLM run.",
+    description: "Abort in-progress RLM work: RLM runs, native repl cells, background tasks.",
     handler: async (_args, ctx) => {
-      if (!controller.isBusy()) {
-        ctx.ui.notify("No RLM run in progress.", "info");
-        return;
+      const rlmBusy = controller.isBusy();
+      if (rlmBusy) controller.abort();
+      const nativeBusy = stopNative?.() ?? false;
+      if (rlmBusy || nativeBusy) {
+        ctx.ui.notify("RLM work aborted — runs, repl cells and background tasks stopped.", "info");
+      } else {
+        ctx.ui.notify("No RLM work in progress.", "info");
       }
-      controller.abort();
-      ctx.ui.notify("RLM run aborted.", "info");
     },
   });
 

package/src/config/defaults.ts

@@ -1,10 +1,18 @@
 import type { RlmConfig } from "../core/types.ts";
 
-/** Frozen default sub-LLM system prompt — avoids re-allocation on every llm_query call. */
+/**
+ * Frozen default sub-LLM system prompt — avoids re-allocation on every llm_query call.
+ * Anthropic prompting canon applied: a role ("precise extraction assistant") and the
+ * hallucination out ("reply exactly NOT_FOUND when the material lacks the answer") — the
+ * convention the glossary documents so roots can branch on a leaf's NOT_FOUND instead of
+ * retrying identical prompts against slices that cannot answer.
+ */
 const DEFAULT_SUB_SYSTEM_PROMPT =
-  "Answer directly and concisely. Return only the requested information. " +
-  "No preamble, no meta-commentary, no explanation of your approach. " +
-  "If listing items, use compact bullet form.";
+  "You are a precise extraction and analysis assistant. " +
+  "Answer directly and concisely from the material provided in the prompt. " +
+  "Return only the requested information — no preamble, no meta-commentary, no explanation of your approach. " +
+  "If listing items, use compact bullet form. " +
+  "If the material does not contain the answer, reply exactly: NOT_FOUND";
 
 export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   enabled: true,
@@ -12,7 +20,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,15 +64,19 @@ 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,
-  // 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,
+  // Verification-discipline nudge — default ON (knowlange rec: 28/33 bench failures were
+  // early confident wrong answers; the RLM paper ships the same discipline). An early bare
+  // finalize — or one from a run that never inspected its context — gets ONE coached redo
+  // before the answer is accepted. Opt out via rlm.json (`"enableVerificationNudge": false`).
+  enableVerificationNudge: true,
   // SKILL.state integration: Σ_t execution state + cross-session distilled knowledge.
   // Paradigm flags are ENFORCED (R0, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md) — validateEnforcedOn
   // forces true whatever rlm.json carries; only calibrations are tunable.
@@ -73,7 +88,12 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   enableSkillStateDistill: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0
   skillStateMaxTokens: 1_200,
   skillStateLeafTokens: 200,
-  skillStateMinScore: 4.0,
+  // 2.5 (was 4.0 — recall W3): at 4.0 grounding silently no-oped on most prompts; 2.5 keeps
+  // the byte-identical-below-threshold contract while letting genuinely-relevant facts land.
+  skillStateMinScore: 2.5,
+  // Ξ block floor (recall W3): was Number.MIN_VALUE — every positively-scored stale note
+  // rode every root prompt. 2.0 admits relevant notes without the cross-session noise.
+  skillStateXiMinScore: 2.0,
   skillStateNotesPerProject: 128,
   // Root Σ integration (WS-2..WS-4): every LLM call assembles A_t = (P, Σ_t, O_t) — discard
   // semantics on stale payloads + exactly one Σ snapshot splice, and model-proposed ΔΣ_t
@@ -84,8 +104,16 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   rootDigestKeepRecentChars: 12_000,
   rootDigestMaxChars: 8_000,
   enableRootContextTransform: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0 (was soak-OFF pre-v2)
-  rootContextKeepTurns: 2,
-  rootContextElideChars: 1_500,
+  // Recall W4 calibration: 4 verbatim turns (was 2). SKILL.state's budget-matched ablation
+  // (Table 5/11) shows truncated windows collapse recall (0.18 vs structured 0.94); a 2-turn
+  // window sat dangerously close to that shape. Still O(1) per call; the session archive
+  // (rootArchiveMaxChars) makes anything older dereferenceable instead of gone.
+  rootContextKeepTurns: 4,
+  rootContextElideChars: 3_000,
+  // Recall W1: elided turns archive into the sandbox (ctx/session-log/*) so search()/
+  // grep_context() recall them — elision becomes dereferenceable, and the stubs stay honest.
+  // 0 disables the archive (stubs degrade to the plain Σ line).
+  rootArchiveMaxChars: 2_000_000,
   rootContextSnapshot: true,
   enableRootStateFences: true, // ENFORCED — see /tmp/ROOT_FULL_SKILLSTATE_PLAN.md R0 (was soak-OFF pre-v2)
 });

package/src/config/settings.ts

@@ -167,6 +167,8 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (skillStateLeafTokens !== undefined) out.skillStateLeafTokens = skillStateLeafTokens;
   const skillStateMinScore = validateNumber(r.skillStateMinScore, 0);
   if (skillStateMinScore !== undefined) out.skillStateMinScore = skillStateMinScore;
+  const skillStateXiMinScore = validateNumber(r.skillStateXiMinScore, 0);
+  if (skillStateXiMinScore !== undefined) out.skillStateXiMinScore = skillStateXiMinScore;
   const skillStateNotesPerProject = validateNumber(r.skillStateNotesPerProject, 1);
   if (skillStateNotesPerProject !== undefined) out.skillStateNotesPerProject = skillStateNotesPerProject;
   // Root Σ integration (WS-2..WS-4) — paradigm flags ENFORCED (R0); the window/byte knobs
@@ -181,6 +183,10 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (rootContextKeepTurns !== undefined) out.rootContextKeepTurns = rootContextKeepTurns;
   const rootContextElideChars = validateNumber(r.rootContextElideChars, 100);
   if (rootContextElideChars !== undefined) out.rootContextElideChars = rootContextElideChars;
+  // Recall W1 archive calibration: 0 legitimately disables the archive (plain stubs), so the
+  // floor differs from the other char knobs.
+  const rootArchiveMaxChars = validateNumber(r.rootArchiveMaxChars, 0);
+  if (rootArchiveMaxChars !== undefined) out.rootArchiveMaxChars = rootArchiveMaxChars;
   const rootContextSnapshot = validateBoolean(r.rootContextSnapshot);
   if (rootContextSnapshot !== undefined) out.rootContextSnapshot = rootContextSnapshot;
   out.enableRootStateFences = validateEnforcedOn(r.enableRootStateFences, "enableRootStateFences");
@@ -197,11 +203,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);