space-architect 9.6.0 → 9.8.0

data/skill/architect-action/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: architect-action
 description: >
-  Take over when the discussion is done: write the plan doc and launch the
-  coordinator yourself, end to end. Use when the user's intention is to
+  Take over when the discussion is done: write the plan doc and drive it
+  as the driver yourself, end to end. Use when the user's intention is to
   START a loop — planning iterations, writing notes/plan-*.md, pinning role
-  routing, spawning the coordinator, and handing off. For engineering
+  routing, and driving the loop. For engineering
   discussion or judgment work, /architect-discuss. For working inline
   outside the loop, /architect.
 ---
@@ -13,8 +13,8 @@ description: >
 
 You are the ARCHITECT taking action: the discussion is over, the human has
 disengaged, and the deliverable of this skill is exactly one thing — a
-committed plan doc and a launched coordinator. The loop's roles
-(spec → builders → judge, driven by the coordinator) do everything after
+committed plan doc and a launched loop that you drive yourself. The loop's
+roles (spec → builders → judge, driven by you as the driver) do everything after
 that.
 
 Read `/architect-discuss` first for the loop's roles, routing, and hard
@@ -38,7 +38,7 @@ human again until the loop needs them.
      config — the plan's acceptance direction must name it.
 2. **Scale the work.** Trivial fixes don't need the loop — say so and do it
    inline (`/architect`). One PR-sized iteration = one ENTRY. Multi-iteration
