harnex 0.10.2 → 0.12.0

data/lib/harnex/commands/status.rb

@@ -8,6 +8,7 @@ module Harnex
   class Status
     DESCRIPTION_WIDTH = 30
     REPO_WIDTH = 20
+    REJECTED_OUTCOME_CLASSES = Session::PROOF_REJECTION_CLASSES
 
     def self.usage(program_name = "harnex status")
       <<~TEXT
@@ -30,8 +31,8 @@ module Harnex
           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.
-          `state` is process/session state; use JSON `done`/`work_state`
-          or `harnex wait --until done` for work-level completion.
+          Settled work outranks prompt state in the table: done, rejected, or failed.
+          JSON `done`/`work_state` retains the structured work-level fields.
           A prompt-like state is not a completion signal by itself.
       TEXT
     end
@@ -217,6 +218,13 @@ module Harnex
     end
 
     def table_state(session)
+      failed = task_failed?(session) || session["work_state"].to_s == "failed"
+      completed = task_complete?(session) || session["work_state"].to_s == "completed"
+      if failed || completed
+        return "rejected" if rejected_work?(session)
+        return failed ? "failed" : "done"
+      end
+
       input_state = session.dig("input_state", "state").to_s
       return input_state unless input_state.empty?
 
@@ -224,6 +232,12 @@ module Harnex
       state.empty? ? "-" : state
     end
 
+    def rejected_work?(session)
+      return true if REJECTED_OUTCOME_CLASSES.include?(session["outcome_class"].to_s)
+
+      !task_failed?(session) && session["artifact_report_status"].to_s == "rejected"
+    end
+
     def timeago(timestamp)
       return "-" if timestamp.to_s.empty?
 

data/lib/harnex/core.rb

@@ -24,6 +24,8 @@ module Harnex
   GIT_FINGERPRINT_SAMPLE_BYTES = 64 * 1024
   STATE_DIR = File.expand_path(env_value("HARNEX_STATE_DIR", default: "~/.local/state/harnex"))
   SESSIONS_DIR = File.join(STATE_DIR, "sessions")
