harnex 0.6.4 → 0.7.3

data/lib/harnex/runtime/session.rb

@@ -6,16 +6,20 @@ module Harnex
   class Session
     OUTPUT_BUFFER_LIMIT = 64 * 1024
     TRANSCRIPT_TAIL_BYTES = 16 * 1024
+    AUTOSTOP_TEARDOWN_GRACE_SECONDS_DEFAULT = 5.0
     USAGE_FIELDS = %i[
       input_tokens output_tokens reasoning_tokens cached_tokens total_tokens agent_session_id
     ].freeze
+    BUDGET_META_FIELDS = %w[read_budget_lines output_ceiling_lines].freeze
     class EventCounters
       def initialize
         @counts = {
           stalls: 0,
           force_resumes: 0,
           disconnections: 0,
-          compactions: 0
+          compactions: 0,
+          tool_calls: 0,
+          commands_executed: 0
         }
       end
 
@@ -32,17 +36,31 @@ module Harnex
         end
       end
 
+      def record_item(item)
+        return unless item.is_a?(Hash)
+
+        case item["type"]
+        when "mcpToolCall", "dynamicToolCall"
+          @counts[:tool_calls] += 1
+        when "commandExecution"
+          @counts[:commands_executed] += 1
+        end
+      end
+
       def snapshot
         @counts.dup
       end
     end
 
-    attr_reader :repo_root, :host, :port, :session_id, :token, :command, :pid, :id, :adapter, :watch, :inbox, :description, :meta, :summary_out, :output_log_path, :events_log_path
+    attr_reader :repo_root, :launch_cwd, :host, :port, :session_id, :token, :command, :pid, :id, :adapter, :watch,
+                :inbox, :description, :meta, :summary_out, :output_log_path, :events_log_path,
+                :started_at, :ended_at, :exit_code, :term_signal
 
-    def initialize(adapter:, command:, repo_root:, host:, port: nil, id: DEFAULT_ID, watch: nil, description: nil, meta: nil, summary_out: nil, inbox_ttl: Inbox::DEFAULT_TTL)
+    def initialize(adapter:, command:, repo_root:, host:, port: nil, id: DEFAULT_ID, watch: nil, description: nil, meta: nil, summary_out: nil, inbox_ttl: Inbox::DEFAULT_TTL, auto_stop: false, launch_cwd: nil)
       @adapter = adapter
       @command = command
       @repo_root = repo_root
+      @launch_cwd = File.expand_path(launch_cwd.to_s.empty? ? repo_root : launch_cwd)
       @host = host
       @id = Harnex.normalize_id(id)
       @watch = watch
@@ -60,6 +78,8 @@ module Harnex
       @mutex = Mutex.new
       @inject_mutex = Mutex.new
       @events_mutex = Mutex.new
+      @stop_mutex = Mutex.new
+      @auto_stop_mutex = Mutex.new
       @injected_count = 0
       @last_injected_at = nil
       @started_at = Time.now
@@ -74,8 +94,15 @@ module Harnex
       @usage_summary = {}
       @ended_at = nil
       @exit_reason = nil
+      @last_error = nil
+      @session_finalized = false
       @turn_started_seen = false
       @last_completed_at = nil
+      @auto_stop = !!auto_stop
+      @auto_stop_fired = false
+      @auto_stop_seen_busy = false
+      @auto_stop_threads = []
+      @stop_requested = false
       @writer = nil
       @pid = nil
       @term_signal = nil
@@ -83,6 +110,9 @@ module Harnex
       @output_buffer.force_encoding(Encoding::BINARY)
       @state_machine = SessionState.new(adapter)
       @inbox = Inbox.new(self, @state_machine, ttl: inbox_ttl)
+      @rate_limits = nil
+      @parent_harnex_id = ENV["HARNEX_ID"].to_s.strip
+      @parent_harnex_id = nil if @parent_harnex_id.empty?
     end
 
     def self.validate_binary!(command)
