space-architect 9.3.0 → 9.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fd0baee9b2db69fa1ef96c1b4993f75a8912b5b0898d012c13036a379e32a7f
-  data.tar.gz: 582172fa5c61e4a9419409cafdfa8701ca096a2621527141099944f3261c6592
+  metadata.gz: 4de640b748008dc4484903c88d496366528cb9eb294002abad5bc02547816198
+  data.tar.gz: 4aa87deb60eee6dc8d768d6f333204137d7ddb49a3e94640263fce5711623e3e
 SHA512:
-  metadata.gz: 59dd000d01b8fd0b42729d87f7f843f93690b0fbccf927e127426f352fa79aada6078a885b54e3342d3c901500fde93338be3198b77e871df85f7b28ef816f9e
-  data.tar.gz: 29f88c1fdec961ed7b53d9d9e4a3a3c156cadac2da157786bea28fca4b20b09cb786ab195d5eedf0877e11c901a2d140d66347bbee3fc52570a4a68225b78284
+  metadata.gz: 5e383f34c36693c6ad9290ec9db84815835545676c194d4c06d79d630c6bc4f98ba6b1c7072570c60b4ce3df2b782d0a6e064b0d1ed5d31fdd9baacc6dbe0342
+  data.tar.gz: b957f8f1a303a9a2c88ad0c569a8ce8b572740dfffb1da6aa203b0e66fb15f1984d711479549c6d1a35ae7ece15a502f3f48994f5614bf09a06346b3392b129a

data/CHANGELOG.md

@@ -5,6 +5,64 @@ 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.5.0] - 2026-10-17
+
+### Added
+
+- **`architect install`** — the one-shot machine install: skills
+  (`--provider`, default pi), the architect-loop extension, then the role
+  playbooks, in that order (install-agents renders from the extension the
+  prior step installs). Each step aborts loudly; no partial silent states.
+- **`architect install-agents`** — the role playbooks to
+  `~/.pi/agent/agents/`, rendered by the installed architect-loop extension
+  (the single owner of the playbook text) with global-routing pins;
+  write-if-changed, `--force`, `--dry-run` like install-skills. Loud
+  failures name the prerequisite (`install-extensions`) or the cure
+  (`routing init --global`).
+
+### Changed
+
+- **install-skills targets pi by default** (was claude; `--provider` still
+  selects claude/codex/opencode).
+- **looplog tags**: the narrator abbreviates to `narr` (it previously
+  truncated to "architect-"), and lane-worktree tags carry the iteration
+  ordinal plus the lane, resolved against the space's iteration ids —
+  `[bld:67-core]` instead of the old clipped
+  `[bld:rig-oracle-repin-core]`.
+
+## [9.4.0] - 2026-10-17
+
+### Added
+
+- **The skill family.** `/architect` is now the inline working mode — work
+  outside the loop at a conversational cadence (UI, ops, small fixes), with
+  the space as the workspace (notes kept, `ARCHITECT.md` updated, commits
+  when the work calls for them) and the vocabulary glossary folded in.
+  **`/architect-discuss`** carries the judgment seat: exploration,
+  arbitration, judging finished runs, landing, iteration surgery.
+  **`/architect-status`** reports state read-only from CLI output and the
+  newest notes. The coordinator launch is agent-owned end to end:
+  **`/architect-action`** (renamed from `/architect-plan`) launches via the
+  new `architect_loop` pi-extension tool (jetpks/pi-extensions) — the
+  agent-side equivalent of `/loop`, sharing one spawn path so the two cannot
+  drift, awaiting the run id, then self-compacting the launching session
+  into a small on-call escalation seat.
+
+### Changed
+
+- The `install-skills` help text, `docs/DESIGN.md`, and
+  `docs/reference/project.md` describe the five-skill family; the
+  `/architect-discuss` routing section now describes the real dual
+  agent-file mechanism (per-space `.pi/agents/` generation with resolved
+  pins, plus user-level `install-agents` playbooks as the headless/
+  untrusted fallback) instead of claiming nothing generates into the space.
+
+### Removed
+
+- **`/architect-plan`** (renamed to `/architect-action`) and
+  **`/architect-vocabulary`** (folded into `/architect`); the `dispatch.md`
+  and `research.md` companion references moved to the discuss skill.
+
 ## [9.3.0] - 2026-10-17
 
 ### Removed

