harnex 0.29.1 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e36a59564be22ba55cda2815e3e72b59b887bb2a4e0417be776295ef1cb10b82
-  data.tar.gz: 0a9b1355a5bc153e4d6fdd6ef79df81f022c5b6a75f97de0a8f91ef52353e526
+  metadata.gz: b4b50e456b0b9be717e037a0596b942273e2e4c192b80d697fc502a66cc4c220
+  data.tar.gz: 77ed9e03656bfff5f68064bb4dcb64f898d1de6b5d599ad30450ac51f8a1938e
 SHA512:
-  metadata.gz: 1794b1c8190bf40109732a821470d9a24772be9e68e46b9c49732ac46bd24fb73a88d07d0097dece3ec43e3b164932903d69ffda7fa6b4f18b244989990c8a52
-  data.tar.gz: 8163c5eb86dacb6174868459fcc9bba2fb87b66c503e61a96f38baefbe2ca93423df3a84fd07da626927402fe5432f4f541eec202a7b4cc4fde131e1b9ff7de4
+  metadata.gz: 85ca4102b12fe2a0e109c1fdfc643c96d80677b267c0b658cb4ff5787a72075e0d77e9d98a29bf401fa5975502cfc5fca891fe62c63ef51a92b8f626e2c60d04
+  data.tar.gz: 39b143e75ade8b68254742f6ea23eee43fde615c01de9c273d221b681b8b913f7c35e87b6bf9a79f84e290602790641fdb5a96e84c7a75fedad602b1ef6718d6

data/CHANGELOG.md

@@ -1,8 +1,51 @@
 # Changelog
 
