space-architect 9.7.0 → 9.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f12c744b4e442b1ba96e09e2ede78bf7f048932d61bd891c667b65f62c78674a
-  data.tar.gz: 87e62449c0d0539fdf688fc7faa43909cbc0dc034c5a0ee477b645f3ceac7a9e
+  metadata.gz: 2a29d0c5688ed96e02a49a159385f508a845714e1741577384f6a6369a1fbb7e
+  data.tar.gz: 2b46a7ffee6ee544c9f5e30b7926f4ee5d541d81032be53617cec19f5e519bfd
 SHA512:
-  metadata.gz: c84129b96fa520324e1c15bf00f8f3de595bc642248ce3e72c9af0283b9802f63d2d3e7a15f1c450321bdf6c9840513ecce5cac477adf33cd0a8528bd63d585f
-  data.tar.gz: f1fff1968103fd8108619aefbcfd69531c6f2c916c42c4748ea75247ef8bf208d850a3c6bc79b208f12eb1c35b0cb9fc906a10455a357e13cd8ef1c326dec656
+  metadata.gz: d418323e0ef3c26cfdf2ca7d06aac9fcec9da1d74c8ccbb0a339cc5f0e85eaf9838ab5bf380f7949f28d30a416e7d5b2a0c9043e1fe74d3659ffbfaf5d764641
+  data.tar.gz: 6fdbc0e2e89a34ff61f661202fb04e0f452a5f2b096db28b2dfd0a3adf41e6b9194a82b62253e2e1d4e9647886244d0ff0e38339d898726b93d8bcebc207800f

data/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [9.8.0] - 2026-10-30
+
+### Removed
+
+- **The coordinator role (I10)** — the architect session itself drives the
+  loop in driver mode (the pi extension's `/loop` and agent-side launch
+  install a driver playbook instead of spawning a detached coordinator).
+  The role leaves the routing known set and the `architect routing init`
+  template (byte-exact contract re-frozen through both parsers), and
+  install no longer ships its playbook — a stale user-level
+  `architect-coordinator.md` is removed on install.
+
+### Changed
+
+- **Routing deprecation tolerance** — unknown `architect.yaml` role keys
+  (a retired key, or a typo) inform instead of rejecting: every command
+  proceeds, with one inform line naming the key and the known-role set.
+  Upgrading never breaks on an older config.
+- **Shipped skills rewritten for driver mode** — architect,
+  architect-action, and architect-discuss describe the session-driven
+  loop: one-hop escalations, state re-derived from disk each wake,
+  compaction after each child launch.
+
 ## [9.7.0] - 2026-10-30
 
 ### Added

data/lib/space_architect/agent_installer.rb

@@ -4,8 +4,10 @@ require "open3"
 
 module Space
   module Architect
-    # Installs the role playbooks (architect-coordinator/spec/builder/judge/
-    # narrator) to ~/.pi/agent/agents. The playbook text is rendered by the
+    # Installs the role playbooks (architect-spec/builder/judge/narrator) to
+    # ~/.pi/agent/agents and removes a stale architect-coordinator.md left by a
+    # pre-driver-era install (I10: the coordinator role retired — the architect
+    # session itself drives the loop). The playbook text is rendered by the
     # installed architect-loop extension itself — the extension owns that text
     # (it renders the per-space .pi/agents files from the same source), so this
     # installer carries no second copy to drift. Routing pins come from the
@@ -14,7 +16,7 @@ module Space
     # machine-wide fallback for sessions that cannot see a space's .pi dir;
     # a space's own .pi/agents files always win inside that space.
     module AgentInstaller
-      ROLES = %w[coordinator spec builder judge narrator].freeze
+      ROLES = %w[spec builder judge narrator].freeze
 
       # Renders each role's agent file and prints it between ===FILE===<role>
       # markers. Dynamic import (node -e runs CJS; import() is legal there) so
@@ -29,7 +31,7 @@ module Space
             console.error("no architect.yaml found — run `architect routing init --global` to scaffold the machine-wide config first");
             process.exit(1);
           }
