harnex 0.8.0 → 0.10.0

data/lib/harnex/runtime/session.rb

@@ -1,6 +1,7 @@
 require "io/console"
 require "json"
 require "pty"
+require "shellwords"
 
 module Harnex
   class Session
@@ -23,7 +24,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
@@ -86,10 +87,11 @@ module Harnex
     end
 
     attr_reader :repo_root, :launch_cwd, :child_cwd, :host, :port, :session_id, :token, :command, :pid, :id, :adapter, :watch,
-                :inbox, :description, :meta, :summary_out, :artifact_report_path, :output_log_path, :events_log_path,
-                :started_at, :ended_at, :exit_code, :term_signal, :require_artifact_report
+                :inbox, :description, :meta, :artifact_report_path, :artifact_claims_path,
+                :output_log_path, :events_log_path, :started_at, :ended_at, :exit_code, :term_signal,
+                :require_artifact_report
 
-    def initialize(adapter:, command:, repo_root:, host:, port: nil, id: DEFAULT_ID, watch: nil, description: nil, meta: nil, summary_out: nil, artifact_report_path: nil, require_artifact_report: false, inbox_ttl: Inbox::DEFAULT_TTL, auto_stop: false, launch_cwd: nil, child_cwd: nil)
+    def initialize(adapter:, command:, repo_root:, host:, port: nil, id: DEFAULT_ID, watch: nil, description: nil, meta: nil, artifact_report_path: nil, require_artifact_report: false, inbox_ttl: Inbox::DEFAULT_TTL, auto_stop: false, launch_cwd: nil, child_cwd: nil)
       @adapter = adapter
       @command = command
       @repo_root = repo_root
@@ -97,22 +99,29 @@ module Harnex
       @child_cwd = child_cwd.to_s.empty? ? nil : File.expand_path(child_cwd)
       @host = host
       @id = Harnex.normalize_id(id)
+      @session_id = SecureRandom.hex(8)
       @watch = watch
       @description = description.to_s.strip
       @description = nil if @description.empty?
       @meta = meta
-      @summary_out = summary_out.to_s.strip
-      @summary_out = nil if @summary_out.empty?
-      @artifact_report_path = artifact_report_path.to_s.strip
-      @artifact_report_path = nil if @artifact_report_path.empty?
-      @artifact_report_path = File.expand_path(@artifact_report_path, repo_root) if @artifact_report_path
+      configured_report_path = artifact_report_path.to_s.strip
+      @artifact_report_path = if configured_report_path.empty?
+                                Harnex::ArtifactReport.default_path(
+                                  repo_root: repo_root,
+                                  id: @id,
+                                  session_id: @session_id
+                                )
+                              else
+                                File.expand_path(configured_report_path, repo_root)
+                              end
+      @artifact_claims_path = Harnex::ArtifactReport.claims_path(@artifact_report_path)
+      FileUtils.mkdir_p(File.dirname(@artifact_report_path))
       @require_artifact_report = !!require_artifact_report
-      raise ArgumentError, "require_artifact_report requires artifact_report_path" if @require_artifact_report && !@artifact_report_path
-      @artifact_report_start_fingerprint = Harnex::ArtifactReport.fingerprint(@artifact_report_path) if @artifact_report_path
+      @artifact_report_start_fingerprint = Harnex::ArtifactReport.fingerprint(@artifact_report_path)
+      @artifact_claims_start_fingerprint = Harnex::ArtifactReport.fingerprint(@artifact_claims_path)
       @registry_path = Harnex.registry_path(repo_root, @id)
       @output_log_path = Harnex.output_log_path(repo_root, @id)
       @events_log_path = Harnex.events_log_path(repo_root, @id)
-      @session_id = SecureRandom.hex(8)
       @token = SecureRandom.hex(16)
       @port = Harnex.allocate_port(repo_root, @id, port, host: host)
       @mutex = Mutex.new
@@ -129,6 +138,12 @@ module Harnex
       @events_log = nil
       @events_log_seq = 0
       @event_counters = EventCounters.new
