@hicaru/pi-rlm 0.2.1 → 0.3.0

package/src/core/types.ts

@@ -1,8 +1,6 @@
 /** Shared configuration + runtime types for the RLM engine. */
 
 import type { ThinkingLevel } from "@earendil-works/pi-ai";
-import type { AskAnswer, AskQuestion } from "../sandbox/protocol.ts";
-import type { ReconstructResult } from "../state/resume.ts";
 
 export interface Sampling {
   readonly maxTokens?: number;
@@ -10,17 +8,6 @@ export interface Sampling {
   readonly reasoning?: ThinkingLevel;
 }
 
-export interface RunLogConfig {
-  /** Default: true — always-on, opt-out. */
-  readonly enabled?: boolean;
-  /** Default: ".rlm/runs". Directory under cwd for run artifacts. */
-  readonly dir?: string;
-  /** Default: true — whether to write sandbox.pkl snapshots. */
-  readonly snapshot?: boolean;
-  /** Default: 50 — prune oldest runs beyond this count on each new run. */
-  readonly maxRuns?: number;
-}
-
 export interface RlmConfig {
   /** Persistent editor-routing mode; when enabled, plain interactive prompts use RLM. */
   readonly enabled: boolean;
@@ -34,10 +21,11 @@ export interface RlmConfig {
   readonly requestTimeoutMs: number;
   /** Concurrency pool for *_batched sub-calls. */
   readonly maxConcurrentSubcalls: number;
+  /** Concurrent recursive child engines admitted per depth. Lower than maxConcurrentSubcalls:
+   *  each child is a Python subprocess holding its own copy of the inherited context. */
+  readonly maxConcurrentChildren: number;
   /** Reject sub-LLM prompts larger than this many chars. */
   readonly maxPromptChars: number;
-  /** Max USD spend across the whole tree before the engine stops (undefined = no cap). */
-  readonly maxBudgetUsd?: number;
   /** Max wall-clock ms across the whole tree before the engine stops (undefined = no cap). */
   readonly maxTimeoutMs?: number;
   /** Max total input+output tokens across the whole tree before the engine stops (undefined = no cap). */
@@ -46,10 +34,6 @@ export interface RlmConfig {
   readonly maxErrors?: number;
   /** Append the orchestrator addendum to the system prompt. */
   readonly orchestrator: boolean;
-  /** Enable the phase pipeline (advance_phase + stall nags) at depth 0. */
-  readonly pipeline: boolean;
-  /** Max validate→blueprint corrective re-entries when validation reports blockers (default 2). */
-  readonly maxBackwardJumps: number;
   /** Summarize the trajectory when it grows past the threshold (keeps the root window small). */
   readonly compaction: boolean;
   /** Compact when estimated history tokens reach this fraction of the model's context window. */
@@ -58,12 +42,13 @@ export interface RlmConfig {
   readonly python: string;
   /** Worker startup wait before treating sandbox init as failed (ms). */
   readonly sandboxInitTimeoutMs: number;
-  /** Allow ask_user_question() calls from the root REPL. */
-  readonly askUserQuestion: boolean;
-  /** Allow todo() calls from the REPL. */
-  readonly todo: boolean;
-  /** Enable the load_library() REPL scaffold (external dirs/files/git repos as extra context slots). */
-  readonly libraryLoader: boolean;
+  /** Enable the add_context() REPL scaffold (external dirs/files/git repos/documents into context). */
+  readonly contextLoader: boolean;
+  /**
+   * When true, the first repl() call seeds `context` with the working directory
+   * (un-prefixed paths). When false, context stays empty until add_context is called.
+   */
+  readonly autoSeedCwd: boolean;
   /** ThinkingLevel for the root smart model (set via /rlm-config). */
   readonly smartReasoning?: ThinkingLevel;
   /** Output token cap + temperature for the root smart model per turn.
@@ -76,8 +61,6 @@ export interface RlmConfig {
   readonly subSystemPrompt?: string;
   /** Sampling for sub-LLM (worker) calls. */
   readonly subSampling: Readonly<Sampling>;
-  /** Optional run-state persistence configuration. Enabled by default. */
-  readonly runLog?: RunLogConfig;
 }
 
 /** Input to a (headless) RLM run. */
@@ -92,12 +75,8 @@ export interface RlmInput {
   readonly parentNodeId?: string;
   /** "provider/id" — overrides the root model for this run (set by recursive rlm_query). */
   readonly modelOverride?: string;
-  /** Remaining budget for this subtree (set by parent from its LimitGuard). */
-  readonly remainingBudgetUsd?: number;
   /** Remaining timeout for this subtree (set by parent from its LimitGuard). */
   readonly remainingTimeoutMs?: number;
-  /** Depth-0 resume payload — controller rebuilds this from the trail's `reconstructRlmState()`. */
-  readonly resume?: ReconstructResult & { readonly ok: true };
 }
 
 /** Result of a completed RLM run. */
@@ -111,11 +90,4 @@ export interface RlmResult {
 }
 
 /** A function that runs an RLM to completion — used to wire recursion (rlm_query). */
-export interface InteractiveDeps {
-  /** Called when the sandbox issues ask_user_question; undefined = feature disabled. */
-  readonly onAskUserQuestion?: (questions: readonly AskQuestion[]) => Promise<AskAnswer[]>;
-  /** Called when the sandbox issues todo; undefined = feature disabled. */
-  readonly onTodo?: (action: string, params: Record<string, unknown>) => Promise<string>;
-}
-
 export type RunRlm = (input: RlmInput) => Promise<RlmResult>;

package/src/index.ts

@@ -7,15 +7,19 @@ import { registerRlmConfigCommand } from "./commands/rlm-config.ts";
 import { createRlmTool } from "./tool/rlm-tool.ts";
 import { createReplTool } from "./tool/repl-tool.ts";
 import { loadSettings, mergeConfig, resolveModelId } from "./config/settings.ts";
-import { RlmController, cheapestModel } from "./mode/rlm-mode.ts";
+import { RlmController } from "./mode/rlm-mode.ts";
+import { cheapestModel } from "./mode/llm-model.ts";
 import { postRlmGuide } from "./ui/intro.ts";
 import { setRlmModeStatus } from "./ui/status.ts";
 import { markdownTheme } from "./ui/theme-adapter.ts";
 import { SandboxManager } from "./sandbox/sandbox-manager.ts";
 import { createSubcallGates } from "./util/concurrency.ts";
 import { BackgroundTasks } from "./tool/background-tasks.ts";
-import { packRepository, formatForLLM, serializeForSandbox } from "./context/repomix-context.ts";
-import { buildNativeSystemPrompt, NATIVE_TURN_REMINDER } from "./prompts/system.ts";
+import { resolve } from "node:path";
+import { resolveSource } from "./context/resolve.ts";
+import { formatContextListing } from "./context/listing.ts";
+import type { AddContextHandlerBundle } from "./bridge/add-context.ts";
+import { buildNativeSystemPrompt, NATIVE_TURN_REMINDER } from "./prompts/native.ts";
 import { bashCommandFromInput, isFileReadingCommand, capToolResultText, BASH_BLOCK_REASON } from "./mode/native-guards.ts";
 import { errorMessage } from "./util/errors.ts";
 
@@ -42,9 +46,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   });
   // One admission gate for the whole session: spawn() lets the sandbox put many requests on
   // the wire at once, so nothing smaller than session scope actually bounds fan-out.
-  const gates = createSubcallGates(config.maxConcurrentSubcalls);
+  const gates = createSubcallGates(config.maxConcurrentSubcalls, config.maxConcurrentChildren);
   const background = new BackgroundTasks({
-    maxBudgetUsd: config.maxBudgetUsd,
     maxTimeoutMs: config.maxTimeoutMs,
     maxTokens: config.maxTokens,
     maxErrors: config.maxErrors,
@@ -57,29 +60,44 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   }, WATCHDOG_HEARTBEAT_MS);
   watchdogHeartbeat.unref();
 
-  let packedContextText: string | undefined;
-  let contextPackPromise: Promise<string | undefined> | undefined;
-  const ensureRepositoryContext = async (cwd: string): Promise<string | undefined> => {
-    if (packedContextText !== undefined && sandboxManager.contextPayload !== null) return packedContextText;
-    contextPackPromise ??= packRepository(cwd)
+  /** Memoised cwd seed — one resolveSource(pathPrefix:"") per session. */
+  let seedPromise: Promise<void> | undefined;
+  let cwdSeeded = false;
+  /** Live add_context bundle — seed plants the "" sentinel here so add_context(".") is a no-op. */
+  let contextBundleRef: AddContextHandlerBundle | undefined;
+  /**
+   * Payload identity last injected into the context hook. Re-inject only when the payload
+   * reference changes (seed, add_context, reset) — not every turn. Keeps the root window small.
+   */
+  let listingPayloadRef: unknown = undefined;
+  let listingInjected = false;
+  const seedContext = async (cwd: string): Promise<void> => {
+    if (cwdSeeded) return;
+    if (!controller.config.autoSeedCwd) {
+      cwdSeeded = true;
+      return;
+    }
+    seedPromise ??= resolveSource(cwd, { cwd, pathPrefix: "" })
       .then((result) => {
+        // Sticky either way: a failed seed must not re-walk the whole repo on every repl().
+        cwdSeeded = true;
         if (!result.ok) {
-          console.warn(`[rlm] repository context pack failed: ${result.error}`);
-          return undefined;
+          console.warn(`[rlm] context seed failed: ${result.error}`);
+          return;
         }
-        sandboxManager.contextPayload = serializeForSandbox(result.value);
-        packedContextText = formatForLLM(result.value);
-        return packedContextText;
+        sandboxManager.contextPayload = result.value.payload;
+        // Register the cwd seed with the bridge so add_context(".") cannot double the tree.
+        contextBundleRef?.markSeededCwd(resolve(cwd));
       })
-      .finally(() => { contextPackPromise = undefined; });
-    return contextPackPromise;
+      .finally(() => { seedPromise = undefined; });
+    await seedPromise;
   };
 
   // Load persisted settings async — applied before session_start handler reads controller state
   const settingsReady = loadSettings()
     .then((persisted) => {
       controller.config = mergeConfig(persisted.config);
-      controller.savedWorkerRef = persisted.worker;
+      controller.savedLlmRef = persisted.llm;
     })
     .catch((err) => {
       console.warn(`[rlm] settings load failed: ${errorMessage(err)}`);
@@ -120,30 +138,48 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const flag = pi.getFlag("rlm");
     if (typeof flag === "boolean") controller.setConfig(Object.freeze({ ...controller.config, enabled: flag }));
 
-    if (controller.savedWorkerRef) {
-      const resolved = resolveModelId(ctx.modelRegistry, controller.savedWorkerRef);
-      if (resolved) controller.workerModel = resolved;
+    // Reload the catalog before the worker-model pick below reads it. Newer pi builds make
+    // `getAvailable()` an async-populated snapshot that starts empty, and picking from an empty
+    // catalog silently falls back to the root model. Called with no arguments and awaited so it
+    // is valid whether `refresh` returns void (current) or a promise (newer); fail-soft, because
+    // a refresh error must not abort session start.
+    try {
+      await ctx.modelRegistry.refresh();
+    } catch (err) {
+      console.warn(`[rlm] model registry refresh failed: ${errorMessage(err)}`);
+    }
+
+    if (controller.savedLlmRef) {
+      const resolved = resolveModelId(ctx.modelRegistry, controller.savedLlmRef);
+      if (resolved) controller.llmModel = resolved;
     }
 
     // Re-register repl tool each session to pick up model provider changes
-    const workerModel = controller.workerModel ?? cheapestModel(ctx.modelRegistry) ?? ctx.model;
+    const llmModel = controller.llmModel ?? cheapestModel(ctx.modelRegistry) ?? ctx.model;
     const model = ctx.model;
-    if (workerModel && model) {
+    if (llmModel && model) {
       try {
         pi.registerTool(createReplTool({
           sandboxManager,
           model,
-          workerModel,
+          llmModel,
           getModel: () => controller.resolveModels(ctx)?.model,
-          getWorkerModel: () => controller.resolveModels(ctx)?.worker,
+          getLlmModel: () => controller.resolveModels(ctx)?.llm,
           registry: ctx.modelRegistry,
           getConfig: () => controller.config,
           gates,
           background,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
+          registerContextBundle: (bundle) => {
+            contextBundleRef = bundle;
+            // Tool re-registers each session; re-plant sentinel if seed already landed.
+            if (cwdSeeded && Array.isArray(sandboxManager.contextPayload)
+              && sandboxManager.contextPayload.length > 0) {
+              bundle.markSeededCwd(resolve(ctx.cwd ?? process.cwd()));
+            }
+          },
           ensureContext: async () => {
-            const contextText = await ensureRepositoryContext(ctx.cwd ?? process.cwd());
-            if (contextText === undefined) throw new Error("repository context could not be loaded into RLM sandbox");
+            await seedContext(ctx.cwd ?? process.cwd());
           },
         }));
       } catch (err) {
@@ -173,9 +209,10 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     return { systemPrompt: event.systemPrompt + "\n\n" + buildNativeSystemPrompt() };
   });
 
-  // ── Context injection: repo listing for the main agent ──
-  let contextInjected = false;
-  pi.on("context", async (event, ctx) => {
+  // ── Context injection: listing of whatever is currently loaded ──
+  // Re-inject only when the payload identity changes (seed / add_context), not every turn —
+  // the listing can be up to 200 file lines and the plugin exists to shrink the root window.
+  pi.on("context", async (event) => {
     const filtered = event.messages.filter(
       (message) =>
         !(message.role === "custom" && message.customType === "rlm-intro")
@@ -185,25 +222,24 @@ export default function rlmExtension(pi: ExtensionAPI): void {
 
     type PiMessage = (typeof filtered)[number];
 
-    // Inject repository context as a compact listing (once per session)
-    if (!contextInjected) {
-      const cwd = ctx.cwd ?? process.cwd();
-      const contextText = await ensureRepositoryContext(cwd);
-      if (contextText !== undefined) {
-        contextInjected = true;
-        const instruction = [
-          "ANALYZE THIS REPOSITORY using repl({code}) — read/grep are DISABLED.",
-          "Repository contents are pre-loaded in the Python REPL `context` variable.",
-          "Locate with search()/grep_context()/outline() (free), then delegate bulk reading to",
-          "map_files()/llm_query_batched(). If credits exhausted → report and stop.",
-          "",
-        ].join("\n");
-        filtered.unshift({
-          role: "user" as const,
-          content: instruction + contextText,
-          timestamp: 0,
-        } as PiMessage);
-      }
+    const payload = sandboxManager.contextPayload;
+    if (!listingInjected || payload !== listingPayloadRef) {
+      listingInjected = true;
+      listingPayloadRef = payload;
+      const listing = formatContextListing(payload);
+      const instruction = [
+        "ANALYZE with repl({code}) — read/grep are DISABLED.",
+        "Files you have loaded live in the Python REPL `context` variable (starts empty; cwd seeds on first repl()).",
+        "Locate with search()/grep_context()/outline() (free), then delegate bulk reading to",
+        "map_files()/llm_query_batched(). Use add_context(path) for external dirs/files/docs/git URLs.",
+        "If credits exhausted → report and stop.",
+        "",
+      ].join("\n");
+      filtered.unshift({
+        role: "user" as const,
+        content: instruction + listing,
+        timestamp: 0,
+      } as PiMessage);
     }
 
     // Per-turn last-position reminder (not persisted — context hook rebuilds every request)
@@ -225,7 +261,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     if (BLOCKED_NATIVE_TOOLS.has(event.toolName)) {
       return {
         block: true,
-        reason: "RLM mode active. Use repl({code}) to read files and search the repository — all files are pre-loaded in the REPL `context` variable. Use `edit`/`write` for file changes. If sub-LLM credits are exhausted, report to the user.",
+        reason: "RLM mode active. Use repl({code}) to read files and search the repository — loaded files live in the REPL `context` variable (cwd seeds on first call). Use `edit`/`write` for file changes. If sub-LLM credits are exhausted, report to the user.",
       };
     }
     const bashCommand = event.toolName === "bash" ? bashCommandFromInput(event.input) : undefined;
@@ -253,9 +289,11 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     clearInterval(watchdogHeartbeat);
     background.dispose();
     await sandboxManager.dispose();
-    contextInjected = false;
-    packedContextText = undefined;
-    contextPackPromise = undefined;
-    sandboxManager.contextPayload = null;
+    cwdSeeded = false;
+    seedPromise = undefined;
+    contextBundleRef = undefined;
+    listingPayloadRef = undefined;
+    listingInjected = false;
+    sandboxManager.contextPayload = [];
   });
 }

package/src/mode/llm-model.ts

@@ -0,0 +1,54 @@
+/**
+ * Sub-LLM model ranking — "cheapest available", with free models winning outright.
+ *
+ * Pi's `ModelCost` is non-nullable (`packages/ai/src/types.ts`), so a free model is a literal 0,
+ * not a null. That makes plain price sorting ambiguous rather than wrong: subscription and
+ * token-plan providers also publish 0, and a stable sort would hand back whichever 0-cost entry
+ * happened to be first in catalog order. The tie-breaks below are what actually pick a usable
+ * free model — and what make the pick identical across sessions and catalog reorderings.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+/** $/Mtok, input-weighted 3:1 — a sub-call sends a file body and gets back a sentence. */
+function priceOf(model: Model<Api>): number {
+  const { input, output, cacheRead } = model.cost;
+  return input * 3 + output + cacheRead;
+}
+
+/** True when the model costs nothing to call on any axis. */
+export function isFreeModel(model: Model<Api>): boolean {
+  return priceOf(model) === 0;
+}
+
+/**
+ * Negative when `a` is the better sub-LLM.
+ *
+ * Window before maxTokens before id: a free model with a 4K context is useless for bulk reading,
+ * so price alone must not decide. The final id comparison exists only to make the result
+ * deterministic — without it the pick drifts whenever a provider reorders its catalog.
+ */
+export function compareLlm(a: Model<Api>, b: Model<Api>): number {
+  return (priceOf(a) - priceOf(b))
+    || (b.contextWindow - a.contextWindow)
+    || (b.maxTokens - a.maxTokens)
+    || `${a.provider}/${a.id}`.localeCompare(`${b.provider}/${b.id}`);
+}
+
+/**
+ * Best sub-LLM among the models whose provider has configured auth.
+ *
+ * Single pass rather than `[...models].sort()[0]`: the copy and the sort both allocate for a
+ * result that is one element.
+ */
+export function cheapestModel(registry: ModelRegistry): Model<Api> | undefined {
+  const models = registry.getAvailable();
+  let best: Model<Api> | undefined;
+  for (let i = 0; i < models.length; i++) {
+    const model = models[i];
+    if (model === undefined) continue;
+    if (best === undefined || compareLlm(model, best) < 0) best = model;
+  }
+  return best;
+}

package/src/mode/rlm-mode.ts

@@ -1,42 +1,35 @@
 /**
  * RlmController — holds RLM config + chosen models.
  *
- * The engine drives the root model turn-by-turn over ```repl``` blocks with full budget/token/
+ * The engine drives the root model turn-by-turn over ```repl``` blocks with full token/
  * timeout/error guards, compaction, and a finalize fallback. `start()` returns a RunHandle with
  * the completion promise.
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
-import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_RUN_DIR } from "../config/defaults.ts";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { modelRef, resolveModelId, saveSettings } from "../config/settings.ts";
 import { createEngine } from "../core/engine.ts";
 import { limitsFromConfig } from "../core/limits.ts";
-import type { InteractiveDeps, RlmConfig, RlmInput, RlmResult } from "../core/types.ts";
-import type { ReconstructResult } from "../state/resume.ts";
-import { packRepository, serializeForSandbox } from "../context/repomix-context.ts";
+import type { RlmConfig, RlmResult } from "../core/types.ts";
+import { resolveSource } from "../context/resolve.ts";
 import { RlmEmitter } from "../tool/rlm-events.ts";
 import { formatError } from "../util/errors.ts";
-
-export function cheapestModel(registry: ModelRegistry): Model<Api> | undefined {
-  const models = registry.getAvailable();
-  if (models.length === 0) return undefined;
-  return [...models].sort((a, b) => a.cost.input + a.cost.output - (b.cost.input + b.cost.output))[0];
-}
+import { cheapestModel } from "./llm-model.ts";
 
 export interface RunHandle {
   readonly abort: () => void;
   readonly done: Promise<RlmResult>;
 }
 
-/** B5+SA: discriminated union removes non-null `!` assertions and the `context: ""` hack. */
-export type StartInput =
-  | { readonly kind: "fresh"; readonly rootPrompt: string; readonly context: unknown }
-  | { readonly kind: "resume"; readonly resume: ReconstructResult & { ok: true }; readonly context: unknown };
+export interface StartInput {
+  readonly rootPrompt: string;
+  readonly context: unknown;
+}
 
 export class RlmController {
-  workerModel: Model<Api> | undefined;
-  savedWorkerRef: string | undefined;
+  llmModel: Model<Api> | undefined;
+  savedLlmRef: string | undefined;
   private active: AbortController | null = null;
 
   constructor(public config: RlmConfig) {}
@@ -65,7 +58,7 @@ export class RlmController {
   async persist(): Promise<boolean> {
     return await saveSettings({
       config: this.config,
-      worker: modelRef(this.workerModel) ?? this.savedWorkerRef,
+      llm: modelRef(this.llmModel) ?? this.savedLlmRef,
     });
   }
 
@@ -77,15 +70,15 @@ export class RlmController {
     this.active?.abort();
   }
 
-  resolveModels(ctx: ExtensionContext): { model: Model<Api>; worker: Model<Api> } | undefined {
-    if (!this.workerModel && this.savedWorkerRef) this.workerModel = resolveModelId(ctx.modelRegistry, this.savedWorkerRef);
+  resolveModels(ctx: ExtensionContext): { model: Model<Api>; llm: Model<Api> } | undefined {
+    if (!this.llmModel && this.savedLlmRef) this.llmModel = resolveModelId(ctx.modelRegistry, this.savedLlmRef);
     const model = ctx.model ?? cheapestModel(ctx.modelRegistry);
     if (!model) return undefined;
-    const worker = this.workerModel ?? cheapestModel(ctx.modelRegistry) ?? model;
-    return { model, worker };
+    const llm = this.llmModel ?? cheapestModel(ctx.modelRegistry) ?? model;
+    return { model, llm };
   }
 
-  start(ctx: ExtensionContext, input: StartInput, emitter?: RlmEmitter, interactive?: InteractiveDeps): RunHandle {
+  start(ctx: ExtensionContext, input: StartInput, emitter?: RlmEmitter): RunHandle {
     const models = this.resolveModels(ctx);
     if (!models) throw new Error("no model with configured auth is available");
     if (this.active) throw new Error("RLM run already in progress"); // QC: mutual-exclusion guard
@@ -93,50 +86,27 @@ export class RlmController {
     const abortController = new AbortController();
     this.active = abortController;
 
-    const runState = this.config.runLog?.enabled !== false
-      ? { cwd: ctx.cwd ?? process.cwd(), dir: this.config.runLog?.dir ?? DEFAULT_RUN_DIR, snapshot: this.config.runLog?.snapshot !== false }
-      : undefined;
-
     const done = (async () => {
-      let engineInput: RlmInput;
-      if (input.kind === "fresh") {
-        // Auto-pack empty/undefined context via repomix; pass explicit context through.
-        let contextValue: unknown = input.context;
-        if (contextValue === undefined || contextValue === "" || (typeof contextValue === "string" && contextValue.trim() === "")) {
-          const cwd = ctx.cwd ?? process.cwd();
-          const result = await packRepository(cwd, abortController.signal);
-          if (result.ok) {
-            contextValue = serializeForSandbox(result.value);
-          } else {
-            contextValue = formatError(`failed to pack repository — ${result.error}`);
-          }
-        }
-        engineInput = {
-          rootPrompt: input.rootPrompt,
-          context: contextValue,
-          depth: 0,
-        };
-      } else {
-        engineInput = {
-          rootPrompt: input.resume.header.rootPrompt,
-          context: input.context, // B5: load the actual context from the sidecar, not ""
-          depth: 0,
-          resume: input.resume,
-        };
+      // Auto-seed empty/undefined context from cwd (same resolveSource path as native mode);
+      // pass explicit context through.
+      let contextValue: unknown = input.context;
+      if (contextValue === undefined || (typeof contextValue === "string" && contextValue.trim() === "")) {
+        const cwd = ctx.cwd ?? process.cwd();
+        const result = await resolveSource(cwd, { cwd, pathPrefix: "", signal: abortController.signal });
+        contextValue = result.ok
+          ? result.value.payload
+          : formatError(`failed to pack repository — ${result.error}`);
       }
       const engine = createEngine({
         model: models.model,
-        workerModel: models.worker,
+        llmModel: models.llm,
         registry: ctx.modelRegistry,
         config: this.config,
         signal: abortController.signal,
         emitter: emitter ?? new RlmEmitter(),
-        runState,
-        onAskUserQuestion: interactive?.onAskUserQuestion,
-        onTodo: interactive?.onTodo,
         limits: limitsFromConfig(this.config),
       });
-      return await engine(engineInput);
+      return await engine({ rootPrompt: input.rootPrompt, context: contextValue, depth: 0 });
     })().finally(() => {
       if (this.active === abortController) this.active = null;
     });