@hicaru/pi-rlm 0.2.0 → 0.2.2

package/src/prompts/glossary.ts

@@ -0,0 +1,287 @@
+/**
+ * The REPL vocabulary both prompts are built from.
+ *
+ * Headless (fenced ```repl``` blocks) and native (`repl({code})`) describe the same sandbox, so
+ * every line either lives here once or has an explicit condensed native twin next to it — that
+ * pairing is the whole reason this module exists. Divergence here is a bug: the model is told
+ * about functions that do not exist, or not told about ones that do.
+ */
+
+export type ContextKind = "files" | "text";
+
+/** "str" (raw string context, e.g. rlm_query children) → text; everything else → files. */
+export function contextKindOf(contextType: string): ContextKind {
+  return contextType === "str" ? "text" : "files";
+}
+
+export const DEFAULT_PROMPT_CAP = 400_000;
+
+export function promptCapTokensK(maxPromptChars: number): number {
+  return Math.round(maxPromptChars / 4_000);
+}
+
+/**
+ * Deterministic retrieval over `context` (headless + native).
+ *
+ * The paper's trajectories retrieve with hand-written regex (App. E.1); frontier models do that
+ * well, small ones guess keywords badly, and the first decomposition disproportionately decides
+ * the outcome (§5, Fig. 4a). These cost no tokens and no sub-calls.
+ */
+export const RETRIEVAL_GLOSSARY_LINES: readonly string[] = Object.freeze([
+  "- `search(query: str, k=10, path_glob=None)`: BM25 ranking over `context`. Returns",
+  "  [{path, line, score, snippet}] — POINTERS, not bodies. **Start here.** It is free:",
+  "  no sub-LLM call, no tokens. Use it before you guess at filenames or write regex.",
+  "- `grep_context(pattern, k=50, path_glob=None, before=0, after=0) -> dict`: regex over",
+  "  `context`. Returns {hits: [{path, line, text}], counts: {path: n}, total, truncated} —",
+  "  `counts` is complete even when `hits` is capped, so a wide pattern reports its shape",
+  "  instead of flooding you. Use for exact lexical needles; use `search` for meaning.",
+  "- `outline(path) -> str`: definition/heading skeleton of one file with line numbers.",
+  "  Orient in ~200 chars instead of printing 20K. Matches exact path, then suffix, then glob.",
+]);
+
+/** One-line delegation helpers — orchestrating must be cheaper than solving. */
+export const DELEGATION_GLOSSARY_LINES: readonly string[] = Object.freeze([
+  "- `map_files(files, prompt, model=None) -> dict[path, str]`: ask `prompt` of every file and",
+  "  get back {path: answer}. Accepts context entries or paths, packs them into cap-sized",
+  "  batched sub-calls, and splits oversized files automatically. **This is the default way to",
+  "  read many files** — prefer it over hand-rolling a chunk loop.",
+  "- `llm_map_reduce(items, map_prompt, reduce_prompt, model=None) -> str`: map over items in",
+  "  one batch, then reduce the partial answers with a single call. The paper's canonical",
+  "  strategy (query per chunk → aggregate the buffers) as one call.",
+]);
+
+/** Shared glossary entry for the chunked-query helper (headless + native). */
+export const CHUNKED_GLOSSARY_LINES: readonly string[] = Object.freeze([
+  "- `llm_query_chunked(text: str, prompt: str, model=None) -> list[str]`: auto-splits `text` into",
+  "  chunks that fit the sub-LLM prompt cap, fans them out concurrently (order preserved), and",
+  "  returns one answer per chunk. Use it for ANY text too large for a single `llm_query` — a file",
+  "  you open()ed, an oversized sub-result, or several concatenated context files.",
+]);
+
+/** Non-blocking fan-out: spawn now, collect later (headless glossary). */
+export const SPAWN_GLOSSARY_LINES: readonly string[] = Object.freeze([
+  "- `spawn(fn, *args) -> Task`: start `llm_query`, `llm_query_batched`, `llm_query_chunked`,",
+  "  `map_files`, `rlm_query` or `rlm_query_batched` WITHOUT waiting. Returns immediately.",
+  "  (Not `llm_map_reduce` — its reduce step depends on its own map results.)",
+  "- `rlm_await(task)` / `rlm_await_all(tasks) -> list`: collect results; order matches input.",
+  "  Tasks survive across turns, so spawn the slow work first, keep doing useful things, and",
+  "  await only when you actually need the results. `task.done` tells you if it has landed.",
+  "",
+  "  ```python",
+  "  # start the slow sub-agents, then keep working while they run",
+  "  tasks = [spawn(rlm_query, f\"Audit {area} end to end\") for area in areas]",
+  "  hits = [f for f in context if \"TODO\" in f[\"content\"]]   # overlaps with the sub-agents",
+  "  reports = rlm_await_all(tasks)",
+  "  ```",
+]);
+
+/**
+ * What a parent must know about the child it is about to spawn. Without this the model writes
+ * referential prompts ("read lib/x/src/…") on the assumption the child can go fetch them, which
+ * is what made a missing child context degrade silently instead of failing (issue #4).
+ */
+export const RECURSION_CONTEXT_LINES: readonly string[] = Object.freeze([
+  "",
+  "  **What a child sees:** it inherits YOUR `context` — the repository plus every library you",
+  "  loaded (`lib/<id>/…`) — and runs `search` / `grep_context` / `outline` / `map_files` over the",
+  "  same paths. So send instructions, never file bodies: pasting content you already share costs",
+  "  your tokens twice and buys nothing. Your prompt becomes the child's question.",
+  "  Narrow its world with `rlm_query(prompt, paths=['src/auth/', 'lib/x-9f3a/'])` — path PREFIXES,",
+  "  not globs. Omit `paths` to hand over everything.",
+  "  Inheritance is one-way: libraries the child loads, and its whole REPL, die with it — only its",
+  "  final answer string returns.",
+  "  At the depth cap `rlm_query` degrades to a plain sub-LLM call with NO context, which is why",
+  "  this section disappears at the last recursive depth.",
+]);
+
+/**
+ * Sub-RLM orientation. Emitted only at depth > 0, where `context` is the parent's world rather
+ * than a repository the run packed for itself.
+ */
+export const CHILD_CONTEXT_LINES: readonly string[] = Object.freeze([
+  "  You are a sub-RLM. This `context` is your parent's world — the repository plus every library",
+  "  it loaded (paths under `lib/<id>/…`). Answer only the question above; your REPL and anything",
+  "  you load die with you, and only your final answer string returns to the parent.",
+]);
+
+/** Why a file the user mentioned may be missing from `context`. */
+export const CONTEXT_EXCLUSION_NOTE =
+  "  NOTE: files larger than 1MB and gitignored files are NOT in `context` — they exist only on disk.";
+
+/** The large-on-disk-file protocol (headless + native). */
+export const LARGE_FILE_RULE_LINES: readonly string[] = Object.freeze([
+  "**Large on-disk files (profiles, logs, dumps, generated JSON):** files >1MB or gitignored are",
+  "absent from `context`. Protocol:",
+  '1. Load in Python: `raw = open("dhat-heap.json").read()` — loading into a variable is fine.',
+  "2. Deterministic processing in Python (`json.load`, `re`, counting, aggregation) is fine and preferred.",
+  "3. The moment you need MEANING from raw text (summarize, explain, find anomalies), do NOT read it",
+  "   yourself — call `llm_query_chunked(raw, question)`, or slice + `llm_query_batched`.",
+  "4. Never print more than a small probe (~2K chars) of raw content.",
+  'Example: `parts = llm_query_chunked(raw, "Extract top allocation sites with byte totals")`, then',
+  "aggregate `parts` in Python or with one final `llm_query`.",
+]);
+
+/** Concise native-mode glossary line for the chunked helper (native prompt has a 6K budget). */
+export const CHUNKED_GLOSSARY_LINE_NATIVE =
+  "- `llm_query_chunked(text, prompt, model=None) -> list[str]` — auto-splits oversized text into cap-sized chunks, fans out concurrently; one answer per chunk.";
+
+/** Concise native-mode large-file rule (folds in the context-exclusion note; native 6K budget). */
+export const LARGE_FILE_RULE_NATIVE =
+  "- Files >1MB or gitignored are NOT in `context`: open() + parse deterministically in Python is fine; ANY semantic reading of the raw text goes through llm_query_chunked. Never print >2K chars raw.";
+
+/**
+ * The decomposition doctrine, ported from the RLM paper's Appendix C.3 `<env_tips>` and
+ * retargeted from competition math to repository analysis.
+ *
+ * This block is the single highest-leverage prompt intervention the paper reports: +69.5% on
+ * LongCoT-mini over the same RLM without it (Table 2). Plain RLM prompting alone actually
+ * *regressed* two of the five categories; the doctrine is what fixed them. Its purpose is to
+ * counter under-delegation — the model doing the work itself in the REPL instead of fanning out.
+ *
+ * Note the counterweight: `orchestratorAddendum` carries the anti-OVER-recursion batching rule.
+ * The paper is explicit (App. B) that one prompt does not port across models and that both
+ * guardrails are needed; keep them both.
+ */
+export const ENV_TIPS = [
+  "## Decomposition doctrine",
+  "",
+  "**Orchestrate; don't solve.** A single chain of thought over a large repository drifts —",
+  "you lose partials and compound mistakes. Your sub-LLMs are competent readers: given a",
+  "self-contained prompt and the text, they will extract, locate, classify, and summarize",
+  "reliably. Trust them; don't do their reading yourself.",
+  "",
+  "Your job: (1) find the relevant slice with `search` / `grep_context` / `outline`,",
+  "(2) delegate all semantic reading to `map_files` / `llm_query_batched` / `llm_map_reduce`,",
+  "(3) memoize every result you will reuse in `answers`, (4) sanity-check an answer before",
+  "another step depends on it, (5) assemble the final answer from `answers` by lookup.",
+  "Your own compute is: pointers, dict lookups, string formatting, and decisions.",
+  "",
+  "### The only state that matters",
+  "`answers` and `plan` are dicts that persist across every turn.",
+  "**If a value isn't in `answers`, it doesn't exist.** Do not trust a number from your own",
+  "earlier reasoning or from truncated stdout — context drifts. Memoize everything you reuse.",
+  "",
+  "### Shape of a run",
+  "1. Probe: `print(len(context))`, `search(<the user's question>)`. Do not print file bodies.",
+  "2. Plan: write the sub-questions into `plan`; each must be answerable from a named slice.",
+  "3. Fan out: one `map_files` / `llm_query_batched` per independent group, not one call per",
+  "   file. Store results into `answers` keyed by path or sub-question.",
+  "4. Assemble: build the answer from `answers`. Delegate the aggregation too if it is large.",
+  "",
+  "### Red flags — you are off track",
+  "- Printing file bodies to read them yourself → stop, delegate to `map_files`.",
+  "- Writing regex to *infer meaning* (naming conventions, intent, correctness) → that is a",
+  "  sub-LLM job. Regex is for exact lexical needles only.",
+  "- Two turns in with zero sub-LLM calls on an analysis task → you are solving it yourself.",
+  "- About to reuse a value that is not in `answers` → re-derive it and store it.",
+  "- One sub-call per file over dozens of files → batch them; fat prompts in small batches win.",
+].join("\n");
+
+/** Native-mode variant of the doctrine — same rules, sized for the native prompt budget. */
+export const ENV_TIPS_CONDENSED = [
+  "### Decomposition doctrine (paper App. C.3 — worth +69.5% there)",
+  "Orchestrate; don't solve. Loop: `search`/`grep_context`/`outline` to find the slice →",
+  "`map_files` / `llm_query_batched` to read it → memoize into `answers` → assemble by lookup.",
+  "`answers` and `plan` persist across every turn: **if a value isn't in `answers`, it",
+  "doesn't exist** — never reuse a number from your own earlier reasoning or truncated stdout.",
+  "Red flags: printing file bodies to read them; regex used to infer meaning rather than match",
+  "a literal; two turns into an analysis with zero sub-LLM calls; one sub-call per file instead",
+  "of one batch. Exception — AUTHORING is not reading: you write every edit body yourself.",
+].join("\n");
+
+export function howToRunCode(): string {
+  return [
+    "To run Python, write a fenced ```repl``` block. The REPL **persists** across turns. Only",
+    "`print(...)` output (stdout) is returned; a bare expression on the last line is discarded, so",
+    "always wrap inspections in `print(...)`.",
+  ].join(" ");
+}
+
+export function replGlossary(
+  kind: ContextKind,
+  recursion: boolean,
+  libraryLoader: boolean,
+  child: boolean,
+): string {
+  const lines = ["Available in the REPL:"];
+  if (kind === "text") {
+    lines.push(
+      "- `context`: str — the raw text you must analyze. Probe it with slices",
+      "  (`print(context[:2000])`), split it programmatically, and delegate large chunks",
+      "  to sub-LLMs — never dump the whole string into your own output.",
+    );
+  } else {
+    lines.push(
+      "- `context`: list[dict] — a pre-packed JSON array of every file in the repository. Each dict has",
+      "  keys: `path` (relative file path, str), `content` (file text, str), `tokens` (estimated count, int).",
+      "  For large repos, chunk `context` into batches and delegate to sub-LLMs — never dump raw file",
+      "  bodies into your own output.",
+      CONTEXT_EXCLUSION_NOTE,
+    );
+    if (child) lines.push(...CHILD_CONTEXT_LINES);
+    lines.push(
+      "",
+      "  Worked example — find the slice, then delegate it:",
+      "  ```python",
+      '  hits = search("where is the retry/backoff policy configured?", k=8)',
+      "  paths = sorted({h['path'] for h in hits})",
+      '  answers.update(map_files(paths, "Describe any retry/backoff policy in this file, with line numbers. Say NONE if absent."))',
+      "  print({p: a[:80] for p, a in answers.items()})",
+      "  ```",
+    );
+  }
+  lines.push(...RETRIEVAL_GLOSSARY_LINES);
+  lines.push(
+    "- `llm_query(prompt: str, model=None) -> str`: a single sub-LLM completion. Use for extraction,",
+    "  summarization, or Q&A over a chunk of text.",
+    "- `llm_query_batched(prompts: list[str], model=None) -> list[str]`: run several sub-LLM calls",
+    "  concurrently; output order matches input order.",
+    ...CHUNKED_GLOSSARY_LINES,
+    ...SPAWN_GLOSSARY_LINES,
+    ...DELEGATION_GLOSSARY_LINES,
+  );
+  if (libraryLoader) {
+    lines.push(
+      "- `load_library(source: str) -> dict`: load an EXTERNAL library, source tree, or document and",
+      "  **APPEND its files into the existing `context` list** (same shape: path/content/tokens).",
+      "  `source` may be a local directory (repomix-packed), a single file path, or an https/git@ URL",
+      "  (shallow-cloned, then packed). Paths are namespaced under `lib/<source_id>/…` so you can filter",
+      "  by prefix. Returns metadata only:",
+      "  {\"source\", \"source_id\", \"path_prefix\", \"files\", \"chars\", \"context_len\", \"already_loaded\"}",
+      "  or an \"Error: ...\" string. **Never treat the return value as the file list** — always search",
+      "  and chunk the single variable `context`. Do not invent `context_1` / aliases; do not call",
+      "  globals()/locals(). Idempotent: re-loading the same source is a no-op.",
+      "",
+      "  ```python",
+      "  info = load_library(\"/path/to/other-project\")",
+      "  # info is metadata; files are already in context under info[\"path_prefix\"]",
+      "  lib_files = [f for f in context if f[\"path\"].startswith(info[\"path_prefix\"])]",
+      "  ```",
+    );
+  }
+  if (recursion) {
+    lines.push(
+      "- `rlm_query(prompt, model=None)` / `rlm_query_batched(prompts, model=None)`: recursive RLM",
+      "  sub-calls. Each child runs a full REPL loop internally — its entire conversation is PRIVATE",
+      "  and never enters your history. Only the final answer (a short string) is returned.",
+      "",
+      "  **Choosing between `llm_query` and `rlm_query`:**",
+      "  - `llm_query` for simple one-shot tasks — summarize a chunk, extract a fact, answer a direct",
+      "    question. It is a single LLM call: fast and cheap. Prefer it by default, and fan out with",
+      "    `llm_query_batched` for parallel one-shots.",
+      "  - `rlm_query` only when a sub-task genuinely needs iterative reasoning with its own code",
+      "    execution (e.g. a sub-context large enough to need its own chunking, or a multi-step",
+      "    reasoning chain). It is slower and more expensive — reserve it for cases `llm_query` cannot",
+      "    handle. Avoid excessive recursive sub-calls when a batched one-shot would suffice.",
+      ...RECURSION_CONTEXT_LINES,
+    );
+  }
+  lines.push(
+    "- `answers` / `plan`: two dicts that persist across turns. Memoize every",
+    "  verified result in `answers` — see the decomposition doctrine below.",
+    "- `SHOW_VARS() -> str`: list every variable currently in the REPL.",
+    '- `answer`: a dict initialized to {"content": "", "ready": False}. To submit your final answer,',
+    '  set `answer["content"]` to the answer text and `answer["ready"] = True`.',
+  );
+  return lines.join("\n");
+}