-          for (const role of ["coordinator", "spec", "builder", "judge", "narrator"]) {
+          for (const role of ["spec", "builder", "judge", "narrator"]) {
             console.log("===FILE===" + role);
             console.log(renderAgentFile(role, config));
           }
@@ -53,11 +55,23 @@ module Space
           results = ROLES.map do |role|
             write_agent(dest.join("architect-#{role}.md"), rendered.fetch(role), force: force, dry_run: dry_run)
           end
+          results.concat(remove_stale_coordinator(dest, dry_run: dry_run))
           { dest_root: dest, agents: results, dry_run: dry_run }
         end
 
         private
 
+        # The retired coordinator playbook: remove, never update — the loop is
+        # driven by the architect session itself, so a leftover fifth playbook
+        # can only mislead. A dry run reports the would-be removal untouched.
+        def remove_stale_coordinator(dest, dry_run:)
+          stale = dest.join("architect-coordinator.md")
+          return [] unless stale.exist?
+
+          FileUtils.rm(stale) unless dry_run
+          [{ name: stale.basename.to_s, action: dry_run ? :would_remove : :removed, path: stale }]
+        end
+
         def default_dest(env)
           Pathname.new(env.fetch("PI_AGENTS_DIR", File.join(pi_agent_dir(env), "agents")))
         end

data/lib/space_architect/architect_project.rb

@@ -907,12 +907,12 @@ module Space::Architect
     def worktree_add(repo, iteration, lane, base: nil, base_explicit: !base.nil?, harness: nil, model: nil,
                      variant: false, effort: nil, touch: nil, force: false, err: $stderr)
       model, suffix_level = Harness.parse_model_suffix(model)
-      harness, model, inform = resolve_harness_model(harness, model)
+      harness, model, inform = resolve_harness_model(harness, model, err: err)
       err.puts inform if inform
       # The config layer sits above project.effort — architect.yaml is the
       # dedicated routing layer; unconfigured spaces fall through unchanged.
       resolved_level = effort || suffix_level ||
-        Routing.for_space(space.path)&.dig("builder", "thinking") || project_defaults["effort"]
+        Routing.for_space(space.path, err: err)&.dig("builder", "thinking") || project_defaults["effort"]
       Harness.validate_thinking_level!(resolved_level)
       if effort.nil? && suffix_level
         err.puts "thinking: model suffix ':#{suffix_level}' parsed from lane model → level=#{suffix_level} (model stripped)"
@@ -1992,12 +1992,14 @@ module Space::Architect
     # Returns [harness, model, inform] — inform is the loud last-resort line (nil
     # otherwise) for the caller to print once to its err stream when the model
     # fell all the way through to Harness::DEFAULT_MODEL (no flag, no stored
-    # value, no architect.yaml builder role, no project.model).
-    def resolve_harness_model(harness, model, stored_harness: nil, stored_model: nil)
+    # value, no architect.yaml builder role, no project.model). +err+ is additive
+    # (I10): given a stream, a config carrying an unknown role key prints the one
+    # per-process deprecation inform on it; nil (the default) resolves silently.
+    def resolve_harness_model(harness, model, stored_harness: nil, stored_model: nil, err: nil)
       defaults = project_defaults
       resolved_harness = (harness || stored_harness || defaults["harness"] || "pi").to_s
       stored_model = nil unless stored_harness.nil? || stored_harness.to_s == resolved_harness
-      config_model = Routing.for_space(space.path)&.dig("builder", "model")
+      config_model = Routing.for_space(space.path, err: err)&.dig("builder", "model")
       resolved_model = model || stored_model || config_model || defaults["model"] || Harness::DEFAULT_MODEL
       inform = default_model_inform if model.nil? && stored_model.nil? && config_model.nil? && defaults["model"].nil?
       [resolved_harness, resolved_model, inform]
@@ -2037,7 +2039,7 @@ module Space::Architect
     def resolve_dispatch_harness(lane_entry, model:, harness:, effort:, force:, err:)
       model, suffix_level = Harness.parse_model_suffix(model)
       resolved_harness, resolved_model, inform = resolve_harness_model(harness, model,
-        stored_harness: lane_entry["harness"], stored_model: lane_entry["model"])
+        stored_harness: lane_entry["harness"], stored_model: lane_entry["model"], err: err)
       err.puts inform if inform
 
       resolved_effort =
@@ -2050,7 +2052,7 @@ module Space::Architect
         else
           # Dispatch's tail is the lane's stored effort (project.effort was never
           # in the dispatch chain); architect.yaml builder thinking slots in above it.
-          lane_entry["effort"] || Routing.for_space(space.path)&.dig("builder", "thinking")
+          lane_entry["effort"] || Routing.for_space(space.path, err: err)&.dig("builder", "thinking")
         end
 
       [resolved_harness, resolved_model, resolved_effort]