+  COMPLETION_OUTCOMES = %w[completed rejected failed error].freeze
+  COMPLETION_MARKERS_DIR = File.join(STATE_DIR, "done")
   WatchConfig = Struct.new(:absolute_path, :display_path, :hook_message, :debounce_seconds, keyword_init: true)
   ID_ADJECTIVES = %w[
     bold blue calm cool dark dry fast gold gray green
@@ -395,6 +397,19 @@ module Harnex
     File.join(exit_dir, "#{session_file_slug(repo_root, id)}.json")
   end
 
+  def completion_marker_path(repo_root, id, outcome)
+    normalized_outcome = outcome.to_s
+    unless COMPLETION_OUTCOMES.include?(normalized_outcome)
+      raise ArgumentError, "unsupported completion outcome #{outcome.inspect}"
+    end
+
+    File.join(COMPLETION_MARKERS_DIR, "#{session_file_slug(repo_root, id)}.#{normalized_outcome}")
+  end
+
+  def completion_marker_paths(repo_root, id)
+    COMPLETION_OUTCOMES.map { |outcome| completion_marker_path(repo_root, id, outcome) }
+  end
+
   def output_log_path(repo_root, id)
     output_dir = File.join(STATE_DIR, "output")
     FileUtils.mkdir_p(output_dir)

data/lib/harnex/runtime/completion_notifier.rb

@@ -0,0 +1,137 @@
+require "time"
+
+module Harnex
+  class CompletionNotifier
+    WORK_STATES = {
+      "completed" => "completed", "rejected" => "failed",
+      "failed" => "failed", "error" => "failed"
+    }.freeze
+
+    def initialize(repo_root:, id:, session_id:, receipt_path:, hook_command: nil,
+                   started_at: Time.now, clock: nil, event_sink: nil, spawn: nil,
+                   detach: nil, atomic_write: nil, remove: nil, stderr: $stderr)
+      @repo_root = Harnex.canonical_repo_root(repo_root)
+      @id = Harnex.normalize_id(id)
+      @session_id = session_id.to_s
+      @receipt_path = receipt_path.to_s
+      @hook_command = hook_command.to_s
+      @hook_command = nil if @hook_command.empty?
+      @started_at = started_at
+      @clock = clock || -> { Time.now }
+      @event_sink = event_sink
+      @spawn = spawn || method(:spawn_hook)
+      @detach = detach || ->(pid) { Process.detach(pid) }
+      @atomic_write = atomic_write || Harnex.method(:atomic_write_json)
+      @remove = remove || ->(path) { FileUtils.rm_f(path) }
+      @stderr = stderr
+      @mutex = Mutex.new
+      @registered = false
+      @notified = false
+    end
+
+    # Registration is the stale-marker boundary for a reused repo/id pair.
+    def register!
+      @mutex.synchronize do
+        return true if @registered
+
+        Harnex.completion_marker_paths(@repo_root, @id).each do |path|
+          @remove.call(path)
+        rescue StandardError => e
+          report_error("completion marker cleanup failed", "cleanup", e, path: path)
+        end
+        @registered = true
+      end
+      true
+    end
+
+    def notify(outcome:, work_state:, outcome_class:, artifact_report_status:,
+               end_sha:, terminal_signal:)
+      outcome = outcome.to_s
+      work_state = work_state.to_s
+      expected = WORK_STATES[outcome]
+      raise ArgumentError, "unsupported completion outcome #{outcome.inspect}" unless expected
+      raise ArgumentError, "#{outcome.inspect} completion requires work_state #{expected.inspect}" unless work_state == expected
+      return false unless @mutex.synchronize do
+        @registered && !@notified ? (@notified = true) : false
+      end
+
+      now = @clock.call
+      path = Harnex.completion_marker_path(@repo_root, @id, outcome)
+      payload = {
+        schema_version: 1, id: @id, session_id: @session_id,
+        repo_root: @repo_root, outcome: outcome, work_state: work_state,
+        outcome_class: optional_string(outcome_class),
+        artifact_report_status: optional_string(artifact_report_status),
+        receipt_path: @receipt_path, end_sha: optional_string(end_sha),
+        elapsed_s: elapsed_seconds(now), terminal_signal: terminal_signal.to_s,
+        notified_at: now.utc.iso8601
+      }
+      marker_written = write_marker(path, payload)
+      hook_launched = launch_hook(payload)
+      emit("completion_notification", outcome: outcome, work_state: work_state,
+           marker_path: path, marker_written: marker_written,
+           hook_configured: !@hook_command.nil?, hook_launched: hook_launched)
+      true
+    end
+
+    private
+
+    def optional_string(value)
+      text = value.to_s
+      text.empty? ? nil : text
+    end
+
+    def elapsed_seconds(now)
+      [(now - @started_at).to_i, 0].max
+    rescue StandardError
+      0
+    end
+
+    def write_marker(path, payload)
+      @atomic_write.call(path, payload)
+      true
+    rescue StandardError => e
+      report_error("completion marker write failed", "marker", e, path: path)
+      false
+    end
+
+    def launch_hook(payload)
+      return false unless @hook_command
+
+      env = {
+        "HARNEX_ID" => @id,
+        "HARNEX_OUTCOME" => payload.fetch(:outcome),
+        "HARNEX_WORK_STATE" => payload.fetch(:work_state),
+        "HARNEX_RECEIPT_PATH" => @receipt_path,
+        "HARNEX_END_SHA" => payload[:end_sha].to_s,
+        "HARNEX_ELAPSED_S" => payload.fetch(:elapsed_s).to_s
+      }
+      pid = @spawn.call(env, @hook_command, {
+        chdir: @repo_root, in: File::NULL, out: @stderr, err: @stderr
+      })
+      @detach.call(pid)
+      true
+    rescue StandardError => e
+      report_error("completion hook launch failed", "hook", e)
+      false
+    end
+
+    def spawn_hook(env, command, options)
+      Process.spawn(env, "/bin/sh", "-c", command, **options)
+    end
+
+    # Do not include exception messages: injected spawn failures can echo CMD.
+    def report_error(message, component, error, path: nil)
+      @stderr.puts("harnex: #{message} (#{error.class})") rescue nil
+      payload = { component: component, error_class: error.class.name }
+      payload[:path] = path if path
+      emit("completion_notification_error", **payload)
+    end
+
+    def emit(type, **payload)
+      @event_sink&.call(type, payload)
+    rescue StandardError => e
+      @stderr.puts("harnex: completion diagnostic event failed (#{e.class})") rescue nil
+    end
+  end
+end

data/lib/harnex/runtime/session.rb

@@ -1,5 +1,6 @@
 require "io/console"
 require "json"
+require "monitor"
 require "pty"
 require "shellwords"
 
@@ -39,6 +40,9 @@ module Harnex
       adapter_close real_disconnections stream_interruptions stalls force_resumes compactions recovered
     ].freeze
     SUCCESSFUL_TURN_STATUSES = %w[completed success succeeded].freeze
