harnex 0.7.14 → 0.9.0

data/lib/harnex/runtime/session.rb

@@ -23,7 +23,7 @@ module Harnex
       terminal_tokens terminal_percent peak_tokens peak_percent
     ].freeze
     CONTEXT_SAMPLE_STATUSES = %w[observed estimated missing].freeze
-    ATTEMPT_KINDS = %w[initial retry fix review superseding].freeze
+    ATTEMPT_KINDS = %w[initial retry fix review fallback superseding].freeze
     SESSION_SUMMARY_SIGNAL_FIELDS = %i[
       input_tokens output_tokens reasoning_tokens cached_tokens total_tokens
       agent_session_id cost_usd
@@ -183,6 +183,7 @@ module Harnex
 
     def run(validate_binary: true)
       validate_binary! if validate_binary
+      prune_retained_logs
       prepare_output_log
       prepare_events_log
 
@@ -205,6 +206,7 @@ module Harnex
       @server = ApiServer.new(self)
       @server.start
       persist_registry
+      append_dispatch_start_record
 
       stdin_state = STDIN.tty? ? STDIN.raw! : nil
       watch_thread = start_watch_thread
@@ -474,6 +476,7 @@ module Harnex
       @server = ApiServer.new(self)
       @server.start
       persist_registry
+      append_dispatch_start_record
 
       watch_thread = start_watch_thread
       @inbox.start
@@ -1152,6 +1155,13 @@ module Harnex
       @output_log_failed = false
     end
 
+    def prune_retained_logs
+      Harnex::Retention.auto_prune(
+        repo_root: repo_root,
+        current_paths: [output_log_path, events_log_path]
+      )
+    end
+
     def prepare_events_log
       @events_log&.close unless @events_log&.closed?
       @events_log = File.open(events_log_path, "ab")
@@ -1245,7 +1255,9 @@ module Harnex
     end
 
     def emit_summary_event
-      emit_event("summary", path: summary_out, exit: @exit_reason)
+      payload = { path: dispatch_history_path, exit: @exit_reason }
+      payload[:mirror_path] = summary_out if summary_out
+      emit_event("summary", **payload)
     end
 
     def emit_attempt_finished(attempt)
@@ -1282,9 +1294,9 @@ module Harnex
         warn("harnex: failed to collect session-end telemetry: #{e.message}")
       end
       @exit_reason ||= classify_exit
-      record = build_summary_record
+      record = DispatchHistory.build_record(self)
+      append_dispatch_history_record(record)
       append_summary_record(record)
-      append_dispatch_history_record
       emit_summary_event
       emit_attempt_finished(record.fetch(:attempt))
       emit_exit_event
@@ -1579,10 +1591,30 @@ module Harnex
       cost_source ||= "provider_reported" if !@usage_summary[:cost_usd].nil?
       cost_source ||= summary_string(declared["cost_source"]) || "caller_estimate" if status == "estimated"
 
+      cost_price_as_of = nil
+      if values[:cost_usd].nil? && %w[observed zero].include?(status)
+        priced = Pricing.compute(
+          provider: summary_agent_provider,
+          model: summary_model,
+          input_tokens: values[:input_tokens],
+          output_tokens: values[:output_tokens],
+          cached_tokens: values[:cached_tokens],
+          service_tier: summary_service_tier,
+          context_tokens: @context_summary[:peak_tokens],
+          input_includes_cached: adapter.usage_input_includes_cached?
+        )
+        if priced
+          values[:cost_usd] = priced[:cost_usd]
+          cost_source = "price_table"
+          cost_price_as_of = priced[:as_of]
+        end
+      end
+
       {
         "status" => status,
         "cost_usd" => values[:cost_usd],
         "cost_source" => cost_source,
+        "cost_price_as_of" => cost_price_as_of,
         "input_tokens" => values[:input_tokens],
         "output_tokens" => values[:output_tokens],
         "cached_input_tokens" => values[:cached_tokens],
@@ -1760,6 +1792,101 @@ module Harnex
       @exit_reason == "success"
     end
 
+    def attempt_chain_summary
+      @attempt_chain_summary ||= begin
+        current = {
+          id: id,
+          parent_dispatch_id: summary_string(meta_hash["parent_dispatch_id"]) || @parent_harnex_id,
+          kind: summary_attempt_kind,
+          outcome: summary_attempt_succeeded? ? "succeeded" : "failed"
+        }
+        index = historical_attempt_index
+        nodes = [current]
+        seen = {}
+        seen[current[:id]] = true if current[:id]
+        parent = current[:parent_dispatch_id]
+        immediate_parent = nil
+
+        while parent && !seen[parent]
+          record = index[parent]
+          break unless record
+
+          node = historical_attempt_node(record)
+          break unless node
+
+          immediate_parent ||= node
+          nodes << node
+          seen[node[:id]] = true if node[:id]
+          parent = node[:parent_dispatch_id]
+        end
+
+        {
+          attempts_total: nodes.length,
+          attempts_succeeded: nodes.count { |node| node[:outcome] == "succeeded" },
+          attempts_failed: nodes.count { |node| node[:outcome] == "failed" },
+          fallback_triggered: nodes.any? { |node| node[:kind] == "fallback" },
+          recovered: current[:outcome] == "succeeded" && immediate_parent&.dig(:outcome) == "failed"
+        }
+      end
+    end
+
+    def historical_attempt_index
+      path = dispatch_history_path
+      return {} unless File.file?(path)
+
+      records = {}
+      duplicates = {}
+      File.foreach(path) do |line|
+        record = JSON.parse(line)
+        next unless DispatchHistory.end_record?(record)
+
+        dispatch_id = summary_string(record["id"])
+        next unless dispatch_id
+
+        if records.key?(dispatch_id)
+          records.delete(dispatch_id)
+          duplicates[dispatch_id] = true
+        elsif !duplicates.key?(dispatch_id)
+          records[dispatch_id] = record
+        end
+      rescue JSON::ParserError
+        next
+      end
+      records
+    rescue StandardError
+      {}
+    end
+
+    def historical_attempt_node(record)
+      attempt = record["attempt"].is_a?(Hash) ? record["attempt"] : {}
+      meta = record["meta"].is_a?(Hash) ? record["meta"] : {}
+      dispatch_id = summary_string(record["id"])
+      return nil unless dispatch_id
+
+      {
+        id: dispatch_id,
+        parent_dispatch_id: summary_string(attempt["parent_dispatch_id"]) || summary_string(meta["parent_dispatch_id"]),
+        kind: summary_string(attempt["kind"]),
+        outcome: historical_attempt_outcome(record, attempt)
+      }
+    end
+
+    def historical_attempt_outcome(record, attempt)
+      case summary_string(attempt["status"])
+      when "succeeded"
+        "succeeded"
+      when "failed"
+        "failed"
+      else
+        case summary_string(record["status"])
+        when "completed"
+          "succeeded"
+        when "failed", "timeout", "killed"
+          "failed"
+        end
+      end
+    end
+
     def accepted_throughput_tokens_per_s(total_tokens, duration_s, accepted)
       return nil unless accepted && total_tokens.is_a?(Numeric) && duration_s.to_f.positive?
 
@@ -1783,6 +1910,7 @@ module Harnex
     def build_summary_reliability
       counters = reliability_event_counters
       real_disconnections = counters[:disconnections].to_i
+      chain = attempt_chain_summary
       {
         "adapter_close" => summary_adapter_close(real_disconnections),
         "real_disconnections" => real_disconnections,
@@ -1790,7 +1918,7 @@ module Harnex
         "stalls" => counters[:stalls].to_i,
         "force_resumes" => counters[:force_resumes].to_i,
         "compactions" => counters[:compactions].to_i,
-        "recovered" => false
+        "recovered" => chain[:recovered]
       }
     end
 
@@ -1799,7 +1927,7 @@ module Harnex
       output_measurements = summary_output_measurements
       accepted = outcome["status"] == "accepted"
       duration_s = @ended_at ? (@ended_at - @started_at).to_i : nil
-      attempt_succeeded = summary_attempt_succeeded?
+      chain = attempt_chain_summary
       total_tokens = @usage_summary[:total_tokens]
 
       actual = {
@@ -1837,9 +1965,9 @@ module Harnex
         event_records: @events_log_seq,
         output_log_path: output_log_path,
         events_log_path: events_log_path,
-        attempts_total: 1,
-        attempts_succeeded: attempt_succeeded ? 1 : 0,
-        attempts_failed: attempt_succeeded ? 0 : 1,
+        attempts_total: chain[:attempts_total],
+        attempts_succeeded: chain[:attempts_succeeded],
+        attempts_failed: chain[:attempts_failed],
         retry_count: counters[:retries],
         throttle_429_count: counters[:throttle_429],
         disconnect_count: counters[:disconnections],
@@ -1847,7 +1975,7 @@ module Harnex
         throughput_successes_per_h: accepted_throughput_successes_per_h(duration_s, accepted),
         retry_tax_pct: counters[:retries].to_i.zero? ? 0.0 : nil,
         unattributed: attribution["status"] != "complete",
-        fallback_triggered: false
+        fallback_triggered: chain[:fallback_triggered]
       }
       actual
     end
@@ -1981,6 +2109,8 @@ module Harnex
       meta.is_a?(Hash) ? meta : {}
     end
 
+    # Explicit-only mirror: the identical end record lands here in addition
+    # to the tracked stream when --summary-out is configured.
     def append_summary_record(record)
       return unless summary_out
 
@@ -1993,13 +2123,26 @@ 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))
+    def append_dispatch_start_record
+      DispatchHistory.append(dispatch_history_path, DispatchHistory.build_start_record(self))
+    rescue StandardError => e
+      warn("harnex: failed to write dispatch start record: #{e.message}")
+    end
+
+    def append_dispatch_history_record(record)
+      DispatchHistory.append(dispatch_history_path, record)
     rescue StandardError => e
       warn("harnex: failed to write dispatch history: #{e.message}")
     end
 
