space-architect 9.6.0 → 9.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d95b9e18cb5c8dbaf32c57ad55915e12b387ee5a68eb5cea89e52c0ab3a2542
-  data.tar.gz: d95ef73a8929c852f58c8712f7dfce3bd14eab18e06c0e518f8bdd6c55625588
+  metadata.gz: 2a29d0c5688ed96e02a49a159385f508a845714e1741577384f6a6369a1fbb7e
+  data.tar.gz: 2b46a7ffee6ee544c9f5e30b7926f4ee5d541d81032be53617cec19f5e519bfd
 SHA512:
-  metadata.gz: 1e36ea6062b43c49d1ebcf69fac6205af9e7f24cb5e51bff1d2ae70db518ef07facafa41d17e8bb7de2736d8748b84ab97d42a7ce70513046b7b089c4ff1d2cc
-  data.tar.gz: 659816b4ea7286f5a24fb8ff16d0e0eb2783258051ceddeab53f00ba8e2e3ea9adfbcd1150132d751a5fd4f0531070689796a3c01135f2e49c04faa5c7c51224
+  metadata.gz: d418323e0ef3c26cfdf2ca7d06aac9fcec9da1d74c8ccbb0a339cc5f0e85eaf9838ab5bf380f7949f28d30a416e7d5b2a0c9043e1fe74d3659ffbfaf5d764641
+  data.tar.gz: 6fdbc0e2e89a34ff61f661202fb04e0f452a5f2b096db28b2dfd0a3adf41e6b9194a82b62253e2e1d4e9647886244d0ff0e38339d898726b93d8bcebc207800f

data/CHANGELOG.md

@@ -5,6 +5,46 @@ 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
+
+- **Structured-record emission (I16)** — the loop commands now mirror the
+  iteration record to a space-server as structured data: `architect
+  freeze`/`verdict`/`integrate` and lane completion POST to the four ingest
+  mouths (`/iterations/ingest/{freeze,lane,verdict,integration}`). Payloads
+  derive from the canonical sources (the iteration file, space.yaml lane
+  records, gate sidecars); the verdict detail rides a new fenced ` ```rulings `
+  YAML block (ac_rulings + phase0_resolutions) in the `## Verdict` body.
+  Config: `~/.config/space-architect/emission.yaml` (host/token/disabled),
+  session-sink semantics — unconfigured is fully inert, ENV overrides per
+  field (`SPACE_ARCHITECT_EMISSION_HOST/_TOKEN/_DISABLED`), best-effort
+  POSTs that never raise into or block a loop command. `architect emit`
+  replays the emission byte-stable.
+
 ## [9.6.0] - 2026-10-17
 
 ### Changed

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

@@ -2,6 +2,7 @@
 
 require "yaml"
 require "erb"
+require "json"
 require "open3"
 require "fileutils"
 require "pathname"
@@ -92,8 +93,23 @@ module Space::Architect
       }
     JSON
 
-    def initialize(space:)
+    def initialize(space:, emitter: nil)
       @space = space
+      # I16: the emission sink — an injected emitter (tests) always wins;
+      # the default resolves the emission config lazily, once per instance,
+      # and memoizes. nil resolution = unconfigured = every call site no-ops.
+      @injected_emitter = emitter unless emitter.nil?
+    end
+
+    # The resolved emitter for this space, or nil when unconfigured (no file,
+    # missing host/token, or disabled — Space::Architect::IterationEmission).
+    # Memoized on the first call-site resolution so machine state cannot
+    # differ between the five hooks of one command invocation.
+    def emitter
+      return @injected_emitter if instance_variable_defined?(:@injected_emitter)
+      return @resolved_emitter if instance_variable_defined?(:@resolved_emitter)
+
+      @resolved_emitter = IterationEmission.emitter_for(space)
     end
 
     def init!(message: nil)
@@ -261,6 +277,17 @@ module Space::Architect
       git_run("-C", space.path.to_s, "commit", "-m",
         compose_message("I#{nn} freeze:", "I#{nn}: record freeze sha", message), "--", Space::Core::Space::METADATA_FILE)
 
+      # I16 emission — mouth 1 (freeze): identity + the frozen gates, derived
+      # from the just-committed text. The already-frozen early return above
+      # emits nothing. Best-effort: unconfigured no-ops, failures never block.
+      safe_emit("freeze #{iteration}") do
+        em = emitter
+        next unless em
+        em.post("freeze", IterationEmission.build_freeze(
+          ordinal: entry["ordinal"], name: entry["name"], freeze_sha: sha,
+          branch: head_branch, gates: parse_gates(text)))
+      end
+
       sha
     end
 