data/lib/space_architect/agent_installer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+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
+    # 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
+    # global architect.yaml (ENV["SPACE_ARCHITECT_GLOBAL_CONFIG"] overrides the
+    # path, honored inside the extension): the user-level files are the
+    # 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
+
+      # Renders each role's agent file and prints it between ===FILE===<role>
+      # markers. Dynamic import (node -e runs CJS; import() is legal there) so
+      # the .ts source — type-stripped by node — loads with its own package's
+      # node_modules. The scratch startDir forces global-only routing.
+      RENDER_SCRIPT = <<~JS
+        const { pathToFileURL } = require("node:url");
+        const fs = require("node:fs"), os = require("node:os"), path = require("node:path");
+        import(pathToFileURL(process.argv[1]).href).then(({ renderAgentFile, resolveConfig }) => {
+          const config = resolveConfig(fs.mkdtempSync(path.join(os.tmpdir(), "architect-agents-")), {});
+          if (!config) {
+            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"]) {
+            console.log("===FILE===" + role);
+            console.log(renderAgentFile(role, config));
+          }
+        }).catch((error) => {
+          console.error(error && error.message ? error.message : String(error));
+          process.exit(1);
+        });
+      JS
+
+      class << self
+        def install(env: ENV, force: false, dry_run: false, dest: nil, extension_dir: nil)
+          source = extension_dir ? Pathname.new(extension_dir).join("architect-loop.ts") : locate_extension(env)
+          unless source&.exist?
+            raise Space::Core::Error,
+                  "architect-loop.ts not found under #{search_root(env)} — run `architect install-extensions` first " \
+                  "(install-agents renders its playbooks from the installed extension)"
+          end
+
+          dest ||= default_dest(env)
+          rendered = render_via_node(source, env)
+          results = ROLES.map do |role|
+            write_agent(dest.join("architect-#{role}.md"), rendered.fetch(role), force: force, dry_run: dry_run)
+          end
+          { dest_root: dest, agents: results, dry_run: dry_run }
+        end
+
+        private
+
+        def default_dest(env)
+          Pathname.new(env.fetch("PI_AGENTS_DIR", File.join(pi_agent_dir(env), "agents")))
+        end
+
+        # Same convention as SkillInstaller: PI_CODING_AGENT_DIR or ~/.pi/agent.
+        def pi_agent_dir(env)
+          Pathname.new(env.fetch("PI_CODING_AGENT_DIR", File.join(Space::Core::XDG.home(env: env), ".pi", "agent")))
+        end
+
+        def search_root(env)
+          File.join(pi_agent_dir(env), "git", "**")
+        end
+
+        # The installed extension package: pi clones it under
+        # <agent dir>/git/<host>/<owner>/pi-extensions/. First match wins;
+        # --extension-dir (tests) bypasses discovery.
+        def locate_extension(env)
+          Dir.glob(File.join(search_root(env), "pi-extensions", "architect-loop.ts")).first # paths:exempt — enumerates pi's own managed install layout (git/<host>/<owner>/pi-extensions), matching exactly the declared package, never user project files
+            &.then { |p| Pathname.new(p) }
+        end
+
+        def render_via_node(source, env)
+          out, err, status = Open3.capture3(env, "node", "-e", RENDER_SCRIPT, source.to_s)
+          unless status.success?
+            raise Space::Core::Error, "rendering playbooks via node failed (exit #{status.exitstatus}):\n#{out + err}"
+          end
+
+          rendered = {}
+          marker = nil
+          out.each_line do |line|
+            if (m = line.match(/\A===FILE===(\w+)\n?\z/))
+              marker = m[1]
+              rendered[marker] = +""
+            elsif marker
+              rendered[marker] << line
+            end
+          end
+          missing = ROLES - rendered.keys
+          raise Space::Core::Error, "rendered output missing roles: #{missing.join(', ')}" if missing.any?
+          rendered
+        rescue Errno::ENOENT
+          raise Space::Core::Error,
+                "node: command not found — install-agents renders playbooks through the installed " \
+                "architect-loop extension, which needs node on PATH (it ships with pi)."
+        end
+
+        def write_agent(dest, content, force:, dry_run:)
+          name = dest.basename.to_s
+          if dest.exist?
+            return { name: name, action: :unchanged, path: dest } if File.read(dest) == content
+            return { name: name, action: :conflict, path: dest } if dry_run
+
+            raise Space::Core::Error,
+                  "Refusing to overwrite existing playbook at #{dest}. Re-run with --force." unless force
+
+            File.write(dest, content)
+            { name: name, action: :updated, path: dest }
+          else
+            FileUtils.mkdir_p(dest.parent)
+            File.write(dest, content) unless dry_run
+            { name: name, action: dry_run ? :would_install : :installed, path: dest }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/architect_project.rb

