@hicaru/pi-rlm 0.3.15 → 0.3.17

package/src/bridge/model.ts

@@ -9,11 +9,12 @@
  * 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";
 
-export type Role = "system" | "user" | "assistant";
+type Role = "system" | "user" | "assistant";
 export interface ChatMsg {
   readonly role: Role;
   readonly content: string;
@@ -54,20 +55,36 @@ function assistantMessage(text: string, model: Model<Api>): Message {
 }
 
 function toPiMessages(messages: readonly ChatMsg[], model: Model<Api>): { readonly systemPrompt?: string; readonly messages: Message[] } {
-  let systemPrompt: string | undefined;
+  // System segments joined once below — no quadratic re-copy of the accumulated prompt (rule:
+  // never build large text with `+`/template concat inside a loop).
+  const systemParts: string[] = [];
   const out: Message[] = [];
   for (const m of messages) {
     if (m.role === "system") {
-      systemPrompt = systemPrompt ? `${systemPrompt}\n\n${m.content}` : m.content;
+      systemParts.push(m.content);
     } else if (m.role === "user") {
       out.push({ role: "user", content: m.content, timestamp: Date.now() });
     } else {
       out.push(assistantMessage(m.content, model));
     }
   }
+  const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
   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 +114,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/commands/rlm-llm.ts

@@ -1,22 +1,13 @@
 /** `/rlm-llm` — pin the leaf-LLM model (llm_query / llm_batch / map_files). */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { modelRef } from "../config/settings.ts";
-import { cheapestModel } from "../mode/llm-model.ts";
+import { cheapestModel, sessionScopedModels } from "../mode/llm-model.ts";
 import type { RlmController } from "../mode/rlm-mode.ts";
 import { pickableModels, selectModel } from "../ui/model-picker.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 import { applyLlmSelection } from "./pins.ts";
 
-/** Newer Pi hosts expose session-scoped models; 0.79 peers do not — duck-type safely. */
-function sessionScopedModels(
-  ctx: ExtensionContext,
-): readonly { readonly model: Model<Api> }[] | undefined {
-  const scoped: unknown = Reflect.get(ctx, "scopedModels");
-  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
-}
-
 async function runRlmLlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
   try {
     await ctx.modelRegistry.refresh();

package/src/commands/rlm-rlm.ts

@@ -4,21 +4,14 @@
  * the pre-pin behavior, now an explicit picker row.
  */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { modelRef } from "../config/settings.ts";
+import { sessionScopedModels } from "../mode/llm-model.ts";
 import type { RlmController } from "../mode/rlm-mode.ts";
 import { pickableModels, selectModel } from "../ui/model-picker.ts";
 import { setRlmModeStatus } from "../ui/status.ts";
 import { applyRlmSelection } from "./pins.ts";
 
-function sessionScopedModels(
-  ctx: ExtensionContext,
-): readonly { readonly model: Model<Api> }[] | undefined {
-  const scoped: unknown = Reflect.get(ctx, "scopedModels");
-  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
-}
-
 async function runRlmRlm(controller: RlmController, ctx: ExtensionContext): Promise<void> {
   try {
     await ctx.modelRegistry.refresh();

package/src/config/defaults.ts

@@ -20,11 +20,12 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // of the context it inherited, where a leaf is one HTTP request. Worst case is
   // (maxDepth - 1) × this many concurrent child engines. Default 4.
   maxConcurrentChildren: 4,
-  // v5.1 rate-limit resilience (util/retry.ts): 3 total attempts, 500ms→15s backoff,
-  // 2s→60s adaptive per-provider cooldown. All overridable in rlm.json.
-  retryMaxAttempts: 3,
-  // 429s park on the cooldown instead of dying — up to 8 windows (2s→4s→…≤60s ≈ 4 min).
-  rateLimitMaxAttempts: 8,
+  // v5.1 rate-limit resilience (util/retry.ts): 15 total attempts on the SAME model —
+  // 500ms→15s backoff, 2s→60s adaptive per-provider cooldown. DOCTRINE: NO fallback —
+  // when the attempts are exhausted the call fails loudly; model/provider never switch.
+  retryMaxAttempts: 15,
+  // 429s park on the cooldown instead of dying — up to 15 windows (2s→4s→…≤60s).
+  rateLimitMaxAttempts: 15,
   retryBaseDelayMs: 500,
   retryMaxDelayMs: 15_000,
   throttleBaseMs: 2_000,
@@ -51,11 +52,29 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   // v5 TaskLedger blackboard
   enableLedger: true,
   rlmBudget: 8,
-  // v5 durable memory
-  enableMemory: true,
-  injectNoteTokens: 2_000,
-  evolveEvery: 8,
-  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,
+  // SKILL.state integration: Σ_t execution state + cross-session distilled knowledge.
+  enableRunState: true,
+  runStateRetryMax: 2,
+  enableSkillState: true,
+  // Default ON (bench rec #3): deterministic harvest — one cheap distill leaf per finalize
+  // replaces the stochastic fence-emission harvest (0 vs 4 notes across identical ON arms).
+  enableSkillStateDistill: true,
+  skillStateMaxTokens: 1_200,
+  skillStateLeafTokens: 200,
+  skillStateMinScore: 4.0,
+  skillStateNotesPerProject: 128,
+  // Root Σ integration (WS-2..WS-4): digest compaction ON (it only swaps the summarizer for
+  // a deterministic digest — zero tokens, strictly less latency); the context transform and
+  // model-proposed fences soak with flags OFF until the A/B says otherwise.
+  enableRootDigestCompaction: true,
+  rootDigestKeepRecentChars: 12_000,
+  rootDigestMaxChars: 8_000,
+  enableRootContextTransform: false,
+  rootContextKeepTurns: 2,
+  rootContextElideChars: 1_500,
+  rootContextSnapshot: true,
+  enableRootStateFences: false,
 });

package/src/config/settings.ts

@@ -7,7 +7,7 @@ import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { RlmConfig } from "../core/types.ts";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 
-export interface PersistedSettings {
+interface PersistedSettings {
   readonly config: Partial<RlmConfig>;
   /** "provider/id" of the pinned sub-LLM, or undefined for "cheapest (auto)".
    *  `null` = explicit "cheapest" clear (omit key on disk). */
@@ -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,
 });
 
@@ -103,8 +104,7 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
   const sandboxInitTimeoutMs = validateNumber(r.sandboxInitTimeoutMs, 100);
   if (sandboxInitTimeoutMs !== undefined) out.sandboxInitTimeoutMs = sandboxInitTimeoutMs;
-  // `libraryLoader` is the pre-rename key — still read so an existing rlm.json survives the upgrade.
-  const contextLoader = validateBoolean(r.contextLoader) ?? validateBoolean(r.libraryLoader);
+  const contextLoader = validateBoolean(r.contextLoader);
   if (contextLoader !== undefined) out.contextLoader = contextLoader;
   const autoSeedCwd = validateBoolean(r.autoSeedCwd);
   if (autoSeedCwd !== undefined) out.autoSeedCwd = autoSeedCwd;
@@ -126,18 +126,6 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (enableLedger !== undefined) out.enableLedger = enableLedger;
   const rlmBudget = validateNumber(r.rlmBudget, 0);
   if (rlmBudget !== undefined) out.rlmBudget = rlmBudget;
-  // v5 durable memory
-  const enableMemory = validateBoolean(r.enableMemory);
-  if (enableMemory !== undefined) out.enableMemory = enableMemory;
-  const injectNoteTokens = validateNumber(r.injectNoteTokens, 100);
-  if (injectNoteTokens !== undefined) out.injectNoteTokens = injectNoteTokens;
-  const evolveEvery = validateNumber(r.evolveEvery, 0);
-  if (evolveEvery !== undefined) out.evolveEvery = evolveEvery;
-  if (r.memoryDir === null) out.memoryDir = null;
-  else {
-    const memoryDir = validateString(r.memoryDir);
-    if (memoryDir !== undefined) out.memoryDir = memoryDir;
-  }
   // v5 provider concurrency caps: { provider: minConcurrent }
   if (typeof r.providerMaxConcurrent === "object" && r.providerMaxConcurrent !== null) {
     const caps: Record<string, number> = {};
@@ -147,8 +135,43 @@ export function validateConfig(raw: unknown): Partial<RlmConfig> {
     }
     if (Object.keys(caps).length > 0) out.providerMaxConcurrent = Object.freeze(caps);
   }
-  // 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;
+  // SKILL.state integration (Workstreams A–F)
+  const enableRunState = validateBoolean(r.enableRunState);
+  if (enableRunState !== undefined) out.enableRunState = enableRunState;
+  const runStateRetryMax = validateNumber(r.runStateRetryMax, 0);
+  if (runStateRetryMax !== undefined) out.runStateRetryMax = runStateRetryMax;
+  const enableSkillState = validateBoolean(r.enableSkillState);
+  if (enableSkillState !== undefined) out.enableSkillState = enableSkillState;
+  const enableSkillStateDistill = validateBoolean(r.enableSkillStateDistill);
+  if (enableSkillStateDistill !== undefined) out.enableSkillStateDistill = enableSkillStateDistill;
+  const skillStateMaxTokens = validateNumber(r.skillStateMaxTokens, 50);
+  if (skillStateMaxTokens !== undefined) out.skillStateMaxTokens = skillStateMaxTokens;
+  const skillStateLeafTokens = validateNumber(r.skillStateLeafTokens, 0);
+  if (skillStateLeafTokens !== undefined) out.skillStateLeafTokens = skillStateLeafTokens;
+  const skillStateMinScore = validateNumber(r.skillStateMinScore, 0);
+  if (skillStateMinScore !== undefined) out.skillStateMinScore = skillStateMinScore;
+  const skillStateNotesPerProject = validateNumber(r.skillStateNotesPerProject, 1);
+  if (skillStateNotesPerProject !== undefined) out.skillStateNotesPerProject = skillStateNotesPerProject;
+  // Root Σ integration (WS-2..WS-4)
+  const enableRootDigestCompaction = validateBoolean(r.enableRootDigestCompaction);
+  if (enableRootDigestCompaction !== undefined) out.enableRootDigestCompaction = enableRootDigestCompaction;
+  const rootDigestKeepRecentChars = validateNumber(r.rootDigestKeepRecentChars, 200);
+  if (rootDigestKeepRecentChars !== undefined) out.rootDigestKeepRecentChars = rootDigestKeepRecentChars;
+  const rootDigestMaxChars = validateNumber(r.rootDigestMaxChars, 200);
+  if (rootDigestMaxChars !== undefined) out.rootDigestMaxChars = rootDigestMaxChars;
+  const enableRootContextTransform = validateBoolean(r.enableRootContextTransform);
+  if (enableRootContextTransform !== undefined) out.enableRootContextTransform = enableRootContextTransform;
+  const rootContextKeepTurns = validateNumber(r.rootContextKeepTurns, 0);
+  if (rootContextKeepTurns !== undefined) out.rootContextKeepTurns = rootContextKeepTurns;
+  const rootContextElideChars = validateNumber(r.rootContextElideChars, 100);
+  if (rootContextElideChars !== undefined) out.rootContextElideChars = rootContextElideChars;
+  const rootContextSnapshot = validateBoolean(r.rootContextSnapshot);
+  if (rootContextSnapshot !== undefined) out.rootContextSnapshot = rootContextSnapshot;
+  const enableRootStateFences = validateBoolean(r.enableRootStateFences);
+  if (enableRootStateFences !== undefined) out.enableRootStateFences = enableRootStateFences;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
     const ss = r.subSampling as Record<string, unknown>;
     const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};
@@ -181,8 +204,7 @@ export async function loadSettings(): Promise<PersistedSettings> {
     const r = raw as Record<string, unknown>;
     return {
       config: validateConfig(r.config),
-      // `worker` is the pre-rename key — still read so an existing pin survives the upgrade.
-      llm: validateString(r.llm) ?? validateString(r.worker),
+      llm: validateString(r.llm),
       rlm: validateString(r.rlm),
     };
   } catch {
@@ -238,16 +260,8 @@ export function modelRef(model: Model<Api> | undefined): string | undefined {
   return model ? `${model.provider}/${model.id}` : undefined;
 }
 
-/**
- * Human-readable "provider/id" for a sub-call node: the resolved override when one was
- * supplied and resolves, otherwise the fallback model. Shared by the llm and rlm bridges
- * so sub-call trees label their nodes identically.
- */
-export function displayModelRef(
-  registry: ModelRegistry,
-  override: string | null,
-  fallback: Model<Api>,
-): string {
-  const resolved = override ? (resolveModelId(registry, override) ?? fallback) : fallback;
-  return modelRef(resolved) ?? fallback.id;
+/** Single "provider/id" projection for sub-call node labels — shared by the llm and rlm
+ *  bridges so sub-call trees label their nodes identically. */
+export function modelLabelOf(model: Model<Api>): string {
+  return modelRef(model) ?? model.id;
 }