@@ -116,6 +146,7 @@ module Harnex
     def run_pty
       @reader, @writer, @pid = PTY.spawn(child_env, *command)
       @writer.sync = true
+      arm_auto_stop_after_initial_context
       emit_started_event
       emit_git_start_event
 
@@ -136,17 +167,15 @@ module Harnex
       @exit_code = status.exited? ? status.exitstatus : 128 + status.termsig
       @ended_at = Time.now
 
+      normalize_auto_stop_exit_code!
+      drain_auto_stop_threads
       output_thread.join(1)
-      emit_session_end_telemetry
-      @exit_reason = classify_exit
-      summary_record = build_summary_record
-      append_summary_record(summary_record)
-      emit_summary_event
-      emit_exit_event
+      finalize_session!
       input_thread&.kill
       watch_thread&.kill
       @exit_code
     ensure
+      finalize_session!
       @inbox.stop
       STDIN.cooked! if STDIN.tty? && stdin_state
       @server&.stop
@@ -195,6 +224,18 @@ module Harnex
       payload
     end
 
+    def task_complete?
+      !!@last_completed_at
+    end
+
+    def git_start
+      @git_start || {}
+    end
+
+    def git_end
+      @git_end || {}
+    end
+
     def auth_ok?(header)
       header == "Bearer #{token}"
     end
@@ -205,11 +246,26 @@ module Harnex
       inject_sequence([{ text: text, newline: newline }])
     end
 
-    def inject_stop
+    def inject_stop(turn_id: nil)
+      unless adapter.transport == :stdio_jsonrpc
+        raise "session is not running" unless pid && Harnex.alive_pid?(pid)
+      end
+
+      return { ok: true, signal: "already_requested" } if stop_requested!
+
       if adapter.transport == :stdio_jsonrpc
+        if adapter.respond_to?(:terminate_subprocess)
+          Thread.new do
+            begin
+              adapter.terminate_subprocess
+            rescue Errno::ESRCH, StandardError
+              nil
+            end
+          end
+        end
         @inject_mutex.synchronize do
           begin
-            adapter.interrupt
+            adapter.interrupt(turn_id: turn_id)
           rescue StandardError
             nil
           end
@@ -218,8 +274,6 @@ module Harnex
         return { ok: true, signal: "interrupt_sent" }
       end
 
-      raise "session is not running" unless pid && Harnex.alive_pid?(pid)
-
       @inject_mutex.synchronize do
         adapter.inject_exit(@writer)
         @state_machine.force_busy!
@@ -341,15 +395,13 @@ module Harnex
       end
       @ended_at = Time.now
 
-      emit_session_end_telemetry
-      @exit_reason = classify_exit
-      summary_record = build_summary_record
-      append_summary_record(summary_record)
-      emit_summary_event
-      emit_exit_event
+      normalize_auto_stop_exit_code!
+      drain_auto_stop_threads
+      finalize_session!
       watch_thread&.kill
       @exit_code
     ensure
+      finalize_session!
       @inbox.stop
       @server&.stop
       begin
@@ -376,33 +428,40 @@ module Harnex
 
       case method
       when "thread/started"
-        @rpc_thread_id = params["threadId"] || params["thread_id"]
+        @rpc_thread_id = params.dig("thread", "id")
       when "turn/started"
         @turn_started_seen = true
         @state_machine.force_busy!
-        emit_event("turn_started", turnId: params["turnId"] || params["turn_id"])
+        emit_event("turn_started", turnId: params.dig("turn", "id"))
       when "turn/completed"
         @last_completed_at = Time.now
         @state_machine.force_prompt!
-        payload = { turnId: params["turnId"] || params["turn_id"] }
-        payload[:status] = params["status"] if params["status"]
+        turn = params["turn"] || {}
+        payload = { turnId: turn["id"] }
+        payload[:status] = turn["status"] if turn["status"]
         payload[:tokenUsage] = params["tokenUsage"] if params["tokenUsage"]
         emit_event("task_complete", **payload)