@@ -352,6 +379,18 @@ module Space::Architect
         compose_message("I#{nn} verdict:", "I#{nn}: verdict", message), "--", rel, Space::Core::Space::METADATA_FILE)
 
       head, = git_capture("-C", space.path.to_s, "rev-parse", "HEAD")
+
+      # I16 emission — mouth 3 (verdict): the decision plus ac_rulings /
+      # phase0_resolutions parsed from the body's ```rulings block when one is
+      # present. The body lands in the markdown verbatim either way.
+      safe_emit("verdict #{iteration}") do
+        em = emitter
+        next unless em
+        em.post("verdict", IterationEmission.build_verdict(
+          ordinal: entry["ordinal"], name: entry["name"], decision: decision,
+          rulings: IterationEmission.parse_rulings(body)))
+      end
+
       { decision: decision, sha: head.strip }
     end
 
@@ -387,6 +426,12 @@ module Space::Architect
         compose_message("I#{nn} evidence:", "I#{nn}: evidence", message), "--", rel)
       head, = git_capture("-C", space.path.to_s, "rev-parse", "HEAD")
 
+      # I16 emission — mouth 2 (lane): the lane's disposition scalars from the
+      # space.yaml record, status "complete". With lane nil, only when the
+      # entry records exactly ONE lane (the single-lane iteration shorthand);
+      # a multi-lane unlabeled run has no single owner — skip.
+      emit_lane_complete!(iteration, entry, lane)
+
       status_line = raw.lines.reverse_each.find { |l| l.strip.start_with?("STATUS:") }&.strip
       { sha: head.strip, lines: raw.lines.count, status_line: status_line, lane: lane }
     end
@@ -408,6 +453,149 @@ module Space::Architect
       section_body(text, "## Acceptance Criteria")
     end
 
