space-architect 7.1.0 → 8.0.0

data/lib/space_architect/research/mux.rb

@@ -11,10 +11,12 @@ module Space::Architect
       HEARTBEAT_EVERY  = 30    # seconds of silence before heartbeat
       FILE_WAIT_LIMIT  = 10    # seconds to wait for run.jsonl to appear
 
-      def initialize(runs, renderer:, out: $stdout)
-        @runs     = runs
-        @renderer = renderer
-        @out      = out
+      # heartbeat_every: test seam — defaults to HEARTBEAT_EVERY.
+      def initialize(runs, renderer:, out: $stdout, heartbeat_every: HEARTBEAT_EVERY)
+        @runs            = runs
+        @renderer        = renderer
+        @out             = out
+        @heartbeat_every = heartbeat_every
       end
 
       # Returns :ok or :failed
@@ -35,7 +37,7 @@ module Space::Architect
         wait_for_file(run)
 
         unless File.exist?(run.run_log_path.to_s)
-          emit(@renderer.render(lane: run.id, events: [error_event("run.jsonl never appeared")], alive: false))
+          emit(@renderer.terminal(lane: run.id, ok: false, reason: "run.jsonl never appeared"))
           return :failed
         end
 
@@ -43,7 +45,7 @@ module Space::Architect
 
         events_all = []
         last_emit  = Time.now
-        terminal   = nil
+        settled    = nil
 
         File.open(run.run_log_path.to_s, "r") do |f|
           loop do
@@ -53,30 +55,29 @@ module Space::Architect
               next unless ev
 
               events_all << ev
-              terminal = ev if ev["type"] == "result"
+              settled = ev if ev["type"] == "agent_settled"
 
               new_events = [ev]
-              rendered = @renderer.render(lane: run.id, events: new_events, alive: terminal.nil?)
+              rendered = @renderer.render(lane: run.id, events: new_events, alive: settled.nil?)
               emit(rendered) unless rendered.empty?
               last_emit = Time.now
 
-              break if terminal
+              break if settled
             else
               # EOF — check liveness
               pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
 
               unless pid_alive
                 # PID dead and no terminal event → treat as failure
-                unless terminal
-                  emit(@renderer.render(lane: run.id,
-                                        events: [error_event("process died without result event")],
-                                        alive: false))
+                unless settled
+                  emit(@renderer.terminal(lane: run.id, ok: false,
+                                          reason: "process died without a terminal event"))
                   return :failed
                 end
                 break
               end
 
-              if Time.now - last_emit > HEARTBEAT_EVERY
+              if Time.now - last_emit > @heartbeat_every
                 emit("[#{run.id}] ⏳ still running…\n") if @renderer.lifecycle?
                 last_emit = Time.now
               end
@@ -86,14 +87,36 @@ module Space::Architect
           end
         end
 
-        if terminal
-          extract_report(run, terminal)
-          rendered = @renderer.render(lane: run.id, events: [terminal], alive: false)
-          emit(rendered) unless rendered.empty?
-          terminal["is_error"] ? :failed : :ok
-        else
-          :failed
-        end
+        finish(run, events_all, settled)
+      end
+
+      # Classify the settled stream via PiEvents and render the terminal line.
+      def finish(run, events, settled)
+        text   = PiEvents.message_text(PiEvents.last_assistant_message(events))
+        outcome, reason = classify(events, settled, text)
+
+        extract_report(run, text) unless text.empty?
+
+        emit(@renderer.terminal(lane: run.id, ok: outcome == :ok,
+                                reason:  outcome == :ok ? nil : reason,
+                                snippet: outcome == :ok ? text : nil,
+                                duration: PiEvents.duration_seconds(events),
+                                turns:    PiEvents.turn_count(events)))
+        outcome
+      end
+
+      # :ok iff the stream settled un-aborted, the last assistant stopReason is
+      # "stop", and the final assistant text is non-empty; :failed with a named
+      # reason otherwise.
+      def classify(events, settled, text)
+        reason = PiEvents.stop_reason(events)
+
+        return [:failed, text.empty? ? "aborted" : text] if settled.is_a?(Hash) && settled["aborted"] == true
+        return [:ok, text] if reason == "stop" && !text.empty?
+        return [:failed, text.empty? ? reason : text] if PiEvents.failed_stop_reason?(reason)
+
+        # "stop" or no assistant message at all, but no final text.
+        [:failed, "no final assistant text"]
       end
 
       def wait_for_file(run)
