rubyn-code 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b43dc2a8fab138bcfe303180881aa9fa23878faaa532367f07a0fee7605feb34
-  data.tar.gz: 12dffaa487a75dfe276be9d20ff8152814bd60c6b107efd9ed10d2993afd57a5
+  metadata.gz: f5cbf6f4737790408893a904d64412c2dd695e81a2cd2e5960b4da3196e48f4f
+  data.tar.gz: f0e9b80f10c77d6eb6c357db7518851344670653546d5eca2784d017d490608c
 SHA512:
-  metadata.gz: fcbe574a607028345e38587388a6c0bd9cdb8ab134e690d45583a1a27b4c698383bd43088eb8fa537cddba8690e77d15ab155be92fb997117c8fe62a978df211
-  data.tar.gz: 43e72475ec24edf03f21e4aafa4402de31351728a38de42e55b69db104aea1828b930a1cafb79d3065d07e16f84c8a5a5023311da5d1e40f7a667daa90ddee3c
+  metadata.gz: bc4553f04fbac43903e1515cec43cf595245d36223bca70342ddafb2a2920f38f502b356eb353b4b6e5284d128688e07c015e0a3ebb4aa06f7029fac0ba42a37
+  data.tar.gz: b9f8ab09a40e073bff1657ef9d829b7551a5ca56ce9f77b65bd59b835d079665d3663faf92ccf44fd84d4ff3674f835c09d102b4f449c175c77bcafb466dd934

data/README.md

@@ -138,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
@@ -227,7 +229,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 +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.
 
@@ -367,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 |
 |----------|-------|
@@ -390,6 +392,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 +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.
@@ -537,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 |
@@ -547,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
 

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)"

data/lib/rubyn_code/agent/loop.rb

@@ -9,7 +9,7 @@ require_relative 'llm_caller'
 
 module RubynCode
   module Agent
-    class Loop
+    class Loop # rubocop:disable Metrics/ClassLength -- core agent loop: LLM calls, tool dispatch, recovery, hooks
       include SystemPromptBuilder
       include ResponseParser
       include ToolProcessor
@@ -18,6 +18,7 @@ module RubynCode
       include LlmCaller
 
       MAX_ITERATIONS = Config::Defaults::MAX_ITERATIONS
+      GOAL_MAX_ITERATIONS = Config::Defaults::GOAL_MAX_ITERATIONS
 
       # @param opts [Hash] keyword arguments for loop configuration
       # @option opts [LLM::Client]                    :llm_client
@@ -39,6 +40,7 @@ module RubynCode
         assign_dependencies(opts)
         assign_callbacks(opts)
         @plan_mode = false
+        @static_prompt_sections = nil
       end
 
       # @return [Boolean]
@@ -61,19 +63,36 @@ module RubynCode
         @skill_ttl&.tick!
         autoload_triggered_skills(user_input)
         @conversation.add_user_message(user_input)
+        reset_system_prompt_cache!
         reset_iteration_state
 
-        MAX_ITERATIONS.times do |iteration|
+        iteration = 0
+        loop do
           result = run_iteration(iteration)
           return result if result
+
+          iteration += 1
+          break unless keep_iterating?(iteration)
         end
 
-        RubynCode::Debug.warn("Hit MAX_ITERATIONS (#{MAX_ITERATIONS})")
-        max_iterations_warning
+        RubynCode::Debug.warn("Hit iteration limit (#{iteration})")
+        max_iterations_warning(iteration)
       end
 
       private
 
+      # Decide whether the loop should run another iteration after `iteration`
+      # turns. Normally capped at MAX_ITERATIONS, but while a Stop hook (e.g. an
+      # active /goal) is keeping the agent alive we extend up to a hard ceiling
+      # — a goal can need more tool turns than a single request. The GoalHook's
+      # own max-attempts valve terminates an unsatisfiable goal; the ceiling is
+      # only a runaway guard.
+      def keep_iterating?(iteration)
+        return true if iteration < MAX_ITERATIONS
+
+        @stop_block_active && iteration < GOAL_MAX_ITERATIONS
+      end
+
       def assign_dependencies(opts)
         assign_required_deps(opts)
         assign_optional_deps(opts)
@@ -148,6 +167,7 @@ module RubynCode
         @max_tokens_override   = nil
         @output_recovery_count = 0
         @task_budget_remaining = nil
+        @stop_block_active     = false # true while a Stop hook keeps us going
       end
 
       def run_iteration(iteration)
@@ -199,6 +219,13 @@ module RubynCode
 
         @conversation.add_assistant_message(response_content(response))
 
+        # Stop hook: a hook may block stopping (e.g. an active /goal). When
+        # blocked, the reason is injected as user feedback and the loop keeps
+        # iterating instead of returning the final text. While blocked, the
+        # loop is allowed to run past MAX_ITERATIONS (see #keep_iterating?).
+        @stop_block_active = stop_blocked?(text)
+        return nil if @stop_block_active
+
         # Decision-based compaction (topic switch, milestone)
         @decision_compactor&.check!(@conversation)
 
@@ -208,6 +235,19 @@ module RubynCode
         text
       end
 
+      # Fires the :stop hook. If a hook blocks (returns { block: true }), the
+      # reason is appended as a user message so the next iteration acts on it.
+      #
+      # @return [Boolean] true if stopping was blocked (keep iterating)
+      def stop_blocked?(text)
+        decision = @hook_runner.fire(:stop, conversation: @conversation, response_text: text)
+        return false unless decision.is_a?(Hash) && decision[:block]
+
+        RubynCode::Debug.agent('Stop blocked by hook — continuing')
+        @conversation.add_user_message(decision[:reason])
+        true
+      end
+
       # Empty LLM response (0 content blocks). Common after dispatching
       # background_run — the LLM has nothing to say until results arrive.
       # Wait briefly for jobs, then either continue or accept the empty response.
