harnex 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72eab06bb2287cadb7e9e2f525350b981571717088de593d9ad5225ca9aa324e
-  data.tar.gz: 6a2fecf3083f015e9ecc90d658a4797439740e21985fecdd3515e98f179f16d1
+  metadata.gz: b4b50e456b0b9be717e037a0596b942273e2e4c192b80d697fc502a66cc4c220
+  data.tar.gz: 77ed9e03656bfff5f68064bb4dcb64f898d1de6b5d599ad30450ac51f8a1938e
 SHA512:
-  metadata.gz: e662b7bb01799d6a8faf1ff62efb1b4353dd6f684ab43f250bcf783981189709a2c60871a8cf8e3c55772e2d233131880ddd2324d8bbe47f2ac2766d5d09ef91
-  data.tar.gz: 4de10a7bed0959e709c2f99df9dda5dac4ccdc79054919d4cade8780c712f3f2ad1a5b322586a01dadf43637de52ec731299ca8a874f13e156ff31480b02357b
+  metadata.gz: 85ca4102b12fe2a0e109c1fdfc643c96d80677b267c0b658cb4ff5787a72075e0d77e9d98a29bf401fa5975502cfc5fca891fe62c63ef51a92b8f626e2c60d04
+  data.tar.gz: 39b143e75ade8b68254742f6ea23eee43fde615c01de9c273d221b681b8b913f7c35e87b6bf9a79f84e290602790641fdb5a96e84c7a75fedad602b1ef6718d6

data/CHANGELOG.md

@@ -1,5 +1,72 @@
 # 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
+
+Fix release for #88: lanes in repos with a phase allowlist. Published to
+RubyGems on 2026-10-25 | 02:14 AM | IST.
+
+### Fixed
+
+- In a repo whose `.harnex/config.json` phase allowlist has
+  `"policy": "reject"`, harnex refused every `delegate`, `ask --write` and
+  `reply` (`meta.phase (none) is not allowlisted`). The run behind a lane
+  is now tagged with phase `delegate` or `ask`. These are harnex's own
+  phases, like `preflight`, so every allowlist accepts them.
+- A lane that harnex refused before the worker started left a `failed`
+  record, so a retry under the same name failed with `lane NAME already
+  exists (failed)` until `discard`. Now a refused new lane leaves no record
+  and no brief. A refused `reply` keeps the state the lane's last turn left.
+  The next `delegate` under the same name also clears a record left this way
+  by 0.29.0.
+
+### Added
+
+- `harnex delegate --phase NAME` and `harnex ask --phase NAME` tag a lane
+  with a work phase such as `implement`. The repo allowlist checks a named
+  phase, and `reply` reuses it.
+
 ## [0.29.0] - 2026-10-22 | 06:08 PM | IST
 
 **The agent release.** harnex becomes a tool your coding agents use directly:

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/configuration.md

@@ -42,6 +42,10 @@ The effective value is the first-class `harnex run --phase TEXT` value, or
 - Allowlisted phase: dispatches silently.
 - `policy: "warn"`: prints a warning and dispatches.
 - `policy: "reject"`: exits non-zero before spawn and writes no dispatch row.
+- Harnex's own phases always pass: `preflight` (the `harnex preflight` probe)
+  and the lane phases `delegate` and `ask`. A lane runs under its kind's
+  phase unless `harnex delegate --phase NAME` (or `harnex ask --phase NAME`)
+  names a work phase, which the allowlist then checks.
 
 The allowlist must be an array of non-empty strings. Policy must be `warn` or
 `reject`.

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,15 +66,28 @@ 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.
 - **`--model provider/model`** and **`--effort low|medium|high`** pick the
   model; the default is Pi's own default model.
+- **`--phase NAME`** tags the lane's dispatch rows with a work phase (for
+  example `implement`). Without it the phase is `delegate` (`ask` for an ask),
+  which a repo's phase allowlist always accepts; a named phase is checked
+  against the allowlist (see [configuration](configuration.md)).
 
 ### Waiting, and long tasks
 
