harnex 0.12.0 → 0.29.0

data/lib/harnex/runtime/stop_request.rb

@@ -0,0 +1,39 @@
+require "time"
+
+module Harnex
+  # Caller-declared provenance is deliberately an enum, never a free-text log.
+  # Session owns first-request-wins synchronization and work acceptance.
+  class StopRequest
+    REASONS = %w[manual completion runtime_budget].map(&:freeze).freeze
+    ORIGINS = %w[api cli auto_stop watch runtime].map(&:freeze).freeze
+    WORK_STATES = %w[running completed failed unknown].freeze
+
+    def self.validate!(reason:, origin:)
+      raise ArgumentError, "stop reason must be one of #{REASONS.join(', ')}" unless REASONS.include?(reason)
+      raise ArgumentError, "stop origin must be one of #{ORIGINS.join(', ')}" unless ORIGINS.include?(origin)
+    end
+
+    def initialize(reason:, origin:, work_state:, requested_at: Time.now, runtime_limit_s: nil)
+      self.class.validate!(reason: reason, origin: origin)
+      raise ArgumentError, "invalid stop work state" unless WORK_STATES.include?(work_state)
+
+      @payload = {
+        reason: reason.dup.freeze,
+        origin: origin.dup.freeze,
+        requested_at: requested_at.getutc.iso8601(3).freeze,
+        work_state: work_state.dup.freeze
+      }
+      unless runtime_limit_s.nil?
+        limit = Float(runtime_limit_s)
+        raise ArgumentError, "invalid stop runtime limit" unless limit.finite? && limit.positive?
+
+        @payload[:runtime_limit_s] = limit
+      end
+      @payload.freeze
+    end
+
+    def to_h
+      @payload.dup
+    end
+  end
+end

data/lib/harnex/stall.rb

@@ -0,0 +1,46 @@
+module Harnex
+  # #76: one "no progress" predicate over a live status payload, shared by
+  # `wait/watch --stall-after` and later observers (#77). It only reads clocks;
+  # it never nudges, stops, or judges the worker.
+  module Stall
+    STRUCTURED_CLOCKS = %w[turn_age_s model_idle_s tool_idle_s].freeze
+
+    module_function
+
+    # Seconds since the session last showed progress, with the clock used:
+    #   activity    - the structured Pi adapter: the most
+    #                 recent of turn start, model event, or tool event, and
+    #                 only while a turn is active;
+    #   output_log  - PTY adapters: seconds since the transcript last changed.
+    # nil when no clock applies: settled work, no active structured turn, or
+    # nothing observable.
+    def progress_idle(payload)
+      return nil unless payload.is_a?(Hash)
+      return nil if payload["done"] == true || payload["task_complete"] == true || payload["task_failed"] == true
+
+      activity = payload["activity"]
+      if activity.is_a?(Hash) && activity["status"] == "observed"
+        return nil unless activity["turn_active"] == true
+
+        idle = STRUCTURED_CLOCKS.filter_map { |key| non_negative(activity[key]) }.min
+        return idle && { "clock" => "activity", "idle_s" => idle }
+      end
+
+      idle = non_negative(payload["log_idle_s"])
+      idle && { "clock" => "output_log", "idle_s" => idle }
+    end
+
+    def stalled(payload, threshold_s)
+      progress = progress_idle(payload)
+      return nil unless progress && progress["idle_s"] >= threshold_s
+
+      progress.merge("threshold_s" => threshold_s.to_f)
+    end
+
+    def non_negative(value)
+      return nil unless value.is_a?(Numeric) && value.finite?
+
+      [value.to_f, 0.0].max
+    end
+  end
+end

data/lib/harnex/telemetry_reconciler.rb

@@ -37,9 +37,9 @@ module Harnex
 
     private
 
-    def analyze
+    def analyze(canonical_locked: false)
       reset_diagnostics