+      @observed_commands_mutex = Mutex.new
+      @observed_commands = []
+      @artifact_claims = {}
+      @artifact_claims_loaded = false
+      @artifact_report_generated = false
+      @artifact_report_write_error = nil
       @git_start = {}
       @git_end = {}
       @usage_summary = {}
@@ -183,6 +198,7 @@ module Harnex
 
     def run(validate_binary: true)
       validate_binary! if validate_binary
+      prune_retained_logs
       prepare_output_log
       prepare_events_log
 
@@ -256,7 +272,9 @@ module Harnex
         last_injected_at: @last_injected_at&.iso8601,
         injected_count: @injected_count,
         output_log_path: output_log_path,
-        events_log_path: events_log_path
+        events_log_path: events_log_path,
+        artifact_report_path: artifact_report_path,
+        artifact_claims_path: artifact_claims_path
       }
       payload.merge!(log_activity_snapshot)
       payload[:description] = description if description
@@ -426,7 +444,7 @@ module Harnex
         @state_machine.force_busy!
         @injected_count += 1
         @last_injected_at = Time.now
-        persist_registry
+        refresh_registry
       end
 
       emit_send_event(dispatch.fetch(:prompt, text), force: payload[:force])
@@ -570,6 +588,7 @@ module Harnex
       when "item/completed"
         emit_event("item_completed", item: params["item"])
         @event_counters.record_item(params["item"])
+        record_observed_command(params["item"])
         text = render_item_text(params["item"])
         record_synthesized(text) if text
       when "thread/compacted"
@@ -627,6 +646,7 @@ module Harnex
           artifact_report_status: assessment[:report_status],
           diagnostics: assessment[:diagnostics]
         )
+        enforce_required_artifact_report!
         return false
       end
 
@@ -640,9 +660,15 @@ module Harnex
         @completion_diagnostics = []
       end
 
+      # Persist proof before publishing task_complete. A coordinator that sees
+      # the completion event can immediately validate the harness-authored file.
+      enforce_required_artifact_report!
+      return false if task_failed?
+
       event_payload = payload.dup
       event_payload[:outcome_class] = @completion_outcome_class if @completion_outcome_class
       event_payload[:artifact_report_status] = @completion_report_status if @completion_report_status
+      event_payload[:artifact_report_path] = artifact_report_path
       emit_event("task_complete", **event_payload)
       true
     end
@@ -655,85 +681,30 @@ module Harnex
     end
 
     def assess_completion_proof
-      report_result = artifact_report_path ? Harnex::ArtifactReport.validate(artifact_report_path, final: true) : nil
-      report_fresh = report_result && report_result.status != "missing" && artifact_report_fresh?
-      report_stale = report_result && Harnex::ArtifactReport.accepted_final?(report_result) && !report_fresh
-      report_status = report_stale ? "stale" : report_result&.status
-      report_diagnostics = if report_stale
-                             [artifact_report_stale_diagnostic]
-                           else
-                             report_result&.diagnostics || []
-                           end
-
-      if report_result
-        if report_fresh && Harnex::ArtifactReport.accepted_final?(report_result)
-          return {
-            accepted: true,
-            outcome_class: "completed_with_proof",
-            report_status: "accepted",
-            diagnostics: []
-          }
-        end
-
-        report_outcome = Harnex::ArtifactReport.outcome_status(report_result)
-        if report_fresh && report_outcome == "rejected"
-          return {
-            accepted: false,
-            outcome_class: "report_rejected",
-            report_status: "rejected",
-            diagnostics: report_result.diagnostics
-          }
-        end
-
-        if require_artifact_report
-          outcome_class = report_result.status == "missing" ? "report_missing" : "report_invalid"
-          return {
-            accepted: false,
-            outcome_class: outcome_class,
-            report_status: report_status,
-            diagnostics: report_diagnostics
-          }
-        end
-      elsif require_artifact_report
-        return {
-          accepted: false,
-          outcome_class: "report_missing",
-          report_status: "missing",
-          diagnostics: []
-        }
-      end
-
-      if structured_activity_observed? || git_activity_observed?
+      refresh_git_end_snapshot
+      if structured_activity_observed? || git_activity_observed?(@git_end)
         {
           accepted: true,
           outcome_class: "completed_with_activity",
-          report_status: report_status,
+          report_status: nil,
           diagnostics: []
         }
       else
         {
           accepted: false,
           outcome_class: "completed_no_activity",
-          report_status: report_status,
-          diagnostics: report_diagnostics
+          report_status: "rejected",
+          diagnostics: []
         }
       end
     end
 