@@ -1713,7 +1713,7 @@ module Space::Architect
     # two paths looked at, and the default in use.
     def default_model_inform
       "model: no architect.yaml found (looked at #{Routing.space_path(space.path)} + #{Routing.global_path}) — " \
-        "using default '#{Harness::DEFAULT_MODEL}'"
+        "using default '#{Harness::DEFAULT_MODEL}' #{Routing::INIT_HINT}"
     end
 
     # --prompt: the caller authors the lane prompt anywhere (a fresh scratch file) and

data/lib/space_architect/cli/architect.rb

@@ -6,6 +6,7 @@ require_relative "../loop_cost"
 require_relative "../runlog"
 require_relative "../looplog"
 require_relative "../extension_installer"
+require_relative "../agent_installer"
 
 module Space::Architect
   module CLI
@@ -169,7 +170,9 @@ module Space::Architect
               # Legacy lanes store no model — resolve the config layer once so the
               # display shows what they would actually route, and mark the bare
               # constant as the last resort it is, not ordinary behavior.
-              config_model = Routing.for_space(sp.path)&.dig("builder", "model")
+              # 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")
 
               terminal.say "Project status:     #{block['status'] || '(none)'}"
               terminal.say "Current iteration:  #{block['current_iteration'] || '(none)'}"
@@ -1060,14 +1063,14 @@ module Space::Architect
       end
 
       class InstallSkills < BaseCommand
-        desc "Install bundled skills (architect, architect-research, architect-vocabulary) for a harness"
+        desc "Install bundled skills (architect, architect-discuss, architect-action, architect-status, architect-research) for a harness"
         phase 53, "Project"
-        option :provider, default: "claude", desc: "Skill install target (default: claude; validated by the installer)"
+        option :provider, default: "pi", desc: "Skill install target (default: pi; validated by the installer)"
         option :project, type: :boolean, default: false, desc: "Install to CWD instead of global"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing skills that differ"
         option :dry_run, type: :boolean, default: false, desc: "Print what would happen without writing files"
 