-      canonical = load_canonical(@canonical)
+      canonical = load_canonical(@canonical, locked: canonical_locked)
       sources = discover_sources(@sources, @canonical)
       source_rows = sources[:rows]
       conflict_rows = sources[:conflicts]
@@ -115,7 +115,7 @@ module Harnex
 
     def writable?(state) = state[:fatal].empty? && state[:conflict_rows].empty? && state[:missing_rows].any?
 
-    def load_canonical(path)
+    def load_canonical(path, locked: false)
       rows = []
       fatal = []
       families = FAMILY_KEYS.to_h { |key| [key, 0] }
@@ -123,7 +123,19 @@ module Harnex
       ends = {}
       recoverable = []
 
-      read_jsonl(path).each do |entry|
+      begin
+        entries = read_jsonl(path, complete: true, locked: locked)
+      rescue DispatchHistory::HistoryUnavailable => e
+        return {
+          rows: 0,
+          families: families,
+          recoverable: [],
+          fatal: [e.message],
+          open_starts: 0
+        }
+      end
+
+      entries.each do |entry|
         if entry[:error]
           fatal << "malformed canonical JSON at #{path}:#{entry[:line]}"
           next
@@ -281,18 +293,27 @@ module Harnex
       records.each_with_index.map { |record, index| { record: record, line: index + 1, path: path } }
     end
 
-    def read_jsonl(path)
-      return [] unless File.file?(path)
+    def read_jsonl(path, complete: false, locked: false)
+      return [] unless File.file?(path) || complete
 
-      File.readlines(path, chomp: true).each_with_index.filter_map do |line, index|
+      entries = []
+      index = 0
+      consume = proc do |line|
+        index += 1
         next if line.strip.empty?
 
         begin
-          { record: JSON.parse(line), line: index + 1, path: path }
+          entries << { record: JSON.parse(line), line: index, path: path }
         rescue JSON::ParserError => error
-          { error: error, line: index + 1, path: path }
+          entries << { error: error, line: index, path: path }
         end
       end
+      if complete
+        DispatchHistory.each_history_line(path, locked: locked, &consume)
+      else
+        File.foreach(path, &consume)
+      end
+      entries
     end
 
     def canonical_family(record)
@@ -410,23 +431,22 @@ module Harnex
 
     def append_missing_under_lock(rows)
       FileUtils.mkdir_p(File.dirname(@canonical))
-      File.open(@canonical, File::RDWR | File::CREAT, 0o644) do |file|
-        file.flock(File::LOCK_EX)
-        file.rewind
-        existing = file.read
-        locked = analyze
+      DispatchHistory.with_lock(@canonical) do
+        locked = analyze(canonical_locked: true)
         return [0, locked] unless writable?(locked)
 
         still_missing = locked[:missing_rows].select { |row| rows.any? { |wanted| wanted.identity == row.identity } }
-        payload = still_missing.map { |row| JSON.generate(row.record) }.join("\n")
+        payload = still_missing.map { |row| JSON.generate(DispatchHistory.portable_record(row.record)) }.join("\n")
+        existing = File.file?(@canonical) ? File.binread(@canonical) : ""
         payload = "\n#{payload}" unless existing.empty? || existing.end_with?("\n")
         payload = "#{payload}\n" unless payload.empty?
-        file.seek(0, IO::SEEK_END)
-        file.write(payload)
-        file.flush
+        DispatchHistory.prepare_archive(@canonical, payload.bytesize)
+        File.open(@canonical, File::WRONLY | File::APPEND | File::CREAT, 0o644) do |file|
+          file.write(payload)
+          file.flush
+          file.fsync
+        end
         [still_missing.length, locked.merge(missing_rows: [])]
-      ensure
-        file.flock(File::LOCK_UN) unless file.closed?
       end
     end
 
@@ -459,6 +479,8 @@ module Harnex
         end
       when Array
         value.map { |item| deep_normalize(item) }