-    def artifact_report_fresh?
-      current = Harnex::ArtifactReport.fingerprint(artifact_report_path)
-      return false unless current
-      return true unless @artifact_report_start_fingerprint
-
-      current != @artifact_report_start_fingerprint
-    end
-
-    def artifact_report_stale_diagnostic
-      {
-        "code" => "report_stale",
-        "path" => "$",
-        "message" => "artifact report was not created or updated during this session"
-      }
+    # Fingerprints now protect only optional claims ingestion. They are never
+    # an acceptance gate: Harnex always replaces the receipt with fresh
+    # observed state for this session.
+    def artifact_input_fresh?(path, start_fingerprint)
+      current = Harnex::ArtifactReport.fingerprint(path)
+      current && (!start_fingerprint || current != start_fingerprint)
     end
 
     def structured_activity_observed?
@@ -741,10 +712,10 @@ module Harnex
       counters[:commands_executed].to_i.positive? || counters[:tool_calls].to_i.positive?
     end
 
-    def git_activity_observed?
+    def git_activity_observed?(snapshot = nil)
       return false if @git_start[:sha].to_s.empty?
 
-      snapshot = Harnex.git_capture_end(repo_root, @git_start[:sha])
+      snapshot ||= Harnex.git_capture_end(repo_root, @git_start)
       snapshot[:commits].to_i.positive? || Array(snapshot[:changed_paths]).any? ||
         (!snapshot[:sha].to_s.empty? && snapshot[:sha].to_s != @git_start[:sha].to_s)
     end
@@ -752,7 +723,7 @@ module Harnex
     def completion_failure_message(outcome_class)
       case outcome_class
       when "completed_no_activity"
-        "turn completed without command/tool execution, Git delta, or accepted artifact report"
+        "turn completed without command/tool execution or Git delta"
       when "report_missing"
         "required artifact report is missing"
       when "report_rejected"
@@ -941,6 +912,33 @@ module Harnex
       end
     end
 
+    def record_observed_command(item)
+      return unless item.is_a?(Hash) && item["type"] == "commandExecution"
+
+      command = item["command"]
+      command = Shellwords.join(command.map(&:to_s)) if command.is_a?(Array)
+      command = command.to_s
+      exit_code = item["exitCode"]
+      exit_code = item["exit_code"] if exit_code.nil?
+      exit_code = Integer(exit_code)
+      return if command.empty?
+
+      duration = item["duration_s"]
+      duration = item["durationMs"].to_f / 1000.0 if duration.nil? && item["durationMs"]
+      observed = {
+        "cmd" => command,
+        "exit_code" => exit_code,
+        "status" => item["status"],
+        "duration_s" => duration
+      }.compact
+      @observed_commands_mutex.synchronize do
+        @observed_commands << observed
+        @observed_commands = @observed_commands.last(Harnex::ArtifactReport::MAX_COMMANDS)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
     def summarize(value)
       str = value.is_a?(String) ? value : JSON.generate(value)
       str.length > 120 ? "#{str[0, 117]}..." : str
@@ -1005,7 +1003,9 @@ module Harnex
       if artifact_report_path
         env["HARNEX_ARTIFACT_REPORT_PATH"] = artifact_report_path
         env["HARNEX_VALIDATION_REPORT_PATH"] = artifact_report_path
+        env["HARNEX_ARTIFACT_CLAIMS_PATH"] = artifact_claims_path
         env["HARNEX_ARTIFACT_REPORT_SCHEMA"] = Harnex::ArtifactReport::SCHEMA
+        env["HARNEX_ARTIFACT_REPORT_MODE"] = "observed_state"
         env["HARNEX_ARTIFACT_REPORT_REQUIRED"] = "1" if require_artifact_report
       end
       env["HARNEX_SPAWNER_PANE"] = ENV["TMUX_PANE"] if ENV["TMUX_PANE"]
