devrites 1.19.0

package/pack/.claude/rules/afk-hitl.md

@@ -0,0 +1,245 @@
+# AFK & HITL — the pause/resume contract
+
+The rule layer for DevRites's two run modes. Every `rite-*` and `devrites-*` skill that
+might pause for a human reads from this contract; `/rite-build`, `/rite-status`,
+`/rite-resolve`, and `devrites-doubt` are the primary callers.
+
+The contract is intentionally small: one sentinel, one queue, one verb.
+
+## Run modes
+
+- **HITL (default)** — human is present. At a gap/checkpoint the skill **asks inline** via
+  the harness `AskUserQuestion` tool — a ranked **option set** (recommended first, each with
+  dimension-tagged rationale; see [Option set](#option-set--how-every-gap-is-presented)). The
+  human picks; the skill records the pick to `questions.md` (`answered`) + `decisions.md` and
+  **continues in place — no `/rite-resolve` round-trip**. `/rite-resolve` is only for answering
+  **async** (a pause that already stopped the session) or in **batch**.
+- **AFK** — `.devrites/AFK` is present. For any gate AFK may auto-handle (severity in
+  `allow_gates`), the skill **auto-picks the recommended option** (option 1 of the set), records
+  it (`gate: advisory` + a `decisions.md` ADR), and continues unattended. Gates above the
+  ceiling — and every irreversible-risk item — pause and queue a `questions.md` entry for
+  `/rite-resolve`, **unless `allow_irreversible: true`** is set (see [Maximal
+  autonomy](#irreversible-risk-list-always-pause)).
+
+`.devrites/AFK` presence is authoritative for run mode; gate-deciding skills re-read the
+sentinel at decision time (the shared preamble derives the mode from it). There is no
+`state.md` run-mode field to drift out of sync.
+
+## The sentinel — `.devrites/AFK`
+
+Presence = AFK active. The file body is optional YAML:
+
+```yaml
+max_slices: 10                       # read-only INITIAL budget; seeds state.md `AFK slices remaining`
+notify: "ntfy.sh/my-topic"           # shell command run on awaiting_human transition
+allow_gates: [advisory, validating]  # gate severities AFK auto-handles (auto-picks the recommended option)
+allow_irreversible: false            # DANGER, opt-in. true → auto-pick the recommended option even on
+                                     # irreversible gates (drop-table, auth, public-API break, data-loss).
+                                     # Lifts the safety floor; destructive changes ship unattended. Default false.
+```
+
+The file is **read-only config** — never rewritten in place. `max_slices` is the initial
+budget; the mutable remaining count lives in `state.md` as `AFK slices remaining: <n>`,
+seeded from `max_slices` on the first AFK build and decremented by `tick-afk.sh` (which
+exits non-zero at 0, forcing a HITL stop). The cap is enforced by the script, not prose.
+
+Missing keys fall back to defaults:
+
+| Key | Default | Meaning |
+|---|---|---|
+| `max_slices` | unlimited | a missing cap is unsafe; recommend setting one explicitly |
+| `notify` | none | no notification fires |
+| `allow_gates` | `[advisory]` | AFK auto-handles advisory only by default (auto-picks the recommended option) |
+| `allow_irreversible` | `false` | when `true`, AFK auto-picks even irreversible-risk gates — the safety floor is lifted (see [Maximal autonomy](#irreversible-risk-list-always-pause)) |
+
+To leave AFK, delete the file. The next skill invocation reverts to HITL.
+
+## The four gates
+
+Every `Mode: HITL` slice declares a `Gate:` and an `SLA:`. See
+[`.claude/skills/rite-define/reference/gates.md`](../skills/rite-define/reference/gates.md)
+for the full taxonomy. Summary:
+
+| Gate | Stakes | Pause? | SLA | AFK auto-handle when in `allow_gates`? |
+|---|---|---|---|---|
+| advisory | low | no | none | yes (log + proceed) |
+| validating | medium | async | 4h | yes (build + queue, no merge until resolved) |
+| blocking | high | sync | 15m | **no** — always pauses |
+| escalating | novel pattern | sync to specialist | 24h | **no** — always pauses |
+
+`blocking` and `escalating` always pause regardless of `allow_gates`. They are the
+"AFK never silently accepts" guarantees in protocol form.
+
+An open `gate: validating` entry is **merge-blocking by definition**: at `/rite-seal` any
+`questions.md` entry with `gate: validating` and `status: open` is a NO-GO, regardless of
+its behavior impact. A slice marked `built (pending review)` is **not done** until that
+validating gate resolves.
+
+## Option set — how every gap is presented
+
+Wherever a gap, checkpoint, or non-trivial decision surfaces (`/rite-spec`, `/rite-define`,
+`/rite-build`, `/rite-temper`, `/rite-vet`, `devrites-doubt`, `devrites-interview`), present a
+**ranked option set**, never a single bare guess:
+
+- **2–4 concrete options**, the **recommended one first**, labelled `(Recommended)`.
+- Each option carries a **one-line rationale tagged by the dimensions that matter** —
+  `logic · infra · business · architecture` (add `security` / `UX` / `risk` when in scope).
+  Name the trade-off, not just the choice.
+- Always include an escape hatch (`Something else — I'll describe it`).
+- The recommendation reflects what's best for *this* project (its conventions, stack, scale,
+  domain) — not a generic default.
+
+**HITL** renders the set via `AskUserQuestion` (recommended option first; rationale in each
+option's description); the human's pick resolves the gate **in place**. **AFK** auto-picks
+option 1 (the recommendation) for gates it may auto-handle. Either way the chosen option is
+recorded verbatim and the **rejected options stay in `questions.md`** as the considered-alternatives
+trail — the audit shows what was weighed, not just what was decided.
+
+## Irreversible-risk list (always pause)
+
+The following always invoke the checkpoint protocol, regardless of `Mode`, `Gate`, or
+`allow_gates`:
+
+- Destructive data migration (drop column, drop table, irreversible backfill).
+- Auth / authz boundary change.
+- Public API break (response shape, removed endpoint, changed status code semantics).
+- External-service contract change.
+- Filesystem destruction outside the workspace.
+- Red tests / types / lint on slice completion (fail-on-red).
+
+By default, AFK widens what's *automatic*; it never widens what's *irreversible*.
+
+**Maximal autonomy (`allow_irreversible: true` — opt-in, dangerous).** Setting this key in
+`.devrites/AFK` lifts the floor: AFK then **auto-picks the recommended option on irreversible
+gates too, with no pause**. This ships destructive migrations / auth changes / public-API
+breaks / data-loss paths **unattended, with zero human review** — recommended *only* on a
+throwaway or sandboxed target you can roll back wholesale. Default is `false`; a missing key
+keeps the floor. The floor is the deliberate safety default — `allow_irreversible` is the user
+pulling the trigger themselves, not something a stray sentinel can do silently.
+
+## `questions.md` schema
+
+Append-only. One entry per qid. Format:
+
+```markdown
+## q-YYYY-MM-DD-NNN
+status: open | answered | dropped
+slice: <slice id, e.g. 03-list-endpoint, or "spec" / "plan">
+gate: advisory | validating | blocking | escalating
+question: <one crisp sentence>
+options: |                                    # ranked option set; recommended FIRST (see "Option set")
+  1. <recommended> (Recommended) — logic: … · infra: … · business: … · architecture: …
+  2. <alternative> — <dimension-tagged rationale + trade-off>
+  3. Something else — describe it
+proposed: <the recommended option restated — the HITL default + the AFK auto-pick>
+raised_at: <iso>
+answered_at: <iso, when status flips off "open">
+answer: <chosen option (or human's verbatim reply / drop reason)>
+```
+
+Rules:
+- `NNN` is sequential per date — the next-available 3-digit integer.
+- `status: open` is the only state `/rite-resolve` can mutate; `answered` and `dropped`
+  are terminal.
+- The file is the audit trail. Don't edit answered/dropped entries — open a new qid that
+  references the old one (`supersedes: q-...-OLD`) and resolve it.
+
+## `state.md` `Awaiting human` block
+
+When a HITL gate fires, `/rite-build` writes:
+
+```markdown
+- Status: awaiting_human
+- Next step: /rite-resolve <qid> "<answer>"
+
+## Awaiting human
+- qid: <q-...>
+- gate: <gate>
+- question: <crisp text>
+- proposed: <agent's tentative answer>
+- raised_at: <iso>
+- blocking_slices: [<slice ids that cannot advance>]
+```
+
+`/rite-resolve` removes the block on success and flips `Status: running`.
+
+## The resume verb — `/rite-resolve`
+
+Three shapes:
+
+```
+/rite-resolve <qid> "<answer>"
+/rite-resolve --drop <qid> ["<reason>"]
+/rite-resolve --batch <path-to-yaml>
+```
+
+`/rite-resolve` is the canonical writer for **async** resume — a gate that already paused and
+stopped the session (an AFK blocking/escalating/irreversible queue, or a HITL pause the human
+walked away from), plus `--batch`. In an **interactive HITL** session the skill resolves the
+`AskUserQuestion` pick **in place** (the same `questions.md` `answered` write + `state.md`
+clear), so you don't type `/rite-resolve` for gaps you answer live. Both paths flip
+`status: open → answered` and clear `Awaiting human` through the **same `resolve.sh` writer** —
+one source of truth, two entry points (live pick vs typed verb). Manual edits work but the
+script is the contract — use it.
+
+When `/rite-resolve` does resume a stopped session, the skill does **not** auto-run the next
+`/rite-build`. The user types the next command explicitly so:
+- A `/rite-plan repair` can land first if the answer changes scope.
+- The user sees the workspace state before resuming.
+- Each verb has one mutation; chaining is a hidden side-effect.
+
+## AFK exception for discretionary pauses
+
+`devrites-doubt` and similar skills that "ask the user" follow this rule when
+`.devrites/AFK` exists:
+
+- Finding severity ≤ slice's gate ceiling (slice's `Gate:` plus `.devrites/AFK`
+  `allow_gates`) → log to `questions.md` as `gate: advisory`, record the trade-off in
+  `decisions.md`, proceed.
+- Finding severity > gate ceiling, OR finding touches the irreversible-risk list →
+  log to `questions.md` as `gate: blocking`, set `state.md` `Status: awaiting_human`,
+  fire `notify:`, STOP.
+
+The loop limits of the calling skill still apply — after the limit, the unresolved
+doubt becomes a blocking question regardless of AFK config.
+
+## Retry cap, stuck loops, and self-resolve
+
+- **Cap retries.** At most **3 attempts** on the same failing check (test, lint, type, build).
+  On the third failure, stop guessing and convert it to a `gate: blocking` question — a fourth
+  identical attempt is thrash, not progress.
+- **Stuck loops pause even in AFK.** A detected loop — the same action repeating, or an
+  action↔error ping-pong — pauses regardless of `allow_gates` (`stuck.sh`), the same standing as
+  the irreversible-risk list. AFK widens what's automatic, never what's looping.
+- **Bias to self-resolve.** Before raising a question, try to answer it from the code, the docs,
+  or `decisions.md`. Communicate only for a blocked environment, a deliverable to hand over,
+  critical info you genuinely can't access, or a credential / permission you lack. This narrows
+  needless pauses and never weakens the blocking / escalating / irreversible gates.
+- **Human time is for human-only work.** A `human_intervention` pause is for what the agent
+  literally cannot do (create a cloud account, click a console button) — never for writing code,
+  writing tests, or reviewing. Punting the agent's own job to the human is not a valid gate.
+
+## What the rule does NOT cover
+
+This contract is about **human pauses**. It does not weaken or replace:
+
+- `/rite-prove`, `/rite-review`, `/rite-seal` — feature-scoped gates that always run.
+- Spec Drift Guard — answer that changes acceptance criteria routes through
+  `/rite-plan repair`, not silently into the slice.
+- `evidence.md` writes — every AFK iteration still records evidence; un-recorded passes
+  are unproven at `/rite-prove`.
+- `/clear` / `/compact` advice — context-hygiene rules are unchanged.
+
+AFK shifts the boundary between automatic and "ask"; nothing else.
+
+## Cross-reference
+
+- Skill: `/rite-resolve` (`.claude/skills/rite-resolve/SKILL.md`).
+- Workflow integration: `/rite-build` (`.claude/skills/rite-build/SKILL.md`),
+  workflow steps 0 + 2a (readiness / HITL pre-flight) and steps 4–6 (doubt / fail-on-red /
+  record) on the wright's return.
+- Render contract: `.claude/skills/rite-build/reference/checkpoint-protocol.md`.
+- Loop discipline: `.claude/skills/rite-build/reference/afk-discipline.md`.
+- Gate taxonomy: `.claude/skills/rite-define/reference/gates.md`.
+- Schema: `.claude/skills/rite-spec/reference/state-workspace.md`.
+- Doubt's AFK exception: `.claude/skills/devrites-doubt/SKILL.md` (AFK exception section).

package/pack/.claude/rules/agents.md

@@ -0,0 +1,98 @@
+# Agent orchestration
+
+DevRites uses **project-local** agents under `.claude/agents/` (never a global location).
+It separates three roles: **specialist skills** (model-invoked disciplines that run inline),
+**review subagents** (fresh-context, **read-only** reviewers spawned for independent judgment),
+and the **executor subagent** (`devrites-slice-wright` — fresh-context but **write-capable**,
+the one agent that produces code).
+
+## Review subagents — `.claude/agents/`
+Fresh-context, read-only reviewers. Each is given the active feature workspace path
+(`.devrites/work/<slug>/`) + the diff, and returns findings — they do **not** edit code.
+
+| Agent | Purpose | When |
+|-------|---------|------|
+| `devrites-spec-reviewer` | Does the diff implement the spec? Missing / partial / wrong criteria; scope creep | `/rite-review` (Spec axis); `/rite-seal` |
+| `devrites-code-reviewer` | Correctness / readability / architecture / maintainability | `/rite-seal`; after a slice |
+| `devrites-test-analyst` | Do the tests actually prove the acceptance criteria? | `/rite-seal` |
+| `devrites-frontend-reviewer` | UX flow, a11y, responsive, design-system, anti-AI-slop | `/rite-seal` on UI features |
+| `devrites-security-auditor` | Untrusted input, trust boundaries, secrets, deps | `/rite-seal` when input/auth/data in scope |
+| `devrites-performance-reviewer` | Measure-first perf (N+1, hot paths, payload size) | `/rite-seal` when perf relevant |
+| `devrites-simplifier-reviewer` | Behavior-preserving simplification (Chesterton's Fence, deletion test) — Suggestion-only by design | `/rite-polish` Phase 1; `devrites-audit simplify` |
+| `devrites-doubt-reviewer` | Adversarial check of a single claim/decision | `devrites-doubt` loop; risky decisions |
+| `devrites-strategy-reviewer` | Spec-vs-rubric strategic review (ambition / scope / premise / pre-mortem / YAGNI / testability / irreversibility / cross-cutting / convention) — **before** any plan or code | `/rite-temper` loop (pre-plan) |
+| `devrites-plan-reviewer` | Plan-vs-rubric engineering review (architecture / scope-reuse / plan code-quality / test-coverage design / performance / reversibility / failure-mode coverage), confidence-banded with a quote-the-source verification gate — **after define, before build** | `/rite-vet` loop (pre-build) |
+
+## The executor subagent — `.claude/agents/devrites-slice-wright.md`
+
+The system's one **write-capable** agent, and the mirror of the reviewers: where a reviewer
+reads a finished diff in a fresh context, the wright **writes** one slice in a fresh context.
+
+| Agent | Purpose | When |
+|-------|---------|------|
+| `devrites-slice-wright` | Turn ONE fully-specified slice contract into the smallest complete, idiomatic, proven implementation — orient → TDD → verify, anti-AI-slop, feature scope only | `/rite-build` — the build-core dispatch step |
+
+`/rite-build` is the orchestrator: it owns the gates and the workspace, dispatches the wright
+for the implementation, then doubts, gates, and records the return. Tools:
+`Read, Edit, Write, Bash, Glob, Grep` (+ a code-intelligence index when present). It writes
+**code and tests only** — never the `.devrites/` bookkeeping files; it returns that data and
+the orchestrator persists it, so there is exactly one canonical writer of workspace state and
+the HITL/AFK contract stays intact. **Single-threaded: one wright per slice, never a parallel
+fan-out of writers** (concurrent writers make conflicting implicit decisions). Contract + return
+shape + fallback: `.claude/skills/rite-build/reference/wright-dispatch.md`.
+
+## Namespaces — `rite-*` is the user surface; `devrites-*` is internal
+
+The prefix mirrors visibility:
+
+- **`rite-*`** = user-invocable (`user-invocable: true`). The public slash-command
+  surface — lifecycle phases plus utilities. `rite`, `rite-spec`, `rite-temper`,
+  `rite-define`, `rite-vet`,
+  `rite-plan`, `rite-build`, `rite-prove`, `rite-polish`, `rite-review`, `rite-seal`,
+  `rite-ship`, `rite-autocomplete`, `rite-status`, `rite-resolve`, `rite-prototype`,
+  `rite-handoff`, `rite-zoom-out`, `rite-pressure-test`. `/rite-seal` **decides**
+  GO/NO-GO and writes the verdict; `/rite-ship` **executes** the irreversible git
+  ladder and **closes** the task (archives the workspace, clears `.devrites/ACTIVE`).
+  `/rite-autocomplete` drives the whole lifecycle unattended.
+- **`devrites-*`** = model-invoked (`user-invocable: false`, no slash command).
+  Internal specialists that fire on trigger from the `rite-*` skills or auto-select.
+  `devrites-interview`, `devrites-source-driven`, `devrites-doubt`,
+  `devrites-ux-shape` (plans UX/UI into `design-brief.md` at `/rite-spec` when UI is
+  detected — the build target), `devrites-frontend-craft`, `devrites-prose-craft`
+  (human-voice prose for artifacts + replies; the catch pass in `/rite-polish`),
+  `devrites-browser-proof`,
+  `devrites-debug-recovery`, `devrites-api-interface`, `devrites-audit` (dispatches the
+  security / perf / simplify reviewer subagent on an axis argument).
+  The `devrites-` prefix avoids collisions with bundled Claude Code skill
+  names (`prototype`, `handoff`, `diagnose`, etc.) — peer skill packs may
+  collide on the bare names internally even though these never appear in the
+  user's slash menu. Parallel reviewer fan-out at `/rite-seal` is no longer
+  a skill — it lives as a reference file
+  (`.claude/skills/rite-seal/reference/parallel-dispatch.md`).
+
+The `/rite` menu carries the routing previously held by `devrites-selector`, which
+has been removed. `user-invocable:` in each `SKILL.md` is the source of truth; the
+prefix is a naming convention that matches it.
+
+## When to bring in a reviewer (no prompt needed)
+1. Standing a non-trivial decision (boundary, data model, auth, public API, migration) →
+   `devrites-doubt` → `devrites-doubt-reviewer`.
+2. Sealing a feature → fan out to the relevant reviewers above.
+3. A UI feature at seal → include `devrites-frontend-reviewer`.
+4. Input/auth/data/integration in scope → include `devrites-security-auditor`.
+
+## Rules
+- Run independent reviewers **in parallel** at the seal, then reconcile; surface
+  disagreements explicitly rather than averaging them away.
+- Reviewer read-only is **enforced at the tool layer**, not just promised: each reviewer
+  carries a shared deny-mutating-Bash frontmatter hook (`devrites-reviewer-readonly.sh`). A
+  fresh-context reviewer reads untrusted source — a silent write path would be a prompt-injection
+  surface.
+- **Reviewer** agents are **read-only** and return labeled findings (Critical / Important /
+  Suggestion / Nit / FYI). Keep review **feature-scoped**.
+- The **executor** agent (`devrites-slice-wright`) is the one **write-capable** agent: it writes
+  code + tests for a single slice and returns a structured artifact, but it never writes the
+  `.devrites/` workspace files (the orchestrator does) and never runs in parallel with another
+  writer.
+- Give each agent the contract (workspace + diff for a reviewer; the slice contract for the
+  wright) without the author's reasoning — fresh, undirected context is the point.

package/pack/.claude/rules/anti-patterns.md

@@ -0,0 +1,48 @@
+# DevRites — universal anti-patterns
+
+The pack-wide rationalizations the agent reaches for when discipline gets in
+the way. Apply at every phase. Each `rite-*/reference/anti-patterns.md`
+extends this with phase-specific items.
+
+This file is the **single source** of the universal anti-rationalization table.
+`core.md` carries only a minimal 5-row subset (its first five rows are
+byte-identical to the matching rows below); read this file for the full set.
+
+## Universal rationalizations
+
+| Excuse | Rebuttal |
+|---|---|
+| "I'll add the tests later." | Tests written after the fact don't drive design and miss the boundary cases the act of writing exposes. Test now or the tests you eventually write are worse. |
+| "Lint and build pass — that proves quality." | Automation proves syntax and style, not design or correctness. Never cite clean automation as evidence of good design. |
+| "It's only a small refactor while I'm in here." | Feature scope only — drive-by cleanup balloons the diff, hides intent, and gets rejected at seal. Record as an FYI follow-up. |
+| "This is a special case, the pattern doesn't apply." | Special cases multiply silently. Either they really are special (record *why* in `decisions.md`) or they're not (and the pattern wins). |
+| "The user will tell me if something is wrong." | Drift detection is the workflow's job, not the user's QA. Surface assumptions; route material questions through the Spec Drift Guard. |
+| "Generic name (`processData`, `handleItem`) is fine — the code is self-evident." | Generic AI naming is slop. Match the project's idiom; one concept gets one word across the codebase. |
+| "Better safe than sorry — add the defensive null/length check." | Over-defensive guarding is slop. Validate at boundaries; trust the core. A check inside trusted code hides bugs in the boundary. |
+| "It's faster to skip the small step." | Process shortcuts pay back later as drift, missed criteria, or unrecorded decisions. The step is the point. |
+| "I observed it pass; recording is bureaucracy." | Un-recorded pass = unproven. The next phase reads `evidence.md`, not your memory. |
+| "User clearly wants this, so I'll bypass the gate." | Gates exist for the failure modes asks miss. Honor the gate; the gate exists *because* of the ask. |
+| "The test is failing — I'll just skip it / loosen the assertion to get green." | Faking green is reward-hacking, not progress. Never delete / skip / `xfail` / `.only` / loosen a failing test — a red test means fix the code or agree the change. A weakened test is a Critical finding (`test-integrity.sh`). |
+
+## Pack-wide red flags
+
+These show up at any phase and are equally damning regardless:
+
+- Touching files that aren't in `touched-files.md` "while I'm here".
+- A finding / decision / assumption recorded only in chat, not in the workspace files (it dies on `/clear`).
+- Catching the broadest possible error and continuing past it.
+- A test that asserts the implementation, not the behavior.
+- A failing test deleted, skipped, `xfail`-ed, `.only`-narrowed, or loosened to make the suite pass.
+- Commenting out code instead of deleting it.
+- A `// TODO` left in shipped code.
+- Adding a dependency or a second design system without rationale in `decisions.md`.
+- "I'll fix it in a follow-up PR" with no follow-up actually opened.
+
+## Where this gets loaded
+
+Each `rite-*/reference/anti-patterns.md` opens with a pointer back here
+(written as a relative link in the form `../../../rules/anti-patterns.md`
+from the per-phase reference file), then lists only the **phase-specific**
+rationalizations + red flags that don't fit here. When the agent is
+reluctant, it reads the phase file first, then this file if the reluctance
+is broader than the phase.

package/pack/.claude/rules/code-review.md

@@ -0,0 +1,38 @@
+# Code review
+
+The reviewer's one question: **does this change make the codebase healthier** — clearer
+design, cleaner logic, better tests, fewer risks? If not, it doesn't merge yet.
+
+## Keep changes small
+- One concern per change (a fix, an endpoint, a refactor) — not three at once.
+- Aim for small diffs: under ~200 lines reviews well and merges fast; treat ~400 as a
+  soft ceiling and self-split beyond it. Large diffs hide defects and get rubber-stamped.
+
+## What to check (tests first)
+1. **Tests** — do they exist and prove the behavior + failure modes (empty, error,
+   boundary, concurrency)? Would they fail if the code were wrong?
+2. **Correctness** — logic, edge cases, error paths, race conditions, wrong assumptions.
+3. **Readability** — names, function size, control flow, intent obvious without the author.
+4. **Architecture** — right seam, coupling/cohesion, fits existing patterns, no premature
+   abstraction. How does it fit the bigger system, not just what it does?
+5. **Security** — trust boundaries, input validation, authz, secrets.
+6. **Risk** — migrations, destructive changes, rollback.
+
+## Give actionable feedback
+- Label severity so the author knows what blocks: **Critical / Important / Suggestion /
+  Nit / FYI**.
+- Be specific: point at the line, name the problem, propose the fix. Frame non-blocking
+  ideas as questions ("what about a map here for readability?").
+- Let automation (linters, formatters, CI) catch the trivial stuff so review focuses on
+  design and correctness.
+
+## Scope discipline
+Review the change, not the whole project. Out-of-scope problems become follow-ups, not
+drive-by edits that balloon the diff.
+
+## Charter & conventions are a pass/fail gate
+The anti-slop charter and the project conventions ledger (`.devrites/conventions.md`) are not
+advisory at review time — they are evaluated as explicit pass/fail at `/rite-vet` and re-checked
+after design lands. A change that violates a stated convention or trips the charter is a
+**Critical** finding, not a Nit; record it with `file:line` and block on it the same as any
+correctness defect.

package/pack/.claude/rules/coding-style.md

@@ -0,0 +1,55 @@
+# Coding style
+
+Write code the next engineer can read without you in the room. Match the project's
+existing idiom first; these rules fill the gaps.
+
+## Names reveal intent
+- A name should answer *what is this and why*. `daysSinceLastModification`, not `d`.
+- Avoid generic verbs that hide intent: `process()`, `handle()`, `doWork()`, `manage()`.
+- Be consistent: the same concept gets the same word across the codebase. Don't alias
+  `user` / `account` / `member` for one thing.
+
+## Functions do one thing
+- One responsibility per function; if you need "and" to describe it, split it.
+- Keep functions short enough to hold in your head. Long functions hide bugs.
+- Limit parameters; a long parameter list usually wants a struct/object or a split.
+- Make edge cases explicit rather than implicit in clever control flow.
+
+## Guard clauses over nested pyramids
+Handle the unwanted cases up front and return early; keep the success path flat.
+```
+# instead of nesting the whole body in if/else, exit early:
+if (!user) return Unauthorized
+if (!user.active) return Forbidden
+# ...happy path here, un-nested
+```
+
+## Comments explain *why*, not *what*
+- Self-explanatory code beats a comment restating it. Rename before you comment.
+- Reserve comments for intent, trade-offs, non-obvious constraints, and "here be
+  dragons" warnings. Delete commented-out code — that's what version control is for.
+
+## Simplicity
+- Prefer the simplest thing that works. Don't add abstraction before you have two real
+  callers; premature generalization is a cost, not a saving.
+- Don't be clever at the expense of clear. Shorter-but-cryptic is not simpler.
+- Delete dead code you created; don't leave TODOs or stray debug logs in shipped code.
+
+## Reuse before you write
+Before adding a new util, helper, hook, type, component, or formatter, **search** for an
+existing one. **Reuse → extend → build new**, in that order. Don't re-implement what the
+project (or stdlib) already provides. If forcing reuse would distort the existing thing's
+shape, build a sibling and consolidate later — duplication is cheaper than the wrong
+abstraction (AHA).
+
+## Edit reliably, change only what's asked
+- **No elision.** Never write `// ... rest unchanged` / `# ... existing code` in place of an
+  edit — emit the whole coherent function. Don't anchor an edit on line numbers; match on the
+  surrounding code. If an edit fails to apply, **re-read the file before retrying** — it may
+  have changed under you.
+- **Do what's asked, no more — and no less.** Don't improve, comment, or refactor code unrelated
+  to the task while you're in the file (feature scope). And never leave a comment describing code
+  you didn't write — implement it.
+- **Never hand-edit a manifest or lockfile.** Add / update / remove dependencies through the
+  package manager (`npm install`, `pip install`, `go get`, `cargo add`) so the lockfile stays
+  consistent — don't paste a version into `package.json` / `requirements.txt` by hand.

package/pack/.claude/rules/context-hygiene.md

@@ -0,0 +1,97 @@
+# Context hygiene
+
+Long conversations degrade an agent's reasoning quality. The fix is operational, not
+mystical: end phases cleanly, persist what matters to disk, and start the next phase
+in a fresh context.
+
+DevRites is uniquely well-suited to this because its workspace
+(`.devrites/work/<slug>/`) already stores everything the next session needs —
+`spec.md`, `plan.md`, `tasks.md`, `state.md`, `decisions.md`, `evidence.md`,
+`questions.md`, `assumptions.md`, `drift.md`, `touched-files.md`, `review.md`. None
+of those live in chat memory.
+
+## Why long contexts hurt (research-backed)
+
+- **Lost-in-the-middle** (Liu et al. 2023). Models attend strongly to the start and
+  end of their context and **systematically under-attend the middle**. Performance
+  drops by ~30% on retrieval and reasoning tasks when load-bearing information shifts
+  from the edges to the centre.
+- **Context rot.** Even on simple tasks, accuracy degrades as input length grows. The
+  effect compounds for agent workflows: every tool call, file read, and failed attempt
+  pushes earlier load-bearing context toward the middle of the window.
+- **Failed-attempt amplification.** When an agentic task goes wrong and is corrected
+  in the same session, the failed attempt stays in context — doubling the token cost
+  and dragging the model toward the same kinds of mistake.
+- **The 50–70% threshold.** Published Claude Code guidance + community evidence
+  consistently land at the same number: **act on context at 50–70% used, not 95%.**
+  By 95% the model is already operating in the dump-zone.
+
+The summary the model can carry is *not* a substitute for the workspace; the workspace
+is the source of truth.
+
+**Compaction-preservation directive.** When the harness summarizes or compacts mid-feature,
+always preserve these four — they are the cursor, and losing them to a summary forces the next
+agent to re-derive state the workspace already holds: the `.devrites/ACTIVE` slug, `state.md`'s
+`Next step`, every open `questions.md` gate, and `decisions.md`'s `Dead ends`. (The SessionStart
+orientation and the UserPromptSubmit cursor re-inject this each session and turn; this directive
+is the fallback for involuntary mid-session compaction, where no hook fires.)
+
+## `/clear` vs `/compact`
+
+| Use `/clear` (default) when | Use `/compact` when |
+|---|---|
+| The current phase is done and its outputs are on disk (the common DevRites case). | You need to keep mid-flight reasoning that hasn't yet been written to the workspace. |
+| Next phase reads workspace files anyway (every `rite-*` does). | The remaining work is small and continuation beats restart. |
+| The chat is dominated by tool outputs (file reads, diffs, test logs, browser snapshots). | A drift or doubt loop is mid-flight and the trade-off discussion isn't yet recorded. |
+| You hit a wrong path that needs unwinding — fresh start beats arguing with stale context. | A user clarification just landed that materially changes the next phase. |
+
+**Default to `/clear`.** Reach for `/compact` only when continuity has real load-bearing
+value that the workspace doesn't capture. When in doubt, write the missing decision /
+assumption / question to the canonical file (`/rite-handoff` does this in one step),
+then `/clear`.
+
+## Phase-aware recommendation (DevRites lifecycle)
+
+| Phase | Typical context cost | After-phase recommendation |
+|---|---|---|
+| `/rite-spec` | HIGH — reads codebase, references, design assets. | **Strong `/clear`.** `spec.md`, `references/`, `decisions.md`, `assumptions.md`, `questions.md`, `brief.md` all captured. |
+| `/rite-define` | MED — reads spec + decides architecture. | **`/clear`.** `plan.md`, `tasks.md`, `decisions.md`, `state.md` captured. |
+| `/rite-plan` | MED — reshape / repair. | **`/clear`** if reshape was big; **keep** if only a small reorder. |
+| `/rite-build` | HIGH — reads files, writes code + tests, runs checks, often retries. | **Strong `/clear` between slices.** `state.md` cursor, `touched-files.md`, `evidence.md` carry the cursor forward. |
+| `/rite-prove` | HIGH — full test suite output, build logs, browser snapshots. | **Strong `/clear`.** `evidence.md`, `browser-evidence.md` captured. |
+| `/rite-polish` | MED-HIGH — diffs + design-system reads + per-target polish. | **`/clear` between targets.** `polish-report.md`, `browser-evidence.md` captured. |
+| `/rite-review` | HIGH — diff + parallel sub-agent reports + multi-axis review. | **`/compact`** if Criticals must be fixed in flow (review context informs the fix); **`/clear`** if review is clean. `review.md` captured. |
+| `/rite-seal` | MED — read-only fan-out + GO/NO-GO. | Usually session-end. **`/clear` after a GO**; `/compact` if NO-GO and the seal's findings drive immediate fixes. |
+| `/rite-status` | LOW (read-only). | **No recommendation** — cheap. |
+| `/rite` (menu) | LOW. | **No recommendation.** |
+
+## The "Session hygiene" footer (every rite-* output)
+
+Every `rite-*` skill ends its output with a one-line **Session hygiene** advisory, plus
+the **single command** that resumes work next session:
+
+```
+Session hygiene: /clear (recommended)   — <one-line why, anchored to what just got persisted>
+Resume next session with: <single command, e.g. /rite-build slice 2>
+```
+
+The advisory is advisory, not a gate. The user can ignore it. But it surfaces the
+trade-off the model itself can't reliably introspect (no API for "how full is my
+context") at the exact moment the next decision is cheap.
+
+## When NOT to recommend `/clear` or `/compact`
+
+- The current phase is read-only and cheap (`/rite-status`, `/rite` menu) — no
+  recommendation; let the user keep their flow.
+- The user just landed material clarification that changes the next phase — write the
+  clarification to the workspace (`decisions.md` / `assumptions.md`) before suggesting
+  any session reset, otherwise the clarification dies in chat.
+- A drift / doubt loop is mid-flight — finish the loop and record the verdict first.
+
+## The handoff bridge
+
+When the user is leaving for a long break (not just between phases), `/rite-handoff`
+is the stronger move than `/clear` alone: it syncs chat-only context into the canonical
+workspace files **before** the reset, then the user can `/clear` (or even close the
+session) without losing anything. The session-hygiene footer points at `/rite-handoff`
+when the gap to the next session is likely > a few hours.