@hicaru/pi-rlm 0.2.1 → 0.3.0

package/src/ui/config-panel.ts

@@ -9,22 +9,19 @@ const CHOICES = Object.freeze({
   maxDepth: Object.freeze(["1", "2", "3", "4"]),
   maxIterations: Object.freeze(["10", "20", "30", "50"]),
   execTimeoutS: Object.freeze(["30", "60", "120", "300"]),
-  maxConcurrentSubcalls: Object.freeze(["2", "4", "8", "16"]),
-  maxBudgetUsd: Object.freeze(["none", "0.50", "1", "5"]),
+  maxConcurrentSubcalls: Object.freeze(["2", "4", "8", "16", "32"]),
+  maxConcurrentChildren: Object.freeze(["1", "2", "3", "4", "6", "8"]),
   maxTimeoutMs: Object.freeze(["none", "60", "120", "300"]),
   maxTokens: Object.freeze(["none", "10000", "50000", "100000"]),
   maxErrors: Object.freeze(["3", "5", "10", "none"]),
   orchestrator: Object.freeze(["on", "off"]),
-  pipeline: Object.freeze(["on", "off"]),
-  maxBackwardJumps: Object.freeze(["0", "1", "2", "3"]),
   compaction: Object.freeze(["on", "off"]),
   compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
   requestTimeoutMs: Object.freeze(["2", "5", "10", "20"]),
-  askUserQuestion: Object.freeze(["on", "off"]),
-  todo: Object.freeze(["on", "off"]),
-  libraryLoader: Object.freeze(["on", "off"]),
+  contextLoader: Object.freeze(["on", "off"]),
+  autoSeedCwd: Object.freeze(["on", "off"]),
 });
 
 function item(id: string, label: string, currentValue: string, values: readonly string[], description: string): SettingItem {
@@ -43,22 +40,20 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxIterations", "Max iterations", String(config.maxIterations), CHOICES.maxIterations, "Maximum root REPL turns before RLM asks the model for a final answer."),
     item("execTimeoutS", "REPL block timeout (s)", String(config.execTimeoutS), CHOICES.execTimeoutS, "Wall-clock limit for one model-authored Python REPL block."),
     item("maxConcurrentSubcalls", "Max concurrent sub-calls", String(config.maxConcurrentSubcalls), CHOICES.maxConcurrentSubcalls, "Concurrency pool size for llm_query_batched and rlm_query_batched."),
-    item("maxBudgetUsd", "Budget ceiling (USD)", config.maxBudgetUsd != null ? String(config.maxBudgetUsd) : "none", CHOICES.maxBudgetUsd, "Total spend cap for the whole recursive tree; none disables the cap."),
+    item("maxConcurrentChildren", "Max concurrent children", String(config.maxConcurrentChildren), CHOICES.maxConcurrentChildren, "Concurrent rlm_query child engines per depth. Each is a Python process holding its own copy of the inherited context."),
     item("maxTimeoutMs", "Wall-clock ceiling (min)", config.maxTimeoutMs != null ? String(Math.round(config.maxTimeoutMs / 60_000)) : "none", CHOICES.maxTimeoutMs, "Total runtime cap for the whole recursive tree; none disables the cap."),
     item("maxTokens", "Token ceiling", config.maxTokens != null ? String(config.maxTokens) : "none", CHOICES.maxTokens, "Total input+output token cap for the whole recursive tree."),
     item("maxErrors", "Max consecutive errors", config.maxErrors != null ? String(config.maxErrors) : "none", CHOICES.maxErrors, "Stop after this many consecutive failing turns; none disables the guard."),
     item("orchestrator", "Orchestrator addendum", config.orchestrator ? "on" : "off", CHOICES.orchestrator, "Append extra divide-and-conquer guidance to the root model system prompt."),
-    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable artifact-gated phases: clarify→research→blueprint→validate (read-only plan pipeline; clarify needs Ask user on)."),
-    item("maxBackwardJumps", "Max validate→blueprint loops", String(config.maxBackwardJumps), CHOICES.maxBackwardJumps, "Bounded corrective re-entries when validation reports blockers_count > 0."),
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
     item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "Compact once estimated history tokens reach this share of the root model's context window."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
     item("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
     item("requestTimeoutMs", "Sandbox request timeout (min)", String(Math.round(config.requestTimeoutMs / 60_000)), CHOICES.requestTimeoutMs, "Parent-side watchdog per sandbox request; on breach the Python worker is killed."),
-    item("askUserQuestion", "[Interactive] Ask user", config.askUserQuestion ? "on" : "off", CHOICES.askUserQuestion, "Allow root REPL code to present structured ask_user_question dialogs."),
-    item("todo", "[Interactive] Todo", config.todo ? "on" : "off", CHOICES.todo, "Allow REPL code to manage a visible todo task list."),
-    item("libraryLoader", "Library loader", config.libraryLoader ? "on" : "off", CHOICES.libraryLoader,
-      "Allow load_library() to pull an external dir, file, or git repo into the shared context list."),
+    item("contextLoader", "Context loader", config.contextLoader ? "on" : "off", CHOICES.contextLoader,
+      "Allow add_context() to pull an external dir, file, document, or git repo into context."),
+    item("autoSeedCwd", "Auto-seed cwd", config.autoSeedCwd ? "on" : "off", CHOICES.autoSeedCwd,
+      "Seed the working directory into context on the first repl() call (otherwise starts empty)."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 
@@ -101,22 +96,19 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
     case "maxIterations": return Object.freeze({ ...config, maxIterations: Number(value) });
     case "execTimeoutS": return Object.freeze({ ...config, execTimeoutS: Number(value) });
     case "maxConcurrentSubcalls": return Object.freeze({ ...config, maxConcurrentSubcalls: Number(value) });
-    case "maxBudgetUsd": return Object.freeze({ ...config, maxBudgetUsd: optionalNumber(value) });
+    case "maxConcurrentChildren": return Object.freeze({ ...config, maxConcurrentChildren: Number(value) });
     case "maxTimeoutMs": return Object.freeze({ ...config, maxTimeoutMs: optionalNumber(value, 60_000) });
     case "maxTokens": return Object.freeze({ ...config, maxTokens: optionalNumber(value) });
     case "maxErrors": return Object.freeze({ ...config, maxErrors: optionalNumber(value) });
     case "orchestrator": return Object.freeze({ ...config, orchestrator: value === "on" });
-    case "pipeline": return Object.freeze({ ...config, pipeline: value === "on" });
-    case "maxBackwardJumps": return Object.freeze({ ...config, maxBackwardJumps: Number(value) });
     case "compaction": return Object.freeze({ ...config, compaction: value === "on" });
     case "compactionThresholdPct": return Object.freeze({ ...config, compactionThresholdPct: Number(value) / 100 });
     case "rootSamplingMaxTokens":
       return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }) });
     case "sandboxInitTimeoutMs": return Object.freeze({ ...config, sandboxInitTimeoutMs: Number(value) });
     case "requestTimeoutMs": return Object.freeze({ ...config, requestTimeoutMs: Number(value) * 60_000 });