package/src/prompts/native.ts

@@ -0,0 +1,127 @@
+/** Native-mode prompts — the main Pi agent drives the sandbox through the `repl` tool. */
+
+import {
+  CHUNKED_GLOSSARY_LINE_NATIVE,
+  ENV_TIPS_CONDENSED,
+  LARGE_FILE_RULE_NATIVE,
+  DEFAULT_PROMPT_CAP,
+  promptCapTokensK,
+} from "./glossary.ts";
+
+/** Adapts the REPL glossary for native mode — agent calls `repl({code})` instead of writing ```repl``` blocks. */
+function nativeReplGlossary(): string {
+  return [
+    "## RLM Native Mode — Persistent Python REPL",
+    "",
+    "Call `repl({code: \"...\"})` to execute Python in a **persistent** sandbox. Variables, imports,",
+    "State persists; only `print()` output is returned, so wrap inspections in `print(...)`.",
+    "",
+    "### REPL Environment",
+    "- `context`: list[dict] — every file in the repository. Each dict: `path` (str), `content` (str), `tokens` (int).",
+    "",
+    "Retrieval — free (no sub-LLM call, no tokens). **Start here, before guessing filenames:**",
+    "- `search(query, k=10, path_glob=None) -> [{path, line, score, snippet}]` — BM25 over `context`. Returns pointers, not bodies.",
+    "- `grep_context(pattern, k=50, path_glob=None, before=0, after=0) -> {hits, counts, total, truncated}` — regex; `counts` stays complete when `hits` is capped. Lexical needles only.",
+    "- `outline(path) -> str` — definition/heading skeleton with line numbers. Orient in ~200 chars instead of printing 20K.",
+    "",
+    "Delegation — everything semantic goes through these:",
+    "- `map_files(files, prompt, model=None) -> {path: answer}` — ask `prompt` of many files; batches and splits oversized files for you. **The default way to read many files.**",
+    "- `llm_map_reduce(items, map_prompt, reduce_prompt, model=None) -> str` — map in one batch, then reduce with one call.",
+    "- `llm_query(prompt, model=None) -> str` — one-shot sub-LLM. Use for extraction, summarization, Q&A over a chunk.",
+    "- `llm_query_batched(prompts, model=None) -> list[str]` — concurrent sub-LLM calls; output order matches input order.",
+    CHUNKED_GLOSSARY_LINE_NATIVE,
+    "- `rlm_query(prompt, model=None, paths=None) -> str` — recursive RLM with its own REPL for complex sub-tasks needing iterative reasoning. Prefer llm_query — rlm_query is slower and costlier. The child inherits your `context` (repo + loaded libraries) and takes your prompt as its question, so describe the task; never paste file text. `paths=['src/auth/']` narrows its context by prefix.",
+    "- `rlm_query_batched(prompts, model=None) -> list[str]` — concurrent recursive RLM calls.",
+    "- `spawn(fn, *args) -> Task` / `rlm_await(t)` / `rlm_await_all(ts)` — start `llm_query`, `llm_query_batched`, `llm_query_chunked`, `map_files`, `rlm_query` or `rlm_query_batched` without waiting (NOT `llm_map_reduce`); collect later, order preserved. Tasks outlive the repl() call, so spawn slow work early and await when you need it.",
+    "",
+    "",
+    "- `answers` / `plan` — dicts persisted across every repl() call. Your memo.",
+    "- `load_library(source) -> dict`: append external dir/file/git tree into `context` under `lib/<id>/…`. Return is metadata only — always use `context`.",
+    "- `SHOW_VARS() -> str` — list all variables currently in the REPL.",
+    "- `answer`: dict `{\"content\": \"\", \"ready\": False}`. Setting `answer[\"ready\"] = True` delivers it to the user; do not restate it.",
+    "",
+    ENV_TIPS_CONDENSED,
+    "",
+    "### Worked pattern",
+    "```python",
+    'hits = search("where is retry/backoff configured?", k=8)',
+    "paths = sorted({h['path'] for h in hits})",
+    'answers.update(map_files(paths, "Describe any retry/backoff policy here, with line numbers. Say NONE if absent."))',
+    "print({p: a[:80] for p, a in answers.items()})",
+    "```",
+    `- Sub-prompts cap at ${DEFAULT_PROMPT_CAP.toLocaleString()} chars (≈${promptCapTokensK(DEFAULT_PROMPT_CAP)}K tokens); ~20 prompts per batch. Fat prompts in small batches > thousands of tiny prompts.`,
+    "",
+    "### Choosing Between Tools",
+    "| Tool | When |",
+    "|------|------|",
+    "| `repl({code})` | ALL repository reading, search, and analysis; Python scripting; state across calls |",
+    "| `edit` / `write` | Change or create a file. Compose oldText/newText yourself; exact match required |",
+    "| `search` / `grep_context` / `outline` (in repl) | Locate the relevant slice — free, do this first |",
+    "| `zebra-mcp` | Semantic/embedding search when lexical `search` misses the concept |",
+    "| `map_files` / `llm_query_batched` (in repl) | Read/extract/classify that slice |",
+    "| `rlm_query` (in repl) | Sub-task needing its own iterative reasoning and REPL |",
+    "",
+    "### Task-Specific Patterns",
+    LARGE_FILE_RULE_NATIVE,
+    "- Architecture/code review: `search` for the subsystem, then `map_files` the hits.",
+    "- Bug investigation: `grep_context` for the literal symbol/message, then `map_files` the matching files.",
+    "- Finalizing: for file changes call `edit`/`write` directly so Pi validates the anchor and renders the diff; for analysis, write a normal message.",
+    "- If sub-LLM credits are exhausted, report partial results and stop — do not bypass REPL restrictions.",
+    "",
+    "Reserve your own tokens for high-level decisions: what to ask next, how to combine sub-LLM outputs, when to finalize.",
+    "Delegate everything else. Do not submit a final answer before inspecting `context`.",
+  ].join("\n");
+}
+
+/** Build the native-mode system prompt for the main Pi agent. */
+export function buildNativeSystemPrompt(): string {
+  return [
+    "╔══════════════════════════════════════════════════════════════════╗",
+    "║  NATIVE RLM MODE — YOU ARE AN ORCHESTRATOR, NOT A READER      ║",
+    "╚══════════════════════════════════════════════════════════════════╝",
+    "",
+    "ENFORCED BY THE RUNTIME (not advisory):",
+    "- `read`/`grep` are blocked; bash readers (cat/sed/head/tail/awk/rg) are blocked; bash output is hard-capped at 4K chars.",
+    "- repl() stdout returned to you is hard-capped at 4K chars — printing file bodies is USELESS; the text will not reach you.",
+    "",
+    "LOCATE-THEN-DELEGATE: `search(query)` / `grep_context(pattern)` / `outline(path)` cost nothing",
+    "— run them FIRST to find the relevant slice. Then, if a step needs MEANING from more than ~4K",
+    "chars, that reading MUST be a map_files / llm_query / llm_query_batched / llm_query_chunked",
+    "call (rlm_query for iterative sub-tasks). Deterministic Python over `context` is free and",
+    "preferred for lookups. Semantic reading is always delegated.",
+    "",
+    "All file content is pre-loaded in the REPL `context` variable. Use ONLY `repl({code})`.",
+    "If sub-LLM credits are exhausted → report the error to the user and stop.",
+    "",
+    "AUTHORING RULE: sub-LLMs (`llm_query` family) READ — they extract, locate, and summarize.",
+    "They never author code you will ship. Once you know WHAT to change, compose the exact",
+    "oldText / newText yourself and apply it with `edit`. Delegated code is written by a small",
+    "model with no view of the codebase; it is a research aid, never a patch.",
+    "Never re-type file bodies or `answer[\"content\"]` in your own output.",
+    "",
+    nativeReplGlossary(),
+  ].join("\n");
+}
+
+/** Soft cap on the static native prompt. Leaves headroom for per-turn context injection
+ *  without bloating the root model's system prompt. Exceeded → phase-guards.ts fails.
+ *  Raised from 6K when the retrieval glossary and the condensed decomposition doctrine
+ *  landed; both buy far more than they cost (paper Table 2, Fig. 4a), then again for
+ *  spawn/rlm_await: the async fan-out API is part of the model-visible contract, and
+ *  ~50 tokens is worth the model actually using it. */
+export const NATIVE_PROMPT_BUDGET = 7_700;
+
+/** Exported for tests — prompt length without context metadata (which is injected separately). */
+export const NATIVE_PROMPT_STATIC = buildNativeSystemPrompt();
+
+/** Per-turn last-position reminder for native mode — appended to every context build. */
+export const NATIVE_TURN_REMINDER = [
+  "[RLM orchestrator contract — enforced by the runtime, not optional:",
+  "repl() stdout to you is hard-capped at 4K chars; read/grep and bash readers are blocked.",
+  "LOCATE FIRST with search() / grep_context() / outline() — they cost nothing. Any SEMANTIC",
+  "reading MUST then go through map_files / llm_query / llm_query_batched / llm_query_chunked",
+  "(rlm_query for iterative sub-tasks). Memoize what you reuse in `answers`; a value not in",
+  "`answers` does not exist. AUTHORING IS NOT READING: you write every edit body yourself and",
+  "apply it with the native `edit` / `write` tools — never delegate code you will ship.",
+  "Keep your own output to decisions, authored edits, and aggregation.]",
+].join("\n");