@hicaru/pi-rlm 0.1.9 → 0.2.0

package/src/core/pipeline-handlers.ts

@@ -0,0 +1,319 @@
+/**
+ * The phase pipeline's stateful half: the `save_artifact` / `advance_phase` sandbox handlers
+ * and the validate-phase finalize routing.
+ *
+ * Pulled out of the engine's run closure so the pipeline's mutable state (current phase, the
+ * per-phase latest save, serviced ask rounds, accumulated warnings, a pending history reset)
+ * lives in one owner instead of six `let`s threaded through a 640-line function.
+ *
+ * Two invariants this file exists to protect:
+ *  - Gates measure the CURRENT phase's latest save (`lastSaved`) only — never
+ *    `phase.artifacts`, whose paths are the completed channel and go stale across a
+ *    corrective loop-back.
+ *  - `lastSaved` and `askRounds` are session-only. They are never rehydrated from the trail,
+ *    so a resumed run must genuinely re-save and re-interview rather than re-gate stale work.
+ */
+
+import type { ChatMsg } from "../bridge/model.ts";
+import type { RlmEmitter } from "../tool/rlm-events.ts";
+import type { PhaseRecon } from "../state/resume.ts";
+import { formatError } from "../util/errors.ts";
+import { readArtifact, saveArtifact, type GoalCapture } from "./artifacts.ts";
+import { critiqueArtifact, formatCritique } from "./critique.ts";
+import {
+  advancePhase as validatePhaseTransition,
+  initialPhaseState,
+  isPhase,
+  PHASES,
+  reconcilePhase,
+  routeAfterValidate,
+  stageForArtifactKind,
+  STAGES,
+  type ArtifactRef,
+  type Phase,
+  type PhaseState,
+  type SavedArtifact,
+  type StageGateData,
+} from "./pipeline.ts";
+
+/** Builds the fresh-session history for a phase. Supplied by the engine (its own policy). */
+export type ResetHistoryForPhase = (
+  state: PhaseState,
+  options: { readonly goal?: GoalCapture; readonly validation?: import("./gates.ts").ValidationGateData; readonly notice?: string },
+) => ChatMsg[];
+
+/** Appends a `phase` row to the run trail. Supplied by the engine (owns persistence state). */
+export type PersistPhaseRow = (
+  state: PhaseState,
+  artifactPath: string | undefined,
+  artifactPhase: Phase | undefined,
+  gateData: StageGateData | undefined,
+  supersededPath?: string,
+) => Promise<void>;
+
+export interface PipelineDeps {
+  /** Repo root that artifact paths are resolved against. */
+  readonly runCwd: string;
+  readonly maxBackwardJumps: number;
+  readonly emitter: RlmEmitter;
+  /** Turns completed so far — phase rows and `advancedAt` are stamped with it. */
+  readonly completedTurns: () => number;
+  readonly resetHistoryForPhase: ResetHistoryForPhase;
+  readonly persistPhaseRow: PersistPhaseRow;
+}
+
+/** What the engine should do with a finalize submitted while in the `validate` phase. */
+export type ValidateOutcome =
+  /** Not finalizable yet — feed `error` back as the next turn's REPL output. */
+  | { readonly kind: "reject"; readonly error: string }
+  /** Blockers found — re-enter `blueprint` with this fresh history. */
+  | { readonly kind: "loop-back"; readonly history: ChatMsg[] }
+  /** Backward-jump cap reached — terminate with this report. */
+  | { readonly kind: "halt"; readonly report: string }
+  /** Validation passed — take the model's final answer. */
+  | { readonly kind: "accept" };
+
+/** The sandbox handlers the pipeline contributes. Shape-compatible with `SubLlmHandlers`. */
+export interface PipelineHandlers {
+  saveArtifact(kind: string, content: string): Promise<string>;
+  advancePhase(phase: string, summary: string | undefined): Promise<string>;
+}
+
+export class PipelineController {
+  /** Current phase state; `undefined` until seeded. Read by the engine for gate prompts/rows. */
+  phase: PhaseState | undefined;
+
+  /**
+   * Latest save per phase: path plus an optional gate memo, as ONE record so the two cannot
+   * desync. Cleared on phase exit and on loop-back.
+   */
+  private lastSaved: Partial<Record<Phase, SavedArtifact>> = {};
+
+  /** Serviced ask_user_question rounds in the current phase (session-only). */
+  private askRounds = 0;
+
+  /** Advisory critique warnings accumulated across saves (surfaced in the TUI). */
+  private warnings: readonly string[] = [];
+
+  /** History replacement scheduled by advance_phase; the engine drains it at a turn boundary. */
+  private pendingReset: ChatMsg[] | undefined;
+
+  private goal: GoalCapture | undefined;
+
+  constructor(private readonly deps: PipelineDeps) {}
+
+  /** Called after each successfully serviced root-depth ask_user_question round. */
+  noteAskRound(): void {
+    this.askRounds++;
+  }
+
+  /** Take and clear the scheduled fresh-session history, if advance_phase left one. */
+  takePendingReset(): ChatMsg[] | undefined {
+    const reset = this.pendingReset;
+    this.pendingReset = undefined;
+    return reset;
+  }
+
+  /** Seed a fresh run: capture goal, enter `startPhase`, and build the opening history. */
+  seedFresh(startPhase: Phase, goal: GoalCapture | undefined, notice: string | undefined): ChatMsg[] {
+    this.goal = goal;
+    this.phase = initialPhaseState(0, startPhase);
+    return this.deps.resetHistoryForPhase(this.phase, { goal, notice });
+  }
+
+  /**
+   * Rehydrate phase state from a trail. `lastSaved`/`askRounds` stay empty by design: a
+   * resume must re-save and re-interview rather than re-gate work from a previous process.
+   */
+  seedFromResume(recon: PhaseRecon): void {
+    const artifacts: Partial<Record<Phase, ArtifactRef>> = {};
+    for (const [key, value] of Object.entries(recon.artifacts ?? {})) {
+      if (value === undefined || !isPhase(key)) continue;
+      artifacts[key] = Object.freeze({
+        path: value.path,
+        status: value.superseded ? ("superseded" as const) : ("active" as const),
+      });
+    }
+    this.phase = {
+      current: reconcilePhase(recon.current),
+      advancedAt: recon.advancedAt,
+      summary: recon.summary,
+      artifacts,
+      backwardJumps: recon.backwardJumps ?? 0,
+    };
+    this.lastSaved = {};
+    this.askRounds = 0;
+  }
+
+  handlers(): PipelineHandlers {
+    return {
+      saveArtifact: (kind, content) => this.handleSaveArtifact(kind, content),
+      advancePhase: (phase, summary) => this.handleAdvancePhase(phase, summary),
+    };
+  }
+
+  // ── save_artifact ──
+
+  private async handleSaveArtifact(kind: string, content: string): Promise<string> {
+    const stage = stageForArtifactKind(kind);
+    if (stage === undefined) {
+      return formatError(`unknown artifact kind '${kind}' (valid: clarification, research, plan, validation)`);
+    }
+    const current = this.currentPhase();
+    if (stage.phase !== current) {
+      return formatError(`artifact kind '${kind}' belongs to phase '${stage.phase}', but the pipeline is in '${current}'`);
+    }
+    const saved = saveArtifact(this.deps.runCwd, stage.artifactDir, kind, content);
+    if (!saved.ok) return formatError(saved.error);
+
+    // Preflight: run the SAME gate advance_phase will run, now instead of a turn later, and
+    // memoize the verdict so the transition does not re-read and re-gate the file.
+    const critique = critiqueArtifact(stage, content, saved.path, this.deps.runCwd);
+    this.lastSaved = {
+      ...this.lastSaved,
+      [stage.phase]: Object.freeze({ path: saved.path, gateData: critique.gateData }),
+    };
+    if (critique.warnings.length > 0) {
+      this.warnings = Object.freeze([...this.warnings, ...critique.warnings]);
+      this.deps.emitter.emitWarnings(this.warnings);
+    }
+    return `ok — saved ${saved.path}.\n${formatCritique(critique)}`;
+  }
+
+  // ── advance_phase ──
+
+  private async handleAdvancePhase(phase: string, summary: string | undefined): Promise<string> {
+    const current = this.currentPhase();
+    const outcome = validatePhaseTransition(current, phase);
+    if (!outcome.ok) return formatError(outcome.error);
+
+    // Clarify interview gate: the engine counts serviced rounds itself, so the model cannot
+    // advance by merely claiming to have interviewed the user.
+    if (current === "clarify" && this.askRounds === 0) {
+      return formatError("clarify requires at least one ask_user_question round — interview the user before advancing");
+    }
+
+    const gated = this.gateCurrentPhase(current);
+    if (!gated.ok) return formatError(gated.error);
+    const { artifactPath, gateData } = gated;
+
+    const nextArtifacts: Partial<Record<Phase, ArtifactRef>> = { ...(this.phase?.artifacts ?? {}) };
+    if (artifactPath !== undefined) {
+      nextArtifacts[current] = Object.freeze({ path: artifactPath, status: "active" });
+    }
+    this.phase = {
+      current: outcome.phase,
+      advancedAt: this.deps.completedTurns(),
+      summary,
+      artifacts: nextArtifacts,
+      backwardJumps: this.phase?.backwardJumps ?? 0,
+    };
+    await this.deps.persistPhaseRow(this.phase, artifactPath, artifactPath !== undefined ? current : undefined, gateData);
+    this.clearLastSaved(current);
+    this.askRounds = 0;
+    this.pendingReset = this.deps.resetHistoryForPhase(this.phase, { goal: this.goal });
+    return `ok — phase advanced to '${outcome.phase}' (was '${current}'${summary ? `, summary: ${summary.slice(0, 80)}` : ""})`;
+  }
+
+  /**
+   * Measure the current phase's latest save. Deliberately reads `lastSaved` only — falling
+   * back to `phase.artifacts` would let a stale path from before a loop-back pass the gate.
+   */
+  private gateCurrentPhase(
+    current: Phase,
+  ): { ok: true; artifactPath: string | undefined; gateData: StageGateData | undefined } | { ok: false; error: string } {
+    const stage = STAGES[current];
+    if (stage.artifactDir === "") return { ok: true, artifactPath: undefined, gateData: undefined };
+
+    const savedEntry = this.lastSaved[current];
+    const artifactPath = savedEntry?.path;
+    if (artifactPath === undefined) {
+      return {
+        ok: false,
+        error: `phase '${current}' has no saved artifact — call save_artifact("${stage.artifactKind}", content) first`,
+      };
+    }
+    if (savedEntry?.gateData !== undefined) {
+      return { ok: true, artifactPath, gateData: savedEntry.gateData };
+    }
+    // No memo (e.g. the file was written outside save_artifact) — read and gate it now.
+    const content = readArtifact(this.deps.runCwd, artifactPath);
+    if (!content.ok) return { ok: false, error: content.error };
+    const gate = stage.gate(content.value, artifactPath, this.deps.runCwd);
+    if (!gate.ok) return { ok: false, error: gate.error };
+    this.lastSaved = {
+      ...this.lastSaved,
+      [current]: Object.freeze({ path: artifactPath, gateData: gate.value }),
+    };
+    return { ok: true, artifactPath, gateData: gate.value };
+  }
+
+  // ── validate-phase finalize ──
+
+  /**
+   * Decide what a finalize submitted during `validate` means. As with advance_phase, this
+   * measures THIS turn's validation save only, never `phase.artifacts`.
+   */
+  async finalizeInValidate(final: string): Promise<ValidateOutcome> {
+    const phase = this.phase;
+    if (phase === undefined) return { kind: "accept" };
+
+    const vPath = this.lastSaved.validate?.path;
+    if (vPath === undefined) {
+      return {
+        kind: "reject",
+        error: formatError(
+          'finalize rejected — save the validation artifact first via save_artifact("validation", content) with status: ready, blockers_count, and verdict',
+        ),
+      };
+    }
+    const content = readArtifact(this.deps.runCwd, vPath);
+    if (!content.ok) return { kind: "reject", error: formatError(content.error) };
+
+    const gate = STAGES.validate.gate(content.value, vPath, this.deps.runCwd);
+    if (!gate.ok) return { kind: "reject", error: formatError(gate.error) };
+    if (gate.value.kind !== "validation") {
+      return { kind: "reject", error: formatError("internal: validate gate did not return validation data") };
+    }
+
+    const { validation } = gate.value;
+    const route = routeAfterValidate(validation, phase.backwardJumps, this.deps.maxBackwardJumps);
+    if (route.kind === "halt") return { kind: "halt", report: `${route.reason}\n\n${final}` };
+    if (route.kind !== "loop-back") return { kind: "accept" };
+
+    // Loop back to blueprint. Prior artifacts are kept — the append-only journal marks the
+    // blueprint superseded by this validation rather than dropping it.
+    const prior = phase.artifacts.blueprint;
+    const nextArtifacts: Partial<Record<Phase, ArtifactRef>> = {
+      ...phase.artifacts,
+      validate: Object.freeze({ path: vPath, status: "active" }),
+    };
+    if (prior !== undefined) {
+      nextArtifacts.blueprint = Object.freeze({ path: prior.path, status: "superseded", supersededBy: vPath });
+    }
+    this.phase = {
+      current: "blueprint",
+      advancedAt: this.deps.completedTurns(),
+      summary: `loop-back: ${validation.blockersCount} blocker(s)`,
+      artifacts: nextArtifacts,
+      backwardJumps: phase.backwardJumps + 1,
+    };
+    await this.deps.persistPhaseRow(this.phase, vPath, "validate", gate.value, prior?.path);
+    // Clear BOTH so the re-entered blueprint must produce a genuinely fresh plan and a fresh
+    // validation of it, rather than re-gating what was just rejected.
+    this.clearLastSaved("blueprint", "validate");
+    this.askRounds = 0;
+    this.pendingReset = undefined;
+    return { kind: "loop-back", history: this.deps.resetHistoryForPhase(this.phase, { goal: this.goal, validation }) };
+  }
+
+  private currentPhase(): Phase {
+    return this.phase?.current ?? PHASES[0];
+  }
+
+  private clearLastSaved(...phases: readonly Phase[]): void {
+    const next: Partial<Record<Phase, SavedArtifact>> = { ...this.lastSaved };
+    for (const phase of phases) delete next[phase];
+    this.lastSaved = next;
+  }
+}