+    PROOF_REJECTION_CLASSES = %w[
+      completed_no_activity report_missing report_invalid report_rejected
+    ].freeze
     class EventCounters
       def initialize
         @counts = {
@@ -91,7 +95,7 @@ module Harnex
                 :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, 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, on_done: nil, launch_cwd: nil, child_cwd: nil, completion_notifier: nil)
       @adapter = adapter
       @command = command
       @repo_root = repo_root
@@ -132,6 +136,20 @@ module Harnex
       @injected_count = 0
       @last_injected_at = nil
       @started_at = Time.now
+      @completion_transition_lock = Monitor.new
+      @completion_notification_mutex = Mutex.new
+      @completion_notification_registered = false
+      @completion_notification_sent = false
+      @pending_completion_notification = nil
+      @completion_notifier = completion_notifier || CompletionNotifier.new(
+        repo_root: repo_root,
+        id: @id,
+        session_id: @session_id,
+        receipt_path: @artifact_report_path,
+        hook_command: on_done,
+        started_at: @started_at,
+        event_sink: ->(type, payload) { emit_event(type, **payload) }
+      )
       @server = nil
       @reader = nil
       @output_log = nil
@@ -161,6 +179,10 @@ module Harnex
       @completion_report_status = nil
       @completion_diagnostics = []
       @pi_streamed_text_by_message = {}
+      @pi_active_message_key = nil
+      @pi_last_assistant_stop_reason = nil
+      @pi_last_assistant_error = nil
+      @pi_last_retry_error = nil
       @auto_stop = !!auto_stop
       @auto_stop_fired = false
       @auto_stop_seen_busy = false
@@ -197,6 +219,7 @@ module Harnex
     end
 
     def run(validate_binary: true)
+      configure_adapter_startup!
       validate_binary! if validate_binary
       prune_retained_logs
       prepare_output_log
@@ -221,6 +244,7 @@ module Harnex
       @server = ApiServer.new(self)
       @server.start
       persist_registry
+      register_completion_notifier!
       append_dispatch_start_record
 
       stdin_state = STDIN.tty? ? STDIN.raw! : nil
@@ -471,10 +495,18 @@ module Harnex
 
     def validate_binary!
       self.class.validate_binary!(command)
+      adapter.validate_runtime! if adapter.respond_to?(:validate_runtime!)
     end
 
     private
 
+    def configure_adapter_startup!
+      return unless adapter.respond_to?(:configure_startup)
+
+      adapter.configure_startup(model: meta_hash["model"], effort: meta_hash["effort"])
+      @command = adapter.build_command
+    end
+
     def structured_transport?
       %i[stdio_jsonrpc stdio_jsonl_rpc].include?(adapter.transport)
     end
@@ -493,6 +525,7 @@ module Harnex
       @server = ApiServer.new(self)
       @server.start
       persist_registry
+      register_completion_notifier!
       append_dispatch_start_record
 
       watch_thread = start_watch_thread
@@ -501,9 +534,18 @@ module Harnex
 
       if @pid
         begin
-          _, status = Process.wait2(@pid)
-          @term_signal = status.signaled? ? status.termsig : nil
-          @exit_code = status.exited? ? status.exitstatus : 128 + status.termsig
+          status = if adapter.respond_to?(:wait_for_exit)
+                     adapter.wait_for_exit
+                   else
+                     _waited_pid, process_status = Process.wait2(@pid)
+                     process_status
+                   end
+          if status
+            @term_signal = status.signaled? ? status.termsig : nil
+            @exit_code = status.exited? ? status.exitstatus : 128 + status.termsig
+          else
+            @exit_code = 0
+          end
         rescue Errno::ECHILD
           @exit_code = 0
         end