+    # One canonical stream per session: the start row and the end row must
+    # land in the same file so readers can pair them. repo_root — not the
+    # launch cwd — is the root that registry, events, and default summary
+    # paths already key off.
+    def dispatch_history_path
+      @dispatch_history_path ||= DispatchHistory.path_for(repo_root)
+    end
+
     def normalized_usage_summary(summary)
       summary ||= {}
       USAGE_FIELDS.to_h { |field| [field, summary[field] || summary[field.to_s]] }

data/lib/harnex/terminal_status.rb

@@ -78,8 +78,18 @@ module Harnex
       File.foreach(path) do |line|
         record = JSON.parse(line)
         next unless record.is_a?(Hash)
+        next if DispatchHistory.start_record?(record)
 
-        if summary_record?(record) && record.dig("meta", "id").to_s == id
+        # Branch on record_type first: a v2 end row carries both the thin
+        # envelope and the rich sections, so it resolves as summary and
+        # history in one shot — never double-counted via the legacy
+        # duck-types below, which stay for pre-v2 files.
+        if record["record_type"] == "dispatch_end"
+          next unless record["id"].to_s == id
+
+          history_record = record
+          summary_record = record if summary_record?(record)
+        elsif 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
@@ -97,6 +107,7 @@ module Harnex
       record["meta"].is_a?(Hash) && record["actual"].is_a?(Hash)
     end
 
