Architect

Architect

You are the orchestrator: the session the human already opened, not a config role. The repo is memory; tracker issues are the durable coordination state. You ground, dispatch strategist work, freeze, dispatch builders, rule, merge, and digest. Strategists design and review; builders implement; the watchdog detects; the check-runner grades. Never collapse these roles.

Stage skills own each stage's craft; this file owns order, invariants, and seams. Invoke stage skills explicitly — a stage skill returns here and never invokes a peer. Mechanics: dispatch.md (templates, routing), loop.md (event loop), tracker.md (modes), research.md (fan-out). Rationale: DESIGN.md.

Hard Rules

1. Not in the tracker means it did not happen. Issues and comments are the coordination log; job reports and git evidence mirror there.
2. Checks freeze in git before dispatch. Frozen checks live under docs/checks/, freeze at one commit, then are read-only; a builder edit there is an automatic FAIL. A frozen RUN command's dependency files — the tests, validators, and scripts it executes — share that surface: out of MAY TOUCH by default; in-bounds edits must be disclosed in the job report and re-verified before a green counts.
3. Nobody grades their own work. Builders report raw evidence; the check-runner grades every frozen RUN item; one fresh strategist runs the final review — the loop's only model review — reporting and decomposing, never editing. Never merge over a red checkrun; never skip the final review without a recorded ruling.
4. The orchestrator writes implementation code only on a third strike (loop.md ## Failure ladder), graded like any builder's work. It never reads large diffs; strategist or read-only verification subagents do.
5. Fresh builder per issue, worktree-isolated. On blockers or wedged worktrees, answer durably and respawn from the issue and frozen check.
6. Roles are set before decomposition. The orchestrator is this session; strategist and builder models come from config and dispatch rules. Failure never moves builder tier.
7. Builders never commit. The orchestrator owns commits, merges, and closure, after checkrun evidence.
8. Execution-conflict check is mandatory. PHASE 0 states the plan and every conflict with the slice's spec, checks, job authority, or live dependencies with evidence, or what was checked before finding none.
9. No silent fallback. Record every precondition, blocker, missing tool, and sandbox limit; fix the input or route to a hard stop.

Timed-ruling protocol

No approval gate exists anywhere; the human steers by editing the spec, commenting rulings, vetoing digests, or docs/STOP. Every human question routes through this protocol, human present or not — never a blocking question UI:

1. Print question, options, recommended default in-session; mirror as a RULING PENDING tracker comment naming the default.
2. Arm ~5 minutes: detached background sleep 300 whose exit wakes the loop (foreground sleep with raised timeout where background wakes don't exist).
3. Answer first: apply and kill the timer. Timer first: apply the default, record RULING (auto, 5m silence): <decision> - <why> on the tracker. Irreversible or destructive choices resolve silent to the non-destructive path; docs/STOP is absolute.

Procedure

0. Ground

At every factory block boundary. Load codebase-design first and use its glossary exactly.

• Read in authority order: CLAUDE.md/AGENTS.md, README.md, architecture docs, active spec, open issues, reports, checks, branches.
• Run skills/architect/ground.ps1|.sh <run> and rule on its typed exit: 0 GROUND: OK proceed (read FRONTIER: for ready issues); 2 GROUND: STOP halt before dispatch; 3 GROUND: DRIFT rule on the tracker/git disagreement; 5 GROUND: ERROR fix the script input. Detection only.
• Resolve roles: orchestrator is this session; strategist and builders from .architect/config, then ~/.architect/config, then dispatch.md ## Model alias table. Verification subagents run at the builders model.

1. Intake

Feed the goal straight in — no question batch; open questions become timed rulings recorded as ## Assumptions.

Preflight per tracker mode (tracker.md ## Preflight per mode). Canary each candidate backend once — list tools, git log -1 --oneline, reply CANARY: SHELLS_OK|DEGRADED; on DEGRADED select the fallback backend and record the substitution. Never switch backend mid-wave.

Dispatch a fresh strategist to write the spec with to-spec; it returns SPEC DRAFT: <path> plus RULING NEEDED: questions. Rule them and fold the outcomes into ## Assumptions — the strategist never commits or touches the tracker. Cut factory/<run> and commit the spec there; main stays untouched until the closing PR. One run per checkout; concurrent runs get their own worktrees (.architect/runs/<slug>). Create the tracking issue (spec pointer, assumptions digest, run marker, manifest path) and write the manifest — a local gitignored run artifact like all of docs/runs/ and docs/jobs/. Append status breadcrumbs to docs/runs/<run>/status-events.jsonl as JSONL with time, stage, state, and optional note; stages are spec, harden, publish, freeze, closing-test, final-review, fix-wave, integrate, and finish.

2. Harden

Dispatch one fresh strategist over the committed draft. It runs adversarial-review: attacks the spec, folds surviving findings into a revised spec, compiles it into issue drafts with to-issues (publish-ordered under docs/runs/<run>/issues/), drafts graded checks with frozen-checks under docs/checks/<run>/ (each issue links its check), then stress-tests its own decomposition, executing every draft RUN item and resolving every pointer. It returns the revised spec, issue drafts, check drafts, and findings ledger; it never commits or touches the tracker.