rubyn-code 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 342d51b0944ce35908b8fd56f52b0321cf698ea01ec3cc8fa572d92b9c332b22
-  data.tar.gz: '033868c98fedc4814cb9e8c94eb8f013b15641d5a3e7cecf7e819d3d3b57f771'
+  metadata.gz: f5cbf6f4737790408893a904d64412c2dd695e81a2cd2e5960b4da3196e48f4f
+  data.tar.gz: f0e9b80f10c77d6eb6c357db7518851344670653546d5eca2784d017d490608c
 SHA512:
-  metadata.gz: 283cff44827418497c9ed9d27e4331d8fdf24c04825ee3f28e46a33da28bf61f65d0a2b85173187947393856053fad5466dce5782fcef3d0e1dcce68d37e00eb
-  data.tar.gz: 6c96e7beba37f74c0fe947470a1a37d50b521087b573407d6ba7d0d0649d71385b263b70b126fe9c2b7da3c910a233862fdbfb8c1d7c534db6f6cc1d813ec305
+  metadata.gz: bc4553f04fbac43903e1515cec43cf595245d36223bca70342ddafb2a2920f38f502b356eb353b4b6e5284d128688e07c015e0a3ebb4aa06f7029fac0ba42a37
+  data.tar.gz: b9f8ab09a40e073bff1657ef9d829b7551a5ca56ce9f77b65bd59b835d079665d3663faf92ccf44fd84d4ff3674f835c09d102b4f449c175c77bcafb466dd934

data/README.md