+## [0.30.0] - 2026-10-25 | 02:55 AM | IST
+
+Holm's first nights with lanes (Holm Queue 167): #89–#92. Local install.
+
+### Fixed
+
+- **Lane names collided** (#89). Identical briefs in sibling worktrees of a
+  bare repo all became `pi-read-carry-out-brief`, and `harnex result NAME`
+  then failed with `several lanes are named …`.
+  - A bare layout (`repo/.bare` plus sibling worktrees) is one repo: its main
+    checkout is the worktree on the bare repo's `HEAD` branch, so every
+    worktree shares one lane namespace and `harnex lanes` shows them all.
+  - Generated names skip every name another lane still holds in any repo
+    (working, uncollected, or an unlanded worktree); `--name`, `--worktree`
+    and `ask --id` refuse a name while another repo's worker runs under it;
+    `result`/`reply` find a working lane from anywhere.
+  - A lane working in another worktree is named after it
+    (`pi-night-1024_s3`); brief openers such as "You are a … lane" and "carry
+    out the brief" no longer make the name.
+  - `delegate --worktree` refuses a `--cwd` that is already another worktree
+    of the repo (it would have branched from the main checkout instead).
+- **The `gpt` agent invented a `worktree`** from brief prose (#89). It now
+  sets `worktree`, `name` and `cwd` only from header lines, takes a new
+  `name:` header, and passes `cwd:` on to `result` and `reply`.
+- **A lane in place reported other people's commits** (#91). Its footer
+  counts only commits that appeared while the worker ran a git command, and
+  names the rest: `0 commits (HEAD also moved 6 commits by others)`.
+- **Messages sent straight to a worker were invisible** to the session that
+  started its lane (#92). `harnex send` now records who sent a message, and a
+  lane's result lists messages from anyone but the lane's owner and its own
+  `harnex reply` (`interjected: 1 message … from a terminal (harnex send):
+  "…"`). When a message reached the worker after it had answered, the result
+  shows the answers it replaced first, the original task's report among them.
+
+### Added
+
+- `.harnex/config.json` `lanes` templates put worktree lanes where the repo
+  keeps its worktrees (#90): `{"lanes": {"worktree_path": "../{name}",
+  "branch": "night/{mm}{dd}_{name}"}}` (`{name}`, `{yyyy}`, `{mm}`, `{dd}`).
+  `land` and `discard` follow each lane's own path and branch.
+- MCP `ask` takes `name`.
+
 ## [0.29.1] - 2026-10-23 | 10:31 AM | IST
 
-Local-only fix release for #88: lanes in repos with a phase allowlist.
+Fix release for #88: lanes in repos with a phase allowlist. Published to
+RubyGems on 2026-10-25 | 02:14 AM | IST.
 
 ### Fixed
 

data/agents/gpt.md

@@ -1,6 +1,6 @@
 ---
 name: gpt
-description: "Hand a task or question to a GPT model (a Pi worker run through harnex) and get its reply back verbatim. Use when the user asks for GPT, for another model's opinion or review, or to delegate work to Pi/GPT workers; launch several at once for parallel GPT work, and SendMessage the same agent for follow-ups (the worker keeps its context). While it runs, the harnex `lanes` tool or `harnex lanes` shows what each worker is doing right now (its current tool). Questions and reviews go to a read-only worker; a brief that asks to run commands, tests or benchmarks, or to change files, goes to a worker that can (in the current checkout). The prompt may open with header lines, then a blank line, then the brief: `worktree: NAME` (edit in a new git worktree on branch harnex/NAME; afterwards land it with the harnex `land` tool or `harnex land NAME`, which merges and removes the worktree and branch; don't git merge lane branches by hand), `mode: write` (run commands or edit the current checkout in place), `mode: read` (read-only even if the brief mentions commands), `model: provider/model`, `effort: low|medium|high`, `fallback: provider/model` (read-only asks), `cwd: <dir>`. Write a self-contained brief: the GPT worker has not seen this conversation."
+description: "Hand a task or question to a GPT model (a Pi worker run through harnex) and get its reply back verbatim. Use when the user asks for GPT, for another model's opinion or review, or to delegate work to Pi/GPT workers; launch several at once for parallel GPT work, and SendMessage the same agent for follow-ups (the worker keeps its context). While it runs, the harnex `lanes` tool or `harnex lanes` shows what each worker is doing right now (its current tool). Questions and reviews go to a read-only worker; a brief that asks to run commands, tests or benchmarks, or to change files, goes to a worker that can (in the current checkout). The prompt may open with header lines, then a blank line, then the brief: `worktree: NAME` (edit in a new git worktree on branch harnex/NAME; afterwards land it with the harnex `land` tool or `harnex land NAME`, which merges and removes the worktree and branch; don't git merge lane branches by hand), `mode: write` (run commands or edit the current checkout in place), `mode: read` (read-only even if the brief mentions commands), `model: provider/model`, `effort: low|medium|high`, `fallback: provider/model` (read-only asks), `cwd: <dir>` (work in that directory, e.g. a sibling worktree), `name: NAME` (the lane's name; default: the cwd worktree's name or the brief's first words). Write a self-contained brief: the GPT worker has not seen this conversation."
 tools: mcp__harnex__ask, mcp__harnex__delegate, mcp__harnex__reply, mcp__harnex__result
 mcpServers:
   - harnex
@@ -16,11 +16,16 @@ return its text.
 ## 1. Split the prompt
 
 The prompt may open with header lines `key: value` using only these keys:
-`worktree`, `mode`, `model`, `effort`, `fallback`, `cwd`. The header ends at
-the first line that is not one of them; drop one blank line after it.
+`worktree`, `mode`, `model`, `effort`, `fallback`, `cwd`, `name`. The header
+ends at the first line that is not one of them; drop one blank line after it.
 Everything after the header is the brief, kept exactly as written. No header
 lines means the whole prompt is the brief.
 
+Only header lines set tool arguments. Never take a `worktree`, `name` or
+`cwd` from the brief's wording, even when the brief names a worktree, a
+branch or a directory: the brief goes to the worker as it is, and the worker
+reads it.
+
 ## 2. Call one tool
 
 Pick the tool:
@@ -35,23 +40,26 @@ Then:
 
 - **`delegate`:** call it with
   - `task` = the brief;
-  - `worktree` = NAME, if given;
+  - `worktree` = NAME, only if the header has a `worktree:` line;
+  - `name` = NAME, if the header has a `name:` line and no `worktree:` line;
   - and `model`, `effort`, `cwd` if given.
 - **`ask`:** call it with
   - `question` = the brief;
-  - and `model`, `effort`, `cwd` if given, plus `fallback_model` from
+  - and `model`, `effort`, `cwd`, `name` if given, plus `fallback_model` from
     `fallback:`.
 - **A later message in this conversation** (a follow-up) goes to `reply`, with
   - `name` = the lane named in the last result's `── NAME:` footer;
-  - `message` = the new message, exactly as written.
+  - `message` = the new message, exactly as written;
+  - and `cwd` if the first prompt's header gave one.
 
 Pass every string exactly as written.
 
 ## 3. Still working
 
 If the tool's text ends with a footer saying `still working`, call `result`
-with `names` = [that lane name]. Repeat while it says still working, up to 12
-times. Never start a second lane for the same brief.
+with `names` = [that lane name], and `cwd` if the header gave one. Repeat
+while it says still working, up to 12 times. Never start a second lane for
+the same brief.
 
 ## 4. Return
 

data/docs/agents.md

@@ -59,10 +59,13 @@ Optional header lines, then a blank line, then the brief:
 | `mode: read` | Read-only, even if the brief mentions commands |
 | `model: provider/model`, `effort: low\|medium\|high` | Pick the worker's model |
 | `fallback: provider/model` | Retry a read-only ask on another model |
-| `cwd: DIR` | Work in another directory |
+| `cwd: DIR` | Work in another directory, e.g. a sibling worktree (follow-ups stay there) |
+| `name: NAME` | Name the lane (default: the `cwd` worktree's name, else the brief's first words) |
 
 Without a header, questions and reviews go to a read-only worker, and a brief
-that asks to run something or change files goes to a worker that can.
+that asks to run something or change files goes to a worker that can. Only
+header lines set these: a brief that mentions a worktree or a branch is passed
+on as it is, never turned into a `worktree`.
 The definition ships with harnex as [`agents/gpt.md`](../agents/gpt.md).
 
 ### The CLI from Claude's Bash tool

data/docs/lanes.md

@@ -5,7 +5,8 @@ its follow-ups. You start one with `harnex ask` or `harnex delegate`, collect
 it with `harnex result`, continue it with `harnex reply`, and finish it with
 `harnex land` or `harnex discard`. Every lane has a name, runs in a visible
 tmux window named after it, and leaves a small record so any later command can
-find it by name from anywhere in the repository.
+find it by name from anywhere in the repository (from any worktree of it, a
+bare-repo layout included).
 
 Lanes are the agent-facing layer of harnex. Everything here is also available
 as native tools through [`harnex mcp`](mcp.md), and the low-level `run`, `send`,
@@ -65,10 +66,19 @@ cost, commits and the next commands.
   `harnex/NAME` from `HEAD`. The worker is told to commit there. Parallel lanes
   never collide, and your checkout is untouched until you land. If your checkout
   has uncommitted changes, harnex warns that the worktree starts from `HEAD`.
-- **Without `--worktree`** the worker works in the current directory, which is
-  right for tasks that only run or inspect things (tests, a benchmark, a long
-  command). `--name NAME` names the lane; otherwise harnex derives a name from
-  the task (`pi-slow-bench`).
+  A repo that keeps its worktrees elsewhere says so in `.harnex/config.json`
+  (see [Where things live](#where-things-live)).
+- **Without `--worktree`** the worker works in the current directory, or in
+  `--cwd DIR`, which is right for tasks that only run or inspect things (tests,
+  a benchmark, a long command) and for a worktree you made yourself.
+- **Names.** `--name NAME` names the lane. Otherwise a lane working in another
+  worktree of the repo is named after it (`--cwd ../night-1024_s3` gives
+  `pi-night-1024_s3`), and any other lane after the task's first words
+  (`pi-slow-bench`, then `pi-slow-bench-2`). Generated names skip every name
+  another lane still holds anywhere (working, uncollected, or a worktree not
+  yet landed), and a name you choose is refused while another repo's worker
+  is running under it, so `harnex result NAME` and `reply NAME` find a
+  working lane from anywhere.
 - **`--file PATH`** reads a long brief from a file. Briefs must be
   self-contained: the worker has not seen your conversation. Name the files, the
   expected behavior and how to verify it.
@@ -126,6 +136,11 @@ or bare `land`.
 `harnex discard NAME` stops the lane if it is still working and deletes its
 worktree and branch without merging.
 
+**Lanes in place.** For a lane without a worktree, the footer counts only the
+commits the worker made (harnex watches `HEAD` around each git command the
+worker runs). Commits someone else made in the same checkout meanwhile are
+named apart: `0 commits (HEAD also moved 3 commits by others)`.
+
 ## Parallel lanes
 
 ```bash
@@ -153,6 +168,26 @@ mid-task as a follow-up; a lane that has finished is relaunched on its own Pi
 session (`pi --session`), so it remembers everything from the earlier turns.
 The footer's cost is the lane's total so far.
 
+**Messages from someone else.** Anyone can `harnex send` to a lane's worker
+(the owner from another terminal, a buddy). The lane's result then says so,
+so the session that started the lane is not left guessing:
+
+```text
+[earlier reply this turn, before another message reached the worker]
+Review: PASS (0 P1, 2 P2) ...
+
+[latest reply]
+Understood; the report is now in /tmp/review.md.
+
+── review: done in 6m10s · gpt-6.1-sol · $0.41 · 0 commits
+   interjected: 1 message reached the worker from outside this lane (the reply above may answer it; all: `harnex events --id review`):
+     23:26:04 from a terminal (harnex send): "Write the report to /tmp/review.md instead"
+```
+
+The worker's earlier answers in the same turn (the original task's report
+among them) come first; your own `harnex reply` follow-ups are never listed as
+interjections.
+
 ## When a model fails
 
 ```text
@@ -188,7 +223,18 @@ worker's tmux window, and the window itself is always there to watch.
   repo, worktree, branch, model, owner, Pi session, cost, last result). Closed
   lanes are pruned after 30 days; open lanes never are.
 - **Worktrees:** `.harnex/worktrees/NAME` inside your repository, on branch
-  `harnex/NAME`.
+  `harnex/NAME`. To keep them beside the main checkout instead, set templates
+  in the repo's `.harnex/config.json` (`{name}`, `{yyyy}`, `{mm}`, `{dd}`;
+  the path is relative to the main checkout). `land` and `discard` follow the
+  lane's own path and branch:
+
+  ```json
+  { "lanes": { "worktree_path": "../night-{mm}{dd}_{name}", "branch": "night/{mm}{dd}_{name}" } }
+  ```
+
+- **Bare-repo layouts** (`repo/.bare` plus sibling worktrees): the main
+  checkout is the worktree on the bare repo's `HEAD` branch (`master`), and
+  every worktree of the repo shares its lanes.
 - **`.harnex/`** is added to the clone's `.git/info/exclude` the first time
   harnex writes there, so lane worktrees and dispatch rows never show up as
   untracked work. Nothing tracked changes.

data/lib/harnex/commands/ask.rb

@@ -112,6 +112,9 @@ module Harnex
 
     def register_lane(id, model)
       cwd = File.expand_path(@options[:cwd] || Dir.pwd)
+      if (other = Lanes.live_holder(id))
+        raise OptionParser::InvalidArgument, "a worker named #{id} is working in #{other['repo_root']}; pick another --id"
+      end
       Lanes.save(
         "name" => id, "kind" => "ask", "repo_root" => Lanes.main_root(cwd) || cwd, "run_root" => run_root,
         "cwd" => cwd, "read_only" => !@options[:write], "owner" => Harnex.ambient_owner_id,
@@ -204,7 +207,8 @@ module Harnex
       answer = full_answer(turn)
       case exit_code
       when 0
-        @out.puts answer.to_s
+        lane = answered_lane(result["id"])
+        @out.puts(lane ? Lanes.render_answer(lane, turn.merge("final_message" => answer.to_s, "final_message_truncated" => false)) : answer.to_s)
         @err.puts("harnex ask: #{result['id']} answered in #{elapsed.round}s (model #{turn['model'] || 'Pi default'})")
       when Waiter::DONE_EXIT_TIMEOUT
         @err.puts("harnex ask: #{result['id']} is still working; keep waiting with: #{resume_command(result['id'])}")
@@ -216,6 +220,12 @@ module Harnex
       exit_code
     end
 
+    def answered_lane(id)
+      id && Lanes.resolve(id, from: File.expand_path(@options[:cwd] || Dir.pwd))
+    rescue OptionParser::InvalidArgument
+      nil
+    end
+
     def full_answer(turn)
       path = turn["final_message_path"].to_s
       return File.read(path).chomp if turn["final_message_truncated"] && !path.empty? && File.file?(path)

data/lib/harnex/commands/delegate.rb

@@ -17,8 +17,12 @@ module Harnex
         Options:
           --worktree NAME  Work in a new git worktree (.harnex/worktrees/NAME, branch
                            harnex/NAME); finish with `harnex land NAME` or
-                           `harnex discard NAME`
-          --name NAME      Lane name without a worktree (default: from the task)
+                           `harnex discard NAME`. The repo's .harnex/config.json
+                           can move it: {"lanes": {"worktree_path": "../{name}",
+                           "branch": "night/{mm}{dd}_{name}"}}
+          --name NAME      Lane name without a worktree (default: the --cwd
+                           worktree's name, else from the task). A working
+                           lane's name is unique across every repo
           --cwd DIR        Directory the worker works in (default: current directory)
           --file PATH      Read the task from PATH
           --model NAME     Pi model (provider/model); default: Pi's own default
@@ -86,9 +90,10 @@ module Harnex
       root = Lanes.main_root(workdir)
       raise OptionParser::InvalidArgument, "--worktree needs a git repository (#{workdir} is not in one)" if @options[:worktree] && root.nil?
 
+      refuse_nested_worktree!(root, workdir) if @options[:worktree]
       Lanes.sweep_merged(root)
       root ||= workdir
-      name = Lanes.validate_name!(@options[:worktree] || @options[:name] || Lanes.generate_name(root, task))
+      name = Lanes.validate_name!(@options[:worktree] || @options[:name] || Lanes.generate_name(root, task, cwd: workdir))
       ensure_free!(root, name)
       lane = {
         "name" => name, "kind" => "delegate", "repo_root" => root, "run_root" => root, "cwd" => workdir,
@@ -125,11 +130,27 @@ module Harnex
               "lane #{name} already exists (#{existing['state']}): follow up with `harnex reply #{name} \"...\"`, " \
               "or `harnex land #{name}` / `harnex discard #{name}` first"
       end
+      if (other = Lanes.live_holder(name)) && other["repo_root"] != root
+        raise OptionParser::InvalidArgument,
+              "a worker named #{name} is working in #{other['repo_root']}; working lanes' names are unique, " \
+              "so pick another name (or wait: `harnex result #{name}`)"
+      end
       return unless Harnex.read_registry(root, name)
 
       raise OptionParser::InvalidArgument, "a harnex session named #{name} is running; pick another name"
     end
 
+    # #89: --cwd in a sibling worktree plus --worktree would branch a new
+    # worktree from the main checkout, not from --cwd; say so instead.
+    def refuse_nested_worktree!(root, workdir)
+      top = Lanes.toplevel(workdir)
+      return if top.nil? || root.nil? || Lanes.same_dir?(top, root)
+
+      raise OptionParser::InvalidArgument,
+            "--cwd #{top} is already a worktree of #{root}: drop --worktree to work there in place, " \
+            "or drop --cwd to start a new worktree from the main checkout"
+    end
+
     def warn_uncommitted(root)
       dirty = Lanes.dirty_paths(root)
       return if dirty.empty?

data/lib/harnex/commands/reply.rb

@@ -61,7 +61,8 @@ module Harnex
     def follow_up(lane, message)
       argv = @harnex_command + ["send", "--id", lane["name"], "--repo", lane["run_root"], "--message", message]
       argv += ["--wait-done"] + (@options[:timeout] ? ["--timeout", @options[:timeout].to_s] : []) if @options[:wait]
-      stdout, stderr, status = Open3.capture3(*argv)
+      # Marked as the lane's own follow-up, not an interjection (#92).
+      stdout, stderr, status = Open3.capture3({ "HARNEX_SEND_VIA" => "reply" }, *argv)
       result = Lanes.last_json(stdout)
       raise Lanes::LaunchError, "harnex could not reach lane #{lane['name']}: #{stderr.strip.lines.last}" if result.empty?
 

data/lib/harnex/commands/result.rb

@@ -71,7 +71,7 @@ module Harnex
       text = if @options[:json]
                JSON.generate(lane: lane["name"], exit_code: exit_code, state: lane["state"], result: turn)
              elsif lane["kind"] == "ask" && exit_code.zero?
-               Lanes.final_message(turn)
+               Lanes.render_answer(lane, turn)
              else
                Lanes.render(lane, turn, exit_code)
              end

data/lib/harnex/commands/send.rb

@@ -141,7 +141,8 @@ module Harnex
           text: text,
           submit: @options[:submit],
           enter_only: @options[:submit_only],
-          force: @options[:force]
+          force: @options[:force],
+          from: Harnex.sender_identity
         )
 
         Net::HTTP.start(

data/lib/harnex/commands/wait.rb

@@ -488,7 +488,8 @@ module Harnex
       }
       payload[:turn] = event["turn"] if event["turn"]
       payload[:follow_ups] = event["follow_ups"] if event["follow_ups"]