data/lib/space_architect/cli/architect.rb

@@ -172,7 +172,10 @@ module Space::Architect
               # constant as the last resort it is, not ordinary behavior.
               # Fully qualified: the Architect::Routing subcommand namespace
               # (I09) lexically shadows Space::Architect::Routing inside this module.
-              config_model = Space::Architect::Routing.for_space(sp.path)&.dig("builder", "model")
+              # err: $stderr makes status one of the three deprecation-inform surfaces
+              # (I10) — a config still carrying an unknown role key informs once per
+              # process, here or on whichever surface resolves routing first.
+              config_model = Space::Architect::Routing.for_space(sp.path, err: $stderr)&.dig("builder", "model")
 
               terminal.say "Project status:     #{block['status'] || '(none)'}"
               terminal.say "Current iteration:  #{block['current_iteration'] || '(none)'}"
@@ -1162,7 +1165,7 @@ module Space::Architect
       # global-routing pins — the machine-wide fallback for sessions that
       # cannot see a space's .pi dir. Needs install-extensions to have run.
       class InstallAgents < BaseCommand
-        desc "Install the role playbooks (architect-coordinator/spec/builder/judge/narrator) to ~/.pi/agent/agents, rendered from the installed architect-loop extension"
+        desc "Install the role playbooks (architect-spec/builder/judge/narrator) to ~/.pi/agent/agents, rendered from the installed architect-loop extension, and remove a stale architect-coordinator.md"
         phase 53, "Project"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing playbooks that differ"
         option :dry_run, type: :boolean, default: false, desc: "Print what would happen without writing files"

data/lib/space_architect/routing.rb

@@ -17,48 +17,47 @@ module Space::Architect
   # XDG_CONFIG_HOME); space-local is architect.yaml beside the loaded
   # space.yaml (the CLI already resolved the space — no walk-up).
   module Routing
-    ROLES          = %w[architect spec builder judge coordinator narrator].freeze
-    # The five agent roles that must be routed after the merge; `architect` is optional.
-    REQUIRED_ROLES = %w[spec builder judge coordinator narrator].freeze
+    ROLES          = %w[architect spec builder judge narrator].freeze
+    # The four agent roles that must be routed after the merge; `architect` is optional.
+    REQUIRED_ROLES = %w[spec builder judge narrator].freeze
     ENTRY_KEYS     = %w[model thinking].freeze
 
     # I09: the `architect routing init` scaffold — the exact bytes the command
     # writes, living beside the parsers that must accept it. Example models are
     # loud REPLACE_MEs; the header comment carries both locations and the merge
-    # order so the file is self-documenting. Byte-exact contract: the extension
-    # lane's tests carry an inline copy, and the command round-trips the write
-    # through parse below — a template the machinery rejects is a bug.
+    # order so the file is self-documenting. Byte-exact contract (1021 B): the
+    # extension lane's tests carry an inline copy, and the command round-trips
+    # the write through parse below — a template the machinery rejects is a bug.
+    # I10: the detached driver role retired (the architect session drives the
+    # loop itself); the scaffold routes the four required roles plus optional architect.
     TEMPLATE = <<~'YAML'.freeze