-    case "askUserQuestion": return Object.freeze({ ...config, askUserQuestion: value === "on" });
-    case "todo": return Object.freeze({ ...config, todo: value === "on" });
-    case "libraryLoader": return Object.freeze({ ...config, libraryLoader: value === "on" });
+    case "contextLoader": return Object.freeze({ ...config, contextLoader: value === "on" });
+    case "autoSeedCwd": return Object.freeze({ ...config, autoSeedCwd: value === "on" });
     default: return config;
   }
 }

package/src/ui/intro.ts

@@ -11,9 +11,8 @@ export const RLM_GUIDE = `# RLM mode
 ## Commands
 
 - \`/rlm\` — toggle RLM mode (shortcut: Ctrl+Shift+R). Turning it OFF also stops a running query.
-- \`/rlm-config\` — choose models, reasoning, and budget limits
+- \`/rlm-config\` — choose models, reasoning, and run limits
 - \`/rlm-stop\` — cancel the current run but stay in RLM mode (use /rlm or Ctrl+Shift+R to leave)
-- \`/rlm-help\` — show this guide again
 
 When RLM mode is ON, \`read\`/\`grep\` are disabled and the agent reads the repository through the
 \`repl\` tool, delegating bulk analysis to sub-LLMs. The footer/status line shows the current state.`;