@@ -122,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
@@ -149,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
@@ -184,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/guides/01_dispatch.md

@@ -213,7 +213,8 @@ are present.
 Every dispatch writes one `dispatch_start` and one rich v2 `dispatch_end` row
 to the canonical repo/global dispatch stream, which is the only telemetry
 destination. Repo `.harnex/config.json` can warn on or reject non-canonical
-phase names before spawn.
+phase names before spawn; lanes (`delegate`, `ask`) and `preflight` are
+exempt unless a lane is given `--phase NAME`.
 
 Pi runs use structured RPC (`pi --mode rpc`) and require Pi >= 0.80.4; gate
 unattended work with `harnex doctor --adapter pi`. Harnex `--model` / `--effort`

data/lib/harnex/commands/ask.rb

@@ -33,6 +33,8 @@ module Harnex
                            Ask once more with NAME when the first model fails on
                            provider capacity or rate limits (provider_capacity)
           --effort LEVEL   Reasoning effort / Pi thinking level
+          --phase NAME     Tag the run with a repo work phase (with --write, checked
+                           against the repo's allowlist); default: ask
           --cwd DIR        Directory the worker works in (default: current directory)
           --file PATH      Read the question from PATH (see run --context-file)
           --section TEXT   With --file: send only that section
@@ -63,7 +65,7 @@ module Harnex
       @out = out
       @err = err
       @harnex_command = harnex_command || [Gem.ruby, File.expand_path("../../../bin/harnex", __dir__)]
-      @options = { model: nil, fallback_model: nil, effort: nil, cwd: nil, file: nil, section: nil, write: false,
+      @options = { model: nil, fallback_model: nil, effort: nil, phase: nil, cwd: nil, file: nil, section: nil, write: false,
                    id: nil, timeout: Lanes::DEFAULT_TIMEOUT, detach: false, json: false, help: false, resume: nil,
                    repo: nil }
     end
@@ -99,17 +101,25 @@ module Harnex
       lane = register_lane(id, model)
       stdout, status = launch(question, model, id)
       result = parse_result(stdout)
-      Lanes.settle(lane, result["turn_result"] || {}, status.exitstatus) unless result.empty?
+      if !result.empty?
+        Lanes.settle(lane, result["turn_result"] || {}, status.exitstatus)
+      elsif status.exitstatus != Waiter::DONE_EXIT_TIMEOUT
+        # Refused before the worker started (#88); 124 may still come up.
+        Lanes.forget(lane)
+      end
       [result, status.exitstatus]
     end
 
     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,
-        "requested_model" => model, "effort" => @options[:effort], "created_at" => Lanes.now,
-        "launched_at" => Lanes.now, "state" => "running", "turns" => 0
+        "requested_model" => model, "effort" => @options[:effort], "phase" => @options[:phase],
+        "created_at" => Lanes.now, "launched_at" => Lanes.now, "state" => "running", "turns" => 0
       )
     end
 
@@ -126,7 +136,7 @@ module Harnex
       else
         argv += ["--context", question]
       end
-      argv += ["--auto-stop", "--wait-done", "--intent", INTENT]
+      argv += ["--auto-stop", "--wait-done", "--intent", INTENT, "--phase", @options[:phase] || INTENT]
       argv += ["--wait-timeout", @options[:timeout].to_s] if @options[:timeout]
       argv += ["--model", model] if model
       argv += ["--effort", @options[:effort]] if @options[:effort]
@@ -197,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'])}")
@@ -209,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)
@@ -231,7 +248,7 @@ module Harnex
         when "--write" then @options[:write] = true
         when "--detach" then @options[:detach] = true
         when "--json" then @options[:json] = true