@@ -105,16 +128,8 @@ module Space::Architect
         end
       end
 
-      def extract_report(run, terminal_ev)
-        result = terminal_ev["result"].to_s
-        return if result.empty?
-
-        Pathname.new(run.report_path).write(result)
-      end
-
-      def error_event(msg)
-        { "type" => "result", "subtype" => "error", "is_error" => true,
-          "duration_ms" => 0, "num_turns" => 0, "result" => msg }
+      def extract_report(run, text)
+        Pathname.new(run.report_path).write(text)
       end
 
       def emit(text)

data/lib/space_architect/research/pi_events.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Space::Architect
+  module Research
+    # Pure helpers over pi's JSONL event stream — parsed event hashes in, values
+    # out, no I/O. The one home for the pi-shape predicates: Mux, report
+    # extraction, and Supervisor#classify all consume these, so the terminal
+    # classification is not duplicated per call site.
+    module PiEvents
+      # pi's StopReason values that mean the assistant did not finish normally.
+      FAILED_STOP_REASONS = %w[error aborted].freeze
+
+      module_function
+
+      # Assistant `message_end` messages, in stream order — the sole source of
+      # complete message content (`message_start`/`message_update` are inert;
+      # `turn_end`/`agent_end` only replay).
+      def assistant_messages(events)
+        events.filter_map do |e|
+          next unless e.is_a?(Hash) && e["type"] == "message_end" &&
+                      e["message"].is_a?(Hash) && e["message"]["role"] == "assistant"
+          e["message"]
+        end
+      end
+
+      def last_assistant_message(events)
+        assistant_messages(events).last
+      end
+
+      # The last assistant message's stopReason ("stop"/"error"/"aborted"), or
+      # nil when the stream has no assistant message_end.
+      def stop_reason(events)
+        last_assistant_message(events)&.fetch("stopReason", nil)
+      end
+
+      def failed_stop_reason?(reason)
+        FAILED_STOP_REASONS.include?(reason)
+      end
+
+      # Joined text blocks of a message — the report source.
+      def message_text(message)
+        return "" unless message.is_a?(Hash)
+        Array(message["content"]).select { |b| b.is_a?(Hash) && b["type"] == "text" }
+                                 .map { |b| b["text"].to_s }
+                                 .join
+      end
+
+      # Run span in whole-tenths of a second: last assistant message_end
+      # `.timestamp` (epoch ms) minus `session.timestamp` (ISO 8601). NOT a sum
+      # of per-response durationMs — that omits tool time between turns.
+      def duration_seconds(events)
+        session = events.find { |e| e.is_a?(Hash) && e["type"] == "session" }
+        end_ms  = last_assistant_message(events)&.fetch("timestamp", nil)
+        return nil unless session.is_a?(Hash) && session["timestamp"].is_a?(String) && end_ms.is_a?(Numeric)
+
+        start_s = Time.iso8601(session["timestamp"]).to_f
+        ((end_ms / 1000.0) - start_s).round(1)
+      rescue ArgumentError
+        nil
+      end
+
+      # One turn_end per turn.
+      def turn_count(events)
+        events.count { |e| e.is_a?(Hash) && e["type"] == "turn_end" }
+      end
+    end
+  end
+end

data/lib/space_architect/research/renderer.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Space::Architect
   module Research
-    # Pure, testable verbosity-gated renderer for stream-json events.
+    # Pure, testable verbosity-gated renderer for pi JSONL events.
     #
     # Levels (§5.3 ladder):
     #   0 (quiet)  — nothing
@@ -22,8 +24,8 @@ module Space::Architect
 
       # Render a batch of events for a lane.
       # alive: true  → lane still in flight (lifecycle prefix)
-      # alive: false → lane finished (terminal line included)
-      # Returns a String (may be empty).
+      # alive: false → lane finished
+      # Returns a String (may be empty). Terminal lines come from #terminal.
       def render(lane:, events:, alive:)
         return "" if @level == 0 && !@jsonl
 
@@ -32,69 +34,67 @@ module Space::Architect
         end
 
         lines = []
