ypi 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+All notable changes to ypi are documented here.
+Format based on [Keep a Changelog](https://keepachangelog.com/).
+
+## [0.2.0] - 2026-02-12
+
+### Added
+- **Cost tracking**: children default to `--mode json`, parsed by `rlm_parse_json` for structured cost/token data
+- **Budget enforcement**: `RLM_BUDGET=0.50` caps dollar spend for entire recursive tree
+- **`rlm_cost` command**: agent can query cumulative spend at any time (`rlm_cost` or `rlm_cost --json`)
+- **`rlm_parse_json`**: streams text to stdout, captures cost via fd 3 to shared cost file
+- System prompt updated with cost awareness (SECTION 4 teaches `rlm_cost`)
+- `rlm_query` source embedded in system prompt (SECTION 6) so agents understand their own infrastructure
+
+### Changed
+- **Uniform children**: removed separate leaf path — all depths get full tools, extensions, sessions, jj workspaces
+- **Extensions on by default** at all depths (`RLM_EXTENSIONS=1`)
+- **`RLM_CHILD_EXTENSIONS`**: per-instance extension override for depth > 0
+- Recursion limited by removing `rlm_query` from PATH at max depth (not `--no-tools`)
+- `RLM_JSON=0` opt-out for plain text mode (disables cost tracking)
+
+### Removed
+- Separate leaf code path (`--no-tools`, `--no-extensions`, `--no-session` at max depth)
+- sops/age/gitleaks references from README and install.sh (internal only)
+
+## [0.1.0] - 2026-02-12
+
+Initial release.
+
+### Added
+- `ypi` launcher — starts Pi as a recursive coding agent
+- `rlm_query` — bash recursive sub-call function (analog of Python RLM's `llm_query()`)
+- `SYSTEM_PROMPT.md` — teaches the LLM to use recursion + bash for divide-and-conquer
+- Guardrails: timeout (`RLM_TIMEOUT`), call limits (`RLM_MAX_CALLS`), depth limits (`RLM_MAX_DEPTH`)
+- Model routing: `RLM_CHILD_MODEL` / `RLM_CHILD_PROVIDER` for cheaper sub-calls
+- jj workspace isolation for recursive children (`RLM_JJ`)
+- Session forking and trace logging (`PI_TRACE_FILE`, `RLM_TRACE_ID`)
+- Pi extensions support (`RLM_EXTENSIONS`, `RLM_CHILD_EXTENSIONS`)
+- `install.sh` for curl-pipe-bash installation
+- npm package with `ypi` and `rlm_query` as global CLI commands

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raymond Weitekamp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# ypi
+
+**ypi** — a recursive coding agent built on [Pi](https://github.com/badlogic/pi-mono).
+
+Named after the [Y combinator](https://en.wikipedia.org/wiki/Fixed-point_combinator#Y_combinator) from lambda calculus — the fixed-point combinator that enables recursion. `ypi` is Pi that can call itself. (`rpi` already has another connotation.)
+
+Inspired by [Recursive Language Models](https://github.com/alexzhang13/rlm) (RLM), which showed that an LLM with a code REPL and a `llm_query()` function can recursively decompose problems, analyze massive contexts, and write code — all through self-delegation.
+
+## The Idea
+
+Pi already has a bash REPL. We add one function — `rlm_query` — and a system prompt that teaches Pi to use it recursively. Each child gets its own [jj](https://martinvonz.github.io/jj/) workspace for file isolation. That's the whole trick.
+
+```
+┌──────────────────────────────────────────┐
+│  ypi (depth 0)                           │
+│  Tools: bash, rlm_query                  │
+│  Workspace: default                      │
+│                                          │
+│  > grep -n "bug" src/*.py                │
+│  > sed -n '50,80p' src/app.py \          │
+│      | rlm_query "Fix this bug"          │
+│            │                             │
+│            ▼                             │
+│    ┌────────────────────────────┐        │
+│    │  ypi (depth 1)            │        │
+│    │  Workspace: jj isolated   │        │
+│    │  Edits files safely       │        │
+│    │  Returns: patch on stdout │        │
+│    └────────────────────────────┘        │
+│                                          │
+│  > jj squash --from <child-change>       │
+│  # absorb the fix into our working copy  │
+└──────────────────────────────────────────┘
+```
+
+---
+
+## Using ypi
+
+### Install
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/rawwerks/ypi/master/install.sh | bash
+```
+
+Or manually:
+
+```bash
+git clone https://github.com/rawwerks/ypi.git
+cd ypi
+git submodule update --init --depth 1  # pulls pi-mono
+export PATH="$PWD:$PATH"
+```
+
+### Run
+
+```bash
+# Interactive
+ypi
+
+# One-shot
+ypi "Refactor the error handling in this repo"
+
+# Different model
+ypi --provider anthropic --model claude-sonnet-4-5-20250929 "What does this codebase do?"
+```
+
+### How It Works
+
+**Three pieces** (same architecture as Python RLM):
+
+| Piece | Python RLM | ypi |
+|---|---|---|
+| System prompt | `RLM_SYSTEM_PROMPT` | `SYSTEM_PROMPT.md` |
+| Context / REPL | Python `context` variable | `$CONTEXT` file + bash |
+| Sub-call function | `llm_query("prompt")` | `rlm_query "prompt"` |
+
+**Recursion:** `rlm_query` spawns a child Pi process with the same system prompt and tools. The child can call `rlm_query` too:
+
+```
+Depth 0 (root)    → full Pi with bash + rlm_query
+  Depth 1 (child) → full Pi with bash + rlm_query, own jj workspace
+    Depth 2 (leaf) → plain LM call, no tools (RLM_MAX_DEPTH reached)
+```
+
+**File isolation with jj:** Each recursive child gets its own [jj workspace](https://martinvonz.github.io/jj/latest/working-copy/). The parent's working copy is untouched. Review child work with `jj diff -r <change-id>`, absorb with `jj squash --from <change-id>`.
+
+### Guardrails
+
+| Feature | Env var | What it does |
+|---------|---------|-------------|
+| Budget | `RLM_BUDGET=0.50` | Max dollar spend for entire recursive tree |
+| Timeout | `RLM_TIMEOUT=60` | Wall-clock limit for entire recursive tree |
+| Call limit | `RLM_MAX_CALLS=20` | Max total `rlm_query` invocations |
+| Model routing | `RLM_CHILD_MODEL=haiku` | Use cheaper model for sub-calls |
+| Depth limit | `RLM_MAX_DEPTH=3` | How deep recursion can go |
+| jj disable | `RLM_JJ=0` | Skip workspace isolation |
+| Plain text | `RLM_JSON=0` | Disable JSON mode (no cost tracking) |
+| Tracing | `PI_TRACE_FILE=/tmp/trace.log` | Log all calls with timing + cost |
+
+The agent can check spend at any time:
+
+```bash
+rlm_cost          # "$0.042381"
+rlm_cost --json   # {"cost": 0.042381, "tokens": 12450, "calls": 3}
+```
+
+---
+
+## Contributing
+
+### Project Structure
+
+```
+ypi/
+├── ypi                    # Launcher: sets up env, starts Pi as recursive agent
+├── rlm_query              # The recursive sub-call function (Pi's analog of rlm llm_query())
+├── SYSTEM_PROMPT.md       # Teaches the LLM to be recursive + edit code
+├── AGENTS.md              # Meta-instructions for the agent (read by ypi itself)
+├── Makefile               # test targets
+├── tests/
+│   ├── test_unit.sh       # Mock pi, test bash logic (no LLM, fast)
+│   ├── test_guardrails.sh # Test guardrails (no LLM, fast)
+│   └── test_e2e.sh        # Real LLM calls (slow, costs ~$0.05)
+├── pi-mono/               # Git submodule: upstream Pi coding agent
+└── README.md
+```
+
+### Version Control
+
+This repo uses **[jj](https://martinvonz.github.io/jj/)** for version control. Git is only for GitHub sync.
+
+```bash
+jj status                    # What's changed
+jj describe -m "message"     # Describe current change
+jj new                       # Start a new change
+jj bookmark set master       # Point master at current change
+jj git push                  # Push to GitHub
+```
+
+**Never use `git add/commit/push` directly.** jj manages git under the hood.
+
+### Testing
+
+```bash
+make test-fast    # 54 tests, no LLM calls, seconds
+make test-e2e     # Real LLM calls, costs ~$0.05
+make test         # Both
+```
+
+**Before any change to `rlm_query`:** run `make test-fast`. After: run it again. `rlm_query` is a live dependency of the agent's own execution — breaking it breaks the agent.
+
+
+### History
+
+ypi went through four approaches before landing on the current design:
+
+1. **Tool-use REPL** (exp 010/012) — Pi's `completeWithTools()`, ReAct loop. 77.6% on LongMemEval.
+2. **Python bridge** — HTTP server between Pi and Python RLM. Too complex.
+3. **Pi extension** — Custom provider with search tools. Not true recursion.
+4. **Bash RLM** (`rlm_query` + `SYSTEM_PROMPT.md`) — True recursion via bash. **Current approach.**
+
+The key insight: Pi's bash tool **is** the REPL. `rlm_query` **is** `llm_query()`. No bridge needed.
+
+---
+
+## See Also
+
+- [Pi coding agent](https://github.com/badlogic/pi-mono) — the underlying agent
+- [Recursive Language Models](https://github.com/alexzhang13/rlm) — the library that inspired this
+- [rlm-cli](https://github.com/rawwerks/rlm-cli) — Python RLM CLI (budget, timeout, model routing)

package/SYSTEM_PROMPT.md

@@ -0,0 +1,122 @@
+# SYSTEM_PROMPT.md
+
+## SECTION 1 – Core Identity
+- You are a **recursive LLM** equipped with a Bash shell and the `rlm_query` tool.
+- The environment variable `RLM_DEPTH` tells you your current recursion depth; respect `RLM_MAX_DEPTH` and be more **conservative** (fewer sub‑calls, more direct actions) the deeper you are.
+- You can **read files, write files, run commands, and delegate work** to sub‑agents via `rlm_query`.
+- Sub‑agents inherit the same capabilities and receive their own isolated context.
+- All actions should aim to be **deterministic and reproducible**.
+
+## SECTION 2 – Context Analysis (QA over Context)
+Your environment is initialized with a `$CONTEXT` file that may contain the information needed to answer a query.
+
+**Key workflow**
+1. **Check size first** – `wc -l "$CONTEXT"` and `wc -c "$CONTEXT"`. Small contexts (≈ 5 KB) can be read directly; larger ones require search + chunking.
+2. **Search** – use `grep` (or `rg`) to locate relevant keywords before invoking `rlm_query`.
+3. **Chunk** – break large files into line ranges (e.g., 500‑line windows) and feed each chunk to a sub‑LLM.
+4. **Delegate** – use the two `rlm_query` patterns:
+   ```bash
+   # Pipe a specific chunk
+   sed -n '100,200p' "$CONTEXT" | rlm_query "Your question"
+
+   # Inherit the whole context (no pipe)
+   rlm_query "Your question"
+   ```
+5. **Combine** – aggregate answers from chunks, deduplicate, and produce the final response.
+
+### Example Patterns (keep all five)
+
+**Example 1 – Short context, direct approach**
+```bash
+wc -c "$CONTEXT"
+# 3200 chars — small enough to read directly
+cat "$CONTEXT"
+# Now I can see the content and answer the question
+```
+
+**Example 2 – Long context, search and delegate**
+```bash
+# First, explore the structure
+wc -l "$CONTEXT"
+head -50 "$CONTEXT"
+grep -n "Chapter" "$CONTEXT"
+
+# Found relevant section around line 500. Delegate reading to a sub‑call:
+sed -n '480,600p' "$CONTEXT" | rlm_query "Who is the author of this chapter? Return ONLY the name."
+```
+
+**Example 3 – Chunk and query**
+```bash
+# Check size
+TOTAL=$(wc -l < "$CONTEXT")
+echo "Context has $TOTAL lines"
+
+# Search for keywords first
+grep -n "graduation\|degree\|university" "$CONTEXT"
+
+# Delegate each chunk:
+ANSWER1=$(sed -n '1950,2100p' "$CONTEXT" | rlm_query "What degree did the user graduate with? Quote the evidence.")
+ANSWER2=$(sed -n '7900,8100p' "$CONTEXT" | rlm_query "What degree did the user graduate with? Quote the evidence.")
+
+# Combine results
+echo "Chunk 1: $ANSWER1"
+echo "Chunk 2: $ANSWER2"
+```
+
+**Example 4 – Iterative chunking for huge contexts**
+```bash
+TOTAL=$(wc -l < "$CONTEXT")
+CHUNK=500
+for START in $(seq 1 $CHUNK $TOTAL); do
+    END=$((START + CHUNK - 1))
+    RESULT=$(sed -n "${START},${END}p" "$CONTEXT" | rlm_query "Extract any mentions of concerts or live music events. Return a numbered list, or 'none' if none found.")
+    if [ "$RESULT" != "none" ]; then
+        echo "Lines $START-$END: $RESULT"
+    fi
+done
+```
+
+**Example 5 – Temporal reasoning with computation**
+```bash
+grep -n "started\|began\|finished\|completed" "$CONTEXT"
+
+START_DATE=$(sed -n '300,500p' "$CONTEXT" | rlm_query "When exactly did the user start this project? Return ONLY the date in YYYY-MM-DD format.")
+END_DATE=$(sed -n '2000,2200p' "$CONTEXT" | rlm_query "When exactly did the user finish this project? Return ONLY the date in YYYY-MM-DD format.")
+
+python3 -c "from datetime import date; d1=date.fromisoformat('$START_DATE'); d2=date.fromisoformat('$END_DATE'); print((d2-d1).days, 'days')"
+```
+
+## SECTION 3 – Coding and File Editing
+- You may be asked to **modify code, add files, or restructure the repository**.
+- First, check whether you are inside a **jj workspace**:
+  ```bash
+  jj root 2>/dev/null && echo "jj workspace detected"
+  ```
+- In a jj workspace, every edit you make is **isolated**; the parent worktree remains untouched until you `jj commit`.
+- **Write files directly** with `write` or standard Bash redirection; do **not** merely describe the change.
+- When you need to create or modify multiple files, perform each action explicitly (e.g., `echo >> file`, `sed -i`, `cat > newfile`).
+- Any sub‑agents you spawn via `rlm_query` inherit their own jj workspaces, so their edits are also isolated.
+
+## SECTION 4 – Guardrails & Cost Awareness
+- **RLM_TIMEOUT** – if set, respect the remaining wall‑clock budget; avoid long‑running loops.
+- **RLM_MAX_CALLS** – each `rlm_query` increments `RLM_CALL_COUNT`; stay within the limit.
+- **RLM_BUDGET** – if set, max dollar spend for the entire recursive tree. The infrastructure enforces this, but you should also be cost-conscious.
+- **`rlm_cost`** – call this at any time to see cumulative spend:
+  ```bash
+  rlm_cost          # "$0.042381"
+  rlm_cost --json   # {"cost": 0.042381, "tokens": 12450, "calls": 3}
+  ```
+  Use this to decide whether to make more sub‑calls or work directly. If spend is high relative to the task, prefer direct Bash actions over spawning sub‑agents.
+- **Depth awareness** – at deeper `RLM_DEPTH` levels, prefer **direct actions** (e.g., file edits, single‑pass searches) over spawning many sub‑agents.
+- Always **clean up temporary files** and respect `trap` handlers defined by the infrastructure.
+
+## SECTION 5 – Rules (Updated)
+1. **Context size first** – always `wc -l "$CONTEXT"` and `wc -c "$CONTEXT"`. Use direct read for small files, grep + chunking for large ones.
+2. **Validate before answering** – if a sub‑call returns unexpected output, re‑query; never guess.
+3. **Counting & temporal questions** – enumerate items with evidence, deduplicate, then count; extract dates and compute with `python3` or `date`.
+4. **Entity verification** – `grep` must confirm the exact entity exists; if not, respond with *"I don't know"* (only when the entity truly isn’t present).
+5. **Code editing** – when instructed to edit code, **perform the edit** immediately; do not just describe the change.
+6. **Sub‑agent calls** – favor **small, focused** sub‑agent calls over vague, large ones; keep the call count low.
+7. **Depth preference** – deeper depths ⇒ fewer sub‑calls, more direct Bash actions.
+8. **No blanket "I don't know" rule** – remove the generic rule; only use "I don't know" when the required information is absent from the context or repository.
+9. **Safety** – never execute untrusted commands without explicit intent; rely on the provided tooling.

package/install.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# ypi installer — one-line install:
+#   curl -fsSL https://raw.githubusercontent.com/rawwerks/ypi/master/install.sh | bash
+#
+# Installs ypi + Pi coding agent. Requires: npm (or bun), git, bash.
+# Optional: jj (for workspace isolation), sops + age (for encrypted notes)
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+DIM='\033[0;90m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+info()  { echo -e "${GREEN}▸${RESET} $1"; }
+warn()  { echo -e "${RED}▸${RESET} $1"; }
+dim()   { echo -e "${DIM}  $1${RESET}"; }
+
+# ── Check prerequisites ──────────────────────────────────────────────────
+
+MISSING=""
+command -v git &>/dev/null || MISSING="$MISSING git"
+command -v bash &>/dev/null || MISSING="$MISSING bash"
+
+if [ -n "$MISSING" ]; then
+    warn "Missing required tools:$MISSING"
+    exit 1
+fi
+
+# Need npm or bun for Pi
+HAS_NPM=false
+HAS_BUN=false
+command -v npm &>/dev/null && HAS_NPM=true
+command -v bun &>/dev/null && HAS_BUN=true
+
+if [ "$HAS_NPM" = false ] && [ "$HAS_BUN" = false ]; then
+    warn "Need npm or bun to install Pi. Install Node.js: https://nodejs.org"
+    exit 1
+fi
+
+# ── Install Pi if not present ────────────────────────────────────────────
+
+if ! command -v pi &>/dev/null; then
+    info "Installing Pi coding agent..."
+    if [ "$HAS_BUN" = true ]; then
+        bun install -g @mariozechner/pi-coding-agent
+    else
+        npm install -g @mariozechner/pi-coding-agent
+    fi
+    dim "Installed $(pi --version 2>/dev/null | head -1 || echo 'pi')"
+else
+    dim "Pi already installed: $(which pi)"
+fi
+
+# ── Clone ypi ────────────────────────────────────────────────────────────
+
+INSTALL_DIR="${YPI_DIR:-$HOME/.ypi}"
+
+if [ -d "$INSTALL_DIR" ]; then
+    info "Updating ypi at $INSTALL_DIR..."
+    cd "$INSTALL_DIR"
+    git pull --quiet
+    git submodule update --init --depth 1 --quiet
+else
+    info "Cloning ypi to $INSTALL_DIR..."
+    git clone --quiet https://github.com/rawwerks/ypi.git "$INSTALL_DIR"
+    cd "$INSTALL_DIR"
+    git submodule update --init --depth 1 --quiet
+fi
+
+# ── Add to PATH ──────────────────────────────────────────────────────────
+
+SHELL_NAME="$(basename "${SHELL:-/bin/bash}")"
+EXPORT_LINE="export PATH=\"$INSTALL_DIR:\$PATH\""
+RC_FILE=""
+
+case "$SHELL_NAME" in
+    zsh)  RC_FILE="$HOME/.zshrc" ;;
+    bash) RC_FILE="$HOME/.bashrc" ;;
+    fish) RC_FILE="$HOME/.config/fish/config.fish"
+          EXPORT_LINE="set -gx PATH $INSTALL_DIR \$PATH" ;;
+    *)    RC_FILE="$HOME/.profile" ;;
+esac
+
+if [ -n "$RC_FILE" ] && ! grep -qF "$INSTALL_DIR" "$RC_FILE" 2>/dev/null; then
+    echo "" >> "$RC_FILE"
+    echo "# ypi — recursive coding agent" >> "$RC_FILE"
+    echo "$EXPORT_LINE" >> "$RC_FILE"
+    info "Added to PATH in $RC_FILE"
+    dim "Run: source $RC_FILE   (or open a new terminal)"
+else
+    dim "Already in PATH"
+fi
+
+# ── Set up git hooks ────────────────────────────────────────────────────
+
+cd "$INSTALL_DIR"
+git config core.hooksPath .githooks 2>/dev/null || true
+
+# ── Report optional tools ───────────────────────────────────────────────
+
+echo ""
+info "ypi installed! ✓"
+echo ""
+dim "Required:"
+command -v pi &>/dev/null && dim "  ✓ pi ($(which pi))" || dim "  ✗ pi"
+echo ""
+dim "Optional:"
+command -v jj &>/dev/null && dim "  ✓ jj (workspace isolation)" || dim "  · jj — install for workspace isolation: https://martinvonz.github.io/jj/"
+echo ""
+echo -e "${BOLD}Get started:${RESET}"
+echo "  ypi                    # interactive"
+echo "  ypi \"What does this repo do?\"   # one-shot"
+echo ""

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "ypi",
+  "version": "0.2.0",
+  "description": "ypi — a recursive coding agent. Pi that can call itself via rlm_query.",
+  "license": "MIT",
+  "author": "Raymond Weitekamp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rawwerks/ypi.git"
+  },
+  "homepage": "https://github.com/rawwerks/ypi#readme",
+  "bugs": {
+    "url": "https://github.com/rawwerks/ypi/issues"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-agent",
+    "recursive",
+    "rlm",
+    "llm",
+    "pi",
+    "cli"
+  ],
+  "bin": {
+    "ypi": "./ypi",
+    "rlm_query": "./rlm_query",
+    "rlm_cost": "./rlm_cost",
+    "rlm_parse_json": "./rlm_parse_json"
+  },
+  "files": [
+    "ypi",
+    "rlm_query",
+    "rlm_cost",
+    "rlm_parse_json",
+    "SYSTEM_PROMPT.md",
+    "install.sh",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/rlm_cost

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# rlm_cost — Report cumulative cost for the current recursive tree.
+# Usage:
+#   rlm_cost          # prints "$0.042381"
+#   rlm_cost --json   # prints {"cost": 0.042381, "tokens": 12450, "calls": 3}
+
+if [ -z "${RLM_COST_FILE:-}" ] || [ ! -f "${RLM_COST_FILE:-}" ]; then
+    if [ "${1:-}" = "--json" ]; then
+        echo '{"cost": 0, "tokens": 0, "calls": 0}'
+    else
+        echo "\$0.000000"
+    fi
+    exit 0
+fi
+
+python3 -c "
+import json, sys
+total_cost = 0.0
+total_tokens = 0
+calls = 0
+with open('${RLM_COST_FILE}') as f:
+    for line in f:
+        line = line.strip()
+        if not line: continue
+        try:
+            obj = json.loads(line)
+            total_cost += obj.get('cost', 0)
+            total_tokens += obj.get('tokens', 0)
+            calls += 1
+        except: pass
+if '--json' in sys.argv:
+    print(json.dumps({'cost': round(total_cost, 6), 'tokens': total_tokens, 'calls': calls}))
+else:
+    print(f'\${total_cost:.6f}')
+" "$@"

package/rlm_parse_json

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Parse Pi JSON mode output. Stream text to stdout, write cost to fd 3."""
+import sys
+import json
+
+total_cost = 0.0
+total_tokens = 0
+
+for line in sys.stdin:
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        obj = json.loads(line)
+    except json.JSONDecodeError:
+        continue
+
+    t = obj.get("type", "")
+
+    # Stream text deltas to stdout as they arrive
+    if t == "message_update":
+        event = obj.get("assistantMessageEvent", {})
+        if event.get("type") == "text_delta":
+            delta = event.get("delta", "")
+            sys.stdout.write(delta)
+            sys.stdout.flush()
+
+    # Accumulate cost from each turn_end (handles multi-turn tool use)
+    if t == "turn_end":
+        msg = obj.get("message", {})
+        usage = msg.get("usage", {})
+        cost = usage.get("cost", {}).get("total", 0)
+        tokens = usage.get("totalTokens", 0)
+        total_cost += cost
+        total_tokens += tokens
+
+# Write cost summary to fd 3 (if open)
+cost_line = json.dumps({"cost": total_cost, "tokens": total_tokens})
+try:
+    with open(3, "w") as f:
+        f.write(cost_line)
+except OSError:
+    pass  # fd 3 not open, skip

package/rlm_query

@@ -0,0 +1,349 @@
+#!/usr/bin/env bash
+# rlm_query — Recursive Language Model sub-call for Pi.
+#
+# This is the Pi/bash equivalent of Python RLM's llm_query().
+# Each invocation spawns a child Pi that can answer questions about context.
+#
+# Usage:
+#   rlm_query "Analyze this and extract all dates"
+#   echo "some text" | rlm_query "What is the main topic?"
+#   sed -n '100,200p' "$CONTEXT" | rlm_query "Summarize this section"
+#   rlm_query --fork "Continue working on this refactor"
+#
+# If stdin has data (piped), that becomes the child's context.
+# Otherwise, the child inherits the parent's $CONTEXT file.
+#
+# Flags:
+#   --fork             Fork parent session into child (carries conversation history)
+#                      Default: fresh session per child (only data context, no history)
+#
+# Environment:
+#   RLM_DEPTH         — current recursion depth (default: 0)
+#   RLM_MAX_DEPTH     — max recursion depth (default: 3)
+#   RLM_PROVIDER      — LLM provider
+#   RLM_MODEL         — LLM model
+#   RLM_SYSTEM_PROMPT — path to the RLM system prompt file
+#   CONTEXT           — path to the current context file
+#   RLM_STDIN         — set to "1" by the calling pattern to indicate piped input
+#   RLM_TIMEOUT       — max wall‑clock seconds for the whole call chain
+#   RLM_START_TIME    — epoch seconds when the root call started (auto‑set)
+#   RLM_MAX_CALLS     — maximum total rlm_query invocations allowed
+#   RLM_CALL_COUNT    — current count of invocations (auto‑incremented)
+#   RLM_CHILD_MODEL   — model to use for child calls (depth > 0)
+#   RLM_CHILD_PROVIDER— provider to use for child calls (depth > 0)
+#   RLM_JJ            — set to "0" to disable jj workspace isolation
+#   RLM_EXTENSIONS    — set to "0" to disable Pi extensions (default: 1)
+#   RLM_CHILD_EXTENSIONS — override extensions for depth > 0 (default: same as parent)
+#   RLM_BUDGET        — max dollar spend for entire recursive tree (e.g. "0.50")
+#   RLM_COST_FILE     — shared file tracking cumulative cost (auto‑created)
+#   RLM_JSON          — set to "0" to disable JSON mode (plain text, no cost tracking)
+#   RLM_TRACE_ID      — shared ID linking all sessions in a recursive tree
+#   RLM_SESSION_DIR   — Pi session directory for this project
+#   RLM_SESSION_FILE  — parent's session file (used with --fork)
+
+set -euo pipefail
+
+# Structured error helper
+rlm_error() { echo "✗ $1" >&2; [ -n "${2:-}" ] && echo "  Why: $2" >&2; [ -n "${3:-}" ] && echo "  Fix: $3" >&2; }
+
+# ----------------------------------------------------------------------
+# Parse flags
+# ----------------------------------------------------------------------
+FORK=false
+while [[ "${1:-}" == --* ]]; do
+    case "$1" in
+        --fork) FORK=true; shift ;;
+        *) break ;;
+    esac
+done
+
+PROMPT="${1:?Usage: rlm_query [--fork] \"your prompt here\"}"
+
+# ----------------------------------------------------------------------
+# Depth guard — refuse to go beyond max depth
+# This is the only recursion limiter. Children get full tools/extensions.
+# ----------------------------------------------------------------------
+DEPTH="${RLM_DEPTH:-0}"
+MAX_DEPTH="${RLM_MAX_DEPTH:-3}"
+NEXT_DEPTH=$((DEPTH + 1))
+
+if [ "$NEXT_DEPTH" -gt "$MAX_DEPTH" ]; then
+    rlm_error "Max depth exceeded" "At depth $DEPTH of $MAX_DEPTH" "Increase RLM_MAX_DEPTH or simplify the task"
+    exit 1
+fi
+
+PROVIDER="${RLM_PROVIDER:-cerebras}"
+MODEL="${RLM_MODEL:-gpt-oss-120b}"
+SYSTEM_PROMPT_FILE="${RLM_SYSTEM_PROMPT:-}"
+
+# ----------------------------------------------------------------------
+# Timeout start time initialization
+# ----------------------------------------------------------------------
+if [ -z "${RLM_START_TIME:-}" ]; then
+    export RLM_START_TIME=$(date +%s)
+fi
+
+# ----------------------------------------------------------------------
+# Call counting & max‑calls guard
+# ----------------------------------------------------------------------
+RLM_CALL_COUNT=$(( ${RLM_CALL_COUNT:-0} + 1 ))
+export RLM_CALL_COUNT
+if [ -n "${RLM_MAX_CALLS:-}" ] && [ "$RLM_CALL_COUNT" -ge "$RLM_MAX_CALLS" ]; then
+    rlm_error "Max calls exceeded" "$RLM_CALL_COUNT of $RLM_MAX_CALLS calls used" "Increase RLM_MAX_CALLS or reduce recursion depth"
+    exit 1
+fi
+
+# ----------------------------------------------------------------------
+# Budget guard — check cumulative cost before proceeding
+# ----------------------------------------------------------------------
+if [ -n "${RLM_BUDGET:-}" ] && [ -n "${RLM_COST_FILE:-}" ] && [ -f "$RLM_COST_FILE" ]; then
+    CURRENT_COST=$(python3 -c "
+import json
+total = 0.0
+with open('$RLM_COST_FILE') as f:
+    for line in f:
+        line = line.strip()
+        if line:
+            try: total += json.loads(line).get('cost', 0)
+            except: pass
+print(f'{total:.6f}')
+" 2>/dev/null || echo "0")
+    OVER=$(python3 -c "print('yes' if $CURRENT_COST >= $RLM_BUDGET else 'no')" 2>/dev/null || echo "no")
+    if [ "$OVER" = "yes" ]; then
+        rlm_error "Budget exceeded" "Spent \$$CURRENT_COST of \$$RLM_BUDGET budget" "Increase RLM_BUDGET or simplify the task"
+        exit 1
+    fi
+fi
+
+# Initialize cost file if budget is set but no file exists yet
+if [ -n "${RLM_BUDGET:-}" ] && [ -z "${RLM_COST_FILE:-}" ]; then
+    export RLM_COST_FILE=$(mktemp /tmp/rlm_cost_XXXXXX.jsonl)
+fi
+
+# ----------------------------------------------------------------------
+# Session tree — each child gets a persisted session file
+# Trace ID groups all sessions from one recursive invocation.
+# ----------------------------------------------------------------------
+if [ -z "${RLM_TRACE_ID:-}" ]; then
+    export RLM_TRACE_ID=$(head -c 4 /dev/urandom | od -An -tx1 | tr -d ' \n')
+fi
+
+CHILD_SESSION_FILE=""
+if [ -n "${RLM_SESSION_DIR:-}" ]; then
+    mkdir -p "$RLM_SESSION_DIR"
+    CHILD_SESSION_FILE="${RLM_SESSION_DIR}/${RLM_TRACE_ID}_d${NEXT_DEPTH}_c${RLM_CALL_COUNT}.jsonl"
+
+    # --fork: copy parent session to give child full conversation history
+    if [ "$FORK" = true ] && [ -n "${RLM_SESSION_FILE:-}" ] && [ -f "${RLM_SESSION_FILE:-}" ]; then
+        cp "$RLM_SESSION_FILE" "$CHILD_SESSION_FILE"
+    fi
+fi
+
+# ----------------------------------------------------------------------
+# Trace logging (optional)
+# ----------------------------------------------------------------------
+if [ -n "${PI_TRACE_FILE:-}" ]; then
+    echo "[$(date +%H:%M:%S.%3N)] depth=$DEPTH→$NEXT_DEPTH PID=$$ PPID=$PPID call=$RLM_CALL_COUNT trace=$RLM_TRACE_ID fork=$FORK prompt: ${PROMPT:0:120}" >> "$PI_TRACE_FILE"
+fi
+
+# ----------------------------------------------------------------------
+# Temporary child context file
+# ----------------------------------------------------------------------
+CHILD_CONTEXT=$(mktemp /tmp/rlm_ctx_d${NEXT_DEPTH}_XXXXXX.txt)
+COMBINED_PROMPT=""
+
+# ----------------------------------------------------------------------
+# jj workspace isolation — give recursive children their own working copy
+# ----------------------------------------------------------------------
+JJ_WORKSPACE=""
+JJ_WS_NAME=""
+if [ "${RLM_JJ:-1}" != "0" ] \
+   && command -v jj &>/dev/null \
+   && jj root &>/dev/null 2>&1; then
+    JJ_WS_NAME="rlm-d${NEXT_DEPTH}-$$"
+    JJ_WORKSPACE=$(mktemp -d /tmp/rlm_ws_d${NEXT_DEPTH}_XXXXXX)
+    if ! jj workspace add --name "$JJ_WS_NAME" "$JJ_WORKSPACE" &>/dev/null; then
+        JJ_WORKSPACE=""
+        JJ_WS_NAME=""
+    fi
+fi
+
+# Cleanup: remove temp context + forget jj workspace (updated in run section below)
+trap '{
+    rm -f "$CHILD_CONTEXT"
+    rm -f "${COMBINED_PROMPT:-}"
+    if [ -n "$JJ_WS_NAME" ]; then
+        jj workspace forget "$JJ_WS_NAME" 2>/dev/null || true
+    fi
+}' EXIT
+trap 'rlm_error "Interrupted" "Received signal" "Re-run the command"; exit 130' INT TERM
+
+# ----------------------------------------------------------------------
+# Detect piped stdin
+# ----------------------------------------------------------------------
+HAS_STDIN=false
+if [ -p /dev/stdin ]; then
+    HAS_STDIN=true
+elif [ -n "${RLM_STDIN:-}" ]; then
+    HAS_STDIN=true
+fi
+
+if [ "$HAS_STDIN" = true ]; then
+    cat > "$CHILD_CONTEXT"
+else
+    if [ -n "${CONTEXT:-}" ] && [ -f "${CONTEXT:-}" ]; then
+        cp "$CONTEXT" "$CHILD_CONTEXT"
+    fi
+fi
+
+# ----------------------------------------------------------------------
+# Model routing for child calls (depth > 0)
+# ----------------------------------------------------------------------
+if [ "$DEPTH" -gt 0 ] && [ -n "${RLM_CHILD_MODEL:-}" ]; then
+    MODEL="${RLM_CHILD_MODEL}"
+    if [ -n "${RLM_CHILD_PROVIDER:-}" ]; then
+        PROVIDER="${RLM_CHILD_PROVIDER}"
+    fi
+fi
+
+# ----------------------------------------------------------------------
+# Spawn child Pi with tools, extensions, and session
+# ----------------------------------------------------------------------
+export CONTEXT="$CHILD_CONTEXT"
+export RLM_DEPTH="$NEXT_DEPTH"
+export RLM_MAX_DEPTH="$MAX_DEPTH"
+export RLM_PROVIDER="$PROVIDER"
+export RLM_MODEL="$MODEL"
+export RLM_SYSTEM_PROMPT="${SYSTEM_PROMPT_FILE:-}"
+export RLM_START_TIME="${RLM_START_TIME}"
+export RLM_TIMEOUT="${RLM_TIMEOUT:-}"
+export RLM_TRACE_ID="${RLM_TRACE_ID}"
+export RLM_SESSION_DIR="${RLM_SESSION_DIR:-}"
+export RLM_BUDGET="${RLM_BUDGET:-}"
+export RLM_COST_FILE="${RLM_COST_FILE:-}"
+
+# At max depth: remove rlm_query from PATH so the child can't recurse.
+# The child still gets full tools (bash, read, write, edit) — it just
+# can't spawn sub-agents. The depth guard above is a safety net.
+# Follow symlinks — npm install -g creates symlinks in .bin/
+SCRIPT_DIR="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)"
+if [ "$NEXT_DEPTH" -ge "$MAX_DEPTH" ]; then
+    export PATH=$(echo "$PATH" | tr ':' '\n' | grep -v "^${SCRIPT_DIR}$" | paste -sd ':' -)
+fi
+
+if [ -n "$CHILD_SESSION_FILE" ]; then
+    export RLM_SESSION_FILE="$CHILD_SESSION_FILE"
+fi
+
+CMD_ARGS=(-p --provider "$PROVIDER" --model "$MODEL")
+
+# Extensions: on by default, configurable per-instance like model routing
+CHILD_EXT="${RLM_EXTENSIONS:-1}"
+if [ "$DEPTH" -gt 0 ] && [ -n "${RLM_CHILD_EXTENSIONS:-}" ]; then
+    CHILD_EXT="${RLM_CHILD_EXTENSIONS}"
+fi
+if [ "$CHILD_EXT" = "0" ]; then
+    CMD_ARGS+=(--no-extensions)
+fi
+
+# Session: use dedicated file if we have a session dir, otherwise ephemeral
+if [ -n "$CHILD_SESSION_FILE" ]; then
+    CMD_ARGS+=(--session "$CHILD_SESSION_FILE")
+else
+    CMD_ARGS+=(--no-session)
+fi
+
+# Build combined system prompt with rlm_query source embedded
+COMBINED_PROMPT=""
+if [ -n "$SYSTEM_PROMPT_FILE" ] && [ -f "$SYSTEM_PROMPT_FILE" ]; then
+    COMBINED_PROMPT=$(mktemp /tmp/rlm_system_prompt_XXXXXX.md)
+    cat "$SYSTEM_PROMPT_FILE" > "$COMBINED_PROMPT"
+    SELF_SOURCE="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)/rlm_query"
+    if [ -f "$SELF_SOURCE" ]; then
+        cat >> "$COMBINED_PROMPT" << 'SYSEOF'
+
+## SECTION 6 – rlm_query Implementation
+
+Below is the full source of `rlm_query`. You are running inside this infrastructure.
+Understanding it helps you use recursion effectively and respect guardrails.
+
+```bash
+SYSEOF
+        cat "$SELF_SOURCE" >> "$COMBINED_PROMPT"
+        echo '```' >> "$COMBINED_PROMPT"
+    fi
+    CMD_ARGS+=(--system-prompt "$COMBINED_PROMPT")
+fi
+
+# Timeout wrapper
+TIMEOUT_CMD=""
+if [ -n "${RLM_TIMEOUT:-}" ]; then
+    ELAPSED=$(( $(date +%s) - RLM_START_TIME ))
+    REMAINING=$(( RLM_TIMEOUT - ELAPSED ))
+    if [ "$REMAINING" -le 0 ]; then
+        rlm_error "Timeout exceeded" "Ran for ${ELAPSED}s of ${RLM_TIMEOUT}s" "Increase RLM_TIMEOUT or simplify the task"
+        exit 124
+    fi
+    TIMEOUT_CMD="timeout $REMAINING"
+fi
+
+# Enter jj workspace if available (child gets isolated working copy)
+if [ -n "$JJ_WORKSPACE" ]; then
+    cd "$JJ_WORKSPACE"
+fi
+
+# ----------------------------------------------------------------------
+# Run child Pi — JSON mode (default) or plain text
+# JSON mode streams text to stdout and captures cost via fd 3.
+# ----------------------------------------------------------------------
+COST_OUT=$(mktemp /tmp/rlm_cost_out_XXXXXX.json)
+trap '{
+    rm -f "$CHILD_CONTEXT"
+    rm -f "${COMBINED_PROMPT:-}"
+    rm -f "$COST_OUT"
+    if [ -n "$JJ_WS_NAME" ]; then
+        jj workspace forget "$JJ_WS_NAME" 2>/dev/null || true
+    fi
+}' EXIT
+
+if [ "${RLM_JSON:-1}" != "0" ]; then
+    # JSON mode: get structured cost + stream text
+    # Replace -p with --mode json, pipe through parser
+    JSON_CMD_ARGS=()
+    for arg in "${CMD_ARGS[@]}"; do
+        [ "$arg" = "-p" ] && continue
+        JSON_CMD_ARGS+=("$arg")
+    done
+    JSON_CMD_ARGS+=(--mode json)
+
+    PARSER="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)/rlm_parse_json"
+
+    $TIMEOUT_CMD pi "${JSON_CMD_ARGS[@]}" "$PROMPT" 2>/dev/null | python3 "$PARSER" 3>"$COST_OUT"
+    RC=${PIPESTATUS[0]}
+
+    # Record cost if we got data
+    if [ -s "$COST_OUT" ] && [ -n "${RLM_COST_FILE:-}" ]; then
+        cat "$COST_OUT" >> "$RLM_COST_FILE"
+    fi
+
+    # Log cost to trace
+    if [ -s "$COST_OUT" ] && [ -n "${PI_TRACE_FILE:-}" ]; then
+        COST_DATA=$(cat "$COST_OUT")
+        ELAPSED=$(( $(date +%s) - RLM_START_TIME ))
+        echo "[$(date +%Y-%m-%dT%H:%M:%S%z)] depth=$DEPTH COMPLETED exit=$RC elapsed=${ELAPSED}s cost=$COST_DATA" >> "$PI_TRACE_FILE"
+    elif [ -n "${PI_TRACE_FILE:-}" ]; then
+        ELAPSED=$(( $(date +%s) - RLM_START_TIME ))
+        echo "[$(date +%Y-%m-%dT%H:%M:%S%z)] depth=$DEPTH COMPLETED exit=$RC elapsed=${ELAPSED}s" >> "$PI_TRACE_FILE"
+    fi
+else
+    # Plain text mode (RLM_JSON=0): no cost tracking
+    $TIMEOUT_CMD pi "${CMD_ARGS[@]}" "$PROMPT"
+    RC=$?
+
+    if [ -n "${PI_TRACE_FILE:-}" ]; then
+        ELAPSED=$(( $(date +%s) - RLM_START_TIME ))
+        echo "[$(date +%Y-%m-%dT%H:%M:%S%z)] depth=$DEPTH COMPLETED exit=$RC elapsed=${ELAPSED}s" >> "$PI_TRACE_FILE"
+    fi
+fi
+
+exit $RC

package/ypi

@@ -0,0 +1,86 @@
+#!/bin/bash
+# ypi — Y-Combinator Pi — Recursive Coding Agent
+#
+# Launches Pi as a Recursive Language Model. The LLM gets a system prompt
+# that teaches it to use bash + rlm_query for divide-and-conquer reasoning
+# over large contexts.
+#
+# Usage:
+#   ypi                              # interactive recursive pi
+#   ypi "What is in this repo?"      # one-shot with -p
+#   ypi --provider anthropic --model claude-sonnet-4-5-20250929 "question"
+#
+# Environment overrides:
+#   RLM_PROVIDER       — LLM provider for root call (default: cerebras)
+#   RLM_MODEL          — LLM model for root call (default: gpt-oss-120b)
+#   RLM_MAX_DEPTH      — max recursion depth (default: 3)
+#   RLM_TIMEOUT        — wall-clock seconds for entire recursive tree (default: none)
+#   RLM_MAX_CALLS      — max total rlm_query invocations (default: none)
+#   RLM_CHILD_MODEL    — cheaper model for sub-calls at depth > 0 (default: same as root)
+#   RLM_CHILD_PROVIDER — provider for sub-calls at depth > 0 (default: same as root)
+#   RLM_JJ             — set to "0" to disable jj workspace isolation (default: 1)
+#   RLM_EXTENSIONS     — set to "0" to disable Pi extensions (default: 1)
+#   RLM_CHILD_EXTENSIONS — override extensions for depth > 0 (default: same as parent)
+#   RLM_BUDGET         — max dollar spend for entire recursive tree (default: none)
+#   RLM_JSON           — set to "0" to disable JSON mode / cost tracking (default: 1)
+#   PI_TRACE_FILE      — path to trace log for all calls with timing (default: none)
+
+set -euo pipefail
+
+# Resolve the directory where ypi lives (and where rlm_query + SYSTEM_PROMPT.md are)
+# Follow symlinks — npm install -g creates symlinks in .bin/ pointing to node_modules/ypi/
+SCRIPT_DIR="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)"
+
+# Put rlm_query on PATH so Pi's bash tool can find it
+export PATH="$SCRIPT_DIR:$PATH"
+
+# Initialize RLM environment — pass through all guardrails
+export RLM_DEPTH="${RLM_DEPTH:-0}"
+export RLM_MAX_DEPTH="${RLM_MAX_DEPTH:-3}"
+export RLM_PROVIDER="${RLM_PROVIDER:-cerebras}"
+export RLM_MODEL="${RLM_MODEL:-gpt-oss-120b}"
+export RLM_SYSTEM_PROMPT="$SCRIPT_DIR/SYSTEM_PROMPT.md"
+
+# Guardrails — pass through if set, don't override
+[ -n "${RLM_TIMEOUT:-}" ]        && export RLM_TIMEOUT
+[ -n "${RLM_MAX_CALLS:-}" ]      && export RLM_MAX_CALLS
+[ -n "${RLM_CHILD_MODEL:-}" ]    && export RLM_CHILD_MODEL
+[ -n "${RLM_CHILD_PROVIDER:-}" ] && export RLM_CHILD_PROVIDER
+[ -n "${PI_TRACE_FILE:-}" ]      && export PI_TRACE_FILE
+export RLM_JJ="${RLM_JJ:-1}"
+export RLM_EXTENSIONS="${RLM_EXTENSIONS:-1}"
+[ -n "${RLM_CHILD_EXTENSIONS:-}" ] && export RLM_CHILD_EXTENSIONS
+[ -n "${RLM_BUDGET:-}" ]           && export RLM_BUDGET
+export RLM_JSON="${RLM_JSON:-1}"
+
+# Session tree tracing — generate a trace ID that links all recursive sessions
+export RLM_TRACE_ID="${RLM_TRACE_ID:-$(head -c 4 /dev/urandom | od -An -tx1 | tr -d ' \n')}"
+
+# Compute Pi's session directory for this CWD so children can write there
+CWD="$(pwd)"
+SAFE_PATH="--$(echo "$CWD" | sed 's|^/||; s|[/:\\]|-|g')--"
+export RLM_SESSION_DIR="${HOME}/.pi/agent/sessions/${SAFE_PATH}"
+mkdir -p "$RLM_SESSION_DIR"
+
+# Build combined system prompt: SYSTEM_PROMPT.md + rlm_query source
+# This way the agent sees the full implementation, not just usage docs.
+COMBINED_PROMPT=$(mktemp /tmp/ypi_system_prompt_XXXXXX.md)
+trap 'rm -f "$COMBINED_PROMPT"' EXIT
+
+cat "$SCRIPT_DIR/SYSTEM_PROMPT.md" > "$COMBINED_PROMPT"
+cat >> "$COMBINED_PROMPT" << 'EOF'
+
+## SECTION 6 – rlm_query Implementation
+
+Below is the full source of `rlm_query`. You are running inside this infrastructure.
+Understanding it helps you use recursion effectively and respect guardrails.
+
+```bash
+EOF
+cat "$SCRIPT_DIR/rlm_query" >> "$COMBINED_PROMPT"
+cat >> "$COMBINED_PROMPT" << 'EOF'
+```
+EOF
+
+# Launch Pi with the combined system prompt, passing all args through
+exec pi --system-prompt "$COMBINED_PROMPT" "$@"