@@ -1045,7 +1045,7 @@ module Harnex
       injected_count = @mutex.synchronize do
         @injected_count += 1
         @last_injected_at = Time.now
-        persist_registry
+        refresh_registry
         @injected_count
       end
 
@@ -1071,6 +1071,17 @@ module Harnex
       Harnex.write_registry(@registry_path, payload)
     end
 
+    # Post-injection registry refresh. By the time this runs the prompt has
+    # already reached the agent, so a failed bookkeeping write must not report
+    # the send as failed — that would make an orchestrator retry a turn the
+    # agent is already working on. Startup persistence stays strict: a session
+    # nothing can discover should fail loudly instead of running unreachable.
+    def refresh_registry
+      persist_registry
+    rescue StandardError => e
+      warn("harnex: failed to refresh session registry: #{e.message}")
+    end
+
     def persist_exit_status
       return unless defined?(@exit_code) && !@exit_code.nil?
 
@@ -1125,19 +1136,38 @@ module Harnex
         rescue EOFError, Errno::EIO, IOError
           break
         end
+      rescue StandardError => e
+        warn("harnex: input forwarder stopped: #{e.class}: #{e.message}")
       end
     end
 
+    # Draining the PTY is the one job this thread must never stop doing: if it
+    # dies, the kernel buffer fills and the wrapped agent blocks forever on
+    # write, which looks like the agent hanging rather than the harness
+    # failing. Echoing to our own stdout is best-effort by comparison —
+    # Errno::EPIPE/EBADF (not IOError subclasses, so they used to escape and
+    # kill the thread) just mean nobody is watching, e.g. `harnex run … | head`.
     def start_output_thread
       Thread.new do
+        echo = true
         loop do
           chunk = @reader.readpartial(4096)
           record_output(chunk)
-          STDOUT.write(chunk)
-          STDOUT.flush
-        rescue EOFError, Errno::EIO, IOError
-          break
+          next unless echo
+
+          begin
+            STDOUT.write(chunk)
+            STDOUT.flush
+          rescue StandardError => e
+            echo = false
+            warn("harnex: stopped mirroring output to stdout: #{e.message}")
+          end
         end
+      rescue EOFError, Errno::EIO, IOError
+        nil
+      rescue StandardError => e
+        # Never disappear quietly; a dead reader must be diagnosable.
+        warn("harnex: output reader stopped: #{e.class}: #{e.message}")
       end
     end
 
@@ -1154,6 +1184,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, artifact_report_path, artifact_claims_path]
+      )
+    end
+
     def prepare_events_log
       @events_log&.close unless @events_log&.closed?
       @events_log = File.open(events_log_path, "ab")
@@ -1219,19 +1256,34 @@ module Harnex
     end
 
     def emit_git_start_event
-      @git_start = Harnex.git_capture_start(repo_root)
+      @git_start = Harnex.git_capture_start(
+        repo_root,
+        exclude_paths: git_observation_excluded_paths
+      )
       return if @git_start.empty?
 
       emit_event("git", phase: "start", sha: @git_start[:sha], branch: @git_start[:branch])
     end
 
+    def git_observation_excluded_paths
+      git_root = DispatchHistory.find_git_root(repo_root)
+      return [] unless git_root
+
+      root = File.expand_path(git_root)
+      prefix = "#{root}#{File::SEPARATOR}"
+      [dispatch_history_path, artifact_report_path, artifact_claims_path].filter_map do |path|
+        absolute = File.expand_path(path.to_s, root)
+        absolute.delete_prefix(prefix) if absolute.start_with?(prefix)
+      end.uniq
+    end
+
     def emit_session_end_telemetry
       summary = collect_session_summary
       @usage_summary = normalized_usage_summary(summary)
       @context_summary = normalized_context_summary(summary)
       emit_event("usage", **@usage_summary)
 
-      @git_end = Harnex.git_capture_end(repo_root, @git_start[:sha])
+      @git_end = Harnex.git_capture_end(repo_root, @git_start)
       return if @git_end.empty?
 
       emit_event(
@@ -1242,12 +1294,15 @@ module Harnex
         loc_removed: @git_end[:loc_removed],
         files_changed: @git_end[:files_changed],
         changed_paths: @git_end[:changed_paths],
-        commits: @git_end[:commits]
+        commits: @git_end[:commits],
+        start_dirty: @git_end[:start_dirty],
+        end_dirty: @git_end[:end_dirty],
+        worktree_changed: @git_end[:worktree_changed]
       )
     end
 
     def emit_summary_event
