@hicaru/pi-rlm 0.2.2 → 0.3.1

package/README.md

@@ -59,9 +59,9 @@ sub-LLM calls, hence the name.
 - A **root orchestrator** model drives a **persistent Python REPL** turn-by-turn.
 - Long-context work is **delegated** to cheap worker models via `llm_query` / `llm_query_batched`.
 - Hard sub-problems **recurse** into child RLMs via `rlm_query` (depth-capped). A child inherits
-  its parent's `context` — the repository plus every library loaded with `load_library()` — so it
-  runs the same retrieval primitives over the same paths. Inheritance costs no extra tokens: the
-  content lives in the sandbox, and only a size line reaches the model.
+  its parent's `context` — every file loaded so far, including sources added with `add_context()` —
+  so it runs the same retrieval primitives over the same paths. Inheritance costs no extra tokens:
+  the content lives in the sandbox, and only a size line reaches the model.
 - Everything runs **in-process** — the only external process is one local `python3` worker.
 
 > This is a Pi-plugin reimplementation of the RLM method (see the [RLM paper](https://arxiv.org/abs/2512.24601)).
@@ -109,33 +109,36 @@ These functions are injected into the model's Python namespace inside the REPL:
 
 | Function | Signature | Description |
 |---|---|---|
-| `context` | `list[dict]` | Repository packed as `[{"path","content","tokens"}, ...]` — the full codebase |
+| `context` | `list[dict]` | Loaded files as `[{"path","content","tokens"}, …]` — starts empty; cwd seeds on first `repl()` |
 | `llm_query` | `(prompt, model=None) -> str` | One-shot sub-LLM call (worker model) |
 | `llm_query_batched` | `(prompts, model=None) -> list[str]` | Concurrent sub-LLM calls (pool-bounded) |
 | `llm_query_chunked` | `(text, prompt, model=None) -> list[str]` | Split large text into cap-sized chunks and fan out via sub-LLMs |
 | `rlm_query` | `(prompt, model=None, paths=None) -> str` | Recursive child RLM with its own sandbox (depth-capped). Inherits your `context`; `paths` narrows it by prefix |
 | `rlm_query_batched` | `(prompts, model=None, paths=None) -> list[str]` | Concurrent recursive child RLMs, sharing one `paths` slice |
-| `load_library` | `(source) -> dict \| str` | Append an external dir, file, or git URL into `context` under `lib/<id>/` |
+| `add_context` | `(source) -> dict \| str` | Append a dir, file, document, or git URL into `context` under `ctx/<id>/` |
 | `SHOW_VARS` | `() -> str` | List currently defined variables & their types |
 | `answer` | `dict` | Set `answer["content"]=...; answer["ready"]=True` to finalize |
 
-### Loading external libraries
+### Adding context
 
-When the task needs an **external library, another source tree, or standalone docs** that are
-not in the packed repo `context`, the model calls `load_library(source)` mid-run:
+`context` starts empty. The working directory seeds automatically on the first `repl()` call
+(un-prefixed paths so `search()` hits remain real paths for `edit`/`write`). For an **external
+tree, document, or git URL**, call `add_context(source)`:
 
 ```python
-info = load_library("../some-lib")                # local directory → packed + appended
-info = load_library("docs/api.md")                # single file → one entry in context
-info = load_library("https://github.com/x/y.git") # shallow clone, then pack + append
-# Files land in the SAME `context` list under lib/<source_id>/…
-# info == {"source_id", "path_prefix", "files", "chars", "context_len", "already_loaded", …}
+info = add_context("../some-lib")                # local directory → packed + appended
+info = add_context("docs/api.md")                # single file → one entry in context
+info = add_context("report.pdf")                 # document → Markdown, then appended
+info = add_context("https://github.com/x/y.git") # shallow clone, then pack + append
+# Files land in the SAME `context` list under ctx/<source_id>/…
+# info == {"source_id", "path_prefix", "files", "chars", "context_len", "already_loaded", "converted", "skipped", …}
 lib = [f for f in context if f["path"].startswith(info["path_prefix"])]
 ```
 
 There is no `context_1` / `context_2` — only `context`. Paths are namespaced so multiple
-libraries do not collide. Toggle via `/rlm-config` → **Library loader** (`libraryLoader`,
-default on). A library loaded at any point is inherited by every child spawned afterwards.
+sources do not collide. Toggle via `/rlm-config` → **Context loader** (`contextLoader`,
+default on) and **Auto-seed cwd** (`autoSeedCwd`, default on). A source loaded at any point is
+inherited by every child spawned afterwards.
 
 ## Settings (`/rlm-config`)
 
@@ -155,13 +158,32 @@ default on). A library loaded at any point is inherited by every child spawned a
 | Trajectory compaction | on (0.65) | summarize old turns when history nears the context window |
 | Root model output cap (tok) | `16384` | max output tokens per root-model turn |
 | Sandbox init timeout | `30000` ms | how long to wait for the Python worker to start |
-| Library loader | on | expose `load_library()` for external dirs/files/git repos |
+| Context loader | on | expose `add_context()` for external dirs/files/documents/git repos |
+| Auto-seed cwd | on | seed the working directory into `context` on the first `repl()` |
 
 > **Concurrency note:** each `rlm_query` child spawns its own `python3` worker (~50–150 ms
 > cold start). Children are bounded separately (`maxConcurrentChildren`, default 6) because
 > each holds a full Python process and its own copy of the inherited context. Error and
 > wall-clock caps (above) still bound a runaway tree.
 
+## Subagents and environment
+
+RLM never confiscates native file tools (`read` / `grep` / bash readers) unless `repl` is in
+the **active** tool set — the paper's trade is all-or-nothing. Process-boundary subagents that
+spawn pi with a `--tools` allowlist without `repl` therefore keep ordinary file access.
+
+Optional env conventions (for packages that want an explicit full bypass):
+
+| Env | Meaning |
+|---|---|
+| `PI_SUBAGENT_CHILD=1` | Full RLM bypass in this process (no tools / hooks / flags). |
+| `PI_RLM_FORCE_IN_SUBAGENT=1` | Experimental: opt a child back into RLM. **Consumed on activate** (not inherited after). Refused when `PI_RLM_DEPTH >= maxDepth`. |
+| `PI_RLM_DEPTH` | Cross-process depth counter (default `0`). Bumped when force-in activates. |
+
+In-process recursion (`rlm_query`) still uses `maxDepth` from `/rlm-config` and is unrelated to
+these env vars. Set `RLM_TRACE_FILE` to a path for JSONL traces of bypass / force / block-skip
+decisions.
+
 ## Security
 
 - **Key isolation**: provider keys live only in TypeScript (`AuthStorage`); the sandbox

package/README.ru.md

@@ -35,7 +35,7 @@
 - Работа с длинным контекстом **делегируется** дешевым worker-моделям через `llm_query` / `llm_query_batched`.
 - Сложные подзадачи **рекурсивно** передаются в дочерние RLM через `rlm_query` (с ограничением глубины).
   Дочерний RLM наследует `context` родителя — репозиторий и все библиотеки, загруженные через
-  `load_library()`, — и работает с теми же путями. Наследование не стоит дополнительных токенов:
+  `add_context()`, — и работает с теми же путями. Наследование не стоит дополнительных токенов:
   содержимое живёт в песочнице, модель видит только строку с размером.
 - Все работает **in-process** — единственным внешним процессом является локальный worker `python3`.
 
@@ -154,7 +154,7 @@ src/
   text/       parsing (repl blocks) · tokens · preview
   tool/       repl-tool · repl-result · repl-render · rlm-tool · rlm-events · rlm-aggregator · subcall-store · background-tasks
   config/     defaults · settings (rlm.json persistence + validation)
-  context/    repomix repository packing + library context merge
+  context/    native walker + anydoc document conversion + add_context
   ui/         status · model-picker · config-panel · intro · theme
   commands/   rlm · rlm-config
   mode/       rlm-mode (controller) · worker-model (cheapest pick) · native-guards

package/README.zh-CN.md

@@ -34,7 +34,7 @@
 - **根编排器**模型逐轮驱动一个**持久化的 Python REPL**。
 - 长上下文工作通过 `llm_query` / `llm_query_batched` **委派**给廉价的工作模型。
 - 困难的子问题通过 `rlm_query` **递归**到子 RLM 中（设有深度限制）。子 RLM 继承父级的 `context`
-  ——仓库以及通过 `load_library()` 加载的所有库——因此可以在相同的路径上使用相同的检索原语。
+  ——已加载的文件以及通过 `add_context()` 追加的来源——因此可以在相同的路径上使用相同的检索原语。
   继承不消耗额外的 token：内容存放在沙箱中，模型只看到一行大小信息。
 - 所有内容均**在进程内**运行 —— 唯一的外部进程是一个本地的 `python3` worker。
 
@@ -168,7 +168,7 @@ src/
   text/       parsing (repl blocks) · tokens · preview
   tool/       repl-tool · repl-result · repl-render · rlm-tool · rlm-events · rlm-aggregator · subcall-store · background-tasks
   config/     defaults · settings (rlm.json persistence + validation)
-  context/    repomix repository packing + library context merge
+  context/    native walker + anydoc document conversion + add_context
   ui/         status · model-picker · config-panel · intro · theme
   commands/   rlm · rlm-config
   mode/       rlm-mode (controller) · worker-model (cheapest pick) · native-guards

package/package.json

@@ -1,23 +1,30 @@
 {
   "name": "@hicaru/pi-rlm",
-  "version": "0.2.2",
-  "type": "module",
-  "description": "Save 99% tokens, Recursive Language Model (RLM) for the Pi",
-  "license": "MIT",
+  "version": "0.3.1",
   "author": "hicaru",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/openzebra/rlm.pi.git"
   },
-  "homepage": "https://github.com/openzebra/rlm.pi",
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
   "bugs": {
     "url": "https://github.com/openzebra/rlm.pi/issues"
   },
+  "description": "Save 99% tokens, Recursive Language Model (RLM) for the Pi",
   "files": [
     "src/",
     "README.md",
     "LICENSE"
   ],
+  "homepage": "https://github.com/openzebra/rlm.pi",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -25,11 +32,7 @@
     "recursive",
     "ai-agent"
   ],