package/src/ui/model-picker.ts

@@ -1,10 +1,11 @@
 /** Model picker TUI — choose a model and, when supported, a thinking level. */
 
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
 import { Container, type Component, type SelectItem, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { formatCost } from "./theme.ts";
+import { compareLlm } from "../mode/llm-model.ts";
 
 export interface ModelSelection {
   readonly model: Model<Api>;
@@ -16,15 +17,38 @@ type SelectableThinkingLevel = (typeof LEVELS)[number];
 
 const CHEAPEST_VALUE = "__rlm_cheapest__";
 
-function items(models: Model<Api>[], includeCheapest = false): SelectItem[] {
-  const modelItems = models.map((m) => ({
-    value: `${m.provider}/${m.id}`,
-    label: `${m.provider}/${m.id}`,
-    description: `in ${formatCost(m.cost.input)}/Mtok · out ${formatCost(m.cost.output)}/Mtok${m.reasoning ? " · reasoning" : ""}`,
-  }));
+/**
+ * Models Pi itself would offer for this session, cheapest-first.
+ *
+ * Mirrors the built-in model switcher:
+ *   - if the session has scoped models (`--models` / enabledModels) → those only
+ *   - else → `getAvailable()` (providers with configured auth)
+ *
+ * Deliberately NOT `getAll()`: the full catalog dumps every provider's catalog entry and is
+ * not what the user sees in Pi natively. See Pi extension docs on `ctx.scopedModels`.
+ */
+export function pickableModels(
+  registry: ModelRegistry,
+  scoped?: readonly { readonly model: Model<Api> }[],
+): readonly Model<Api>[] {
+  const source = scoped !== undefined && scoped.length > 0
+    ? scoped.map((s) => s.model)
+    : registry.getAvailable();
+  return [...source].sort(compareLlm);
+}
+
+function items(models: readonly Model<Api>[], includeCheapest: boolean): SelectItem[] {
+  const modelItems = models.map((m) => {
+    const price = `in ${formatCost(m.cost.input)}/Mtok · out ${formatCost(m.cost.output)}/Mtok`;
+    return {
+      value: `${m.provider}/${m.id}`,
+      label: `${m.provider}/${m.id}`,
+      description: `${price}${m.reasoning ? " · reasoning" : ""}`,
+    };
+  });
   if (!includeCheapest) return modelItems;
   return [
-    { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest available model" },
+    { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest model with a configured key" },
     ...modelItems,
   ];
 }
@@ -79,12 +103,12 @@ async function selectThinkingLevel(
 export async function selectModel(
   ctx: ExtensionContext,
   title: string,
-  models: Model<Api>[],
+  models: readonly Model<Api>[],
   current?: Model<Api>,
   currentThinking?: ThinkingLevel,
 ): Promise<ModelSelection | null | undefined> {
   if (models.length === 0) {
-    ctx.ui.notify("RLM: no models with configured auth", "warning");
+    ctx.ui.notify("RLM: no models available (add a provider key in Pi, or widen --models / enabledModels)", "warning");
     return undefined;
   }
   if (ctx.mode !== "tui") {

package/src/ui/status.ts

@@ -12,18 +12,14 @@ export function modelLabel(model: Model<Api> | undefined, fallback: string): str
 
 export function formatRlmStateLine(controller: RlmController, contextUsage?: ContextUsage): string {
   if (!controller.enabled) return "○ RLM OFF";
-  const worker = modelLabel(controller.workerModel, controller.savedWorkerRef ?? "cheapest");
-  const workerSuffix = controller.config.subSampling.reasoning ? `:${controller.config.subSampling.reasoning}` : "";
+  const llm = modelLabel(controller.llmModel, controller.savedLlmRef ?? "cheapest");
+  const llmSuffix = controller.config.subSampling.reasoning ? `:${controller.config.subSampling.reasoning}` : "";
   // `percent` is null right after a compaction, before the next assistant response reports usage.
   const percent = contextUsage?.percent;
   const ctxSuffix = percent === null || percent === undefined ? "" : ` · ctx ${Math.round(percent)}%`;
-  return `● RLM ON · worker=${worker}${workerSuffix}${ctxSuffix}`;
+  return `● RLM ON · llm=${llm}${llmSuffix}${ctxSuffix}`;
 }
 
 export function setRlmModeStatus(ui: ExtensionUIContext, controller: RlmController, contextUsage?: ContextUsage): void {
   ui.setStatus(KEY, formatRlmStateLine(controller, contextUsage));
 }
-
-export function clearRlmStatus(ui: ExtensionUIContext): void {
-  ui.setStatus(KEY, undefined);
-}

package/src/util/concurrency.ts

@@ -80,10 +80,14 @@ export interface SubcallGates {
 }
 
 /**
- * Worst case is `maxDepth × limit` concurrent child engines (each owning a Python
- * subprocess) plus `limit` leaf completions, so keep `limit` modest — see
- * DEFAULT_CONFIG.maxConcurrentSubcalls.
+ * Worst case is `(maxDepth - 1) × childLimit` concurrent child engines — the cap short-circuits
+ * at `childDepth >= maxDepth`, so engines exist at depths 1..maxDepth-1 — plus `leafLimit` leaf
+ * completions.
+ *
+ * Children get their own, smaller bound because they are far heavier than leaves: each owns a
+ * Python subprocess AND its own copy of the context it inherited from its parent, where a leaf
+ * is one HTTP request. See DEFAULT_CONFIG.maxConcurrentChildren.
  */
-export function createSubcallGates(limit: number): SubcallGates {
-  return Object.freeze({ leaf: new Semaphore(limit), rlm: new DepthGates(limit) });
+export function createSubcallGates(leafLimit: number, childLimit: number = leafLimit): SubcallGates {
+  return Object.freeze({ leaf: new Semaphore(leafLimit), rlm: new DepthGates(childLimit) });
 }

package/src/bridge/fallback-todo.ts

@@ -1,148 +0,0 @@
-import { formatError } from "../util/errors.ts";
-
-type TaskStatus = "pending" | "in_progress" | "completed" | "deleted";
-
-interface Task {
-  readonly id: number;
-  readonly subject: string;
-  readonly description?: string;
-  readonly status: TaskStatus;
-  readonly activeForm?: string;
-  readonly blockedBy?: readonly number[];
-  readonly owner?: string;
-}
-
-interface TodoParams {
-  readonly id?: number;
-  readonly subject?: string;
-  readonly description?: string;
-  readonly status?: TaskStatus;
-  readonly activeForm?: string;
-  readonly blockedBy?: readonly number[];
-  readonly addBlockedBy?: readonly number[];
-  readonly removeBlockedBy?: readonly number[];
-  readonly owner?: string;
-  readonly filterStatus?: string;
-  readonly includeDeleted?: boolean;
-}
-
-const TODO_STATUSES = Object.freeze(new Set<unknown>(["pending", "in_progress", "completed", "deleted"]));
-
-function isTaskStatus(value: unknown): value is TaskStatus {
-  return TODO_STATUSES.has(value);
-}
-
-function numericArray(value: unknown): readonly number[] | undefined {
-  return Array.isArray(value) ? Object.freeze(value.filter((n): n is number => typeof n === "number")) : undefined;
-}
-
-function toTodoParams(raw: Record<string, unknown>): TodoParams {
-  const blockedBy = numericArray(raw.blockedBy);
-  const addBlockedBy = numericArray(raw.addBlockedBy);
-  const removeBlockedBy = numericArray(raw.removeBlockedBy);
-  return Object.freeze({
-    ...(typeof raw.id === "number" ? { id: raw.id } : {}),
-    ...(typeof raw.subject === "string" ? { subject: raw.subject } : {}),
-    ...(typeof raw.description === "string" ? { description: raw.description } : {}),
-    ...(isTaskStatus(raw.status) ? { status: raw.status } : {}),
-    ...(typeof raw.activeForm === "string" ? { activeForm: raw.activeForm } : {}),
-    ...(blockedBy ? { blockedBy } : {}),
-    ...(addBlockedBy ? { addBlockedBy } : {}),
-    ...(removeBlockedBy ? { removeBlockedBy } : {}),
-    ...(typeof raw.owner === "string" ? { owner: raw.owner } : {}),
-    ...(typeof raw.filterStatus === "string" ? { filterStatus: raw.filterStatus } : {}),
-    ...(raw.includeDeleted === true ? { includeDeleted: true } : {}),
-  });
-}
-
-function patchedBlockedBy(task: Task, params: TodoParams): readonly number[] | undefined {
-  if (params.blockedBy) return params.blockedBy;
-
-  let next = task.blockedBy ?? Object.freeze([] as readonly number[]);
-  if (params.addBlockedBy) next = Object.freeze([...next, ...params.addBlockedBy]);
-
-  if (params.removeBlockedBy) {
-    const removeSet = new Set(params.removeBlockedBy);
-    next = Object.freeze(next.filter((n) => !removeSet.has(n)));
-  }
-  return next.length ? next : undefined;
-}
-
-function taskLines(task: Task): readonly string[] {
-  const lines: string[] = [`#${task.id} [${task.status}] ${task.subject}`];
-  if (task.description) lines.push(`  description: ${task.description}`);
-  if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);
-  if (task.blockedBy?.length) lines.push(`  blockedBy: ${task.blockedBy.map((n) => `#${n}`).join(", ")}`);
-  if (task.owner) lines.push(`  owner: ${task.owner}`);
-  return lines;
-}
-
-function withPatch(task: Task, params: TodoParams): Task {
-  const blockedBy = patchedBlockedBy(task, params);
-  return Object.freeze({
-    ...task,
-    ...(params.subject !== undefined ? { subject: params.subject } : {}),
-    ...(params.description !== undefined ? { description: params.description } : {}),
-    ...(params.status !== undefined ? { status: params.status } : {}),
-    ...(params.activeForm !== undefined ? { activeForm: params.activeForm } : {}),
-    ...(blockedBy ? { blockedBy } : {}),
-    ...(params.owner !== undefined ? { owner: params.owner } : {}),
-  });
-}
-
-/** The actions `worker.py::_todo` documents. Anything else is a caller error, not a missing task. */
-const TODO_ACTIONS: ReadonlySet<string> = Object.freeze(new Set([
-  "create", "update", "list", "get", "delete", "clear",
-]));
-
-export function createTodoFallback(): (action: string, params: Record<string, unknown>) => Promise<string> {
-  let nextId = 1;
-  let tasks: readonly Task[] = Object.freeze([]);
-  const fmt = (task: Task): string => taskLines(task)[0] ?? `#${task.id}`;
-
-  const apply = (action: string, rawParams: Record<string, unknown>): string => {
-    // Validated BEFORE the id lookup below: an unknown action used to fall through to it and
-    // report "task #? not found", which reads as a missing task rather than a bad action.
-    if (!TODO_ACTIONS.has(action)) {
-      return formatError(`unknown todo action '${action}' — expected ${[...TODO_ACTIONS].join(", ")}`);
-    }
-    const params = toTodoParams(rawParams);
-    if (action === "clear") {
-      const count = tasks.length;
-      tasks = Object.freeze([]);
-      nextId = 1;
-      return `Cleared ${count} task(s).`;
-    }
-    if (action === "create") {
-      const subject = typeof params.subject === "string" && params.subject.trim() ? params.subject.trim() : undefined;
-      if (!subject) return formatError("create requires subject");
-      const task = withPatch(Object.freeze({ id: nextId, subject, status: "pending" }), params);
-      nextId += 1;
-      tasks = Object.freeze([...tasks, task]);
-      return `Created ${fmt(task)}`;
-    }
-    if (action === "list") {
-      const filter = params.filterStatus ?? params.status;
-      const includeDeleted = params.includeDeleted === true;
-      const rows = tasks.filter((task) => (includeDeleted || task.status !== "deleted") && (!filter || task.status === filter)).map(fmt);
-      return rows.length ? rows.join("\n") : "No tasks.";
-    }
-    const id = params.id;
-    const task = id !== undefined ? tasks.find((item) => item.id === id) : undefined;
-    if (!task) return formatError(`task #${id ?? "?"} not found`);
-    if (action === "get") return taskLines(task).join("\n");
-    if (action === "delete") {
-      const deleted = Object.freeze({ ...task, status: "deleted" as const });
-      tasks = Object.freeze(tasks.map((item) => item.id === task.id ? deleted : item));
-      return `Deleted ${fmt(deleted)}`;
-    }
-    if (action === "update") {
-      const updated = withPatch(task, params);
-      tasks = Object.freeze(tasks.map((item) => item.id === task.id ? updated : item));
-      return `Updated ${fmt(updated)}`;
-    }
-    // Unreachable: every TODO_ACTIONS member is handled above. Kept as the exhaustiveness arm.
-    return formatError(`unhandled todo action '${action}'`);
-  };
-  return async (action, params) => apply(action, params);
-}

package/src/bridge/interactive.ts

@@ -1,65 +0,0 @@
-import type { AskAnswer, AskQuestion } from "../sandbox/protocol.ts";
-import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import type { RlmEmitter } from "../tool/rlm-events.ts";
-import { formatError } from "../util/errors.ts";
-
-export interface InteractiveBridgeOpts {
-  readonly onAskUserQuestion?: (questions: readonly AskQuestion[]) => Promise<AskAnswer[]>;
-  readonly onTodo?: (action: string, params: Record<string, unknown>) => Promise<string>;
-  readonly onTodoRow?: (action: string, params: Record<string, unknown>, result: string) => void | Promise<void>;
-  readonly emitter?: RlmEmitter;
-  readonly depth: number;
-  readonly parentId?: string;
-}
-
-export function buildInteractiveHandlers(opts: InteractiveBridgeOpts): {
-  askUserQuestion: SubLlmHandlers["askUserQuestion"];
-  todo: SubLlmHandlers["todo"];
-} {
-  return {
-    async askUserQuestion(questions, depth) {
-      if (depth > 0) return questions.map((q) => ({
-        question: q.question,
-        selected: [],
-        custom: formatError("ask_user_question not available inside rlm_query sub-calls"),
-      }));
-
-      const id = opts.emitter?.emitSubcallCreated({
-        kind: "tool", parentId: opts.parentId,
-        label: "ask_user_question",
-        args: `${questions.length} question(s)`,
-        depth,
-      });
-      try {
-        const cb = opts.onAskUserQuestion;
-        if (!cb) throw new Error("ask_user_question not configured (no onAskUserQuestion callback)");
-        const answers = await cb(questions);
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "done" });
-        return answers;
-      } catch (err) {
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
-        throw err;
-      }
-    },
-
-    async todo(action, params, depth) {
-      const id = opts.emitter?.emitSubcallCreated({
-        kind: "tool", parentId: opts.parentId,
-        label: `todo:${action}`,
-        args: params.subject ? String(params.subject) : String(params.id ?? ""),
-        depth,
-      });
-      try {
-        const cb = opts.onTodo;
-        if (!cb) throw new Error("todo not configured (no onTodo callback)");
-        const result = await cb(action, params);
-        await opts.onTodoRow?.(action, params, result);
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "done", resultPreview: result.slice(0, 80) });
-        return result;
-      } catch (err) {
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
-        throw err;
-      }
-    },
-  };
-}

package/src/bridge/library.ts

@@ -1,155 +0,0 @@
-/**
- * Shared load_library handler for headless engine and native repl() mode.
- *
- * Host packs the source via resolveLibrarySource (namespaced under lib/<id>/),
- * assigns a resume-sidecar index, and returns the payload for the worker to
- * append into the single `context` list.
- *
- * Idempotency is host-side: re-loading a source that was already packed does
- * not consume an index, write a sidecar, or re-clone/pack. That keeps resume
- * trails free of duplicate library slots.
- *
- * Late-bound deps (getCwd / getEmitter) keep a single handler closure correct
- * across native repl() calls — getOrCreate only installs handlers at spawn.
- */
-
-import type { RlmEmitter } from "../tool/rlm-events.ts";
-import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import {
-  libraryNamespace,
-  resolveLibrarySource,
-} from "../context/library-context.ts";
-import { previewText } from "../text/preview.ts";
-
-export interface LibraryBridgeOpts {
-  /** 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;
-  /** First resume-sidecar index (slot 0 = repo). Resume passes 1 + max restored. */
-  readonly startIndex: number;
-  /**
-   * Prefixes already present in context (e.g. restored from sidecars).
-   * Seeded so re-load after resume is still a no-op without re-packing.
-   */
-  readonly loadedPrefixes?: readonly string[];
-  /** Post-load hook — the engine writes the resume sidecar here; native mode omits it. */
-  readonly onLoaded?: (index: number, payload: unknown) => void | Promise<void>;
-}
-
-export interface LibraryHandlerBundle {
-  readonly handlers: Pick<SubLlmHandlers, "loadLibrary">;
-  /** Reset the sidecar index counter (call when the sandbox is discarded and will re-spawn). */
-  readonly reset: () => void;
-  /** Prefixes loaded in this sandbox lifetime (for tests). */
-  readonly loadedPrefixes: () => ReadonlySet<string>;
-}
-
-export function buildLibraryHandler(opts: LibraryBridgeOpts): LibraryHandlerBundle {
-  let nextIndex = opts.startIndex;
-  /** Prefixes already loaded in this sandbox — mirrors the worker's context state. */
-  const loaded = new Set<string>(opts.loadedPrefixes ?? []);
-  return {
-    reset: () => {
-      nextIndex = opts.startIndex;
-      loaded.clear();
-    },
-    loadedPrefixes: () => loaded,
-    handlers: {
-      async loadLibrary(source, depth) {
-        const emitter = opts.getEmitter?.() ?? opts.emitter;
-        const cwd = opts.getCwd?.() ?? opts.cwd;
-        if (cwd === undefined || cwd === "") {
-          throw new Error("load_library: no cwd configured");
-        }
-        const id = emitter?.emitSubcallCreated({
-          kind: "tool", parentId: opts.parentId,
-          label: "load_library",
-          args: previewText(source, 80),
-          depth,
-        });
-        try {
-          // Cheap pre-check BEFORE cloning/packing: same namespace ⇒ nothing to do.
-          const { sourceId: preId, pathPrefix: prefix } = libraryNamespace(source, cwd);
-          if (loaded.has(prefix)) {
-            if (id) {
-              emitter?.emitSubcallUpdated({
-                id,
-                status: "done",
-                resultPreview: `already loaded (${prefix}*)`,
-              });
-            }
-            // No index consumed, no sidecar written — resume stays consistent.
-            return {
-              payload: Object.freeze([]),
-              index: -1,
-              files: 0,
-              chars: 0,
-              sourceId: preId,
-              pathPrefix: prefix,
-              alreadyLoaded: true,
-            };
-          }
-
-          const resolved = await resolveLibrarySource(source, cwd, opts.signal);
-          if (!resolved.ok) throw new Error(resolved.error);
-          const { payload, files, chars, sourceId, pathPrefix } = resolved.value;
-
-          // 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 {
-              payload: Object.freeze([]),
-              index: -1,
-              files: 0,
-              chars: 0,
-              sourceId,
-              pathPrefix,
-              alreadyLoaded: true,
-            };
-          }
-
-          // Increment only after a successful sidecar write (or when no hook is set).
-          const index = nextIndex;
-          if (opts.onLoaded) {
-            await opts.onLoaded(index, payload);
-          }
-          nextIndex = index + 1;
-          loaded.add(pathPrefix);
-
-          if (id) {
-            emitter?.emitSubcallUpdated({
-              id,
-              status: "done",
-              resultPreview:
-                `+${files} file(s) → context (${pathPrefix}*, ${chars.toLocaleString()} chars)`,
-            });
-          }
-          return {
-            payload,
-            index,
-            files,
-            chars,
-            sourceId,
-            pathPrefix,
-            alreadyLoaded: false,
-          };
-        } 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/pi-interactive.ts

@@ -1,41 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { InteractiveDeps } from "../core/types.ts";
-import type { AskAnswer, AskQuestion } from "../sandbox/protocol.ts";
-import { formatError } from "../util/errors.ts";
-import { createTodoFallback } from "./fallback-todo.ts";
-
-async function askViaUi(ctx: ExtensionContext, questions: readonly AskQuestion[]): Promise<AskAnswer[]> {
-  if (!ctx.hasUI) throw new Error("ask_user_question requires UI");
-  const answers = new Array<AskAnswer>(questions.length);
-  for (let i = 0; i < questions.length; i++) {
-    const q = questions[i];
-    if (!q) {
-      answers[i] = { question: "", selected: [], custom: formatError("malformed question") };
-      continue;
-    }
-    if (q.multiSelect) {
-      const selected: string[] = [];
-      while (true) {
-        const pick = await ctx.ui.select(`${q.header}: ${q.question}`, [...q.options.map((o) => o.label), "Done"]);
-        if (!pick || pick === "Done") break;
-        if (!selected.includes(pick)) selected.push(pick);
-      }
-      answers[i] = { question: q.question, selected };
-      continue;
-    }
-    const pick = await ctx.ui.select(`${q.header}: ${q.question}`, [...q.options.map((o) => o.label), "Type something."]);
-    if (!pick) answers[i] = { question: q.question, selected: [], custom: formatError("user cancelled") };
-    else if (pick === "Type something.") answers[i] = { question: q.question, selected: [], custom: await ctx.ui.input(q.question) ?? "" };
-    else answers[i] = { question: q.question, selected: [pick] };
-  }
-  return answers;
-}
-
-export function createPiInteractiveDeps(ctx: ExtensionContext): InteractiveDeps {
-  const fallbackTodo = createTodoFallback();
-  return Object.freeze({
-    onAskUserQuestion: (questions: readonly AskQuestion[]): Promise<AskAnswer[]> => askViaUi(ctx, questions),
-    onTodo: (action: string, params: Record<string, unknown>): Promise<string> =>
-      Promise.resolve(fallbackTodo(action, params)),
-  });
-}