harnex 0.7.3 → 0.7.5

data/lib/harnex/commands/status.rb

@@ -28,6 +28,8 @@ module Harnex
         Gotchas:
           By default, status filters to the current repo root.
           Use --all when supervising workers launched from sibling worktrees.
+          With --id, terminal summaries can report completed/failed/unknown
+          even after the live session registry is gone.
           A prompt-like state is not a completion signal by itself.
       TEXT
     end
@@ -83,12 +85,31 @@ module Harnex
     end
 
     def load_sessions
-      repo_root = @options[:all] ? nil : Harnex.resolve_repo_root(@options[:repo_path])
-      sessions = Harnex.active_sessions(repo_root, id: @options[:id])
+      active_repo_root = @options[:all] ? nil : Harnex.resolve_repo_root(@options[:repo_path])
+      fallback_repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      sessions = Harnex.active_sessions(active_repo_root, id: @options[:id])
+
+      live = sessions.map { |session| normalize_live_status(load_live_status(session)) }
+                     .sort_by { |session| [session["repo_root"].to_s, session["started_at"].to_s, session["id"].to_s] }
+                     .reverse
+      return live unless @options[:id]
+      return [live.first] unless live.empty?
+
+      terminal = Harnex::TerminalStatus.resolve(id: @options[:id], repo_root: fallback_repo_root)
+      [terminal || Harnex::TerminalStatus.unknown(id: @options[:id], repo_root: fallback_repo_root)]
+    end
 
-      sessions.map { |session| load_live_status(session) }
-        .sort_by { |session| [session["repo_root"].to_s, session["started_at"].to_s, session["id"].to_s] }
-        .reverse
+    def normalize_live_status(session)
+      session.merge(
+        "state" => "running",
+        "terminal" => false,
+        "task_complete" => !session["last_completed_at"].to_s.empty?,
+        "exit" => nil,
+        "exit_code" => nil,
+        "summary_out" => nil,
+        "ended_at" => nil,
+        "source" => "live"
+      )
     end
 
     def load_live_status(session)
@@ -128,7 +149,7 @@ module Harnex
         "PORT" => session["port"].to_s,
         "AGE" => timeago(session["started_at"]),
         "IDLE" => format_idle(session["log_idle_s"]),
-        "STATE" => session.dig("input_state", "state").to_s.empty? ? "-" : session.dig("input_state", "state").to_s,
+        "STATE" => table_state(session),
         "DESC" => truncate(session["description"])
       }
       row["REPO"] = truncate_repo(session["repo_root"])
@@ -139,6 +160,14 @@ module Harnex
       columns.map { |column| row.fetch(column).ljust(widths.fetch(column)) }.join("  ")
     end
 
+    def table_state(session)
+      input_state = session.dig("input_state", "state").to_s
+      return input_state unless input_state.empty?
+
+      state = session["state"].to_s
+      state.empty? ? "-" : state
+    end
+
     def timeago(timestamp)
       return "-" if timestamp.to_s.empty?
 

data/lib/harnex/commands/wait.rb

@@ -38,6 +38,8 @@ module Harnex
         Gotchas:
           task_complete is an event predicate; prompt/busy are live state polls.
           Prompt state alone does not prove work acceptance. Verify artifacts/tests.
+          Exit waits can resolve from terminal summary rows when live registry/
+          exit-status files are already gone.
           Without --timeout, wait can block indefinitely.
       TEXT
     end
@@ -238,7 +240,11 @@ module Harnex
       unless registry
         return read_exit_status(exit_path, @options[:id]) if File.exist?(exit_path)
 
+        terminal = terminal_status(repo_root)
+        return emit_terminal_status(terminal) if terminal
+
         warn("harnex wait: no session found with id #{@options[:id].inspect}")
+        puts JSON.generate(ok: false, id: @options[:id], state: "unknown", terminal: false, status: "unknown")
         return 1
       end
 
