space-architect 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62235ba54045a8883eaaaced2fef7c231d45ad6cb363dda9256ec65692b6023b
-  data.tar.gz: 7d90b91f3a247c20cc273c332807c65c8e500dc62bffaec1a35076263eb969a2
+  metadata.gz: db24aa20a68fdf981176f7e51a46794a4fc2ec5cef9765c33de5832f0a314a9e
+  data.tar.gz: 8912085239c76c1228e01d8986d789ba0fde42b4517459830c1f08cdb6e0fcfc
 SHA512:
-  metadata.gz: 042c966a4dbf2075abaeaffb23ad9e426a4421ffcd9621ff238d2f074771e5d65bc7030775fe1733dde40030dc0aff37b84c35e13a035ac29705e3e42667c96e
-  data.tar.gz: f633823970cefde990131c1cce4a415bd8f767030120438ae7bd76220653ab0c42580352de48ab2c34b82f5fd4cc597c6ba14410603e66de6a3dd86f89e197ee
+  metadata.gz: 06a4e3382403542421679272136d6c1f6a99ac5dece354b5175f5d895b1afb9cce902f9e11ea2cf64c940dd4a00f11d3dfa7390a0941f387ae4a28f47cdbc3fb
+  data.tar.gz: 73c71c080f640540c4cfb57f347f12eae5a2486c45a373a525c44dc35ea54edf7b43ee415d979352f6569406f0f261e8d4a601af869eae5bd9f9055df02d9807

data/README.md

@@ -69,6 +69,7 @@ architect space status done                      # mark the current mission comp
 **Architect Loop (run from inside a space):**
 
 ```sh
+architect install-skills                          # install skills for your harness (once per machine)
 architect init                                   # scaffold ARCHITECT.md + architecture/
 architect new <iteration>                        # scaffold next iteration file
 architect dispatch <iteration> <lane>            # dispatch a builder for a lane
@@ -77,6 +78,14 @@ architect freeze <iteration>                     # freeze Acceptance Criteria
 architect verify <iteration>                     # post-flight mechanical checks
 ```
 
