@hicaru/pi-rlm 0.2.0 → 0.2.2

package/src/config/defaults.ts

@@ -1,8 +1,4 @@
 import type { RlmConfig } from "../core/types.ts";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export const DEFAULT_RUN_DIR = join(tmpdir(), "rlm-runs");
 
 /** Frozen default sub-LLM system prompt — avoids re-allocation on every llm_query call. */
 const DEFAULT_SUB_SYSTEM_PROMPT =
@@ -16,26 +12,22 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   maxIterations: 30,
   execTimeoutS: 120,
   requestTimeoutMs: 10 * 60_000,
-  maxConcurrentSubcalls: 4,
+  // Session-wide, not per-batch: spawn() puts many requests on the wire at once, so this is
+  // the only thing bounding leaf fan-out.
+  maxConcurrentSubcalls: 16,
+  // Children are bounded separately and lower: each is a Python subprocess holding its own copy
+  // of the context it inherited, where a leaf is one HTTP request. Worst case is
+  // (maxDepth - 1) × this many concurrent child engines.
+  maxConcurrentChildren: 6,
   maxPromptChars: 400_000,
   maxErrors: 5,
   orchestrator: true,
-  pipeline: false,
-  maxBackwardJumps: 2,
   compaction: true,
   compactionThresholdPct: 0.65,
   python: "python3",
   sandboxInitTimeoutMs: 30_000,
-  askUserQuestion: true,
-  todo: true,
   libraryLoader: true,
   rootSampling: Object.freeze({ maxTokens: 16_384 }),
   subSystemPrompt: DEFAULT_SUB_SYSTEM_PROMPT,
   subSampling: Object.freeze({ maxTokens: 8192 }),
-  runLog: Object.freeze({
-    enabled: true,
-    dir: DEFAULT_RUN_DIR,
-    snapshot: true,
-    maxRuns: 50,
-  }),
 });

package/src/config/settings.ts

@@ -1,15 +1,16 @@
-/** Persist RLM settings (tunable config + chosen worker model id). */
+/** Persist RLM settings (tunable config + pinned sub-LLM model id). */
 
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir, type ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
-import type { RlmConfig, RunLogConfig } from "../core/types.ts";
+import type { RlmConfig } from "../core/types.ts";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 
 export interface PersistedSettings {
   readonly config: Partial<RlmConfig>;
-  readonly worker?: string;
+  /** "provider/id" of the pinned sub-LLM, or undefined for "cheapest (auto)". */
+  readonly llm?: string;
 }
 
 type MutablePartialRlmConfig = { -readonly [K in keyof RlmConfig]?: RlmConfig[K] };
@@ -43,21 +44,6 @@ function validateThinkingLevel(v: unknown): ThinkingLevel | undefined {
   return typeof v === "string" && Object.hasOwn(THINKING_LEVELS, v) ? (v as ThinkingLevel) : undefined;
 }
 
-function validateRunLog(raw: unknown): Partial<RunLogConfig> | undefined {
-  if (typeof raw !== "object" || raw === null) return undefined;
-  const r = raw as Record<string, unknown>;
-  const out: { enabled?: boolean; dir?: string; snapshot?: boolean; maxRuns?: number } = {};
-  const enabled = validateBoolean(r.enabled);
-  if (enabled !== undefined) out.enabled = enabled;
-  const dir = validateString(r.dir);
-  if (dir !== undefined) out.dir = dir;
-  const snapshot = validateBoolean(r.snapshot);
-  if (snapshot !== undefined) out.snapshot = snapshot;
-  const maxRuns = validateNumber(r.maxRuns, 1);
-  if (maxRuns !== undefined) out.maxRuns = maxRuns;
-  return Object.keys(out).length > 0 ? Object.freeze(out) : undefined;
-}
-
 function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (typeof raw !== "object" || raw === null) return {};
   const r = raw as Record<string, unknown>;
@@ -74,10 +60,10 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (requestTimeoutMs !== undefined) out.requestTimeoutMs = requestTimeoutMs;
   const maxConcurrentSubcalls = validateNumber(r.maxConcurrentSubcalls, 1);
   if (maxConcurrentSubcalls !== undefined) out.maxConcurrentSubcalls = maxConcurrentSubcalls;
+  const maxConcurrentChildren = validateNumber(r.maxConcurrentChildren, 1);
+  if (maxConcurrentChildren !== undefined) out.maxConcurrentChildren = maxConcurrentChildren;
   const maxPromptChars = validateNumber(r.maxPromptChars, 1000);
   if (maxPromptChars !== undefined) out.maxPromptChars = maxPromptChars;
-  const maxBudgetUsd = validateNumber(r.maxBudgetUsd, 0.01);
-  if (maxBudgetUsd !== undefined) out.maxBudgetUsd = maxBudgetUsd;
   const maxTimeoutMs = validateNumber(r.maxTimeoutMs, 1000);
   if (maxTimeoutMs !== undefined) out.maxTimeoutMs = maxTimeoutMs;
   const maxTokens = validateNumber(r.maxTokens, 1);
