@hicaru/pi-rlm 0.1.8 → 0.2.0

package/src/index.ts

@@ -1,18 +1,16 @@
 /** 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";
 import { createRlmTool } from "./tool/rlm-tool.ts";
 import { createReplTool } from "./tool/repl-tool.ts";
-import { createApplyEditsTool } from "./tool/apply-edits-tool.ts";
-import { EditRegistry } from "./registry/edit-registry.ts";
 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";
@@ -26,7 +24,6 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   // Init synchronously with defaults — ensures commands/tools/handlers register before session_start
   const config = mergeConfig({});
   const controller = new RlmController(config);
-  const editRegistry = new EditRegistry();
   let onSandboxDiscardExtra: (() => void) | undefined;
   const sandboxManager = new SandboxManager({
     execTimeoutS: config.execTimeoutS,
@@ -34,10 +31,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     python: config.python,
     sandboxInitTimeoutMs: config.sandboxInitTimeoutMs,
     maxPromptChars: config.maxPromptChars,
-    onSandboxDiscarded: () => {
-      editRegistry.clear();
-      onSandboxDiscardExtra?.();
-    },
+    onSandboxDiscarded: () => { onSandboxDiscardExtra?.(); },
   });
   let packedContextText: string | undefined;
   let contextPackPromise: Promise<string | undefined> | undefined;
@@ -68,30 +62,40 @@ 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);
 
   // ── Tool registration ──
   pi.registerTool(createRlmTool(controller));
-  pi.registerTool(createApplyEditsTool(editRegistry));
   let guidePosted = false;
 
   pi.on("session_start", async (_event, ctx) => {
     // 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;
@@ -109,24 +113,34 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           getModel: () => controller.resolveModels(ctx)?.model,
           getWorkerModel: () => controller.resolveModels(ctx)?.worker,
           registry: ctx.modelRegistry,
-          editRegistry,
-          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;
@@ -154,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({
@@ -175,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/native-guards.ts

@@ -86,7 +86,7 @@ export function replDelegationNudge(stdoutChars: number, delegated: boolean): st
   if (delegated || stdoutChars <= NUDGE_STDOUT_CHARS) return undefined;
   return (
     `\n[RLM: this repl() printed ${stdoutChars.toLocaleString()} chars with 0 sub-LLM calls — ` +
-    "delegate semantic reading via llm_query / llm_query_batched / llm_query_chunked instead of " +
-    "reading output yourself.]"
+    "if you were READING, delegate via llm_query / llm_query_batched / llm_query_chunked. " +
+    "Authoring an edit body yourself is correct and needs no delegation.]"
   );
 }

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(() => {

package/src/prompts/phases.ts

@@ -3,7 +3,6 @@
  * Injected at each phase boundary; the only channel between phases is durable
  * artifacts under .rlm/artifacts/.
  */
