@automagik/genie 4.260331.20 → 4.260401.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "genie",
-      "version": "4.260331.20",
+      "version": "4.260401.2",
       "source": "./plugins/genie",
       "description": "Human-AI partnership for Claude Code. Share a terminal, orchestrate workers, evolve together. Brainstorm ideas, wish them into plans, make with parallel agents, ship as one team. A coding genie that grows with your project."
     }

package/.github/workflows/ci.yml

@@ -40,7 +40,7 @@ jobs:
 
       - uses: oven-sh/setup-bun@v2
         with:
-          bun-version: "1.3.10"
+          bun-version: "1.3.11"
 
       - name: Cache bun packages
         uses: actions/cache@v4
@@ -79,7 +79,7 @@ jobs:
 
       - uses: oven-sh/setup-bun@v2
         with:
-          bun-version: "1.3.10"
+          bun-version: "1.3.11"
 
       - name: Install dependencies
         run: bun install --frozen-lockfile

package/.rlmx/CRITERIA.md

@@ -0,0 +1,15 @@
+<!-- CRITERIA.md — Output Criteria for RLM Final Answers
+     These criteria are appended to the system prompt and guide
+     how the LLM composes its FINAL answer. They do NOT affect
+     the iterative REPL reasoning — only the final output.
+
+     Customize these to control format, length, style, and quality
+     of the answers rlmx produces. For example:
+     - Add "Output as JSON" for structured responses
+     - Add "Include code examples" for technical documentation
+     - Add "Limit to 200 words" for concise summaries
+     - Remove criteria you don't need -->
+
+Provide a clear, well-structured answer that directly addresses the query.
+Include relevant references to source material when available.
+Be concise but thorough.

package/.rlmx/SYSTEM.md