-      %w[end_sha commits turn_commits model final_message final_message_path final_message_truncated].each do |key|
+      %w[end_sha commits turn_commits model final_message final_message_path final_message_truncated
+         earlier_replies].each do |key|
         payload[key.to_sym] = event[key] if event.key?(key)
       end
       exit_code = 0

data/lib/harnex/config.rb

@@ -6,6 +6,7 @@ module Harnex
     PHASE_POLICIES = %w[warn reject].freeze
     RETENTION_DIRS = %w[events output receipts].freeze
     RETENTION_FIELDS = %w[max_age_days max_bytes].freeze
+    LANE_TEMPLATES = %w[worktree_path branch].freeze
     RETENTION_ENV = {
       "events" => {
         "max_age_days" => "HARNEX_EVENTS_MAX_AGE_DAYS",
@@ -38,6 +39,10 @@ module Harnex
       def retention
         data.is_a?(Hash) ? data["retention"] : nil
       end
+
+      def lanes
+        data.is_a?(Hash) ? data["lanes"] : nil
+      end
     end
 
     module_function
@@ -63,6 +68,22 @@ module Harnex
 
       validate_phase!(document["phase"], path) if document.key?("phase")
       validate_retention!(document["retention"], path) if document.key?("retention")
+      validate_lanes!(document["lanes"], path) if document.key?("lanes")
+    end
+
+    # #90: where worktree lanes live and what their branches are called,
+    # e.g. {"worktree_path": "../{name}", "branch": "night/{mm}{dd}_{name}"}.
+    def validate_lanes!(lanes, path)
+      raise ConfigError, "#{path}: $.lanes must be an object" unless lanes.is_a?(Hash)
+
+      lanes.each do |key, template|
+        unless LANE_TEMPLATES.include?(key)
+          raise ConfigError, "#{path}: $.lanes.#{key} is not supported (expected #{LANE_TEMPLATES.join(' or ')})"
+        end
+        next if template.is_a?(String) && template.include?("{name}")
+
+        raise ConfigError, "#{path}: $.lanes.#{key} must be a string containing {name}"
+      end
     end
 
     def validate_phase!(phase, path)

data/lib/harnex/core.rb

@@ -450,6 +450,17 @@ module Harnex
     nil
   end
 
+  # #92: who is sending a message, for the receiving lane's footer. `via`
+  # is "reply" when `harnex reply` sends on the lane's behalf
+  # (HARNEX_SEND_VIA), else "send".
+  def sender_identity(env = ENV)
+    {
+      "via" => env["HARNEX_SEND_VIA"].to_s.strip.empty? ? "send" : env["HARNEX_SEND_VIA"].strip,
+      "session" => env["HARNEX_ID"].to_s.strip,
+      "owner" => ambient_owner_id(env).to_s
+    }.reject { |_key, value| value.empty? }
+  end
+
   # How to invoke this harnex in a printed hint: the checkout's bin when
   # running from source, plain `harnex` for the installed gem.
   def cli_command

data/lib/harnex/lanes.rb

@@ -74,20 +74,45 @@ module Harnex
     end
 
     # A name resolves to this repo's lane first, then to the only lane
-    # anywhere with that name.
+    # anywhere whose worker is running (those names are unique, #89), then
+    # in flight, open, or at all.
     def resolve(name, from: Dir.pwd)
       root = main_root(from)
       lane = root && load(root, name)
       return lane if lane
 
       matches = all.select { |candidate| candidate["name"] == name }
-      return matches.first if matches.one?
       raise OptionParser::InvalidArgument, "no lane named #{name.inspect} (see `harnex lanes`)" if matches.empty?
 
+      [matches.select { |l| open?(l) && live?(l) }, matches.select { |l| in_flight?(l) },
+       matches.select { |l| open?(l) }, matches].each do |group|
+        return group.first if group.one?
+      end
       raise OptionParser::InvalidArgument,
             "several lanes are named #{name.inspect} (#{matches.map { |l| l['repo_root'] }.join(', ')}); run from the lane's repo"
     end
 
+    # Working (or finished but uncollected), or a worktree not yet landed,
+    # in a repo that still exists.
+    def in_flight?(lane)
+      open?(lane) && !never_started?(lane) && (lane["state"] == "running" || !lane["branch"].nil?) &&
+        File.directory?(lane["repo_root"].to_s)
+    end
+
+    # #89: the in-flight lane anywhere that holds `name`, if any. Generated
+    # names skip these, so `harnex result NAME` and `reply NAME` find their
+    # lane from anywhere.
+    def holder(name)
+      all.find { |lane| lane["name"] == name && in_flight?(lane) }
+    end
+
+    # The lane anywhere whose worker is running under `name`, if any. A name
+    # someone chooses is refused only while another repo's worker has it, so
+    # stale lanes elsewhere (an old eval, an abandoned clone) never block it.
+    def live_holder(name)
+      all.find { |lane| lane["name"] == name && open?(lane) && live?(lane) }
+    end
+
     # Lanes this caller started in this repo whose current turn nobody has
     # collected yet.
     def pending(from: Dir.pwd, owner: Harnex.ambient_owner_id)
@@ -98,20 +123,32 @@ module Harnex
 
     FILLER = %w[a an the this that these those to of in on at for from with and or but it its please
                 run use add make have has can could would should will do does just then also your you
-                our my me i we gpt worker workers task repo repository git command file files code].freeze
-
-    def generate_name(root, task, prefix: "pi")
-      words = task.to_s.downcase.scan(/[a-z0-9]+/).reject { |word| FILLER.include?(word) }.first(4)
-      base = ([prefix] + words).join("-")[0, 40].sub(/-+\z/, "")
+                our my me i we gpt worker workers task repo repository git command file files code
+                are is be carry out brief lane].freeze
+
+    # A lane working in another worktree of the repo is named after that
+    # worktree (`pi-night-1024_s3`); otherwise after the task's first words.
+    # Either way no repo has the name in flight (#89).
+    def generate_name(root, task, cwd: nil, prefix: "pi")
+      base = ([prefix] + name_words(root, task, cwd)).join("-")[0, 40].sub(/[-_.]+\z/, "")
       name = base
       index = 2
-      while open?(load(root, name)) || Harnex.read_registry(root, name)
+      while open?(load(root, name)) || holder(name) || Harnex.read_registry(root, name)
         name = "#{base}-#{index}"
         index += 1
       end
       name
     end
 
+    def name_words(root, task, cwd)
+      top = cwd && toplevel(cwd)
+      if top && root && !same_dir?(top, root)
+        slug = File.basename(top).downcase.gsub(/[^a-z0-9._-]+/, "-").sub(/\A[^a-z0-9]+/, "")
+        return [slug] unless slug.empty?
+      end
+      task.to_s.downcase.scan(/[a-z0-9]+/).reject { |word| FILLER.include?(word) || word.match?(/\A[a-z]\z/) }.first(4)
+    end
+
     def live?(lane)
       registry = Harnex.read_registry(lane["run_root"], lane["name"])
       !registry.nil? && Harnex.alive_pid?(registry["pid"])
@@ -155,17 +192,43 @@ module Harnex
     end
 
     # The main checkout of the repo that contains `path` (also from inside one
-    # of its worktrees), or nil outside git.
+    # of its worktrees), or nil outside git. In a bare layout (`repo/.bare`
+    # plus sibling worktrees, #89) it is the worktree on the bare repo's HEAD
+    # branch, so every worktree of the repo shares one lane namespace.
     def main_root(path)
       common, _err, ok = git(path, "rev-parse", "--path-format=absolute", "--git-common-dir")
       return nil unless ok
 
       return File.dirname(common) if File.basename(common) == ".git"
 
+      bare_main_worktree(path, common) || toplevel(path)
+    end
+
+    def same_dir?(one, two)
+      File.realpath(one.to_s) == File.realpath(two.to_s)
+    rescue SystemCallError
+      File.expand_path(one.to_s) == File.expand_path(two.to_s)
+    end
+
+    def toplevel(path)
       top, _err, ok = git(path, "rev-parse", "--show-toplevel")
       ok ? top : nil
     end
 
+    def bare_main_worktree(path, common)
+      list, _err, ok = git(path, "worktree", "list", "--porcelain")
+      return nil unless ok
+
+      entries = list.split(/\n{2,}/).map do |block|
+        block.lines.to_h { |line| line.chomp.split(" ", 2).then { |key, value| [key, value.to_s] } }
+      end
+      return nil unless entries.first&.key?("bare")
+
+      head, _err, ok = git(common, "symbolic-ref", "-q", "HEAD")
+      main = ok && entries.find { |entry| entry["branch"] == head && File.directory?(entry["worktree"].to_s) }
+      main ? main["worktree"] : nil
+    end
+
     def head_sha(dir)
       sha, _err, ok = git(dir, "rev-parse", "HEAD")
       ok ? sha : nil
@@ -176,10 +239,28 @@ module Harnex
       ok ? out.lines.map { |line| line[3..].to_s.strip } : []
     end
 
+    # #90: a worktree lane lives at .harnex/worktrees/NAME on harnex/NAME,
+    # unless the repo's .harnex/config.json `lanes` templates say otherwise
+    # ({name}, {yyyy}, {mm}, {dd}; worktree_path is relative to the main
+    # checkout, so "../{name}" puts lanes beside it).
+    def worktree_layout(root, name, now: Time.now)
+      templates = Config.load_repo(root).lanes || {}
+      fill = lambda do |template|
+        template.gsub("{name}", name).gsub("{yyyy}", now.strftime("%Y")).gsub("{mm}", now.strftime("%m"))
+                .gsub("{dd}", now.strftime("%d"))
+      end
+      path = fill.call(templates["worktree_path"] || File.join(WORKTREES_DIR, "{name}"))
+      [File.expand_path(path, root), fill.call(templates["branch"] || "#{BRANCH_PREFIX}{name}")]
+    rescue Config::ConfigError => e
+      raise OptionParser::InvalidArgument, "invalid config #{e.message}"
+    end
+
     def create_worktree(root, name)
       Harnex.ensure_git_excluded(root)
-      worktree = File.join(root, WORKTREES_DIR, name)
-      branch = BRANCH_PREFIX + name
+      worktree, branch = worktree_layout(root, name)
+      _out, _err, valid = git(root, "check-ref-format", "--branch", branch)
+      raise OptionParser::InvalidArgument, "lanes.branch gives #{branch.inspect}, which is not a valid branch name" unless valid
+
       _out, _err, exists = git(root, "rev-parse", "--verify", "--quiet", "refs/heads/#{branch}")
       if exists || File.exist?(worktree)
         raise OptionParser::InvalidArgument,
@@ -259,8 +340,12 @@ module Harnex
       merged
     end
 
+    # Inside the checkout: "a/b"; beside it: "../x"; anywhere else: absolute.
     def relative(root, path)
-      path.to_s.start_with?("#{root}/") ? path.to_s.delete_prefix("#{root}/") : path.to_s
+      return path.to_s.delete_prefix("#{root}/") if path.to_s.start_with?("#{root}/")
+
+      sibling = "../#{File.basename(path.to_s)}"
+      File.expand_path(sibling, root.to_s) == File.expand_path(path.to_s) ? sibling : path.to_s
     end
 
     # ---- briefs ------------------------------------------------------------
@@ -419,7 +504,7 @@ module Harnex
       lane["settled_at"] = now
       # Kept so a later `harnex result NAME` can show the result again.
       lane["last_turn"] = turn.slice("final_message", "final_message_path", "final_message_truncated", "model",
-                                     "outcome_class", "status", "last_error", "end_sha")
+                                     "outcome_class", "status", "last_error", "end_sha", "earlier_replies")
       save(lane)
     end
 