@@ -636,6 +678,10 @@ module Harnex
     end
 
     def record_successful_completion(payload)
+      @completion_transition_lock.synchronize { record_successful_completion_locked(payload) }
+    end
+
+    def record_successful_completion_locked(payload)
       assessment = completion_gate_required? ? assess_completion_proof : { accepted: true }
       unless assessment[:accepted]
         mark_task_failed(
@@ -646,7 +692,6 @@ module Harnex
           artifact_report_status: assessment[:report_status],
           diagnostics: assessment[:diagnostics]
         )
-        enforce_required_artifact_report!
         return false
       end
 
@@ -663,13 +708,17 @@ module Harnex
       # 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?
+      if task_failed?
+        publish_completion_notification("task_failed")
+        return false
+      end
 
       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)
+      publish_completion_notification("task_complete")
       true
     end
 
@@ -735,7 +784,11 @@ module Harnex
       end
     end
 
-    def mark_task_failed(turn_id: nil, status: nil, error: nil, codex_error_info: nil, outcome_class: nil, artifact_report_status: nil, diagnostics: nil)
+    def mark_task_failed(**attributes)
+      @completion_transition_lock.synchronize { mark_task_failed_locked(**attributes) }
+    end
+
+    def mark_task_failed_locked(turn_id: nil, status: nil, error: nil, codex_error_info: nil, outcome_class: nil, artifact_report_status: nil, diagnostics: nil, publish: true)
       @last_completed_at = nil if outcome_class
       @last_failed_at = Time.now
       @last_failed_status = status.to_s.empty? ? "failed" : status.to_s
@@ -752,6 +805,11 @@ module Harnex
       payload[:artifact_report_status] = artifact_report_status if artifact_report_status
       payload[:diagnostics] = @completion_diagnostics unless @completion_diagnostics.empty?
       emit_event("task_failed", **payload)
+      if publish
+        enforce_required_artifact_report!
+        terminal_signal = @last_failed_status == "dispatch_error" ? "dispatch_error" : "task_failed"
+        publish_completion_notification(terminal_signal)
+      end
     end
 
     def extract_error_notification_message(params)
@@ -792,29 +850,43 @@ module Harnex
       event_type = message["type"].to_s
 
       case event_type
-      when "agent_start", "turn_start"
-        @turn_started_seen = true if event_type == "turn_start"
+      when "agent_start"
+        reset_pi_run_outcome!
+        @state_machine.force_busy!
+      when "turn_start"
+        @turn_started_seen = true
         @state_machine.force_busy!
-        emit_event("turn_started") if event_type == "turn_start"
+        emit_event("turn_started")
       when "agent_end"
+        capture_pi_agent_end(message)
+        @state_machine.force_busy!
+        emit_event("agent_end", will_retry: message["willRetry"] == true)
+        adapter.request_session_stats_async if adapter.respond_to?(:request_session_stats_async)
+      when "agent_settled"
         @state_machine.force_prompt!
-        record_successful_completion({})
+        emit_event("agent_settled", stop_reason: @pi_last_assistant_stop_reason)
+        settle_pi_task!
         adapter.request_session_stats_async if adapter.respond_to?(:request_session_stats_async)
-        schedule_auto_stop("task_complete", interrupt: false)
+        schedule_auto_stop("agent_settled", interrupt: false) if task_complete? || task_failed?
       when "message_start"
-        @pi_streamed_text_by_message[pi_message_key(message["message"])] = false
+        @pi_active_message_key = pi_message_key(message["message"])
+        @pi_streamed_text_by_message[@pi_active_message_key] = false
       when "message_update"
         event = message["assistantMessageEvent"] || {}
         delta = event["delta"]
-        key = pi_message_key(message["message"])
+        key = @pi_active_message_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"])
+        key = @pi_active_message_key || pi_message_key(message["message"])
         streamed = @pi_streamed_text_by_message.delete(key)
