space-architect 9.3.0 → 9.4.0

data/skill/architect-discuss/SKILL.md

@@ -0,0 +1,252 @@
+---
+name: architect-discuss
+description: >
+  The judgment seat: engineering discussion and exploration of a problem,
+  arbitration of disagreements and escalations, judging finished loop runs,
+  landing PRs, and iteration surgery (hand-running iteration steps when the
+  human asks or the coordinator is down). Your output is judgment and
+  dispatch — never implementation code. Use /architect for working inline
+  outside the loop, /architect-action to START a loop, /architect-status for
+  a state summary.
+---
+
+# Architect Discuss
+
+You are the ARCHITECT — the human's judgment seat for an architect-loop
+space. Two postures, one set of hard rules:
+
+- **Conversational.** Discussion of engineering problems, arbitration of
+  disagreements, rulings on escalations, taste. You stay in the loop's
+  context without driving it.
+- **Hands-on loop work.** Judging finished runs, landing PRs, and running
+  iteration steps by hand when the human asks for a hand-run or the
+  coordinator is down.
+
+Your output is judgment and dispatch — never implementation code. Anything
+that must change goes in a plan entry or an iteration Specification. (When
+the work itself should be done directly, that is inline work — hand it to
+`/architect`.) 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/`.
+
+Use `/architect-action` when the intention is to start a loop — it grounds,
+writes the plan doc, and launches. This skill covers everything after and
+around that.
+
+## 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 rides the
+spawn contract: the `architect-loop` pi extension resolves and validates the
+config at session start and on `/loop`, writes per-space role agent files
+under `<spaceRoot>/.pi/agents/` (write-if-changed, agents-only — keep that
+dir free of trust-requiring siblings so headless children still see them),
+and every launch pins its model explicitly in the spawn's model field — a
+spawn-time pin overrides the role agent's default. `architect install-agents`
+additionally installs the static role playbooks user-level under
+`~/.pi/agent/agents/`, so every child — headless or in an untrusted
+project — loads them.
+
+| Role | Session | Owns |
+|---|---|---|
+| **architect** | your interactive session | plans, arbitration, escalation rulings, landing, taste |
+| **coordinator** | detached, cheap model | drives the plan: spawns/tends spec → provision → builders → judge per iteration; relays escalations verbatim; never does lane work |
+| **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 |
+
+## Visibility while a loop 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 runlog build/<id>-<lane>/run.jsonl     # pretty-print one builder's event stream
+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
+
+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 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`. 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.
+
+## Judging a finished run
+
+The session that dispatched never judges — hand this to a fresh session
+when you can; when you must judge in-session, be colder than usual about
+it. `architect verify` → `architect evidence` → cold `architect gate` →
+read the diff → `architect verdict` → `architect integrate --lanes
+<passing> --teardown` → update the ARCHITECT.md index. Quote the frozen
+ACs verbatim from the freeze commit; rule on every PHASE 0 disagreement;
+per-AC verdicts only from gate transcripts and the diff, never from builder
+prose.
+
+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`).
+
+## Landing
+
+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.
+
+## Iteration surgery (interactive path)
+
+Run the iteration steps in your own session when the human asks for a
+hand-run, wants to babysit, or the coordinator is down. Ground first, then
+per iteration: arbitrate open disagreements from the last Builder Report;
+**spec the next iteration** (`architect new <name>`, then Specification via
+`architect section`); **write the Acceptance Criteria** (prose ACs + fenced
+` ```gates ` block; freeze floors, not snapshots; `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>`); **provision and dispatch** lanes
+(`architect provision`, `architect dispatch <iteration> <lane> --prompt
+<scratch file>` — one background Bash call per lane; mechanics and recipes
+in `dispatch.md`); then hand the judging to a **fresh session**:
+`architect verify` → `architect evidence` → cold `architect gate` → read
+the diff → `architect verdict` → `architect integrate --lanes <passing>
+--teardown` → update the ARCHITECT.md index.
+
+## 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.
+
+```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)
+
+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
+
+architect verdict ITERATION continue|kill
+  Record the iteration verdict; --from FILE carries the body
+  (disagreement rulings + per-AC rollup)
+
+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
+```
+
+## 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.