+`architect install-skills` installs the bundled `architect`, `architect-research`,
+and `architect-vocabulary` skills for a harness. (`architect-vocabulary` loads the
+system's terms and a short orientation when you're in a space but don't want to run
+the loop — see [The Architect Loop](#the-architect-loop-).) Default is `claude`
+(`~/.claude/skills/`); use `--provider
+opencode|codex|pi` for other harnesses, and `--project` to install into the current
+directory instead of globally. See the [command reference](docs/reference.md) for details.
+
 ## Usage 🛰️
 
 ```sh

data/lib/space_architect/cli/architect.rb

@@ -348,6 +348,31 @@ module SpaceArchitect
         end
       end
 
+      class InstallSkills < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Install bundled skills (architect, architect-research, architect-vocabulary) for a harness"
+        option :provider, default: "claude", desc: "Harness: claude, codex, opencode, pi"
+        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)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            result = SkillInstaller.install(provider, project: project, force: force,
+                                             env: project_config.env, dry_run: dry_run)
+            verb = dry_run ? "Would install" : "Installed"
+            terminal.say "#{verb} skills for #{provider} → #{terminal.path(result[:dest_root])}"
+            result[:skills].each do |s|
+              terminal.say "  #{s[:name]}: #{terminal.style_skill_action(s[:action])} (#{terminal.path(s[:path])})"
+            end
+            CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+        end
+      end
+
       module Brief
         class New < Dry::CLI::Command
           include GlobalOptions
@@ -559,6 +584,7 @@ SpaceArchitect::CLI::Registry.register "evidence",  SpaceArchitect::CLI::Archite
 SpaceArchitect::CLI::Registry.register "merge",     SpaceArchitect::CLI::Architect::Merge
 SpaceArchitect::CLI::Registry.register "integrate", SpaceArchitect::CLI::Architect::Integrate
 SpaceArchitect::CLI::Registry.register "gate",      SpaceArchitect::CLI::Architect::Gate
+SpaceArchitect::CLI::Registry.register "install-skills", SpaceArchitect::CLI::Architect::InstallSkills
 SpaceArchitect::CLI::Registry.register "brief" do |b|
   b.register "new", SpaceArchitect::CLI::Architect::Brief::New
 end

data/lib/space_architect/skill_installer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module SpaceArchitect
+  module SkillInstaller
+    PROVIDERS = %w[claude codex opencode pi].freeze
+
+    class << self
+      def source_root
+        Pathname.new(__dir__).parent.parent.join("skill")
+      end
+
+      def dest_root(provider, project:, env:, cwd: Dir.pwd)
+        case provider.to_s
+        when "claude"
+          base = project ? Pathname.new(cwd) : Pathname.new(XDG.home(env: env))
+          base.join(".claude", "skills")
+        when "codex"
+          base = project ? Pathname.new(cwd) : Pathname.new(XDG.home(env: env))
+          base.join(".agents", "skills")
+        when "opencode"
+          project ? Pathname.new(cwd).join(".opencode", "skills") : XDG.config_home(env: env).join("skills")
+        when "pi"
+          base = project ? Pathname.new(cwd) : Pathname.new(pi_agent_dir(env: env))
+          base.join("skills")
+        else
+          raise Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
+        end
+      end
+
+      def install(provider, project:, force:, env:, cwd: Dir.pwd, dry_run: false)
+        validate_provider!(provider)
+        dest = dest_root(provider, project: project, env: env, cwd: cwd)
+        results = []
+
+        source_skills.each do |skill_dir|
+          name = skill_dir.basename.to_s
+          skill_dest = dest.join(name)
+          results << install_skill(skill_dir, skill_dest, force: force, dry_run: dry_run)
+        end
+
+        { dest_root: dest, skills: results, dry_run: dry_run }
+      end
+
+      def source_skills
+        source_root.children.select(&:directory?)
+      end
+
+      private
+
+      def validate_provider!(provider)
+        return if PROVIDERS.include?(provider.to_s)
+
+        raise Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
+      end
+
+      def pi_agent_dir(env:)
+        Pathname.new(env.fetch("PI_CODING_AGENT_DIR", File.join(XDG.home(env: env), ".pi", "agent")))
+      end
+
+      def install_skill(source, dest, force:, dry_run:)
+        name = source.basename.to_s
+
+        if dest.exist?
+          if same_content?(source, dest)
+            return { name: name, action: :unchanged, path: dest }
+          end
+
+          unless force
+            return { name: name, action: :conflict, path: dest } if dry_run
+
+            raise Error,
+              "Refusing to overwrite existing skill at #{dest}. Re-run with --force."
+          end
+
+          unless dry_run
+            FileUtils.rm_rf(dest)
+            FileUtils.cp_r(source, dest)
+          end
+          { name: name, action: dry_run ? :would_update : :updated, path: dest }
+        else
+          unless dry_run
+            FileUtils.mkdir_p(dest.parent)
+            FileUtils.cp_r(source, dest)
+          end
+          { name: name, action: dry_run ? :would_install : :installed, path: dest }
+        end
+      end
+
+      def same_content?(source, dest)
+        return false unless dest.directory?
+
+        source_files = Dir.glob("#{source}/**/*").reject { |f| File.directory?(f) }
+        dest_files = Dir.glob("#{dest}/**/*").reject { |f| File.directory?(f) }
+
+        return false if source_files.length != dest_files.length
+
+        source_files.sort.zip(dest_files.sort).all? do |sf, df|
+          rel = sf.sub("#{source}/", "")
+          df.end_with?(rel) && File.read(sf) == File.read(df)
+        end
+      end
+    end
+  end
+end

data/lib/space_architect/terminal.rb

@@ -74,6 +74,21 @@ module SpaceArchitect
       end.wait
     end
 
+    def style_skill_action(action)
+      case action.to_s
+      when "installed", "updated"
+        pastel.green(action)
+      when "would_install", "would_update"
+        pastel.cyan(action)
+      when "unchanged"
+        pastel.bright_black(action)
+      when "conflict"
+        pastel.yellow(action)
+      else
+        action.to_s
+      end
+    end
+
     private
 
     def color_mode

data/lib/space_architect/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SpaceArchitect
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/space_architect.rb

@@ -19,6 +19,7 @@ require_relative "space_architect/git_client"
 require_relative "space_architect/mise_client"
 require_relative "space_architect/space_store"
 require_relative "space_architect/shell_integration"
+require_relative "space_architect/skill_installer"
 require_relative "space_architect/terminal"
 require_relative "space_architect/harness"
 require_relative "space_architect/dispatcher"

data/skill/architect/SKILL.md

@@ -0,0 +1,329 @@
+---
+name: architect
+description: >
+  Run the Architect Loop: Opus 4.8 in Claude Code is the ARCHITECT — judgment
+  only: arbitration, judging raw evidence against frozen Acceptance Criteria,
+  splitting iterations into disjoint lanes, kill/continue calls. The BUILDERS
+  are 1-4 parallel Sonnet 4.6 agents run headless via `claude -p`, each in its
+  own git worktree; the architect reviews, merges, and integrates their work.
+  The space is the memory: one file per iteration at
+  architecture/I<NN>-<name>.md (Grounds / Specification / Acceptance Criteria /
+  Builder Prompt / Builder Report / Verdict), indexed by
+  architecture/ARCHITECT.md; a mission spans the repos under repos/. Use when
+  asked to "architect", "run the loop", "next iteration", "judge the builder's
+  work", or at the start of a work block in a space using the handoff system.
+---
+
+# Architect
+
+You are the ARCHITECT (Opus 4.8 in Claude Code). Sonnet 4.6 via headless
+`claude -p` is the BUILDER — the same harness, one tier down. The space is the
+memory — mission artifacts live in the space's `architecture/` dir (committed),
+scratch in `build/` (gitignored); the mission spans the repos under `repos/`.
+Your output is judgment and a dispatch — never implementation code. When you
+have enough information to act, act.
+
+Each iteration is **one self-contained file**,
+`architecture/I<NN>-<name>.md` (`<NN>` = zero-padded ordinality), grown section
+by section. The `architect` CLI writes and commits each section for you with the
+canonical message — the commits give the differentiation and git gives the
+change guarantees, so there are no separate `gates/`, `lanes/`, or `prd/` dirs:
+
+| Section | Holds | How you persist it |
+|---|---|---|
+| **Grounds** | why — research/brief distilled (optional) | `architect section <it> grounds --from <f>` |
+| **Specification** | what/how — the full delegation contract | `architect section <it> specification --from <f>` |
+| **Acceptance Criteria** | proof — exact gate commands + thresholds | `architect freeze <it>` ❄️ **= the freeze** |
+| **Builder Prompt** | the exact lane-prompt(s) dispatched | `architect section <it> prompt --append --lane <l> --from <f>` |
+| **Builder Report** | raw evidence, transcribed verbatim from scratch | `architect evidence <it> --lane <l>` |
+| **Verdict** | rulings + per-AC PASS/FAIL/INVALID + KILL/CONTINUE | `architect section <it> verdict --from <f>` (later session) |
+
+Each command writes the section, commits it with the canonical `I<NN>: …`
+message, and prints back what changed (SHA + diff stat; `freeze` prints the
+frozen AC; `evidence` echoes the builder's STATUS line) — so you don't hand-edit
+the file or run a separate `git add`/`commit`, and you don't run three follow-ups
+to see what happened. You still author the *content*; the CLI owns the
+*persistence*.
+
+The builder **never** writes this file — the Acceptance Criteria must stay out
+of its editable blast radius. Each lane builder writes raw evidence to a scratch
+report in `build/<id>-<lane>/report.md`; `architect evidence` transcribes it
+**verbatim** into Builder Report. Frozen sections
+(Grounds/Specification/Acceptance Criteria) are read-only after the freeze
+commit — `architect section` refuses to write a frozen section once frozen; only
+Builder Prompt, Builder Report, and Verdict are appended after.
+
+**The mission brief (`architecture/BRIEF.md`).** A mission with a durable spec
+carries one brief — numbered §sections (§1 goal, §2 constraints, … §N definition
+of done) that span iterations. Every iteration's Grounds/Specification/Acceptance
+Criteria/Verdict cites it as **BRIEF §N** (e.g. `(BRIEF §3.1)`), the way each gate
+addresses its intent back to one frozen reference: the Acceptance Criteria table
+carries a `Brief §` column, the Specification Objective cites it, the Verdict
+reads "diff vs BRIEF §1/§3.3 — CONTINUE". Scaffold it with `architect brief new`.
+The brief is frozen at the mission level — edits to a §section are logged
+decisions in `ARCHITECT.md`, never silent per-iteration drift. Discovery missions
+that are still finding their shape defer the brief, cite per-iteration Grounds,
+and promote the consolidated picture into BRIEF.md once it stabilizes.
+
+Full rationale and citations: `DESIGN.md` in this skill's repo. Exact dispatch
+commands and the lane-prompt template: `dispatch.md` next to this file. To load
+this system's vocabulary without running the loop (e.g. when working *on* the
+skill), invoke the `/architect-vocabulary` skill — it is the glossary, not the
+loop.
+
+## Hard rules
+
+1. **Never write implementation code.** Anything that must change goes in the
+   iteration Specification.
+2. **Not in the space's committed architecture = didn't happen.** Refuse to
+   judge results that exist only in conversation or builder chat output.
+3. **The Acceptance Criteria freeze before results exist** — written as the
+   iteration file's Acceptance Criteria section and committed (the freeze commit)
+   *before* dispatch. Quote them verbatim when judging, reading from the freeze
+   commit (`git show <freeze-sha>:architecture/I<NN>-<name>.md`); never restate
+   from memory; never edit after results. Any change to
+   Grounds/Specification/Acceptance Criteria lines since the freeze (caught by
+   `git diff <freeze-sha> HEAD`) is an automatic iteration FAIL — only Builder
+   Prompt/Report/Verdict may be appended afterward.
+4. **Nobody grades their own work.** The builder reports raw evidence only (to
+   scratch); you transcribe it, run the gates yourself, and read the output —
+   builder claims are hearsay. You never judge a run in the same session that
+   dispatched it.
+5. **Disagreement is mandatory.** Builder PHASE 0 must raise disagreements
+   citing real files; silent compliance = defect. You rule on every one in the
+   Verdict: ACCEPT / REJECT / MODIFY + one line why. Flag the human's scope
+   creep and goalpost-moving bluntly too.
+6. **Audit every status claim** — yours and the builder's — against a tool
+   result from the session before reporting it.
+7. **Fresh builder context per lane, worktree isolation between lanes.**
+   `claude -p --continue` (from the lane's worktree) only for follow-ups within
+   the current lane. Builders never commit — Claude Code has no sandbox to
+   enforce that, so verify it yourself post-flight (`git -C <worktree> log
+   <repo-base>..` must be empty). If a run leaves a worktree broken or
+   committed, discard that lane + re-dispatch over rescue prompting — lanes are
+   cheap by construction.
+8. **Stop conditions:** failing verification you can't root-cause, instructions
+   conflicting with project docs, irreversible/destructive calls, or scope
+   growth beyond the iteration → checkpoint to the handoff and ask the human.
+
+## Procedure
+
+### 0. Ground (every session — never skip because the task "looks small")
+
+- Read the project's operating docs in authority order: `CLAUDE.md` /
+  `AGENTS.md` → `README.md` → architecture docs. Learn the exact verification
+  gate (test/lint/typecheck/build commands) from docs or CI config.
+- Once per environment: `claude --version` and confirm the builder model
+  resolves (`echo ok | claude -p --model claude-sonnet-4-6 --max-turns 1`;
+  details in `dispatch.md`). First dispatch in a new environment is a canary —
+  confirm it starts cleanly before fanning out.
+- Read `architecture/ARCHITECT.md` (the cross-iteration table of contents),
+  `architecture/BRIEF.md` if present (the durable §-numbered mission contract you
+  cite as BRIEF §N), and the iteration file `architecture/I<NN>-<name>.md` for any
+  in-flight iteration. If `ARCHITECT.md` is missing, run `architect init` (scaffolds
+  `architecture/ARCHITECT.md` and the `architect:` block in `space.yaml`,
+  commits). Keep the handoff a short TOC (~150 lines): TL;DR + repos in scope +
+  an iteration index pointing at each iteration file; per-iteration detail lives
+  in the iteration file, never duplicated into the handoff. `architect status`
+  prints mission state (iterations, freeze_shas, lanes, verdicts) at any point.
+- **Space setup (first time):** `architect space new "Mission Name" org/repo …`
+  (repos are variadic positionals after the title), then `architect init` inside
+  the space to scaffold `architecture/ARCHITECT.md`.
+- Scale to the task: trivial fixes don't need the loop — say so and let the
+  human do it inline or in a normal session. The loop is for iteration-sized
+  work.
+
+### 1. Arbitrate
+
+Every open disagreement from the last iteration's Builder Report gets
+**ACCEPT / REJECT / MODIFY + one line why**, written into that iteration's
+Verdict. No deferrals.
+
+### 2. Judge
+
+Read the frozen Acceptance Criteria from the freeze commit (`architect freeze`
+re-prints them, or `git show <freeze-sha>:architecture/I<NN>-<name>.md`). For each
+gate: run the gate command yourself — `architect gate <iteration>` runs the
+frozen gate commands in the resolved repo/worktree and streams raw output (it is a
+runner, never a judge), or run them by hand — then compare the output against the
+verbatim frozen text → **PASS / FAIL / INVALID** (INVALID = not measured the way
+the gate specifies). Check `git diff <freeze-sha> HEAD --
+architecture/I<NN>-<name>.md` — any change to Grounds/Specification/Acceptance
+Criteria lines is an automatic FAIL.
+Gate-pass is necessary, not sufficient: read the diff against the
+Specification's intent **and the cited BRIEF §sections** before the verdict —
+test-passing changes are frequently
+unmergeable, and iterating against visible tests is a known gaming vector. Read
+for **idiomaticity and style**, not just correctness: does the code match the
+target repo's house conventions (naming, guards, predicates, error/persistence
+idioms, the language's expressive forms), stay well-factored and DRY-ish, avoid
+needless repetition or abstraction it doesn't need, and read like the
+surrounding code? A gate-green diff that fights the house style — or introduces
+an inconsistency a careful reader of that repo would never write — is a defect:
+flag it in the Verdict with file:line, and weight it in a head-to-head. (Models
+are strong on *local* idiom and restraint but weak on *structural*
+re-derivation — the simplification that re-sees the shape is often the
+architect's or human's to name.) Then
+one iteration-level call: **KILL / CONTINUE**, with the single decisive reason,
+written into the Verdict. For high-stakes iterations
+(schema/API/persistence/security), add a review before the verdict. You
+(Opus 4.8) reading the diff is already a stronger-model, fresh-context pass
+over the Sonnet builder's work — a cross-tier read, though not cross-vendor
+(both are Claude Code). For an extra adversarial pass, pipe the diff to a fresh
+read-only `claude -p` reviewer (command in `dispatch.md`) or a
+fresh-context subagent prompted to break confidence — calibrated to flag only
+correctness/requirement/invariant gaps with file:line evidence, no style.
+
+**Variant sets — human in the loop.** When the iteration was built as a variant
+set (multiple `(harness, model)` lanes over one frozen spec), judge every
+variant against the same frozen AC, then **do not pick the winner unilaterally**
+— assume the human wants to be involved in selection. Present the head-to-head:
+per-variant gate results plus the deltas that decide it (correctness/invariants,
+idiomaticity + house-style, tests, user-facing behavior), with your
+recommendation and its reasoning. Let the human choose (`AskUserQuestion` or a
+checkpoint); you then execute the promote/merge they pick. Surface a
+recommendation — the call is theirs. (A standing handoff that pre-delegates the
+pick still gets the comparison surfaced before you act on it.)
+
+### 3. Research fan-out (optional — most iterations skip this)
+
+Two scales, two routes:
+
+- **Discovery scale** — brainstorming what to build, technology selection,
+  state-of-the-art surveys → invoke the `/architect-research` skill (a scout
+  researcher maps the topic, the orchestrator designs topic-specific parallel
+  researcher lanes, claims verified against sources, synthesized into a cited
+  report). Its report then distills into `architecture/BRIEF.md` §sections when
+  it is mission-scope (a durable contract that spans iterations), or the
+  iteration's **Grounds** section when it is iteration-scope.
+- **Iteration scale** — run the inline fan-out below only when at least one
+  trigger holds: (a) the iteration depends on external APIs, libraries, or
+  versions not already used in the target repo; (b) a narrow approach choice
+  needs facts neither you nor the repo has; (c) the human asked
+  (`/architect research: <question>`). Otherwise skip — the builder's
+  verify-against-reality requirement already covers routine API checks, and
+  researching well-understood iterations is pure cost.
+
+When a trigger fires, read `research.md` next to this file and follow it:
+3–5 narrow non-overlapping questions → parallel read-only `claude -p`
+researchers (built-in `WebSearch`/`WebFetch`) in the background → you
+adversarially verify the load-bearing claims → you write the iteration's
+**Grounds** section with citations and commit it. Researchers gather; you judge
+and write Grounds. Findings without a source URL don't enter Grounds.
+
+### 4. Spec the next iteration
+
+One-PR-sized. Run `architect new <name>` to scaffold
+`architecture/I<NN>-<name>.md` (it allocates the next ordinal and records the
+iteration in `space.yaml`), then write the **Specification** section with
+`architect section <name> specification --from <file>` — the full delegation
+contract, self-contained:
+
+- **Objective** — what to build and why (give the reason, not just the ask).
+  Cite **BRIEF §N** for durable context and a Grounds section for
+  iteration-local research, rather than restating either.
+- **Output format** — what the builder reports: raw tables, numbers, commit
+  SHAs, test output paths. No interpretation.
+- **Tool guidance** — the exact verification commands for the target repo, and
+  the specific APIs/formats/versions the builder must verify against the live
+  dependencies *before* writing code.
+- **Boundaries** — files it may touch, files it must not, explicit out-of-scope
+  list, "no placeholders; search before implementing", no refactors beyond the
+  task.
+- **Lane plan** — split the iteration into 1–4 parallel lanes, each declaring
+  its **target repo + file-touch set, checked for overlap**: name the repo
+  (`repos/<repo>`) and every file each lane may touch. Lanes in *different*
+  repos are inherently disjoint; same-repo lanes with any file overlap run as
+  one. Each lane gets its own objective, output format, and boundaries. Most
+  iterations are one lane — fan out only when the work is genuinely parallel (a
+  cross-repo mission often is).
+- **Effort call** — thinking budget set in the lane-prompt via the escalation
+  keywords (`think hard` … `ultrathink`); default unattended builder work high,
+  downgrade a routine, tightly-specified lane (record which and why). Claude
+  Code has no per-invocation effort flag — see `dispatch.md`.
+
+Then write the **Acceptance Criteria** section — exact gate commands +
+thresholds, each row carrying a `Brief §` column that addresses it back to
+intent — and run `architect freeze <name>`. What must be frozen before dispatch
+is the Acceptance Criteria: `architect freeze` commits any pending content in the
+frozen region (Grounds/Specification/Acceptance Criteria) in one freeze commit,
+records the `freeze_sha` in `space.yaml`, and prints the frozen AC back; **that
+commit is the freeze** ❄️ and is the last thing before dispatch. You needn't
+sequence Grounds and Specification into separate commits first — the freeze
+snapshots the whole frozen region and refuses to re-freeze once a frozen section
+changed afterward.
+
+### 5. Dispatch (one fresh `claude -p` per lane, worktree-isolated)
+
+Per the mechanics in `dispatch.md`:
+
+- **1 lane** → dispatch in the target repo's checkout (`repos/<repo>`).
+- **2–4 lanes** → `architect worktree add <repo> <iteration> <lane>
+  [--base <repo-base>]` per lane (creates `build/<id>-<lane>/wt` off the target
+  repo's base commit — a repo commit, distinct from the freeze, which is a
+  space commit — and records it in `space.yaml`).
+
+Assemble each lane's lane-prompt (the template in `dispatch.md` + this lane's
+section of the Specification + the frozen Acceptance Criteria) and write it to
+`build/<id>-<lane>/prompt.md` (fed to the builder on stdin); record it in the
+iteration file's **Builder Prompt** section — the dispatched-prompt provenance —
+with `architect section <iteration> prompt --append --lane <lane> --from
+build/<id>-<lane>/prompt.md`. Then run `architect dispatch <iteration> <lane>` — it assembles the
+canonical `claude -p` argv, pins the model, and streams stream-json to
+`build/<id>-<lane>/run.jsonl`. Launch one dispatch per worktree — each as its
+**own background Bash tool call** (your harness's `run_in_background`), **not**
+shell `&`. The harness keeps each lane alive for its full run and notifies you
+per lane; a `for … & done` launcher instead orphans the lanes and the harness
+reaps them all at once (see `dispatch.md`). Each lane builds only its declared
+files and writes raw results to `build/<id>-<lane>/report.md` — it never
+touches `architecture/`, so lanes never collide and the Acceptance Criteria
+stay untouchable.
+
+Do not block — end the turn or do other judgment work; multi-hour runs are
+normal. Print the lane-prompts too, so the human can run any lane in an
+interactive `claude` session instead. Whenever you return to a running lane,
+check liveness: the lane's `run.jsonl` must still be growing. If it has been
+silent 15+ minutes on one in-flight command, follow "Stall detection and
+rescue" in `dispatch.md` — kill the stuck child process, not the run.
+
+### 6. Post-flight and integrate (when the runs complete)
+
+`architect verify <iteration>` REPORTS (it never judges) per lane: frozen
+sections untouched, no builder commits, scratch report present, in-bounds.
+Confirm each yourself with evidence: (a) the scratch report has raw results
+only, (b) PHASE 0 disagreements were raised (silent compliance = defect to
+log), (c) the iteration file's frozen sections are untouched — `git diff
+<freeze-sha> HEAD -- architecture/I<NN>-<name>.md` shows no change to
+Grounds/Specification/Acceptance Criteria, (d) `git status` in the worktree
+shows **only files inside the lane's declared set** — an out-of-bounds write
+fails the lane, (e) `git -C <worktree> log <repo-base>..` is empty — a builder
+commit means a tampered worktree (reset and re-dispatch).
+
+**Transcribe** each lane's scratch report into the **Builder Report** section
+with `architect evidence <iteration> --lane <lane>` — it copies
+`build/<id>-<lane>/report.md` **verbatim** (byte-for-byte, no interpretation),
+commits it, and echoes the builder's STATUS line. The builder never wrote into
+`architecture/`; the CLI transcribes, preserving raw-results-only.
+
+**Then integrate** — you decide which lanes pass, the CLI does the git
+mechanics. `architect integrate <iteration> --lanes <passing-set>` commits each
+named lane on its branch and merges it `--no-ff` into the repo's integration
+branch `lane/<iteration>`, in order; it **refuses** a lane that left builder
+commits or wrote out-of-bounds, and stops on a merge conflict — which means the
+lane plan wasn't disjoint, a spec defect: kill the conflicting lane and re-spec
+it (never hand-resolve). Then run `architect gate <iteration>` against the
+integration branch as a smoke check (raw output; the verdict stays yours). A
+cross-repo mission yields one `lane/<iteration>` branch per touched repo. Update
+the iteration index in `architecture/ARCHITECT.md` (recording each repo's
+integration branch), remove the worktrees (`architect integrate … --teardown`,
+or `architect worktree remove <iteration> <lane>`), and commit the space.
+
+**Do not judge now** — the Verdict on the integration branch belongs to the
+next architect session; merge to each repo's main only on a CONTINUE verdict
+there.
+
+## Maintenance
+
+Re-read this skill against each new model generation and delete what the models
+now do unprompted — over-prescription degrades current-model output. The rules
+above are invariants; everything else is prunable.