@@ -436,13 +521,79 @@ module Harnex
 
     def render(lane, turn, exit_code)
       lines = []
-      message = final_message(turn)
+      message = with_earlier_replies(final_message(turn), turn)
       lines << message.rstrip << "" unless message.strip.empty? || exit_code == Waiter::DONE_EXIT_TIMEOUT
       lines << "── #{lane['name']}: #{headline(lane, turn, exit_code)}"
-      lines.concat(details(lane, exit_code).map { |line| "   #{line}" })
+      lines.concat((interjection_lines(lane) + details(lane, exit_code)).map { |line| "   #{line}" })
       lines.join("\n")
     end
 
+    # An answered ask prints only its answer, plus what else reached the
+    # worker (#92).
+    def render_answer(lane, turn)
+      text = with_earlier_replies(final_message(turn), turn)
+      notes = interjection_lines(lane)
+      return text if notes.empty?
+
+      [text.rstrip, "", "── #{lane['name']}: #{notes.first}", *notes.drop(1).map { |line| "   #{line}" }].join("\n")
+    end
+
+    # #92: when a later message reached the worker after it had answered,
+    # the turn's result is its answer to that message; the answers it
+    # replaced (the original task's report among them) come first.
+    def with_earlier_replies(message, turn)
+      earlier = Array(turn["earlier_replies"]).map(&:to_s).reject { |text| text.strip.empty? }
+      return message if earlier.empty? || message.strip.empty?
+
+      parts = earlier.map { |text| "[earlier reply this turn, before another message reached the worker]\n#{text.rstrip}" }
+      (parts + ["[latest reply]\n#{message.rstrip}"]).join("\n\n")
+    end
+
+    # #92: messages that reached the worker from anyone but the lane's own
+    # owner and its `harnex reply` (someone's `harnex send` from another
+    # terminal or session), since the lane's latest launch.
+    def interjections(lane)
+      events(lane).select do |event|
+        event["type"] == "send" && event["from"].is_a?(Hash) && after?(event["ts"], lane["launched_at"]) &&
+          !own_message?(lane, event["from"])
+      end
+    end
+
+    def own_message?(lane, from)
+      owner = lane["owner"].to_s
+      from["owner"].to_s == owner && (!owner.empty? || from["via"] == "reply")
+    end
+
+    def interjection_lines(lane)
+      found = interjections(lane)
+      return [] if found.empty?
+
+      count = found.length == 1 ? "1 message" : "#{found.length} messages"
+      ["interjected: #{count} reached the worker from outside this lane " \
+       "(the reply above may answer #{found.length == 1 ? 'it' : 'them'}; all: `harnex events --id #{lane['name']}`):"] +
+        found.last(5).map { |event| "  #{clock(event['ts'])} #{sender_label(event['from'])}: #{preview(event)}" }
+    end
+
+    def sender_label(from)
+      who = if from["session"] then "harnex session #{from['session']}"
+            elsif from["owner"] then "session #{from['owner'][0, 8]}"
+            else "a terminal"
+            end
+      "from #{who} (harnex #{from['via'] || 'send'})"
+    end
+
+    def preview(event)
+      text = event["msg"].to_s.sub(/\A\[harnex [^\]]*\]\s*/, "").gsub(/\s+/, " ").strip
+      cut = text.length > 160 || event["msg_truncated"]
+      "\"#{text[0, 160]}#{cut ? '…' : ''}\""
+    end
+
+    def clock(ts)
+      Time.iso8601(ts.to_s).localtime.strftime("%H:%M:%S")
+    rescue ArgumentError
+      ts.to_s
+    end
+
     def headline(lane, turn, exit_code)
       model = turn["model"] || lane["model"] || lane["requested_model"]
       parts = []
