rubyn-code 0.1.0 → 0.2.0

data/lib/rubyn_code/memory/session_persistence.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require "json"
+require 'securerandom'
+require 'json'
 
 module RubynCode
   module Memory
@@ -24,11 +24,11 @@ module RubynCode
       # @param metadata [Hash] arbitrary metadata
       # @return [void]
       def save_session(session_id:, project_path:, messages:, title: nil, model: nil, metadata: {})
-        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
         messages_json = JSON.generate(messages)
         meta_json = JSON.generate(metadata)
 
-        @db.execute(<<~SQL, [session_id, project_path, title, model, messages_json, "active", meta_json, now, now, messages_json, title, model, meta_json, now])
+        @db.execute(<<~SQL, [session_id, project_path, title, model, messages_json, 'active', meta_json, now, now, messages_json, title, model, meta_json, now])
           INSERT INTO sessions (id, project_path, title, model, messages, status, metadata, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
           ON CONFLICT(id) DO UPDATE SET
@@ -46,21 +46,21 @@ module RubynCode
       # @return [Hash, nil] { messages:, metadata:, title:, model:, status:, project_path: } or nil
       def load_session(session_id)
         rows = @db.query(
-          "SELECT * FROM sessions WHERE id = ?",
+          'SELECT * FROM sessions WHERE id = ?',
           [session_id]
         ).to_a
         return nil if rows.empty?
 
         row = rows.first
         {
-          messages: parse_json_array(row["messages"]),
-          metadata: parse_json_hash(row["metadata"]),
-          title: row["title"],
-          model: row["model"],
-          status: row["status"],
-          project_path: row["project_path"],
-          created_at: row["created_at"],
-          updated_at: row["updated_at"]
+          messages: parse_json_array(row['messages']),
+          metadata: parse_json_hash(row['metadata']),
+          title: row['title'],
+          model: row['model'],
+          status: row['status'],
+          project_path: row['project_path'],
+          created_at: row['created_at'],
+          updated_at: row['updated_at']
         }
       end
 
@@ -75,16 +75,16 @@ module RubynCode
         params = []
 
         if project_path
-          conditions << "project_path = ?"
+          conditions << 'project_path = ?'
           params << project_path
         end
 
         if status
-          conditions << "status = ?"
+          conditions << 'status = ?'
           params << status
         end
 
-        where_clause = conditions.empty? ? "" : "WHERE #{conditions.join(' AND ')}"
+        where_clause = conditions.empty? ? '' : "WHERE #{conditions.join(' AND ')}"
         params << limit
 
         rows = @db.query(<<~SQL, params).to_a
@@ -97,14 +97,14 @@ module RubynCode
 
         rows.map do |row|
           {
-            id: row["id"],
-            project_path: row["project_path"],
-            title: row["title"],
-            model: row["model"],
-            status: row["status"],
-            metadata: parse_json_hash(row["metadata"]),
-            created_at: row["created_at"],
-            updated_at: row["updated_at"]
+            id: row['id'],
+            project_path: row['project_path'],
+            title: row['title'],
+            model: row['model'],
+            status: row['status'],
+            metadata: parse_json_hash(row['metadata']),
+            created_at: row['created_at'],
+            updated_at: row['updated_at']
           }
         end
       end
@@ -123,27 +123,27 @@ module RubynCode
         attrs.each do |key, value|
           case key
           when :title
-            sets << "title = ?"
+            sets << 'title = ?'
             params << value
           when :status
-            sets << "status = ?"
+            sets << 'status = ?'
             params << value
           when :model
-            sets << "model = ?"
+            sets << 'model = ?'
             params << value
           when :metadata
-            sets << "metadata = ?"
+            sets << 'metadata = ?'
             params << JSON.generate(value)
           when :messages
-            sets << "messages = ?"
+            sets << 'messages = ?'
             params << JSON.generate(value)
           end
         end
 
         return if sets.empty?
 
-        sets << "updated_at = ?"
-        params << Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        sets << 'updated_at = ?'
+        params << Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
         params << session_id
 
         @db.execute("UPDATE sessions SET #{sets.join(', ')} WHERE id = ?", params)
@@ -154,16 +154,31 @@ module RubynCode
       # @param session_id [String]
       # @return [void]
       def delete_session(session_id)
-        @db.execute("DELETE FROM sessions WHERE id = ?", [session_id])
+        @db.execute('DELETE FROM sessions WHERE id = ?', [session_id])
       end
 
       private
 
       def ensure_table
-        # Add messages column if it doesn't exist (migration schema didn't include it)
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            project_path TEXT NOT NULL,
+            title TEXT,
+            model TEXT,
+            messages TEXT NOT NULL DEFAULT '[]',
+            status TEXT NOT NULL DEFAULT 'active',
+            metadata TEXT DEFAULT '{}',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          )
+        SQL
+
+        # Add messages column for databases created by the original migration
+        # (001_create_sessions.sql) which omitted it
         @db.execute("ALTER TABLE sessions ADD COLUMN messages TEXT NOT NULL DEFAULT '[]'")
       rescue StandardError