-        terminal = nil
-
         events.each do |ev|
           case ev["type"]
-          when "assistant"
+          when "message_end"
+            next unless ev.dig("message", "role") == "assistant"
             Array(ev.dig("message", "content")).each do |block|
               case block["type"]
               when "thinking"
                 lines << "[#{lane}] #{block['thinking'].to_s.strip}" if @thinking && @level >= 1
               when "text"
                 lines << "[#{lane}] #{block['text'].to_s.strip}" if @level >= 2
-              when "tool_use"
+              when "toolCall"
                 if @level >= 3
                   name_line = "[#{lane}] tool: #{block['name']}"
                   if @level >= 4
-                    input = block["input"]
-                    name_line += " #{JSON.generate(input)}" if input && !input.empty?
+                    arguments = block["arguments"]
+                    name_line += " #{JSON.generate(arguments)}" if arguments && !arguments.empty?
                   end
                   lines << name_line
                 end
               end
             end
-          when "user"
-            Array(ev.dig("message", "content")).each do |block|
-              next unless block["type"] == "tool_result"
-              next unless @level >= 4
-
-              content = block["content"]
-              lines << "[#{lane}] tool_result: #{content.to_s.strip}"
+          when "tool_execution_start"
+            if @level >= 3
+              line = "[#{lane}] tool: #{ev['toolName']}"
+              if @level >= 4
+                args = ev["args"]
+                line += " #{JSON.generate(args)}" if args && !args.empty?
+              end
+              lines << line
+            end
+          when "tool_execution_end"
+            if @level >= 4
+              text = Array(ev.dig("result", "content")).select { |c| c.is_a?(Hash) && c["type"] == "text" }
+                                                     .map { |c| c["text"].to_s }.join
+              lines << "[#{lane}] tool_result: #{text.strip}"
             end
-          when "result"
-            terminal = ev
           end
         end
 
-        if terminal
-          lines << terminal_line(lane, terminal)
-        elsif alive && @level >= 1 && events.empty?
-          lines << "[#{lane}] running"
-        end
+        lines << "[#{lane}] running" if alive && @level >= 1 && events.empty?
 
         lines.reject(&:empty?).join("\n").then { |s| s.empty? ? s : "#{s}\n" }
       end
 
-      def lifecycle?
-        @level >= 1 && !@jsonl
-      end
+      # The terminal line, fed terminal FACTS by the mux (never a fabricated
+      # event): ok/failed, the failure reason or the final-text snippet, the
+      # run span, and the turn count.
+      def terminal(lane:, ok:, reason: nil, snippet: nil, duration: nil, turns: nil)
+        return "" if @level == 0 || @jsonl
 
-      private
-
-      def terminal_line(lane, ev)
-        if ev["is_error"]
-          reason = ev["result"].to_s.strip
-          reason = ev["subtype"] if reason.empty?
-          "[#{lane}] ✗ failed #{reason}"
-        elsif ev["subtype"] == "success"
-          dur   = ev["duration_ms"] ? "#{(ev['duration_ms'] / 1000.0).round(1)}s" : "-"
-          turns = ev["num_turns"] || "-"
-          result_snip = ev["result"].to_s.strip.slice(0, 80)
-          "[#{lane}] ✓ complete · STATUS: #{result_snip} · #{dur} · #{turns} turns"
+        line = if ok
+          span  = duration ? "#{duration}s" : "-"
+          "[#{lane}] ✓ complete · STATUS: #{snippet.to_s.strip.slice(0, 80)} · #{span} · #{turns || '-'} turns"
         else
-          "[#{lane}] ⚠ nonzero exit"
+          "[#{lane}] ✗ failed #{reason.to_s.strip}"
         end
+        "#{line}\n"
+      end
+
+      def lifecycle?
+        @level >= 1 && !@jsonl
       end
     end
   end

data/lib/space_architect/research/supervisor.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "pathname"
 require "time"
 
 module Space::Architect
   module Research
     class Supervisor
-      DEFAULT_MODEL     = Harness::CLAUDE_DEFAULT_MODEL
+      DEFAULT_MODEL     = Harness::DEFAULT_MODEL
       DEFAULT_MAX_TURNS = 40
 