-      emit_event("summary", path: summary_out, exit: @exit_reason)
+      emit_event("summary", path: dispatch_history_path, exit: @exit_reason)
     end
 
     def emit_attempt_finished(attempt)
@@ -1283,10 +1338,10 @@ module Harnex
         @context_summary = normalized_context_summary(nil)
         warn("harnex: failed to collect session-end telemetry: #{e.message}")
       end
+      enforce_required_artifact_report!
       @exit_reason ||= classify_exit
-      record = build_summary_record
-      append_summary_record(record)
-      append_dispatch_history_record
+      record = DispatchHistory.build_record(self)
+      append_dispatch_history_record(record)
       emit_summary_event
       emit_attempt_finished(record.fetch(:attempt))
       emit_exit_event
@@ -1381,48 +1436,174 @@ module Harnex
       AUTOSTOP_TEARDOWN_GRACE_SECONDS_DEFAULT
     end
 
+    # Kept under the existing method name for call-site compatibility. The
+    # worker no longer has to author or validate proof: Harnex overwrites the
+    # configured/default path with a receipt derived from observed state.
     def enforce_required_artifact_report!
-      return unless require_artifact_report
-      return if task_failed? && %w[report_missing report_invalid report_rejected].include?(@completion_outcome_class)
-
-      result = Harnex::ArtifactReport.validate(artifact_report_path, final: true)
-      report_fresh = result.status != "missing" && artifact_report_fresh?
-      report_accepted = Harnex::ArtifactReport.accepted_final?(result)
-      report_stale = report_accepted && !report_fresh
-      if report_fresh && report_accepted
-        @completion_outcome_class = "completed_with_proof"
-        @completion_report_status = "accepted"
-        @completion_diagnostics = []
-        return
-      end
+      persist_observed_receipt!
+    rescue StandardError => e
+      @artifact_report_write_error = e.message
+      warn("harnex: failed to write observed-state receipt #{artifact_report_path}: #{e.message}")
+      return if task_failed?
 
-      report_outcome = Harnex::ArtifactReport.outcome_status(result)
-      outcome_class = if report_fresh && report_outcome == "rejected"
-                        "report_rejected"
-                      elsif result.status == "missing"
-                        "report_missing"
-                      else
-                        "report_invalid"
-                      end
-      report_status = if report_stale
-                        "stale"
-                      elsif report_fresh && report_outcome == "rejected"
-                        "rejected"
-                      else
-                        result.status
-                      end
-      diagnostics = report_stale ? [artifact_report_stale_diagnostic] : result.diagnostics
+      @last_completed_at = nil
       mark_task_failed(
-        status: outcome_class,
-        error: completion_failure_message(outcome_class),
-        outcome_class: outcome_class,
-        artifact_report_status: report_status,
-        diagnostics: diagnostics
+        status: "report_invalid",
+        error: "harness could not generate the observed-state receipt",
+        outcome_class: "report_invalid",
+        artifact_report_status: "write_error",
+        diagnostics: [{
+          "code" => "receipt_write_error",
+          "path" => "$",
+          "message" => "harness could not write the observed-state receipt"
+        }]
       )
       @exit_code = 1 if @exit_code.nil? || @exit_code.zero? || @term_signal
       @term_signal = nil if @exit_code == 1
     end
 