@@ -465,6 +616,9 @@ module Harnex
       dir = lane["worktree"] || lane["cwd"]
       return nil unless lane["base_sha"] && File.directory?(dir.to_s)
 
+      shas = lane["branch"] ? nil : worker_commits(lane)
+      return worker_change_summary(lane, dir, shas) if shas
+
       count, _err, ok = git(dir, "rev-list", "--count", "#{lane['base_sha']}..HEAD")
       return nil unless ok
 
@@ -473,6 +627,47 @@ module Harnex
       stat.empty? ? commits : "#{commits}, #{compact_stat(stat)}"
     end
 
+    # #91: a lane working in place shares HEAD with whoever else commits
+    # there, so count only the commits the worker made (worker_commits
+    # events). nil when the worker's harnex did not track them.
+    def worker_commits(lane)
+      found = events(lane).select { |event| after?(event["ts"], lane["created_at"]) }
+      return nil unless found.any? { |event| event["type"] == "git" && event["tracks_worker_commits"] }
+
+      found.select { |event| event["type"] == "worker_commits" }.flat_map { |event| Array(event["shas"]) }
+    end
+
+    def worker_change_summary(lane, dir, shas)
+      moved, _err, ok = git(dir, "rev-list", "#{lane['base_sha']}..HEAD")
+      return nil unless ok
+
+      history = moved.split
+      mine = history & shas
+      text = "#{mine.length} commit#{mine.length == 1 ? '' : 's'}"
+      stat = mine.empty? ? nil : commits_stat(dir, mine)
+      text += ", #{stat}" if stat
+      others = history.length - mine.length
+      text += " (HEAD also moved #{others} commit#{others == 1 ? '' : 's'} by others)" if others.positive?
+      text
+    end
+
+    def commits_stat(dir, shas)
+      out, _err, ok = git(dir, "show", "--numstat", "--format=", *shas)
+      return nil unless ok
+
+      files = {}
+      added = removed = 0
+      out.each_line do |line|
+        plus, minus, path = line.chomp.split("\t", 3)
+        next unless path
+
+        files[path] = true
+        added += plus.to_i
+        removed += minus.to_i
+      end
+      "#{files.size} file#{files.size == 1 ? '' : 's'} (+#{added} -#{removed})"
+    end
+
     def compact_stat(stat)
       files = stat[/(\d+) files? changed/, 1]
       added = stat[/(\d+) insertions?/, 1]