-import type { PhaseRecord } from "../core/gates.ts";
 import type { Phase } from "../core/pipeline.ts";
 
 const CLARIFY_GUIDANCE = Object.freeze([
@@ -48,7 +47,7 @@ const RESEARCH_GUIDANCE = Object.freeze([
   "Probe the repository, delegate long reads via `llm_query_batched` / `llm_query_chunked`.",
   "Every factual claim about the code MUST be cited as `path/file.ext:LINE` (or `LINE-LINE`).",
   "The engine VERIFIES citations against the working tree — unbacked citations reject advance.",
-  "When research is complete, write ONE research document and call:",
+  "When research is complete, write ONE research document with a `## Findings` section and call:",
   '  `save_artifact("research", content)`  # frontmatter must include `status: ready`',
   '  `advance_phase("blueprint", summary)`',
   "Do not implement code in this phase.",
@@ -59,39 +58,37 @@ const BLUEPRINT_GUIDANCE = Object.freeze([
   "Read the clarifications artifact (if present) and plan only within recorded Decisions;",
   "Open Questions that would block the design must be re-asked via ask_user_question, not assumed.",
   'Produce ONE plan document and save it with `save_artifact("plan", content)`.',
+  "This pipeline is read-only: it produces a plan a human or a native-mode agent executes;",
+  "do not write source files here (sandbox write modes are blocked).",
+  "Write changes as exact, copy-pasteable before/after code — never as prose instructions.",
   "The ENGINE derive-checks the document — these are hard gates, not suggestions:",
   "- frontmatter: `status: ready`, `phase_count: N`, `phases: [{n: 1, title: ...}, ...]`",
   "- `phases:` / `phase_count` MUST match the `## Phase N:` body headings exactly (fenced examples ignored)",
   "- every `file:line` citation MUST resolve against the working tree at this revision",
   "Each `## Phase N: <title>` section contains:",
-  "- `### Changes Required` — per file: path + exact intended change (code from research)",
+  "- `### Changes Required` — per file: path + the exact intended change",
   "- `### Success Criteria` — `#### Automated Verification:` (runnable commands) and",
   "  `#### Manual Verification:` checklists",
-  "Phases are executed by ISOLATED workers, one at a time, in order: each phase must be",
-  "independently implementable, leave the tree working, and never share a file with a",
-  "later phase unless that phase only EDITS what an earlier phase CREATED.",
-  'When ready: `advance_phase("implement", summary)` — the engine runs implement fanout itself.',
-].join("\n"));
-
-const IMPLEMENT_GUIDANCE = Object.freeze([
-  "## Implement phase",
-  "The engine drives serial child-RLM workers over each plan phase — you do not implement",
-  "here. If you were re-entered into implement unexpectedly, call",
-  '`advance_phase("validate")` only after the fanout has already completed.',
+  "Phases must be independently implementable in order, each leaving the tree working.",
+  'When ready: `advance_phase("validate", summary)`.',
 ].join("\n"));
 
 const VALIDATE_GUIDANCE = Object.freeze([
-  "## Validate phase",
+  "## Validate phase (adversarial plan review)",
+  "Nothing has been implemented — you are reviewing the PLAN, not a diff.",
   "Read the goal artifact (verbatim brief), the clarifications artifact (recorded Decisions),",
-  "and the plan. Check each phase's Success Criteria against the working tree.",
-  "Exclude paths listed in the baseline JSON (pre-existing dirt).",
-  "Open Questions are not silently resolved — a blocking one surfaces via ask_user_question.",
-  "Write ONE validation document via `save_artifact(\"validation\", content)` with frontmatter:",
+  "and the plan. For each plan phase check against the working tree:",
+  "- every cited `file:line` still resolves and says what the plan claims",
+  "- every file the phase edits exists (or is created by an earlier phase)",
+  "- no phase contradicts a recorded Decision or silently resolves an Open Question",
+  "- the Success Criteria are actually runnable and actually prove the change",
+  "- phases are independently implementable in the stated order",
+  "Write ONE review via `save_artifact(\"validation\", content)` with frontmatter:",
   "- `status: ready`",
-  "- `blockers_count: <int ≥ 0>`  # MEASURED — routing key; not prose",
+  "- `blockers_count: <int >= 0>`  # MEASURED — routing key; not prose",
   "- `verdict: pass | fail`  # pass requires blockers_count === 0",
   "Each blocker needs a resolvable `file:line` citation.",
-  "Then finalize: `answer[\"content\"] = <report>; answer[\"ready\"] = True`.",
+  "Then finalize: `answer[\"content\"] = <the reviewed plan + review summary>; answer[\"ready\"] = True`.",
   "If `blockers_count > 0`, the engine re-enters blueprint (bounded by maxBackwardJumps).",
 ].join("\n"));
 
@@ -99,27 +96,9 @@ const GUIDANCE: Readonly<Record<Phase, string>> = Object.freeze({
   clarify: CLARIFY_GUIDANCE,
   research: RESEARCH_GUIDANCE,
   blueprint: BLUEPRINT_GUIDANCE,
-  implement: IMPLEMENT_GUIDANCE,
   validate: VALIDATE_GUIDANCE,
 });
 
 export function phaseGuidance(phase: Phase): string {
   return GUIDANCE[phase];
 }
-
-/** Single-phase implement prompt for an isolated child RLM (serial fanout unit). */
-export function buildImplementPhasePrompt(planPath: string, r: PhaseRecord): string {
-  return [
-    `Implement ONLY Phase ${r.n} (${r.title}) of the plan at ${planPath} (${r.index + 1}/${r.total}).`,
-    `Read the plan from the REPL (open("${planPath}").read()).`,
-    "Hard rules (you are one unit of a sequenced run):",
-    "- CRITICAL: `context` is a STALE snapshot from run start. Always `open(path).read()` any file",
-    "  you will edit BEFORE computing stage_edit anchors — earlier phases may have already changed them.",
-    "- Touch ONLY the files this phase's ### Changes Required lists.",
-    "- Earlier phases have already landed; a missing prerequisite file is a HARD ERROR —",
-    "  finalize with 'Error: prerequisite missing: <path>' instead of creating it.",
-    "- Stage every change via stage_edit(path, old_text, new_text); never defer your own edits.",
-    "- Run only THIS phase's '#### Automated Verification:' commands; whole-plan checks are validate's job.",
-    `Finalize with a short summary of what landed for Phase ${r.n}.`,
-  ].join("\n");
-}