-  "scripts": {
-    "check": "tsc --noEmit",
-    "test": "bun run test/smoke.ts",
-    "prepublishOnly": "npm run check"
-  },
+  "license": "MIT",
   "pi": {
     "extensions": [
       "./src/index.ts"
@@ -38,16 +41,16 @@
   "publishConfig": {
     "access": "public"
   },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
-    "typebox": "*"
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "bun run test/smoke.ts",
+    "prepublishOnly": "npm run check"
   },
-  "dependencies": {
-    "repomix": "^1.15.0"
+  "type": "module",
+  "engines": {
+    "node": ">=20"
   },
-  "devDependencies": {
-    "typescript": "^5.0.0"
+  "dependencies": {
+    "@firecrawl/anydoc": "^0.1.7"
   }
 }

package/src/bridge/add-context.ts

@@ -0,0 +1,322 @@
+/**
+ * Shared add_context handler for headless engine and native repl() mode.
+ *
+ * Host packs the source via resolveSource (namespaced under ctx/<id>/) and returns the
+ * payload for the worker to append into the single `context` list.
+ *
+ * Idempotency is host-side:
+ *  - prefix set (ctx/<id>/) for external sources
+ *  - cwd seed: markSeededCwd + exact-path short-circuit for add_context(".")
+ *  - subpath of seed: short-circuit only when the live context already holds un-prefixed
+ *    entries under that relative path (gitignored subtrees still pack for real)
+ *
+ * Late-bound deps (getCwd / getEmitter) keep a single handler closure correct
+ * across native repl() calls — getOrCreate only installs handlers at spawn.
+ */
+
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { RlmEmitter } from "../tool/rlm-events.ts";
+import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
+import {
+  contextNamespace,
+  isContextFile,
+} from "../context/namespace.ts";
+import { resolveSource } from "../context/resolve.ts";
+import { previewText } from "../text/preview.ts";
+
+export interface AddContextBridgeOpts {
+  /** Fixed cwd (headless). Prefer getCwd when the sandbox outlives a single invocation. */
+  readonly cwd?: string;
+  /** Late-bound cwd (native mode — sandbox handlers outlive a single repl()). */
+  readonly getCwd?: () => string;
+  readonly emitter?: RlmEmitter;
+  /** Native mode: read the live emitter each call. */
+  readonly getEmitter?: () => RlmEmitter | null | undefined;
+  readonly parentId?: string;
+  readonly signal?: AbortSignal;
+  /** Prefixes already present in context — seeds host-side idempotency after a sandbox restart. */
+  readonly loadedPrefixes?: readonly string[];
+  /**
+   * The live context this sandbox holds. Read to refuse pre-flight exactly what the worker's
+   * `_append_context` would reject, before any prefix is committed.
+   */
+  readonly getContext?: () => unknown;
+  /**
+   * Post-load hook. The engine grows its live context here; native mode grows
+   * SandboxManager.contextPayload.
+   */
+  readonly onLoaded?: (payload: unknown) => void | Promise<void>;
+}
+
+export interface AddContextHandlerBundle {
+  readonly handlers: Pick<SubLlmHandlers, "addContext">;
+  /**
+   * Reset the loaded-prefix cache (call when the sandbox is
+   * discarded and will re-spawn).
+   *
+   * `keep` re-seeds the cache from the payload that will be replayed into the fresh worker.
+   * `loaded` is a CACHE of `contextPrefixesIn(context)` plus the cwd sentinel `""`, never
+   * independent state, so it may only be cleared by re-deriving it — clearing it outright
+   * would make the host re-clone a source the recreated worker already holds.
+   */
+  readonly reset: (keep?: readonly string[]) => void;
+  /**
+   * Register a prefix as already loaded without packing. Used by the cwd seed to plant the
+   * `""` sentinel so add_context of the same tree is a no-op.
+   */
+  readonly markLoaded: (prefix: string) => void;
+  /**
+   * Record the absolute path of the cwd seed. add_context(".") resolves to a ctx/<id>/
+   * namespace, not "", so the absolute-path check is the only reliable short-circuit.
+   */
+  readonly markSeededCwd: (absPath: string) => void;
+  /** Prefixes loaded in this sandbox lifetime (for tests). */
+  readonly loadedPrefixes: () => ReadonlySet<string>;
+  /** Absolute seeded cwd, if any (for tests). */
+  readonly seededCwd: () => string | undefined;
+}
+
+/**
+ * JS runtime kind → the Python type name worker.py reports, so both sides emit exactly one
+ * message for the same refusal. Covers every shape a context payload can take after JSON
+ * transport; anything else is a plain object, which `json.load` materializes as a dict.
+ */
+const PY_TYPE_NAME: Readonly<Record<string, string>> = Object.freeze({
+  string: "str", boolean: "bool", number: "int", bigint: "int", undefined: "None",
+});
+
+function pythonKindOf(value: unknown): string {
+  if (value === null) return "None"; // matches worker.py's `if ctx is not None else "None"`
+  return PY_TYPE_NAME[typeof value] ?? "dict";
+}
+
+/**
+ * Refusal messages shared with worker.py `_append_context`. The worker is the backstop; the host
+ * pre-flights the same two conditions so it never commits a prefix for an append that
+ * will be rejected. Keep the wording identical — a comment in worker.py points back here.
+ */
+const LIST_CONTEXT_REQUIRED = (kind: string): string =>
+  `add_context requires list context (file bundle); got ${kind}`;
+const NO_FILES_PRODUCED = "add_context produced no files";
+
+/** Absolute path with no trailing slash (except root). */
+function absKey(path: string): string {
+  const resolved = resolve(path);
+  return resolved.length > 1 && (resolved.endsWith("/") || resolved.endsWith("\\"))
+    ? resolved.slice(0, -1)
+    : resolved;
+}
+
+/**
+ * True when the live context already holds un-prefixed (cwd-seed) entries under `relPrefix`.
+ * Used so add_context("./src/context") does not double-load a subpath that the seed already
+ * has — without blocking genuinely-absent (gitignored) subtrees.
+ */
+function contextHasUnprefixedUnder(context: unknown, relPrefix: string): boolean {
+  if (!Array.isArray(context) || relPrefix === "") return false;
+  const clean = relPrefix.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (clean === "" || clean.startsWith("..")) return false;
+  const withSlash = `${clean}/`;
+  for (let i = 0; i < context.length; i++) {
+    const entry: unknown = context[i];
+    if (!isContextFile(entry)) continue;
+    // Only cwd-seed paths are un-prefixed; ctx/<id>/… is a different source.
+    if (entry.path.startsWith("ctx/")) continue;
+    if (entry.path === clean || entry.path.startsWith(withSlash)) return true;
+  }
+  return false;
+}
+
+function alreadyLoadedResult(
+  sourceId: string,
+  pathPrefix: string,
+): Awaited<ReturnType<SubLlmHandlers["addContext"]>> {
+  return {
+    payload: Object.freeze([]),
+    files: 0,
+    chars: 0,
+    sourceId,
+    pathPrefix,
+    alreadyLoaded: true,
+    documents: 0,
+    converted: 0,
+    skipped: Object.freeze([]),
+  };
+}
+
+export function buildAddContextHandler(opts: AddContextBridgeOpts): AddContextHandlerBundle {
+  /** Prefixes already loaded in this sandbox — mirrors the worker's context state. */
+  const loaded = new Set<string>(opts.loadedPrefixes ?? []);
+  /** Absolute path of the cwd seed, if autoSeedCwd planted one successfully. */
+  let seededCwdAbs: string | undefined;
+  return {
+    reset: (keep) => {
+      const seed = keep ?? opts.loadedPrefixes ?? [];
+      loaded.clear();
+      for (const prefix of seed) loaded.add(prefix);
+      // Do NOT clear seededCwdAbs — the payload is still on disk in the manager and will be
+      // replayed; the absolute-path short-circuit must keep working after a death-recreate.
+    },
+    markLoaded: (prefix) => { loaded.add(prefix); },
+    markSeededCwd: (absPath) => {
+      seededCwdAbs = absKey(absPath);
+      loaded.add(""); // cwd sentinel — payloadPrefix never sees un-prefixed files
+    },
+    loadedPrefixes: () => loaded,
+    seededCwd: () => seededCwdAbs,
+    handlers: {
+      async addContext(source, depth) {
+        const emitter = opts.getEmitter?.() ?? opts.emitter;
+        const cwd = opts.getCwd?.() ?? opts.cwd;
+        if (cwd === undefined || cwd === "") {
+          throw new Error("add_context: no cwd configured");
+        }
+        const id = emitter?.emitSubcallCreated({
+          kind: "tool", parentId: opts.parentId,
+          label: "add_context",
+          args: previewText(source, 80),
+          depth,
+        });
+        try {
+          // Pre-flight the worker's own refusal: a non-list context cannot be appended to, and
+          // committing a prefix for it would make the NEXT load lie with already_loaded.
+          const current = opts.getContext?.();
+          if (current !== undefined && !Array.isArray(current)) {
+            throw new Error(LIST_CONTEXT_REQUIRED(pythonKindOf(current)));
+          }
+
+          const trimmed = source.trim();
+          const isLocal = trimmed !== "" && !/^(https:\/\/|git@)/.test(trimmed)
+            && !/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed);
+          const candidate = isLocal
+            ? absKey(isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed))
+            : undefined;
+          const cwdAbs = absKey(cwd);
+
+          // ── Cwd seed short-circuit / recovery ──
+          // Exact cwd: if already seeded → no-op; if seed failed (sticky, no markSeededCwd)
+          // pack un-prefixed so paths stay edit/write-friendly.
+          if (candidate !== undefined && candidate === cwdAbs) {
+            if (seededCwdAbs !== undefined) {
+              if (id) {
+                emitter?.emitSubcallUpdated({
+                  id, status: "done", resultPreview: "already loaded (cwd seed)",
+                });
+              }
+              return alreadyLoadedResult("cwd", "");
+            }
+            // Recovery after failed seed (or autoSeedCwd off): pack as primary, un-prefixed.
+            const recovered = await resolveSource(source, {
+              cwd, pathPrefix: "", signal: opts.signal,
+            });
+            if (!recovered.ok) throw new Error(recovered.error);
+            const r = recovered.value;
+            if (r.payload.length === 0) throw new Error(NO_FILES_PRODUCED);
+            if (opts.onLoaded) await opts.onLoaded(r.payload);
+            seededCwdAbs = cwdAbs;
+            loaded.add("");
+            if (id) {
+              emitter?.emitSubcallUpdated({
+                id, status: "done",
+                resultPreview: `+${r.files} file(s) → context (cwd seed recovery, ${r.chars.toLocaleString()} chars)`,
+              });
+            }
+            return {
+              payload: r.payload,
+              files: r.files,
+              chars: r.chars,
+              sourceId: r.sourceId,
+              pathPrefix: "",
+              alreadyLoaded: false,
+              documents: r.documents,
+              converted: r.converted,
+              skipped: r.skipped,
+            };
+          }
+
+          // Subpath of the seeded cwd: only short-circuit when those files are already in
+          // context (un-prefixed). A gitignored subtree that the seed never had still packs.
+          if (candidate !== undefined && seededCwdAbs !== undefined
+            && candidate !== seededCwdAbs
+            && (candidate.startsWith(seededCwdAbs + sep) || candidate.startsWith(seededCwdAbs + "/"))) {
+            const rel = relative(seededCwdAbs, candidate).split(sep).join("/");
+            if (rel !== "" && !rel.startsWith("..") && contextHasUnprefixedUnder(current, rel)) {
+              if (id) {
+                emitter?.emitSubcallUpdated({
+                  id, status: "done",
+                  resultPreview:
+                    `already in cwd seed under '${rel}/' — filter context by path prefix`,
+                });
+              }
+              return alreadyLoadedResult("cwd", "");
+            }
+          }
+
+          // Cheap pre-check BEFORE cloning/packing: same namespace ⇒ nothing to do.
+          const { sourceId: preId, pathPrefix: prefix } = contextNamespace(source, cwd);
+          if (loaded.has(prefix)) {
+            if (id) {
+              emitter?.emitSubcallUpdated({
+                id,
+                status: "done",
+                resultPreview: `already loaded (${prefix}*)`,
+              });
+            }
+            return alreadyLoadedResult(preId, prefix);
+          }
+
+          const resolved = await resolveSource(source, { cwd, signal: opts.signal });
+          if (!resolved.ok) throw new Error(resolved.error);
+          const { payload, files, chars, sourceId, pathPrefix, documents, converted, skipped } =
+            resolved.value;
+          // The worker's other refusal, pre-flighted for the same reason.
+          if (payload.length === 0) throw new Error(NO_FILES_PRODUCED);
+
+          // Race: another concurrent load of the same prefix finished while we packed.
+          if (loaded.has(pathPrefix)) {
+            if (id) {
+              emitter?.emitSubcallUpdated({
+                id,
+                status: "done",
+                resultPreview: `already loaded (${pathPrefix}*)`,
+              });
+            }
+            return alreadyLoadedResult(sourceId, pathPrefix);
+          }
+
+          // Mark loaded only after the host has grown its own copy of the context.
+          if (opts.onLoaded) {
+            await opts.onLoaded(payload);
+          }
+          loaded.add(pathPrefix);
+
+          if (id) {
+            const docNote = documents > 0
+              ? `, ${documents} doc(s)${converted > 0 ? ` (${converted} fresh)` : " (cached)"}`
+              : "";
+            emitter?.emitSubcallUpdated({
+              id,
+              status: "done",
+              resultPreview:
+                `+${files} file(s) → context (${pathPrefix}*, ${chars.toLocaleString()} chars${docNote})`,
+            });
+          }
+          return {
+            payload,
+            files,
+            chars,
+            sourceId,
+            pathPrefix,
+            alreadyLoaded: false,
+            documents,
+            converted,
+            skipped,
+          };
+        } catch (err) {
+          if (id) emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
+          throw err;   // serviceInterrupt catch → {error} reply → "Error: …" in the REPL
+        }
+      },
+    },
+  };
+}