data/lib/harnex/mcp.rb

@@ -41,6 +41,7 @@ module Harnex
           "model" => MODEL, "effort" => EFFORT,
           "fallback_model" => { "type" => "string", "description" => "Ask this model instead if the first is rate limited" },
           "write" => { "type" => "boolean", "description" => "Let the worker edit files and run commands (default false)" },
+          "name" => { "type" => "string", "description" => "Lane name (default: pi-ask-<random>)" },
           "cwd" => CWD, "wait_minutes" => WAIT_MINUTES
         } },
         "annotations" => { "readOnlyHint" => false, "openWorldHint" => true }
@@ -56,7 +57,7 @@ module Harnex
         "inputSchema" => { "type" => "object", "required" => ["task"], "properties" => {
           "task" => { "type" => "string", "description" => "Self-contained brief: files, expected behavior, how to verify (e.g. the test command)" },
           "worktree" => { "type" => "string", "description" => "Lane name; work in a new git worktree on branch harnex/NAME (recommended for edits)" },
-          "name" => { "type" => "string", "description" => "Lane name when not using a worktree (default: from the task)" },
+          "name" => { "type" => "string", "description" => "Lane name when not using a worktree (default: the cwd worktree's name, else from the task)" },
           "wait" => { "type" => "boolean", "description" => "Wait for the result (default true); false starts the lane and returns at once" },
           "model" => MODEL, "effort" => EFFORT, "cwd" => CWD, "wait_minutes" => WAIT_MINUTES
         } },
