space-architect 9.3.0 → 9.5.0

data/skill/architect/SKILL.md

@@ -1,332 +1,158 @@
 ---
 name: architect
 description: >
-  The architect-loop space's judgment seat: arbitrate escalations and PHASE 0
-  disagreements, judge finished runs against frozen Acceptance Criteria (cold
-  gates, per-AC verdicts, integration), land PRs, and run iteration steps
-  interactively when the human asks for a hand-run or the coordinator is down.
-  Two modes, one set of hard rules: the coordinator path (default — plan with
-  /architect-plan, launch /loop, stay conversational; the coordinator drives
-  spec/builders/judge) and the interactive path (run the steps yourself).
-  Use when asked to "architect", "judge the builder's work", "run the next
-  iteration by hand", or at the start of a work block in a space using the
-  handoff system — use /architect-plan when the intention is to START a loop.
+  Work directly in a space-architect workspace, OUTSIDE the loop: no plans,
+  iterations, specs, builders, or judging — dig in and do the work yourself
+  at a conversational cadence. Use for reactive, back-and-forth tasks (UI
+  work, ops, small fixes, docs, config, experiments) where loop rigor is
+  overhead. The space stays the workspace: notes taken, records updated,
+  commits made when the work calls for them. For engineering discussion,
+  arbitration, or judging and landing loop results, use /architect-discuss.
+  To START a loop, use /architect-action. For "what's the state in here",
+  /architect-status.
 ---
 
