rubyn-code 0.5.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b43dc2a8fab138bcfe303180881aa9fa23878faaa532367f07a0fee7605feb34
-  data.tar.gz: 12dffaa487a75dfe276be9d20ff8152814bd60c6b107efd9ed10d2993afd57a5
+  metadata.gz: 7696c779b900fe4dca806aa73d7fcca79309ebe58a242d16e2d5309b43d44ec4
+  data.tar.gz: 2d8d4c8905255ce11e98569f86f4c2d788c620ea30c513fd6771b3c58bb98073
 SHA512:
-  metadata.gz: fcbe574a607028345e38587388a6c0bd9cdb8ab134e690d45583a1a27b4c698383bd43088eb8fa537cddba8690e77d15ab155be92fb997117c8fe62a978df211
-  data.tar.gz: 43e72475ec24edf03f21e4aafa4402de31351728a38de42e55b69db104aea1828b930a1cafb79d3065d07e16f84c8a5a5023311da5d1e40f7a667daa90ddee3c
+  metadata.gz: c5d2b5f15b21d7e02b2f6c2252248eb6e933337b3f4c491135f5453c1ddf4ce47c48605aaeb6e26180a38324c8effc7a149e528c794ca9391ec8c43febbc2bdb
+  data.tar.gz: 15c9aa06c02dd8c105116b403cba0f36cb5a2b91c8690b66b6320a289011cf6f2986a308fdaacad933fbd221646de84b7f774a47709a7c8409fdc5bddca5b671

data/README.md

@@ -15,7 +15,7 @@
   <a href="https://github.com/MatthewSuttles/rubyn-code/actions/workflows/ci.yml"><img src="https://github.com/MatthewSuttles/rubyn-code/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
 </p>
 
-Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code for anti-patterns, and build entire features — all context-aware with your schema, routes, and specs. Powered by Claude Opus 4.6, running on your existing Claude subscription.
+Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code for anti-patterns, and build entire features — all context-aware with your schema, routes, and specs. Powered by Claude Opus 4.8, running on your existing Claude subscription.
 
 <img width="1230" height="280" alt="image" src="https://github.com/user-attachments/assets/14e07ce8-def0-4a8f-ac89-46661361a4eb" />
 
@@ -69,6 +69,22 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 - **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
 
+## Claude Code Feature Parity
+
+Phase 4 ships nine parity features with Claude Code:
+
+- **Extended thinking** — `/think <budget>` toggles per-session reasoning; the Anthropic adapter emits `thinking: {type: 'adaptive'}` on Claude 4.6+ models (`{type: 'enabled', budget_tokens}` on older ones).
+- **Reasoning effort** — `/effort <low|medium|high|xhigh|max>` sets the request-level reasoning depth; the Anthropic adapter emits `output_config: {effort}` on the wire. GA on Claude 4.6+ (Opus 4.6/4.7/4.8, Sonnet 4.6/5, Fable 5); `xhigh` needs Opus 4.7+ / Sonnet 5 / Fable 5. Model default is `high`.
+- **Task budgets (beta)** — the agent loop's remaining token budget is sent as `output_config: {task_budget: {type: 'tokens', total}}` on supported models (Fable 5, Sonnet 5, Opus 4.7/4.8), advisory pacing only — `max_tokens` stays the enforced per-response cap.
+- **Image / vision input** — `@chart.png` (and `.jpg` / `.jpeg` / `.gif` / `.webp`) becomes a real image content block attached to the user turn; Anthropic and OpenAI each emit their native shape.
+- **TodoWrite live checklist** — `TodoWrite` tool; the checklist refreshes above the spinner on every tool result so you see in-turn progress at a glance.
+- **Custom-command frontmatter** — `argument-hint`, `allowed-tools`, and `model:` keys in `~/.rubyn-code/commands/*.md`; the loop honors the per-prompt tool restriction and model override.
+- **`.mcp.json` auto-discovery** — project-root MCP servers flow into the REPL automatically; `/mcp` shows entries prefixed `[project]` or `[user]`. OAuth for URL transports is still deferred.
+- **`/export` transcript** — `/export <path>` writes the conversation as Markdown (default) or `--jsonl` for tooling.
+- **Fable 5 refusal handling** — a declined request (`stop_reason: "refusal"`) surfaces a clear message instead of an empty turn; `claude-fable-5` / `claude-mythos-5` requests opt into a server-side Opus 4.8 fallback by default, so most refusals are transparently re-served in the same call.
+
+See `docs/04-feature-parity/` for per-feature design + tasks docs.
+
 ## Install
 
 Requires **Ruby 4.0.2+**. Install with your latest Ruby, then pin it so it works in every project:
@@ -138,6 +154,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
@@ -227,7 +245,7 @@ The extension communicates over 19 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
 
@@ -349,7 +367,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.
 
@@ -367,7 +385,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 |
 |----------|-------|
@@ -390,6 +408,65 @@ 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.
@@ -476,6 +553,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.
@@ -537,6 +627,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 |
@@ -547,6 +639,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
 

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,21 +1,28 @@
 # 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.
       #
-      # @param content [String]
+      # @param content [String, Array<Hash>] either a plain string or an
+      #   array of content blocks (text, image, etc.). Strings get wrapped
+      #   as `[{ type: 'text', text: content }]` only if there's a planned
+      #   Array; we keep raw String for backward compatibility with the API.
       # @return [Hash] the appended message
       def add_user_message(content)
         message = { role: 'user', content: content }
         @messages << message
+        track_added_message(message)
         message
       end
 
@@ -28,6 +35,7 @@ module RubynCode
         blocks = normalize_content(content, tool_calls)
         message = { role: 'assistant', content: blocks }
         @messages << message
+        track_added_message(message)
         message
       end
 
@@ -52,8 +60,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 +90,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 +149,83 @@ 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
+
+      # Alias for `messages`. Common shorthand for callers that want to
+      # treat the conversation as an Array of message hashes.
+      def to_a
+        @messages
       end
+      alias to_ary to_a
 
       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/dynamic_tool_schema.rb

@@ -8,7 +8,7 @@ module RubynCode
     # prompt overhead by 30-50%.
     module DynamicToolSchema
       BASE_TOOLS = %w[
-        read_file write_file edit_file glob grep bash
+        read_file write_file edit_file glob grep code_graph bash
       ].freeze
 
       TASK_TOOLS = {

data/lib/rubyn_code/agent/llm_caller.rb

@@ -25,7 +25,7 @@ module RubynCode
       def build_llm_opts
         opts = {
           messages: @conversation.to_api_format,
-          tools: @plan_mode ? read_only_tool_definitions : tool_definitions,
+          tools: filtered_tool_definitions,
           system: build_system_prompt,
           on_text: @on_text
         }
@@ -36,6 +36,8 @@ module RubynCode
             total: UsageTracker::TASK_BUDGET_TOTAL, remaining: @task_budget_remaining
           }
         end
+        budget = @llm_client.respond_to?(:thinking_budget_tokens) ? @llm_client.thinking_budget_tokens.to_i : 0
+        opts[:thinking] = { budget_tokens: budget } if budget.positive?
         opts
       end
 
@@ -45,6 +47,8 @@ module RubynCode
       # Falls back to nil (use client's default) if routing fails.
       # -- guard clauses for provider/mode checks
       def routed_model
+        return @model_override if @model_override
+
         return nil if manual_model_mode?
 
         last_user = last_user_message_text
@@ -114,7 +118,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 +134,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)"