@@ -250,10 +251,11 @@ module Harnex
         case tool
         when "delegate"
           if args["worktree"].to_s.empty? && args["name"].to_s.empty?
-            root = Lanes.main_root(work_dir(args)) || work_dir(args)
-            args["name"] = Lanes.generate_name(root, args["task"] || args["prompt"] || args["brief"])
+            dir = work_dir(args)
+            args["name"] = Lanes.generate_name(Lanes.main_root(dir) || dir, args["task"] || args["prompt"] || args["brief"], cwd: dir)
           end
         when "ask"
+          args["id"] = args["name"] unless args["name"].to_s.strip.empty?
           args["id"] ||= "pi-ask-#{SecureRandom.hex(2)}"
         end
         args

data/lib/harnex/runtime/api_server.rb

@@ -78,7 +78,8 @@ module Harnex
             text: payload[:text],
             submit: payload[:submit],
             enter_only: payload[:enter_only],
-            force: payload[:force]
+            force: payload[:force],
+            from: payload[:from]
           )
           http_code = result.delete(:http_status) || 200
           json(client, http_code, result)
@@ -136,6 +137,15 @@ module Harnex
       context
     end
 
+    # Who sent a message (#92), as `harnex send` reports it: bounded strings.
+    def sender(value)
+      return nil unless value.is_a?(Hash)
+
+      value.slice("via", "session", "owner").filter_map do |key, text|
+        [key, text.to_s[0, 120]] unless text.to_s.strip.empty?
+      end.to_h
+    end
+
     def parse_send_body(headers, body)
       if headers["content-type"].to_s.include?("application/json")
         parsed = JSON.parse(body.empty? ? "{}" : body)
@@ -145,7 +155,8 @@ module Harnex
             text: parsed["text"].to_s,
             submit: parsed.fetch("submit", true),
             enter_only: parsed.fetch("enter_only", false),