+    # Legacy thin end rows predate record_type.
     def history_record?(record)
       record["schema_version"] == 1 && record.key?("status")
     end

data/lib/harnex/version.rb

@@ -1,4 +1,4 @@
 module Harnex
-  VERSION = "0.7.14"
-  RELEASE_DATE = "2026-07-15"
+  VERSION = "0.9.0"
+  RELEASE_DATE = "2026-08-03"
 end

data/lib/harnex.rb

@@ -5,6 +5,9 @@ require "open3"
 require_relative "harnex/version"
 require_relative "harnex/core"
 require_relative "harnex/dispatch_history"
+require_relative "harnex/config"
+require_relative "harnex/retention"
+require_relative "harnex/pricing"
 require_relative "harnex/terminal_status"
 require_relative "harnex/artifact_report"
 require_relative "harnex/context_telemetry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harnex
 version: !ruby/object:Gem::Version
-  version: 0.7.14
+  version: 0.9.0
 platform: ruby
 authors:
 - Jikku Jose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-15 00:00:00.000000000 Z
+date: 2026-08-02 00:00:00.000000000 Z
 dependencies: []
 description: A local PTY harness that wraps terminal AI agents (Claude, Codex, Pi)
   and adds a control plane for discovery, messaging, and coordination.
@@ -26,6 +26,10 @@ files:
 - TECHNICAL.md
 - bin/gem-push
 - bin/harnex
+- docs/codex-appserver.md
+- docs/configuration.md
+- docs/dispatch-telemetry.md
+- docs/events.md
 - guides/01_dispatch.md
 - guides/02_chain.md
 - guides/03_buddy.md
@@ -60,10 +64,13 @@ files:
 - lib/harnex/commands/wait.rb
 - lib/harnex/commands/watch.rb
 - lib/harnex/commands/watch_presets.rb
+- lib/harnex/config.rb
 - lib/harnex/context_telemetry.rb
 - lib/harnex/core.rb
 - lib/harnex/dispatch_history.rb
 - lib/harnex/orchestration.rb
+- lib/harnex/pricing.rb
+- lib/harnex/retention.rb
 - lib/harnex/runtime/api_server.rb
 - lib/harnex/runtime/file_change_hook.rb
 - lib/harnex/runtime/inbox.rb