+    def persist_observed_receipt!
+      refresh_git_end_snapshot
+      load_artifact_claims
+      successful = receipt_successful?
+      if successful
+        @completion_outcome_class = "completed_with_proof" if task_complete? || require_artifact_report
+        @completion_report_status = "accepted"
+        @completion_diagnostics = []
+      else
+        @completion_report_status ||= "rejected"
+      end
+
+      result = Harnex::ArtifactReport.write_observed(
+        artifact_report_path,
+        id: id,
+        session_id: session_id,
+        generated_at: Time.now.utc,
+        successful: successful,
+        outcome_status: receipt_outcome_status(successful),
+        outcome_summary: receipt_outcome_summary(successful),
+        git: receipt_git_payload,
+        commands: observed_commands_snapshot,
+        turn: receipt_turn_payload(successful),
+        usage: build_summary_usage,
+        claims: @artifact_claims,
+        command_observation: command_observation_status
+      )
+      @artifact_report_generated = true
+      @artifact_report_write_error = nil
+      result
+    end
+
+    def refresh_git_end_snapshot
+      return @git_end = {} if @git_start[:sha].to_s.empty?
+
+      snapshot = Harnex.git_capture_end(repo_root, @git_start)
+      @git_end = snapshot unless snapshot.empty?
+      @git_end
+    end
+
+    def load_artifact_claims
+      return @artifact_claims if @artifact_claims_loaded
+
+      @artifact_claims_loaded = true
+      candidates = [
+        [artifact_claims_path, @artifact_claims_start_fingerprint],
+        [artifact_report_path, @artifact_report_start_fingerprint]
+      ]
+      candidates.each do |path, start_fingerprint|
+        next unless artifact_input_fresh?(path, start_fingerprint)
+
+        claims = Harnex::ArtifactReport.extract_claims(path)
+        next if claims.empty?
+
+        @artifact_claims = claims
+        break
+      end
+      @artifact_claims
+    end
+
+    def observed_commands_snapshot
+      @observed_commands_mutex.synchronize { @observed_commands.map(&:dup) }
+    end
+
+    def command_observation_status
+      adapter.transport == :stdio_jsonrpc ? "observed" : "unsupported"
+    end
+
+    def receipt_successful?
+      return false if task_failed?
+      return @exit_code.to_i.zero? unless @exit_code.nil?
+
+      task_complete?
+    end
+
+    def receipt_outcome_status(successful)
+      return "rejected" unless successful
+
+      git = receipt_git_payload
+      if git[:status] == "observed" &&
+         git[:commits].to_i.zero? &&
+         Array(git[:changed_paths]).empty? &&
+         !git[:start_sha].to_s.empty? &&
+         git[:start_sha].to_s == git[:end_sha].to_s
+        "no_change"
+      else
+        "accepted"
+      end
+    end
+
+    def receipt_outcome_summary(successful)
+      return "Harnex observed an unsuccessful completion." unless successful
+
+      if receipt_outcome_status(true) == "no_change"
+        "Harnex observed successful completion with no Git delta."
+      else
+        "Harnex observed successful completion with repository or structured activity."
+      end
+    end
+
+    def receipt_git_payload
+      start_sha = @git_start[:sha].to_s
+      end_sha = @git_end[:sha].to_s
+      return { status: "unavailable" } if start_sha.empty? || end_sha.empty?
+
+      {
+        status: "observed",
+        start_sha: start_sha,
+        end_sha: end_sha,
+        branch: @git_start[:branch],
+        changed_paths: Array(@git_end[:changed_paths]),
+        loc_added: @git_end[:loc_added],
+        loc_removed: @git_end[:loc_removed],
+        files_changed: @git_end[:files_changed],
+        commits: @git_end[:commits],
+        start_dirty: @git_end[:start_dirty],
+        end_dirty: @git_end[:end_dirty],
+        worktree_changed: @git_end[:worktree_changed]
+      }
+    end
+
+    def receipt_turn_payload(successful)
+      status = if task_failed?
+                 "failed"
+               elsif task_complete?
+                 "completed"
+               elsif !@exit_code.nil?
+                 "process_exit"
+               else
+                 "completed"
+               end
+      {
+        status: status,
+        outcome_class: @completion_outcome_class,
+        task_complete: task_complete?,
+        task_failed: task_failed?,
+        accepted: successful,
+        exit_code: @exit_code,
+        signal: @term_signal
+      }
+    end
+
     def normalize_work_acceptance_exit_code!
       return unless task_failed? && @completion_outcome_class
 
@@ -1472,7 +1653,7 @@ module Harnex
     end
 
     def build_summary_record