-        # Column already exists or table doesn't exist yet — either way, safe to continue
+        # Column already exists — safe to continue
       end
 
       # @param raw [String, Array, nil]

data/lib/rubyn_code/memory/store.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require "json"
-require_relative "models"
+require 'securerandom'
+require 'json'
+require_relative 'models'
 
 module RubynCode
   module Memory
@@ -26,12 +26,12 @@ module RubynCode
       # @param metadata [Hash] arbitrary metadata
       # @param expires_at [String, nil] ISO 8601 expiration timestamp
       # @return [MemoryRecord] the created record
-      def write(content:, tier: "medium", category: nil, metadata: {}, expires_at: nil)
+      def write(content:, tier: 'medium', category: nil, metadata: {}, expires_at: nil)
         validate_tier!(tier)
         validate_category!(category) if category
 
         id = SecureRandom.uuid
-        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
         meta_json = JSON.generate(metadata)
 
         @db.execute(<<~SQL, [id, @project_path, tier, category, content, 1.0, 0, now, expires_at, meta_json, now])
@@ -63,24 +63,24 @@ module RubynCode
         attrs.each do |key, value|
           case key
           when :content
-            sets << "content = ?"
+            sets << 'content = ?'
             params << value
           when :tier
             validate_tier!(value)
-            sets << "tier = ?"
+            sets << 'tier = ?'
             params << value
           when :category
             validate_category!(value) if value
-            sets << "category = ?"
+            sets << 'category = ?'
             params << value
           when :metadata
-            sets << "metadata = ?"
+            sets << 'metadata = ?'
             params << JSON.generate(value)
           when :expires_at
-            sets << "expires_at = ?"
+            sets << 'expires_at = ?'
             params << value
           when :relevance_score
-            sets << "relevance_score = ?"
+            sets << 'relevance_score = ?'
             params << value.to_f
           end
         end
@@ -101,23 +101,23 @@ module RubynCode
       # @param id [String]
       # @return [void]
       def delete(id)
-        @db.execute("DELETE FROM memories WHERE id = ? AND project_path = ?", [id, @project_path])
+        @db.execute('DELETE FROM memories WHERE id = ? AND project_path = ?', [id, @project_path])
       end
 
       # Removes all memories whose expires_at is in the past.
       #
       # @return [Integer] number of expired memories deleted
       def expire_old!
-        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
 
         expired_ids = @db.query(
-          "SELECT id FROM memories WHERE project_path = ? AND expires_at IS NOT NULL AND expires_at < ?",
+          'SELECT id FROM memories WHERE project_path = ? AND expires_at IS NOT NULL AND expires_at < ?',
           [@project_path, now]
-        ).to_a.map { |row| row["id"] }
+        ).to_a.map { |row| row['id'] }
 
         return 0 if expired_ids.empty?
 