-        when "--model", "--effort", "--cwd", "--file", "--section", "--id", "--fallback-model", "--resume", "--repo"
+        when "--model", "--effort", "--phase", "--cwd", "--file", "--section", "--id", "--fallback-model", "--resume", "--repo"
           @options[arg.delete_prefix("--").tr("-", "_").to_sym] = value(index += 1, arg)
         # Habits from `harnex run` (#87): an ask already runs in a tmux window
         # named after its id and stops after answering.

data/lib/harnex/commands/delegate.rb

@@ -17,12 +17,19 @@ 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
           --effort LEVEL   Reasoning effort / Pi thinking level
+          --phase NAME     Tag the run with a repo work phase (checked against the
+                           repo's .harnex/config.json allowlist); default: delegate,
+                           which every allowlist accepts
           --no-wait        Start the lane and return at once; collect with
                            `harnex result` (all your lanes) or `harnex result NAME`
           --timeout DUR    Wait at most DUR (default 9m, fits a 10-minute tool cap;
@@ -46,7 +53,7 @@ module Harnex
       @out = out
       @err = err
       @harnex_command = harnex_command || [Gem.ruby, File.expand_path("../../../bin/harnex", __dir__)]
-      @options = { worktree: nil, name: nil, cwd: nil, file: nil, model: nil, effort: nil, wait: true,
+      @options = { worktree: nil, name: nil, cwd: nil, file: nil, model: nil, effort: nil, phase: nil, wait: true,
                    timeout: Lanes::DEFAULT_TIMEOUT, detach: false, json: false, help: false }
     end
 
@@ -83,14 +90,15 @@ 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,
         "owner" => Harnex.ambient_owner_id, "requested_model" => @options[:model], "effort" => @options[:effort],
-        "created_at" => Lanes.now, "turns" => 0
+        "phase" => @options[:phase], "created_at" => Lanes.now, "turns" => 0
       }
       if @options[:worktree]
         warn_uncommitted(root)
@@ -105,25 +113,44 @@ module Harnex
 
     # A lane that never started leaves nothing behind.
     def discard_unstarted
-      return unless @lane && @lane["worktree"] && @lane["turns"].to_i.zero?
+      return unless @lane && @lane["turns"].to_i.zero?
 
-      Lanes.remove_worktree(@lane, force: true)
-      @lane["state"] = "discarded"
-      Lanes.save(@lane)
+      Lanes.remove_worktree(@lane, force: true) if @lane["worktree"]
+      Lanes.forget(@lane)
     end
 
     def ensure_free!(root, name)
       existing = Lanes.load(root, name)
+      if Lanes.never_started?(existing)
+        Lanes.forget(existing)
+        existing = nil
+      end
       if Lanes.open?(existing)
         raise OptionParser::InvalidArgument,
               "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?
@@ -165,7 +192,7 @@ module Harnex
         when "--no-wait" then @options[:wait] = false
         when "--detach" then @options[:detach] = true
         when "--json" then @options[:json] = true
-        when "--worktree", "--name", "--cwd", "--file", "--model", "--effort"
+        when "--worktree", "--name", "--cwd", "--file", "--model", "--effort", "--phase"
           @options[arg.delete_prefix("--").to_sym] = value(index += 1, arg)
         when "--timeout", "--wait-timeout"
           @options[:timeout] = Lanes.parse_timeout(value(index += 1, arg))

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/run.rb

@@ -486,8 +486,9 @@ module Harnex
       metadata = @options[:meta].is_a?(Hash) ? @options[:meta] : {}
       phase = metadata["phase"].to_s
       allowlist = phase_config.fetch("allowlist")
-      # `harnex preflight` tags its own probe; repo phase policy governs work.
-      return if allowlist.include?(phase) || phase == Preflight::PHASE
+      # Harnex tags its own runs (the `harnex preflight` probe, lanes); repo
+      # phase policy governs work phases.
+      return if allowlist.include?(phase) || phase == Preflight::PHASE || Lanes::PHASES.include?(phase)
 
       policy = phase_config.fetch("policy")
       message = "harnex run: meta.phase #{phase.empty? ? '(none)' : phase.inspect} " \

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