@@ -86,10 +72,6 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (maxErrors !== undefined) out.maxErrors = maxErrors;
   const orchestrator = validateBoolean(r.orchestrator);
   if (orchestrator !== undefined) out.orchestrator = orchestrator;
-  const pipeline = validateBoolean(r.pipeline);
-  if (pipeline !== undefined) out.pipeline = pipeline;
-  const maxBackwardJumps = validateNumber(r.maxBackwardJumps, 0);
-  if (maxBackwardJumps !== undefined) out.maxBackwardJumps = maxBackwardJumps;
   const compaction = validateBoolean(r.compaction);
   if (compaction !== undefined) out.compaction = compaction;
   const compactionThresholdPct = validateNumber(r.compactionThresholdPct, 0);
@@ -100,14 +82,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (smartReasoning !== undefined) out.smartReasoning = smartReasoning;
   const subSystemPrompt = validateString(r.subSystemPrompt);
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
-  const runLog = validateRunLog(r.runLog);
-  if (runLog) out.runLog = runLog;
   const sandboxInitTimeoutMs = validateNumber(r.sandboxInitTimeoutMs, 100);
   if (sandboxInitTimeoutMs !== undefined) out.sandboxInitTimeoutMs = sandboxInitTimeoutMs;
-  const askUserQuestion = validateBoolean(r.askUserQuestion);
-  if (askUserQuestion !== undefined) out.askUserQuestion = askUserQuestion;
-  const todo = validateBoolean(r.todo);
-  if (todo !== undefined) out.todo = todo;
   const libraryLoader = validateBoolean(r.libraryLoader);
   if (libraryLoader !== undefined) out.libraryLoader = libraryLoader;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
@@ -142,7 +118,8 @@ export async function loadSettings(): Promise<PersistedSettings> {
     const r = raw as Record<string, unknown>;
     return {
       config: validateConfig(r.config),
-      worker: typeof r.worker === "string" ? r.worker : undefined,
+      // `worker` is the pre-rename key — still read so an existing pin survives the upgrade.
+      llm: validateString(r.llm) ?? validateString(r.worker),
     };
   } catch {
     return { config: {} };
@@ -167,7 +144,6 @@ export function mergeConfig(partial: Partial<RlmConfig>): RlmConfig {
     ...partial,
     subSampling: { ...DEFAULT_CONFIG.subSampling, ...partial.subSampling },
     rootSampling: Object.freeze({ ...DEFAULT_CONFIG.rootSampling, ...partial.rootSampling }),
-    ...(partial.runLog ? { runLog: Object.freeze({ ...DEFAULT_CONFIG.runLog, ...partial.runLog }) } : {}),
   };
 }
 

package/src/context/library-context.ts

@@ -31,7 +31,7 @@ const execFileP = promisify(execFile);
 /** Single-file sources above this must use open() + llm_query_chunked in the REPL. */
 export const MAX_LIBRARY_FILE_BYTES = 8 * 1024 * 1024;
 