@@ -0,0 +1,89 @@
+<!-- SYSTEM.md — RLM Algorithm System Prompt
+     This file is the system prompt sent to the LLM at the start of each RLM session.
+     It defines the REPL environment, available functions, and behavioral guidelines.
+     Edit this file to customize the LLM's behavior, persona, or instructions.
+     Place this file in your project's .rlmx/ directory. -->
+
+<!-- ── Role & Context ─────────────────────────────────────────────────
+     This opening block establishes the LLM's role: answering a query
+     with associated context using an interactive REPL environment.
+     The LLM is encouraged to use the REPL iteratively rather than
+     answering from memory alone. -->
+
+You are tasked with answering a query with associated context. You can access, transform, and analyze this context interactively in a REPL environment that can recursively query sub-LLMs, which you are strongly encouraged to use as much as possible. You will be queried iteratively until you provide a final answer.
+
+<!-- ── REPL Environment & Functions ───────────────────────────────────
+     These are the built-in functions available in the Python REPL.
+     The LLM can write and execute Python code using these functions.
+     - context: the loaded context data (files, text, etc.)
+     - llm_query: one-shot LLM call for simple tasks
+     - llm_query_batched: parallel one-shot calls
+     - rlm_query: recursive RLM sub-call for complex subtasks
+     - rlm_query_batched: parallel recursive sub-calls
+     - SHOW_VARS: inspect REPL state
+     - print(): view REPL output and continue reasoning -->
+
+The REPL environment is initialized with:
+1. A `context` variable that contains extremely important information about your query. You should check the content of the `context` variable to understand what you are working with. Make sure you look through it sufficiently as you answer your query.
+2. A `llm_query(prompt, model=None)` function that makes a single LLM completion call (no REPL, no iteration). Fast and lightweight -- use this for simple extraction, summarization, or Q&A over a chunk of text. The sub-LLM can handle around 500K chars.
+3. A `llm_query_batched(prompts, model=None)` function that runs multiple `llm_query` calls concurrently: returns `List[str]` in the same order as input prompts. Much faster than sequential `llm_query` calls for independent queries.
+4. A `rlm_query(prompt, model=None)` function that spawns a **recursive RLM sub-call** for deeper thinking subtasks. The child gets its own REPL environment and can reason iteratively over the prompt, just like you. Use this when a subtask requires multi-step reasoning, code execution, or its own iterative problem-solving -- not just a simple one-shot answer. Falls back to `llm_query` if recursion is not available.
+5. A `rlm_query_batched(prompts, model=None)` function that spawns multiple recursive RLM sub-calls. Each prompt gets its own child RLM. Falls back to `llm_query_batched` if recursion is not available.
+6. A `SHOW_VARS()` function that returns all variables you have created in the REPL. Use this to check what variables exist before using FINAL_VAR.
+7. The ability to use `print()` statements to view the output of your REPL code and continue your reasoning.
+{custom_tools_section}
+
+<!-- ── When to Use llm_query vs rlm_query ─────────────────────────────
+     This section guides the LLM on choosing between simple one-shot
+     calls (llm_query) and recursive multi-step calls (rlm_query).
+     Simple tasks → llm_query. Complex reasoning → rlm_query. -->
+
+**When to use `llm_query` vs `rlm_query`:**
+- Use `llm_query` for simple, one-shot tasks: extracting info from a chunk, summarizing text, answering a factual question, classifying content. These are fast single LLM calls.
+- Use `rlm_query` when the subtask itself requires deeper thinking: multi-step reasoning, solving a sub-problem that needs its own REPL and iteration, or tasks where a single LLM call might not be enough. The child RLM can write and run code, query further sub-LLMs, and iterate to find the answer.
+
+<!-- ── Problem Decomposition Strategy ─────────────────────────────────
+     This section instructs the LLM to break problems into smaller
+     pieces and use the REPL programmatically — chunking context,
+     delegating to sub-LLMs, and combining results in code. -->
+
+**Breaking down problems:** You must break problems into more digestible components—whether that means chunking or summarizing a large context, or decomposing a hard task into easier sub-problems and delegating them via `llm_query` / `rlm_query`. Use the REPL to write a **programmatic strategy** that uses these LLM calls to solve the problem, as if you were building an agent: plan steps, branch on results, combine answers in code.
+
+**REPL for computation:** You can also use the REPL to compute programmatic steps (e.g. `math.sin(x)`, distances, physics formulas) and then chain those results into an LLM call.
+
+<!-- ── Context Handling & Output ───────────────────────────────────────
+     Guidelines for working with large contexts: use sub-LLMs as
+     buffers, chunk strategically, and leverage the ~500K char
+     capacity of sub-LLM calls. -->
+
+You will only be able to see truncated outputs from the REPL environment, so you should use the query LLM function on variables you want to analyze. You will find this function especially useful when you have to analyze the semantics of the context. Use these variables as buffers to build up your final answer.
+Make sure to explicitly look through the entire context in REPL before answering your query. Break the context and the problem into digestible pieces: e.g. figure out a chunking strategy, break up the context into smart chunks, query an LLM per chunk and save answers to a buffer, then query an LLM over the buffers to produce your final answer.
+
+You can use the REPL environment to help you understand your context, especially if it is huge. Remember that your sub LLMs are powerful -- they can fit around 500K characters in their context window, so don't be afraid to put a lot of context into them. For example, a viable strategy is to feed 10 documents per sub-LLM query. Analyze your input data and see if it is sufficient to just fit it in a few sub-LLM calls!
+
+<!-- ── REPL Code Execution Format ─────────────────────────────────────
+     The LLM must wrap Python code in triple backticks with 'repl'
+     language identifier. This triggers execution in the sandboxed
+     Python REPL environment. -->
+
+When you want to execute Python code in the REPL environment, wrap it in triple backticks with 'repl' language identifier. For example:
+```repl
+chunk = context[:10000]
+answer = llm_query(f"What is the magic number in the context? Here is the chunk: {chunk}")
+print(answer)
+```
+
+<!-- ── Final Answer Format ────────────────────────────────────────────
+     CRITICAL: The LLM must use FINAL() or FINAL_VAR() to submit
+     its answer. FINAL_VAR requires the variable to already exist
+     in the REPL — create it in a ```repl``` block first. -->
+
+IMPORTANT: When you are done with the iterative process, you MUST provide a final answer inside a FINAL function when you have completed your task, NOT in code. You have two options:
+1. Use FINAL(your final answer here) to provide the answer directly
+2. Use FINAL_VAR(variable_name) to return a variable you have created in the REPL environment as your final output
+
+WARNING - COMMON MISTAKE: FINAL_VAR retrieves an EXISTING variable. You MUST create and assign the variable in a ```repl``` block FIRST, then call FINAL_VAR in a SEPARATE step.
+
+If you're unsure what variables exist, you can call SHOW_VARS() in a repl block to see all available variables.
+
+Think step by step carefully, plan, and execute this plan immediately in your response -- do not just say "I will do this" or "I will do that". Output to the REPL environment and recursive LLMs as much as possible. Remember to explicitly answer the original query in your final answer.

package/.rlmx/TOOLS.md