+    # I16 S4 — `architect emit`: re-derive the emission payloads for one facet
+    # from the canonical sources (space.yaml, the frozen iteration file via
+    # `git show`, the gate sidecars) through the EXACT builders the live hook
+    # call sites use, so a re-send replays the same bytes. Returns the array
+    # of payloads for the facet — empty for "nothing to emit". Deliberately
+    # single-iteration: no bulk backfill surface, no enumeration of
+    # historical I*.md files.
+    def emission_replays(iteration, facet:, lane: nil)
+      entry = slice_entry(iteration)
+      case facet
+      when "freeze"      then freeze_replay(entry)
+      when "lane"        then lane_replays(entry, lane)
+      when "verdict"     then verdict_replay(entry)
+      when "integration" then integration_replay(entry)
+      else raise Space::Core::Error, "unknown facet '#{facet}' — one of: freeze, lane, verdict, integration"
+      end
+    end
+
+    # freeze facet: gates re-parsed from the frozen file's byte state (same
+    # parse_gates path as the live freeze), branch re-read live — identical
+    # whenever the space repo's HEAD branch hasn't changed since the freeze.
+    def freeze_replay(entry)
+      sha = entry["freeze_sha"]
+      return [] unless sha
+
+      text, _, st = git_capture("-C", space.path.to_s, "show", "#{sha}:#{entry['file']}")
+      raise Space::Core::Error, "could not read #{entry['file']} at freeze #{sha[0, 8]}" unless st.success?
+
+      [IterationEmission.build_freeze(
+        ordinal: entry["ordinal"], name: entry["name"], freeze_sha: sha,
+        branch: head_branch, gates: parse_gates(text))]
+    end
+
+    # lane facet: the space.yaml lane records (or --lane NAME). When the lane
+    # has a gate sidecar, replay the gate-results shape (scalars minus status
+    # + gate_results re-attached from the sidecar, transcript from the sibling
+    # .md) — the live gate-time payload; otherwise the completion shape
+    # (status "complete") — the live evidence-time payload.
+    def lane_replays(entry, lane)
+      lanes = entry["lanes"] || []
+      if lane
+        lanes = lanes.select { |l| l["name"] == lane }
+        raise Space::Core::Error, "No lane '#{lane}' recorded for iteration '#{entry['name']}'" if lanes.empty?
+      end
+
+      lanes.map do |record|
+        sidecar = newest_lane_sidecar(record["name"])
+        if sidecar
+          IterationEmission.build_lane(ordinal: entry["ordinal"], name: entry["name"],
+            lane_record: record, gate_results: lane_sidecar_results(sidecar))
+        else
+          IterationEmission.build_lane(ordinal: entry["ordinal"], name: entry["name"],
+            lane_record: record, status: "complete")
+        end
+      end
+    end
+
+    # verdict facet: the entry's recorded decision + the current iteration
+    # file's Verdict section ```rulings block (the section the live verdict
+    # command wrote — post-freeze, so it is read from the working tree).
+    def verdict_replay(entry)
+      decision = entry["verdict"]
+      return [] if decision.nil? || decision == "pending"
+
+      path = space.path.join(entry["file"])
+      raise Space::Core::Error, "#{entry['file']} does not exist" unless path.exist?
+
+      [IterationEmission.build_verdict(ordinal: entry["ordinal"], name: entry["name"],
+        decision: decision,
+        rulings: IterationEmission.parse_rulings(section_body(path.read, "## Verdict").to_s))]
+    end
+
+    # integration facet: the lanes' recorded integrate_sha/integration_branch
+    # plus the project integration branch. "nothing to emit" ([]) when no lane
+    # has merge data.
+    def integration_replay(entry)
+      lanes = (entry["lanes"] || []).select { |l| l["integrate_sha"] }
+      return [] if lanes.empty?
+
+      branch = lanes.filter_map { |l| l["integration_branch"] }.first || project_integration_branch
+      merge_commits = lane_merge_commits(lanes, branch)
+      [IterationEmission.build_integration(
+        ordinal: entry["ordinal"], name: entry["name"], branch: branch,
+        lanes: lanes.map { |l|
+          { name: l["name"], merge_sha: merge_commits[l["name"]] || l["integrate_sha"],
+            integration_branch: l["integration_branch"] }
+        })]
+    end
+
+    # The live integration emission carries each lane's repo MERGE commit (the
+    # tip after its --no-ff merge); space.yaml records the lane WORKTREE commit
+    # (integrate_sha). The merge commit is derivable from the canonical repo
+    # history — each merge's second parent is exactly the lane branch tip — so
+    # the re-send replays the same merge_sha the live path posted. When the
+    # branch history no longer holds the merge (rewritten/deleted), the
+    # recorded integrate_sha is the only remaining truth and is used as-is.
+    def lane_merge_commits(lanes, branch)
+      lanes.group_by { |l| l["repo"] }.flat_map do |repo, group|
+        next [] unless repo
+        out, _, st = git_capture("-C", space.path.join("repos", repo).to_s,
+          "rev-list", "--merges", "--parents", branch)
+        next [] unless st.success?
+        group.filter_map do |l|
+          next unless l["integrate_sha"]
+          commit = out.strip.split("\n")
+                       .find { |line| line.split.drop(1).include?(l["integrate_sha"]) }
+                       &.split
+                       &.first
+          commit ? [l["name"], commit] : nil
+        end
+      end.to_h
+    end
+
+    # The newest lane gate sidecar in build/gate/ whose sibling .md transcript
+    # names the lane: sidecar files are keyed to their .md by basename, and
+    # the .md's "Lane: <name> (…}" header line is the only recorded lane
+    # association. Filenames embed a monotonic timestamp — reverse sort is
+    # newest-first.
+    def newest_lane_sidecar(lane_name)
+      dir = space.path.join("build", "gate")
+      return nil unless dir.exist?
+
+      # paths:exempt - the .extname == ".json" filter structurally cannot match a dotfile-prefixed name (".json" has no extname), so raw enumeration of the build/gate scratch dir is already dotfile-safe here
+      candidates = dir.children.select { |f| f.extname == ".json" }.sort_by(&:to_s).reverse
+      candidates.find do |sidecar|
+        md = sidecar.sub_ext(".md")
+        md.exist? && File.foreach(md).any? { |line| line.start_with?("Lane: #{lane_name} (") }
+      end
+    end
+
+    # Re-attach gate_results from a sidecar: same entry shape the live
+    # gate-time lane emission built (reason omitted when empty — the server
+    # stores NULL for ""), transcript from the sibling .md.
+    def lane_sidecar_results(sidecar)
+      transcript = sidecar.sub_ext(".md").read
+      JSON.parse(sidecar.read).map do |r|
+        IterationEmission.map_gate_result(
+          { gate_id: r["gate_id"], status: r["status"], reason: r["reason"] },
+          transcript)
+      end
+    end
+
+
     # Integrate ONE architect-judged-passing lane: commit the builder's working tree on
     # the lane branch, then merge --no-ff into the repo's lane/<id> integration branch.
     # Runs NO gates and makes NO pass/fail decision. Refuses a mechanically-failing lane
@@ -534,6 +722,14 @@ module Space::Architect
         raise Space::Core::Error, "Integrated #{done.empty? ? "(none)" : done} then stopped at '#{lane}': #{e.message}"
       end
 