package/src/core/pipeline.ts

@@ -208,7 +208,7 @@ export function advancePhase(
   current: Phase | undefined,
   target: string,
 ): AdvancePhaseOutcome {
-  if (!PHASES.includes(target as Phase)) {
+  if (!isPhase(target)) {
     return {
       ok: false,
       error: `unknown phase '${target}'; valid phases: ${PHASES.join(", ")}`,
@@ -231,7 +231,7 @@ export function advancePhase(
       phase: from,
     };
   }
-  return { ok: true, phase: target as Phase };
+  return { ok: true, phase: target };
 }
 
 /** Return the current phase (defaults to first phase if undefined). */

package/src/core/types.ts

@@ -10,8 +10,6 @@ export interface Sampling {
   readonly reasoning?: ThinkingLevel;
 }
 
-type MutableSampling = { -readonly [Key in keyof Sampling]?: Sampling[Key] };
-
 export interface RunLogConfig {
   /** Default: true — always-on, opt-out. */
   readonly enabled?: boolean;
@@ -25,59 +23,59 @@ export interface RunLogConfig {
 
 export interface RlmConfig {
   /** Persistent editor-routing mode; when enabled, plain interactive prompts use RLM. */
-  enabled: boolean;
+  readonly enabled: boolean;
   /** Max recursion depth. depth >= maxDepth ⇒ rlm_query falls back to a plain llm_query. */
-  maxDepth: number;
+  readonly maxDepth: number;
   /** Max turns before the engine must finalize. */
-  maxIterations: number;
+  readonly maxIterations: number;
   /** Per-`repl`-block wall-clock timeout inside the worker (seconds). */
-  execTimeoutS: number;
+  readonly execTimeoutS: number;
   /** Parent-side watchdog per sandbox request (ms). */
-  requestTimeoutMs: number;
+  readonly requestTimeoutMs: number;
   /** Concurrency pool for *_batched sub-calls. */
-  maxConcurrentSubcalls: number;
+  readonly maxConcurrentSubcalls: number;
   /** Reject sub-LLM prompts larger than this many chars. */
-  maxPromptChars: number;
+  readonly maxPromptChars: number;
   /** Max USD spend across the whole tree before the engine stops (undefined = no cap). */
-  maxBudgetUsd?: number;
+  readonly maxBudgetUsd?: number;
   /** Max wall-clock ms across the whole tree before the engine stops (undefined = no cap). */
-  maxTimeoutMs?: number;
+  readonly maxTimeoutMs?: number;
   /** Max total input+output tokens across the whole tree before the engine stops (undefined = no cap). */
-  maxTokens?: number;
+  readonly maxTokens?: number;
   /** Max consecutive error turns before the engine stops (undefined = no cap). */
-  maxErrors?: number;
+  readonly maxErrors?: number;
   /** Append the orchestrator addendum to the system prompt. */
-  orchestrator: boolean;
+  readonly orchestrator: boolean;
   /** Enable the phase pipeline (advance_phase + stall nags) at depth 0. */
-  pipeline: boolean;
+  readonly pipeline: boolean;
   /** Max validate→blueprint corrective re-entries when validation reports blockers (default 2). */
-  maxBackwardJumps: number;
+  readonly maxBackwardJumps: number;
   /** Summarize the trajectory when it grows past the threshold (keeps the root window small). */
-  compaction: boolean;
+  readonly compaction: boolean;
   /** Compact when estimated history tokens reach this fraction of the model's context window. */
-  compactionThresholdPct: number;
+  readonly compactionThresholdPct: number;
   /** Python executable used to launch the sandbox worker. */
-  python: string;
+  readonly python: string;
   /** Worker startup wait before treating sandbox init as failed (ms). */
-  sandboxInitTimeoutMs: number;
+  readonly sandboxInitTimeoutMs: number;
   /** Allow ask_user_question() calls from the root REPL. */
-  askUserQuestion: boolean;
+  readonly askUserQuestion: boolean;
   /** Allow todo() calls from the REPL. */
-  todo: boolean;
+  readonly todo: boolean;
   /** Enable the load_library() REPL scaffold (external dirs/files/git repos as extra context slots). */
-  libraryLoader: boolean;
+  readonly libraryLoader: boolean;
   /** ThinkingLevel for the root smart model (set via /rlm-config). */
-  smartReasoning?: ThinkingLevel;
+  readonly smartReasoning?: ThinkingLevel;
   /** Output token cap + temperature for the root smart model per turn.
    *  Keeps each turn short so the next turn's input stays manageable.
    *  `reasoning` is read from `smartReasoning` if omitted here. */
-  rootSampling?: Readonly<Sampling>;
+  readonly rootSampling?: Readonly<Sampling>;
   /** System prompt injected into every llm_query / llm_query_batched sub-call.
    *  Instructs the worker model to respond concisely.
    *  undefined = no system prompt (raw completion). */
-  subSystemPrompt?: string;
+  readonly subSystemPrompt?: string;
   /** Sampling for sub-LLM (worker) calls. */
-  subSampling: MutableSampling;
+  readonly subSampling: Readonly<Sampling>;
   /** Optional run-state persistence configuration. Enabled by default. */
   readonly runLog?: RunLogConfig;
 }

package/src/index.ts

@@ -1,7 +1,6 @@
 /** pi-rlm — Recursive Language Model for Pi. */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
 import { Markdown } from "@earendil-works/pi-tui";
 import { registerRlmCommand } from "./commands/rlm.ts";
 import { registerRlmConfigCommand } from "./commands/rlm-config.ts";
@@ -11,6 +10,7 @@ import { loadSettings, mergeConfig, resolveModelId } from "./config/settings.ts"
 import { RlmController, cheapestModel } from "./mode/rlm-mode.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 { packRepository, formatForLLM, serializeForSandbox } from "./context/repomix-context.ts";
 import { buildNativeSystemPrompt, NATIVE_TURN_REMINDER } from "./prompts/system.ts";
@@ -62,17 +62,24 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     });
 
   // ── Message renderers ──
-  pi.registerMessageRenderer(
-    "rlm-answer",
-    (message, _options, _theme) => new Markdown(String(message.content ?? ""), 1, 0, getMarkdownTheme()),
+  // Markdown themes are derived from the injected `theme`, never pi's module-global
+  // `getMarkdownTheme()` — under jiti that global can be undefined inside a plugin.
+  pi.registerMessageRenderer("rlm-answer", (message, _options, theme) =>
+    new Markdown(String(message.content ?? ""), 1, 0, markdownTheme(theme)),
   );
-  pi.registerMessageRenderer("rlm-question", (message, _options, _theme) =>
-    new Markdown(`**RLM question**\n\n${String(message.content ?? "")}`, 1, 0, getMarkdownTheme()),
+  pi.registerMessageRenderer("rlm-question", (message, _options, theme) =>
+    new Markdown(`**RLM question**\n\n${String(message.content ?? "")}`, 1, 0, markdownTheme(theme)),
   );
-  pi.registerMessageRenderer("rlm-intro", (message, _options, _theme) =>
-    new Markdown(String(message.content ?? ""), 1, 0, getMarkdownTheme()),
+  pi.registerMessageRenderer("rlm-intro", (message, _options, theme) =>
+    new Markdown(String(message.content ?? ""), 1, 0, markdownTheme(theme)),
   );
 
+  // ── CLI flag: `pi --rlm` / `pi --rlm=false` overrides the persisted mode for this run ──
+  pi.registerFlag("rlm", {
+    description: "Start with RLM mode on (repl-only repository reading).",
+    type: "boolean",
+  });
+
   // ── Commands ──
   registerRlmCommand(pi, controller);
   registerRlmConfigCommand(pi, controller);
@@ -85,6 +92,10 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     // Wait for persisted settings before reading controller state
     await settingsReady;
 
+    // An explicit --rlm flag wins over the persisted setting for this session.
+    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;
@@ -102,23 +113,34 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           getModel: () => controller.resolveModels(ctx)?.model,
           getWorkerModel: () => controller.resolveModels(ctx)?.worker,
           registry: ctx.modelRegistry,
-          config: controller.config,
+          getConfig: () => controller.config,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
           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");
           },
         }));
-      } catch { /* re-registration on provider change — ignore if already registered */ }
+      } catch (err) {
+        // Re-registering the same tool each session is expected; anything else is a real failure.
+        const message = errorMessage(err);
+        if (!/already (registered|exists)/i.test(message)) {
+          console.warn(`[rlm] repl tool registration failed: ${message}`);
+        }
+      }
     }
 