-            force: parsed.fetch("force", false)
+            force: parsed.fetch("force", false),
+            from: sender(parsed["from"])
           }
         else
           {

data/lib/harnex/runtime/inbox.rb

@@ -32,13 +32,14 @@ module Harnex
       @thread&.kill
     end
 
-    def enqueue(text:, submit:, enter_only:, force: false)
+    def enqueue(text:, submit:, enter_only:, force: false, from: nil)
       msg = Message.new(
         id: SecureRandom.hex(8),
         text: text,
         submit: submit,
         enter_only: enter_only,
         force: force,
+        from: from,
         queued_at: Time.now,
         status: :queued
       )
@@ -139,6 +140,7 @@ module Harnex
     def deliver_now(msg, follow_up: false)
       options = { text: msg.text, submit: msg.submit, enter_only: msg.enter_only, force: msg.force }
       options[:follow_up] = true if follow_up
+      options[:from] = msg.from if msg.from
       result = @session.inject_via_adapter(**options)
       msg.status = :delivered
       msg.delivered_at = Time.now

data/lib/harnex/runtime/message.rb

@@ -1,6 +1,6 @@
 module Harnex
   Message = Struct.new(:id, :text, :submit, :enter_only, :force, :queued_at, :status, :delivered_at, :error,
-                       :after_seq, :delivery, keyword_init: true) do
+                       :after_seq, :delivery, :from, keyword_init: true) do
     def to_h
       {
         id: id,

data/lib/harnex/runtime/session.rb

@@ -61,6 +61,7 @@ module Harnex
     MAX_PENDING_PI_COMMANDS = 256
     # Inline cap for a turn's final reply; the full text is in its file.
     FINAL_MESSAGE_LIMIT = 4000
+    MAX_EARLIER_REPLIES = 3
     class EventCounters
       def initialize
         @counts = {
@@ -171,6 +172,7 @@ module Harnex
       @turn_follow_ups_sent = 0
       @pi_follow_up_pending = 0
       @turn_final_text = nil
+      @turn_earlier_replies = []
       @completion_notifier = completion_notifier || CompletionNotifier.new(
         repo_root: repo_root,
         id: @id,
@@ -190,6 +192,7 @@ module Harnex
       @observed_commands_mutex = Mutex.new
       @observed_commands = []
       @pi_pending_commands = {}
+      @pi_git_heads = {}
       @pi_unobserved_commands = 0
       # Final gates and the failure flag cover the whole command history; the
       # retained @observed_commands window is capped at MAX_COMMANDS (#68).
@@ -480,10 +483,12 @@ module Harnex
       { ok: true, signal: "exit_sequence_sent" }
     end
 
-    def inject_via_adapter(text:, submit:, enter_only:, force: false, follow_up: false)
+    # `from` names who sent a message through `harnex send` (#92); the
+    # launch prompt has none.
+    def inject_via_adapter(text:, submit:, enter_only:, force: false, follow_up: false, from: nil)
       if structured_transport?
         return inject_via_structured(text: text, submit: submit, enter_only: enter_only, force: force,
-                                     follow_up: follow_up)
+                                     follow_up: follow_up, from: from)
       end
 
       after_seq = current_event_seq
@@ -509,7 +514,7 @@ module Harnex
         force: payload[:force],
         after_seq: after_seq
       )
-        .tap { emit_send_event(text, force: payload[:force]) }
+        .tap { emit_send_event(text, force: payload[:force], from: from) }
     end
 
     # #79: a structured adapter that can queue a message into the running turn
@@ -525,7 +530,7 @@ module Harnex
       @events_mutex.synchronize { @events_log_seq }
     end
 
-    def inject_via_structured(text:, submit:, enter_only:, force: false, follow_up: false)
+    def inject_via_structured(text:, submit:, enter_only:, force: false, follow_up: false, from: nil)
       if @runtime_budget&.expired?
         stop_for_runtime_budget!
         raise ArgumentError, "session runtime budget is exhausted"
@@ -560,6 +565,8 @@ module Harnex
           # is reset here. If Pi has in fact gone idle it starts a new run,
           # whose agent_start begins the next turn.
           unless queued_into_run
+            # A new prompt answers nothing earlier in this turn (#92).
+            @pi_last_answer = nil
             # Reserve work before the blocking RPC. Steering an active run does
             # not reset its clocks, but a new prompt cannot reuse old proof.
             @activity.start_turn
@@ -584,7 +591,7 @@ module Harnex
         end
       end
 
-      emit_send_event(dispatch_options.fetch(:prompt, text), force: payload[:force])
+      emit_send_event(dispatch_options.fetch(:prompt, text), force: payload[:force], from: from)
       {
         ok: true,
         cli: adapter.key,
@@ -930,6 +937,7 @@ module Harnex
         adapter.request_session_stats_async if adapter.respond_to?(:request_session_stats_async)
         schedule_auto_stop("agent_settled", interrupt: false) if task_complete? || task_failed?
       when "message_start"
+        note_pi_user_message(message["message"])
         @pi_active_message_key = pi_message_key(message["message"])
         @pi_streamed_text_by_message[@pi_active_message_key] = false
       when "message_update"
@@ -955,6 +963,7 @@ module Harnex
         if pi_command_tool?(message)
           @event_counters.record_item({ "type" => "commandExecution" })
           start_pi_command(message)
+          note_pi_git_head(message)
         else
           @event_counters.record_item({ "type" => "dynamicToolCall" })
         end
@@ -962,7 +971,10 @@ module Harnex
           "tool: #{message["toolName"] || "tool"}#{message["args"] ? " #{summarize(message["args"])}" : ""}"
         )
       when "tool_execution_end"
-        finish_pi_command(message) if pi_command_tool?(message)
+        if pi_command_tool?(message)
+          finish_pi_command(message)
+          record_pi_worker_commits(message)
+        end
         tool_name = message["toolName"] || "tool"
         status = message["isError"] ? "error" : "ok"
         record_synthesized("tool-result: #{tool_name} (#{status})")
@@ -1198,6 +1210,9 @@ module Harnex
 
       text = pi_extract_message_text(message).to_s
       @turn_final_text = text unless text.strip.empty?
+      # An answer (stopReason "stop"), kept apart from the run outcome that
+      # every turn_start resets (#92).
+      @pi_last_answer = message["stopReason"] == "stop" && !text.strip.empty? ? text : nil
 
       reason = message["stopReason"].to_s
       @pi_last_assistant_stop_reason = reason unless reason.empty?
@@ -1205,6 +1220,49 @@ module Harnex
       @pi_last_assistant_error = error unless error.empty?
     end
 
+    # #92: a message that reaches the worker after it has answered (a
+    # follow-up from the lane's owner or from anyone else) starts a new
+    # answer; keep the one it replaces so the turn's result still has it.
+    def note_pi_user_message(message)
+      return unless message.is_a?(Hash) && message["role"] == "user"
+
+      text = @pi_last_answer.to_s.strip
+      @pi_last_answer = nil
+      return if text.empty? || @turn_earlier_replies.last == text
+
+      @turn_earlier_replies = (@turn_earlier_replies + [text]).last(MAX_EARLIER_REPLIES)
+    end
+
+    # #91: commits the worker made, told apart from HEAD moving under it
+    # (an orchestrator committing in the same checkout): HEAD is read around
+    # each command that runs git, and only commits that appear during one
+    # count as the worker's.
+    def note_pi_git_head(message)
+      args = message["args"]
+      command = args["command"] if args.is_a?(Hash)
+      return unless command.is_a?(String) && command.match?(/\bgit\b/) && @git_start && !@git_start.empty?
+
+      head = observed_git_head
+      @pi_git_heads[message["toolCallId"].to_s] = head if head
+    end
+
+    def record_pi_worker_commits(message)
+      before = @pi_git_heads.delete(message["toolCallId"].to_s)
+      after = before && observed_git_head
+      return if after.nil? || after == before
+
+      shas = Harnex.git_output(git_observation_root, "rev-list", "--max-count=100", "#{before}..#{after}").split
+      emit_event("worker_commits", shas: shas) unless shas.empty?
+    rescue StandardError
+      nil
+    end
+
+    def observed_git_head
+      Harnex.git_output(git_observation_root, "rev-parse", "HEAD")
+    rescue StandardError
+      nil
+    end
+
     def settle_pi_task!
       return if @stop_requested || @pi_transport_failed
 
@@ -1392,6 +1450,8 @@ module Harnex
         @completion_notification_sent = false
         @turn_follow_ups_sent = 0
         @turn_final_text = nil
+        @turn_earlier_replies = []
+        @pi_last_answer = nil
         @completion_turn += 1
       end
       return unless turn
@@ -1451,6 +1511,7 @@ module Harnex
       end
       fields = { final_message: text[0, FINAL_MESSAGE_LIMIT], final_message_path: path }
       fields[:final_message_truncated] = true if text.length > FINAL_MESSAGE_LIMIT
+      fields[:earlier_replies] = @turn_earlier_replies.map { |reply| reply[0, FINAL_MESSAGE_LIMIT] } if @turn_earlier_replies.any?
       fields
     rescue StandardError
       { final_message: text[0, FINAL_MESSAGE_LIMIT] }
@@ -1658,11 +1719,13 @@ module Harnex
       warn("harnex: failed to write output log #{output_log_path}: #{e.message}")
     end
 
-    def emit_send_event(text, force:)
+    def emit_send_event(text, force:, from: nil)
       compact = text.to_s
       truncated = compact.length > 200
       preview = truncated ? "#{compact[0, 200]}…" : compact
-      emit_event("send", msg: preview, msg_truncated: truncated, forced: !!force)
+      payload = { msg: preview, msg_truncated: truncated, forced: !!force }
+      payload[:from] = from if from.is_a?(Hash) && !from.empty?
+      emit_event("send", **payload)
     end
 
     def emit_started_event
@@ -1685,7 +1748,7 @@ module Harnex
       )
       return if @git_start.empty?
 
-      payload = { phase: "start", sha: @git_start[:sha], branch: @git_start[:branch] }
+      payload = { phase: "start", sha: @git_start[:sha], branch: @git_start[:branch], tracks_worker_commits: true }
       payload[:git_root] = git_observation_root if git_lane?
       emit_event("git", **payload)
     end

data/lib/harnex/version.rb

@@ -1,4 +1,4 @@
 module Harnex
-  VERSION = "0.29.1"
-  RELEASE_DATE = "2026-10-23"
+  VERSION = "0.30.0"
+  RELEASE_DATE = "2026-10-25"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harnex
 version: !ruby/object:Gem::Version
-  version: 0.29.1
+  version: 0.30.0
 platform: ruby
 authors:
 - Jikku Jose
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-25 00:00:00.000000000 Z
 dependencies: []
 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,