harnex 0.6.4 → 0.7.3

data/lib/harnex/commands/run.rb

@@ -8,7 +8,7 @@ module Harnex
     KNOWN_FLAGS = %w[
       --id --description --detach --tmux --host --port --watch --watch-file
       --stall-after --max-resumes --preset --context --meta --summary-out
-      --timeout --inbox-ttl --legacy-pty --help
+      --timeout --inbox-ttl --auto-stop --fast --legacy-pty --help
     ].freeze
     VALUE_FLAGS = %w[
       --id --description --host --port --watch --watch-file --stall-after
@@ -32,6 +32,9 @@ module Harnex
           --preset NAME      Watch preset: impl, plan, gate (requires --watch)
           --watch-file PATH  Auto-send a file-change hook on modification
           --context TEXT     Inject as the initial prompt (prepends session header)
+          --auto-stop        Stop after the first task completion from --context
+          --fast             (codex only) Use Codex service_tier="fast".
+                             Default Codex runs force service_tier="flex".
           --meta JSON        Attach parsed JSON metadata to the started event
           --summary-out PATH Append dispatch telemetry summary JSONL to PATH
           --timeout SECS     Max seconds to wait for detached registration (default: #{DEFAULT_TIMEOUT})
@@ -45,6 +48,7 @@ module Harnex
         Notes:
           Compatibility: `--watch PATH` and `--watch=PATH` still configure file-hook mode.
           Bare `--watch` enables the babysitter.
+          --auto-stop requires --context and fires once after the first completion.
           Explicit --stall-after/--max-resumes values override --preset defaults.
           CLIs with smart prompt detection: #{Adapters.known.join(', ')}
           Any other CLI name is launched with generic wrapping.
@@ -52,6 +56,7 @@ module Harnex
 
         Common patterns:
           #{program_name} codex --id cx-i-42 --tmux cx-i-42 --context "Read /tmp/task-impl-42.md"
+          #{program_name} codex --id cx-i-42 --tmux cx-i-42 --context "Read /tmp/task-impl-42.md" --auto-stop
           #{program_name} codex --id cx-i-42 --watch --preset impl --context "Read /tmp/task-impl-42.md"
           #{program_name} claude --id cl-r-42 --tmux cl-r-42 --description "Review task 42"
 
@@ -60,11 +65,14 @@ module Harnex
           Passing --tmux without --id creates a random harnex session ID.
           --watch is foreground-only; do not combine it with --tmux or --detach.
           Use -- before child CLI flags when a flag could be parsed by harnex.
+          Codex JSON-RPC: pass model as `-c model=NAME`, not `-m NAME`. The
+            legacy PTY adapter (--legacy-pty) accepts `-m`.
       TEXT
     end
 
     def initialize(argv)
       @argv = argv.dup
+      @launch_cwd = Dir.pwd
       @options = {
         id: nil,
         description: nil,
@@ -80,11 +88,13 @@ module Harnex
         context: nil,
         meta: nil,
         summary_out: nil,
+        auto_stop: false,
         detach: false,
         tmux: false,
         tmux_name: nil,
         timeout: DEFAULT_TIMEOUT,
         inbox_ttl: default_inbox_ttl,
+        fast: false,
         legacy_pty: false,
         help: false
       }
@@ -98,12 +108,13 @@ module Harnex
       end
 
       raise OptionParser::MissingArgument, "cli" if cli_name.nil?
+      validate_auto_stop_context!
 
       repo_root = Harnex.resolve_repo_root(adapter_repo_path(cli_name, child_args))
       @options[:summary_out] = resolve_summary_out(repo_root)
       @options[:id] ||= Harnex.generate_id(repo_root)
       validate_unique_id!(repo_root)
-      effective_child_args = apply_context(child_args)
+      effective_child_args = apply_context(apply_codex_service_tier(cli_name, child_args))
       adapter = Harnex.build_adapter(cli_name, effective_child_args, legacy_pty: @options[:legacy_pty])
       @options[:detach] = true if @options[:tmux]
       validate_watch_mode!
@@ -159,9 +170,11 @@ module Harnex
       tmux_cmd += ["--port", @options[:port].to_s] if @options[:port]
       tmux_cmd += ["--watch-file", @options[:watch]] if @options[:watch]
       tmux_cmd += ["--context", @options[:context]] if @options[:context]
+      tmux_cmd << "--auto-stop" if @options[:auto_stop]
       tmux_cmd += ["--meta", JSON.generate(@options[:meta])] if @options[:meta]
       tmux_cmd += ["--summary-out", @options[:summary_out]] if @options[:summary_out]
       tmux_cmd += ["--inbox-ttl", @options[:inbox_ttl].to_s]
+      tmux_cmd << "--fast" if @options[:fast]
       tmux_cmd += ["--legacy-pty"] if @options[:legacy_pty]
       tmux_cmd += ["--"] + child_args unless child_args.empty?
 
@@ -170,9 +183,9 @@ module Harnex
 
       started =
         if ENV["TMUX"]
-          system("tmux", "new-window", "-n", window_name, "-d", shell_cmd)
+          system("tmux", "new-window", "-c", @launch_cwd, "-n", window_name, "-d", shell_cmd)
         else
-          system("tmux", "new-session", "-d", "-s", "harnex", "-n", window_name, shell_cmd)
+          system("tmux", "new-session", "-c", @launch_cwd, "-d", "-s", "harnex", "-n", window_name, shell_cmd)
         end
 
       raise "tmux failed to start #{cli_name.inspect}" unless started
@@ -266,7 +279,9 @@ module Harnex
         description: @options[:description],
         meta: @options[:meta],
         summary_out: @options[:summary_out],
-        inbox_ttl: @options[:inbox_ttl]
+        inbox_ttl: @options[:inbox_ttl],
+        auto_stop: @options[:auto_stop],
+        launch_cwd: @launch_cwd
       )
     end
 
@@ -412,6 +427,10 @@ module Harnex
           @options[:context] = required_option_value(arg, argv[index])
         when /\A--context=(.+)\z/
           @options[:context] = required_option_value("--context", Regexp.last_match(1))
+        when "--auto-stop"
+          @options[:auto_stop] = true
+        when "--fast"
+          @options[:fast] = true
         when "--meta"
           index += 1
           @options[:meta] = parse_meta(required_option_value(arg, argv[index]))
@@ -435,6 +454,7 @@ module Harnex
         when "--legacy-pty"
           @options[:legacy_pty] = true
         else
+          reject_unknown_long_flag!(arg) if unknown_long_flag?(arg)
           if cli_name.nil?
             cli_name = arg
           else
@@ -447,6 +467,16 @@ module Harnex
       [cli_name, forwarded]
     end
 
+    def unknown_long_flag?(arg)
+      arg.start_with?("--")
+    end
+
+    def reject_unknown_long_flag!(arg)
+      flag = arg.split("=", 2).first
+      raise OptionParser::InvalidOption,
+            "harnex run: unknown flag #{flag}; see harnex run --help"
+    end
+
     def required_option_value(option_name, value)
       raise OptionParser::MissingArgument, option_name if value.nil?
       raise OptionParser::MissingArgument, option_name if value.match?(/\A-[A-Za-z]/)
@@ -473,7 +503,7 @@ module Harnex
         case arg
         when "--"
           return false
-        when "-h", "--help", "--detach", "--tmux", "--legacy-pty"
+        when "-h", "--help", "--detach", "--tmux", "--auto-stop", "--fast", "--legacy-pty"
           nil
         when /\A--tmux=/
           nil
@@ -520,6 +550,32 @@ module Harnex
       @options[:max_resumes] = preset[:max_resumes] unless @options[:max_resumes_explicit]
     end
 
+    def validate_auto_stop_context!
+      return unless @options[:auto_stop]
+      return if @options[:context]
+
+      raise OptionParser::InvalidOption, "harnex run: --auto-stop requires --context"
+    end
+
+    def apply_codex_service_tier(cli_name, child_args)
+      return child_args unless cli_name.to_s == "codex"
+      return child_args if child_service_tier_config?(child_args)
+
+      child_args + ["-c", "service_tier=\"#{@options[:fast] ? 'fast' : 'flex'}\""]
+    end
+
+    def child_service_tier_config?(child_args)
+      child_args.each_with_index.any? do |arg, index|
+        text = arg.to_s
+        text.start_with?("service_tier=") ||
+          text.start_with?("service_tier.") ||
+          text == "-c" && child_args[index + 1].to_s.start_with?("service_tier") ||
+          text == "--config" && child_args[index + 1].to_s.start_with?("service_tier") ||
+          text.start_with?("-cservice_tier") ||
+          text.start_with?("--config=service_tier")
+      end
+    end
+
     def parse_non_negative_integer(value, option_name:)
       integer = Integer(value)
       raise OptionParser::InvalidArgument, "#{option_name} must be 0 or greater" if integer.negative?

data/lib/harnex/commands/wait.rb

@@ -6,8 +6,13 @@ require "uri"
 module Harnex
   class Waiter
     POLL_INTERVAL = 0.5
+    EVENT_POLL_INTERVAL = 0.1
+    EXIT_STATUS_GRACE_SECONDS_DEFAULT = 5.0
+    EXIT_STATUS_GRACE_POLL_INTERVAL = 0.05
+    FINAL_EVENT_GRACE_SECONDS = 5.0
 
     EVENT_PREDICATES = %w[task_complete].freeze
+    LEGACY_EVENT_TYPES = %w[agent_state exited task_complete].freeze
 
     def self.usage(program_name = "harnex wait")
       <<~TEXT
@@ -84,30 +89,17 @@ module Harnex
 
       offset = 0
       task_complete_seen = false
+      final_event_deadline = nil
 
       # Replay existing events first — we may already be past the predicate.
-      if File.exist?(events_path)
-        File.open(events_path, "r") do |f|
-          f.each_line do |line|
-            offset = f.pos
-            event = parse_event(line)
-            next unless event
-            task_complete_seen = true if event["type"] == "task_complete"
-            if matches?(event, predicate, task_complete_seen)
-              return emit_event_match(event, start_time)
-            end
-          end
-        end
-      end
+      status, offset, task_complete_seen = scan_events(events_path, offset, predicate, task_complete_seen, start_time)
+      return status if status
 
       target_pid = registry && registry["pid"]
 
       loop do
-        if target_pid && !Harnex.alive_pid?(target_pid)
-          waited = (Time.now - start_time).round(1)
-          puts JSON.generate(ok: false, id: @options[:id], state: "exited", waited_seconds: waited)
-          return 1
-        end
+        status, offset, task_complete_seen = scan_events(events_path, offset, predicate, task_complete_seen, start_time)
+        return status if status
 
         if deadline && Time.now >= deadline
           waited = (Time.now - start_time).round(1)
@@ -115,34 +107,62 @@ module Harnex
           return 124
         end
 
-        if File.exist?(events_path) && File.size(events_path) > offset
-          File.open(events_path, "r") do |f|
-            f.seek(offset)
-            f.each_line do |line|
-              event = parse_event(line)
-              next unless event
-              task_complete_seen = true if event["type"] == "task_complete"
-              if matches?(event, predicate, task_complete_seen)
-                offset = f.pos
-                return emit_event_match(event, start_time)
-              end
-            end
-            offset = f.pos
+        if target_pid && !Harnex.alive_pid?(target_pid)
+          final_event_deadline ||= Time.now + FINAL_EVENT_GRACE_SECONDS
+          if Time.now >= final_event_deadline
+            waited = (Time.now - start_time).round(1)
+            puts JSON.generate(ok: false, id: @options[:id], state: "exited", waited_seconds: waited)
+            return 1
           end
+        else
+          final_event_deadline = nil
         end
 
-        sleep 0.1
+        sleep EVENT_POLL_INTERVAL
+      end
+    end
+
+    def scan_events(path, offset, predicate, task_complete_seen, start_time)
+      return [nil, offset, task_complete_seen] unless File.exist?(path) && File.size(path) > offset
+
+      File.open(path, "r") do |f|
+        f.seek(offset)
+        f.each_line do |line|
+          event = parse_event(line)
+          next unless event
+
+          task_complete_seen = true if event_type(event) == "task_complete"
+          if matches?(event, predicate, task_complete_seen)
+            return [emit_event_match(event, start_time), f.pos, task_complete_seen]
+          end
+        end
+        offset = f.pos
       end
+
+      [nil, offset, task_complete_seen]
     end
 
     def parse_event(line)
-      JSON.parse(line)
+      event = JSON.parse(line)
+      event.is_a?(Hash) ? event : nil
     rescue JSON::ParserError
-      nil
+      legacy_type = line.to_s.strip
+      return nil unless LEGACY_EVENT_TYPES.include?(legacy_type)
+
+      { "type" => legacy_type }
     end
 
-    def matches?(event, predicate, task_complete_seen)
+    def event_type(event)
       type = event["type"]
+      return type if type.is_a?(String) && !type.empty?
+
+      legacy_type = event["terminal_event"] || event["event"]
+      legacy_type = legacy_type.to_s
+      LEGACY_EVENT_TYPES.include?(legacy_type) ? legacy_type : nil
+    end
+
+    def matches?(event, predicate, task_complete_seen)
+      type = event_type(event)
       case predicate
       when "task_complete"
         type == "task_complete"
@@ -159,7 +179,7 @@ module Harnex
       puts JSON.generate(
         ok: true,
         id: @options[:id],
-        event: event["type"],
+        event: event_type(event),
         seq: event["seq"],
         waited_seconds: waited
       )
@@ -227,6 +247,7 @@ module Harnex
 
       loop do
         unless Harnex.alive_pid?(target_pid)
+          await_exit_status(exit_path)
           return read_exit_status(exit_path, @options[:id])
         end
 
@@ -239,6 +260,26 @@ module Harnex
       end
     end
 
+    # Subprocess death races the parent's DISPATCH-row write; the exit-status
+    # file is written *after* the row, so polling it bounds the race.
+    def await_exit_status(exit_path)
+      return if File.exist?(exit_path)
+
+      grace_deadline = Time.now + exit_status_grace_seconds
+      until File.exist?(exit_path) || Time.now >= grace_deadline
+        sleep EXIT_STATUS_GRACE_POLL_INTERVAL
+      end
+    end
+
+    def exit_status_grace_seconds
+      override = ENV["HARNEX_EXIT_STATUS_GRACE_SECONDS"]
+      return EXIT_STATUS_GRACE_SECONDS_DEFAULT if override.to_s.strip.empty?
+
+      Float(override)
+    rescue ArgumentError
+      EXIT_STATUS_GRACE_SECONDS_DEFAULT
+    end
+
     def fetch_agent_state(host, port, token)
       uri = URI("http://#{host}:#{port}/status")
       request = Net::HTTP::Get.new(uri)

data/lib/harnex/core.rb

@@ -85,10 +85,10 @@ module Harnex
   end
 
   def default_summary_out_path(repo_root)
-    koder_dir = File.join(repo_root.to_s, "koder")
-    return nil unless File.directory?(koder_dir)
+    root = repo_root.to_s
+    return nil if root.empty?
 
-    File.join(koder_dir, "DISPATCH.jsonl")
+    File.join(root, ".harnex", "dispatch.jsonl")
   end
 
   def git_capture_start(repo_root)

data/lib/harnex/dispatch_history.rb

@@ -0,0 +1,112 @@
+require "fileutils"
+require "json"
+require "open3"
+require "time"
+
+module Harnex
+  module DispatchHistory
+    module_function
+
+    MAX_REPO_WALK_LEVELS = 10
+
+    def global_path
+      File.join(STATE_DIR, "dispatch.jsonl")
+    end
+
+    def path_for(start_path = Dir.pwd, global: false)
+      return global_path if global
+
+      repo_root = find_git_root(start_path)
+      return global_path unless repo_root
+
+      File.join(repo_root, ".harnex", "dispatch.jsonl")
+    end
+
+    def find_git_root(start_path)
+      path = File.expand_path(start_path.to_s.empty? ? Dir.pwd : start_path)
+      path = File.dirname(path) unless File.directory?(path)
+
+      git_root = git_toplevel(path)
+      return git_root if git_root
+
+      (MAX_REPO_WALK_LEVELS + 1).times do
+        return path if File.directory?(File.join(path, ".git"))
+
+        parent = File.dirname(path)
+        break if parent == path
+
+        path = parent
+      end
+
+      nil
+    end
+
+    def git_toplevel(path)
+      output, status = Open3.capture2("git", "-C", path, "rev-parse", "--show-toplevel", err: File::NULL)
+      root = output.to_s.strip
+      return root if status.success? && !root.empty?
+
+      nil
+    rescue StandardError
+      nil
+    end
+
+    def append(path, record)
+      FileUtils.mkdir_p(File.dirname(path))
+      line = JSON.generate(record) + "\n"
+      File.open(path, File::WRONLY | File::APPEND | File::CREAT, 0o644) do |file|
+        file.flock(File::LOCK_EX)
+        file.write(line)
+      ensure
+        file.flock(File::LOCK_UN) unless file.closed?
+      end
+    end
+
+    def build_record(session)
+      ended_at = session.ended_at || Time.now
+      status, terminal_event = classify(session)
+      {
+        schema_version: 1,
+        id: session.id,
+        description: session.description,
+        cli: session.adapter.key,
+        started_at: session.started_at.utc.iso8601,
+        ended_at: ended_at.utc.iso8601,
+        duration_s: (ended_at - session.started_at).to_i,
+        status: status,
+        terminal_event: terminal_event,
+        commit_sha: commit_sha(session.git_start, session.git_end),
+        tier: session.__send__(:meta_hash)["tier"],
+        meta: session.__send__(:meta_hash),
+        summary_out_path: session.summary_out,
+        events_log_path: session.events_log_path,
+        tmux_state: tmux_state(session.__send__(:summary_tmux_session))
+      }
+    end
+
+    def classify(session)
+      return ["completed", "task_complete"] if session.task_complete?
+      return ["timeout", "timeout"] if session.exit_code == 124
+      return ["killed", "process_kill"] if session.term_signal
+      return ["completed", "process_exit"] if session.exit_code == 0
+
+      ["failed", "dispatch_failed"]
+    end
+
+    def commit_sha(git_start, git_end)
+      start_sha = git_start[:sha].to_s
+      end_sha = git_end[:sha].to_s
+      return nil if start_sha.empty? || end_sha.empty? || start_sha == end_sha
+
+      end_sha
+    end
+
+    def tmux_state(tmux_session)
+      return "torn-down" if tmux_session.to_s.empty?
+
+      system("tmux", "has-session", "-t", tmux_session.to_s, out: File::NULL, err: File::NULL) ? "live" : "torn-down"
+    rescue StandardError
+      "torn-down"
+    end
+  end
+end