-    setRlmModeStatus(ctx.ui, controller);
+    setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
     if (!guidePosted && controller.enabled) {
       guidePosted = true;
       postRlmGuide(pi, controller);
     }
   });
 
+  // ── Keep the footer's context reading live (RLM exists to shrink this number) ──
+  pi.on("turn_end", async (_event, ctx) => {
+    setRlmModeStatus(ctx.ui, controller, ctx.getContextUsage());
+  });
+
   // ── System prompt: native RLM mode addendum (only when enabled) ──
   pi.on("before_agent_start", async (event) => {
     if (!controller.enabled) return;
@@ -146,7 +168,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
         const instruction = [
           "ANALYZE THIS REPOSITORY using repl({code}) — read/grep are DISABLED.",
           "Repository contents are pre-loaded in the Python REPL `context` variable.",
-          "Chunk context via Python, delegate to llm_query. If credits exhausted → report and stop.",
+          "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({
@@ -167,11 +190,6 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     return { messages: filtered };
   });
 
-  // ── Input routing: native mode — agent decides whether to use repl() or other tools ──
-  pi.on("input", async (_event, _ctx) => {
-    return { action: "continue" };
-  });
-
   // ── Native mode restrictions: keep bulk file content out of root-model context ──
   // `edit`/`write` stay unblocked so the agent modifies files through Pi's native
   // tool flow (visible to all plugins, +/- diff preview). File reading/searching

package/src/mode/rlm-mode.ts

@@ -11,6 +11,7 @@ import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-
 import { DEFAULT_RUN_DIR } from "../config/defaults.ts";
 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";
@@ -44,8 +45,13 @@ export class RlmController {
     return this.config.enabled;
   }
 
+  /** Replace the config wholesale — `RlmConfig` is immutable, so edits produce a new object. */
+  setConfig(config: RlmConfig): void {
+    this.config = config;
+  }
+
   setEnabled(enabled: boolean): void {
-    this.config.enabled = enabled;
+    this.config = Object.freeze({ ...this.config, enabled });
     void this.persist();
   }
 
@@ -56,10 +62,6 @@ export class RlmController {
     return next;
   }
 
-  hasSavedModels(): boolean {
-    return Boolean(this.savedWorkerRef || this.workerModel);
-  }
-
   async persist(): Promise<boolean> {
     return await saveSettings({
       config: this.config,
@@ -132,12 +134,7 @@ export class RlmController {
         runState,
         onAskUserQuestion: interactive?.onAskUserQuestion,
         onTodo: interactive?.onTodo,
-        limits: {
-          maxBudgetUsd: this.config.maxBudgetUsd,
-          maxTimeoutMs: this.config.maxTimeoutMs,
-          maxTokens: this.config.maxTokens,
-          maxErrors: this.config.maxErrors,
-        },
+        limits: limitsFromConfig(this.config),
       });
       return await engine(engineInput);
     })().finally(() => {