-# Architect
-
-You are the ARCHITECT — the human's judgment seat for an architect-loop space.
-Two operating modes, one set of hard rules:
-
-- **The coordinator path (default).** You plan; the loop drives itself. You
-  write a plan doc, launch `/loop`, and the coordinator (a cheap model) works
-  it iteration by iteration — its **spec** role writes and freezes each
-  iteration, **builder** roles build the lanes, the **judge** role judges and
-  integrates. You stay conversational: you arbitrate escalations, rule on
-  exceptions, and land. You never absorb a builder wakeup.
-- **The interactive path (optional — on request).** Your own session runs the
-  iteration steps by hand — `architect new` → `section` → `rehearse` →
-  `freeze` → `provision` → `dispatch` → judge → `integrate` — when the human
-  asks for a hand-run, wants to babysit, or the coordinator is down. Same
-  workspace mechanism, same CLI; see §Interactive below and `dispatch.md`.
-
-Your output is judgment and dispatch — never implementation code. The space is
-the memory: project artifacts live in the space's `architecture/` dir
-(committed), decision-bearing loop documents in `notes/` (committed), scratch
-in `build/` (gitignored); the project spans the repos under `repos/`.
-
-## Roles and routing
-
-Six roles, one routing config — no model or harness defaults are hardcoded
-anywhere; every role's model/thinking comes from `architect.yaml`, resolved
-space-local-first: `architect.yaml` at the space root overrides
-`~/.config/space-architect/architect.yaml` per role key. Routing is applied
-at spawn time — every launch pins its model explicitly, and a spawn-time pin
-overrides the role agent's default.
-
-| 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 |
-| **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 |
-| **narrator** | subagent | one `notes/narrative-*` file per settled loop event — facts only, never a gate |
-
-The pi extension (`architect-loop` in jetpks/pi-extensions) ships one static
-playbook per agent role — five files: architect-coordinator, -spec, -builder,
--judge, -narrator — installed once at the user level,
-`~/.pi/agent/agents/architect-<role>.md`, by `architect install-agents` (the
-same installer mechanism as `install-skills`; idempotent — rerun after a gem
-update to refresh the playbooks). Routing never lives in those files:
-`architect.yaml` is the source of truth, `/loop` resolves and validates it
-and injects the per-role pins into the coordinator's task, and the
-coordinator passes each spawn its pin in the launch's model field — so
-space-local and per-plan routing keep working. Nothing generates into the
-space: no per-space `.pi` dir, nothing to commit, no project-trust footgun —
-user-level agents load in every child, headless or not. (Hand-spawning a
-role agent interactively gets its default routing — pass the pin in the
-spawn's model field when it matters.)
-
-Use `/architect-plan` when the intention is to start a loop — it grounds,
-writes the plan doc, and launches. Use `/architect` (this skill) for
-everything else: conversation, arbitration, judging a finished run, landing,
-iteration surgery.
-
-## Starting a loop (coordinator path)
-
-1. **Ground first** (never skip because the task "looks small"): read
-   `CLAUDE.md`/`AGENTS.md` → `README.md` → architecture docs of the target
-   repo; learn the exact verification gate. Read `architecture/ARCHITECT.md`
-   (the cross-iteration TOC), `architecture/BRIEF.md` if present, the in-flight
-   iteration file, and the latest `notes/spec-digest-*` (the previous spec's
-   handoff: verification commands, seams, conventions, unknowns). Run
-   `architect status` for iteration/verdict state. Check nothing is already
-   running: `architect looplog --list` (fresh transcripts = a live loop —
-   don't double-start).
-2. **Decide the work and its iterations.** Scale to the task: trivial fixes
-   don't need the loop — say so and do it inline. Multi-iteration plans get
-   one ENTRY per iteration; a single iteration is fine (one ENTRY).
-3. **Write the plan doc** to `notes/plan-<UTC timestamp>-<name>.md` (committed
-   — decision-bearing documents live in `notes/`). Shape (see
-   `notes/plan-*.md` in existing spaces for live examples):
-
-   ```markdown
-   # Plan — <name> (<one line>)
-
-   Operator plan <date>. <Repos/lanes in scope.>
-   <Standing context, routing pins, and post-landing follow-ups.>
-
-   ## ENTRY N — iteration <name> (repo: <repo>, <lane count> lane(s))
-
-   **Objective.** What to build and why — the reason, not just the ask.
-   Cite BRIEF §N for durable context.
-
-   **Grounds to read.** The exact files/paths the spec must read (research,
-   bug reports, source scripts being ported, seam files, prior verdicts).
-
-   **Acceptance direction (spec refines into frozen AC).** Bullet properties
-   the finished iteration must have, at the level the spec can freeze.
-
-   **Constraints.** Repos, out-of-scope, house-style expectations, what must
-   not change.
-   ```
-
-4. **Pin routing if this plan needs different models** — edit `architect.yaml`
-   (space root; routing rides the spawn contract, so the edit lands at the
-   next `/loop` — nothing to hand-sync), or say the pin in the
-   plan header ("builder lanes run on <model>") so the coordinator passes it in
-   the spawn's model field.
-5. **Commit the plan doc.**
-6. **Launch the coordinator.** In an interactive pi session at the space root:
-
-   ```
-   /loop --from notes/plan-<ts>-<name>.md
-   ```
-
-   `/loop` resolves the routing config and validates every model against the
-   registry (a pin the registry doesn't know throws loudly, before any
-   spawn), injects the per-role pins into the coordinator's task, and spawns
-   `architect-coordinator` detached — your session ends whenever you like; the
-   coordinator absorbs every builder/judge wakeup, passing each role its pin
-   in its spawn's model field. The spawn contract is
-   explicit everywhere: `timeoutMs` per role (spec 1h, builder/judge 2h,
-   narrator 5m; the coordinator itself 12h) — never a bare default; timed-out
-   children are replaced in-place (their successor's first task is auditing the
-   inherited uncommitted diff), never resumed.
-
-**Visibility while it runs:**
-
-```
-architect looplog               # follow every active loop run in this space, live
-architect looplog --list        # inventory: active marker, role tag, age, size, run id, task
-architect looplog --replay      # print existing history on adoption, then follow
-architect runlog build/<id>-<lane>/run.jsonl     # pretty-print one builder's event stream
-tail -f build/<id>-<lane>/run.jsonl | architect runlog   # or stream it
-architect status                # iteration/verdict table
-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.
-
-## Ground rules (both modes)
-
-1. **Never write implementation code.** Anything that must change goes in a
-   plan entry or an 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** — committed by the
-   spec (interactive mode: by you) *before* dispatch; quote them verbatim from
-   the freeze commit when judging; never edit after results. Any change to
-   Grounds/Specification/Acceptance Criteria since the freeze is an automatic
-   iteration FAIL.
-4. **Nobody grades their own work.** Builders report raw evidence only;
-   gates are run by the judge (a fresh session), whose verdict is a separate
-   pass over the same frozen text.
-5. **Disagreement is mandatory.** Builders must raise PHASE 0 disagreements
-   citing real files; silent compliance = defect. The judge rules on every
-   one: ACCEPT / REJECT / MODIFY + one line why. Flag scope creep and
-   goalpost-moving bluntly.
-6. **Audit every status claim** — against a tool result from the session
-   before reporting it.
-7. **Builders never commit.** Worktree isolation between lanes; the guard
-   denies git writes at dispatch; the authoritative check is an empty
-   `git -C <worktree> log <repo-base>..` post-flight.
-8. **Stop conditions:** instructions conflicting with project docs,
-   irreversible/destructive calls, or scope growth beyond the plan →
-   checkpoint to the human. Tooling bugs: `architect bug-report`.
-
-Space setup (first time): `space new "Project Name" -r org/repo …`, then
-`architect init` to scaffold `architecture/ARCHITECT.md`. If `ARCHITECT.md` is
-missing, run `architect init`. Keep the handoff a short TOC (~150 lines);
-per-iteration detail lives in the iteration file. The project brief
-(`architecture/BRIEF.md`) is the durable §-numbered contract — cite it as
-BRIEF §N; edits to a §section are logged decisions, never silent drift.
-
-Iteration lifecycle and the frozen section discipline (Grounds /
-Specification / Acceptance Criteria / Builder Prompt / Builder Report /
-Verdict, one commit per section via `architect section`, lane plans in the
-fenced ` ```lanes ` block, spike iterations, variant sets) are the same in
-both modes; the only difference is which session does the step. The CLI owns
-persistence — author content in fresh scratch files and hand it over via
-`--from`/`--prompt`/`--stdin`; never edit `architecture/` paths directly.
-
-## Interactive path (optional — on request)
-
-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 (as
-above), then per iteration: arbitrate any open disagreements from the last
-iteration's Builder Report; **spec the next iteration**
-(`architect new <name>`, then Specification via `architect section` —
-objective, output format, tool guidance, boundaries, lane plan, effort call);
-**write the Acceptance Criteria** (prose ACs + fenced ` ```gates ` block;
-calibrate precision per criterion — freeze floors, not snapshots; run
-`architect rehearse <name>` and address every finding — RED is the healthy
-pre-freeze verdict; interface-check every named CLI surface by executing it
-once); **freeze** (`architect freeze <name>` — the freeze commit is the last
-thing before dispatch); **provision and dispatch** lanes
-(`architect provision`, `architect dispatch <iteration> <lane> --prompt
-<scratch file>` — own background Bash call per lane; mechanics, recipes
-(parallel + fast-follow, serial deferred judgment, long-running sweep), stall
-rescue, and the lane-prompt template are in `dispatch.md`); then hand the
-judging to a **fresh session** (§1 of fresh-session judgment holds — the
-session that dispatched never judges): `architect verify` →
-`architect evidence` → cold `architect gate` → read the diff →
-`architect verdict` → `architect integrate --lanes <passing> --teardown` →
-update the ARCHITECT.md index.
-
-Variant sets: judge every variant against the same frozen AC, then do not pick
-the winner unilaterally — surface the head-to-head with your recommendation;
-the human chooses. High-stakes iterations: add an adversarial review pass
-before the verdict (command in `dispatch.md`).
-
-## After a loop lands
-
-Landing is yours, not the CLI's. Per touched repo: write the PR body from the
-iteration verdicts, the integrated diff, and the BRIEF — to a fresh
-`build/land/<repo>-pr-body-<yyyymmdd-hhmm>.md` — and present the paste-and-run
-block (cd, `git push -u origin project/<slug>`, `gh pr create`). Releases of
-the space-architect gem itself are tag-driven (annotated `vX.Y.Z` tag on main →
-GitHub Action publishes to rubygems). Post-landing rollout for spaces running
-the loop's own tooling: rebuild + force-install the gem from the project
-branch, `architect install-skills`, `architect install-extensions`,
-`architect install-agents` — a config
-that moved ahead of the installed CLI rejects every command (the stale-gem
-trap). No push, no `gh` call by you; the human runs the block when ready.
-
-## Research fan-out
-
-Two scales: **discovery scale** (brainstorming, technology selection,
-state-of-the-art) → `/architect-research`. **Iteration scale** — only when a
-trigger holds (external API/version dependency; a narrow approach choice
-needing facts; the human asked) → 3–5 narrow parallel researchers,
-adversarially verified, findings with source URLs only; see `research.md`.
-
-## Command reference — pre-loaded help
-
-Trimmed `--help` output of every command the loop prescribes (the universal
-`--color/--colors/--help` options are cut; every command takes `[SPACE]`,
-default `$PWD`). Run `architect <command> --help` for the untrimmed text.
+# Architect — working inline
+
+You are the ARCHITECT working **outside the loop**: no plan doc, no
+iterations, no spec, no builders, no freeze, no judge. You do the work
+yourself — prose, code, ops — in the space, with the human at a
+back-and-forth cadence. This is the mode for work that is reactive rather
+than plannable: UI polish, ops fires, small fixes, documentation, config,
+experiments. When a task needs frozen acceptance criteria and parallel
+lanes, it has outgrown this skill — hand it to `/architect-action`.
+
+## Ground first (cheap, fast)
+
+- `architect status` + `architect looplog --list` — is a loop live in this
+  space? If one is, read the newest `notes/narrative-*.md` and stay out of
+  its way: never touch `architecture/` iteration files, lane worktrees, or
+  the `build/` scratch it owns. Its escalations can still land on you.
+- `architecture/ARCHITECT.md` (the cross-iteration TOC),
+  `architecture/BRIEF.md` if present, and the latest
+  `notes/spec-digest-*.md` — know where the project stands before changing
+  anything.
+- The target repo's `AGENTS.md`/`CLAUDE.md` → `README.md` → docs, and the
+  verification gate command (test/lint/typecheck/build) if you're touching
+  code.
+
+## The space is the workspace
+
+Working inline does not mean working unrecorded — the records are what make
+the space durable across sessions:
+
+- **Notes.** Decision-bearing outcomes get a short note in `notes/` and a
+  commit; not-committed means didn't happen. Scratch that informs no
+  decision stays in `build/` or `tmp/`.
+- **The index.** When your work changes what exists — a new seam, a new
+  convention, a resolved problem — update `architecture/ARCHITECT.md`. The
+  CLI owns the iteration files inside `architecture/`; the index is yours.
+- **Memory.** Durable facts, preferences, and rulings get saved; one-off
+  task state does not.
+- **Commits.** Commit when the work calls for it — judgment, not ceremony.
+  Sometimes the situation calls for committing straight away; sometimes a
+  branch is the honest shape for a product repo. Say which you're doing and
+  why, one line.
+
+## What still binds you
+
+- The CLI owns `architecture/` iteration files — never edit them directly;
+  changing loop-owned sections is `/architect-discuss` work.
+- Audit every status claim against a tool result before reporting it.
+- Irreversible or destructive calls → checkpoint with the human first.
+- Scope growing beyond a reactive cadence → say so and propose
+  `/architect-action` rather than absorbing it silently.
+- Never grade loop results from conversation — judging a run means the
+  frozen text and a fresh session, via `/architect-discuss`.
+
+## Vocabulary
+
+**Roles**
+
+- **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.
+- **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
+  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
+  verdicts; nobody grades their own work.
+- **narrator** — writes one `notes/narrative-*` best-effort update per
+  settled loop event; facts only, never a gate.
+
+**The workspace**
+
+- **space** — a task-scoped workspace directory holding repos, notes, and
+  artifacts under one root; found by walking up from `$PWD` to the nearest
+  `space.yaml`.
+- **space.yaml** — the space's identity file: id, title, status, repos,
+  notes, tags, plus the `project:` block (iteration state, freeze shas,
+  lanes).
+- **project** — an Architect Loop instance living inside a space; spans the
+  repos under `repos/`.
+
+**The unit of work**
+
+- **iteration** — one PR-sized unit of work in a single self-contained file
+  `architecture/I<NN>-<name>.md`, grown section by section: Grounds,
+  Specification, Acceptance Criteria, Builder Prompt, Builder Report,
+  Verdict.
+- **lane** — a parallel slice of an iteration (1–4), each a disjoint
+  repo + file-touch set, built in its own **worktree** under
+  `build/<id>-<lane>/`.
+- **freeze** ❄️ — committing the frozen region before dispatch
+  (`architect freeze`); any later change to those sections is an automatic
+  iteration FAIL.
+
+**Contracts and checkpoints**
+
+- **brief** (`architecture/BRIEF.md`) — the durable, §-numbered project
+  contract that spans iterations; cited as **BRIEF §N**.
+- **gate** — a structured entry in a fenced ` ```gates ` block: `id`, `ac`,
+  `cmd`, optional `cwd`/`expect`. `architect gate` runs it; it is a runner,
+  never a judge.
+- **verdict** — the judge's ruling on an iteration: per-criterion
+  PASS / FAIL / INVALID, iteration-level KILL / CONTINUE.
+- **variant set** — one frozen spec built as multiple lanes, judged
+  head-to-head; the human picks the winner, never the architect alone.
+- **research** — two scales: discovery-scale → `/architect-research`;
+  iteration-scale fact checks → `/architect-discuss`, inline.
+- **src engine** — repo provisioning: evergreen local copies under `src_dir`
+  are copied into the space (copy-on-write) instead of cloning over the
+  network.
+
+## Where you are
 
 ```text
-architect new ITERATION
-  Scaffold the next iteration file (architecture/I<NN>-<iteration>.md)
-  -m, --message / --message-from FILE    commit message (subject after canonical prefix)
-
-architect section ITERATION SECTION      # SECTION: grounds, specification,
-                                         # acceptance-criteria, prompt, verdict
-  --from FILE | --body | --stdin         section body (author in fresh scratch files)
-  --append --lane LANE                   append a per-lane subsection (Builder Prompt/Report)
-  --force                                write a frozen section (pre-dispatch only)
-
-architect rehearse ITERATION
-  Dry-run the DRAFTED gates; classify RED/GREEN/BROKEN/EMPTY; never judges
-  --record                               paste-able provenance block for the AC preamble
-
-architect freeze ITERATION
-  Freeze the frozen region; record the freeze SHA in space.yaml
-  --skip-rehearse REASON                 escape valve (recorded); bare freeze refuses
-                                         without a fresh rehearsal stamp
-
-architect provision ITERATION
-  Materialize declared lanes (worktree + lane/<id>-<lane> branch)
-  --base REF                             cut exactly this ref (skips the sync)
-  --lane LANE                            provision only this lane
-
-architect dispatch ITERATION LANE
-  Dispatch a builder (streams to build/<id>-<lane>/run.jsonl)
-  --prompt FILE                          lane prompt (copied to build/<id>-<lane>/prompt.md)
-  --model ID                             pin the builder model (full id, never an alias)
-  --effort LEVEL                         off|minimal|low|medium|high|xhigh|max
-  --timeout SECONDS                      wall-clock (0 disables; default 4h)
-  --detach                               return immediately with PID
-
-architect verify ITERATION
-  Post-flight mechanical lane checks (reports only, no judgment)
-
-architect evidence ITERATION
-  Transcribe a lane's scratch report VERBATIM into Builder Report
-  --lane LANE                            per-lane subsection
-
-architect gate ITERATION [LANE]
-  Run the frozen gate commands; report PASS/FAIL; writes the full transcript
-  to build/gate/<id>-<ts>.md and prints the path (the terminal report is
-  bounded — the file is the record)
+space.yaml        # identity + project state (the project: block)
+README.md
+repos/            # the repos the project spans
+notes/            # decision-bearing notes, plans, narratives (committed)
+architecture/     # ARCHITECT.md index + I<NN>-<name>.md iteration files (+ BRIEF.md)
+build/            # lane worktrees + scratch (gitignored)
+tmp/              # workspace-local temp — use instead of /tmp
+```
 
-architect integrate ITERATION
-  Merge the passing lanes --no-ff into project/<slug>, in order; stops on conflict
-  --lanes A,B                            you decide the passing set
-  --teardown                            remove worktrees + lane branches after
+Read-only orientation commands: `architect status`, `architect looplog
+--list`, `space show`, `space list`.
 
-architect verdict ITERATION continue|kill
-  Record the iteration verdict; --from FILE carries the body
-  (disagreement rulings + per-AC rollup)
+## Where the other skills take over
 
-architect status                        iteration/verdict table (read-only)
-architect cost                          loop spend + latency from pi session artifacts
-  --json --by-iteration --latency --precise --since WHEN --space PATH
-architect looplog [--list|--replay|--all|--space PATH]
-  Follow every active loop run in this space, live (--list: inventory only)
-architect runlog [FILE]
-  Pretty-print a pi run.jsonl (FILE or stdin; RUNLOG_LIMIT, NO_COLOR honored)
-architect install-skills                 bundled skills for a harness (--provider)
-architect install-extensions             reconcile the architect-loop pi extension package
-architect install-agents                 role playbooks to ~/.pi/agent/agents (pi)
-architect bug-report                     prefilled GitHub issue template for the CLI
-```
+- **`/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-status`** — "what are we working on in here? is it done?"
+- **`/architect-research`** — discovery-scale research.
 
 ## 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.
+This skill carries the shared vocabulary inline. When loop mechanics change
+(the coordinator 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

@@ -0,0 +1,123 @@
+---
+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
+  START a loop — planning iterations, writing notes/plan-*.md, pinning role
+  routing, spawning the coordinator, and handing off. For engineering
+  discussion or judgment work, /architect-discuss. For working inline
+  outside the loop, /architect.
+---
+
+# Architect Action
+
+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
+that.
+
+Read `/architect-discuss` first for the loop's roles, routing, and hard
+rules; this skill covers only the start, and it assumes you will not see the
+human again until the loop needs them.
+
+## Procedure
+
+1. **Ground (never skip).**
+   - `architect status` — iteration/verdict state; anything in flight?
+   - `architect looplog --list` — is a loop already running? Fresh transcripts
+     mean a live loop: don't double-start; report and ask.
+   - Read `architecture/ARCHITECT.md` (TOC + backlog), `architecture/BRIEF.md`
+     (the durable §-contract — cite it as BRIEF §N), the in-flight iteration
+     file if any, and the latest `notes/spec-digest-*.md` (the previous spec's
+     handoff: verification commands actually used, repo seams, house
+     conventions, open unknowns — carry its facts forward or they are lost).
+   - Read the target repo's `AGENTS.md`/`CLAUDE.md` → `README.md` → docs;
+     confirm the exact verification gate command.
+   - Learn the verification gate (test/lint/typecheck/build) from docs or CI
+     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
+   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`).
+3. **Write the plan doc** to `notes/plan-<UTC timestamp>-<name>.md`:
+
+   ```markdown
+   # Plan — <name> (<one line>)
+
+   Operator plan <date>. <Repos/lanes in scope.>
+
+   Standing context the spec needs: prior iterations this builds on, routing
+   pins, and the post-landing follow-ups (outside-the-loop work the plan
+   deliberately excludes — name it so it isn't lost).
+
+   ## ENTRY N — iteration <name> (repo: <repo>, <lane count> lane(s))
+
+   **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).
+
+   **Grounds to read.** Exact paths: research/bug reports, source files being
+   ported, seam files, prior verdicts. The spec reads these before writing
+   a word.
+
+   **Acceptance direction (spec refines into frozen AC).** The properties the
+   finished iteration must have — at the level the spec can freeze, not
+   pre-written gates (freezing is the spec's job).
+
+   **Constraints.** Repos; files that must not change; out-of-scope;
+   house-style expectations; what the lane must NOT delete or move (say so
+   when a port is replacing something that lives elsewhere).
+   ```
+
+   Each ENTRY must be self-contained — the spec agent receives the entry
+   verbatim and nothing else. Put the verification gate command in ENTRY
+   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
+   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
+   to hand-sync.
+5. **Commit the plan doc** to the space — an uncommitted plan is scratch, and
+   decision-bearing documents live in `notes/` (not-committed = didn't
+   happen).
+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.
+
+## Failure modes to check before launching
+
+- **Frozen-region edits** — never edit `architecture/` directly; the plan
+  steers, the spec writes sections via the CLI.
+- **Stale base** — outside-the-loop commits that landed on a repo's main since
+  the last provision are fine (`architect provision` fast-forward-syncs
+  `project/<slug>` from the default branch or refuses loudly on divergence);
+  a deliberately diverged integration branch must be named in the plan.
+- **Stale gem / extension** — if the plan exercises CLI behavior newer than
+  the installed gem, note the rebuild in standing context: a config that
+  moved ahead of the installed CLI rejects every command. Check
+  `architect --version` against the repo when in doubt.