+      # I16 emission — mouth 4 (integration): one integration POST, then a
+      # per-merged-lane lane-mouth scalar re-emission re-sliced from space.yaml
+      # AFTER the merge mutations (a bounds override accepted at integrate
+      # time must land in the record). Teardown-only calls never reach this —
+      # they early-return above. Emission happens before teardown so a
+      # teardown failure can never cost an already-merged lane its record.
+      emit_integration!(iteration, merged)
+
       teardown_lanes!(iteration, merged, force: force) if teardown
       merged
     ensure
@@ -575,7 +771,9 @@ module Space::Architect
     # #run_gates, the only intended caller shape. Returns the path.
     def gate_transcript(iteration, gate_results, lane: nil, now: Time.now)
       entry, base_dir, repo = resolve_gate_run(iteration, lane)
-      write_transcript(:gate, entry, repo, base_dir, lane, gate_results, nil, now)
+      path = write_transcript(:gate, entry, repo, base_dir, lane, gate_results, nil, now)
+      emit_lane_gate_results!(entry, lane, path, gate_results) if lane
+      path
     end
 
     # Rehearse the DRAFTED gates in the WORKING-TREE iteration file — before the
@@ -709,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)"
@@ -1074,6 +1272,103 @@ module Space::Architect
       body.empty? ? composed : "#{composed}\n\n#{body}"
     end
 
+    # The emission belt: a payload-build or call-site bug must never change a
+    # loop command's exit code, stdout, or commit behavior — exactly one
+    # stderr line, then the command carries on. (Emitter#post itself never
+    # raises; this belt guards the payload construction around it.)
+    def safe_emit(context)
+      yield
+    rescue Exception => e # belt, by contract — even a NoMemoryError must not kill the loop
+      $stderr.puts "emission skipped (#{context}): #{e.class}: #{e.message.to_s[0, 200]}"
+    end
+
+    # I16 emission — mouth 2 (lane): the lane's disposition scalars from the
+    # space.yaml record, status "complete". With lane nil, only when the
+    # entry records exactly ONE lane (the single-lane iteration shorthand);
+    # a multi-lane unlabeled run has no single owner — skip.
+    def emit_lane_complete!(iteration, entry, lane)
+      lane_name = lane
+      unless lane_name
+        lanes = entry["lanes"] || []
+        lane_name = lanes.first["name"] if lanes.one?
+      end
+      return unless lane_name
+
+      safe_emit("lane complete #{lane_name}") do
+        em = emitter
+        next unless em
+        record = (slice_entry(iteration)["lanes"] || []).find { |l| l["name"] == lane_name }
+        next unless record
+        em.post("lane", IterationEmission.build_lane(
+          ordinal: entry["ordinal"], name: entry["name"], lane_record: record, status: "complete"))
+      end
+    end
+
+    # I16: the structured sidecar — a JSON mirror of the executed gates
+    # (gate_id/status/reason/stdout/stderr/exit_code/cmd/dir) written beside
+    # the transcript .md (same basename; additive — the .md stays
+    # byte-unchanged). Lane runs only: unlabeled gate runs emit nothing, and
+    # `architect emit` re-attaches gate_results from the newest sidecar whose
+    # sibling .md names the lane.
+    def write_gate_sidecar(transcript_path, gate_results)
+      safe_emit("gate sidecar #{transcript_path.basename}") do
+        sidecar = transcript_path.sub_ext(".json")
+        sidecar.write(JSON.generate(gate_results.map { |g| IterationEmission.map_sidecar_gate(g) }))
+      end
+    end
+
+    # I16 emission — mouth 2 (lane), gate-results shape: the same scalars as
+    # the completion shape MINUS status, plus one gate_results entry per gate
+    # ({gate_id, status exactly "pass"/"fail", reason omitted when empty,
+    # transcript = the .md content just written}). Only called for lane runs.
+    def emit_lane_gate_results!(entry, lane, transcript_path, gate_results)
+      write_gate_sidecar(transcript_path, gate_results)
+      safe_emit("lane gate results #{lane}") do
+        em = emitter
+        next unless em
+        record = (entry["lanes"] || []).find { |l| l["name"] == lane }
+        next unless record
+        transcript = transcript_path.read
+        em.post("lane", IterationEmission.build_lane(
+          ordinal: entry["ordinal"], name: entry["name"], lane_record: record,
+          gate_results: gate_results.map { |g|
+            IterationEmission.map_gate_result({ gate_id: g[:id], status: g[:status], reason: g[:reason] }, transcript)
+          }))
+      end
+    end
+
+    # I16 emission — mouth 4 (integration): one integration POST, then a
+    # per-merged-lane lane-mouth scalar re-emission re-sliced from space.yaml
+    # AFTER the merge mutations (a bounds override accepted at integrate time
+    # must land in the record). Emission happens before teardown so a teardown
+    # failure can never cost an already-merged lane its record.
+    def emit_integration!(iteration, merged)
+      safe_emit("integration #{iteration}") do
+        em = emitter
+        next unless em
+        fresh = slice_entry(iteration)
+        em.post("integration", IterationEmission.build_integration(
+          ordinal: fresh["ordinal"], name: fresh["name"],
+          branch: merged.first[:integration_branch],
+          lanes: merged.map { |m|
+            { name: m[:lane], merge_sha: m[:merge_sha], integration_branch: m[:integration_branch] }
+          }))
+        (fresh["lanes"] || []).each do |l|
+          next unless merged.any? { |m| m[:lane] == l["name"] }
+          em.post("lane", IterationEmission.build_lane(
+            ordinal: fresh["ordinal"], name: fresh["name"], lane_record: l, status: "integrated"))
+        end
+      end
+    end
+
+    # The space repo's HEAD branch, nil when detached (git abbrev-ref prints
+    # "HEAD" there; a real branch of that name is not a thing git creates).
+    def head_branch
+      out, = git_capture("-C", space.path.to_s, "rev-parse", "--abbrev-ref", "HEAD")
+      branch = out.strip
+      branch unless branch == "HEAD"
+    end
+
     # integrate!'s own space.yaml commit, by pathspec — like record_verdict!'s sweep, so
     # other uncommitted work in the space isn't pulled in. A call that mutated nothing
     # (teardown-only over lanes with no worktree, or a call that raised before touching