@@ -35,9 +35,11 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 - [MCP — External Tool Servers](#mcp--external-tool-servers)
 - [Codebase Indexing](#codebase-indexing)
 - [112 Best Practice Skills](#112-best-practice-skills)
+- [Skill Packs — Registry-Backed Extensions](#skill-packs--registry-backed-extensions)
 - [Context Architecture](#context-architecture)
 - [RUBYN.md — Project Instructions](#rubynmd--project-instructions)
 - [PR Review](#pr-review)
+- [Megaplan — Phased Planning](#megaplan--phased-planning)
 - [Sub-Agents & Teams](#sub-agents--teams)
 - [GOLEM — Autonomous Daemon](#golem--autonomous-daemon)
 - [Continuous Learning](#continuous-learning)
@@ -61,14 +63,15 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 
 - **Rails-native** — understands service object extraction, RSpec conventions, ActiveRecord patterns, and Hotwire
 - **Context-aware** — automatically incorporates schema, routes, specs, factories, and models
-- **Best practices built in** — ships with 112 curated Ruby and Rails guidelines that load on demand
+- **Best practices built in** — ships with 112 curated Ruby and Rails guidelines that load on demand, plus registry-backed [skill packs](#skill-packs--registry-backed-extensions) that autoload as you need them
+- **Plans big work in phases** — [`/megaplan`](#megaplan--phased-planning) runs a read-only interview, then breaks rewrites and migrations into vertical-slice phases that ship one at a time
 - **Agentic** — doesn't just answer questions. Reads files, writes code, runs specs, commits, reviews PRs, spawns sub-agents, and remembers what it learns
 - **IDE-ready** — works in the terminal and inside VS Code with full bidirectional communication
 - **Extensible** — connect external tool servers via MCP, add custom skills, or wire up your own providers
 
 ## Install
 
-Requires **Ruby 4.0+**. Install with your latest Ruby, then pin it so it works in every project:
+Requires **Ruby 4.0.2+**. Install with your latest Ruby, then pin it so it works in every project:
 
 ```bash
 # Install the gem
@@ -83,11 +86,11 @@ That's it. `rubyn-code` now works in any project regardless of `.ruby-version`.
 <details>
 <summary>Using rbenv?</summary>
 
-If you manage multiple Rubies with rbenv, install on your latest:
+If you manage multiple Rubies with rbenv, install on your latest (run `rbenv versions` to list what you have):
 
 ```bash
-RBENV_VERSION=4.0.2 gem install rubyn-code
-RBENV_VERSION=4.0.2 rubyn-code --setup
+RBENV_VERSION=<your-ruby-version> gem install rubyn-code
+RBENV_VERSION=<your-ruby-version> rubyn-code --setup
 ```
 
 The `--setup` command creates a launcher in `~/.local/bin` that calls the gem wrapper directly, skipping rbenv's shim. As long as `~/.local/bin` is in your PATH before `~/.rbenv/shims`, you're good.
@@ -98,7 +101,7 @@ The `--setup` command creates a launcher in `~/.local/bin` that calls the gem wr
 <summary>Using rvm?</summary>
 
 ```bash
-rvm use 4.0.2
+rvm use <your-ruby-version>
 gem install rubyn-code
 rubyn-code --setup
 ```
@@ -135,6 +138,8 @@ rubyn-code -p "Refactor app/controllers/orders_controller.rb into service object
 rubyn-code --ide
 ```
 
+**Tip:** Reference files inline with `@` — `rubyn > explain @lib/foo.rb and @config/routes.rb`. Rubyn inlines their contents so you don't have to wait for it to read them.
+
 ## What Can Rubyn Do?
 
 ### Refactor code
@@ -203,7 +208,7 @@ Rubyn Code includes a VS Code extension that provides a full IDE experience with
 | `default` | Per-tool approval required |
 | `bypass` | YOLO — skip all approval prompts |
 
-The extension communicates over 14 RPC methods: `initialize`, `prompt`, `cancel`, `review`, `approveToolUse`, `acceptEdit`, `session/*`, `config/*`, `models/list`, and `shutdown`.
+The extension communicates over 19 RPC methods: `initialize`, `prompt`, `cancel`, `review`, `approveToolUse`, `acceptEdit`, `session/*`, `config/*`, `models/list`, `plan/propose`, `plan/interview/*` (chat-resident [megaplan](#megaplan--phased-planning)), `recover_ci`, and `shutdown`.
 
 ## 29 Built-in Tools
 
@@ -224,7 +229,7 @@ The extension communicates over 14 RPC methods: `initialize`, `prompt`, `cancel`
 
 ## MCP — External Tool Servers
 
-Connect external tool servers via the [Model Context Protocol](https://modelcontextprotocol.io). MCP tools are dynamically discovered and registered as native Rubyn tools, available in the REPL, IDE, and daemon.
+Connect external tool servers via the [Model Context Protocol](https://modelcontextprotocol.io). MCP tools are dynamically discovered and registered as native Rubyn tools, available in the REPL, IDE, and daemon. Servers that expose **resources** and **prompts** are also bridged — Rubyn registers per-server `read_resource` and `get_prompt` tools, and `/mcp` reports the counts.
 
 ### Configuration
 
@@ -316,6 +321,29 @@ mkdir -p ~/.rubyn-code/skills
 echo "# Use double quotes for strings" > ~/.rubyn-code/skills/my_style.md
 ```
 
+## Skill Packs — Registry-Backed Extensions
+
+Beyond the 112 built-in skills, Rubyn can pull additional skill packs from the [rubyn.ai](https://rubyn.ai) registry. Packs are bundles of related skills published by the community or by Rubyn itself.
+
+```
+rubyn > /skills                    # list installed packs and browse the registry
+rubyn > /install-skills sidekiq    # install a pack by name
+rubyn > /install-skills graphql viewcomponent  # install multiple at once
+rubyn > /remove-skills sidekiq     # uninstall
+```
+
+Installed packs live at `~/.rubyn-code/skill-packs/<pack-name>/` and load alongside the built-in catalog.
+
+### Auto-suggest from your Gemfile
+
+On session start, Rubyn parses your `Gemfile` and quietly suggests matching packs the first time it sees a gem (e.g. detects `sidekiq` → suggests the sidekiq pack). Suggestions are recorded in `.rubyn-code/suggested.json` so you only see each one once.
+
+### Trigger-based autoload
+
+If your message mentions a topic that matches an uninstalled pack's name or tags, Rubyn fetches the pack from the registry on the fly, installs it, and feeds the relevant skills into the same turn. Registry failures are silent — the conversation continues as if the autoload weren't there.
+
+Point at a custom registry with `RUBYN_REGISTRY_URL=https://your-registry.example.com`.
+
 ## Context Architecture
 
 Rubyn automatically loads relevant context based on what you're working on:
@@ -323,7 +351,7 @@ Rubyn automatically loads relevant context based on what you're working on:
 - **Controllers** → includes models, routes, request specs, services
 - **Models** → includes schema, associations, specs, factories
 - **Service objects** → includes referenced models and their specs
-- **Any file** → checks for `RUBYN.md`, `CLAUDE.md`, or `AGENT.md` instructions
+- **Any file** → checks for `RUBYN.md`, `CLAUDE.md`, `AGENTS.md`, or `AGENT.md` instructions
 
 The [codebase index](#codebase-indexing) enhances this with structural awareness — Rubyn knows which files depend on each other before it reads them.
 
@@ -341,7 +369,7 @@ Drop a `RUBYN.md` in your project root and Rubyn follows your conventions:
 - Run rubocop before committing
 ```
 
-Also reads `CLAUDE.md` and `AGENT.md` — no migration needed from other tools.
+Also reads `CLAUDE.md`, `AGENTS.md`, and `AGENT.md` — no migration needed from other tools.
 
 | Location | Scope |
 |----------|-------|
@@ -364,6 +392,93 @@ Focus areas: `all`, `security`, `performance`, `style`, `testing`
 
 Severity ratings: **[critical]** **[warning]** **[suggestion]** **[nitpick]**
 
+## Chisel — Write the Minimum That Works
+
+Chisel is an opt-in mode that makes Rubyn think like the laziest senior dev in
+the room: the best code is the code you never wrote. It's **off by default** and
+only changes the agent's behavior once you turn it on.
+
+```
+rubyn > /chisel              # show current intensity
+rubyn > /chisel full         # turn it on
+rubyn > /chisel off          # back to normal
+```
+
+Intensities: `off` (default) · `lite` · `full` · `ultra`. When on, Rubyn walks a
+decision ladder before writing code — does this need to exist? does stdlib or an
+installed gem already do it? is it one line? — and only then writes the smallest
+change that solves the task. The safety floor (validation, error/data-loss
+handling, security, accessibility) is never on the chopping block.
+
+Set it permanently with `chisel_mode: full` in `~/.rubyn-code/config.yml`, or
+per-shell with `RUBYN_CHISEL_MODE=full`.
+
+**On-demand audits** (work whether or not the always-on mode is enabled):
+
+```
+rubyn > /chisel-review            # over-engineering in your diff vs main
+rubyn > /chisel-review develop    # ...vs a different base
+rubyn > /chisel-audit             # sweep the whole repo
+rubyn > /chisel-audit app/services  # ...scoped to a path
+```
+
+Both return a ranked deletion/simplification list — each item with a location, the
+ladder rung it skipped, and the concrete simpler form — and stay read-only (they
+report, they don't edit).
+
+**Debt ledger & status.** Leave a `# chisel: …` comment when you consciously defer a
+simplification, then collect them later:
+
+```
+rubyn > /chisel-debt    # list every `# chisel:` deferral, with file:line and note
+rubyn > /chisel-gain    # current mode, outstanding debt count, and reference impact
+```
+
+**Verifying Chisel.** A standalone smoke test runs the whole layer against a
+committed, deliberately over-engineered fixture and gives the same result every
+time — no LLM, no network:
+
+```
+$ bundle exec ruby skills/self_test/chisel_smoke.rb
+CHISEL debt: PASS         # scans the fixture → its exact planted `# chisel:` markers
+CHISEL engine: PASS       # off injects nothing; lite/full/ultra keep the safety floor
+CHISEL inspection: PASS   # review/audit prompts assemble; bad scope raises
+CHISEL commands: PASS     # all five slash commands register
+CHISEL: PASS
+```
+
+The fixture lives at `skills/self_test/fixtures/chisel_sample.rb`, the same check is
+Section 18 of the `/skill self-test` scorecard, and `spec/rubyn_code/chisel/self_test_fixture_spec.rb`
+guards the fixture's exact scan output so it can't silently drift.
+
+## Megaplan — Phased Planning
+
+For work too big for a single PR — rewrites, migrations, multi-feature initiatives — Rubyn ships a planning workflow that breaks the feature into vertical-slice phases before any code gets written.
+
+```
+rubyn > /megaplan extract billing into its own service
+  Megaplan mode — interviewer with read-only tools
+
+  Decisions so far: (none yet)
+
+  Q1. What triggers the extraction now — a scaling issue, a team boundary,
+      or a compliance constraint?
+        1. Scaling (recommended — billing is the hottest table)
+        2. Team boundary
+        3. Compliance
+```
+
+What happens when you run `/megaplan`:
+
+- Loads the **megaplan** skill into context.
+- Flips the agent into **plan mode** — only read-only tools (file reads, search, git status) are available. No edits, no shell mutations.
+- Conducts a one-question-at-a-time interview to lock down scope, constraints, and risk before proposing phases.
+- Outputs a numbered phase breakdown, each phase shippable on its own with the trunk staying green.
+
+Trigger phrases like "megaplan", "mega plan", "plan phases", or "phase this out" in normal conversation will surface the skill via [trigger-based autoload](#skill-packs--registry-backed-extensions) too.
+
+In the VS Code extension the same workflow runs as a chat-resident interview with structured question cards instead of free-text Q&A. Same skill driving both surfaces.
+
 ## Sub-Agents & Teams
 
 ### Sub-Agents (disposable)
@@ -422,6 +537,19 @@ Rubyn gets smarter with every session:
 3. **On next startup** — injects top instincts into the system prompt
 4. **Over time** — reinforced instincts strengthen, unused ones decay and get pruned
 
+### Take your learnings with you
+
+Instincts live in `~/.rubyn-code`. Move them to another machine with `/learning`:
+
+```
+rubyn > /learning                       # how many instincts you've accumulated
+rubyn > /learning export learnings.json # write them to a portable file
+# ...on the new machine...
+rubyn > /learning import learnings.json --here   # load them (--here = apply to this project)
+```
+
+Import regenerates ids and skips duplicates, so it's safe to run repeatedly.
+
 ## Streaming Output
 
 Real-time streaming with live syntax highlighting via Rouge/Monokai. Code blocks are buffered and highlighted when complete. No waiting for full responses.
@@ -483,6 +611,8 @@ rubyn-code daemon [OPTIONS]   # Run GOLEM autonomous daemon
 | `/new` | Save session and start a fresh conversation |
 | `/review [base]` | PR review against best practices |
 | `/spawn name role` | Spawn a persistent teammate |
+| `/goal <condition>` | Set a goal Rubyn works toward until met (`/goal clear` to cancel) |
+| `/loop [xN] [interval] <prompt-or-/cmd>` | Repeat a prompt or command on an interval (Ctrl-C to stop) |
 | `/compact` | Compress conversation context |
 | `/cost` | Show token usage and costs |
 | `/tasks` | List all tasks |
@@ -493,6 +623,47 @@ rubyn-code daemon [OPTIONS]   # Run GOLEM autonomous daemon
 | `/model` | Show/switch model and provider |
 | `/doctor` | Run environment health checks |
 | `/mcp` | MCP server documentation and status |
+| `/agents` | List sub-agent types (built-in + custom) |
+| `/rewind [id] [code\|chat]` | Rewind code and/or conversation to a checkpoint |
+
+### Custom Sub-Agents
+
+Beyond the built-in `explore` (read-only) and `worker` (read/write) sub-agents, define your own in `.rubyn-code/agents/<name>.md` (project) or `~/.rubyn-code/agents/<name>.md` (global). `spawn_agent` can then target them by name, and `/agents` lists them.
+
+```markdown
+---
+description: Reviews a diff for bugs
+tools: read_file, grep, glob, bash   # optional — omit for the access default
+access: read                         # read | write (default: write)
+---
+You are a meticulous code reviewer. Find correctness bugs only.
+```
+
+### Custom Slash Commands
+
+Drop a markdown file in `.rubyn-code/commands/` (project) or `~/.rubyn-code/commands/` (global) and it becomes a slash command — `deploy.md` → `/deploy`. Project commands override global ones; built-ins always win.
+
+```markdown
+---
+description: Open a PR for the current branch
+---
+Open a pull request for the current branch.
+Title: $ARGUMENTS
+Current diff:
+!`git diff main --stat`
+```
+
+Templating in the body:
+
+| Token | Expands to |
+|-------|-----------|
+| `$ARGUMENTS` | everything typed after the command |
+| `$1` … `$9` | individual positional arguments |
+| `` !`shell cmd` `` | the command's output, inlined |
+
+### Checkpoints & Rewind
+
+Rubyn snapshots a checkpoint at the start of every turn — capturing the conversation and the original contents of any files it changes that turn. `/rewind` lists them; `/rewind <id>` rolls back both code and conversation (or just one with `code`/`chat`). Note: rewind restores files edited via Rubyn's `write_file`/`edit_file`; it does not touch your git history.
 
 ## Authentication
 
@@ -707,7 +878,7 @@ Checks Ruby version, bundler, database state, authentication, skills, project ty
 
 ## Development
 
-Requires Ruby 4.0+.
+Requires Ruby 4.0.2+.
 
 ```bash
 git clone https://github.com/MatthewSuttles/rubyn-code.git

data/db/migrations/014_multi_agent_upgrade.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Multi-agent upgrade: adds parent-child tracking to teammates and
+# structured messaging to mailbox_messages.
+#
+# Teammates: adds parent_agent_id column, fixes status CHECK
+#   (DB had 'busy' but Ruby code uses 'active').
+# Mailbox: adds correlation_id and data columns for structured messaging.
+#
+# Uses table-rebuild pattern because SQLite cannot ALTER CHECK constraints
+# or ADD COLUMN with constraints reliably.
+module Migration014MultiAgentUpgrade
+  module_function
+
+  def up(db)
+    upgrade_teammates(db)
+    upgrade_mailbox(db)
+  end
+
+  def upgrade_teammates(db)
+    db.execute(<<~SQL)
+      CREATE TABLE teammates_new (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        role TEXT NOT NULL,
+        persona TEXT,
+        model TEXT NOT NULL DEFAULT 'claude-sonnet-4-20250514',
+        status TEXT NOT NULL DEFAULT 'idle' CHECK(status IN ('idle','active','offline')),
+        parent_agent_id TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    SQL
+
+    db.execute(<<~SQL)
+      INSERT INTO teammates_new (id, name, role, persona, model, status, metadata, created_at)
+      SELECT id, name, role, persona, model,
+             CASE WHEN status = 'busy' THEN 'active' ELSE status END,
+             metadata, created_at
+      FROM teammates
+    SQL
+
+    db.execute('DROP TABLE teammates')
+    db.execute('ALTER TABLE teammates_new RENAME TO teammates')
+    db.execute('CREATE UNIQUE INDEX IF NOT EXISTS idx_teammates_name ON teammates(name)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_teammates_status ON teammates(status)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_teammates_parent ON teammates(parent_agent_id)')
+  end
+
+  def upgrade_mailbox(db)
+    db.execute(<<~SQL)
+      CREATE TABLE mailbox_messages_new (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        recipient TEXT NOT NULL,
+        message_type TEXT NOT NULL DEFAULT 'message'
+          CHECK(message_type IN ('message','task','result','error','broadcast','shutdown_request','shutdown_response','status_change')),
+        payload TEXT NOT NULL,
+        correlation_id TEXT,
+        data TEXT,
+        read INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+      )
+    SQL
+
+    db.execute(<<~SQL)
+      INSERT INTO mailbox_messages_new (id, sender, recipient, message_type, payload, read, created_at)
+      SELECT id, sender, recipient, message_type, payload, read, created_at
+      FROM mailbox_messages
+    SQL
+
+    db.execute('DROP TABLE mailbox_messages')
+    db.execute('ALTER TABLE mailbox_messages_new RENAME TO mailbox_messages')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_recipient_read ON mailbox_messages(recipient, read)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_sender ON mailbox_messages(sender)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_created ON mailbox_messages(created_at)')
+    db.execute('CREATE INDEX IF NOT EXISTS idx_mailbox_correlation ON mailbox_messages(correlation_id)')
+  end
+end

data/lib/rubyn_code/agent/conversation.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module RubynCode
   module Agent
-    class Conversation
+    class Conversation # rubocop:disable Metrics/ClassLength -- message log + incremental token/tool-ID bookkeeping
       attr_reader :messages
 
       def initialize
         @messages = []
+        reset_derived_state!
       end
 
       # Append a user turn to the conversation.
@@ -16,6 +19,7 @@ module RubynCode
       def add_user_message(content)
         message = { role: 'user', content: content }
         @messages << message
+        track_added_message(message)
         message
       end
 
@@ -28,6 +32,7 @@ module RubynCode
         blocks = normalize_content(content, tool_calls)
         message = { role: 'assistant', content: blocks }
         @messages << message
+        track_added_message(message)
         message
       end
 
@@ -52,8 +57,11 @@ module RubynCode
         # tool results for the same assistant turn are batched together.
         if @messages.last && @messages.last[:role] == 'user' && tool_result_message?(@messages.last)
           @messages.last[:content] << result_block
+          track_appended_block(result_block)
         else
-          @messages << { role: 'user', content: [result_block] }
+          message = { role: 'user', content: [result_block] }
+          @messages << message
+          track_added_message(message)
         end
 
         result_block
@@ -79,6 +87,29 @@ module RubynCode
       # @return [void]
       def clear!
         @messages.clear
+        reset_derived_state!
+      end
+
+      # Character length of the JSON-serialized messages array, maintained
+      # incrementally on append so per-turn token estimation doesn't have to
+      # re-serialize the whole history. Matches JSON.generate(messages).length.
+      #
+      # @return [Integer]
+      def estimated_json_chars
+        @json_chars ||= @messages.sum { |msg| JSON.generate(msg).length }
+        return 2 if @messages.empty?
+
+        # "[" + per-message JSON joined by "," + "]"
+        @json_chars + @messages.length + 1
+      end
+
+      # Drops cached serialization/tool-ID bookkeeping. Must be called after
+      # messages are mutated in place from outside this class (e.g. by
+      # Context::MicroCompact); the caches rebuild lazily on next access.
+      #
+      # @return [void]
+      def refresh_derived_state!
+        reset_derived_state!
       end
 
       # Return the messages array formatted for the Claude API.
@@ -115,21 +146,76 @@ module RubynCode
           @messages.pop
           removed += 1
         end
+        reset_derived_state!
       end
 
       # Replace messages with a new array (used after compaction).
       def replace!(new_messages)
         @messages.replace(new_messages)
+        reset_derived_state!
       end
 
       private
 
+      # Derived bookkeeping kept in sync with @messages so hot paths stay
+      # cheap: per-message JSON char total (token estimation) and
+      # tool_use/tool_result ID sets (orphan repair). nil means "rebuild
+      # lazily from @messages on next access".
+      def reset_derived_state!
+        @json_chars = nil
+        @tool_use_ids = nil
+        @tool_result_ids = nil
+      end
+
+      def track_added_message(message)
+        register_tool_ids(message)
+        return if @json_chars.nil?
+
+        @json_chars += JSON.generate(message).length
+      rescue StandardError
+        @json_chars = nil
+      end
+
+      # A tool_result block appended to an existing user message grows that
+      # message's JSON by the block plus one separator comma.
+      def track_appended_block(result_block)
+        @tool_result_ids << result_block[:tool_use_id] if @tool_result_ids
+        return if @json_chars.nil?
+
+        @json_chars += JSON.generate(result_block).length + 1
+      rescue StandardError
+        @json_chars = nil
+      end
+
+      def register_tool_ids(message)
+        return unless @tool_use_ids && message[:content].is_a?(Array)
+
+        message[:content].each do |block|
+          next unless block.is_a?(Hash)
+
+          if message[:role] == 'assistant' && block_matches_type?(block, 'tool_use')
+            @tool_use_ids << (block[:id] || block['id'])
+          elsif message[:role] == 'user' && block_matches_type?(block, 'tool_result')
+            @tool_result_ids << (block[:tool_use_id] || block['tool_use_id'])
+          end
+        end
+      end
+
+      def rebuild_tool_id_sets!
+        @tool_use_ids = collect_tool_use_ids(@messages)
+        @tool_result_ids = collect_tool_result_ids(@messages)
+      end
+
       # Ensure every tool_use block has a matching tool_result.
       # If a tool_use is orphaned (e.g. from Ctrl-C interruption),
       # inject a synthetic tool_result immediately after the assistant
       # message that contains the orphaned tool_use.
+      #
+      # The ID sets are tracked incrementally as messages are appended, so
+      # the common no-orphan case skips the full-history scans.
       def repair_orphaned_tool_uses(formatted)
-        orphaned = collect_tool_use_ids(formatted) - collect_tool_result_ids(formatted)
+        rebuild_tool_id_sets! if @tool_use_ids.nil?
+        orphaned = @tool_use_ids - @tool_result_ids
         return formatted if orphaned.empty?
 
         insert_orphan_results(formatted, orphaned)

data/lib/rubyn_code/agent/llm_caller.rb

@@ -114,7 +114,7 @@ module RubynCode
 
       def run_compaction
         before = @conversation.length
-        est = @context_manager.estimated_tokens(@conversation.messages)
+        est = @context_manager.estimated_tokens(@conversation)
         RubynCode::Debug.token(
           "context=#{est} tokens (~#{before} messages, " \
           "threshold=#{Config::Defaults::CONTEXT_THRESHOLD_TOKENS})"
@@ -130,7 +130,7 @@ module RubynCode
         after = @conversation.length
         return unless after < before
 
-        new_est = @context_manager.estimated_tokens(@conversation.messages)
+        new_est = @context_manager.estimated_tokens(@conversation)
         RubynCode::Debug.loop_tick(
           "Compacted: #{before} -> #{after} messages " \
           "(#{est} -> #{new_est} tokens)"