package/src/bridge/subcall-handlers.ts

@@ -20,7 +20,7 @@ import { displayModelRef, modelRef, resolveModelId } from "../config/settings.ts
 import { type ChatMsg, modelComplete } from "./model.ts";
 import { previewText } from "../text/preview.ts";
 import { checkResourceLimits } from "../core/resource-limits.ts";
-import { filterContextByPaths } from "../context/library-context.ts";
+import { filterContextByPaths } from "../context/merge.ts";
 import type { RlmInput, RlmResult, Sampling } from "../core/types.ts";
 import type { SubcallGates } from "../util/concurrency.ts";
 import type { SubcallOpts, SubLlmHandlers } from "../sandbox/sandbox.ts";

package/src/config/defaults.ts

@@ -26,7 +26,8 @@ export const DEFAULT_CONFIG: Readonly<RlmConfig> = Object.freeze({
   compactionThresholdPct: 0.65,
   python: "python3",
   sandboxInitTimeoutMs: 30_000,
-  libraryLoader: true,
+  contextLoader: true,
+  autoSeedCwd: true,
   rootSampling: Object.freeze({ maxTokens: 16_384 }),
   subSystemPrompt: DEFAULT_SUB_SYSTEM_PROMPT,
   subSampling: Object.freeze({ maxTokens: 8192 }),

package/src/config/settings.ts

@@ -84,8 +84,11 @@ function validateConfig(raw: unknown): Partial<RlmConfig> {
   if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
   const sandboxInitTimeoutMs = validateNumber(r.sandboxInitTimeoutMs, 100);
   if (sandboxInitTimeoutMs !== undefined) out.sandboxInitTimeoutMs = sandboxInitTimeoutMs;
-  const libraryLoader = validateBoolean(r.libraryLoader);
-  if (libraryLoader !== undefined) out.libraryLoader = libraryLoader;
+  // `libraryLoader` is the pre-rename key — still read so an existing rlm.json survives the upgrade.
+  const contextLoader = validateBoolean(r.contextLoader) ?? validateBoolean(r.libraryLoader);
+  if (contextLoader !== undefined) out.contextLoader = contextLoader;
+  const autoSeedCwd = validateBoolean(r.autoSeedCwd);
+  if (autoSeedCwd !== undefined) out.autoSeedCwd = autoSeedCwd;
   if (typeof r.subSampling === "object" && r.subSampling !== null) {
     const ss = r.subSampling as Record<string, unknown>;
     const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};

package/src/context/anydoc.ts

@@ -0,0 +1,67 @@
+/**
+ * Lazy NAPI handle for @firecrawl/anydoc.
+ *
+ * anydoc is a native addon with per-platform optionalDependencies (darwin x64/arm64,
+ * linux x64/arm64 gnu+musl, win32 x64 — NO win32-arm64). A static `import` on an uncovered
+ * platform is a plugin-load crash. So: import() once, memoised, catch → null. Absence is a
+ * value; documents degrade to skipped: "no-converter".
+ */
+
+/** Minimal surface we consume — never re-export the full anydoc package. */
+export interface AnydocHandle {
+  /** Detect document format from a path's extension; null for plain text / unknown. */
+  readonly formatFromPath: (path: string) => string | null;
+  /** Convert a document file to Markdown. Rejects with Error.code = ConvertErrorCode. */
+  readonly toMarkdown: (path: string) => Promise<string>;
+}
+
+/**
+ * Document container extensions anydoc knows about, including Office macro/variants.
+ * Used when the native addon is absent so we still route these to "no-converter"
+ * instead of reading them as broken binary text.
+ */
+const DOCUMENT_EXTENSIONS: ReadonlySet<string> = Object.freeze(new Set([
+  "doc", "docx", "docm", "odt", "rtf", "epub", "pdf",
+  "ppt", "pptx", "pptm", "ppsx", "odp",
+  "xls", "xlsx", "xlsm", "xlsb", "ods", "csv",
+]));
+
+/**
+ * Detect a document container from a path when the anydoc handle is unavailable.
+ * Returns a non-null token for known extensions so the router can skip as "no-converter".
+ */
+export function documentExtFromPath(path: string): string | null {
+  const base = path.includes("/") ? path.slice(path.lastIndexOf("/") + 1) : path;
+  const dot = base.lastIndexOf(".");
+  if (dot < 0) return null;
+  const ext = base.slice(dot + 1).toLowerCase();
+  return DOCUMENT_EXTENSIONS.has(ext) ? ext : null;
+}
+
+let cached: Promise<AnydocHandle | null> | undefined;
+
+/**
+ * Resolve the anydoc handle once per process. Returns null when the native addon is
+ * missing or fails to load — callers treat documents as skipped: "no-converter".
+ */
+export function getAnydoc(): Promise<AnydocHandle | null> {
+  cached ??= import("@firecrawl/anydoc")
+    .then((mod): AnydocHandle => Object.freeze({
+      formatFromPath: (p: string) => mod.formatFromPath(p),
+      toMarkdown: (p: string) => mod.toMarkdown(p),
+    }))
+    .catch(() => null);
+  return cached;
+}
+
+/**
+ * Test seam: force the next getAnydoc() call to return a fixed handle (or null).
+ * Pass `undefined` to restore the real lazy loader.
+ */
+export function setAnydocForTest(handle: AnydocHandle | null | undefined): void {
+  if (handle === undefined) {
+    cached = undefined;
+    return;
+  }
+  cached = Promise.resolve(handle);
+}