-/** Legacy catch-all prefix for pre-namespace string sidecars — never an identity key. */
+/** Catch-all prefix for a raw string payload with no namespace — never an identity key. */
 const LEGACY_UNKNOWN_PREFIX = "lib/unknown/";
 
 export interface LibrarySource {
@@ -150,23 +150,100 @@ export function namespaceLibraryFiles(
   return namespaceLibraryFilesWithChars(payload, sourceId).files;
 }
 
+/** The one `lib/<id>/` matcher. Never re-declare this regex; use the helpers below. */
+const LIB_PREFIX_RE = /^(lib\/[^/]+\/)/;
+
+/** Narrow an unknown context entry to a ContextFile. Type guard, never a cast. */
+export function isContextFile(entry: unknown): entry is ContextFile {
+  if (entry === null || typeof entry !== "object") return false;
+  return "path" in entry && typeof entry.path === "string"
+    && "content" in entry && typeof entry.content === "string";
+}
+
+/** `path` of a context entry, or undefined when the entry is not file-shaped. */
+export function contextEntryPath(entry: unknown): string | undefined {
+  return isContextFile(entry) ? entry.path : undefined;
+}
+
+/** The `lib/<id>/` prefix owning this path, or undefined. Skips the legacy catch-all. */
+function libPrefixOf(path: string): string | undefined {
+  const prefix = LIB_PREFIX_RE.exec(path)?.[1];
+  // `lib/unknown/` is the legacy catch-all: never treat it as an identity.
+  return prefix === undefined || prefix === LEGACY_UNKNOWN_PREFIX ? undefined : prefix;
+}
+
 /** First `lib/<id>/` prefix found in the payload, or undefined. Skips `lib/unknown/`. */
 export function payloadPrefix(payload: readonly unknown[]): string | undefined {
   for (let i = 0; i < payload.length; i++) {
-    const item = payload[i];
-    if (item === null || typeof item !== "object") continue;
-    const path = (item as { path?: unknown }).path;
-    if (typeof path !== "string") continue;
-    const m = /^(lib\/[^/]+\/)/.exec(path);
-    // `lib/unknown/` is the legacy catch-all: never treat it as an identity.
-    if (m?.[1] !== undefined && m[1] !== LEGACY_UNKNOWN_PREFIX) return m[1];
+    const path = contextEntryPath(payload[i]);
+    if (path === undefined) continue;
+    const prefix = libPrefixOf(path);
+    if (prefix !== undefined) return prefix;
   }
   return undefined;
 }
 
 /**
- * Append a library payload into an existing list context (host-side resume merge).
- * Skips a payload whose path prefix is already present (resume-safe dedup).
+ * Every distinct `lib/<id>/` prefix present in a context payload.
+ *
+ * The loaded-prefix set in bridge/library.ts is a CACHE of this — derived state, never
+ * independent state, so it may only be cleared by re-deriving it from the live payload.
+ */
+export function libraryPrefixesIn(context: unknown): readonly string[] {
+  if (!Array.isArray(context)) return Object.freeze([]);
+  const seen = new Set<string>();
+  for (let i = 0; i < context.length; i++) {
+    const path = contextEntryPath(context[i]);
+    if (path === undefined) continue;
+    const prefix = libPrefixOf(path);
+    if (prefix !== undefined) seen.add(prefix);
+  }
+  return Object.freeze(Array.from(seen));
+}
+
+export interface FilteredContext {
+  readonly files: readonly ContextFile[];
+  /** Prefixes that selected zero files — the caller decides whether that is fatal. */
+  readonly unmatched: readonly string[];
+}
+
+/**
+ * Narrow a context payload to entries under any of `prefixes` (plain prefix match, no globs).
+ *
+ * Backs `rlm_query(prompt, paths=[…])`. Prefix-only is deliberate: the sandbox's own filters use
+ * Python `fnmatch`, which has no host-side equivalent here, and a subtree prefix is what callers
+ * actually want — the child can still `search()` inside the slice.
+ */
+export function filterContextByPaths(context: unknown, prefixes: readonly string[]): FilteredContext {
+  if (!Array.isArray(context) || prefixes.length === 0) {
+    return Object.freeze({ files: Object.freeze([]), unmatched: Object.freeze(Array.from(prefixes)) });
+  }
+  const hit = new Array<boolean>(prefixes.length).fill(false);
+  const out = new Array<ContextFile>(context.length); // pre-allocated, trimmed once below
+  let n = 0;
+  for (let i = 0; i < context.length; i++) {
+    const entry: unknown = context[i];
+    if (!isContextFile(entry)) continue;
+    for (let p = 0; p < prefixes.length; p++) {
+      if (!entry.path.startsWith(prefixes[p])) continue;
+      hit[p] = true;
+      out[n++] = entry;
+      break;
+    }
+  }
+  out.length = n;
+  const unmatched = new Array<string>(prefixes.length); // pre-allocated, no .push()
+  let u = 0;
+  for (let p = 0; p < prefixes.length; p++) {
+    if (!hit[p]) unmatched[u++] = prefixes[p];
+  }
+  unmatched.length = u;
+  return Object.freeze({ files: Object.freeze(out), unmatched: Object.freeze(unmatched) });
+}
+
+/**
+ * Append a library payload into an existing list context.
+ * Skips a payload whose path prefix is already present, so a repeat load is a no-op.
  */
 export function mergeLibraryIntoContext(base: unknown, libraryPayload: unknown): unknown {
   if (!Array.isArray(base)) return base;
@@ -175,12 +252,8 @@ export function mergeLibraryIntoContext(base: unknown, libraryPayload: unknown):
     const prefix = payloadPrefix(libraryPayload);
     if (prefix !== undefined) {
       for (let i = 0; i < base.length; i++) {
-        const item = base[i];
-        if (item !== null && typeof item === "object"
-          && typeof (item as { path?: unknown }).path === "string"
-          && (item as { path: string }).path.startsWith(prefix)) {
-          return base; // already present
-        }
+        const path = contextEntryPath(base[i]);
+        if (path !== undefined && path.startsWith(prefix)) return base; // already present
       }
     }
     const merged = new Array<unknown>(base.length + libraryPayload.length);
@@ -189,7 +262,7 @@ export function mergeLibraryIntoContext(base: unknown, libraryPayload: unknown):
     return merged;
   }
   if (typeof libraryPayload === "string") {
-    // Legacy string sidecars: wrap once under an unknown prefix.
+    // Raw string payload: wrap once under the unknown prefix.
     return mergeLibraryIntoContext(base, namespaceLibraryFiles(libraryPayload, "unknown"));
   }
   return base;