+      when String
+        DispatchHistory.portable_path(value)
       else
         value
       end

data/lib/harnex/terminal_status.rb

@@ -64,8 +64,7 @@ module Harnex
       summary_record = nil
       history_record = nil
 
-      File.foreach(path) do |line|
-        record = JSON.parse(line)
+      DispatchHistory.each_record(path) do |record|
         next unless record.is_a?(Hash)
         next if DispatchHistory.start_record?(record)
 
@@ -83,8 +82,6 @@ module Harnex
         elsif history_record?(record) && record["id"].to_s == id
           history_record = record
         end
-      rescue JSON::ParserError
-        next
       end
 
       [summary_record, history_record]
@@ -139,7 +136,7 @@ module Harnex
       terminal = state != "unknown"
       {
         "id" => meta["id"].to_s,
-        "repo_root" => meta["repo"] || fallback_repo_root,
+        "repo_root" => DispatchHistory.expand_portable_path(meta["repo"] || fallback_repo_root),
         "state" => state,
         "process_state" => Harnex.process_state_for(state, terminal: terminal),
         "terminal" => terminal,
@@ -149,6 +146,9 @@ module Harnex
         "work_state" => Harnex.work_state_for(state, task_complete: task_complete),
         "outcome_class" => blank_to_nil(outcome["class"]),
         "artifact_report_status" => blank_to_nil(outcome["report_status"]),
+        "activity" => record["activity"],
+        "stop" => record["stop"],
+        "runtime_budget" => record["runtime_budget"],
         "exit" => blank_to_nil(actual["exit"]),
         "exit_code" => actual["exit_code"],
         "started_at" => meta["started_at"],

data/lib/harnex/version.rb

@@ -1,4 +1,4 @@
 module Harnex
-  VERSION = "0.12.0"
-  RELEASE_DATE = "2026-09-03"
+  VERSION = "0.29.0"
+  RELEASE_DATE = "2026-10-22"
 end

data/lib/harnex.rb

@@ -9,10 +9,16 @@ require_relative "harnex/config"
 require_relative "harnex/retention"
 require_relative "harnex/pricing"
 require_relative "harnex/terminal_status"
+require_relative "harnex/runtime/stop_request"
 require_relative "harnex/artifact_report"
+require_relative "harnex/context_file"
 require_relative "harnex/context_telemetry"
 require_relative "harnex/telemetry_reconciler"
 require_relative "harnex/orchestration"
+require_relative "harnex/stall"
+require_relative "harnex/owner_stream"
+require_relative "harnex/lanes"
+require_relative "harnex/mcp"
 require_relative "harnex/watcher"
 require_relative "harnex/adapters"
 require_relative "harnex/runtime/session_state"
@@ -20,6 +26,8 @@ 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/activity_tracker"
+require_relative "harnex/runtime/runtime_budget"
 require_relative "harnex/runtime/api_server"
 require_relative "harnex/runtime/session"
 require_relative "harnex/commands/watch"
@@ -37,6 +45,14 @@ require_relative "harnex/commands/recipes"
 require_relative "harnex/commands/guide"
 require_relative "harnex/commands/agents_guide"
 require_relative "harnex/commands/doctor"
+require_relative "harnex/commands/preflight"
+require_relative "harnex/commands/ask"
+require_relative "harnex/commands/delegate"
+require_relative "harnex/commands/result"
+require_relative "harnex/commands/reply"
+require_relative "harnex/commands/land"
+require_relative "harnex/commands/lanes"
+require_relative "harnex/commands/mcp"
 require_relative "harnex/commands/orchestration"
 require_relative "harnex/commands/artifact_report"
 require_relative "harnex/commands/telemetry"

data/recipes/01_fire_and_watch.md

@@ -11,7 +11,7 @@ repeating this pattern with file handoffs between steps.
 ### 1. Spawn the worker
 
 ```bash
-harnex run codex --id cx-23 --tmux
+harnex run pi --id pi-i-23 --tmux pi-i-23
 ```
 
 ### 2. Send the task
@@ -19,22 +19,22 @@ harnex run codex --id cx-23 --tmux
 If the plan file is self-contained, reference it directly:
 
 ```bash
-harnex send --id cx-23 --message "Implement koder/plans/plan_23.md. Run tests when done."
-harnex wait --id cx-23 --until done --timeout 1200
+harnex send --id pi-i-23 --message "Implement koder/plans/plan_23.md. Run tests when done."
+harnex wait --id pi-i-23 --until done --timeout 1200
 ```
 
 For tasks that need structured output, tell the worker to write a
 file and inspect the screen separately:
 
 ```bash
-cat > /tmp/task-cx-23.md <<'EOF'
+cat > /tmp/task-impl-23.md <<'EOF'
 Implement koder/plans/plan_23.md.
 Run the full test suite when done.
 Write a short summary to /tmp/impl-23.md.
 EOF
 
-harnex send --id cx-23 --message "Read and execute /tmp/task-cx-23.md"
-harnex wait --id cx-23 --until done --timeout 1200
+harnex send --id pi-i-23 --message "Read and execute /tmp/task-impl-23.md"
+harnex wait --id pi-i-23 --until done --timeout 1200
 ```
 
 ### 3. Watch until done
@@ -42,25 +42,25 @@ harnex wait --id cx-23 --until done --timeout 1200
 Use `harnex wait --until done` as the work-level fence, then read the worker's screen:
 
 ```bash
-harnex pane --id cx-23 --lines 25
+harnex pane --id pi-i-23 --lines 25
 ```
 
 If you prefer to watch while it runs:
 
 ```bash
-harnex pane --id cx-23 --follow
+harnex pane --id pi-i-23 --follow
 ```
 
 When the worker looks idle, capture a larger snapshot:
 
 ```bash
-harnex pane --id cx-23 --lines 80
+harnex pane --id pi-i-23 --lines 80
 ```
 
 ### 4. Stop the worker
 
 ```bash
-harnex stop --id cx-23
+harnex stop --id pi-i-23
 ```
 
 Start a fresh worker for the next step instead of reusing this one.
@@ -69,10 +69,10 @@ Start a fresh worker for the next step instead of reusing this one.
 
 Use the same pattern for every role:
 
-- Codex planning: "Write the plan to `/tmp/plan-23.md`. Do not change code."
-- Codex implementation: "Read `/tmp/plan-23.md`, implement it, run tests, write `/tmp/impl-23.md`."
-- Claude review: "Review current changes against `/tmp/plan-23.md` and write findings to `/tmp/review-23.md`."
-- Codex fix: "Read `/tmp/review-23.md`, fix the issues, run tests, write `/tmp/fix-23.md`."
+- Pi planning: "Write the plan to `/tmp/plan-23.md`. Do not change code."
+- Pi implementation: "Read `/tmp/plan-23.md`, implement it, run tests, write `/tmp/impl-23.md`."
+- Claude (or fresh Pi) review: "Review current changes against `/tmp/plan-23.md` and write findings to `/tmp/review-23.md`."
+- Pi fix: "Read `/tmp/review-23.md`, fix the issues, run tests, write `/tmp/fix-23.md`."
 
 ## Rationale
 

data/recipes/02_chain_implement.md

@@ -5,16 +5,16 @@ This is repeated fire-and-watch for a batch of jobs.
 Process plans in series. For each plan, use fresh instances for
 every step:
 
-- Codex plans or implements
-- Claude reviews
-- Codex fixes
+- Pi plans or implements
+- Claude (or a fresh Pi lane) reviews
+- Pi fixes
 - Repeat review and fix until clean, then move to the next plan
 
 ## Trigger
 
 User says something like:
 - "implement plans 23 to 27, review each, fix issues"
-- "implement plans 23 to 27, use fresh Codex for implementation
+- "implement plans 23 to 27, use fresh Pi for implementation
   and fresh Claude for review on every plan"
 
 ## Procedure
@@ -24,55 +24,58 @@ For each plan in the batch:
 ### Step 1: Plan or confirm the plan
 
 If the plan file does not already exist or needs refinement, spawn a
-fresh Codex planner and tell it to write a plan artifact.
+fresh Pi planner and tell it to write a plan artifact.
 
 ```bash
-harnex run codex --id cx-plan-23 --tmux
-harnex send --id cx-plan-23 --message "Write a concrete implementation plan for plan 23 to /tmp/plan-23.md. Do not change code." --wait-for-idle --timeout 600
+harnex run pi --id pi-p-23 --tmux pi-p-23
+harnex send --id pi-p-23 --message "Write a concrete implementation plan for plan 23 to /tmp/plan-23.md. Do not change code." --wait-for-idle --timeout 600
 ```
 
-Inspect with `harnex pane --id cx-plan-23 --lines 60`, then stop it.
+Inspect with `harnex pane --id pi-p-23 --lines 60`, then stop it.
 
 If the plan is already written and trusted, skip this step and use the
 existing plan file directly.
 
 ### Step 2: Implement
 
-Spawn a fresh Codex worker, send it the plan, watch it, stop it.
+Spawn a fresh Pi worker, send it the plan, watch it, stop it.
 
 ```bash
-harnex run codex --id cx-impl-23-r1 --tmux
-harnex send --id cx-impl-23-r1 --message "Read /tmp/plan-23.md, implement it, run tests, and write a summary to /tmp/impl-23-r1.md." --wait-for-idle --timeout 1200
+harnex run pi --id pi-i-23-r1 --tmux pi-i-23-r1
+harnex send --id pi-i-23-r1 --message "Read /tmp/plan-23.md, implement it, run tests, and write a summary to /tmp/impl-23-r1.md." --wait-for-idle --timeout 1200
 ```
 
-Inspect with `harnex pane --id cx-impl-23-r1 --lines 80`, then stop it.
+Inspect with `harnex pane --id pi-i-23-r1 --lines 80`, then stop it.
 
 ### Step 3: Review
 
-Spawn a fresh Claude reviewer. Claude is only used for reviews in this
-recipe.
+Spawn a fresh reviewer: a Claude session, or a fresh Pi lane that has
+not seen the implementation. Reviewers only review in this recipe.
 
 ```bash
-harnex run claude --id cl-rev-23-r1 --tmux
-harnex send --id cl-rev-23-r1 --message "Review the current changes against /tmp/plan-23.md. Write findings to /tmp/review-23-r1.md. If there are no issues, say clean." --wait-for-idle --timeout 900
+harnex run claude --id cl-r-23-r1 --tmux cl-r-23-r1
+harnex send --id cl-r-23-r1 --message "Review the current changes against /tmp/plan-23.md. Write findings to /tmp/review-23-r1.md. If there are no issues, say clean." --wait-for-idle --timeout 900
 ```
 
-Inspect with `harnex pane --id cl-rev-23-r1 --lines 80`, then stop it.
+For a Pi reviewer, use `harnex run pi --id pi-r-23-r1 --tmux pi-r-23-r1`
+with the same message.
+
+Inspect with `harnex pane --id cl-r-23-r1 --lines 80`, then stop it.
 
 ### Step 4: Fix and repeat if needed
 
 If the review is clean, move to the next plan.
 
-If the review finds issues, spawn a fresh Codex fixer:
+If the review finds issues, spawn a fresh Pi fixer:
 
 ```bash
-harnex run codex --id cx-fix-23-r1 --tmux
-harnex send --id cx-fix-23-r1 --message "Read /tmp/review-23-r1.md, fix every issue, run tests, and write a summary to /tmp/fix-23-r1.md." --wait-for-idle --timeout 1200
+harnex run pi --id pi-f-23-r1 --tmux pi-f-23-r1
+harnex send --id pi-f-23-r1 --message "Read /tmp/review-23-r1.md, fix every issue, run tests, and write a summary to /tmp/fix-23-r1.md." --wait-for-idle --timeout 1200
 ```
 
-Inspect with `harnex pane --id cx-fix-23-r1 --lines 80`, then stop it.
+Inspect with `harnex pane --id pi-f-23-r1 --lines 80`, then stop it.
 
-Then spawn another fresh Claude reviewer and repeat the review and fix
+Then spawn another fresh reviewer and repeat the review and fix
 loop until clean or until you decide the plan needs manual attention.
 
 ### Step 5: Next plan
@@ -84,12 +87,12 @@ Move to plan 24. Repeat from step 1.
 Use the plan number in every worker ID so you can tell them apart in
 `harnex status`:
 
- | Step      | ID pattern        | Example          |
- | ---       | ---               | ---              |
- | Plan      | `cx-plan-NN`      | `cx-plan-23`     |
- | Implement | `cx-impl-NN-rM`   | `cx-impl-23-r1`  |
- | Review    | `cl-rev-NN-rM`    | `cl-rev-23-r1`   |
- | Fix       | `cx-fix-NN-rM`    | `cx-fix-23-r1`   |
+ | Step      | ID pattern                  | Example        |
+ | ---       | ---                         | ---            |
+ | Plan      | `pi-p-NN`                   | `pi-p-23`      |
+ | Implement | `pi-i-NN-rM`                | `pi-i-23-r1`   |
+ | Review    | `cl-r-NN-rM` / `pi-r-NN-rM` | `cl-r-23-r1`   |
+ | Fix       | `pi-f-NN-rM`                | `pi-f-23-r1`   |
 
 ## Notes
 
@@ -98,8 +101,9 @@ Use the plan number in every worker ID so you can tell them apart in
   implement, review, and fix.
 - The batch is serial. Finish plan 23 completely before starting
   plan 24. Plans often build on each other.
-- Claude only reviews. Do not use Claude as the planner or fixer in
-  this recipe.
+- The reviewer only reviews. Do not use Claude as the planner or
+  fixer in this recipe, and never let the implementing Pi lane review
+  its own work.
 - Pass artifacts between steps as files (`/tmp/plan-23.md`,
   `/tmp/review-23-r1.md`), not as harnex reply messages.
 - If the review finds no issues, skip the fix step and move on.
@@ -111,5 +115,5 @@ fire-and-watch repeated with stronger discipline:
 
 - one worker per step
 - one artifact per handoff
-- one reviewer role, always Claude
+- one reviewer role, always a fresh Claude or Pi lane
 - one serial job stream, so later plans see earlier fixes

data/recipes/03_buddy.md

@@ -22,7 +22,7 @@ session using existing primitives.
 ### 1. Spawn the worker
 
 ```bash
-harnex run codex --id worker-42 --tmux worker-42
+harnex run pi --id worker-42 --tmux worker-42
 harnex send --id worker-42 --message "Read and execute /tmp/task-42.md"
 ```
 

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: harnex
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.29.0
 platform: ruby
 authors:
 - Jikku Jose
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-10-22 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.
+description: 'Hand questions and tasks to Pi workers in visible tmux windows and get
+  the result back in one call: lanes in git worktrees, follow-ups that keep context,
+  an MCP server for Claude Code and Pi, and a local harness for any terminal agent.'
 email:
 - jikkujose@gmail.com
 executables:
@@ -24,40 +25,50 @@ files:
 - LICENSE
 - README.md
 - TECHNICAL.md
+- agents/gpt.md
 - bin/gem-push
 - bin/harnex
-- docs/codex-appserver.md
+- docs/agents.md
 - docs/configuration.md
 - docs/dispatch-telemetry.md
 - docs/events.md
+- docs/lanes.md
+- docs/mcp.md
 - docs/pi-rpc.md
+- docs/upgrading-to-0.29.md
 - guides/01_dispatch.md
 - guides/02_chain.md
 - guides/03_buddy.md
 - guides/04_monitoring.md
 - guides/05_naming.md
+- guides/06_claude.md
 - lib/harnex.rb
 - lib/harnex/adapters.rb
 - lib/harnex/adapters/base.rb
 - lib/harnex/adapters/claude.rb
-- lib/harnex/adapters/codex.rb
-- lib/harnex/adapters/codex_appserver.rb
 - lib/harnex/adapters/generic.rb
 - lib/harnex/adapters/opencode.rb
 - lib/harnex/adapters/pi.rb
 - lib/harnex/artifact_report.rb
 - lib/harnex/cli.rb
-- lib/harnex/codex/app_server/client.rb
 - lib/harnex/commands/agents_guide.rb
 - lib/harnex/commands/artifact_report.rb
+- lib/harnex/commands/ask.rb
+- lib/harnex/commands/delegate.rb
 - lib/harnex/commands/doctor.rb
 - lib/harnex/commands/events.rb
 - lib/harnex/commands/guide.rb
 - lib/harnex/commands/history.rb
+- lib/harnex/commands/land.rb
+- lib/harnex/commands/lanes.rb
 - lib/harnex/commands/logs.rb
+- lib/harnex/commands/mcp.rb
 - lib/harnex/commands/orchestration.rb
 - lib/harnex/commands/pane.rb
+- lib/harnex/commands/preflight.rb
 - lib/harnex/commands/recipes.rb
+- lib/harnex/commands/reply.rb
+- lib/harnex/commands/result.rb
 - lib/harnex/commands/run.rb
 - lib/harnex/commands/send.rb
 - lib/harnex/commands/status.rb
@@ -67,19 +78,28 @@ files:
 - lib/harnex/commands/watch.rb
 - lib/harnex/commands/watch_presets.rb
 - lib/harnex/config.rb
+- lib/harnex/context_file.rb
 - lib/harnex/context_telemetry.rb
 - lib/harnex/core.rb
 - lib/harnex/dispatch_history.rb
+- lib/harnex/lanes.rb
+- lib/harnex/mcp.rb
 - lib/harnex/orchestration.rb
+- lib/harnex/owned_process_group.rb
+- lib/harnex/owner_stream.rb
 - lib/harnex/pricing.rb
 - lib/harnex/retention.rb
+- lib/harnex/runtime/activity_tracker.rb
 - lib/harnex/runtime/api_server.rb
 - lib/harnex/runtime/completion_notifier.rb
 - lib/harnex/runtime/file_change_hook.rb
 - lib/harnex/runtime/inbox.rb
 - lib/harnex/runtime/message.rb
+- lib/harnex/runtime/runtime_budget.rb
 - lib/harnex/runtime/session.rb
 - lib/harnex/runtime/session_state.rb
+- lib/harnex/runtime/stop_request.rb
+- lib/harnex/stall.rb
 - lib/harnex/telemetry_reconciler.rb
 - lib/harnex/terminal_status.rb
 - lib/harnex/version.rb
@@ -96,7 +116,9 @@ metadata:
   homepage_uri: https://github.com/jikkuatwork/harnex
   source_code_uri: https://github.com/jikkuatwork/harnex
   bug_tracker_uri: https://github.com/jikkuatwork/harnex/issues
-post_install_message: 
+  documentation_uri: https://harnex.zyt.app
+  changelog_uri: https://github.com/jikkuatwork/harnex/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.3
-signing_key: 
+signing_key:
 specification_version: 4
-summary: PTY harness for terminal AI agents
+summary: Pi workers (GPT models) as tools for you and your coding agents
 test_files: []