@hicaru/pi-rlm 0.1.8 → 0.2.0

package/src/commands/rlm.ts

@@ -1,6 +1,7 @@
 /** `/rlm` — toggle persistent Recursive Language Model mode. */
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Text, type Component } from "@earendil-works/pi-tui";
 import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import type { RlmController, RunHandle } from "../mode/rlm-mode.ts";
 import { postRlmGuide } from "../ui/intro.ts";
@@ -13,13 +14,19 @@ import type { RunHeader } from "../state/rows.ts";
 import { buildRlmSystemPrompt } from "../prompts/system.ts";
 import { RlmEmitter } from "../tool/rlm-events.ts";
 import { RlmEventAggregator } from "../tool/rlm-aggregator.ts";
+import type { RlmDetails } from "../tool/rlm-details.ts";
+import { cardHeader, cardStatsLine, renderCollapsedSubcallTree } from "../tool/subcall-render.ts";
+import { errorMessage } from "../util/errors.ts";
+
+/** Run ids offered for `/rlm-resume <TAB>`. */
+const MAX_COMPLETIONS = 20;
 
 export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController): void {
   pi.registerCommand("rlm", {
     description: "Toggle persistent RLM mode (route plain prompts through the RLM engine).",
     handler: async (_args, ctx) => {
       const enabled = controller.toggle();
-      setRlmModeStatus(ctx.ui, controller);
+      setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });
@@ -45,6 +52,15 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
 
   pi.registerCommand("rlm-resume", {
     description: "Resume an interrupted RLM run (default @latest).",
+    getArgumentCompletions: async (prefix) => {
+      const dir = controller.config.runLog?.dir ?? DEFAULT_RUN_DIR;
+      const ids = await listRunIds(process.cwd(), dir);
+      const candidates = ["@latest", ...ids];
+      return candidates
+        .filter((value) => value.startsWith(prefix))
+        .slice(0, MAX_COMPLETIONS)
+        .map((value) => ({ value, label: value }));
+    },
     handler: async (args, ctx) => {
       if (controller.isBusy()) {
         ctx.ui.notify("RLM is busy (use /rlm-stop to cancel).", "warning");
@@ -69,7 +85,7 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
       let recon: ReconstructResult;
       try { recon = await reconstructRlmState(cwd, dir, runId, systemPrompt); }
       catch (e) {
-        ctx.ui.notify(`RLM resume failed: corrupt run state — ${e instanceof Error ? e.message : String(e)}`, "error");
+        ctx.ui.notify(`RLM resume failed: corrupt run state — ${errorMessage(e)}`, "error");
         return;
       }
       if (!recon.ok) { ctx.ui.notify(`Cannot resume ${runId}: ${recon.reason}.`, "error"); return; }
@@ -94,12 +110,29 @@ export function registerRlmCommand(pi: ExtensionAPI, controller: RlmController):
     description: "Toggle RLM mode (off also stops a running query)",
     handler: async (ctx) => {
       const enabled = controller.toggle();
-      setRlmModeStatus(ctx.ui, controller);
+      setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
       ctx.ui.notify(`RLM mode ${enabled ? "ON" : "OFF"}`, "info");
     },
   });
 }
 
+/** Above-editor progress card for a `/rlm-resume` run: header + the live sub-call tree. */
+function renderResumeWidget(details: RlmDetails | undefined, theme: Theme): Component {
+  const container = new Container();
+  if (!details) return container;
+  const turns = details.turns;
+  const stats = cardStatsLine(
+    details.totals,
+    theme,
+    turns.max > 0 ? `turn ${turns.current}/${turns.max}` : undefined,
+  );
+  container.addChild(new Text(cardHeader("RLM resume", details.status, stats, theme), 0, 0));
+  if (details.subcalls.length > 0) {
+    container.addChild(new Text(renderCollapsedSubcallTree(details.subcalls, theme), 0, 0));
+  }
+  return container;
+}
+
 async function executeRlmRunWithResume(
   pi: ExtensionAPI,
   controller: RlmController,
@@ -113,13 +146,16 @@ async function executeRlmRunWithResume(
   let aggregator: RlmEventAggregator | undefined;
   try {
     emitter = new RlmEmitter();
+    // Component factory rather than the string[] form: the array form is hard-capped at 10
+    // lines by pi, which the live sub-call tree exceeds as soon as a run fans out. The factory
+    // also receives the live theme, so the widget follows /theme switches.
+    let latest: RlmDetails | undefined;
     aggregator = new RlmEventAggregator(emitter, (partial) => {
-      const d = partial.details;
-      if (!d) return;
-      const turn = d.turns.max > 0 ? ` · turn ${d.turns.current}/${d.turns.max}` : "";
-      const cost = d.totals.costUsd > 0 ? ` · $${d.totals.costUsd.toFixed(4)}` : "";
-      const glyph = d.status === "running" ? "⏳" : d.status === "done" ? "✓" : "✗";
-      ctx.ui.setWidget?.("rlm-status", [`${glyph} RLM resume${turn}${cost}`], { placement: "aboveEditor" });
+      latest = partial.details;
+      if (!latest) return;
+      ctx.ui.setWidget?.("rlm-status", (_tui, theme) => renderResumeWidget(latest, theme), {
+        placement: "aboveEditor",
+      });
     });
     emitter.emitRootPrompt(header.rootPrompt);
     const interactive = createPiInteractiveDeps(ctx);
@@ -131,7 +167,7 @@ async function executeRlmRunWithResume(
       onTodo: controller.config.todo ? interactive.onTodo : undefined,
     });
   } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
     return;
   }
   pi.sendMessage({ customType: "rlm-question", content: `[resume] ${header.rootPrompt}`, display: true });
@@ -140,7 +176,7 @@ async function executeRlmRunWithResume(
     const result = await done;
     pi.sendMessage({ customType: "rlm-answer", content: result.answer, display: true });
   } catch (e) {
-    ctx.ui.notify(`RLM resume failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+    ctx.ui.notify(`RLM resume failed: ${errorMessage(e)}`, "error");
   } finally {
     clearRlmStatus(ctx.ui);
     ctx.ui.setWidget?.("rlm-status", undefined);

package/src/config/settings.ts

@@ -30,6 +30,19 @@ function validateString(v: unknown): string | undefined {
   return typeof v === "string" && v.trim() ? v : 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` and `max` are
+ * NOT ThinkingLevels — a hand-edited rlm.json carrying one is dropped, not forwarded.
+ */
+const THINKING_LEVELS: Readonly<Record<ThinkingLevel, true>> = Object.freeze({
+  minimal: true, low: true, medium: true, high: true, xhigh: true,
+});
+
+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>;
@@ -83,7 +96,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (compactionThresholdPct !== undefined && compactionThresholdPct <= 1) out.compactionThresholdPct = compactionThresholdPct;
   const python = validateString(r.python);
   if (python !== undefined) out.python = python;
-  if (typeof r.smartReasoning === "string") out.smartReasoning = r.smartReasoning as ThinkingLevel;
+  const smartReasoning = validateThinkingLevel(r.smartReasoning);
+  if (smartReasoning !== undefined) out.smartReasoning = smartReasoning;
   const subSystemPrompt = validateString(r.subSystemPrompt);
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
   const runLog = validateRunLog(r.runLog);
@@ -103,7 +117,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
     if (maxTokensValue !== undefined) sampling.maxTokens = maxTokensValue;
     const temperature = validateNumber(ss.temperature, 0);
     if (temperature !== undefined) sampling.temperature = temperature;
-    if (typeof ss.reasoning === "string") sampling.reasoning = ss.reasoning as ThinkingLevel;
+    const ssReasoning = validateThinkingLevel(ss.reasoning);
+    if (ssReasoning !== undefined) sampling.reasoning = ssReasoning;
     out.subSampling = sampling;
   }
   if (typeof r.rootSampling === "object" && r.rootSampling !== null) {
@@ -113,7 +128,8 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
     if (rsMaxTokens !== undefined) rootSampling.maxTokens = rsMaxTokens;
     const rsTemperature = validateNumber(rs.temperature, 0);
     if (rsTemperature !== undefined) rootSampling.temperature = rsTemperature;
-    if (typeof rs.reasoning === "string") rootSampling.reasoning = rs.reasoning as ThinkingLevel;
+    const rsReasoning = validateThinkingLevel(rs.reasoning);
+    if (rsReasoning !== undefined) rootSampling.reasoning = rsReasoning;
     out.rootSampling = Object.freeze(rootSampling);
   }
   return out;
@@ -166,3 +182,17 @@ export function resolveModelId(registry: ModelRegistry, ref?: string): Model<Api
 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;
+}

package/src/context/library-context.ts

@@ -1,30 +1,211 @@
 /**
  * Resolve load_library(source) into a sandbox-ready payload.
  *
- * Sources: local directory (repomix-packed), single file (utf-8 string), or
- * remote git URL (shallow clone then pack). Host-side only — never runs in the sandbox.
+ * Sources: local directory (repomix-packed), single file (utf-8), or remote git URL
+ * (shallow clone then pack). Host-side only — never runs in the sandbox.
+ *
+ * Every successful payload is a namespaced list of ContextFile under
+ * `lib/<source_id>/…` so the worker can append into the single `context` variable.
+ * Source ids include a short content fingerprint so two libraries that share a
+ * basename never collide.
  */
 
+import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { basename, isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { packRepository, serializeForSandbox, type ContextBundle } from "./repomix-context.ts";
+import {
+  packRepository,
+  serializeForSandbox,
+  type ContextBundle,
+  type ContextFile,
+} from "./repomix-context.ts";
+import { estimateTokens } from "../text/tokens.ts";
 import type { Result } from "../util/errors.ts";
 import { errorMessage } from "../util/errors.ts";
 
 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. */
+const LEGACY_UNKNOWN_PREFIX = "lib/unknown/";
+
 export interface LibrarySource {
-  readonly payload: unknown;     // str for a single file; ContextFile[] for a packed dir/repo
-  readonly files?: number;       // undefined for single-file payloads
+  /** Always a namespaced file list (dirs, single files, and git clones). */
+  readonly payload: readonly ContextFile[];
+  readonly files: number;
+  /** Sum of raw content lengths — what the model should size batches against. */
   readonly chars: number;
+  readonly sourceId: string;
+  readonly pathPrefix: string;
+}
+
+export interface LibraryNamespace {
+  readonly sourceId: string;
+  readonly pathPrefix: string;
 }
 
 /** https://host/… or git@host:… — option-injection safe (never starts with "-"). */
 const GIT_URL = /^(https:\/\/|git@)[\w.-]+[:/]\S+$/;
 
+/** Short, stable discriminator so two sources never share a namespace. */
+function sourceFingerprint(canonical: string): string {
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 8);
+}
+
+/**
+ * Sanitize a path/url basename into a stable, filesystem-safe source id.
+ * `resolvedPath` (absolute path) or the git URL is fingerprinted into the id so
+ * distinct sources sharing a basename get distinct namespaces
+ * (`lib/utils-3f9a1c02/` vs `lib/utils-a1b2c3d4/`).
+ */
+export function librarySourceId(source: string, resolvedPath?: string): string {
+  const trimmed = source.trim();
+  const isGit = GIT_URL.test(trimmed);
+  let raw: string;
+  if (isGit) {
+    const m = trimmed.match(/(?:\/|:)([\w.-]+?)(?:\.git)?\/?\s*$/);
+    raw = m?.[1] ?? "repo";
+  } else {
+    raw = basename(resolvedPath ?? trimmed);
+  }
+  const cleaned = raw
+    .replace(/\.git$/i, "")
+    .replace(/[^\w.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80);
+  const canonical = isGit ? trimmed : (resolvedPath ?? trimmed);
+  return `${cleaned.length > 0 ? cleaned : "lib"}-${sourceFingerprint(canonical)}`;
+}
+
+export function pathPrefixFor(sourceId: string): string {
+  return `lib/${sourceId}/`;
+}
+
+/**
+ * Derive the namespace for a source string without packing (host-side idempotency).
+ * Returns both sourceId and pathPrefix so callers never un-parse the prefix.
+ */
+export function libraryNamespace(source: string, cwd: string): LibraryNamespace {
+  const trimmed = source.trim();
+  const sourceId = GIT_URL.test(trimmed)
+    ? librarySourceId(trimmed)
+    : librarySourceId(trimmed, isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed));
+  return Object.freeze({ sourceId, pathPrefix: pathPrefixFor(sourceId) });
+}
+
+/** Derive the path prefix for a source string without packing. */
+export function libraryPathPrefix(source: string, cwd: string): string {
+  return libraryNamespace(source, cwd).pathPrefix;
+}
+
+/** Namespaced files plus summed content chars (one pass). */
+export function namespaceLibraryFilesWithChars(
+  payload: unknown,
+  sourceId: string,
+): { readonly files: readonly ContextFile[]; readonly chars: number } {
+  const prefix = pathPrefixFor(sourceId);
+  if (typeof payload === "string") {
+    return Object.freeze({
+      files: Object.freeze([
+        Object.freeze({
+          path: `${prefix}content`,
+          content: payload,
+          tokens: Math.max(1, estimateTokens(payload.length)),
+        }),
+      ]),
+      chars: payload.length,
+    });
+  }
+  if (!Array.isArray(payload)) return Object.freeze({ files: Object.freeze([]), chars: 0 });
+  const out = new Array<ContextFile>(payload.length);
+  let n = 0;
+  let chars = 0;
+  for (const item of payload) {
+    if (item === null || typeof item !== "object") continue;
+    const rec = item as Record<string, unknown>;
+    const content = typeof rec.content === "string" ? rec.content : String(rec.content ?? "");
+    let path = typeof rec.path === "string" ? rec.path : "unknown";
+    path = path.replace(/^\/+/, "");
+    if (!path.startsWith(prefix)) path = `${prefix}${path}`;
+    const tokens = typeof rec.tokens === "number" && Number.isFinite(rec.tokens)
+      ? Math.max(0, Math.floor(rec.tokens))
+      : Math.max(1, estimateTokens(content.length));
+    out[n++] = Object.freeze({ path, content, tokens });
+    chars += content.length;
+  }
+  out.length = n;
+  return Object.freeze({ files: Object.freeze(out), chars });
+}
+
+/** Namespace file entries under `lib/<sourceId>/…` (single shared implementation). */
+export function namespaceLibraryFiles(
+  payload: unknown,
+  sourceId: string,
+): readonly ContextFile[] {
+  return namespaceLibraryFilesWithChars(payload, sourceId).files;
+}
+
+/** 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];
+  }
+  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).
+ */
+export function mergeLibraryIntoContext(base: unknown, libraryPayload: unknown): unknown {
+  if (!Array.isArray(base)) return base;
+  if (Array.isArray(libraryPayload)) {
+    if (libraryPayload.length === 0) return base;
+    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 merged = new Array<unknown>(base.length + libraryPayload.length);
+    for (let i = 0; i < base.length; i++) merged[i] = base[i];
+    for (let i = 0; i < libraryPayload.length; i++) merged[base.length + i] = libraryPayload[i];
+    return merged;
+  }
+  if (typeof libraryPayload === "string") {
+    // Legacy string sidecars: wrap once under an unknown prefix.
+    return mergeLibraryIntoContext(base, namespaceLibraryFiles(libraryPayload, "unknown"));
+  }
+  return base;
+}
+
+function toLibrarySource(payload: unknown, sourceId: string): LibrarySource {
+  const { files, chars } = namespaceLibraryFilesWithChars(payload, sourceId);
+  return {
+    payload: files,
+    files: files.length,
+    chars,
+    sourceId,
+    pathPrefix: pathPrefixFor(sourceId),
+  };
+}
+
 export async function resolveLibrarySource(
   source: string,
   cwd: string,
@@ -43,34 +224,40 @@ export async function resolveLibrarySource(
   } catch {
     return { ok: false, error: `load_library: path not found: ${path}` };
   }
-  if (s.isDirectory()) return await packDir(path, signal);
+  const sourceId = librarySourceId(trimmed, path);
+  if (s.isDirectory()) return await packDir(path, sourceId, signal);
+  if (s.size > MAX_LIBRARY_FILE_BYTES) {
+    return {
+      ok: false,
+      error: `load_library: ${path} is ${s.size.toLocaleString()} bytes `
+        + `(limit ${MAX_LIBRARY_FILE_BYTES.toLocaleString()}) — `
+        + "open() it in the REPL and delegate with llm_query_chunked instead",
+    };
+  }
   const text = await readFile(path, "utf-8");
-  return { ok: true, value: { payload: text, chars: text.length } };
+  return { ok: true, value: toLibrarySource(text, sourceId) };
 }
 
-async function packDir(dir: string, signal?: AbortSignal): Promise<Result<LibrarySource, string>> {
-  const packed = await packRepository(dir, signal);       // repomix + existing per-path cache
+async function packDir(
+  dir: string,
+  sourceId: string,
+  signal?: AbortSignal,
+): Promise<Result<LibrarySource, string>> {
+  const packed = await packRepository(dir, signal);
   if (!packed.ok) return { ok: false, error: `pack failed for ${dir} — ${packed.error}` };
-  return { ok: true, value: bundleToSource(packed.value) };
+  return { ok: true, value: bundleToSource(packed.value, sourceId) };
 }
 
-function bundleToSource(bundle: ContextBundle): LibrarySource {
-  const payload = serializeForSandbox(bundle);
-  // Match slot-0 contextLength for object/array payloads: JSON-serialized size,
-  // not sum-of-content-lengths (bundle.totalChars), so the model sees one ruler.
-  return {
-    payload,
-    files: bundle.totalFiles,
-    chars: JSON.stringify(payload).length,
-  };
+function bundleToSource(bundle: ContextBundle, sourceId: string): LibrarySource {
+  return toLibrarySource(serializeForSandbox(bundle), sourceId);
 }
 
 async function cloneAndPack(url: string, signal?: AbortSignal): Promise<Result<LibrarySource, string>> {
   const dir = await mkdtemp(join(tmpdir(), "rlm-lib-"));
+  const sourceId = librarySourceId(url);
   try {
-    // "--" terminates options; URL regex already forbids a leading dash.
     await execFileP("git", ["clone", "--depth", "1", "--", url, dir], { signal, timeout: 120_000 });
-    return await packDir(dir, signal);
+    return await packDir(dir, sourceId, signal);
   } catch (err: unknown) {
     return { ok: false, error: `git clone failed for ${url} — ${errorMessage(err)}` };
   } finally {

package/src/context/repomix-context.ts

@@ -5,15 +5,17 @@
  *
  * Uses repomix internally (worker-thread pool, built-in gitignore support)
  * and caches results in a module-level Map with TTL to avoid re-packing on
- * every run within the same process. `patchContextAfterEdits` updates the
- * cached bundle in-memory after file edits are applied to disk — no re-packing.
+ * every run within the same process.
  */
 
 import { pack } from "repomix";
 import type { PackResult as RepomixPackResult } from "repomix";
+/** repomix's own config parameter type — `satisfies` keeps the literal checked against it. */
+type PackConfig = NonNullable<Parameters<typeof pack>[1]>;
 import { resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { errorMessage } from "../util/errors.ts";
+import { estimateTokens } from "../text/tokens.ts";
 
 // ── Public types ──
 
@@ -52,11 +54,6 @@ interface CacheEntry {
 const cache = new Map<string, CacheEntry>();
 const DEFAULT_CACHE_TTL_MS = 30_000;
 
-/** Exported for tests — empties the module-level cache. */
-export function clearCache(): void {
-  cache.clear();
-}
-
 function cacheKey(cwd: string): string {
   return resolve(cwd);
 }
@@ -77,8 +74,6 @@ function cacheSet(key: string, bundle: ContextBundle): void {
 
 // ── Core functions ──
 
-const ESTIMATED_CHARS_PER_TOKEN = 4;
-
 export async function packRepository(
   cwd: string,
   signal?: AbortSignal,
@@ -134,7 +129,7 @@ export async function packRepository(
         },
         security: { enableSecurityCheck: false },
         tokenCount: { encoding: "o200k_base" as const },
-      } as Parameters<typeof pack>[1]),
+      } satisfies PackConfig),
       new Promise<never>((_, reject) => {
         signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
       }),
@@ -148,8 +143,7 @@ export async function packRepository(
 
     for (let i = 0; i < processedFiles.length; i++) {
       const file = processedFiles[i];
-      const tokens = tokenCounts[file.path]
-        ?? Math.ceil(file.content.length / ESTIMATED_CHARS_PER_TOKEN);
+      const tokens = tokenCounts[file.path] ?? estimateTokens(file.content.length);
       files[i] = { path: file.path, content: file.content, tokens };
       totalTokens += tokens;
       totalChars += file.content.length;
@@ -172,42 +166,6 @@ export async function packRepository(
   }
 }
 
-export function patchContextAfterEdits(
-  cached: ContextBundle,
-  edits: readonly { readonly path: string; readonly newContent: string }[],
-): ContextBundle {
-  const editMap = new Map<string, string>();
-  for (const edit of edits) {
-    editMap.set(edit.path, edit.newContent);
-  }
-
-  const files = new Array<ContextFile>(cached.files.length);
-  let totalTokens = 0;
-  let totalChars = 0;
-
-  for (let i = 0; i < cached.files.length; i++) {
-    const file = cached.files[i];
-    const newContent = editMap.get(file.path);
-    if (newContent !== undefined) {
-      const tokens = Math.ceil(newContent.length / ESTIMATED_CHARS_PER_TOKEN);
-      files[i] = { path: file.path, content: newContent, tokens };
-      totalTokens += tokens;
-      totalChars += newContent.length;
-    } else {
-      files[i] = file;
-      totalTokens += file.tokens;
-      totalChars += file.content.length;
-    }
-  }
-
-  return {
-    files,
-    totalFiles: files.length,
-    totalTokens,
-    totalChars,
-  };
-}
-
 export function serializeForSandbox(
   bundle: ContextBundle,
 ): readonly ContextFile[] {
@@ -243,13 +201,4 @@ export function formatForLLM(bundle: ContextBundle): string {
   ].join("\n");
 }
 
-export function patchCachedContext(
-  cwd: string,
-  edits: readonly { readonly path: string; readonly newContent: string }[],
-): void {
-  const key = cacheKey(cwd);
-  const entry = cache.get(key);
-  if (!entry) return;
-  const patched = patchContextAfterEdits(entry.bundle, edits);
-  cache.set(key, { bundle: patched, ts: entry.ts });
-}
+

package/src/core/answer.ts

@@ -1,6 +1,6 @@
 /** Helpers for detecting and formatting the RLM final answer from a turn's REPL results. */
 
-import type { ProposedEdit, ReplResult } from "../sandbox/protocol.ts";
+import type { ReplResult } from "../sandbox/protocol.ts";
 import { truncateOutput } from "../text/parsing.ts";
 
 /** First non-null final answer across a turn's executed blocks, or null. */
@@ -18,15 +18,6 @@ export function latestAnswerContentOf(results: readonly ReplResult[]): string |
   return null;
 }
 
-/** Last cumulative legacy anchor proposed-edit set reported by a turn. */
-export function collectEdits(results: readonly ReplResult[]): ProposedEdit[] {
-  for (let i = results.length - 1; i >= 0; i--) {
-    const edits = results[i]?.edits;
-    if (edits && edits.length > 0) return [...edits];
-  }
-  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);
@@ -46,13 +37,14 @@ export function formatReplOutputs(results: readonly ReplResult[], skippedBlocks
     return "No ```repl``` block found in your response. Write one to interact with the REPL.";
   }
   const multi = results.length > 1;
-  const parts: string[] = [];
+  const parts = new Array<string>(results.length);
   let hadElision = false;
-  for (const [i, r] of results.entries()) {
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
     const head = multi ? `[block ${i + 1}]\n` : "";
     const { text, elided } = formatStdout(r);
     hadElision ||= elided;
-    parts.push(`${head}${text}${formatStderr(r)}`);
+    parts[i] = `${head}${text}${formatStderr(r)}`;
   }
   const body = parts.join("\n\n");
   const skipNote = skippedBlocks > 0

package/src/core/artifacts.ts

@@ -6,6 +6,7 @@ import { execFileSync } from "node:child_process";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Result } from "../util/errors.ts";
+import { errorMessage } from "../util/errors.ts";
 
 export const ARTIFACTS_DIR = ".rlm/artifacts";
 
@@ -59,7 +60,7 @@ export function captureGoal(cwd: string, brief: string): GoalCaptureResult {
     writeFileSync(join(cwd, baselinePath), JSON.stringify({ paths }, null, 2), "utf-8");
     return { ok: true, value: { goalPath, baselinePath } };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = errorMessage(err);
     return { ok: false, error: message };
   }
 }
@@ -72,7 +73,7 @@ export function saveArtifact(cwd: string, dir: string, slug: string, content: st
     writeFileSync(join(cwd, rel), content, "utf-8");
     return { ok: true, path: rel };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = errorMessage(err);
     return { ok: false, error: message };
   }
 }
@@ -82,7 +83,7 @@ export function readArtifact(cwd: string, relPath: string): Result<string, strin
   try {
     return { ok: true, value: readFileSync(join(cwd, relPath), "utf-8") };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = errorMessage(err);
     return { ok: false, error: `could not read artifact ${relPath}: ${message}` };
   }
 }