@@ -243,15 +283,15 @@ module RubynCode
       # after text responses — mirrors Claude Code's "pause for compaction"
       # behavior that keeps context manageable in long sessions.
       def compact_if_needed
-        return unless @context_manager.needs_compaction?(@conversation.messages)
+        return unless @context_manager.needs_compaction?(@conversation)
 
-        est = @context_manager.estimated_tokens(@conversation.messages)
+        est = @context_manager.estimated_tokens(@conversation)
         RubynCode::Debug.token(
           "Context over threshold (#{est}) — running compaction"
         )
         @context_manager.check_compaction!(@conversation)
 
-        after = @context_manager.estimated_tokens(@conversation.messages)
+        after = @context_manager.estimated_tokens(@conversation)
         RubynCode::Debug.token("Compacted: #{est} → #{after} tokens")
       rescue StandardError => e
         RubynCode::Debug.warn("Compaction failed: #{e.message}")
@@ -266,8 +306,8 @@ module RubynCode
         @max_tokens_override = Config::Defaults::ESCALATED_MAX_OUTPUT_TOKENS
       end
 
-      def max_iterations_warning
-        warning = "Reached maximum iteration limit (#{MAX_ITERATIONS}). " \
+      def max_iterations_warning(limit = MAX_ITERATIONS)
+        warning = "Reached maximum iteration limit (#{limit}). " \
                   'The conversation may be incomplete. Please review the ' \
                   'current state and continue if needed.'
         @conversation.add_assistant_message([{ type: 'text', text: warning }])

data/lib/rubyn_code/agent/system_prompt_builder.rb

@@ -10,7 +10,7 @@ module RubynCode
     module SystemPromptBuilder # rubocop:disable Metrics/ModuleLength -- heavily extracted, residual 3 lines over
       include Prompts
 
-      INSTRUCTION_FILES = %w[RUBYN.md CLAUDE.md AGENT.md].freeze
+      INSTRUCTION_FILES = %w[RUBYN.md CLAUDE.md AGENTS.md AGENT.md].freeze
 
       private
 
@@ -19,16 +19,49 @@ module RubynCode
         parts << PLAN_MODE_PROMPT if @plan_mode
         parts << "Working directory: #{@project_root}" if @project_root
         append_response_mode(parts)
+        static = static_prompt_sections
+        parts << static unless static.empty?
+        parts.join("\n")
+      end
+
+      # The static sections hit SQLite (memories, instincts) and walk the
+      # filesystem (instruction files, profile), so they're assembled once
+      # per user turn instead of on every iteration of the tool loop. Only
+      # the plan-mode flag and response-mode line vary mid-turn, and those
+      # stay in build_system_prompt.
+      def static_prompt_sections
+        @static_prompt_sections ||= build_static_prompt_sections
+      end
+
+      def build_static_prompt_sections
+        parts = []
         append_project_profile(parts)
         append_codebase_index(parts)
         append_memories(parts)
         append_project_instructions(parts)
         append_instincts(parts)
         append_skills(parts)
+        append_chisel_ruleset(parts)
         append_deferred_tools(parts)
         parts.join("\n")
       end
 
+      # Chisel's "write the minimum that works" ruleset, injected only when the
+      # user has turned it on (chisel_mode != off). Guarded so a config or
+      # resolution error never breaks prompt assembly.
+      def append_chisel_ruleset(parts)
+        section = Chisel.prompt_section
+        parts << "\n#{section}" unless section.empty?
+      rescue StandardError
+        nil
+      end
+
+      # Called at the start of each user turn so memory, instruction, and
+      # tool changes made between turns show up in the next prompt.
+      def reset_system_prompt_cache!
+        @static_prompt_sections = nil
+      end
+
       def append_response_mode(parts)
         text = last_user_text
         return if text.empty?
@@ -182,7 +215,9 @@ module RubynCode
 
         db = DB::Connection.instance
         search = Memory::Search.new(db, project_path: @project_root)
-        recent = search.recent(limit: 20)
+        # touch: false — assembling the prompt is not a memory "access";
+        # touching here would issue a SQLite write and inflate access counts.
+        recent = search.recent(limit: 20, touch: false)
         return '' if recent.empty?
 
         recent.map { |m| format_memory(m) }.join("\n")

data/lib/rubyn_code/agent/tool_processor.rb

@@ -116,7 +116,9 @@ module RubynCode
 
       def execute_tool(tool_name, tool_input)
         discover_tool(tool_name)
-        @hook_runner.fire(:pre_tool_use, tool_name: tool_name, tool_input: tool_input)
+        pre_decision = @hook_runner.fire(:pre_tool_use, tool_name: tool_name, tool_input: tool_input)
+        raise RubynCode::UserDeniedError, pre_decision[:reason] if pre_decision.is_a?(Hash) && pre_decision[:deny]
+
         result = dispatch_tool(tool_name, tool_input)
         @hook_runner.fire(:post_tool_use, tool_name: tool_name, tool_input: tool_input, result: result)
         signal_decision_compactor(tool_name, tool_input, result)

data/lib/rubyn_code/auth/oauth.rb

@@ -3,7 +3,6 @@
 require 'securerandom'
 require 'digest'
 require 'base64'
-require 'faraday'
 require 'json'
 
 module RubynCode
@@ -163,6 +162,7 @@ module RubynCode
       end
 
       def http_client
+        require 'faraday'
         @http_client ||= Faraday.new do |f|
           f.options.timeout = 30
           f.options.open_timeout = 10