+        schedule_auto_stop("task_complete", turn_id: payload[:turnId])
       when "item/completed"
         emit_event("item_completed", item: params["item"])
+        @event_counters.record_item(params["item"])
         text = render_item_text(params["item"])
         record_synthesized(text) if text
       when "thread/compacted"
         emit_event("compaction", **params)
       when "thread/tokenUsage/updated"
-        # Surfaced via status fields in Phase 4; no event spam.
-        @token_usage = params["usage"] || params
+        # Schema: ThreadTokenUsageUpdatedNotification carries
+        # `tokenUsage: { last, total, modelContextWindow? }` where each
+        # breakdown has camelCase {input,output,cachedInput,reasoningOutput,total}Tokens.
+        # Snapshot it; the cumulative `total` is read at session end.
+        @token_usage = params["tokenUsage"] if params["tokenUsage"].is_a?(Hash)
       when "thread/status/changed"
         # State machine reflects RPC state; no event needed.
         nil
       when "account/rateLimits/updated"
         @rate_limits = params
       when "error"
+        @last_error = params["message"].to_s unless params["message"].to_s.empty?
         @state_machine.force_busy!
         emit_event("disconnected", source: "error_notification", message: params["message"])
         signal_rpc_done!
@@ -413,6 +472,7 @@ module Harnex
 
     def handle_rpc_disconnect(error)
       msg = error.is_a?(Hash) ? error["message"] : error&.message
+      @last_error = msg.to_s unless msg.to_s.empty?
       @state_machine.force_busy!
       emit_event("disconnected", source: "transport", message: msg) rescue nil
       signal_rpc_done!
@@ -430,14 +490,15 @@ module Harnex
     def render_item_text(item)
       return nil unless item.is_a?(Hash)
 
-      type = item["type"] || item["kind"]
-      case type
-      when "agent_message", "assistant_message"
-        item["text"] || item.dig("message", "text")
-      when "tool_call"
-        name = item["name"] || item.dig("tool", "name") || "tool"
-        params = item["params"] || item["arguments"]
-        "tool: #{name}#{params ? " #{summarize(params)}" : ""}"
+      case item["type"]
+      when "agentMessage"
+        item["text"]
+      when "mcpToolCall", "dynamicToolCall"
+        name = item["tool"] || "tool"
+        args = item["arguments"]
+        "tool: #{name}#{args ? " #{summarize(args)}" : ""}"
+      when "commandExecution"
+        "command: #{item["command"]}"
       else
         item["text"]
       end
@@ -644,7 +705,9 @@ module Harnex
         @output_buffer = @output_buffer.byteslice(overflow, OUTPUT_BUFFER_LIMIT) if overflow.positive?
         @output_buffer.dup
       end
-      @state_machine.update(snapshot)
+      old_state = @state_machine.to_s.to_sym
+      new_state = @state_machine.update(snapshot)
+      handle_auto_stop_pty_transition(old_state, new_state)
     end
 
     def append_output_log(chunk)
@@ -679,7 +742,7 @@ module Harnex
     end
 
     def emit_session_end_telemetry
-      @usage_summary = normalized_usage_summary(adapter.parse_session_summary(transcript_tail))
+      @usage_summary = normalized_usage_summary(collect_session_summary)
       emit_event("usage", **@usage_summary)
 
       @git_end = Harnex.git_capture_end(repo_root, @git_start[:sha])
@@ -707,6 +770,120 @@ module Harnex
       emit_event("exited", **payload)
     end
 