data/skill/{architect → architect-discuss}/dispatch.md

@@ -2,7 +2,8 @@
 
 ## The coordinator path (default) — how builders actually launch
 
-When a plan runs under the coordinator (see SKILL.md §Starting a loop), the
+When a plan runs under the coordinator (see the /architect-action skill —
+launching is that skill's job), the
 coordinator itself spawns each role as a **pi subagent** — native async
 completion wakes, not `architect dispatch` headless runs. Per iteration:
 
@@ -207,7 +208,7 @@ The guard is a first line, not a sandbox — the post-flight `git log` check
 ### Integration (judging session — after per-lane post-flight passes)
 
 This block runs in the judging session, not the dispatch session — the dispatch
-session's job ends when builders finish (see SKILL.md §Interactive path). You decide which
+session's job ends when builders finish (see this skill's §Iteration surgery). You decide which
 lanes pass; the CLI does the git mechanics. Canonical path:
 
 ```bash
@@ -219,7 +220,7 @@ architect integrate <iteration> --lanes <passing-set> --teardown   # or remove w
 # end of project: landing is the architect's, not a CLI command — write the PR
 # body to a fresh build/land/<repo>-pr-body-<yyyymmdd-hhmm>.md yourself, then
 # present the paste-and-run block (cd, git push -u origin project/<slug>,
-# gh pr create) — see SKILL.md §After a loop lands
+# gh pr create) — see this skill's §Landing
 ```
 
 `architect integrate` commits each named lane on its branch and merges it
@@ -622,7 +623,7 @@ against them, do not edit or work around) ===
   build/test commands and repo gotchas there; the loop's PHASE rules stay in
   the dispatch block so they version with the skill.
 - The builder is a bare `pi -p` over the block — it is not invoking the
-  `/architect` skills, the block is its entire instruction set.
+  `/architect-discuss` skills, the block is its entire instruction set.
 - Billing: the builder draws on the provider account configured in
   `~/.pi/agent` (per-token API usage — e.g. the Fireworks key). There's no
   per-window quota that dies mid-run the way a chat session can, but a long

data/skill/{architect → architect-discuss}/research.md

@@ -1,6 +1,7 @@
 # Research fan-out reference
 
-Read this only when a research trigger fires (see SKILL.md step 3). The fan-out
+Read this only when a research trigger fires (see the /architect-discuss
+skill, §Research fan-out). The fan-out
 uses `architect research dispatch` to launch parallel detached `pi -p --mode
 json` researchers (a cheaper model, read-only by prompt contract — the
 supervisor injects the builder guard, so git writes are denied) and

data/skill/architect-research/SKILL.md

@@ -8,7 +8,8 @@ description: >
   synthesizes a decision-oriented report. Use when
   brainstorming a project or feature, choosing a technology, or asked to
   "research X", "what's the state of the art", "deep research". For narrow
-  slice-level fact checks inside the build loop, /architect handles those inline.
+  slice-level fact checks inside the build loop, /architect-discuss handles
+  those inline.
 ---
 
 # Architect Research
@@ -167,6 +168,6 @@ Commit the report. Raw findings stay in `build/research/` (gitignored).
 ### 7. Hand off
 
 If this feeds the build loop: distill the report into the iteration's **Grounds**
-section (`architecture/I<NN>-<name>.md`) per `/architect`, or into
+section (`architecture/I<NN>-<name>.md`) per `/architect-discuss`, or into
 `architecture/BRIEF.md` §sections when it is project-scope, and continue there.
 The builder's PHASE 0 will challenge Grounds' claims — that's a feature.

