antigravity-sdk 0.5.0 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: effdabdb0588788c4b168749a2578e2e1f07aa877a54bfd80fe1969d42f497d2
-  data.tar.gz: 3debe5e4295f8c2e2bcd4c37ec7ea52ea11a77d034370320d4064b52aa08cc29
+  metadata.gz: fff0721cd596c0cafa8734522f4a88f26813dfe9afc71941389cb79bf109cfa4
+  data.tar.gz: 0f975b13b784c682519ee0f60e9f0cb574535e819b13e9224bdf3abb74fbc91f
 SHA512:
-  metadata.gz: 4123cbc798ddbfaa82ea0f854e89adb122491d9a99b52f501c15350401e660109be3ca778b6142720f0259256992dbbb73d4d2371d8bdefcda266bd4d98591cf
-  data.tar.gz: d80349e13c564c74bb81c5c8ba14887f39af36507d03b3c6a5883ed3a885359570210d10b9fc1f8cc3e8a0c193408de176f3316129a58e1d6303352c5527ed01
+  metadata.gz: fe0700f980ab6d196252151616ecb79181efa484ce824d5a65f63e75826536a9800f8a2f49450296a92aace284f1270e243115d1f90055098a95fce4a986c446
+  data.tar.gz: 0174bc0e5167c6d406d32f2f3e244e0f4860c2cb6e65237bbe9d591835f05ba8fcf1ab8d501f80e56fb1130c73f93b138f2d3b18c457d2f16e983f4d668bf79f

data/VERSION

@@ -0,0 +1 @@
+0.5.5

data/lib/antigravity/agent.rb

@@ -5,14 +5,14 @@ module Antigravity
 
     attr_accessor :model, :system_instruction, :api_key
     attr_reader :tools, :skills, :hooks, :sidecars, :client, :logger_guard,
-                :workspace, :connection, :conversation
+                :workspace, :connection, :conversation, :policy, :policies, :born_at
 
     def initialize(model: nil, system_instruction: nil, tools: [],
                    skills: [], policies: [], policy: nil, workspace: nil, auto_logger: true, log_file: nil, &block)
       @model = model || Antigravity.config.default_model
       @api_key = Antigravity.config.api_key
       @system_instruction = system_instruction
-      @workspace = workspace ? File.expand_path(workspace) : nil
+      @workspace = resolve_workspace(workspace)
       @tools = tools.dup
       @skills = []
       @policies = []
@@ -23,6 +23,7 @@ module Antigravity
       @connection = nil
       @conversation = nil
       @connected = false
+      @born_at = Time.now
 
       # Register pre-provided tools into the tool runner
       @tool_runner = ToolRunner.new
@@ -68,6 +69,10 @@ module Antigravity
       end
     end
 
+    def workspace=(path)
+      @workspace = resolve_workspace(path)
+    end
+
     # --- Connection Lifecycle ---
 
     def connect!
@@ -89,9 +94,19 @@ module Antigravity
       )
 
       harness_config = build_harness_config
+
+      # Emit indexing hooks — workspace indexing happens during session init
+      index_t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) if @workspace
+      hooks.emit(:indexing_start, { workspace: @workspace }) if @workspace
+
       @conversation.initialize_session!(harness_config: harness_config)
       @connected = true
 