+    def finalize_session!
+      return if @session_finalized
+      return unless @events_log
+
+      @session_finalized = true
+      @ended_at ||= Time.now
+      begin
+        emit_session_end_telemetry
+      rescue StandardError => e
+        @usage_summary = normalized_usage_summary(nil)
+        warn("harnex: failed to collect session-end telemetry: #{e.message}")
+      end
+      @exit_reason ||= classify_exit
+      append_summary_record(build_summary_record)
+      append_dispatch_history_record
+      emit_summary_event
+      emit_exit_event
+    end
+
+    def stop_requested!
+      @stop_mutex.synchronize do
+        return true if @stop_requested
+
+        @stop_requested = true
+        false
+      end
+    end
+
+    def arm_auto_stop_after_initial_context
+      return unless @auto_stop
+      return unless adapter.transport == :pty
+
+      @auto_stop_mutex.synchronize { @auto_stop_seen_busy = true }
+      @state_machine.force_busy!
+    end
+
+    def handle_auto_stop_pty_transition(old_state, new_state)
+      return unless @auto_stop
+      return unless adapter.transport == :pty
+
+      seen_busy = @auto_stop_mutex.synchronize do
+        @auto_stop_seen_busy ||= old_state == :busy || new_state == :busy
+      end
+      schedule_auto_stop("prompt_after_busy") if seen_busy && new_state == :prompt
+    end
+
+    def schedule_auto_stop(reason, turn_id: nil)
+      return unless @auto_stop
+
+      should_fire = @auto_stop_mutex.synchronize do
+        if @auto_stop_fired
+          false
+        else
+          @auto_stop_fired = true
+          true
+        end
+      end
+      return unless should_fire
+
+      thread = Thread.new do
+        begin
+          inject_stop(turn_id: turn_id)
+        rescue StandardError => e
+          warn("harnex: auto-stop failed after #{reason}: #{e.message}")
+        end
+      end
+      track_auto_stop_thread(thread)
+    end
+
+    def track_auto_stop_thread(thread)
+      @auto_stop_mutex.synchronize { @auto_stop_threads << thread }
+    end
+
+    def drain_auto_stop_threads
+      return unless @auto_stop
+
+      threads = @auto_stop_mutex.synchronize { @auto_stop_threads.dup }
+      return if threads.empty?
+
+      grace_seconds = auto_stop_teardown_grace_seconds
+      deadline = Time.now + grace_seconds
+      timed_out = []
+
+      threads.each do |thread|
+        remaining = deadline - Time.now
+        thread.join(remaining) if remaining.positive?
+        timed_out << thread if thread.alive?
+      end
+      return if timed_out.empty?
+
+      timed_out.each(&:kill)
+      @exit_code = 1 if @exit_code.nil? || @exit_code.zero?
+      @term_signal = nil if @exit_code == 1
+      emit_event("auto_stop_teardown_timeout", grace_seconds: grace_seconds, threads: timed_out.size)
+    end
+
+    def auto_stop_teardown_grace_seconds
+      override = ENV["HARNEX_AUTOSTOP_TEARDOWN_GRACE_SECONDS"]
+      return AUTOSTOP_TEARDOWN_GRACE_SECONDS_DEFAULT if override.to_s.strip.empty?
+
+      Float(override)
+    rescue ArgumentError
+      AUTOSTOP_TEARDOWN_GRACE_SECONDS_DEFAULT
+    end
+
+    def normalize_auto_stop_exit_code!
+      return unless @auto_stop
+      return unless @last_completed_at
+      return unless @auto_stop_fired
+
+      @exit_code = 0
+      @term_signal = nil
+    end
+
     def classify_exit
       return "timeout" if @exit_code == 124
       return "success" if @exit_code == 0 && session_summary_present?