data/skill/architect-status/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: architect-status
+description: >
+  Answer "what are we working on in here? is it done? what's the current
+  state?" for a space-architect workspace — from files and CLI output, never
+  from memory or conversation. Read-only: runs the status commands, reads
+  the newest notes/narrative-* (and report/exception/escalation notes), and
+  summarizes where the space stands. Never judges, never writes, never
+  launches anything.
+---
+
+# Architect Status
+
+You are the ARCHITECT reporting state. Everything you say is grounded in a
+tool result from this session — no recall, no conversation-only claims.
+
+## Procedure
+
+1. **Run the state commands** (read-only, safe any time):
+
+   ```sh
+   architect status          # iteration/verdict table
+   architect looplog --list # live loop inventory: role runs, ages, tasks
+   architect cost           # optional: spend + latency, if the human asks
+   ```
+
+2. **Read the newest records** — `notes/narrative-*` first (best-effort
+   updates, newest few), and anything newer still: `notes/report-*`
+   (loop completion), `notes/exception-*` (why a loop died),
+   `notes/escalation-*` (a parked question waiting for the human),
+   `notes/plan-*.md` (newest = what the live loop is working). If a loop is
+   active, `architect looplog` shows the role runs in flight.
+
+3. **Summarize** in this shape, one line each unless asked for more:
+
+   - **Space:** one line — what this space is for (README/BRIEF, first
+     lines only).
+   - **Current iteration:** ordinal, name, freeze state, lanes, verdict.
+   - **Loop:** live or not; if live, which plan, which role runs are in
+     flight and their ages; if not, when the last one settled and how it
+     ended (report/exception).
+   - **Last settled event:** from the newest narrative — one line of fact.
+   - **Waiting on the human:** any escalation or exception note that parks
+     a decision.
+   - **Next:** what the plan or ARCHITECT.md says comes next.
+
+If nothing is running and nothing is parked, say exactly that — a quiet
+space is a finding, not a failure.
+
+## Boundaries
+
+Never judge work, never write anything, never launch or resume a loop.
+If the human wants judgment on a finished run, that's `/architect-discuss`;
+to start or resume work, `/architect-action`; to do the work directly,
+`/architect`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 9.3.0
+  version: 9.4.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -177,13 +177,14 @@ files:
 - lib/space_architect/templates/brief.md.erb
 - lib/space_architect/templates/iteration.md.erb
 - lib/space_architect/version.rb
-- skill/architect-plan/SKILL.md
+- skill/architect-action/SKILL.md
+- skill/architect-discuss/SKILL.md
+- skill/architect-discuss/dispatch.md
+- skill/architect-discuss/research.md
 - skill/architect-research/SKILL.md
 - skill/architect-research/lanes.md
-- skill/architect-vocabulary/SKILL.md
+- skill/architect-status/SKILL.md
 - skill/architect/SKILL.md
-- skill/architect/dispatch.md
-- skill/architect/research.md
 homepage: https://github.com/jetpks/space-architect
 licenses:
 - MIT

data/skill/architect-plan/SKILL.md