-        unless streamed
+        @pi_active_message_key = nil
+        capture_pi_assistant_message(message["message"])
+        if streamed
+          record_synthesized("\n", newline: false)
+        else
           text = pi_extract_message_text(message["message"])
           record_synthesized(text) if text
         end
@@ -828,13 +900,25 @@ module Harnex
         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)
+        emit_event(
+          "compaction",
+          reason: message["reason"],
+          phase: event_type,
+          will_retry: message["willRetry"],
+          aborted: message["aborted"],
+          error_message: message["errorMessage"]
+        )
       when "queue_update"
         nil
       when "auto_retry_start", "auto_retry_end"
         payload = message.reject { |k, _| k == "type" }
+        @pi_last_retry_error = message["finalError"].to_s if event_type == "auto_retry_end" && message["success"] == false
         emit_event(event_type, **payload)
         record_attempt_transition(type: "attempt_retry_scheduled", trigger: "adapter_auto_retry") if event_type == "auto_retry_start"
+      when "summarization_retry_scheduled", "summarization_retry_attempt_start", "summarization_retry_finished"
+        emit_event(event_type, **message.reject { |k, _| k == "type" })
+      when "bash_execution_update"
+        emit_event(event_type, id: message["id"], bytes: message["delta"].to_s.bytesize)
       when "extension_ui_request"
         handle_extension_ui_request(message)
       when "extension_error"
@@ -876,9 +960,19 @@ module Harnex
         return
       end
 
+      if msg.to_s.empty? && adapter.respond_to?(:disconnect_diagnostic)
+        msg = adapter.disconnect_diagnostic
+      end
       @last_error = msg.to_s unless msg.to_s.empty?
       @state_machine.force_busy!
       emit_event("disconnected", source: "transport", message: msg) rescue nil
+      if adapter.respond_to?(:terminate_subprocess)
+        Thread.new do
+          adapter.terminate_subprocess
+        rescue StandardError
+          nil
+        end
+      end
       signal_rpc_done!
     end
 
@@ -946,6 +1040,52 @@ module Harnex
       ""
     end
 
+    def reset_pi_run_outcome!
+      @pi_last_assistant_stop_reason = nil
+      @pi_last_assistant_error = nil
+      @pi_last_retry_error = nil
+    end
+
+    def capture_pi_agent_end(message)
+      assistant = Array(message["messages"]).reverse.find do |candidate|
+        candidate.is_a?(Hash) && candidate["role"] == "assistant"
+      end
+      capture_pi_assistant_message(assistant) if assistant
+    end
+
+    def capture_pi_assistant_message(message)
+      return unless message.is_a?(Hash) && message["role"] == "assistant"
+
+      reason = message["stopReason"].to_s
+      @pi_last_assistant_stop_reason = reason unless reason.empty?
+      error = message["errorMessage"].to_s
+      @pi_last_assistant_error = error unless error.empty?
+    end
+
+    def settle_pi_task!
+      return if @stop_requested && !task_complete? && !task_failed?
+
+      reason = @pi_last_assistant_stop_reason
+      case reason
+      when "stop"
+        record_successful_completion({})
+      when "error", "aborted", "length"
+        error = @pi_last_assistant_error || @pi_last_retry_error
+        error = "Pi agent settled with stopReason=#{reason}" if error.to_s.empty?
+        mark_task_failed(status: reason, error: error)
+      when nil, ""
+        mark_task_failed(
+          status: "missing_final_message",
+          error: "Pi agent settled without an authoritative final assistant stop reason"
+        )
+      else
+        mark_task_failed(
+          status: "unsupported_stop_reason",
+          error: "Pi agent settled with unsupported stopReason=#{reason}"
+        )
+      end
+    end
+
     def pi_extract_message_text(message)
       return nil unless message.is_a?(Hash)
 
@@ -1071,6 +1211,71 @@ module Harnex
       Harnex.write_registry(@registry_path, payload)
     end
 
