ypi 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 All notable changes to ypi are documented here.
 Format based on [Keep a Changelog](https://keepachangelog.com/).
 
+## [0.4.0] - 2026-02-13
+
+### Added
+- **`rlm_sessions` command**: inspect, read, and search session logs from sibling and parent agents in the recursive tree (`rlm_sessions --trace`, `rlm_sessions read <file>`, `rlm_sessions grep <pattern>`)
+- **Symbolic prompt access** (`RLM_PROMPT_FILE`): agents can grep/sed the original prompt as a file instead of copying tokens from context memory
+- **Contrib extensions**: `colgrep.ts` (semantic code search via ColBERT), `dirpack.ts` (repository index), `treemap.ts` (visual tree maps) — opt-in extensions in `contrib/extensions/`
+- **Encryption workflow**: `scripts/encrypt-prose` and `scripts/decrypt-prose` for sops/age encryption of private execution state before pushing
+- **`.sops.yaml`**: age encryption rules for `.prose/runs/`, `.prose/agents/`, `experiments/`, `private/`
+- **`.githooks/pre-commit`**: safety net blocking unencrypted private files on direct git push
+- **OpenProse programs**: `release.prose`, `land.prose`, `incorporate-insight.prose`, `recursive-development.prose`, `self-experiment.prose`, `check-upstream.prose`
+- **Experiment infrastructure**: `experiments/` directory with pipe-vs-filename, session-sharing, and tree-awareness experiments with results
+- E2E tests: expanded coverage (+90 lines), gemini-flash as default e2e model
+- Guardrail tests: `rlm_sessions` tests (G48-G51), session sharing toggle
+- Unit tests: `RLM_PROMPT_FILE` tests (T14d)
+
+### Changed
+- **SYSTEM_PROMPT.md**: added symbolic access principle (SECTION 2), refined depth awareness guidance
+- **AGENTS.md**: expanded with experiment workflow (tmux rules), self-experimentation, session history reading, OpenProse program references
+- **README.md**: updated feature list and project description
+- Removed hardcoded provider/model defaults from `rlm_query` — inherits from environment only
+
+### Fixed
+- Kill orphan `rlm_parse_json` processes after timeout in E2E tests
+- Contrib extension GitHub links (dirpack, colgrep) now point to correct URLs
+
 ## [0.3.0] - 2026-02-13
 
 ### Added

package/README.md

@@ -72,15 +72,12 @@ ypi --provider anthropic --model claude-sonnet-4-5-20250929 "What does this code
 ```
 
 ### 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:
 
 ```
@@ -91,6 +88,18 @@ Depth 0 (root)    → full Pi with bash + rlm_query
 
 **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>`.
 
+### Why It Works
+
+The design has three properties that compound:
+
+1. **Self-similarity** — Every depth runs the same prompt, same tools, same agent. No specialized "scout" or "planner" roles. The intelligence is in *decomposition*, not specialization. The system prompt teaches one pattern — size-first → search → chunk → delegate → combine — and it works at every scale.
+
+2. **Self-hosting** — The system prompt (SECTION 6) contains the full source of `rlm_query`. The agent reads its own recursion machinery. When it modifies `rlm_query`, it's modifying itself. This isn't a metaphor — it's the actual execution model.
+
+3. **Bounded recursion** — Five concentric guardrails (depth limit, PATH scrubbing, call count, budget, timeout) guarantee termination. The system prompt also installs *cognitive* pressure: deeper agents are told to be more conservative, preferring direct action over spawning more children.
+
+4. **Symbolic access** — Anything the agent needs to manipulate precisely is a file, not just tokens in context. `$CONTEXT` holds the data, `$RLM_PROMPT_FILE` holds the original prompt, and hashline provides line-addressed edits. Agents `grep`/`sed`/`cat` instead of copying tokens from memory.
+
 ### Guardrails
 
 | Feature | Env var | What it does |
@@ -111,6 +120,21 @@ rlm_cost          # "$0.042381"
 rlm_cost --json   # {"cost": 0.042381, "tokens": 12450, "calls": 3}
 ```
 
+### Pi Compatibility
+
+ypi is a thin layer on top of Pi. We strive not to break or duplicate what Pi already does:
+
+| Pi feature | ypi behavior | Tests |
+|---|---|---|
+| **Session history** | Uses Pi's native `~/.pi/agent/sessions/` dir. Child sessions go in the same dir with trace-encoded filenames. No separate session store. | G24–G30 |
+| **Extensions** | Passed through to Pi. Children inherit extensions by default. `RLM_EXTENSIONS=0` disables. | G34–G38 |
+| **System prompt** | Built from `SYSTEM_PROMPT.md` + `rlm_query` source, written to a temp file, passed via `--system-prompt` (file path, never inlined as shell arg). | T8–T9 |
+| **`-p` mode** | All child Pi calls run non-interactive (`-p`). ypi never fakes a terminal. | T3–T4 |
+| **`--session` flag** | Used when `RLM_SESSION_DIR` is set; `--no-session` otherwise. Never both. | G24, G28 |
+| **Provider/model** | Never hardcoded. ypi and `rlm_query` use Pi's defaults unless the user sets `RLM_PROVIDER`/`RLM_MODEL`. | T14, T14c |
+
+If Pi changes how sessions or extensions work, our guardrail tests should catch it.
+
 ---
 
 ## Contributing

package/SYSTEM_PROMPT.md

@@ -7,85 +7,84 @@
 - 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:
+## SECTION 2 – Recursive Decomposition
+You solve problems by **decomposing them**: break big tasks into smaller ones, delegate to sub‑agents, combine results. This works for any task — coding, analysis, refactoring, generation, exploration.
+
+Your original prompt is also available as a file at `$RLM_PROMPT_FILE` — use it when you need to manipulate the question programmatically (e.g., extracting exact strings, counting characters) rather than copying tokens from memory.
+
+If a `$CONTEXT` file is set, it contains data relevant to your task. Treat it like any other file — read it, search it, chunk it.
+
+**Core pattern: size up → search → delegate → combine**
+1. **Size up the problem** – How big is it? Can you do it directly, or does it need decomposition? For files: `wc -l` / `wc -c`. For code tasks: how many files, how complex?
+2. **Search & explore** – `grep`, `find`, `ls`, `head` — orient yourself before diving in.
+3. **Delegate** – use `rlm_query` to hand sub‑tasks to child agents. Two patterns:
    ```bash
-   # Pipe a specific chunk
-   sed -n '100,200p' "$CONTEXT" | rlm_query "Your question"
+   # Pipe data as the child's context
+   sed -n '100,200p' bigfile.txt | rlm_query "Summarize this section"
 
-   # Inherit the whole context (no pipe)
-   rlm_query "Your question"
+   # Child inherits your environment (files, cwd, $CONTEXT)
+   rlm_query "Refactor the error handling in src/api.py"
    ```
-5. **Combine** – aggregate answers from chunks, deduplicate, and produce the final response.
+4. **Combine** – aggregate results, deduplicate, resolve conflicts, produce the final output.
+5. **Do it directly when it's small** – don't delegate what you can do in one step.
 
-### Example Patterns (keep all five)
+### Examples
 
-**Example 1 – Short context, direct approach**
+**Example 1 – Small task, do it directly**
 ```bash
-wc -c "$CONTEXT"
-# 3200 chars — small enough to read directly
-cat "$CONTEXT"
-# Now I can see the content and answer the question
+# A 30-line file? Just read it and act.
+wc -l src/config.py
+cat src/config.py
+# Now edit it directly — no need to delegate
 ```
 
-**Example 2 – Long context, search and delegate**
+**Example 2 – Multi-file refactor, delegate per file**
 ```bash
-# First, explore the structure
-wc -l "$CONTEXT"
-head -50 "$CONTEXT"
-grep -n "Chapter" "$CONTEXT"
+# Find all files that need updating
+grep -rl "old_api_call" src/
 
-# 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."
+# Delegate each file to a sub-agent (each gets its own jj workspace)
+for f in $(grep -rl "old_api_call" src/); do
+    rlm_query "In $f, replace all old_api_call() with new_api_call(). Update the imports too."
+done
 ```
 
-**Example 3 – Chunk and query**
+**Example 3 – Large file analysis, chunk and search**
 ```bash
-# Check size
-TOTAL=$(wc -l < "$CONTEXT")
-echo "Context has $TOTAL lines"
-
-# Search for keywords first
-grep -n "graduation\|degree\|university" "$CONTEXT"
+# Too big to read at once — search first, then delegate relevant sections
+wc -l data/logs.txt
+grep -n "ERROR\|FATAL" data/logs.txt
 
-# 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.")
+# Delegate the interesting section
+sed -n '480,600p' data/logs.txt | rlm_query "What caused this error? Suggest a fix."
+```
 
-# Combine results
-echo "Chunk 1: $ANSWER1"
-echo "Chunk 2: $ANSWER2"
+**Example 4 – Parallel sub-tasks with different goals**
+```bash
+# Break a complex task into independent pieces
+SUMMARY=$(rlm_query "Read README.md and summarize what this project does in one paragraph.")
+ISSUES=$(rlm_query "Run the test suite and report any failures.")
+DEPS=$(rlm_query "Check for outdated dependencies in package.json.")
+
+# Combine into a report
+echo "Summary: $SUMMARY"
+echo "Test issues: $ISSUES"
+echo "Dependency status: $DEPS"
 ```
 
-**Example 4 – Iterative chunking for huge contexts**
+**Example 5 – Iterative chunking over a huge file**
 ```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.")
+    RESULT=$(sed -n "${START},${END}p" "$CONTEXT" | rlm_query "Extract any TODO items. 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**:
@@ -107,16 +106,22 @@ python3 -c "from datetime import date; d1=date.fromisoformat('$START_DATE'); d2=
   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.
+- **`rlm_sessions`** – view session logs from sibling and parent agents in the same recursive tree:
+  ```bash
+  rlm_sessions --trace             # list sessions from this call tree
+  rlm_sessions read <file>         # read a session as clean transcript
+  rlm_sessions grep <pattern>      # search across sessions
+  ```
+  Available for debugging and reviewing what other agents in the tree have done.
 - **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.
+## SECTION 5 – Rules
+1. **Size up first** – before delegating, check if the task is small enough to do directly. Read small files, edit simple things, answer obvious questions — don't over‑decompose.
+2. **Validate sub‑agent output** – if a sub‑call returns unexpected output, re‑query or do it yourself; never guess.
+3. **Computation over memorization** – use `python3`, `date`, `wc`, `grep -c` for counting, dates, and math. Don't eyeball it.
+4. **Act, don't describe** – when instructed to edit code, write files, or make changes, **do it** immediately.
+5. **Small, focused sub‑agents** – each `rlm_query` call should have a clear, bounded task. Keep the call count low.
+6. **Depth preference** – deeper depths ⇒ fewer sub‑calls, more direct Bash actions.
+7. **Say "I don't know" only when true** – only when the required information is genuinely absent from the context, repo, or environment.
+8. **Safety** – never execute untrusted commands without explicit intent; rely on the provided tooling.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ypi",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "ypi — a recursive coding agent. Pi that can call itself via rlm_query.",
   "license": "MIT",
   "author": "Raymond Weitekamp",
@@ -26,13 +26,15 @@
     "ypi": "./ypi",
     "rlm_query": "./rlm_query",
     "rlm_cost": "./rlm_cost",
-    "rlm_parse_json": "./rlm_parse_json"
+    "rlm_parse_json": "./rlm_parse_json",
+    "rlm_sessions": "./rlm_sessions"
   },
   "files": [
     "ypi",
     "rlm_query",
     "rlm_cost",
     "rlm_parse_json",
+    "rlm_sessions",
     "SYSTEM_PROMPT.md",
     "install.sh",
     "README.md",

package/rlm_query

@@ -72,8 +72,8 @@ if [ "$NEXT_DEPTH" -gt "$MAX_DEPTH" ]; then
     exit 1
 fi
 
-PROVIDER="${RLM_PROVIDER:-cerebras}"
-MODEL="${RLM_MODEL:-gpt-oss-120b}"
+PROVIDER="${RLM_PROVIDER:-}"
+MODEL="${RLM_MODEL:-}"
 SYSTEM_PROMPT_FILE="${RLM_SYSTEM_PROMPT:-}"
 
 # ----------------------------------------------------------------------
@@ -152,6 +152,11 @@ fi
 CHILD_CONTEXT=$(mktemp /tmp/rlm_ctx_d${NEXT_DEPTH}_XXXXXX.txt)
 COMBINED_PROMPT=""
 
+# Write prompt to a file for symbolic access — agents can grep/sed the original
+# question instead of relying on in-context token copying.
+PROMPT_FILE=$(mktemp /tmp/rlm_prompt_d${NEXT_DEPTH}_XXXXXX.txt)
+echo "$PROMPT" > "$PROMPT_FILE"
+
 # ----------------------------------------------------------------------
 # jj workspace isolation — give recursive children their own working copy
 # ----------------------------------------------------------------------
@@ -170,7 +175,7 @@ fi
 
 # Cleanup: remove temp context + forget jj workspace (updated in run section below)
 trap '{
-    rm -f "$CHILD_CONTEXT"
+    rm -f "$CHILD_CONTEXT" "$PROMPT_FILE"
     rm -f "${COMBINED_PROMPT:-}"
     if [ -n "$JJ_WS_NAME" ]; then
         jj workspace forget "$JJ_WS_NAME" 2>/dev/null || true
@@ -210,6 +215,7 @@ fi
 # Spawn child Pi with tools, extensions, and session
 # ----------------------------------------------------------------------
 export CONTEXT="$CHILD_CONTEXT"
+export RLM_PROMPT_FILE="$PROMPT_FILE"
 export RLM_DEPTH="$NEXT_DEPTH"
 export RLM_MAX_DEPTH="$MAX_DEPTH"
 export RLM_PROVIDER="$PROVIDER"
@@ -221,6 +227,7 @@ 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:-}"
+export RLM_SHARED_SESSIONS="${RLM_SHARED_SESSIONS:-1}"
 
 # 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
@@ -235,7 +242,9 @@ if [ -n "$CHILD_SESSION_FILE" ]; then
     export RLM_SESSION_FILE="$CHILD_SESSION_FILE"
 fi
 
-CMD_ARGS=(-p --provider "$PROVIDER" --model "$MODEL")
+CMD_ARGS=(-p)
+[ -n "$PROVIDER" ] && CMD_ARGS+=(--provider "$PROVIDER")
+[ -n "$MODEL" ] && CMD_ARGS+=(--model "$MODEL")
 
 # Extensions: on by default, configurable per-instance like model routing
 CHILD_EXT="${RLM_EXTENSIONS:-1}"
@@ -298,7 +307,7 @@ fi
 # ----------------------------------------------------------------------
 COST_OUT=$(mktemp /tmp/rlm_cost_out_XXXXXX.json)
 trap '{
-    rm -f "$CHILD_CONTEXT"
+    rm -f "$CHILD_CONTEXT" "$PROMPT_FILE"
     rm -f "${COMBINED_PROMPT:-}"
     rm -f "$COST_OUT"
     if [ -n "$JJ_WS_NAME" ]; then

package/rlm_sessions

@@ -0,0 +1,219 @@
+#!/usr/bin/env bash
+# rlm_sessions — List and read Pi session logs for the current recursive tree.
+#
+# Sub-agents can use this to see what other agents have done — shared memory
+# through session transcripts.
+#
+# Environment:
+#   RLM_SESSION_DIR    — path to Pi session directory (set by ypi/rlm_query)
+#   RLM_TRACE_ID       — current trace ID (filters to this recursive tree)
+#   RLM_SHARED_SESSIONS — set to "0" to disable (exit silently). Default: 1.
+#
+# Usage:
+#   rlm_sessions                     # List all sessions for this project
+#   rlm_sessions --trace             # List only sessions from current trace
+#   rlm_sessions read <file>         # Read a session as clean transcript
+#   rlm_sessions read --last         # Read the most recent session
+#   rlm_sessions grep <pattern>      # Search across all sessions
+#   rlm_sessions grep -t <pattern>   # Search only current trace's sessions
+
+set -euo pipefail
+
+# Gate: disabled when RLM_SHARED_SESSIONS=0
+if [ "${RLM_SHARED_SESSIONS:-1}" = "0" ]; then
+    echo "Session sharing disabled (RLM_SHARED_SESSIONS=0)." >&2
+    exit 0
+fi
+
+SESSION_DIR="${RLM_SESSION_DIR:-}"
+TRACE_ID="${RLM_TRACE_ID:-}"
+
+if [ -z "$SESSION_DIR" ] || [ ! -d "$SESSION_DIR" ]; then
+    echo "No session directory found." >&2
+    echo "  RLM_SESSION_DIR=${SESSION_DIR:-<not set>}" >&2
+    exit 1
+fi
+
+# ─── Helper: render a session JSONL to readable transcript ────────────────
+
+render_session() {
+    local file="$1"
+    python3 -c "
+import json, sys
+
+with open('$file') as f:
+    for line in f:
+        r = json.loads(line)
+
+        # Session metadata
+        if r.get('type') == 'session':
+            ts = r.get('timestamp', '?')
+            cwd = r.get('cwd', '?')
+            print(f'=== Session: {ts} ===')
+            print(f'    cwd: {cwd}')
+            print()
+            continue
+
+        if r.get('type') != 'message':
+            continue
+
+        msg = r['message']
+        role = msg.get('role', '?')
+        content = msg.get('content', '')
+
+        if role == 'toolResult':
+            tool = msg.get('toolName', '?')
+            if isinstance(content, list):
+                text = ''.join(p.get('text', '') for p in content if isinstance(p, dict))
+            else:
+                text = str(content)
+            # Truncate long tool results
+            if len(text) > 500:
+                text = text[:500] + '... [truncated]'
+            print(f'[{tool} result]: {text}')
+            print()
+            continue
+
+        if isinstance(content, str):
+            print(f'{role}: {content}')
+            print()
+            continue
+
+        # content is a list of parts
+        for part in content:
+            if not isinstance(part, dict):
+                continue
+            ptype = part.get('type', '')
+            if ptype == 'text':
+                text = part.get('text', '')
+                if len(text) > 1000:
+                    text = text[:1000] + '... [truncated]'
+                print(f'{role}: {text}')
+                print()
+            elif ptype == 'toolCall':
+                name = part.get('name', '?')
+                args = part.get('arguments', {})
+                if name == 'bash':
+                    cmd = args.get('command', '')
+                    if len(cmd) > 200:
+                        cmd = cmd[:200] + '...'
+                    print(f'{role}: [bash] {cmd}')
+                else:
+                    argstr = json.dumps(args)
+                    if len(argstr) > 200:
+                        argstr = argstr[:200] + '...'
+                    print(f'{role}: [{name}] {argstr}')
+                print()
+            elif ptype == 'thinking':
+                # Skip thinking blocks — they're internal
+                pass
+" 2>/dev/null
+}
+
+# ─── Commands ─────────────────────────────────────────────────────────────
+
+case "${1:-list}" in
+    list|--trace)
+        FILTER=""
+        if [ "${1:-}" = "--trace" ] && [ -n "$TRACE_ID" ]; then
+            FILTER="$TRACE_ID"
+            echo "Sessions for trace $TRACE_ID:"
+        else
+            echo "All sessions in $SESSION_DIR:"
+        fi
+        echo ""
+
+        for f in "$SESSION_DIR"/*.jsonl; do
+            [ -f "$f" ] || continue
+            base=$(basename "$f")
+
+            # Filter by trace if requested
+            if [ -n "$FILTER" ] && [[ "$base" != "${FILTER}"* ]]; then
+                continue
+            fi
+
+            # Get basic info
+            size=$(wc -c < "$f")
+            msgs=$(grep -c '"type":"message"' "$f" 2>/dev/null || echo 0)
+            ts=$(python3 -c "
+import json
+with open('$f') as fh:
+    r = json.loads(fh.readline())
+    print(r.get('timestamp', '?')[:19])
+" 2>/dev/null || echo "?")
+
+            printf "  %-50s %6s bytes  %3s msgs  %s\n" "$base" "$size" "$msgs" "$ts"
+        done
+        ;;
+
+    read)
+        shift
+        if [ "${1:-}" = "--last" ]; then
+            FILE=$(ls -t "$SESSION_DIR"/*.jsonl 2>/dev/null | head -1)
+            if [ -z "$FILE" ]; then
+                echo "No sessions found." >&2
+                exit 1
+            fi
+        else
+            FILE="${1:?Usage: rlm_sessions read <file|--last>}"
+            # Allow bare filename (without path)
+            if [ ! -f "$FILE" ] && [ -f "$SESSION_DIR/$FILE" ]; then
+                FILE="$SESSION_DIR/$FILE"
+            fi
+        fi
+        render_session "$FILE"
+        ;;
+
+    grep)
+        shift
+        TRACE_ONLY=false
+        if [ "${1:-}" = "-t" ]; then
+            TRACE_ONLY=true
+            shift
+        fi
+        PATTERN="${1:?Usage: rlm_sessions grep [-t] <pattern>}"
+
+        for f in "$SESSION_DIR"/*.jsonl; do
+            [ -f "$f" ] || continue
+            base=$(basename "$f")
+
+            if [ "$TRACE_ONLY" = true ] && [ -n "$TRACE_ID" ]; then
+                [[ "$base" == "${TRACE_ID}"* ]] || continue
+            fi
+
+            # Search in message text content
+            matches=$(python3 -c "
+import json, re
+pattern = re.compile(r'$PATTERN', re.IGNORECASE)
+with open('$f') as fh:
+    for line in fh:
+        r = json.loads(line)
+        if r.get('type') != 'message': continue
+        msg = r['message']
+        content = msg.get('content', '')
+        if isinstance(content, str):
+            if pattern.search(content):
+                role = msg.get('role', '?')
+                match = content[:150]
+                print(f'{role}: {match}')
+        elif isinstance(content, list):
+            for part in content:
+                text = part.get('text', '') if isinstance(part, dict) else ''
+                if text and pattern.search(text):
+                    role = msg.get('role', '?')
+                    print(f'{role}: {text[:150]}')
+" 2>/dev/null)
+
+            if [ -n "$matches" ]; then
+                echo "--- $base ---"
+                echo "$matches"
+                echo ""
+            fi
+        done
+        ;;
+
+    *)
+        echo "Usage: rlm_sessions [list|--trace|read <file>|grep <pattern>]" >&2
+        exit 1
+        ;;
+esac

package/ypi

@@ -11,8 +11,8 @@
 #   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_PROVIDER       — LLM provider for sub-calls (default: Pi's default)
+#   RLM_MODEL          — LLM model for sub-calls (default: Pi's default)
 #   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)
@@ -23,6 +23,7 @@
 #   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)
+#   RLM_SHARED_SESSIONS — set to "0" to disable session log sharing (default: 1)
 #   PI_TRACE_FILE      — path to trace log for all calls with timing (default: none)
 
 set -euo pipefail
@@ -37,8 +38,8 @@ 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}"
+[ -n "${RLM_PROVIDER:-}" ]       && export RLM_PROVIDER
+[ -n "${RLM_MODEL:-}" ]          && export RLM_MODEL
 export RLM_SYSTEM_PROMPT="$SCRIPT_DIR/SYSTEM_PROMPT.md"
 
 # Guardrails — pass through if set, don't override
@@ -52,6 +53,7 @@ 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}"
+export RLM_SHARED_SESSIONS="${RLM_SHARED_SESSIONS:-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')}"
@@ -88,6 +90,30 @@ if [ -f "$SCRIPT_DIR/extensions/ypi.ts" ]; then
     YPI_EXT_ARGS=(-e "$SCRIPT_DIR/extensions/ypi.ts")
 fi
 
+# Parse --append-system-prompt from args so ypi works like pi with rp
+# We append to the combined prompt file rather than passing through,
+# since pi already gets --system-prompt from us.
+PASS_ARGS=()
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --append-system-prompt)
+            shift
+            printf '\n%s\n' "$1" >> "$COMBINED_PROMPT"
+            shift
+            ;;
+        --system-prompt)
+            # User overriding ypi's system prompt entirely
+            echo "⚠️  Overriding ypi's system prompt. Did you mean --append-system-prompt?" >&2
+            shift
+            cat "$1" > "$COMBINED_PROMPT" 2>/dev/null || echo "$1" > "$COMBINED_PROMPT"
+            shift
+            ;;
+        *)
+            PASS_ARGS+=("$1")
+            shift
+            ;;
+    esac
+done
 # Launch Pi with the combined system prompt, passing all args through
 # User's own extensions (hashline, etc.) are discovered automatically by Pi.
-exec pi --system-prompt "$COMBINED_PROMPT" "${YPI_EXT_ARGS[@]}" "$@"
+exec pi --system-prompt "$COMBINED_PROMPT" "${YPI_EXT_ARGS[@]}" "${PASS_ARGS[@]}"