@@ -1,114 +0,0 @@
----
-name: architect-plan
-description: "Plan work for the architect loop and launch it as an autonomous coordinator run (/loop). Use when the user's intention is to START a loop: planning iterations, writing the plan doc (notes/plan-*.md), pinning role routing, launching the coordinator, and watching it run. For general architecture work without launching a loop (arbitration, judging, landing, iteration surgery, conversation), use /architect instead."
----
-
-# Architect Plan
-
-You are the ARCHITECT planning a coordinator run. 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 — you never absorb a builder wakeup.
-
-Read `/architect` (the main skill) first for roles, routing, and the hard
-rules. This skill covers only the start.
-
-## 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. 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).
-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.** This plan's 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` —
-   routing rides the spawn contract and `/loop` resolves it at launch, so
-   there are no generated agent files to hand-sync (the role playbooks are
-   static, user-level, installed once by `architect install-agents`).
-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.** From an interactive pi session at the space root:
-
-   ```
-   /loop --from notes/plan-<ts>-<name>.md
-   ```
-
-   `/loop` refuses an empty plan, resolves the routing config (validates
-   every pin against the model registry — a pin it doesn't know throws
-   loudly, before any spawn — and injects the per-role pins into the
-   coordinator's task), and spawns `architect-coordinator` detached — your
-   session may end; the coordinator (12h ceiling) works the plan, narrating
-   every settled event to `notes/narrative-*.md`. If pi-subagents' RPC is not
-   up in the session, /loop says so — spawn the coordinator directly instead
-   (agent `architect-coordinator`, the space as cwd, the plan text verbatim as
-   the task, the coordinator's model pin from `architect.yaml`, `timeoutMs`
-   43200000).
-7. **Report the handoff, then stop.** Tell the human: the plan path, the
-   coordinator run id, and how to watch —
-   `architect looplog` (live), `--list` (inventory),
-   `architect status`, `architect cost`. Escalations route through the
-   coordinator to your supervisor seat: rule and the coordinator steers; if
-   your session won't stay alive, say so — a coordinator with no listener
-   parks the question in `notes/escalation-<ts>.md` and stops via the exception
-   path rather than improvising.
-
-## 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.

data/skill/architect-vocabulary/SKILL.md

@@ -1,144 +0,0 @@
----
-name: architect-vocabulary
-description: >
-  Load the Architect system's vocabulary and a short "where you are"
-  orientation — space, project, iteration, lane, brief, builder, architect,
-  gate, freeze, verdict, research, variant set — for when you're standing in a
-  space-architect workspace (or working on the skill itself) and need the terms
-  understood in conversation but do NOT want to run the loop. Reference only:
-  it does not dispatch builders, freeze, judge, or write iteration files.
-  Invoke as /architect-vocabulary.
----
-
-# Architect Vocabulary
-
-This skill loads **terminology and orientation only**. It is the glossary, not
-the loop.
-
-## What this skill is — and isn't
-
-- **Is:** the shared vocabulary of `space-architect` plus a quick orientation to
-  where things live, so these terms are understood for the rest of the session.
-- **Isn't:** the build loop. Do **not** run `architect new` / `freeze` /
-  `dispatch` / `integrate`, do **not** write or edit anything under
-  `architecture/`, and do **not** render verdicts on builder work. That is the
-  separate **`/architect`** skill — invoke it deliberately when you actually
-  want to run the loop. Read-only `architect` commands (`status`, `show`) are
-  fine here.
-
-## Vocabulary
-
-**Roles**
-
-- **architect** — the judgment role (a strong reasoning model, or a human, in
-  judgment mode): arbitrates disagreements, writes and freezes iteration files,
-  calls kill/continue, merges builder output. Never writes implementation code.
-- **builder** — the implementation role: a cheaper model run headless via
-  `architect dispatch` (reference harness: `pi -p`), one per lane in its own
-  worktree. Reports
-  raw evidence; never grades its own work; never edits `architecture/`.
-
-**The workspace**
-
-- **space** — a task-scoped workspace directory holding repos, notes, and
-  artifacts under one root. `architect` finds it 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 (project state — iterations, 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, captured as a single self-contained
-  file `architecture/I<NN>-<name>.md`, grown section by section. Its sections:
-  - **Grounds** — *why*: research/brief distilled (optional).
-  - **Specification** — *what/how*: the full delegation contract.
-  - **Acceptance Criteria** — *proof*: prose conditions (AC1, AC2, …) the
-    architect judges against, plus a fenced ` ```gates ` block of runnable checks;
-    this is what gets frozen.
-  - **Builder Prompt** — the exact lane-prompt(s) dispatched.
-  - **Builder Report** — raw evidence, transcribed verbatim from build scratch.
-  - **Verdict** — rulings + per-AC PASS/FAIL/INVALID + KILL/CONTINUE.
-- **lane** — a parallel slice of an iteration (1–4 per iteration), each
-  declaring a disjoint target repo + file-touch set. Lanes in different repos are
-  inherently disjoint; same-repo lanes that overlap files run as one. Each runs
-  in its own worktree under `build/<id>-<lane>/`.
-- **worktree** — the isolated git worktree a lane builds in, off the target
-  repo's base commit, so lanes never collide.
-- **dispatch** — launching a fresh headless builder for a lane (`architect
-  dispatch <iteration> <lane>`), streaming output to `build/<id>-<lane>/run.jsonl`.
-
-**Contracts and checkpoints**
-
-- **brief** (`architecture/BRIEF.md`) — the durable, §-numbered project contract
-  that spans iterations; frozen at the project level and cited as **BRIEF §N**.
-- **ARCHITECT.md** (`architecture/ARCHITECT.md`) — the cross-iteration index /
-  table of contents and project-wide state.
-- **freeze** ❄️ — committing the frozen region (Grounds / Specification /
-  Acceptance Criteria) *before* dispatch (`architect freeze`). Records the
-  **freeze_sha** in `space.yaml`; any later change to those sections is an
-  automatic iteration FAIL.
-- **gate** — a structured entry in the ` ```gates ` block: `id`, `ac`, `cmd`,
-  optional `cwd`, and an `expect` hash (exit_code / stdout_match / threshold).
-  `architect gate` runs each gate's `cmd` and streams raw output — it is a runner,
-  never a judge. `architect freeze` lints the gates block before committing.
-
-**Outcomes**
-
-- **verdict** — the architect's ruling on an iteration, written after evidence:
-  - per-criterion: **PASS** / **FAIL** / **INVALID** (INVALID = not measured the
-    way the gate specifies).
-  - iteration-level: **KILL** / **CONTINUE**.
-- **variant set** — an iteration built as multiple `(harness, model)` lanes over
-  one frozen spec, judged head-to-head against the same Acceptance Criteria; the
-  winner is selected with the human in the loop, not unilaterally.
-
-**Research**
-
-- **research** — two scales:
-  - **discovery scale** (brainstorming, technology selection, state-of-the-art)
-    → the **`/architect-research`** skill: a scout maps the topic, the
-    orchestrator designs parallel researcher **lanes**, claims are verified
-    against sources, and the synthesis distills into a brief §section or an
-    iteration's Grounds.
-  - **iteration scale** → an inline fan-out run only when an iteration needs
-    facts the repo doesn't already have.
-
-**Repos**
-
-- **evergreen** / copy-on-write / **`src` engine** — repo provisioning: when an
-  up-to-date local copy exists under `src_dir`, `architect` copies it into
-  the space (copy-on-write on APFS) instead of cloning over the network. The
-  `src` engine (`space-src`) keeps those evergreen checkouts tended.
-
-## Where you are
-
-A space's directory layout:
-
-```text
-space.yaml        # identity + project state (the project: block)
-README.md
-repos/            # the repos the project spans
-notes/            # scratch, prompts, logs
-architecture/     # ARCHITECT.md index + I<NN>-<name>.md iteration files (+ BRIEF.md)
-build/            # lane worktrees + scratch: build/<id>-<lane>/
-tmp/              # workspace-local temp — use instead of /tmp
-```
-
-Safe **read-only** commands to orient yourself (these don't run the loop):
-
-```sh
-architect status            # project state: iterations, freeze shas, lanes, verdicts
-space show                  # the space you're standing in (space-cadet binary)
-space list                  # all your spaces
-```
-
-## Maintenance
-
-This glossary is a **self-contained copy** of terms defined canonically in the
-`architect` skill (`SKILL.md`) and the project `README.md`. It is installed as an
-isolated skill, so it can't reference those at runtime — when the vocabulary
-changes there, re-read this file against them and update it to keep the two from
-drifting.