-      # architect.yaml — space-architect loop role routing, scaffolded by `architect routing init`.
-      # Locations (merged in this order; the space-local entry wins per role):
-      #   global:  ~/.config/space-architect/architect.yaml   (machine-wide)
-      #   local:   architect.yaml beside this space's space.yaml (this file)
-      # A local entry overrides the global entry for THAT ROLE only; after the
-      # merge every agent role must be routed: spec, builder, judge, coordinator,
-      # narrator (architect is optional).
-      # Replace every example/REPLACE_ME below with a real provider/model-id
-      # (e.g. zai/glm-5.3). thinking is optional: off|minimal|low|medium|high|xhigh|max.
-      # Once saved, the next /loop or architect command picks the file up.
-      version: 1
-      roles:
-        architect:
-          model: example/REPLACE_ME
-          thinking: high
-        spec:
-          model: example/REPLACE_ME
-          thinking: high
-        builder:
-          model: example/REPLACE_ME
-          thinking: high
-        judge:
-          model: example/REPLACE_ME
-          thinking: high
-        coordinator:
-          model: example/REPLACE_ME
-          thinking: high
-        narrator:
-          model: example/REPLACE_ME
-          thinking: low
+    # architect.yaml — space-architect loop role routing, scaffolded by `architect routing init`.
+    # Locations (merged in this order; the space-local entry wins per role):
+    #   global:  ~/.config/space-architect/architect.yaml   (machine-wide)
+    #   local:   architect.yaml beside this space's space.yaml (this file)
+    # A local entry overrides the global entry for THAT ROLE only; after the
+    # merge every agent role must be routed: spec, builder, judge, narrator
+    # (architect is optional).
+    # Replace every example/REPLACE_ME below with a real provider/model-id
+    # (e.g. zai/glm-5.3). thinking is optional: off|minimal|low|medium|high|xhigh|max.
+    # Once saved, the next /loop or architect command picks the file up.
+    version: 1
+    roles:
+      architect:
+        model: example/REPLACE_ME
+        thinking: high
+      spec:
+        model: example/REPLACE_ME
+        thinking: high
+      builder:
+        model: example/REPLACE_ME
+        thinking: high
+      judge:
+        model: example/REPLACE_ME
+        thinking: high
+      narrator:
+        model: example/REPLACE_ME
+        thinking: low
     YAML
 
     # The one canonical cure line appended to default_model_inform's last-resort
@@ -75,14 +74,34 @@ module Space::Architect
       Pathname.new(space_dir).join("architect.yaml")
     end
 
-    # Parse one file's text into { role => {"model" => id, "thinking" => level|nil} }.
-    # +path+ is used only in error messages. Frozen v1 rules: integer version 1,
-    # the six known roles, entries ⊆ {model, thinking} with a non-empty model,
-    # duplicate mapping keys rejected (psych's plain load silently keeps the
-    # last — the npm yaml the extension parses with throws), aliases accepted,
-    # a trailing :level suffix on model parsed via Harness.parse_model_suffix
-    # and beating the thinking key.
+    # Parse one file's text into { role => {"model" => id, "thinking" => level|nil} }
+    # for the KNOWN roles. +path+ is used only in error messages. Frozen v1 rules:
+    # integer version 1, the five known roles, entries ⊆ {model, thinking} with a
+    # non-empty model, duplicate mapping keys rejected (psych's plain load silently
+    # keeps the last — the npm yaml the extension parses with throws), aliases
+    # accepted, a trailing :level suffix on model parsed via Harness.parse_model_suffix
+    # and beating the thinking key. Unknown role keys (I10 deprecation tolerance: a
+    # config still carrying a retired role key, or a typo) are skipped for
+    # routing and collected — see split_known_and_unknown.
     def self.parse(text, path)
+      split_known_and_unknown(text, path).first
+    end
+
+    # The pure deprecation seam (I10): the unknown role keys under `roles:` in one
+    # file's text, in document order. Same parse rules as
+    # parse (known-role validation included); only unknown entries are skipped
+    # unvalidated, so the inform never fires for a config the parser rejects.
+    def self.unknown_role_keys(text, path)
+      split_known_and_unknown(text, path).last
+    end
+
+    # One parse, two results: [known-role hash, unknown role keys]. An unknown
+    # STRING key is skipped whole for routing — its entry content is never
+    # validated (an ignored key is ignored whole; garbage under
+    # roles.<retired-role>.thinking must not raise) — and collected for the one
+    # deprecation inform. A non-string key is corruption, not a retired role
+    # name, and still fails loud under the known-role error.
+    def self.split_known_and_unknown(text, path)
       assert_unique_keys!(text, path)
       doc = YAML.safe_load(text, aliases: true)
       unless doc.is_a?(Hash)
@@ -98,8 +117,14 @@ module Space::Architect
       end
 
       parsed = {}
+      unknown = []
       roles.each do |role, entry|
-        unless ROLES.include?(role)
+        if role.is_a?(String)
+          unless ROLES.include?(role)
+            unknown << role # an ignored key is ignored whole: skip for routing, no entry validation
+            next
+          end
+        else
           raise Space::Core::Error,
             "architect.yaml (#{path}): roles.#{role} — expected one of #{ROLES.join('|')}, got #{role.inspect}"
         end
@@ -136,24 +161,48 @@ module Space::Architect
         end
         parsed[role] = { "model" => model, "thinking" => suffix_level || thinking }
       end
-      parsed
+      [parsed, unknown]
     rescue Psych::Exception => e
       raise Space::Core::Error, "architect.yaml (#{path}): malformed YAML — #{e.message}"
     end
 