+      if @workspace
+        index_elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - index_t0
+        hooks.emit(:indexing_done, { workspace: @workspace, elapsed: index_elapsed.round(2) })
+      end
+
       # Emit session_start hook
       hooks.emit(:session_start, {
         model: @model,
@@ -160,6 +175,21 @@ module Antigravity
       @conversation.session_summary(model: @model)
     end
 
+    # Seconds since agent was created
+    def uptime
+      Time.now - @born_at
+    end
+
+    # Human-readable uptime: "1m 23.4s", "7.3s"
+    def uptime_human
+      secs = uptime
+      if secs >= 60
+        "#{(secs / 60).to_i}m #{(secs % 60).round(1)}s"
+      else
+        "#{secs.round(1)}s"
+      end
+    end
+
     # --- Tool Registration ---
 
     def register_tool(tool_or_name = nil, description: "", &block)
@@ -266,11 +296,11 @@ module Antigravity
     end
 
     def lifecycle_logger_enabled?
-      # Explicit opt-in
-      return true if ENV['ANTIGRAVITY_LIFECYCLE'] == '1'
+      # Explicit opt-in (strip handles trailing spaces in .env files)
+      return true if ENV['ANTIGRAVITY_LIFECYCLE']&.strip == '1'
       # Rails/Rack test or development
-      return true if %w[test development].include?(ENV['RAILS_ENV']&.downcase)
-      return true if %w[test development].include?(ENV['RACK_ENV']&.downcase)
+      return true if %w[test development].include?(ENV['RAILS_ENV']&.strip&.downcase)
+      return true if %w[test development].include?(ENV['RACK_ENV']&.strip&.downcase)
       # Explicit opt-out
       false
     end
@@ -361,8 +391,21 @@ module Antigravity
       skill
     end
 
-    def lifecycle_logger_enabled?
-      ENV['ANTIGRAVITY_LIFECYCLE'] == '1'
+    def resolve_workspace(val)
+      return nil if val.nil? || val == false
+
+      raw_path = case val
+                 when :here, :current, true, '.'
+                   '.'
+                 else
+                   val.to_s
+                 end
+
+      expanded = File.expand_path(raw_path)
+      expanded += '/' unless expanded.end_with?('/')
+
+      $stderr.puts "📁 Setting workspace to \e[34m#{expanded}\e[0m" rescue nil
+      expanded
     end
   end
 end

data/lib/antigravity/connection/binary_fetcher.rb

@@ -87,7 +87,7 @@ module Antigravity
 
           unless wheel
             # Try all versions for the platform
-            versions = data['releases']&.keys&.sort_by { |v| Gem::Version.new(v) rescue v }&.reverse
+            versions = data['releases']&.keys&.sort_by { |v| Gem::Version.correct?(v) ? Gem::Version.new(v) : Gem::Version.new('0') }&.reverse
             versions&.each do |ver|
               files = data.dig('releases', ver) || []
               wheel = files.find { |u| u['filename']&.include?(platform) && u['filename']&.end_with?('.whl') }
@@ -134,7 +134,11 @@ module Antigravity
           # Wheels are just ZIP files. Extract the binary.
           # Look for: google/antigravity/bin/localharness (or language_server)
           extract_dir = Dir.mktmpdir('agy-extract-')
-          system('unzip', '-q', '-o', wheel_path, '-d', extract_dir)
+          success = system('unzip', '-q', '-o', wheel_path, '-d', extract_dir)
+          unless success
+            FileUtils.rm_rf(extract_dir)
+            raise HarnessNotFoundError, "Failed to extract wheel using unzip command"
+          end
 
           # Search for the binary inside (prefer localharness over language_server)
           candidates = Dir.glob("#{extract_dir}/**/localharness") +

data/lib/antigravity/connection/local_connection.rb

@@ -121,8 +121,7 @@ module Antigravity
       end
 
       def perform_handshake!
-        storage_dir = File.join(Dir.tmpdir, "antigravity-ruby-#{$$}")
-        FileUtils.mkdir_p(storage_dir)
+        storage_dir = Dir.mktmpdir('antigravity-ruby-')
 
         # Send InputConfig via stdin
         input_config = Protocol.encode_input_config(

data/lib/antigravity/conversation.rb

@@ -131,10 +131,9 @@ module Antigravity
 
           if step[:textDelta] && !step[:textDelta].empty? && is_model_step && is_target_user && !is_error_step
             text_parts << step[:textDelta]
-            chunk = Message.new(
+            chunk = Chunk.new(
               content: step[:textDelta],
-              role: :assistant,
-              delta: true
+              role: :assistant
             )
             block&.call(chunk)
           end
@@ -170,37 +169,44 @@ module Antigravity
           handle_tool_call(tool_call)
         end
 
-        # Usage update
+        # Usage update — do NOT set seen_any_step here!
+        # usageUpdate can leak from the previous turn and trick the GHI #18
+        # stale-FULLY_IDLE guard into accepting a stale FULLY_IDLE as real.
         if (usage = msg[:usageUpdate])
           update_usage(usage)
-          seen_any_step = true
         end
 
         # Trajectory state: STATE_FULLY_IDLE / STATE_CANCELLED = turn complete (authoritative signal from harness)
-        # GHI #18 FIX: Only honor FULLY_IDLE if we've seen at least one stepUpdate/toolCall/usageUpdate
-        # from this turn, OR if enough time has elapsed (1s) that this can't be a stale leftover.
-        # A stale FULLY_IDLE from a previous turn sitting in the WebSocket buffer was causing
-        # collect_response to return immediately with zero steps/text.
+        # GHI #18 + #24 FIX: Only honor FULLY_IDLE if we've seen at least one stepUpdate or toolCall
+        # (NOT usageUpdate — it leaks across turns) from this turn, OR if enough time has elapsed
+        # (2s) that this can't be a stale leftover. A stale FULLY_IDLE from a previous turn sitting
+        # in the WebSocket buffer was causing collect_response to return immediately with 0B text.
         if (traj = msg[:trajectoryStateUpdate])
-          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - turn_started_at
           if traj[:state].to_s =~ /FULLY_IDLE|CANCELLED/
-            if seen_any_step || elapsed > 1.0
+            if seen_any_step
               finished = true
               finished_at = Time.now
             else
               # Stale FULLY_IDLE — skip it (likely leftover from previous turn or init)
-              @hooks&.emit(:ws_message, { _debug: 'skipped_stale_fully_idle', elapsed: elapsed.round(3) })
+              @hooks&.emit(:ws_message, { _debug: 'skipped_stale_fully_idle', seen_any_step: seen_any_step })
             end
           end
         end
 
         # Stop conditions (in priority order):
-        # 1. Session end — always stop
-        # 2. Model response DONE or trajectory FULLY_IDLE / CANCELLED — turn complete
-        if msg.key?(:sessionEndResponse) || finished
+        # 1. Session end — always hard-stop immediately
+        # 2. Finished (DONE or FULLY_IDLE) WITH text — short drain for trailing usage
+        # 3. Finished WITHOUT text but with steps — model was working (thinking),
+        #    text is likely still in-flight. Drain longer (3s) to catch it. (GHI #24)
+        # 4. Not finished but text started — idle timeout for more text
+        if msg.key?(:sessionEndResponse)
           :stop
+        elsif finished && !text_parts.empty?
+          [:idle_timeout, 0.5]
+        elsif finished && text_parts.empty?
+          # FULLY_IDLE arrived but no text yet — wait longer for trailing text
+          [:idle_timeout, 3.0]
         elsif !text_parts.empty?
-          # If assistant has sent text response, allow 3s idle timeout for trailing metadata
           [:idle_timeout, 3.0]
         end
       end
@@ -241,10 +247,40 @@ module Antigravity
       # Symbolize keys for Ruby kwargs
       kwargs = args.transform_keys(&:to_sym)
 
-      begin
-        result = @tool_runner.execute(tool_name, **kwargs)
-      rescue ToolNotFoundError => e
-        result = { error: e.message }
+      # Emit tool_call hook BEFORE execution
+      @hooks&.emit(:tool_call, { tool_name: tool_name, params: args, tool_id: tool_id })
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      policy_check = @hooks ? @hooks.run_pre_tool(tool_name, args) : { allowed: true }
+
+      if !policy_check[:allowed]
+        reason = policy_check[:reason]
+        # Same format as client.rb sidecar emission
+        @hooks&.emit(:tool_blocked, { tool: tool_name, reason: reason })
+        result = "❌ TOOL BLOCKED: #{reason}"
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+        
+        # We run the post_tool hook here as well to satisfy AgentLogger's pairing
+        result = @hooks ? @hooks.run_post_tool(tool_name, args, result) : result
+        @hooks&.emit(:tool_result, { tool_name: tool_name, result: result.to_s, duration: duration, tool_id: tool_id })
+      else
+        begin
+          raw_result = @tool_runner.execute(tool_name, **kwargs)
+          
+          # Run post_tool filters/maskers
+          result = @hooks ? @hooks.run_post_tool(tool_name, args, raw_result) : raw_result
+          
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+
+          # Emit tool_result hook AFTER execution
+          @hooks&.emit(:tool_result, { tool_name: tool_name, result: result.to_s, duration: duration, tool_id: tool_id })
+        rescue ToolNotFoundError => e
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+          result = { error: e.message }
+
+          # Emit tool_error hook on failure
+          @hooks&.emit(:tool_error, { tool_name: tool_name, error: e.message, duration: duration, tool_id: tool_id })
+        end
       end
 
       # Send tool response back (protobuf InputEvent.tool_response format)

data/lib/antigravity/diagnostics.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# Diagnostics module for Antigravity SDK.
+# Probes environment, API key, harness binary, gems, and Gemini API models.
+#
+# Usage:
+#   Antigravity::Diagnostics.run!          # Full colorful output
+#   Antigravity::Diagnostics.summary       # Returns hash of all data
+#   Antigravity::Diagnostics.check_api_key # Just the key check
+#
+module Antigravity
+  module Diagnostics
+    C = Antigravity::Colors
+
+    # Main entry point — prints full colorful diagnostic report
+    def self.run!(verbose: false)
+      data = summary
+
+      puts ''
+      puts C.bold("💎 Antigravity SDK #{C.cyan("v#{data[:sdk_version]}")} — Diagnostics")
+      puts C.dim('=' * 56)
+
+      # Ruby
+      puts section('💻 Runtime')
+      puts field('Ruby', "#{data[:ruby_version]} (#{data[:ruby_platform]})")
+      puts field('Bundler', data[:bundler_version])
+      puts field('rv', data[:rv_version] || C.dim('not detected'))
+
+      # API Key
+      puts section('🔑 Authentication')
+      if data[:api_key_present]
+        masked = data[:api_key_prefix] + '****' + data[:api_key_suffix]
+        source = data[:api_key_source]
+        puts field('API Key', "#{C.green(masked)} (#{C.dim(source)})")
+      else
+        puts field('API Key', C.red('⚠️  NOT SET — export GEMINI_API_KEY'))
+      end
+
+      # Model
+      puts field('Model', data[:default_model])
+      if data[:model_source] == 'default'
+        puts C.dim("           └─ using SDK default (set GEMINI_MODEL or ANTIGRAVITY_MODEL to override)")
+      end
+
+      # Harness
+      puts section('📦 Harness')
+      if data[:harness_exists]
+        size_mb = (data[:harness_size] / 1_048_576.0).round(1)
+        mtime = data[:harness_mtime]&.strftime('%Y-%m-%d %H:%M') || '?'
+        puts field('Path', data[:harness_path])
+        puts field('Size', "#{size_mb}MB")
+        puts field('Modified', mtime)
+        puts field('Arch', data[:harness_arch] || C.dim('unknown'))
+      else
+        puts field('Path', C.red("⚠️  NOT FOUND at #{data[:harness_path]}"))
+        puts C.dim("           └─ run: just harness-fetch")
+      end
+
+      # Gems
+      puts section('📚 Dependencies')
+      data[:gems].each do |name, ver|
+        status = ver ? C.green(ver) : C.red('missing')
+        puts field(name, status)
+      end
+
+      # Timeouts
+      puts section('⏱️  Timeouts')
+      puts field('LLM', "#{data[:timeout_llm]}s")
+      puts field('WebSocket', "#{data[:timeout_ws]}s")
+      puts field('Handshake', "#{data[:timeout_handshake]}s")
+
+      # Gemini API models probe (optional, needs network)
+      if data[:api_key_present] && verbose
+        puts section('🤖 Gemini API Models')
+        models = probe_models(data[:api_key_raw])
+        if models
+          puts field('Available', "#{C.green(models[:count].to_s)} models")
+          flash = models[:names].select { |n| n.include?('flash') }.first(3)
+          pro = models[:names].select { |n| n.include?('pro') }.first(3)
+          puts field('Flash', flash.join(', ')) unless flash.empty?
+          puts field('Pro', pro.join(', ')) unless pro.empty?
+        else
+          puts field('Status', C.yellow('⚠️  Could not reach Gemini API'))
+        end
+      elsif data[:api_key_present]
+        puts C.dim("\n   Tip: run with --verbose to probe Gemini API models")
+      end
+
+      # Overall status
+      puts ''
+      issues = health_check(data)
+      if issues.empty?
+        puts C.green('✅ All checks passed — ready to go!')
+      else
+        puts C.yellow("⚠️  #{issues.length} issue(s) found:")
+        issues.each { |i| puts C.yellow("   • #{i}") }
+      end
+      puts ''
+
+      data
+    end
+
+    # Returns a structured hash of all diagnostic data
+    def self.summary
+      config = Antigravity.config
+      api_key = config.api_key&.strip
+
+      # Detect API key source
+      api_key_source = if ENV['GEMINI_API_KEY'] && !ENV['GEMINI_API_KEY'].empty?
+                         'GEMINI_API_KEY'
+                       else
+                         '.env or config'
+                       end
+
+      # Detect model source
+      model_source = if ENV['GEMINI_MODEL'] && !ENV['GEMINI_MODEL'].empty?
+                       'GEMINI_MODEL'
+                     elsif ENV['ANTIGRAVITY_MODEL'] && !ENV['ANTIGRAVITY_MODEL'].empty?
+                       'ANTIGRAVITY_MODEL'
+                     else
+                       'default'
+                     end
+
+      # Harness binary info
+      harness_path = config.harness_path
+      harness_stat = File.stat(harness_path) rescue nil
+      harness_arch = detect_arch(harness_path) if harness_stat
+
+      # rv detection
+      rv_version = detect_rv
+
+      # Gem versions — stdlib gems need special detection
+      gem_names = %w[websocket dotenv json logger]
+      gems = gem_names.to_h do |g|
+        ver = Gem.loaded_specs[g]&.version&.to_s
+        # Stdlib gems (json, logger) may not appear in loaded_specs
+        ver ||= begin
+                  old_verbose = $VERBOSE
+                  $VERBOSE = nil
+                  require g
+                  $VERBOSE = old_verbose
+                  defined?(Gem) ? Gem.loaded_specs[g]&.version&.to_s : nil
+                rescue LoadError
+                  nil
+                end
+        # Last resort: check if the constant exists (stdlib bundled)
+        ver ||= '(stdlib)' if %w[json logger].include?(g)
+        [g, ver]
+      end
+
+      {
+        sdk_version: Antigravity::VERSION,
+        ruby_version: RUBY_VERSION,
+        ruby_platform: RUBY_PLATFORM,
+        bundler_version: Bundler::VERSION,
+        rv_version: rv_version,
+        api_key_present: api_key && !api_key.empty?,
+        api_key_prefix: api_key ? api_key[0..5] : '',
+        api_key_suffix: api_key ? api_key[-2..] : '',
+        api_key_source: api_key_source,
+        api_key_raw: api_key,
+        default_model: config.default_model,
+        model_source: model_source,
+        harness_path: harness_path,
+        harness_exists: !harness_stat.nil?,
+        harness_size: harness_stat&.size || 0,
+        harness_mtime: harness_stat&.mtime,
+        harness_arch: harness_arch,
+        timeout_llm: config.timeout_llm,
+        timeout_ws: config.timeout_ws,
+        timeout_handshake: config.timeout_handshake,
+        gems: gems,
+      }
+    end
+
+    # Quick health check — returns array of issue strings
+    def self.health_check(data = nil)
+      data ||= summary
+      issues = []
+      issues << 'GEMINI_API_KEY is not set' unless data[:api_key_present]
+      issues << "Harness binary not found at #{data[:harness_path]}" unless data[:harness_exists]
+      issues << 'websocket gem not loaded' unless data.dig(:gems, 'websocket')
+      issues
+    end
+
+    private
+
+    def self.section(title)
+      "\n#{C.bold(title)}"
+    end
+
+    def self.field(label, value)
+      "   #{C.cyan(label.to_s.ljust(12))} #{value}"
+    end
+
+    def self.detect_arch(path)
+      return nil unless File.exist?(path)
+      output = `file '#{path}' 2>/dev/null`.strip
+      case output
+      when /arm64/ then 'arm64 (Apple Silicon)'
+      when /x86_64/ then 'x86_64 (Intel)'
+      when /ELF.*64/ then 'linux-amd64'
+      else output.split(':').last&.strip&.slice(0, 40)
+      end
+    rescue
+      nil
+    end
+
+    def self.detect_rv
+      `rv --version 2>/dev/null`.strip.then { |v| v.empty? ? nil : v }
+    rescue
+      nil
+    end
+
+    def self.probe_models(api_key)
+      require 'net/http'
+      require 'json'
+      uri = URI("https://generativelanguage.googleapis.com/v1beta/models?key=#{api_key}")
+      resp = Net::HTTP.get_response(uri)
+      return nil unless resp.is_a?(Net::HTTPSuccess)
+      body = JSON.parse(resp.body)
+      models = body['models'] || []
+      names = models.map { |m| m['name'].to_s.sub('models/', '') }.sort
+      { count: names.length, names: names }
+    rescue
+      nil
+    end
+  end
+end

data/lib/antigravity/harness.rb

@@ -22,8 +22,7 @@ module Antigravity
         return true
       end
 
-      cmd = "#{@bin_path} --port=#{@port}"
-      @stdin, @stdout, @stderr, wait_thr = Open3.popen3(cmd)
+      @stdin, @stdout, @stderr, wait_thr = Open3.popen3(@bin_path, "--port=#{@port}")
       @pid = wait_thr.pid
 
       at_exit { stop! }

data/lib/antigravity/lifecycle_logger.rb

@@ -20,8 +20,9 @@ module Antigravity
     def self.status_line(agent)
       turns    = agent.turn_count rescue 0
       summary  = agent.session_summary rescue {}
-      tokens   = summary.dig(:tokens, :total) || 0
+      tokens   = summary[:total_tokens] || 0
       tok_str  = tokens > 999 ? "#{(tokens / 1000.0).round(1)}k" : tokens.to_s
+      tok_str  = "🪙#{tok_str}"
       model    = summary[:model] || agent.model || '?'
       conv_id  = (summary[:conversation_id] || '?')[0..7]
 
@@ -54,7 +55,18 @@ module Antigravity
         logger.instance_variable_set(:@session_start_time, Process.clock_gettime(Process::CLOCK_MONOTONIC))
         model = info[:model] || agent.model || '?'
         conv_id = (info[:conversation_id] || '?')[0..11]
-        puts C.gray("🟢 #{C.dim("session_start")} | model=#{C.cyan(model)} | conv=#{C.cyan(conv_id)}")
+        puts C.gray("\n🪝🟢 #{C.dim("session_start")} | model=#{C.cyan(model)} | conv=#{C.cyan(conv_id)}")
+      end
+
+      agent.hooks.on(:indexing_start) do |info|
+        ws = info[:workspace] || '?'
+        puts C.gray("🪝 📂 #{C.dim("indexing")}       | #{C.blue(ws)}")
+      end
+
+      agent.hooks.on(:indexing_done) do |info|
+        ws = info[:workspace] || '?'
+        elapsed = info[:elapsed] ? "#{info[:elapsed]}s" : '?'
+        puts C.gray("🪝 ✅ #{C.dim("indexed")}        | #{C.blue(ws)} | #{C.green(elapsed)}")
       end
 
       agent.hooks.on(:session_end) do |info|
@@ -65,9 +77,9 @@ module Antigravity
                   end
         turns = info[:turn_count] || agent.turn_count rescue 0
         summary = agent.session_summary rescue {}
-        tokens = summary.dig(:tokens, :total) || 0
+        tokens = summary[:total_tokens] || 0
         tok_str = tokens > 999 ? "#{(tokens / 1000.0).round(1)}k" : tokens.to_s
-        puts C.gray("🔴 #{C.dim("session_end")}   | #{C.bold("#{turns} turns")} | #{tok_str} tok | #{elapsed}s")
+        puts C.gray("🪝🔴 #{C.dim("session_end")}   | #{C.bold("#{turns} turns")} | 🪙#{tok_str} | #{elapsed}s")
       end
     end
 
@@ -81,7 +93,7 @@ module Antigravity
         preview = text.to_s[0..60].gsub("\n", ' ')
         preview += '...' if text.to_s.length > 60
         status = self.class.status_line(agent) rescue C.dim("T#{count}")
-        puts C.gray("  ➡️  #{C.dim("pre_turn")}  T#{count} | #{C.yellow("\"#{preview}\"")} | #{status}")
+        puts C.gray("🪝 ➡️  #{C.dim("pre_turn")}  T#{count} | #{C.yellow("\"#{preview}\"")} | #{status}")
       end
 
       agent.hooks.after_response do |response|
@@ -99,12 +111,12 @@ module Antigravity
         tool_count = response.respond_to?(:tool_calls_count) ? (response.tool_calls_count || 0) : 0
         status = self.class.status_line(agent) rescue ''
 
-        parts = ["#{C.green("#{chars}ch")} #{C.dim("#{lines}L")}"]
-        parts << "#{C.magenta("#{thinking_len}ch")} think" if thinking_len > 0
+        parts = ["#{C.green("#{chars}B")} #{C.dim("#{lines}L")}"]
+        parts << "#{C.magenta("#{thinking_len}B")} think" if thinking_len > 0
         parts << "#{C.cyan("#{tool_count}")} tools" if tool_count > 0
         parts << "#{C.blue("#{elapsed}s")}"
 
-        puts C.gray("  ⬅️  #{C.dim("post_turn")} T#{logger.instance_variable_get(:@turn_count)} | #{parts.join(' | ')} | #{status}")
+        puts C.gray("\n🪝 ⬅️  #{C.dim("post_turn")} T#{logger.instance_variable_get(:@turn_count)} | #{parts.join(' | ')} | #{status}")
         if logger.instance_variable_get(:@verbose)
           puts C.dim("     \"#{preview}\"")
         end
@@ -117,28 +129,32 @@ module Antigravity
       agent.hooks.on(:tool_call) do |info|
         name = info[:tool_name] || info[:name] || '?'
         params_preview = (info[:params] || {}).keys.join(', ')
-        puts C.gray("    🔧 #{C.dim("tool_call")}  | #{C.cyan(name)}(#{C.dim(params_preview)})")
+        puts C.gray("  🪝 🔧 #{C.dim("tool_call")}  | #{C.cyan(name)}(#{C.dim(params_preview)})")
       end
 
       agent.hooks.on(:tool_result) do |info|
         name = info[:tool_name] || info[:name] || '?'
-        result_len = info[:result].to_s.length rescue 0
+        result_str = info[:result].to_s
+        result_len = result_str.bytesize rescue 0
+        preview = result_str[0..120].gsub("\n", ' ')
+        preview += '...' if result_str.length > 120
         duration = info[:duration] ? "#{info[:duration].round(2)}s" : nil
-        parts = [C.cyan(name), "#{result_len}ch"]
+        parts = [C.cyan(name), "#{result_len}B"]
         parts << duration if duration
-        puts C.gray("    ✅ #{C.dim("tool_done")}  | #{parts.join(' | ')}")
+        puts C.gray("  🪝 ✅ #{C.dim("tool_done")}  | #{parts.join(' | ')}")
+        puts C.dim("     → #{C.yellow(preview)}") if result_len > 0
       end
 
       agent.hooks.on(:tool_blocked) do |info|
         name = info[:tool] || '?'
         reason = info[:reason] || 'policy'
-        puts C.red("    🚫 #{C.dim("tool_deny")}  | #{C.red(name)} — #{reason}")
+        puts C.red("  🪝 🚫 #{C.dim("tool_deny")}  | #{C.red(name)} — #{reason}")
       end
 
       agent.hooks.on(:tool_error) do |info|
         name = info[:tool_name] || info[:name] || '?'
         error = info[:error] || info[:message] || '?'
-        puts C.red("    💥 #{C.dim("tool_error")} | #{C.red(name)} — #{error.to_s[0..80]}")
+        puts C.red("  🪝 💥 #{C.dim("tool_error")} | #{C.red(name)} — #{error.to_s[0..80]}")
       end
     end
   end

data/lib/antigravity/skill.rb

@@ -71,7 +71,11 @@ module Antigravity
 
       content = File.read(skill_file, encoding: 'UTF-8')
       if content =~ /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
-        front_matter = YAML.safe_load(Regexp.last_match(1)) || {}
+        front_matter = begin
+                         YAML.safe_load(Regexp.last_match(1)) || {}
+                       rescue Psych::SyntaxError => e
+                         raise ArgumentError, "Invalid YAML frontmatter in #{skill_file}: #{e.message}"
+                       end
         @name = front_matter["name"] || File.basename(@path)
         @description = front_matter["description"] || ""
         @metadata = front_matter.fetch("metadata", {})

data/lib/antigravity/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
 module Antigravity
-  VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip rescue "0.1.0"
+  VERSION = begin
+    version_file = [
+      File.expand_path("../../VERSION", __dir__),
+      File.expand_path("../VERSION", __dir__)
+    ].find { |f| File.exist?(f) }
+    version_file ? File.read(version_file).strip : "0.5.0"
+  end
 end

data/lib/antigravity.rb

@@ -29,6 +29,7 @@ require_relative "antigravity/connection/local_connection"
 require_relative "antigravity/conversation"
 require_relative "antigravity/colors"
 require_relative "antigravity/lifecycle_logger"
+require_relative "antigravity/diagnostics"
 require_relative "antigravity/agent"
 
 module Antigravity

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antigravity-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.5
 platform: ruby
 authors:
 - Riccardo Carlesso
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: An elegant, Ruby-like SDK for building autonomous AI agents with Google
   Antigravity.
 email:
@@ -59,6 +73,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- VERSION
 - lib/antigravity.rb
 - lib/antigravity/agent.rb
 - lib/antigravity/base.rb
@@ -69,6 +84,7 @@ files:
 - lib/antigravity/connection/local_connection.rb
 - lib/antigravity/connection/websocket_client.rb
 - lib/antigravity/conversation.rb
+- lib/antigravity/diagnostics.rb
 - lib/antigravity/emojis.rb
 - lib/antigravity/errors.rb
 - lib/antigravity/guards.rb