+    def register_completion_notifier!
+      @completion_notification_mutex.synchronize do
+        @completion_notifier.register!
+        @completion_notification_registered = true
+        deliver_completion_notification(@pending_completion_notification) if @pending_completion_notification
+      end
+    rescue StandardError => e
+      warn("harnex: completion marker cleanup failed (#{e.class})")
+      emit_event("completion_notification_error", component: "cleanup", error_class: e.class.name)
+    end
+
+    def publish_completion_notification(terminal_signal)
+      snapshot = completion_notification_snapshot(terminal_signal)
+      @completion_notification_mutex.synchronize do
+        return false if @completion_notification_sent || @pending_completion_notification
+        return !(@pending_completion_notification = snapshot).nil? unless @completion_notification_registered
+
+        deliver_completion_notification(snapshot)
+      end
+    rescue StandardError => e
+      warn("harnex: completion notification failed (#{e.class})")
+      emit_event("completion_notification_error", component: "session", error_class: e.class.name)
+      false
+    end
+
+    def deliver_completion_notification(snapshot)
+      @completion_notification_sent = true
+      @pending_completion_notification = nil
+      @completion_notifier.notify(**snapshot)
+    end
+
+    def completion_notification_snapshot(terminal_signal)
+      outcome = completion_notification_outcome(terminal_signal)
+      {
+        outcome: outcome, work_state: outcome == "completed" ? "completed" : "failed",
+        outcome_class: @completion_outcome_class, artifact_report_status: @completion_report_status,
+        end_sha: summary_string(@git_end[:sha]), terminal_signal: terminal_signal
+      }
+    end
+
+    def completion_notification_outcome(terminal_signal)
+      signal = terminal_signal.to_s
+      return "error" if %w[dispatch_error finalization].include?(signal)
+      return "rejected" if PROOF_REJECTION_CLASSES.include?(@completion_outcome_class.to_s)
+      return "rejected" if signal == "task_complete" && observed_receipt_outcome_status == "rejected"
+      return "completed" if signal == "task_complete"
+      return "failed" if signal == "task_failed"
+
+      "error"
+    end
+
+    def observed_receipt_outcome_status
+      JSON.parse(File.read(artifact_report_path)).dig("outcome", "status")
+    rescue StandardError
+      nil
+    end
+
+    def current_terminal_signal
+      return "dispatch_error" if task_failed? && @last_failed_status == "dispatch_error"
+      return "task_failed" if task_failed?
+      return "task_complete" if task_complete?
+
+      nil
+    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
@@ -1338,7 +1543,11 @@ module Harnex
         @context_summary = normalized_context_summary(nil)
         warn("harnex: failed to collect session-end telemetry: #{e.message}")
       end
-      enforce_required_artifact_report!
+      @completion_transition_lock.synchronize do
+        terminal_signal = current_terminal_signal
+        enforce_required_artifact_report!
+        publish_completion_notification(terminal_signal || "finalization")
+      end
       @exit_reason ||= classify_exit
       record = DispatchHistory.build_record(self)
       append_dispatch_history_record(record)
@@ -1456,7 +1665,8 @@ module Harnex
           "code" => "receipt_write_error",
           "path" => "$",
           "message" => "harness could not write the observed-state receipt"
-        }]
+        }],
+        publish: false
       )
       @exit_code = 1 if @exit_code.nil? || @exit_code.zero? || @term_signal
       @term_signal = nil if @exit_code == 1
@@ -2193,8 +2403,9 @@ module Harnex
     end
 
     def summary_model
-      meta_hash["model"] || @usage_summary[:model] ||
-        (adapter.current_model if adapter.respond_to?(:current_model))
+      @usage_summary[:model] ||
+        (adapter.current_model if adapter.respond_to?(:current_model)) ||
+        meta_hash["model"]
     end
 
     def summary_service_tier

data/lib/harnex/version.rb

@@ -1,4 +1,4 @@
 module Harnex
-  VERSION = "0.10.2"
-  RELEASE_DATE = "2026-08-08"
+  VERSION = "0.12.0"
+  RELEASE_DATE = "2026-09-03"
 end

data/lib/harnex.rb

@@ -19,6 +19,7 @@ require_relative "harnex/runtime/session_state"
 require_relative "harnex/runtime/message"
 require_relative "harnex/runtime/inbox"
 require_relative "harnex/runtime/file_change_hook"
+require_relative "harnex/runtime/completion_notifier"
 require_relative "harnex/runtime/api_server"
 require_relative "harnex/runtime/session"
 require_relative "harnex/commands/watch"