+    # The one deprecation inform for unknown role keys (I10): names every
+    # roles.<key> found, the known-role set, and that the entries are ignored.
+    # Fired at most once per PROCESS via the class-level flag — worktree_add and
+    # dispatch each resolve routing twice per invocation, so per-call emission
+    # would double-print. A config with no unknown key never composes the
+    # message, so the memo never fires. Tests reset it with
+    # remove_instance_variable(:@deprecation_informed).
+    def self.inform_deprecated_roles!(err, keys, found)
+      return if keys.empty? || @deprecation_informed
+
+      @deprecation_informed = true
+      err.puts "architect.yaml (#{found.join(' + ')}): ignoring unknown role key(s) " \
+               "#{keys.map { |k| "roles.#{k}" }.join(', ')} — known roles: #{ROLES.join(', ')} (each entry is ignored)"
+    end
+
     # The merged routing for a space: [global, space-local] merged per role key
     # (a space file may override only builder and inherit the rest). nil when
     # NEITHER file exists — no config is a normal state: no error, no side
     # effects. Any found file that is malformed/invalid fails loud at parse;
-    # after the merge all four agent roles must be routed.
-    def self.for_space(space_dir)
+    # after the merge all four agent roles must be routed. +err+ is additive
+    # (I10): when given, a merged config carrying unknown role keys prints the
+    # one per-process deprecation inform on it; existing callers (no err)
+    # resolve silently as before.
+    def self.for_space(space_dir, err: nil)
       global = global_path
       local  = space_path(space_dir)
       found  = [global, local].select { |p| File.file?(p.to_s) }
       return nil if found.empty?
 
       merged = {}
-      found.each { |p| merged.merge!(parse(File.read(p.to_s), p)) }
+      unknown = []
+      found.each do |p|
+        known, keys = split_known_and_unknown(File.read(p.to_s), p)
+        merged.merge!(known)
+        unknown |= keys
+      end
+      inform_deprecated_roles!(err, unknown, found) if err
       missing = REQUIRED_ROLES - merged.keys
       if missing.any?
         raise Space::Core::Error,

data/lib/space_architect/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Architect
-    VERSION = "9.7.0"
+    VERSION = "9.8.0"
   end
 end

data/skill/architect/SKILL.md

@@ -72,13 +72,14 @@ the space durable across sessions:
 - **architect** — the judgment seat (this session in either mode: inline
   here, judgment in `/architect-discuss`): plans, arbitrates, rules on
   escalations, judges, lands. In inline mode it also does the work directly.
-- **coordinator** — a detached, cheap-model session that drives one plan:
-  spawns and tends spec → builders → judge per iteration; relays escalations
-  verbatim; never does lane work.
+- **driver** — the architect session itself, in driver mode (the /loop
+  tool installs the driver playbook as operating instructions): spawns and
+  tends spec → builders → judge per iteration; rules escalations in-seat;
+  never does lane work.
 - **spec** — writes one iteration's Grounds/Specification/Acceptance
   Criteria; rehearses; freezes; writes the `notes/spec-digest-*` handoff.
 - **builder** — implementation in one lane's worktree; reports raw evidence
-  only; never commits. Spawned by the coordinator as a subagent, or run via
+  only; never commits. Spawned by the driver as a subagent, or run via
   the `architect dispatch` CLI (which streams to
   `build/<id>-<lane>/run.jsonl`).
 - **judge** — a fresh session that runs the cold gates and rules per-AC
@@ -146,13 +147,14 @@ Read-only orientation commands: `architect status`, `architect looplog
 
 - **`/architect-discuss`** — engineering exploration and arbitration,
   judging a finished run, landing PRs, iteration surgery.
-- **`/architect-action`** — write the plan doc and launch the coordinator.
+- **`/architect-action`** — write the plan doc and drive the loop yourself
+  as the driver.
 - **`/architect-status`** — "what are we working on in here? is it done?"
 - **`/architect-research`** — discovery-scale research.
 
 ## Maintenance
 
 This skill carries the shared vocabulary inline. When loop mechanics change
-(the coordinator flow, dispatch, routing), re-read this file against the
+(the driver flow, dispatch, routing), re-read this file against the
 `architect-discuss` skill and the gem README and update the glossary —
 drift between the two is silent confusion for every future session.

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.7.0
+  version: 9.8.0
 platform: ruby
 authors:
 - Eric Jacobs