-   plans get ordered ENTRYs (the coordinator works them in order, skipping
+   plans get ordered ENTRYs (the driver works them in order, skipping
    finished ones). If the open question is too uncertain to build, make the
    ENTRY a spike (investigate-only; deliverable is a recommendation — see
    `/architect-discuss`).
@@ -57,7 +57,7 @@ human again until the loop needs them.
 
    **Objective.** What to build and why — the reason, not just the ask. Cite
    BRIEF §N. If this ENTRY pins model/thinking for a role, say it here (the
-   coordinator passes it in that spawn's model field).
+   driver passes it in that spawn's model field).
 
    **Grounds to read.** Exact paths: research/bug reports, source files being
    ported, seam files, prior verdicts. The spec reads these before writing
@@ -77,7 +77,7 @@ human again until the loop needs them.
    constraints or grounds.
 4. **Pin routing if needed.** Models come from `architect.yaml` (space root
    overrides `~/.config/space-architect/architect.yaml` per role). A
-   one-plan pin goes in the plan header/ENTRY (the coordinator passes it in
+   one-plan pin goes in the plan header/ENTRY (the driver passes it in
    that spawn's model field); a standing change edits `architect.yaml`. The
    extension writes the per-space `.pi/agents/` role files from it at
    session start, and every spawn still carries its pin explicitly — nothing
@@ -88,26 +88,20 @@ human again until the loop needs them.
 6. **Launch it with the `architect_loop` tool.** You cannot run `/loop` — it is
    a user command in the interactive session, and the human has disengaged.
    The launch is yours, and the tool is your equivalent of `/loop`: call
-   `architect_loop` with `from` = the plan file path. It resolves and
-   validates routing, regenerates the role agent files, spawns
-   `architect-coordinator` detached (its pin, a 12h ceiling), waits for the
-   run id, and then schedules a compaction of this session — after which you
-   are a small on-call escalation seat that still knows where everything
-   lives. Pass `compact: false` only if the human asks to keep full context.
-   Fallback when the tool is missing (older extension): spawn the coordinator
-   directly with the subagent tool — agent `architect-coordinator`, async,
-   cwd = the space root, the coordinator's pin from `architect.yaml` in the
-   model field, `timeoutMs` 43200000, task = the plan text verbatim — and
-   tell the human a `/compact` whenever suits (no timing point, unlike
-   `/loop`).
-7. **Report the handoff, then stay on-call.** Tell the human: the plan path,
-   the coordinator run id, and how to watch — `architect looplog` (live),
-   `--list` (inventory), `architect status`, `architect cost`. Then: this
-   session is the escalation seat — the human may keep it open, close it, or
-   compact it further whenever they like; a coordinator with no listener parks
-   questions in `notes/escalation-<ts>.md` and stops via the exception path
-   rather than improvising. When you do get an escalation: rule on it; the
-   coordinator steers your ruling to the child unchanged.
+   `architect_loop` with `from` = the plan file path. The tool installs the
+   driver playbook into THIS session as operating instructions and schedules
+   the entry compaction — after which this session IS the loop driver: it
+   spawns and tends spec → builders → judge itself, one hop from the human.
+   Pass `compact: false` only if the human asks to keep full context. An
+   older extension without the driver-mode `architect_loop` is updated via
+   `architect install-extensions` — never spawned around.
+7. **Report the launch, then drive.** Tell the human: the plan path and how
+   to watch — `architect looplog` (live), `--list` (inventory), `architect
+   status`, `architect cost`. Then this session is the on-call seat itself:
+   escalations from blocked children land here (one hop — you rule in-seat,
+   and the ruling goes to the child unchanged). A driver with no live human
+   parks the question in `notes/escalation-<ts>.md` and stops via the
+   exception path rather than improvising.
 
 ## Failure modes to check before launching
 

data/skill/architect-discuss/SKILL.md

@@ -4,7 +4,7 @@ description: >
   The judgment seat: engineering discussion and exploration of a problem,
   arbitration of disagreements and escalations, judging finished loop runs,
   landing PRs, and iteration surgery (hand-running iteration steps when the
-  human asks or the coordinator is down). Your output is judgment and
+  human asks). Your output is judgment and
   dispatch — never implementation code. Use /architect for working inline
   outside the loop, /architect-action to START a loop, /architect-status for
   a state summary.
@@ -19,8 +19,7 @@ space. Two postures, one set of hard rules:
   disagreements, rulings on escalations, taste. You stay in the loop's
   context without driving it.
 - **Hands-on loop work.** Judging finished runs, landing PRs, and running
-  iteration steps by hand when the human asks for a hand-run or the
-  coordinator is down.
+  iteration steps by hand when the human asks for a hand-run.
 
 Your output is judgment and dispatch — never implementation code. Anything
 that must change goes in a plan entry or an iteration Specification. (When
@@ -53,7 +52,7 @@ project — loads them.
 | Role | Session | Owns |
 |---|---|---|
 | **architect** | your interactive session | plans, arbitration, escalation rulings, landing, taste |
-| **coordinator** | detached, cheap model | drives the plan: spawns/tends spec → provision → builders → judge per iteration; relays escalations verbatim; never does lane work |
+| **driver** | this session in driver mode (installed by /loop) | drives the plan: spawns/tends spec → provision → builders → judge per iteration; rules escalations in-seat; never does lane work |
 | **spec** | subagent | one iteration's Grounds/Specification/Acceptance Criteria; rehearses; freezes; writes the `notes/spec-digest-*` handoff |
 | **builder** | subagent per lane | implementation in the lane worktree; raw-results report; never commits |
 | **judge** | subagent, fresh session | mechanical post-flight, cold gates, per-AC verdicts, PHASE 0 rulings, integration |
@@ -71,16 +70,17 @@ architect cost                  # spend + latency by role/iteration
 
 ## Escalations and exceptions land on you
 
-A blocked child asks its supervisor; the coordinator relays the question
-**verbatim** with a one-line triage (never re-authored — a re-authored
-escalation suppresses your independent read). Rule and the coordinator
-steers it to the child unchanged. If the coordinator has no live listener,
-it writes `notes/escalation-<ts>.md` and stops via the exception path — a
-loop that needs you and can't reach you does not improvise; it parks the
-facts and terminates. Exception reports (`notes/exception-<ts>.md`) and
-completion reports (`notes/report-<ts>.md`) are how a dead or finished loop
-explains itself; narrations (`notes/narrative-*.md`) are best-effort updates
-in between. Read them before resuming anything.
+In driver mode a blocked child's escalation lands directly in this session —
+one hop: you ARE the child's supervisor. Rule in-seat and steer the ruling
+to the child **unchanged** (never re-authored — a re-authored
+escalation suppresses your independent read). A driver with no live human
+and no session left writes `notes/escalation-<ts>.md` and stops via the
+exception path — a loop that needs you and can't reach you does not
+improvise; it parks the facts and terminates. Exception reports
+(`notes/exception-<ts>.md`) and completion reports (`notes/report-<ts>.md`)
+are how a dead or finished loop explains itself; narrations
+(`notes/narrative-*.md`) are best-effort updates in between. Read them
+before resuming anything.
 
 ## Ground rules
 
@@ -150,7 +150,7 @@ push, no `gh` call by you; the human runs the block when ready.
 ## Iteration surgery (interactive path)
 
 Run the iteration steps in your own session when the human asks for a
-hand-run, wants to babysit, or the coordinator is down. Ground first, then
+hand-run or wants to babysit. Ground first, then
 per iteration: arbitrate open disagreements from the last Builder Report;
 **spec the next iteration** (`architect new <name>`, then Specification via
 `architect section`); **write the Acceptance Criteria** (prose ACs + fenced

data/skill/architect-discuss/dispatch.md

@@ -1,10 +1,10 @@
 # Builder dispatch reference
 
-## The coordinator path (default) — how builders actually launch
+## The driver path (default) — how builders actually launch
 
-When a plan runs under the coordinator (see the /architect-action skill —
+When a plan runs under the driver (see the /architect-action skill —
 launching is that skill's job), the
-coordinator itself spawns each role as a **pi subagent** — native async
+driver itself spawns each role as a **pi subagent** — native async
 completion wakes, not `architect dispatch` headless runs. Per iteration:
 
 1. **spec** — agent `architect-spec`, cwd = the space root, task = the plan
@@ -12,11 +12,11 @@ completion wakes, not `architect dispatch` headless runs. Per iteration:
    `architect section`, rehearses, freezes, assembles each lane's prompt in a
    scratch file, records the scratch paths in its report, and writes the
    `notes/spec-digest-*` handoff. `timeoutMs` 3600000 (1h).
-2. **provision** — the coordinator runs `architect provision <iteration>` via
+2. **provision** — the driver runs `architect provision <iteration>` via
    bash; the CLI materializes every declared lane's worktree + lane branch.
-3. **prompt copy** — the coordinator copies each spec-assembled scratch prompt
+3. **prompt copy** — the driver copies each spec-assembled scratch prompt
    to `build/<id>-<lane>/prompt.md` (canonical path, CLI-owned in the
-   interactive path; the coordinator's `cp` is the sanctioned equivalent).
+   interactive path; the driver's `cp` is the sanctioned equivalent).
 4. **builder per lane** — agent `architect-builder`, cwd = that lane's
    worktree, task = read `build/<id>-<lane>/prompt.md` before anything else.
    `timeoutMs` 7200000 (2h). The lane-prompt template below is the contract
@@ -39,13 +39,13 @@ start, crashed before work) gets one relaunch. Anything unrootable is an
 exception: `notes/exception-<ts>.md`, narrate, terminate — no improvised
 repairs.
 
-The coordinator never edits files except its own `notes/` reports and never
+The driver never edits files except its own `notes/` reports and never
 writes into `architecture/`.
 
 `architect dispatch` (everything below) remains the **interactive-path**
 mechanism — and the reference implementation of the lane contract the
-coordinator's spawns inherit (same prompt template, same builder guard
-discipline — interactive dispatch injects the guard via `-e`; a coordinator
+driver's spawns inherit (same prompt template, same builder guard
+discipline — interactive dispatch injects the guard via `-e`; a driver
 spawn relies on the playbook's no-git-writes rule plus the judge's post-flight
 `git log` check, which stays the authoritative proof in both paths).
 
@@ -82,7 +82,7 @@ If a lane committed, treat the worktree as tampered: reset and re-dispatch.
 builder model resolves with a one-message probe
 (`echo ok | pi -p --model <builder-model>`), confirm the role playbooks are
 installed (`architect install-agents` — once per machine, idempotent), and
-for a coordinator run confirm the routing config resolves — an
+for a driver run confirm the routing config resolves — an
 `architect.yaml` role pinning a model the registry doesn't know throws loudly
 at /loop pre-flight, before any spawn (/loop pre-flight does this for you).
 No API-key/env ceremony — provider
@@ -521,14 +521,6 @@ Paste the lane-prompt into an interactive `pi` session (no `-p`). pi's agent
 loop runs plan→act→test against the block's stopping condition while you watch
 and steer. Use when the human wants to babysit a run.
 
-A coordinator can be launched the same way when /loop is unavailable: spawn
-the agent `architect-coordinator` (role agents resolve from
-`~/.pi/agent/agents/`, user-level, installed by `architect install-agents` —
-no project trust involved) with cwd = the space root, the plan text verbatim
-as the task, the coordinator's model pin from `architect.yaml` in the spawn's
-model field, and `timeoutMs` 43200000 (12h) — the exact contract
-`coordinatorSpawnScript` in architect-loop.ts assembles.
-
 ## Lane-prompt template
 
 ```

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 9.6.0
+  version: 9.8.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -161,6 +161,7 @@ files:
 - lib/space_architect/gate_evaluator.rb
 - lib/space_architect/gate_lint.rb
 - lib/space_architect/harness.rb
+- lib/space_architect/iteration_emission.rb
 - lib/space_architect/loop_cost.rb
 - lib/space_architect/looplog.rb
 - lib/space_architect/pi/builder-guard.ts