-        def call(provider: "claude", project: false, force: false, dry_run: false, **opts)
+        def call(provider: "pi", project: false, force: false, dry_run: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
             result = SkillInstaller.install(provider, project: project, force: force,
@@ -1100,6 +1103,111 @@ module Space::Architect
         end
       end
 
+      # Role playbooks to ~/.pi/agent/agents, rendered from the installed
+      # architect-loop extension (the single owner of the playbook text) with
+      # 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"
+        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"
+
+        def call(force: false, dry_run: false, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            result = AgentInstaller.install(env: project_config.env, force: force, dry_run: dry_run)
+            verb = dry_run ? "Would install" : "Installed"
+            terminal.say "#{verb} role playbooks for pi → #{terminal.path(result[:dest_root])}"
+            result[:agents].each do |a|
+              terminal.say "  #{a[:name]}: #{terminal.style_skill_action(a[:action])} (#{terminal.path(a[:path])})"
+            end
+            CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+        end
+      end
+
+      # The one-shot machine install: skills (pi by default), the
+      # architect-loop extension, then the role playbooks — in that order,
+      # because install-agents renders from the extension the prior step just
+      # installed. Each step aborts loudly on failure; there are no partial
+      # silent states to reason about afterwards.
+      class Install < BaseCommand
+        desc "Install everything for this machine: skills (--provider, default pi), the architect-loop extension, then the role playbooks"
+        phase 53, "Project"
+        option :provider, default: "pi", desc: "Skill install target (default: pi; validated by the installer; passed through to install-skills)"
+        option :force,   type: :boolean, default: false, desc: "Overwrite existing skills/playbooks that differ (passed through)"
+
+        def call(provider: "pi", force: false, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            skills = SkillInstaller.install(provider, project: false, force: force,
+                                             env: project_config.env)
+            terminal.say "skills → #{terminal.path(skills[:dest_root])}"
+            skills[:skills].each { |s| terminal.say "  #{s[:name]}: #{terminal.style_skill_action(s[:action])}" }
+
+            extensions = ExtensionInstaller.install(env: project_config.env)
+            extensions[:steps].each { |s| terminal.say "  #{s[:cmd]} (exit #{s[:exit_code]})" }
+
+            agents = AgentInstaller.install(env: project_config.env, force: force)
+            terminal.say "role playbooks → #{terminal.path(agents[:dest_root])}"
+            agents[:agents].each { |a| terminal.say "  #{a[:name]}: #{terminal.style_skill_action(a[:action])}" }
+
+            CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+        end
+      end
+
+      module Routing
+        # I09: `architect routing init` — the self-service cure for the
+        # missing-config wall (default_model_inform's hint names this command).
+        # Writes Routing::TEMPLATE verbatim and round-trips the write through
+        # Routing.parse before claiming success; the routing machinery itself
+        # is untouched — the command only writes a file it already accepts.
+        class Init < BaseCommand
+          desc "Write a commented starter architect.yaml (space root by default; --global for the machine-wide config)"
+          phase 53, "Project"
+          argument :space, required: false, desc: "Space identifier (default: $PWD)"
+          option :global, type: :boolean, default: false,
+            desc: "Write ~/.config/space-architect/architect.yaml (the machine-wide config; SPACE_ARCHITECT_GLOBAL_CONFIG overrides the path) instead of the space root, creating parent directories as needed"
+
+          def call(space: nil, global: false, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              target =
+                if global
+                  raise Space::Core::Error, "--global and an explicit space argument are mutually exclusive" if space
+                  # Routing.global_path is the env-overridable canonical path — never re-derive it here.
+                  path = Space::Architect::Routing.global_path
+                  FileUtils.mkdir_p(path.dirname)
+                  path
+                else
+                  # The house walk-up: empty identifier looks for space.yaml from $PWD upward.
+                  found = store.find(space).value_or(nil)
+                  unless found
+                    raise Space::Core::Error,
+                      "no space.yaml found upward from #{Dir.pwd} — run `architect routing init --global` to scaffold the machine-wide config instead"
+                  end
+                  Space::Architect::Routing.space_path(found.path)
+                end
+
+              raise Space::Core::Error, "architect.yaml already exists: #{target} — routing init never overwrites" if target.exist?
+
+              File.write(target, Space::Architect::Routing::TEMPLATE)
+              # A scaffold that fails its own parser (or misses a required role)
+              # is a bug — validate the round-trip, let the error escape loud.
+              parsed = Space::Architect::Routing.parse(File.read(target), target)
+              missing = Space::Architect::Routing::REQUIRED_ROLES - parsed.keys
+              raise Space::Core::Error, "scaffolded #{target} is missing required roles: #{missing.join(', ')}" if missing.any?
+
+              terminal.say "Wrote starter routing config: #{terminal.path(target.to_s)}"
+              terminal.say "Edit the example/REPLACE_ME models; the next command or /loop picks the file up."
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
       module Worktree
         class Add < BaseCommand
           desc "Create a worktree for a lane"
@@ -1326,8 +1434,10 @@ Space::Architect::CLI::Registry.register "evidence",  Space::Architect::CLI::Arc
 Space::Architect::CLI::Registry.register "merge",     Space::Architect::CLI::Architect::Merge
 Space::Architect::CLI::Registry.register "integrate", Space::Architect::CLI::Architect::Integrate
 Space::Architect::CLI::Registry.register "gate",      Space::Architect::CLI::Architect::Gate
+Space::Architect::CLI::Registry.register "install",         Space::Architect::CLI::Architect::Install
 Space::Architect::CLI::Registry.register "install-skills", Space::Architect::CLI::Architect::InstallSkills
 Space::Architect::CLI::Registry.register "install-extensions", Space::Architect::CLI::Architect::InstallExtensions
+Space::Architect::CLI::Registry.register "install-agents",   Space::Architect::CLI::Architect::InstallAgents
 Space::Architect::CLI::Registry.register "runlog",          Space::Architect::CLI::Architect::Runlog
 Space::Architect::CLI::Registry.register "looplog",         Space::Architect::CLI::Architect::Looplog
 Space::Architect::CLI::Registry.register "bug-report",     Space::Architect::CLI::Architect::BugReport
@@ -1340,6 +1450,9 @@ Space::Architect::CLI::Registry.register "worktree" do |wt|
   wt.register "remove", Space::Architect::CLI::Architect::Worktree::Remove
   wt.register "list",   Space::Architect::CLI::Architect::Worktree::List
 end
+Space::Architect::CLI::Registry.register "routing" do |r|
+  r.register "init", Space::Architect::CLI::Architect::Routing::Init
+end
 Space::Architect::CLI::Registry.register "variant" do |v|
   v.register "add",     Space::Architect::CLI::Architect::Variant::Add
   v.register "promote", Space::Architect::CLI::Architect::Variant::Promote

data/lib/space_architect/looplog.rb

@@ -56,7 +56,8 @@ module Space
           "architect-coordinator" => "coord",
           "architect-spec" => "spec",
           "architect-judge" => "judge",
-          "architect-builder" => "bld"
+          "architect-builder" => "bld",
+          "architect-narrator" => "narr"
         }.freeze
 
         TAG_COLORS = %w[36 35 33 32 34 95 96 91].freeze
@@ -166,13 +167,23 @@ module Space
           [cwd, task]
         end
 
-        # [bld:I35-editor-multiline-core] when cwd is a lane worktree, else the role.
-        def tag_label(agent, cwd)
+        # [bld:67-core] when cwd is a lane worktree — the iteration ordinal
+        # plus the lane name, resolved against the space's known iteration ids
+        # (architecture/I<NN>-<name>.md) so a hyphenated iteration slug cannot
+        # bleed into the lane (I06-editor-markdown-markdown-seam → 06-markdown-seam).
+        # An unrecognized dir (no architecture/, or a legacy name) falls back
+        # to the whole dir name minus the I<NN>- prefix, clipped.
+        def tag_label(agent, cwd, iteration_ids: [])
           role = ROLE_ABBREV.fetch(agent, agent[0, 10])
           return role unless cwd && File.basename(cwd) == "wt"
 
-          lane = File.basename(File.dirname(cwd)).sub(/\A[Ii]\d+-/, "")
-          "#{role}:#{lane[0, 26]}"
+          dir = File.basename(File.dirname(cwd))
+          ordinal = dir[/\A[Ii](\d+)-/, 1]
+          return "#{role}:#{dir[0, 26]}" unless ordinal
+
+          lane = iteration_ids.filter_map { |id| dir.delete_prefix("#{id}-") if dir.start_with?("#{id}-") }.first
+          lane ||= dir.sub(/\A[Ii]\d+-/, "")
+          "#{role}:#{ordinal}-#{lane[0, 26]}"
         end
 
         def paint_tag(label, run_id)
@@ -350,7 +361,7 @@ module Space
               cwd, task = backscan(t.path)
               @io.puts format("%s %-9s %5s %5.0fm %7sK  %s  %s",
                               active ? green("●") : dim("·"),
-                              tag_label(t.agent, cwd),
+                              tag_label(t.agent, cwd, iteration_ids: iteration_ids),
                               dim(Time.at(t.mtime).strftime("%H:%M")),
                               age_min, t.size / 1024,
                               dim(t.run_id[0, 8]),
@@ -390,9 +401,18 @@ module Space
 
         private
 
+        # The space's iteration ids (architecture/I<NN>-<name>.md basenames) —
+        # the authority for splitting a lane dir name into iteration and lane
+        # without guessing at hyphen boundaries.
+        def iteration_ids
+          # paths:exempt — the I[0-9]*-*.md pattern structurally cannot match a dotfile-prefixed name; one non-hidden directory level, no dotfile hazard
+          @iteration_ids ||= Dir.glob(File.join(@space.to_s, "architecture", "I[0-9]*-*.md"))
+                               .map { |p| File.basename(p, ".md") }
+        end
+
         def adopt(t)
           cwd, task = backscan(t.path)
-          tag = paint_tag(tag_label(t.agent, cwd), t.run_id)
+          tag = paint_tag(tag_label(t.agent, cwd, iteration_ids: iteration_ids), t.run_id)
           run = Run.new(t.path, t.run_id, t.agent, tag,
                         Renderer.new(limit: @limit, think_limit: @env["RUNLOG_THINK"]&.to_i, color: @color),
                         @replay ? 0 : t.size, +"", stamp_now)

data/lib/space_architect/pi/builder-guard.ts

@@ -4,6 +4,11 @@
 // and commands bash cannot parse (a parse error at tool time burns a turn).
 // Parse-level only: `bash -n` cannot catch runtime failures — those are the
 // bash tool's own domain.
+//
+// NOTE: a sibling copy of the guard logic lives in jetpks/pi-extensions
+// (imported by architect-loop.ts, which applies the same denials to sessions
+// whose cwd is a lane worktree — coordinator-spawned builders cannot get -e
+// injection). The logic is kept identical across both — change them together.
 import { spawnSync } from "node:child_process";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
@@ -80,6 +85,13 @@ function parseDenial(command: string): string | null {
 		`fix the command's syntax — bash said: ${(check.stderr ?? "").trim()}`;
 }
 
+// The combined denial for a bash command: why it must not run, or null.
+// Exported pure so architect-loop.ts can apply the same rules to sessions
+// running inside lane worktrees (see the NOTE above).
+export function guardDenial(command: string): string | null {
+	return gitWriteDenial(command) ?? parseDenial(command);
+}
+
 export default function builderGuard(pi: ExtensionAPI): void {
 	pi.on("tool_call", (event) => {
 		// bash only: the deny list is shell-command shaped; edit/write tools are
@@ -90,7 +102,7 @@ export default function builderGuard(pi: ExtensionAPI): void {
 
 		// Test the command string itself, never the JSON-rendered whole input —
 		// a payload that merely mentions `git commit` in prose must not match.
-		const denial = gitWriteDenial(command) ?? parseDenial(command);
+		const denial = guardDenial(command);
 		if (denial) {
 			return {
 				block: true,

data/lib/space_architect/routing.rb

@@ -22,6 +22,49 @@ module Space::Architect
     REQUIRED_ROLES = %w[spec builder judge coordinator 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.
+    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
+    YAML
+
+    # The one canonical cure line appended to default_model_inform's last-resort
+    # inform — self-punctuating, appended after a single space by the caller.
+    INIT_HINT = "Create one: `architect routing init` (beside space.yaml) or `architect routing init --global` (~/.config/space-architect/architect.yaml).".freeze
+
     def self.global_path
       env = ENV["SPACE_ARCHITECT_GLOBAL_CONFIG"]
       return Pathname.new(env) unless env.nil?

data/lib/space_architect/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Architect
-    VERSION = "9.3.0"
+    VERSION = "9.5.0"
   end
 end

data/lib/space_architect.rb

@@ -9,6 +9,7 @@ require_relative "space_architect/gate_lint"
 require_relative "space_architect/gate_evaluator"
 require_relative "space_architect/architect_project"
 require_relative "space_architect/skill_installer"
+require_relative "space_architect/agent_installer"
 require_relative "space_architect/bug_report"
 require_relative "space_architect/research"
 require_relative "space_architect/cli"