@@ -1697,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]
@@ -1742,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 =
@@ -1755,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)'}"
@@ -847,6 +850,60 @@ module Space::Architect
         end
       end
 
+      # I16: re-send the structured iteration emissions for ONE iteration —
+      # payloads re-derived from the canonical sources through the exact
+      # builders the live hook call sites use, so a replay is byte-identical
+      # to what the loop sent. Deliberately single-iteration: no bulk
+      # backfill surface, no enumeration of historical I*.md files.
+      class Emit < BaseCommand
+        desc "Re-send the structured emissions for one iteration (freeze/lane/verdict/integration; idempotent replay)"
+        phase 53, "Project"
+        argument :iteration, required: true,  desc: "Iteration name"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        option :facet, default: "all", desc: "Which facet to emit: freeze, lane, verdict, integration, or all (default)"
+        option :lane,  default: nil,   desc: "Lane name filter (lane facet only; default: all recorded lanes)"
+
+        FACETS = %w[freeze lane verdict integration].freeze
+
+        def call(iteration:, space: nil, facet: "all", lane: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            requested = facet == "all" ? FACETS : FACETS & [facet]
+            if requested.empty?
+              raise Space::Core::Error,
+                "unknown facet '#{facet}' — one of: #{(FACETS + ["all"]).join(', ')}"
+            end
+
+            render(store.find(space)) do |sp|
+              project = ArchitectProject.new(space: sp)
+              emitter = IterationEmission.emitter_for(sp)
+              failed = false
+              requested.each do |f|
+                payloads = project.emission_replays(iteration, facet: f, lane: lane)
+                if payloads.empty?
+                  terminal.say "nothing to emit (#{f})"
+                  next
+                end
+                payloads.each do |payload|
+                  unless emitter
+                    terminal.say "emission off (unconfigured)"
+                    next
+                  end
+                  res = emitter.post(f, payload)
+                  if res
+                    terminal.say "emitted #{f} → #{res[:status]}"
+                  else
+                    failed = true
+                    terminal.say "emission failed (#{f}) — see stderr"
+                  end
+                end
+              end
+              CLI.record_outcome(Outcome.new(exit_code: failed ? 1 : 0))
+            end
+          end
+        end
+      end
+
       # Pretty-print a pi agent run.jsonl as it streams — the ported runlog
       # printer. No space resolution: the stream is the whole input.
       class Runlog < BaseCommand
@@ -1108,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"
@@ -1440,6 +1497,7 @@ Space::Architect::CLI::Registry.register "install-extensions", Space::Architect:
 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 "emit",           Space::Architect::CLI::Architect::Emit
 Space::Architect::CLI::Registry.register "bug-report",     Space::Architect::CLI::Architect::BugReport
 Space::Architect::CLI::Registry.register "cost",           Space::Architect::CLI::Architect::Cost
 Space::Architect::CLI::Registry.register "brief" do |b|