@@ -248,7 +254,13 @@ module Harnex
       loop do
         unless Harnex.alive_pid?(target_pid)
           await_exit_status(exit_path)
-          return read_exit_status(exit_path, @options[:id])
+          return read_exit_status(exit_path, @options[:id]) if File.exist?(exit_path)
+
+          terminal = terminal_status(repo_root)
+          return emit_terminal_status(terminal) if terminal
+
+          puts JSON.generate(ok: false, id: @options[:id], state: "unknown", terminal: false, status: "unknown")
+          return 1
         end
 
         if deadline && Time.now >= deadline
@@ -308,6 +320,38 @@ module Harnex
       end
     end
 
+    def terminal_status(repo_root)
+      status = Harnex::TerminalStatus.resolve(id: @options[:id], repo_root: repo_root)
+      return nil unless status
+      return nil unless status["terminal"]
+
+      status
+    end
+
+    def emit_terminal_status(status)
+      payload = {
+        ok: status["state"] == "completed",
+        id: status["id"],
+        state: status["state"],
+        terminal: true,
+        task_complete: status["task_complete"],
+        exit: status["exit"],
+        exit_code: status["exit_code"],
+        summary_out: status["summary_out"],
+        ended_at: status["ended_at"],
+        source: status["source"]
+      }
+      puts JSON.generate(payload)
+
+      if payload[:ok]
+        0
+      elsif status["exit_code"].is_a?(Integer) && status["exit_code"] > 0
+        status["exit_code"]
+      else
+        1
+      end
+    end
+
     def parser
       @parser ||= OptionParser.new do |opts|
         opts.banner = "Usage: harnex wait [options]"

data/lib/harnex/runtime/session.rb

@@ -8,7 +8,12 @@ module Harnex
     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
+      input_tokens output_tokens reasoning_tokens cached_tokens total_tokens
+      agent_session_id cost_usd tool_calls model agent_provider
+    ].freeze
+    SESSION_SUMMARY_SIGNAL_FIELDS = %i[
+      input_tokens output_tokens reasoning_tokens cached_tokens total_tokens
+      agent_session_id cost_usd
     ].freeze
     BUDGET_META_FIELDS = %w[read_budget_lines output_ceiling_lines].freeze
     class EventCounters
@@ -98,6 +103,7 @@ module Harnex
       @session_finalized = false
       @turn_started_seen = false
       @last_completed_at = nil
+      @pi_streamed_text_by_message = {}
       @auto_stop = !!auto_stop
       @auto_stop_fired = false
       @auto_stop_seen_busy = false
@@ -138,7 +144,7 @@ module Harnex
       prepare_output_log
       prepare_events_log
 
-      return run_jsonrpc if adapter.transport == :stdio_jsonrpc
+      return run_structured if structured_transport?
 
       run_pty
     end
@@ -218,7 +224,7 @@ module Harnex
       payload[:agent_state] = @state_machine.to_s
       payload[:inbox] = @inbox.stats
       payload[:last_completed_at] = @last_completed_at&.iso8601
-      payload[:model] = meta_hash["model"]
+      payload[:model] = summary_model
       payload[:effort] = meta_hash["effort"]
       payload[:auto_disconnects] = @event_counters.snapshot[:disconnections]
       payload
@@ -247,13 +253,13 @@ module Harnex
     end
 
     def inject_stop(turn_id: nil)
-      unless adapter.transport == :stdio_jsonrpc
+      unless structured_transport?
         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 structured_transport?
         if adapter.respond_to?(:terminate_subprocess)
           Thread.new do
             begin
@@ -283,8 +289,8 @@ module Harnex
     end
 
     def inject_via_adapter(text:, submit:, enter_only:, force: false)
-      if adapter.transport == :stdio_jsonrpc
-        return inject_via_jsonrpc(text: text, submit: submit, enter_only: enter_only, force: force)
+      if structured_transport?
+        return inject_via_structured(text: text, submit: submit, enter_only: enter_only, force: force)
       end
 
       snapshot = adapter.wait_for_sendable(method(:screen_snapshot), submit: submit, enter_only: enter_only, force: force)