@@ -742,22 +919,21 @@ module Harnex
 
       {
         id: id,
-        tmux_session: id,
+        tmux_session: summary_tmux_session,
         description: description,
         started_at: @started_at.iso8601,
         ended_at: @ended_at&.iso8601,
         harness: "harnex",
         harness_version: Harnex.harness_version,
         agent: adapter.key,
-        agent_version: nil,
-        agent_provider: nil,
-        agent_deployment: nil,
+        agent_version: adapter.agent_version,
+        agent_provider: adapter.provider,
         host: info[:host],
         platform: info[:platform],
         orchestrator: passthrough["orchestrator"],
         orchestrator_session: passthrough["orchestrator_session"],
         chain_id: passthrough["chain_id"],
-        parent_dispatch_id: passthrough["parent_dispatch_id"],
+        parent_dispatch_id: passthrough["parent_dispatch_id"] || @parent_harnex_id,
         tier: passthrough["tier"],
         phase: passthrough["phase"],
         issue: passthrough["issue"],
@@ -767,16 +943,17 @@ module Harnex
         branch: @git_start[:branch],
         start_sha: @git_start[:sha],
         end_sha: @git_end[:sha]
-      }
+      }.merge(summary_budget_meta)
     end
 
     def build_summary_actual
       counters = @event_counters.snapshot
+      output_measurements = summary_output_measurements
       if %w[disconnected boot_failure].include?(@exit_reason)
         counters[:disconnections] = [counters[:disconnections], 1].max
       end
 