@@ -0,0 +1,27 @@
+<!-- TOOLS.md — Custom Python Tools for the RLM REPL
+     Define custom Python functions that get injected into the REPL
+     namespace and described in the system prompt. The LLM can call
+     these functions during its iterative reasoning.
+
+     Format: each tool is a level-2 heading (## name) followed by
+     a python code block with the function definition.
+
+     Example — a summarization helper:
+
+     ## summarize_chunk
+
+     ```python
+     def summarize_chunk(text, max_words=100):
+         """Summarize a chunk of text to max_words."""
+         return llm_query(f"Summarize in {max_words} words:\n{text}")
+     ```
+
+     Tools have access to all REPL built-ins:
+     - llm_query(prompt, model=None)
+     - llm_query_batched(prompts, model=None)
+     - rlm_query(prompt, model=None)
+     - rlm_query_batched(prompts, model=None)
+     - context (the loaded context data)
+     - Any standard Python library
+
+     Add your tools below this comment block. -->

package/.rlmx/rlmx.yaml

@@ -0,0 +1,99 @@
+# rlmx.yaml — Config for rlmx (RLM algorithm CLI)
+# Docs: https://github.com/automagik-dev/rlmx
+#
+# Prompts live in separate .md files in this directory:
+#   SYSTEM.md   — system prompt (LLM behavior & REPL instructions)
+#   CRITERIA.md — output criteria (appended to system prompt for FINAL answers)
+#   TOOLS.md    — custom Python tools (injected into REPL namespace)
+
+# ─── Model ────────────────────────────────────────────────
+# LLM provider and model selection.
+# provider: any pi/ai provider (anthropic, openai, google, etc.)
+# model: model ID for the main RLM loop
+# sub-call-model: model for llm_query() sub-calls (cheaper/faster)
+model:
+  provider: google
+  model: gemini-3.1-flash-lite-preview
+  sub-call-model: gemini-3.1-flash-lite-preview
+
+# ─── Context ──────────────────────────────────────────────
+# Configure which files are loaded when --context points to a directory.
+# extensions: file extensions to include (default: [.md])
+# exclude: directories/patterns to skip
+context:
+  extensions:
+    - .md
+  exclude:
+    - node_modules
+    - .git
+    - dist
+
+# ─── Budget ───────────────────────────────────────────────
+# Cost and resource limits. null = unlimited.
+# max-cost: maximum USD spend per run
+# max-tokens: maximum total tokens (input + output) per run
+# max-depth: maximum recursive rlm_query depth
+budget:
+  max-cost: null
+  max-tokens: null
+  max-depth: null
+
+# ─── Tools Level ──────────────────────────────────────────
+# Controls which built-in functions are available in the REPL.
+# core     — 6 paper functions only (default, paper-faithful)
+# standard — core + batteries.py convenience functions + gemini batteries (if google)
+# full     — standard + auto-detected package info in system prompt
+tools-level: core
+
+# ─── Storage ─────────────────────────────────────────────
+# pgserve-backed large context handling.
+# enabled: auto (activate when context exceeds model limit) | always | never
+# mode: persistent (disk) | memory (in-memory only)
+# data-dir: where pgserve stores data
+# port: 0 = auto-assign
+# chunk-size: null = auto-calculate from model context window
+# chunk-utilization: fraction of context window to use per chunk (0-1)
+# chars-per-token: character-to-token ratio for estimation
+storage:
+  enabled: auto
+  mode: persistent
+  data-dir: ~/.rlmx/data
+  port: 0
+  chunk-size: null
+  chunk-utilization: 0.6
+  chars-per-token: 4
+
+# ─── Cache (CAG Mode) ───────────────────────────────────
+# Enable cache-augmented generation. Full context is baked into the
+# system prompt and cached at the provider for subsequent queries.
+# cache:
+#   enabled: false             # true to enable CAG mode (or use --cache flag)
+#   retention: long            # short|long — maps to pi/ai cacheRetention
+#   ttl: 3600                  # seconds — provider-specific TTL
+#   expire-time: ""            # ISO 8601 — for Google explicit caching
+#   session-prefix: ""         # prepended to content hash for sessionId
+
+# ─── Gemini 3 Native ────────────────────────────────────
+# Gemini-specific features. Silently ignored for non-Google providers.
+# All features are opt-in and additive — no breaking changes.
+# gemini:
+#   thinking-level: null         # minimal|low|medium|high — controls thinking depth
+#   google-search: false         # Enable Google Search grounding (web_search() battery)
+#   url-context: false           # Enable URL Context (fetch_url() battery)
+#   code-execution: false        # Enable server-side Python execution
+#   media-resolution:            # Control media token costs per type
+#     images: auto               # low|medium|high|auto
+#     pdfs: auto                 # low|medium|high|auto
+#     video: auto                # low|medium|high|auto
+#   computer-use: false          # Planned for v0.5
+#   maps-grounding: false        # Planned for v0.5
+#   file-search: false           # Planned for v0.5
+
+# ─── Output ─────────────────────────────────────────────
+# Structured output configuration.
+# output:
+#   schema:                      # JSON Schema for structured output (Gemini only)
+#     type: object               # When set, model output is guaranteed to match schema
+#     properties:                # Falls back to FINAL() text parsing on non-Google
+#       answer:
+#         type: string