-      artifact_payload = artifact_report_path ? artifact_report_summary : nil
+      artifact_payload = @artifact_report_generated ? artifact_report_summary : nil
       attribution = build_summary_attribution
       outcome = build_summary_outcome(artifact_payload)
       record = {
@@ -1581,10 +1762,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],
@@ -1661,16 +1862,20 @@ module Harnex
     end
 
     def build_summary_outcome(artifact_payload)
-      sidecar_outcome = artifact_payload&.dig("outcome") || {}
+      receipt_outcome = artifact_payload&.dig("outcome") || {}
       outcome_class, report_status = summary_proof_classification
-      proof_failure = %w[completed_no_activity report_missing report_invalid task_failed].include?(outcome_class)
-      status = proof_failure ? nil : sidecar_outcome["status"]
+      proof_failure = %w[completed_no_activity report_missing report_invalid report_rejected task_failed].include?(outcome_class)
+      harness_receipt = artifact_payload&.dig("receipt", "author") == "harnex"
+      status = receipt_outcome["status"]
+      status = nil if status == "accepted" && proof_failure
       status = "no_change" if status.nil? && !proof_failure && @git_end.key?(:changed_paths) && @git_end[:changed_paths].empty?
       status ||= "unknown"
       status = "unknown" unless Harnex::ArtifactReport::OUTCOME_STATUSES.include?(status)
-      source = if proof_failure
+      source = if harness_receipt
+                 "harnex_observed_state"
+               elsif proof_failure
                  "harnex_completion_gate"
-               elsif sidecar_outcome["status"]
+               elsif receipt_outcome["status"]
                  "artifact_report"
                else
                  "harnex_git_observation"
@@ -1681,7 +1886,7 @@ module Harnex
         "class" => outcome_class,
         "source" => source,
         "report_status" => report_status,
-        "commit_sha" => sidecar_outcome["commit_sha"] || summary_commit_sha,
+        "commit_sha" => receipt_outcome["commit_sha"] || summary_commit_sha,
         "changed_paths" => @git_end.key?(:changed_paths) ? @git_end[:changed_paths] : nil,
         "loc_added" => @git_end[:loc_added],
         "loc_removed" => @git_end[:loc_removed],
@@ -1695,13 +1900,10 @@ module Harnex
       return [@completion_outcome_class, @completion_report_status] if @completion_outcome_class
       return ["task_failed", @completion_report_status] if task_failed?
 
-      if artifact_report_path
+      if @artifact_report_generated
         result = Harnex::ArtifactReport.validate(artifact_report_path, final: true)
-        report_fresh = result.status != "missing" && artifact_report_fresh?
-        report_accepted = Harnex::ArtifactReport.accepted_final?(result)
-        return ["completed_with_proof", "accepted"] if report_fresh && report_accepted
-        return ["report_rejected", "rejected"] if report_fresh && Harnex::ArtifactReport.outcome_status(result) == "rejected"
-        return ["unknown", "stale"] if report_accepted && !report_fresh
+        return ["completed_with_proof", "accepted"] if Harnex::ArtifactReport.accepted_final?(result)
+        return ["report_rejected", "rejected"] if Harnex::ArtifactReport.outcome_status(result) == "rejected"
         return ["unknown", result.status]
       end
 
@@ -1762,6 +1964,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?
 
@@ -1785,6 +2082,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,
@@ -1792,7 +2090,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
 
@@ -1801,7 +2099,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 = {
@@ -1839,9 +2137,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],
@@ -1849,7 +2147,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
@@ -1983,34 +2281,21 @@ module Harnex
       meta.is_a?(Hash) ? meta : {}
     end
 
-    def append_summary_record(record)
-      return unless summary_out
-
-      FileUtils.mkdir_p(File.dirname(summary_out))
-      File.open(summary_out, "ab") do |file|
-        file.write(JSON.generate(record))
-        file.write("\n")
-      end
-    rescue StandardError => e
-      warn("harnex: failed to write dispatch summary #{summary_out}: #{e.message}")
-    end
-
     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
-      DispatchHistory.append(dispatch_history_path, DispatchHistory.build_record(self))
+    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.
+    # The only telemetry destination: 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 and events paths already key off.
     def dispatch_history_path
       @dispatch_history_path ||= DispatchHistory.path_for(repo_root)
     end