-      {
+      actual = {
         model: meta_hash["model"],
         effort: meta_hash["effort"],
         duration_s: @ended_at ? (@ended_at - @started_at).to_i : nil,
@@ -784,20 +961,70 @@ module Harnex
         output_tokens: @usage_summary[:output_tokens],
         reasoning_tokens: @usage_summary[:reasoning_tokens],
         cached_tokens: @usage_summary[:cached_tokens],
-        cost_usd: nil,
+        total_tokens: @usage_summary[:total_tokens],
+        agent_session_id: summary_agent_session_id,
+        adapter_transport: adapter.transport.to_s,
         loc_added: @git_end[:loc_added],
         loc_removed: @git_end[:loc_removed],
+        lines_changed: summary_lines_changed,
         files_changed: @git_end[:files_changed],
         commits: @git_end[:commits],
         exit: @exit_reason,
+        task_complete: !!@last_completed_at,
+        signal: @term_signal,
+        exit_code: @exit_code,
+        last_error: @last_error,
         stalls: counters[:stalls],
         force_resumes: counters[:force_resumes],
         disconnections: counters[:disconnections],
         compactions: counters[:compactions],
-        tests_run: nil,
-        tests_passed: nil,
-        tests_failed: nil
+        turn_count: @injected_count,
+        tool_calls: counters[:tool_calls],
+        commands_executed: counters[:commands_executed],
+        rate_limits: @rate_limits,
+        output_lines: output_measurements[:lines],
+        output_bytes: output_measurements[:bytes],
+        event_records: @events_log_seq,
+        output_log_path: output_log_path,
+        events_log_path: events_log_path
       }
+      actual
+    end
+
+    def summary_budget_meta
+      BUDGET_META_FIELDS.each_with_object({}) do |field, values|
+        values[field.to_sym] = meta_hash[field] if meta_hash.key?(field)
+      end
+    end
+
+    def summary_lines_changed
+      added = @git_end[:loc_added]
+      removed = @git_end[:loc_removed]
+      return nil if added.nil? && removed.nil?
+
+      added.to_i + removed.to_i
+    end
+
+    def summary_output_measurements
+      size = File.size?(output_log_path)
+      return { lines: nil, bytes: nil } unless size
+
+      lines = 0
+      File.foreach(output_log_path) { lines += 1 }
+      { lines: lines, bytes: size }
+    rescue StandardError
+      { lines: nil, bytes: size }
+    end
+
+    def summary_tmux_session
+      value = load_existing_registry_metadata["tmux_session"]
+      value.to_s.empty? ? nil : value
+    end
+
+    def summary_agent_session_id
+      @usage_summary[:agent_session_id] ||
+        @rpc_thread_id ||
+        (adapter.thread_id if adapter.respond_to?(:thread_id))
     end
 
     def summary_predicted_payload
@@ -821,11 +1048,45 @@ module Harnex
       warn("harnex: failed to write dispatch summary #{summary_out}: #{e.message}")
     end
 
+    def append_dispatch_history_record
+      path = DispatchHistory.path_for(launch_cwd)
+      DispatchHistory.append(path, DispatchHistory.build_record(self))
+    rescue StandardError => e
+      warn("harnex: failed to write dispatch history: #{e.message}")
+    end
+
     def normalized_usage_summary(summary)
       summary ||= {}
       USAGE_FIELDS.to_h { |field| [field, summary[field] || summary[field.to_s]] }
     end
 
+    # Adapters speaking JSON-RPC capture token usage from the structured
+    # `thread/tokenUsage/updated` notification stream and don't have a
+    # transcript to scrape; fall back to the schema-true cumulative
+    # `total` block. Other adapters parse the transcript tail.
+    def collect_session_summary
+      if adapter.transport == :stdio_jsonrpc
+        summary_from_token_usage
+      else
+        adapter.parse_session_summary(transcript_tail)
+      end
+    end
+
+    def summary_from_token_usage
+      return {} unless @token_usage.is_a?(Hash)
+
+      total = @token_usage["total"]
+      return {} unless total.is_a?(Hash)
+
+      {
+        input_tokens: total["inputTokens"],
+        output_tokens: total["outputTokens"],
+        reasoning_tokens: total["reasoningOutputTokens"],
+        cached_tokens: total["cachedInputTokens"],
+        total_tokens: total["totalTokens"]
+      }
+    end
+
     def transcript_tail
       return "" unless File.file?(output_log_path)
 

data/lib/harnex/version.rb

@@ -1,4 +1,4 @@
 module Harnex
-  VERSION = "0.6.4"
-  RELEASE_DATE = "2026-05-06"
+  VERSION = "0.7.3"
+  RELEASE_DATE = "2026-05-13"
 end

data/lib/harnex.rb

@@ -4,6 +4,7 @@ require "open3"
 
 require_relative "harnex/version"
 require_relative "harnex/core"
+require_relative "harnex/dispatch_history"
 require_relative "harnex/watcher"
 require_relative "harnex/adapters"
 require_relative "harnex/runtime/session_state"
@@ -21,6 +22,7 @@ require_relative "harnex/commands/stop"
 require_relative "harnex/commands/status"
 require_relative "harnex/commands/logs"
 require_relative "harnex/commands/events"
+require_relative "harnex/commands/history"
 require_relative "harnex/commands/pane"
 require_relative "harnex/commands/recipes"
 require_relative "harnex/commands/guide"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harnex
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.3
 platform: ruby
 authors:
 - Jikku Jose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies: []
 description: A local PTY harness that wraps terminal AI agents (Claude, Codex) and
   adds a control plane for discovery, messaging, and coordination.
@@ -38,11 +38,14 @@ files:
 - lib/harnex/adapters/codex.rb
 - lib/harnex/adapters/codex_appserver.rb
 - lib/harnex/adapters/generic.rb
+- lib/harnex/adapters/opencode.rb
 - lib/harnex/cli.rb
+- lib/harnex/codex/app_server/client.rb
 - lib/harnex/commands/agents_guide.rb
 - lib/harnex/commands/doctor.rb
 - lib/harnex/commands/events.rb
 - lib/harnex/commands/guide.rb
+- lib/harnex/commands/history.rb
 - lib/harnex/commands/logs.rb
 - lib/harnex/commands/pane.rb
 - lib/harnex/commands/recipes.rb
@@ -54,6 +57,7 @@ files:
 - lib/harnex/commands/watch.rb
 - lib/harnex/commands/watch_presets.rb
 - lib/harnex/core.rb
+- lib/harnex/dispatch_history.rb
 - lib/harnex/runtime/api_server.rb
 - lib/harnex/runtime/file_change_hook.rb
 - lib/harnex/runtime/inbox.rb