+      # The vendored builder-guard extension ships in the gem next to this file's
+      # sibling pi/ dir — copied per-run and injected with the harness.
+      VENDORED_GUARD = Pathname.new(__dir__).join("../pi/builder-guard.ts")
+
       def initialize(space:, bin: nil)
         @space    = space
         @bin      = bin
         @registry = Registry.new(space.path.join("build", "research", "registry.yaml"))
       end
 
-      # Dispatch each prompt file as a detached read-only claude -p child.
-      # Returns array of Run objects (non-blocking).
+      # Dispatch each prompt file as a detached pi child. Returns array of Run
+      # objects (non-blocking).
       def dispatch(prompts, model: DEFAULT_MODEL, max_turns: DEFAULT_MAX_TURNS)
         prompts.map { |path| dispatch_one(Pathname.new(path), model: model, max_turns: max_turns) }
       end
@@ -54,12 +59,19 @@ module Space::Architect
 
         FileUtils.cp(path.to_s, prompt_path.to_s)
 
-        harness = Harness::ClaudeCodeHarness.new(
-          model:            model,
-          max_turns:        max_turns,
-          bin:              @bin,
-          allowed_tools:    READONLY_TOOLS,
-          disallowed_tools: ""
+        # Vendor the guard into the run dir (idempotent overwrite) and inject it via
+        # the harness — research runs get the same deny-only builder guard.
+        guard_path = dir.join("builder-guard.ts")
+        FileUtils.cp(VENDORED_GUARD, guard_path)
+
+        # config_dir: is pi's --session-dir — research sessions land under
+        # build/research/<id>/ instead of ~/.pi/agent/sessions/.
+        harness = Harness::PiHarness.new(
+          model:      model,
+          max_turns:  max_turns,
+          bin:        @bin,
+          config_dir: dir,
+          guard_path: guard_path
         )
 
         pid = harness.run_detached(
@@ -87,18 +99,27 @@ module Space::Architect
         File.basename(path.to_s).sub(/\.prompt\.md\z/, "").sub(/\.md\z/, "")
       end
 
+      # pi has no terminal "result" event: the run's outcome is the LAST assistant
+      # message's stopReason ("stop" finished normally; "error"/"aborted" failed —
+      # pi's StopReason vocabulary; PiEvents is the one home for these
+      # predicates). Without one, a live pid is still running and a dead pid
+      # died without finishing.
       def classify(run)
-        content = File.exist?(run.run_log_path.to_s) ? File.read(run.run_log_path.to_s) : ""
-        events  = content.lines.filter_map { |l| JSON.parse(l.chomp) rescue nil }
-        terminal = events.find { |e| e["type"] == "result" }
+        events = read_events(run.run_log_path)
+        reason = PiEvents.stop_reason(events)
 
-        return :complete if terminal && !terminal["is_error"]
-        return :failed   if terminal && terminal["is_error"]
+        return :complete if reason == "stop"
+        return :failed   if PiEvents.failed_stop_reason?(reason)
 
         pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
         pid_alive ? :running : :failed
       end
 
+      def read_events(path)
+        return [] unless File.exist?(path.to_s)
+        File.readlines(path.to_s).filter_map { |l| JSON.parse(l.chomp) rescue nil }
+      end
+
       def tail_lines(path, n)
         return [] unless File.exist?(path.to_s)
         File.readlines(path.to_s).last(n).map(&:chomp)

data/lib/space_architect/research.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
-module Space::Architect
-  module Research
-    READONLY_TOOLS = "Read,Grep,Glob,WebSearch,WebFetch"
-  end
-end
-
+require_relative "research/pi_events"
 require_relative "research/run"
 require_relative "research/registry"
 require_relative "research/renderer"

data/lib/space_architect.rb

@@ -5,7 +5,6 @@ require "space_src"
 
 require_relative "space_architect/harness"
 require_relative "space_architect/run_creator"
-require_relative "space_architect/dispatcher"
 require_relative "space_architect/gate_lint"
 require_relative "space_architect/gate_evaluator"
 require_relative "space_architect/architect_project"

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "7.1.0"
+    VERSION = "8.0.0"
   end
 end

data/skill/architect/SKILL.md

@@ -5,7 +5,7 @@ description: >
   — judgment only: arbitration, judging raw evidence against frozen Acceptance
   Criteria, splitting iterations into disjoint lanes, kill/continue calls. The
   BUILDERS are 1-4 parallel cheaper agents run headless (reference harness:
-  `claude -p`), each in its own git worktree; the architect reviews, merges, and
+  `pi -p`), each in its own git worktree; the architect reviews, merges, and
   integrates their work.
   The space is the memory: one file per iteration at
   architecture/I<NN>-<name>.md (Grounds / Specification / Acceptance Criteria /
@@ -19,7 +19,7 @@ description: >
 
 You are the ARCHITECT — the judgment role: a strong reasoning model (or a human),
 run interactively. The BUILDER is a cheaper model run headless (reference
-harness: `claude -p`), one or more per iteration — the models filling both roles
+harness: `pi -p`), one or more per iteration — the models filling both roles
 are an operator choice (see `docs/DESIGN.md` §1–§2), not fixed. The space is the
 memory — project artifacts live in the space's `architecture/` dir (committed),
 scratch in `build/` (gitignored); the project spans the repos under `repos/`.
@@ -116,12 +116,13 @@ loop.
 6. **Audit every status claim** — yours and the builder's — against a tool
    result from the session before reporting it.
 7. **Fresh builder context per lane, worktree isolation between lanes.**
-   `claude -p --continue` (from the lane's worktree) only for follow-ups within
-   the current lane. Builders never commit — Claude Code has no sandbox to
-   enforce that, so verify it yourself post-flight (`git -C <worktree> log
-   <repo-base>..` must be empty). If a run leaves a worktree broken or
-   committed, discard that lane + re-dispatch over rescue prompting — lanes are
-   cheap by construction.
+   `pi -p --continue --session-dir <space>/build/<id>-<lane>` (from the lane's
+   worktree) only for follow-ups within
+   the current lane. Builders never commit — the injected builder guard denies
+   git writes at dispatch, so verify it yourself post-flight (`git -C
+   <worktree> log <repo-base>..` must be empty). If a run leaves a worktree
+   broken or committed, discard that lane + re-dispatch over rescue prompting —
+   lanes are cheap by construction.
 8. **Stop conditions:** failing verification you can't root-cause, instructions
    conflicting with project docs, irreversible/destructive calls, or scope
    growth beyond the iteration → checkpoint to the handoff and ask the human.
@@ -134,8 +135,8 @@ loop.
 - Read the project's operating docs in authority order: `CLAUDE.md` /
   `AGENTS.md` → `README.md` → architecture docs. Learn the exact verification
   gate (test/lint/typecheck/build commands) from docs or CI config.
-- Once per environment: `claude --version` and confirm the builder model
-  resolves (`echo ok | claude -p --model <builder-model> --max-turns 1`;
+- Once per environment: `pi --version` and confirm the builder model
+  resolves (`echo ok | pi -p --model <builder-model>`;
   details in `dispatch.md`). Past that one-time check, every foreground dispatch
   self-verifies — it prints a liveness line naming the streamed model and
   confirming the run log is growing (a WARN line instead if the streamed model
@@ -208,7 +209,7 @@ the builder's work — a capability-gap read whose independence depends on the
 pairing: a same-lab architect/builder shares the builder's blind spots (so the
 frozen gates stay the independent check), while a cross-vendor pairing is more
 independent (see `docs/DESIGN.md` §1/R3). For an extra adversarial pass, pipe the
-diff to a fresh read-only `claude -p` reviewer (command in `dispatch.md`) or a
+diff to a fresh read-only `pi -p` reviewer (command in `dispatch.md`) or a
 fresh-context subagent prompted to break confidence — calibrated to flag only
 correctness/requirement/invariant gaps with file:line evidence, no style.
 
@@ -243,8 +244,9 @@ Two scales, two routes:
   researching well-understood iterations is pure cost.
 
 When a trigger fires, read `research.md` next to this file and follow it:
-3–5 narrow non-overlapping questions → parallel read-only `claude -p`
-researchers (built-in `WebSearch`/`WebFetch`) in the background → you
+3–5 narrow non-overlapping questions → parallel detached `pi -p --mode json`
+researchers (read-only by prompt contract; web via pi's loaded web tools) in
+the background → you
 adversarially verify the load-bearing claims → you write the iteration's
 **Grounds** section with citations and commit it. Researchers gather; you judge
 and write Grounds. Findings without a source URL don't enter Grounds.
@@ -277,9 +279,7 @@ contract, self-contained:
   its **target repo + file-touch set, checked for overlap**: name the repo
   (`repos/<repo>`) and every file each lane may touch. The machine-readable
   declaration lives in a fenced ` ```lanes ` block in the Specification — one
-  entry per lane (`name`, `repo`, `touch` globs; optionally `allowed_tools`/
-  `append_allowed_tools` to replace/extend the lane's builder tool grant — see
-  `dispatch.md`) — the single frozen source of
+  entry per lane (`name`, `repo`, `touch` globs) — the single frozen source of
   truth `architect freeze` records into `space.yaml` and `architect provision`
   materializes. The same boundary is stated twice more — the lane-prompt's
   may-touch list, and the scope gate that checks the lane's diff at judge
@@ -310,8 +310,11 @@ contract, self-contained:
   pending status, and a later session in the same worktree audits it once it
   exits — see `### Long-running sweep` in `dispatch.md`).
 - **Effort call** — thinking budget set per dispatch with `architect dispatch
-  --effort <level>`, translated and clamped to the lane's harness (the
-  escalation keywords `think hard` … `ultrathink` still work in-prompt);
+  --effort <level>`, normalized to the canonical
+  `off`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max` set and passed straight
+  through to pi's `--thinking` (each model's `thinkingLevelMap` in
+  `~/.pi/agent/models.json` clamps it further per model); the escalation
+  keywords `think hard` … `ultrathink` still work in-prompt;
   default unattended builder work high, downgrade a routine, tightly-specified
   lane (record which and why). Levels and mechanics: `dispatch.md`.
 
@@ -404,15 +407,14 @@ dispatch. You needn't sequence Grounds and Specification into separate commits
 first — the freeze snapshots the whole frozen region and refuses to re-freeze
 once a frozen section changed afterward.
 
-### 5. Dispatch (one fresh `claude -p` per lane, worktree-isolated)
+### 5. Dispatch (one fresh `pi -p` per lane, worktree-isolated)
 
 Per the mechanics in `dispatch.md`. The lane lifecycle is **declare → rehearse
 → freeze → provision → write prompts → dispatch** — every lane gets a worktree;
 there is no dispatch-in-the-checkout path:
 
 - **Declare** — at spec time, each lane is one entry in the Specification's
-  fenced ` ```lanes ` block (§4): `name`, `repo`, `touch` globs, and optionally
-  `allowed_tools`/`append_allowed_tools`.
+  fenced ` ```lanes ` block (§4): `name`, `repo`, `touch` globs.
 - **Rehearse** — `architect rehearse <iteration>` dry-runs the drafted gates
   from the working tree (§4's pre-freeze check), resolving its run dir from the
   drafted ` ```lanes ` block, and stamps `space.yaml`; `freeze` refuses without
@@ -440,7 +442,9 @@ with `architect section <iteration> prompt --append --lane <lane> --from
 <that scratch file>`. Then run `architect dispatch <iteration> <lane> --prompt
 <that scratch file>` — it copies the prompt to the canonical
 `build/<id>-<lane>/prompt.md` (fed to the builder on stdin), assembles the
-canonical `claude -p` argv, pins the model, and streams stream-json to
+canonical `pi -p --mode json` argv, pins the model, copies the vendored
+builder-guard into the lane's build dir and injects it with `-e`, and streams
+pi's JSONL event stream to
 `build/<id>-<lane>/run.jsonl`. Launch one dispatch per worktree — each as its
 **own background Bash tool call** (your harness's `run_in_background`), **not**
 shell `&`. The harness keeps each lane alive for its full run and notifies you
@@ -452,7 +456,7 @@ stay untouchable.
 
 Do not block — end the turn or do other judgment work; long runs (30–60 minutes) are
 normal. Print the lane-prompts too, so the human can run any lane in an
-interactive `claude` session instead. Whenever you return to a running lane,
+interactive `pi` session instead. Whenever you return to a running lane,
 check liveness: the lane's `run.jsonl` must still be growing. If it has been
 silent 15+ minutes on one in-flight command, follow "Stall detection and
 rescue" in `dispatch.md` — kill the stuck child process, not the run.