@@ -311,7 +317,7 @@ module Harnex
         .tap { emit_send_event(text, force: payload[:force]) }
     end
 
-    def inject_via_jsonrpc(text:, submit:, enter_only:, force: false)
+    def inject_via_structured(text:, submit:, enter_only:, force: false)
       payload = adapter.build_send_payload(
         text: text,
         submit: submit,
@@ -360,9 +366,13 @@ module Harnex
 
     private
 
-    def run_jsonrpc
-      adapter.on_notification { |msg| handle_rpc_notification(msg) }
-      adapter.on_disconnect { |err| handle_rpc_disconnect(err) }
+    def structured_transport?
+      %i[stdio_jsonrpc stdio_jsonl_rpc].include?(adapter.transport)
+    end
+
+    def run_structured
+      adapter.on_notification { |msg| handle_structured_notification(msg) }
+      adapter.on_disconnect { |err| handle_structured_disconnect(err) }
 
       adapter.start_rpc(env: child_env, cwd: repo_root)
       @pid = adapter.pid
@@ -415,6 +425,8 @@ module Harnex
       @events_log&.close unless @events_log&.closed?
     end
 
+    alias run_jsonrpc run_structured
+
     def signal_rpc_done!
       @rpc_done = true
       if defined?(@rpc_done_lock) && @rpc_done_lock
@@ -422,6 +434,15 @@ module Harnex
       end
     end
 
+    def handle_structured_notification(message)
+      case adapter.transport
+      when :stdio_jsonrpc
+        handle_rpc_notification(message)
+      when :stdio_jsonl_rpc
+        handle_jsonl_notification(message)
+      end
+    end
+
     def handle_rpc_notification(message)
       method = message["method"]
       params = message["params"] || {}
@@ -470,6 +491,86 @@ module Harnex
       warn("harnex: rpc notification handler error: #{e.message}")
     end
 
+    def handle_jsonl_notification(message)
+      event_type = message["type"].to_s
+
+      case event_type
+      when "agent_start", "turn_start"
+        @turn_started_seen = true if event_type == "turn_start"
+        @state_machine.force_busy!
+        emit_event("turn_started") if event_type == "turn_start"
+      when "agent_end"
+        @last_completed_at = Time.now
+        @state_machine.force_prompt!
+        emit_event("task_complete")
+        adapter.request_session_stats_async if adapter.respond_to?(:request_session_stats_async)
+        schedule_auto_stop("task_complete")
+      when "message_start"
+        @pi_streamed_text_by_message[pi_message_key(message["message"])] = false
+      when "message_update"
+        event = message["assistantMessageEvent"] || {}
+        delta = event["delta"]
+        key = pi_message_key(message["message"])
+        if event["type"] == "text_delta" && delta && !delta.empty?
+          @pi_streamed_text_by_message[key] = true
+          record_synthesized(delta, newline: false)
+        end
+      when "message_end"
+        key = pi_message_key(message["message"])
+        streamed = @pi_streamed_text_by_message.delete(key)
+        unless streamed
+          text = pi_extract_message_text(message["message"])
+          record_synthesized(text) if text
+        end
+      when "tool_execution_start"
+        @event_counters.record_item({ "type" => "dynamicToolCall" })
+        record_synthesized(
+          "tool: #{message["toolName"] || "tool"}#{message["args"] ? " #{summarize(message["args"])}" : ""}"
+        )
+      when "tool_execution_end"
+        tool_name = message["toolName"] || "tool"
+        status = message["isError"] ? "error" : "ok"
+        record_synthesized("tool-result: #{tool_name} (#{status})")
+      when "compaction_start", "compaction_end"
+        emit_event("compaction", reason: message["reason"], phase: event_type)
+      when "queue_update"
+        nil
+      when "auto_retry_start", "auto_retry_end"
+        emit_event(event_type, **message.reject { |k, _| k == "type" })
+      when "extension_ui_request"
+        handle_extension_ui_request(message)
+      when "extension_error"
+        @last_error = message["error"].to_s unless message["error"].to_s.empty?
+        emit_event("extension_error", **message.reject { |k, _| k == "type" })
+      when "response"
+        # Adapter-level command responses are handled in the adapter.
+        nil
+      end
+    rescue StandardError => e
+      warn("harnex: rpc notification handler error: #{e.message}")
+    end
+
+    def handle_extension_ui_request(message)
+      method = message["method"].to_s
+      request_id = message["id"]
+      cancelled = false
+      if adapter.respond_to?(:respond_extension_ui_cancel)
+        cancelled = adapter.respond_extension_ui_cancel(request_id: request_id, method: method)
+      end
+
+      payload = {
+        method: method,
+        request_id: request_id,
+        auto_cancelled: !!cancelled
+      }
+      emit_event("extension_ui_request", **payload)
+      record_synthesized("extension-ui: #{method}#{cancelled ? " (auto-cancelled)" : ""}")
+    end
+
+    def handle_structured_disconnect(error)
+      handle_rpc_disconnect(error)
+    end
+
     def handle_rpc_disconnect(error)
       msg = error.is_a?(Hash) ? error["message"] : error&.message
       @last_error = msg.to_s unless msg.to_s.empty?
@@ -484,7 +585,7 @@ module Harnex
       prompt = adapter.initial_prompt
       return if prompt.to_s.empty?
 
-      inject_via_jsonrpc(text: prompt, submit: true, enter_only: false, force: false)
+      inject_via_structured(text: prompt, submit: true, enter_only: false, force: false)
     end
 
     def render_item_text(item)
@@ -511,11 +612,37 @@ module Harnex
       ""
     end
 
-    def record_synthesized(text)
+    def pi_extract_message_text(message)
+      return nil unless message.is_a?(Hash)
+
+      content = message["content"]
+      case content
+      when String
+        content
+      when Array
+        parts = content.filter_map do |item|
+          next unless item.is_a?(Hash)
+          next unless item["type"] == "text"
+
+          item["text"].to_s
+        end
+        parts.empty? ? nil : parts.join
+      else
+        nil
+      end
+    end
+
+    def pi_message_key(message)
+      return "unknown" unless message.is_a?(Hash)
+
+      message["entryId"] || message["id"] || message["timestamp"] || message.object_id
+    end
+
+    def record_synthesized(text, newline: true)
       return if text.nil? || text.to_s.empty?
 
       payload = text.to_s.dup
-      payload << "\n" unless payload.end_with?("\n")
+      payload << "\n" if newline && !payload.end_with?("\n")
       bytes = payload.b
       @mutex.synchronize do
         append_output_log(bytes)
@@ -894,7 +1021,7 @@ module Harnex
     end
 
     def boot_failure_exit?
-      return false unless adapter.transport == :stdio_jsonrpc
+      return false unless structured_transport?
       return false if @turn_started_seen
 
       lifetime = (@ended_at || Time.now) - @started_at
@@ -902,7 +1029,7 @@ module Harnex
     end
 
     def session_summary_present?
-      @usage_summary.values.any? { |value| !value.nil? }
+      SESSION_SUMMARY_SIGNAL_FIELDS.any? { |field| !@usage_summary[field].nil? }
     end
 
     def build_summary_record
@@ -927,7 +1054,7 @@ module Harnex
         harness_version: Harnex.harness_version,
         agent: adapter.key,
         agent_version: adapter.agent_version,
-        agent_provider: adapter.provider,
+        agent_provider: summary_agent_provider,
         host: info[:host],
         platform: info[:platform],
         orchestrator: passthrough["orchestrator"],
@@ -954,7 +1081,7 @@ module Harnex
       end
 
       actual = {
-        model: meta_hash["model"],
+        model: summary_model,
         effort: meta_hash["effort"],
         duration_s: @ended_at ? (@ended_at - @started_at).to_i : nil,
         input_tokens: @usage_summary[:input_tokens],
@@ -962,6 +1089,7 @@ module Harnex
         reasoning_tokens: @usage_summary[:reasoning_tokens],
         cached_tokens: @usage_summary[:cached_tokens],
         total_tokens: @usage_summary[:total_tokens],
+        cost_usd: @usage_summary[:cost_usd],
         agent_session_id: summary_agent_session_id,
         adapter_transport: adapter.transport.to_s,
         loc_added: @git_end[:loc_added],
@@ -979,7 +1107,7 @@ module Harnex
         disconnections: counters[:disconnections],
         compactions: counters[:compactions],
         turn_count: @injected_count,
-        tool_calls: counters[:tool_calls],
+        tool_calls: summary_tool_calls(counters),
         commands_executed: counters[:commands_executed],
         rate_limits: @rate_limits,
         output_lines: output_measurements[:lines],
@@ -1027,6 +1155,19 @@ module Harnex
         (adapter.thread_id if adapter.respond_to?(:thread_id))
     end
 
+    def summary_agent_provider
+      @usage_summary[:agent_provider] || adapter.provider
+    end
+
+    def summary_model
+      meta_hash["model"] || @usage_summary[:model] ||
+        (adapter.current_model if adapter.respond_to?(:current_model))
+    end
+
+    def summary_tool_calls(counters)
+      @usage_summary[:tool_calls] || counters[:tool_calls]
+    end
+
     def summary_predicted_payload
       predicted = meta_hash["predicted"]
       predicted.is_a?(Hash) ? predicted : {}
@@ -1060,13 +1201,13 @@ module Harnex
       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.
+    # Structured adapters emit usage directly (JSON-RPC token snapshots,
+    # Pi RPC stats). PTY adapters parse transcript tails when supported.
     def collect_session_summary
       if adapter.transport == :stdio_jsonrpc
         summary_from_token_usage
+      elsif adapter.respond_to?(:collect_session_summary)
+        adapter.collect_session_summary
       else
         adapter.parse_session_summary(transcript_tail)
       end

data/lib/harnex/terminal_status.rb

@@ -0,0 +1,202 @@
+require "json"
+require "time"
+
+module Harnex
+  module TerminalStatus
+    module_function
+
+    def resolve(id:, repo_root: Dir.pwd)
+      normalized_id = Harnex.normalize_id(id)
+      root = File.expand_path(repo_root.to_s.empty? ? Dir.pwd : repo_root)
+
+      latest_summary = nil
+      latest_summary_path = nil
+      latest_history = nil
+
+      history_paths(root).each do |path|
+        summary, history = scan_dispatch_path(path, normalized_id)
+        if newer_summary?(summary, latest_summary)
+          latest_summary = summary
+          latest_summary_path = path
+        end
+        latest_history = history if newer_history?(history, latest_history)
+      end
+
+      summary_path = latest_history && latest_history["summary_out_path"].to_s.strip
+      if summary_path && !summary_path.empty? && File.file?(summary_path)
+        summary, = scan_dispatch_path(summary_path, normalized_id)
+        if newer_summary?(summary, latest_summary)
+          latest_summary = summary
+          latest_summary_path = summary_path
+        end
+      end
+
+      return build_from_summary(latest_summary, latest_summary_path, root) if latest_summary
+      return build_from_history(latest_history, root) if latest_history
+
+      nil
+    end
+
+    def unknown(id:, repo_root: Dir.pwd)
+      {
+        "id" => Harnex.normalize_id(id),
+        "repo_root" => File.expand_path(repo_root.to_s.empty? ? Dir.pwd : repo_root),
+        "state" => "unknown",
+        "terminal" => false,
+        "task_complete" => false,
+        "exit" => nil,
+        "exit_code" => nil,
+        "summary_out" => nil,
+        "started_at" => nil,
+        "ended_at" => nil,
+        "source" => "none"
+      }
+    end
+
+    def history_paths(repo_root)
+      local_path = DispatchHistory.path_for(repo_root)
+      return [local_path] if File.file?(local_path)
+
+      global_path = DispatchHistory.global_path
+      return [global_path] if File.file?(global_path)
+
+      []
+    rescue StandardError
+      []
+    end
+
+    def scan_dispatch_path(path, id)
+      summary_record = nil
+      history_record = nil
+
+      File.foreach(path) do |line|
+        record = JSON.parse(line)
+        next unless record.is_a?(Hash)
+
+        if summary_record?(record) && record.dig("meta", "id").to_s == id
+          summary_record = record
+        elsif history_record?(record) && record["id"].to_s == id
+          history_record = record
+        end
+      rescue JSON::ParserError
+        next
+      end
+
+      [summary_record, history_record]
+    rescue Errno::ENOENT
+      [nil, nil]
+    end
+
+    def summary_record?(record)
+      record["meta"].is_a?(Hash) && record["actual"].is_a?(Hash)
+    end
+
+    def history_record?(record)
+      record["schema_version"] == 1 && record.key?("status")
+    end
+
+    def newer_summary?(candidate, current)
+      return false unless candidate
+      return true unless current
+
+      summary_time(candidate) >= summary_time(current)
+    end
+
+    def newer_history?(candidate, current)
+      return false unless candidate
+      return true unless current
+
+      history_time(candidate) >= history_time(current)
+    end
+
+    def summary_time(record)
+      parse_time(record.dig("meta", "ended_at")) || parse_time(record.dig("meta", "started_at")) || Time.at(0)
+    end
+
+    def history_time(record)
+      parse_time(record["ended_at"]) || parse_time(record["started_at"]) || Time.at(0)
+    end
+
+    def parse_time(value)
+      Time.iso8601(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    def build_from_summary(record, summary_path, fallback_repo_root)
+      meta = record["meta"] || {}
+      actual = record["actual"] || {}
+      state = classify_summary_state(actual)
+      {
+        "id" => meta["id"].to_s,
+        "repo_root" => meta["repo"] || fallback_repo_root,
+        "state" => state,
+        "terminal" => state != "unknown",
+        "task_complete" => !!actual["task_complete"],
+        "exit" => blank_to_nil(actual["exit"]),
+        "exit_code" => actual["exit_code"],
+        "summary_out" => summary_path,
+        "started_at" => meta["started_at"],
+        "ended_at" => meta["ended_at"],
+        "source" => "summary_out"
+      }
+    end
+
+    def classify_summary_state(actual)
+      exit = actual["exit"].to_s
+      exit_code = actual["exit_code"]
+
+      return "completed" if exit == "success"
+      return "completed" if exit.empty? && exit_code == 0
+      return "failed" unless exit.empty? && exit_code.nil?
+
+      "unknown"
+    end
+
+    def build_from_history(record, fallback_repo_root)
+      status = record["status"].to_s
+      state =
+        case status
+        when "completed"
+          "completed"
+        when "failed", "timeout", "killed"
+          "failed"
+        else
+          "unknown"
+        end
+      {
+        "id" => record["id"].to_s,
+        "repo_root" => fallback_repo_root,
+        "state" => state,
+        "terminal" => state != "unknown",
+        "task_complete" => record["terminal_event"].to_s == "task_complete",
+        "exit" => history_exit(status),
+        "exit_code" => nil,
+        "summary_out" => blank_to_nil(record["summary_out_path"]),
+        "started_at" => record["started_at"],
+        "ended_at" => record["ended_at"],
+        "source" => "dispatch_history"
+      }
+    end
+
+    def history_exit(status)
+      case status
+      when "completed"
+        "success"
+      when "timeout"
+        "timeout"
+      when "killed"
+        "killed"
+      when "failed"
+        "failure"
+      else
+        nil
+      end
+    end
+
+    def blank_to_nil(value)
+      text = value.to_s
+      text.empty? ? nil : text
+    end
+  end
+end

data/lib/harnex/version.rb

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