-        placeholders = (["?"] * expired_ids.size).join(", ")
+        placeholders = (['?'] * expired_ids.size).join(', ')
         @db.execute(
           "DELETE FROM memories WHERE id IN (#{placeholders}) AND project_path = ?",
           expired_ids + [@project_path]
@@ -132,7 +132,7 @@ module RubynCode
       # @param decay_rate [Float] amount to subtract from relevance_score (default 0.01)
       # @return [void]
       def decay!(decay_rate: 0.01)
-        cutoff = (Time.now.utc - 86_400).strftime("%Y-%m-%d %H:%M:%S") # 24 hours ago
+        cutoff = (Time.now.utc - 86_400).strftime('%Y-%m-%d %H:%M:%S') # 24 hours ago
 
         @db.execute(<<~SQL, [decay_rate, @project_path, cutoff])
           UPDATE memories

data/lib/rubyn_code/observability/RUBYN.md

@@ -0,0 +1,19 @@
+# Layer 13: Observability
+
+Token counting, cost tracking, and budget enforcement.
+
+## Classes
+
+- **`TokenCounter`** — Estimates token counts for messages and tool results.
+  Used by `Context::Manager` for compaction decisions and by `CostCalculator` for pricing.
+
+- **`CostCalculator`** — Computes cost per API call based on model, input/output tokens.
+  Persists records to the `cost_records` table.
+
+- **`BudgetEnforcer`** — Enforces per-session and global budget caps. Raises
+  `BudgetExceededError` when the limit is hit. Checked in `Agent::Loop` before each API call.
+
+- **`UsageReporter`** — Generates usage summaries: tokens used, cost breakdown, session stats.
+  Powers the `/cost` and `/budget` slash commands.
+
+- **`Models`** — Data objects for cost records.

data/lib/rubyn_code/observability/budget_enforcer.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require "time"
-require_relative "models"
-require_relative "cost_calculator"
+require 'securerandom'
+require 'time'
+require_relative 'models'
+require_relative 'cost_calculator'
 
 module RubynCode
   module Observability
@@ -13,7 +13,7 @@ module RubynCode
       DEFAULT_SESSION_LIMIT = 5.00
       DEFAULT_DAILY_LIMIT   = 10.00
 
-      TABLE_NAME = "cost_records"
+      TABLE_NAME = 'cost_records'
 
       # @param db [DB::Connection] database connection
       # @param session_id [String] current session identifier
@@ -37,7 +37,8 @@ module RubynCode
       # @param cache_write_tokens [Integer] cache-write token count
       # @param request_type [String] the type of request (e.g., "chat", "compact")
       # @return [CostRecord] the persisted cost record
-      def record!(model:, input_tokens:, output_tokens:, cache_read_tokens: 0, cache_write_tokens: 0, request_type: "chat")
+      def record!(model:, input_tokens:, output_tokens:, cache_read_tokens: 0, cache_write_tokens: 0,
+                  request_type: 'chat')
         cost = CostCalculator.calculate(
           model: model,
           input_tokens: input_tokens,
@@ -51,8 +52,8 @@ module RubynCode
 
         @db.execute(
           "INSERT INTO #{TABLE_NAME} (id, session_id, model, input_tokens, output_tokens, " \
-          "cache_read_tokens, cache_write_tokens, cost_usd, request_type, created_at) " \
-          "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+          'cache_read_tokens, cache_write_tokens, cost_usd, request_type, created_at) ' \
+          'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
           [id, @session_id, model, input_tokens, output_tokens,
            cache_read_tokens, cache_write_tokens, cost, request_type, now]
         )
@@ -79,14 +80,14 @@ module RubynCode
         sc = session_cost
         if sc >= @session_limit
           raise BudgetExceededError,
-                "Session budget exceeded: $#{"%.4f" % sc} >= $#{"%.2f" % @session_limit} limit"
+                "Session budget exceeded: $#{'%.4f' % sc} >= $#{format('%.2f', @session_limit)} limit"
         end
 
         dc = daily_cost
-        if dc >= @daily_limit
-          raise BudgetExceededError,
-                "Daily budget exceeded: $#{"%.4f" % dc} >= $#{"%.2f" % @daily_limit} limit"
-        end
+        return unless dc >= @daily_limit
+
+        raise BudgetExceededError,
+              "Daily budget exceeded: $#{'%.4f' % dc} >= $#{format('%.2f', @daily_limit)} limit"
       end
 
       # Returns the total cost accumulated in the current session.
@@ -104,7 +105,7 @@ module RubynCode
       #
       # @return [Float] total daily cost in USD
       def daily_cost
-        today = Time.now.utc.strftime("%Y-%m-%d")
+        today = Time.now.utc.strftime('%Y-%m-%d')
         rows = @db.query(
           "SELECT COALESCE(SUM(cost_usd), 0.0) AS total FROM #{TABLE_NAME} WHERE created_at >= ?",
           ["#{today}T00:00:00Z"]
@@ -152,7 +153,7 @@ module RubynCode
         return 0.0 if rows.nil? || rows.empty?
 
         row = rows.first
-        (row["total"] || row[:total] || 0.0).to_f
+        (row['total'] || row[:total] || 0.0).to_f
       end
     end
   end

data/lib/rubyn_code/observability/cost_calculator.rb

@@ -9,9 +9,9 @@ module RubynCode
     module CostCalculator
       # Per-million-token rates: { model_prefix => [input_rate, output_rate] }
       PRICING = {
-        "claude-haiku-4-5"        => [1.00, 5.00],
-        "claude-sonnet-4-20250514" => [3.00, 15.00],
-        "claude-opus-4-20250514"   => [15.00, 75.00]
+        'claude-haiku-4-5' => [1.00, 5.00],
+        'claude-sonnet-4-20250514' => [3.00, 15.00],
+        'claude-opus-4-20250514' => [15.00, 75.00]
       }.freeze
 
       CACHE_READ_DISCOUNT  = 0.1

data/lib/rubyn_code/observability/token_counter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 module RubynCode
   module Observability

data/lib/rubyn_code/observability/usage_reporter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "time"
+require 'time'
 
 module RubynCode
   module Observability
@@ -27,21 +27,21 @@ module RubynCode
 
         return "No usage data for session #{session_id}." if rows.empty?
 
-        total_input   = rows.sum { |r| fetch_int(r, "input_tokens") }
-        total_output  = rows.sum { |r| fetch_int(r, "output_tokens") }
-        total_cost    = rows.sum { |r| fetch_float(r, "cost_usd") }
+        total_input   = rows.sum { |r| fetch_int(r, 'input_tokens') }
+        total_output  = rows.sum { |r| fetch_int(r, 'output_tokens') }
+        total_cost    = rows.sum { |r| fetch_float(r, 'cost_usd') }
         turns         = rows.size
         avg_cost      = turns.positive? ? total_cost / turns : 0.0
 
         lines = [
-          header("Session Summary"),
-          field("Session", session_id),
-          field("Turns", turns.to_s),
-          field("Input tokens", format_number(total_input)),
-          field("Output tokens", format_number(total_output)),
-          field("Total tokens", format_number(total_input + total_output)),
-          field("Total cost", format_usd(total_cost)),
-          field("Avg cost/turn", format_usd(avg_cost))
+          header('Session Summary'),
+          field('Session', session_id),
+          field('Turns', turns.to_s),
+          field('Input tokens', format_number(total_input)),
+          field('Output tokens', format_number(total_output)),
+          field('Total tokens', format_number(total_input + total_output)),
+          field('Total cost', format_usd(total_cost)),
+          field('Avg cost/turn', format_usd(avg_cost))
         ]
 
         lines.join("\n")
@@ -51,29 +51,29 @@ module RubynCode
       #
       # @return [String] multi-line formatted summary
       def daily_summary
-        today = Time.now.utc.strftime("%Y-%m-%d")
+        today = Time.now.utc.strftime('%Y-%m-%d')
         rows = @db.query(
-          "SELECT session_id, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, " \
+          'SELECT session_id, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, ' \
           "SUM(cost_usd) AS cost_usd, COUNT(*) AS turns FROM #{TABLE_NAME} " \
-          "WHERE created_at >= ? GROUP BY session_id",
+          'WHERE created_at >= ? GROUP BY session_id',
           ["#{today}T00:00:00Z"]
         ).to_a
 
-        return "No usage data for today." if rows.empty?
+        return 'No usage data for today.' if rows.empty?
 
-        total_input  = rows.sum { |r| fetch_int(r, "input_tokens") }
-        total_output = rows.sum { |r| fetch_int(r, "output_tokens") }
-        total_cost   = rows.sum { |r| fetch_float(r, "cost_usd") }
-        total_turns  = rows.sum { |r| fetch_int(r, "turns") }
+        total_input  = rows.sum { |r| fetch_int(r, 'input_tokens') }
+        total_output = rows.sum { |r| fetch_int(r, 'output_tokens') }
+        total_cost   = rows.sum { |r| fetch_float(r, 'cost_usd') }
+        total_turns  = rows.sum { |r| fetch_int(r, 'turns') }
         sessions     = rows.size
 
         lines = [
           header("Daily Summary (#{today})"),
-          field("Sessions", sessions.to_s),
-          field("Total turns", total_turns.to_s),
-          field("Input tokens", format_number(total_input)),
-          field("Output tokens", format_number(total_output)),
-          field("Total cost", format_usd(total_cost))
+          field('Sessions', sessions.to_s),
+          field('Total turns', total_turns.to_s),
+          field('Input tokens', format_number(total_input)),
+          field('Output tokens', format_number(total_output)),
+          field('Total cost', format_usd(total_cost))
         ]
 
         lines.join("\n")
@@ -85,22 +85,22 @@ module RubynCode
       # @return [String] multi-line formatted breakdown
       def model_breakdown(session_id)
         rows = @db.query(
-          "SELECT model, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, " \
+          'SELECT model, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, ' \
           "SUM(cost_usd) AS cost_usd, COUNT(*) AS calls FROM #{TABLE_NAME} " \
-          "WHERE session_id = ? GROUP BY model ORDER BY cost_usd DESC",
+          'WHERE session_id = ? GROUP BY model ORDER BY cost_usd DESC',
           [session_id]
         ).to_a
 
         return "No usage data for session #{session_id}." if rows.empty?
 
-        lines = [header("Cost by Model")]
+        lines = [header('Cost by Model')]
 
         rows.each do |row|
-          model   = row["model"] || row[:model]
-          cost    = fetch_float(row, "cost_usd")
-          calls   = fetch_int(row, "calls")
-          input_t = fetch_int(row, "input_tokens")
-          output_t = fetch_int(row, "output_tokens")
+          model   = row['model'] || row[:model]
+          cost    = fetch_float(row, 'cost_usd')
+          calls   = fetch_int(row, 'calls')
+          input_t = fetch_int(row, 'input_tokens')
+          output_t = fetch_int(row, 'output_tokens')
 
           lines << "  #{@formatter.pastel.bold(model)}"
           lines << "    Calls: #{calls}  |  Input: #{format_number(input_t)}  |  Output: #{format_number(output_t)}  |  Cost: #{format_usd(cost)}"
@@ -112,7 +112,7 @@ module RubynCode
       private
 
       def header(title)
-        bar = @formatter.pastel.dim("-" * 40)
+        bar = @formatter.pastel.dim('-' * 40)
         "#{bar}\n  #{@formatter.pastel.bold(title)}\n#{bar}"
       end
 
@@ -121,7 +121,7 @@ module RubynCode
       end
 
       def format_usd(amount)
-        "$%.4f" % amount
+        '$%.4f' % amount
       end
 
       def format_number(n)

data/lib/rubyn_code/output/RUBYN.md

@@ -0,0 +1,11 @@
+# Output Layer
+
+Formatting utilities for terminal display.
+
+## Classes
+
+- **`Formatter`** — General-purpose output formatting. Wraps text, formats tables,
+  renders markdown-flavored content for the terminal.
+
+- **`DiffRenderer`** — Renders unified diffs with color highlighting. Used by `edit_file`
+  and `review_pr` tools to show what changed.

data/lib/rubyn_code/output/diff_renderer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "pastel"
+require 'pastel'
 
 module RubynCode
   module Output
@@ -30,17 +30,17 @@ module RubynCode
       # @param new_text [String] the modified text
       # @param filename [String] the filename to display in the diff header
       # @return [String] the rendered, colorized diff output
-      def render(old_text, new_text, filename: "file")
+      def render(old_text, new_text, filename: 'file')
         old_lines = old_text.lines.map(&:chomp)
         new_lines = new_text.lines.map(&:chomp)
 
         hunks = compute_hunks(old_lines, new_lines)
-        return pastel.dim("No differences found.") if hunks.empty?
+        return pastel.dim('No differences found.') if hunks.empty?
 
         parts = []
         parts << render_header(filename)
         hunks.each { |hunk| parts << render_hunk(hunk) }
-        parts << ""
+        parts << ''
 
         result = parts.join("\n")
         $stdout.puts(result)
@@ -128,7 +128,7 @@ module RubynCode
       # Groups raw diff operations into hunks with surrounding context lines.
       def group_into_hunks(raw_diff, old_lines, new_lines)
         # Identify change indices (non-equal operations)
-        change_indices = raw_diff.each_index.select { |idx| raw_diff[idx][0] != :equal }
+        change_indices = raw_diff.each_index.reject { |idx| raw_diff[idx][0] == :equal }
         return [] if change_indices.empty?
 
         # Group changes that are within context_lines of each other
@@ -136,7 +136,7 @@ module RubynCode
         current_group = [change_indices.first]
 
         change_indices.drop(1).each do |idx|
-          if idx - current_group.last <= @context_lines * 2 + 1
+          if idx - current_group.last <= (@context_lines * 2) + 1
             current_group << idx
           else
             groups << current_group

data/lib/rubyn_code/output/formatter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "pastel"
-require "rouge"
+require 'pastel'
+require 'rouge'
 
 module RubynCode
   module Output
@@ -39,7 +39,7 @@ module RubynCode
         output pastel.bold(message)
       end
 
-      def code_block(code, language: "ruby")
+      def code_block(code, language: 'ruby')
         lexer = find_lexer(language)
         formatter = Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
 
@@ -107,7 +107,7 @@ module RubynCode
       def truncate(text, max_length)
         return text if text.length <= max_length
 
-        "#{text[0, max_length]}#{pastel.dim("... (truncated)")}"
+        "#{text[0, max_length]}#{pastel.dim('... (truncated)')}"
       end
 
       def find_lexer(language)

data/lib/rubyn_code/permissions/RUBYN.md

@@ -0,0 +1,17 @@
+# Layer 3: Permissions
+
+Tiered permission system controlling which tools the agent can use.
+
+## Classes
+
+- **`Tier`** — Defines permission tiers (e.g. `:readonly`, `:edit`, `:admin`).
+  Each tier grants access to a set of tools. Higher tiers include all lower-tier tools.
+
+- **`Policy`** — Evaluates whether a tool call is allowed given the current tier.
+  Consulted by `Tools::Executor` before every tool invocation.
+
+- **`DenyList`** — Explicit tool deny list. Overrides tier permissions.
+  Configurable per-project via `.rubyn-code.yml`.
+
+- **`Prompter`** — Asks the user for permission when a tool requires escalation.
+  Renders the tool name and arguments, waits for yes/no confirmation.