devrites 2.6.1 → 3.0.1

package/pack/generated/claude/skills/rite-converge/reference/convergence-assessment.md

@@ -0,0 +1,61 @@
+# Convergence assessment — built / partial / absent
+
+The rubric `/rite-converge` applies to every unit of intent. Load when running step 2–5.
+
+## The unit set
+
+Assess three kinds of unit against the live code:
+
+1. **Acceptance criteria / scenarios** — each buildable `AC-###` and each `#### Scenario:`
+   (WHEN/THEN) in `spec.md`. `## Success metrics` lines are **not** units — they carry no
+   `AC-###` id, no slice can satisfy them, and this pass never enqueues one (`spec-grammar.md`).
+2. **Plan touch-points** — the files/components/modules `plan.md` says get built or edited, and
+   each existing slice's stated **Produces** (the interface it was meant to expose).
+3. **Principles** — each invariant in `.devrites/principles.md`, checked against the code as it
+   stands.
+
+## The three verdicts
+
+For each unit, decide **built / partial / absent** — and only *partial* and *absent* enqueue a
+slice.
+
+| Verdict | Test | Action |
+|---|---|---|
+| **built** | The behavior exists in the code **and** a test covers it (a criterion with code but no covering test is not built — `testing.md`). | Nothing — do not append. |
+| **partial** | Some of it exists: happy path only, un-wired, untested, a TODO stub, or an edge case from the scenario's WHEN/THEN missing. | Append a slice for the **remainder**, its `Known-Gotchas` naming what's already there so `/rite-build` extends rather than rebuilds. |
+| **absent** | No code implements it. | Append a full slice. |
+
+Read the code to decide — do not infer from the plan. Use the code-intelligence index
+(codebase-memory-mcp → codegraph → graphify, else LSP / grep) so the verdict reflects live
+code, not the artifacts' claims. `devrites-engine analyze` / `devrites-engine coverage` tell you what's
+*mapped*; only reading the code tells you what's *built*.
+
+## Principle violations
+
+A live violation of a declared invariant (secret in logs, money as float, a datastore added
+with no ADR) is the **top-severity** gap regardless of coverage. It sorts **first** in the
+appended batch as a remediation slice, and — because reshaping to honor an invariant can be an
+irreversible-risk change — it pauses for a human even under AFK. Absent/empty principles file →
+none declared → skip, never block.
+
+## Spec drift vs code gap
+
+Before appending a slice, separate the two failure directions:
+
+- **Code gap** — the spec is right, the code falls short. → append a slice. (This skill's job.)
+- **Spec drift** — the code is right, the requirement is stale or wrong. → **do not** append a
+  slice that bends correct code to a wrong spec. Stop, route through the Spec Drift Guard
+  (`rite-build/reference/spec-drift-guard.md`) + a recorded decision, and let `/rite-plan
+  repair` reshape intent. Convergence enqueues work; it never launders a spec bug into a code
+  task.
+
+## Numbering + ordering the appended batch
+
+- **Continue the ids** — the highest existing `SLICE-###` + 1, ascending. Never reuse or
+  renumber an existing id.
+- **Order after the existing slices**, dependency-first among the new ones (`depends_on`);
+  a principle-remediation slice sorts before feature gaps.
+- **Mark each** with `Convergence: <iso>` so a later reader (and `/rite-status`) can tell an
+  original slice from a converged-in one.
+- **Nothing unmet → append nothing.** No batch header, no marker, `tasks.md` byte-for-byte
+  unchanged.

package/pack/generated/claude/skills/rite-customize/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: rite-customize
+description: User-invoked helper for authoring DevRites overrides or extensions.
+argument-hint: "[override <agent> | extension <name>]"
+user-invocable: true
+disable-model-invocation: true
+---
+
+# /rite-customize — guided project customization
+
+Create, list, validate, or scaffold one project-local DevRites customization without forking the pack.
+
+Read [`devrites-lib/reference/standards/core.md`](../devrites-lib/reference/standards/core.md), then read `docs/extensions.md` if present; in an installed project, fall back to `.claude/skills/devrites-lib/reference/standards/core.md` plus the user's installed DevRites docs if available.
+
+Fast paths:
+- `list` → run `devrites-engine overrides list` and `devrites-engine extensions list`; stop.
+- `validate` → run both validators; stop.
+- `scaffold extension <name>` → create the smallest valid `.devrites/extensions/<name>/skill/SKILL.md` draft after approval, then validate.
+
+## Workflow
+
+1. **Classify the ask.** Pick exactly one target:
+   - `list` → inspect only.
+   - `validate` → validate only.
+   - `override <agent>` → `.devrites/overrides/<agent>.md`
+   - `extension <name>` / `scaffold extension <name>` → `.devrites/extensions/<name>/`
+   - unclear → ask one blocking question with those options.
+   Done when the target kind and path are known.
+2. **Load the existing surface.** Read the existing file/dir if present. For overrides, confirm the target agent exists under `.claude/agents/` or `pack/.claude/agents/`. For extensions, check whether `skill/SKILL.md` or `agent.md` already exists. Done when you know whether this is create or update.
+3. **Draft the smallest artifact.**
+   - Override: write only added checks/emphasis. Do not restate base reviewer rules.
+   - Extension: create the smallest valid `skill/SKILL.md` or `agent.md` that matches the user's requested surface.
+   Done when the draft has no gate-waiver language and no global paths.
+4. **Show before writing.** Present the path and full content (or a concise diff when updating), then wait. **Completion:** the user explicitly approves or aborts.
+5. **Write and validate.** Create parent dirs, write the file(s), then run the matching validator:
+   ```bash
+   devrites-engine overrides validate
+   devrites-engine extensions validate
+   ```
+   If validation fails, fix the artifact once and re-run. Stop rather than guessing after a second failure.
+
+## Rules
+
+- Project-local only: write under `.devrites/overrides/` or `.devrites/extensions/`.
+- A customization may add checks or raise weight; it may never relax a gate, waive a standard, bypass `type-GO`, or write global config.
+- Sparse wins: do not copy shipped skills, agents, or standards unless the user explicitly asked for a new extension based on them.
+- Scaffold means a tiny valid skeleton plus a TODO body, not a generated framework.
+- No Codex mirroring by hand; extension sync is owned by `devrites-engine extensions sync`.
+
+## Output
+
+Reply-contract exception: customization utility; may run without an active feature.
+
+```
+Done: created|updated <override|extension>.
+Changed: <path(s)>
+Evidence: <validator command + result>
+Open: <none | validation error | user-aborted>
+Next: <devrites-engine extensions sync | /rite-doctor | none>
+Record: <path(s)>
+```
+
+## Gotchas
+
+- **Do not fork by accident.** If a reviewer override is enough, do not create a copied reviewer agent.
+- **Do not weaken gates.** “Ignore”, “waive”, “lower severity”, or “skip type-GO” means rewrite the customization or refuse it.
+- **Do not invent an extension surface.** If the user wants behavior outside DevRites' extension contract, say what the contract supports and stop.

package/pack/generated/claude/skills/rite-define/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: rite-define
+description: Define the first build plan from an approved spec: architecture, task slices, traceability, and state. Use when turning approved intent into its initial plan.
+argument-hint: "[feature-slug]"
+user-invocable: true
+---
+
+# /rite-define — plan from the spec
+
+Read the active feature's `spec.md` and turn it into a buildable workspace: feature
+architecture, approach, a dependency-ordered set of **vertical slices**, traceability, and
+the state cursor. The spec is the WHAT/WHY (from `/rite-spec`); this is the HOW. Splitting
+spec, architecture, plan, tasks, and traceability keeps each file small and phase-owned.
+**No code here.**
+
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+Pull these via `Read` when shaping the plan:
+- `development-workflow.md` — small batches, trunk-always-green, definition of done.
+- `principles.md` — the project invariants (`.devrites/principles.md`) the chosen approach must conform to.
+- `documentation.md` — record plan-time decisions and rationale.
+- `../workspace-artifact-schema.md` — artifact purposes, budgets, IDs, and read triggers.
+
+## Operating rules
+- **Requires a readied spec.** Read the active workspace first; if `.devrites/ACTIVE` is empty,
+  the workspace has no `spec.md`, its readiness gate hasn't passed, or any spec-quality
+  `checklists/<domain>.md` has an open CRITICAL → **STOP** and tell the user to run
+  `/rite-spec <feature>` first. **DO NOT plan from a missing or unreadied spec.**
+- Prefer existing conventions; ask before adding a dependency or a second design system.
+- **Author section by section, not in one dump.** Write `architecture.md` / `plan.md` one section
+  at a time and pause after each; a section resting on an open design choice or a shaky estimate can
+  be deepened right there with a technique from
+  [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) (Tournament for two viable
+  designs, Delphi for the estimate) before it hardens into slices.
+- **Slice count is derived, never dictated.** The number of slices falls out of the work
+  — one per independently-shippable increment, sized by `slicing.md`, every acceptance
+  criterion mapped to ≥1 slice. A user-named count is a hint at most: slice logically and,
+  if your honest count differs, present it and why. Never pad or compress to hit a figure.
+  (`.devrites/AFK` `max_slices` is a separate AFK iteration budget, not the decomposition.)
+- **Wide mechanical refactors slice expand → migrate → contract.** If one repeated change
+  crosses many files, don't fake vertical slices. Add a compatibility/adapter slice, migrate
+  small green batches, then remove the old path. If a batch cannot stay green, use an
+  integration branch plus a final verify slice.
+
+## Workflow
+0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** — the always-on operating rules and anti-rationalizations.
+   Then **run the shared orientation preamble** — it confirms the active feature and which
+   artifacts exist (it prints `state.md`, the artifacts present, the run mode, and the
+   open-question tally):
+   ```bash
+   devrites-engine preamble
+   devrites-engine snapshot
+   devrites-engine spec-skeleton ".devrites/work/$(cat .devrites/ACTIVE 2>/dev/null)"
+   ```
+   If there is no active workspace, no `spec.md`, `spec-skeleton` blocks, or its readiness gate hasn't passed →
+   **STOP** and tell the user to run `/rite-spec <feature>` first.
+1. **Read the spec** — `spec.md` (objective, requirements, acceptance, **placement**,
+   design references, gaps/decisions), plus `references.md`, `decisions.md`,
+   `assumptions.md`, **`strategy.md` if present** (the scope mode, deferred / out-of-scope
+   register, and pre-mortem risks from `/rite-temper` — cut slices to mitigate the top risks
+   and respect the IN/OUT line; map coverage against the **hardened** spec), and
+   **`design-brief.md` if the feature touches UI** (the UX/UI contract `/rite-spec` shaped —
+   its key states, interaction model, and proof targets drive how UI slices are cut). If a blocking
+   `[NEEDS CLARIFICATION]` remains, stop → `/rite-spec`.
+2. **Decide the architecture + approach** (the HOW the spec deliberately omitted): write
+   `architecture.md` for owning layer, boundaries, integration points, data/API/events,
+   dependencies, risks, and affected areas; write only the build strategy in `plan.md`.
+   Use a
+   code-intelligence index if available (see
+   `.claude/skills/devrites-lib/reference/standards/tooling.md`) for structure/impact; for the current API or behaviour of
+   an external library/framework the architecture will rely on, consult context7 if available.
+   Record significant options in `decisions.md` as `DEC-###` ADR entries.
+   **Deep-modules check** — while sketching the major modules, look for opportunities
+   to extract a **deep module**: a small, stable interface that hides a meaningful chunk
+   of behavior, and is therefore independently testable. A *shallow* module — interface
+   nearly as complex as its implementation — earns nothing; either deepen it or delete
+   it. Where a slice will produce a deep module, confirm with the user which deep
+   modules they want unit-tested in isolation (this informs the slice's "Tests to
+   write/run" field).
+3. **Slice into vertical tasks** — each delivers one observable capability end-to-end and
+   is verifiable on its own; the **count emerges from the work, not a target number**;
+   first slice = thinnest useful end-to-end path; order by dependency (risk-first within a
+   tier). For a broad mechanical refactor, use expand → migrate batches → contract instead
+   of pretending each touched file is a product slice; every migrate batch must stay green,
+   or route through an integration branch + final verify slice. Use `rite-plan/reference/slicing.md` and
+   `rite-plan/reference/task-breakdown.md`. Mark per slice: **Frontend craft required**
+   and **Browser proof required** (UI), and whether it's **fullstack** (FE+BE → contract
+   first, see `devrites-frontend-craft/reference/fullstack.md`). **For UI slices, name which
+   of `design-brief.md`'s key states + interaction the slice delivers, and give it a binary
+   **Visual acceptance** target (state × viewport × input + target R-id/brief rule)** — so
+   the design contract maps onto slices, not just acceptance criteria.
+4. **Map coverage** — every `AC-###` spec acceptance criterion maps to ≥1 `SLICE-###`
+   (`rite-spec/reference/acceptance-criteria.md`); no orphaned criteria, no slice without a
+   criterion. Lift covered/backstop `Edge Coverage` rows and resolved `Prohibitions (must-NOT)`
+   rows into `traceability.md` and `test-plan.md`; unresolved rows go to `assumptions.md` with
+   their gate/owner.
+4a. **Parallel-lane sanity check** — after drafting `tasks.md` but before asking for plan
+   approval, run the advisory lane planner:
+   ```bash
+   devrites-engine lanes plan "$(cat .devrites/ACTIVE 2>/dev/null)"
+   ```
+   Use it to spot independent read-only/review lanes and dependency mistakes, but do not
+   weaken DevRites' default of one production-write slice at a time.
+4b. **Persist the traceability matrix** — write `traceability.md` (`AC/REQ ID → slice(s) →
+   test/proof → evidence ID → touched files → status`), the living map `/rite-prove` and
+   `/rite-seal` walk. Generate it with `devrites-engine coverage` when available, then save/rename
+   the output as `traceability.md`, or write the table by hand from the same inputs if the
+   script is absent:
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine coverage "$S" > ".devrites/work/$S/traceability.md"
+   ```
+5. **Complexity & deviations gate** — justify anything off DevRites defaults (new dep,
+   extra abstraction, second design system) in the plan; if you can't justify it, simplify.
+   **Principles conformance:** read `.devrites/principles.md` (if present) and confirm the
+   approach honors every declared invariant. A plan that conflicts with one is not "a deviation
+   to justify away" — either reshape the approach to conform, or, when the conflict is genuine and
+   intended, route it through the Spec Drift Guard plus a recorded decision and a scoped principle
+   exception a human approves. Never ready a plan that silently violates an invariant. (Re-scored
+   as a blocking gate at `/rite-vet`; no file → none declared → nothing to check.)
+6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md`; update
+   `state.md` (phase: plan → next `/rite-vet`).
+6a. **Cross-artifact gate — now that `tasks.md` exists.** Run the deterministic
+   spec↔tasks coverage/consistency check; any non-zero result blocks plan readiness:
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine analyze "$S"
+   ```
+7. **Readiness gate** (bottom of plan-template): every acceptance criterion covered by a
+   slice, dependency order acyclic + risk-first, no unjustified deviation, rollback for
+   every destructive/migration step. **Stop and confirm** before code. Render the review-before-code
+   digest first: `Intent` (one sentence from the spec), `Done means` (acceptance coverage x/y),
+   `Plan sanity` (slice count + riskiest boundary/gate), and `Build exactly this?` (yes → approve;
+   no → `/rite-plan revise`). When the human confirms the plan, write `Plan approved: <iso>` to
+   `state.md` (see [state-workspace](../rite-spec/reference/state-workspace.md)); `/rite-build`
+   checks this exists before building.
+
+## tasks.md slice format
+
+Use the canonical slice grammar in
+[`workspace-artifact-schema.md`](../devrites-lib/reference/workspace-artifact-schema.md#canonical-slice-grammar).
+Every slice must satisfy that complete field set; phase-specific gate details live in
+[`reference/gates.md`](reference/gates.md).
+
+> **Mid-flight discipline.** When tempted to skip vertical slicing, coverage mapping, or dependency-order discipline — see [`anti-patterns`](reference/anti-patterns.md) (Common Rationalizations + Red Flags). Load it the moment you reach for the excuse.
+
+## Output
+
+**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+Default success shape:
+```
+Done: plan written for <slug>; <n> vertical slices defined.
+Changed: architecture.md, plan.md, tasks.md, traceability.md, decisions.md, state.md
+Evidence: not applicable; acceptance coverage <x/y> mapped in traceability.md
+Open: <none | plan questions | Alternative: /rite-plan revise to reshape artifacts>; review digest: intent + coverage + plan sanity rendered
+Next: /rite-vet
+Record: .devrites/work/<slug>/plan.md
+↻ Hygiene: /clear after user confirms the plan
+```

package/pack/generated/claude/skills/rite-define/reference/anti-patterns.md

@@ -0,0 +1,26 @@
+# rite-define — anti-patterns
+
+Load this when standing a non-trivial planning decision in `/rite-define`,
+or when the agent feels reluctance toward vertical slicing or coverage
+mapping.
+
+Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
+
+## Phase-specific rationalizations
+
+| Excuse | Rebuttal |
+|---|---|
+| "Spec is good enough; just start coding." | Plan separates HOW from WHAT for a reason — missed HOW shows up as drift at slice 3. |
+| "One big slice is fine, the work is all related." | If slice 1 isn't shippable on its own, you're not slicing vertically — you're staging waterfall in disguise. |
+| "Tests can come at build time, not in tasks." | Every slice's `Tests to write/run` line is the contract that proves its acceptance — leave it blank, lose the contract. |
+| "Backend + frontend belong in one slice." | Fullstack goes contract-first: split the contract, then build a thin vertical slice that crosses both layers. |
+| "I can skip mapping every spec criterion." | An unmapped criterion is one nobody will build. Coverage isn't bureaucracy. |
+
+## Red Flags
+
+- A slice with no acceptance criterion link back to `spec.md`.
+- A slice whose name contains "and" — two capabilities smuggled into one slice (the "and" test, [slicing](../../rite-plan/reference/slicing.md)).
+- No first slice that's end-to-end thin (every slice depends on infra that doesn't exist yet).
+- A new dependency added without rationale in `decisions.md`.
+- A slice that doesn't list "Existing to reuse / extend" (you didn't search).
+- Plan readiness gate failing but you're about to call `/rite-build` anyway.

package/pack/generated/claude/skills/rite-define/reference/gates.md

@@ -0,0 +1,152 @@
+# Gate taxonomy — advisory · validating · blocking · escalating
+
+DevRites uses a four-gate model for HITL pauses, adapted from the regulated-agentic-workflow
+governance pattern. Picking the right gate for each `Mode: HITL` slice is the difference
+between a workflow that catches real risk and one that becomes a review queue.
+
+> **Default failure mode:** marking every HITL slice as `blocking`. The same reviewer ends
+> up approving low-stakes and high-stakes items at the same priority and the gate becomes
+> a queue. Mix gate types per slice; most plans use 2-3 of the 4.
+
+## The four gates
+
+### advisory
+
+**Stakes:** low. The slice can ship without the human's input; the question exists for
+audit / future record / FYI.
+
+**Behavior:** the slice runs. The question is logged to `questions.md` with
+`gate: advisory` and an explanation. `state.md` does **not** flip to `awaiting_human`.
+`/rite-status` surfaces the count but does not flag it as blocking.
+
+**Example:** "We picked option A from the prototype's verdict but option B is also viable.
+Recording the choice for posterity."
+
+**SLA:** `none` — there is no waiting time because nothing is waiting.
+
+### validating
+
+**Stakes:** medium. The slice can be built but should not merge before a human signs off.
+Async — the human reviews when they get to it, but the loop does not stall.
+
+**Behavior:** in HITL mode, `/rite-build` pauses on this gate and writes
+`Awaiting human` to `state.md`. In AFK mode with `allow_gates: [advisory, validating]`,
+`/rite-build` builds the slice but marks it `built (pending review)` and writes the
+validating question; the feature does not seal until the entry is resolved. An open
+`gate: validating` entry is **merge-blocking by definition** — a slice marked
+`built (pending review)` is not done, and seal is a NO-GO while it stands open.
+
+**Example:** "Schema migration adds a non-null column with a default. Backfill plan is
+recorded; reviewer should confirm the default is the right one for archived rows."
+
+**SLA:** `4h` — the work continues but the validating queue should drain within hours,
+not days.
+
+### blocking
+
+**Stakes:** high. The slice cannot proceed safely without the answer. Synchronous —
+the loop stops.
+
+**Behavior:** **always pauses regardless of `.devrites/AFK` config.** `/rite-build`
+writes `Awaiting human`, sets `Status: awaiting_human`, fires the `notify:` hook, and
+STOPs. The slice is not built until `/rite-resolve` lands.
+
+**Examples:**
+- Destructive migration (data loss risk).
+- Auth/authz boundary change.
+- Public API break.
+- Spec drift that changes acceptance criteria.
+- Tests / types / lint are red and the agent cannot tell whether the slice's contract is
+  wrong or the failing code is.
+
+**SLA:** `15m` — synchronous gates demand fast turnaround; otherwise treat the work as
+genuinely blocked and re-plan around it.
+
+### escalating
+
+**Stakes:** novel pattern. The question is not within the active reviewer's scope and
+needs to route to a specialist (legal, security, principal engineer, designer-of-record).
+
+**Behavior:** same pause behavior as `blocking`, but the `questions.md` entry includes a
+`route:` field naming the specialist tag. `/rite-status` shows it under a separate
+"Escalating" line so it doesn't compete with synchronous blockers for the same reviewer.
+
+**Example:** "Slice introduces a contract with an external partner — needs legal review
+of the data-sharing language."
+
+**SLA:** `24h` — specialist routing implies the SLA is loose; if it needs to be tight,
+it's actually `blocking`.
+
+## Picking the gate
+
+Apply this decision tree per HITL slice:
+
+1. **Can the slice ship safely without the answer?**
+   - Yes → `advisory`.
+   - No → continue.
+2. **Does the slice need a different reviewer than the default one?**
+   - Yes → `escalating`.
+   - No → continue.
+3. **Can the slice be built but not merged until reviewed?**
+   - Yes → `validating`.
+   - No → `blocking`.
+
+## SLA mapping
+
+| Gate | SLA | Synchronous? |
+|---|---|---|
+| advisory | `none` | — (does not pause) |
+| validating | `4h` | no (async; build continues, merge blocks) |
+| blocking | `15m` | yes |
+| escalating | `24h` | yes, but to a specialist |
+
+SLAs are guidance for human reviewers and for tools that surface stale questions. DevRites
+itself does not enforce them; `/rite-status` reports time since `raised_at` so the user
+can see when a gate is slipping.
+
+## AFK interaction
+
+`.devrites/AFK` carries an `allow_gates:` list. AFK auto-handles a gate by logging the
+question as advisory and proceeding **only when** the gate is in `allow_gates`. The
+defaults and the always-pause rules:
+
+| AFK `allow_gates` | advisory | validating | blocking | escalating |
+|---|---|---|---|---|
+| `[]` (or omitted) | log + proceed | pause | pause | pause |
+| `[advisory]` (default) | log + proceed | pause | pause | pause |
+| `[advisory, validating]` | log + proceed | build + queue | pause | pause |
+| `[advisory, validating, blocking]` | log + proceed | build + queue | log + proceed* | pause |
+
+\* but **never** for destructive migrations, auth/authz boundary changes, public API
+breaks, or red tests/types/lint — those always pause. See
+[`.claude/skills/devrites-lib/reference/standards/afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) for the irreversible-risk
+list.
+
+`escalating` is never in `allow_gates` — specialist routing is not something AFK can
+shortcut.
+
+## Anti-patterns
+
+- **One gate for everything.** Validates becomes a queue, blocks all work behind one
+  reviewer. Pick gates per slice.
+- **Marking a destructive migration `validating` to "keep the loop moving".** Destructive
+  work is `blocking` regardless of the urge to ship.
+- **`advisory` as a synonym for "I'm not sure but I don't want to ask".** If the slice
+  needs the answer, it's not advisory. Pick the right gate instead.
+- **`escalating` with no `route:` field.** Without a specialist tag, an escalation is
+  just a slow blocker. Name who answers.
+
+## Field shape in `tasks.md`
+
+```markdown
+## SLICE-003: list endpoint
+Mode: HITL
+Gate: blocking
+SLA: 15m
+Checkpoint: Confirm (user_id, created_at) composite index choice vs two single-col indexes.
+Blocked by: SLICE-002
+...
+```
+
+`Gate`, `SLA`, and `Checkpoint` are **required** when `Mode: HITL`. The plan readiness
+gate in `plan-template.md` enforces this.

package/pack/generated/claude/skills/rite-define/reference/plan-template.md

@@ -0,0 +1,94 @@
+# `plan.md` template
+
+Write **how** to build what `spec.md` defines. The plan is **living, not sacred** —
+`/rite-plan` repairs it when reality disagrees. This is where technology choices live
+(they're banned from the spec).
+
+```markdown
+# Plan: <Feature>
+Spec: ./spec.md   Date: <date>
+
+## Summary
+1–2 sentences: the primary requirement + the chosen approach.
+
+## Technical context
+- Language / runtime + version: <e.g. TypeScript 5, Node 20>
+- Frameworks / libraries in play: <...>
+- Storage / data: <...>
+- Testing tools + commands: <from spec "Commands discovered">
+- Target / platform / constraints: <...>
+- `[NEEDS CLARIFICATION: ...]` for any unknown that affects the approach.
+
+## Global constraints
+Project-wide requirements from the spec that every slice implicitly includes — version
+floors, dependency limits, naming/copy rules, platform requirements. One line each, exact
+values **verbatim from spec.md** (a paraphrased constraint drifts by the time slice 4 builds).
+
+## Approach
+The strategy in a few sentences. Why this over the alternatives considered.
+
+## Slice strategy
+How the feature is split into vertical `SLICE-###` increments, why the order is
+risk-first within dependency tiers, and which acceptance criteria each slice covers. For a
+wide mechanical refactor, use expand → migrate batches → contract; keep every migrate batch
+green, or name the integration branch + final verify slice.
+
+## Architecture decisions
+Key decisions + rationale (mirror into decisions.md). New pattern vs reuse — prefer
+reuse of existing project conventions. Record architecture as invariants, not scaffolding:
+include a decision only when two implementing slices could otherwise choose incompatibly. For each
+medium+ decision, include `Binds:` (what future work must follow) and `Prevents:` (the divergence
+or failure it avoids).
+
+## Dependency graph
+What must exist before what (text is fine):
+- SLICE-001 (no deps) → SLICE-002 (needs SLICE-001) → SLICE-004 (needs SLICE-002, SLICE-003)
+- SLICE-003 (independent / parallelizable)
+
+## Implementation order
+Ordered slice list + the reason for the order (risk-first within a dependency tier).
+`MVP cut: after SLICE-00N — <what ships if we stop here>` — the earliest prefix of the order
+that is a coherent, shippable feature on its own. This is the pre-agreed retreat position when
+the feature stalls or `/rite-plan` pivots: every acceptance criterion above the cut is proven by
+slices above the cut, and no slice above it depends on one below.
+
+## Validation strategy
+After which slices to run tests / build / browser proof. For UI slices, name the visual
+acceptance targets from `design-brief.md`, not a generic "looks good" check.
+
+**Key links** — the wiring the assembled feature must exhibit, one row each:
+`<from> → <to> via <mechanism>` (route → handler via registration; producer → consumer via
+event). List only cross-slice links whose absence no single
+slice's tests would catch — `/rite-prove` walks each (step 5d). `Key links: none` is a
+deliberate single-slice call.
+
+## Complexity & deviations gate
+List anything that deviates from DevRites defaults (prefer existing conventions, the
+simplest approach, feature scope only, no new deps/design system) and **justify it**.
+If you can't justify a deviation, simplify instead of recording it.
+| Deviation | Why needed | Simpler option rejected because |
+|-----------|-----------|---------------------------------|
+| <e.g. new dependency X> | <reason> | <why the in-repo option won't work> |
+
+## Rollback
+How to back out each risky step (migration down, feature flag, revert boundary, backup).
+
+## Scope boundaries
+What this plan will NOT touch. Restate "Ask first" / "Never do" from the spec.
+
+## Source docs needed
+Framework/library docs to consult (triggers devrites-source-driven). Record URLs in
+decisions.md / evidence.md when used.
+
+## Readiness gate  *(must pass before /rite-build)*
+- [ ] Every spec acceptance criterion is covered by a slice
+- [ ] Dependency order is acyclic and risk-first
+- [ ] An `MVP cut` is named, self-contained (ACs above the cut proven above the cut, no dependency reaching below), and marks a genuinely shippable scope
+- [ ] No unjustified deviation remains in the complexity gate
+- [ ] Rollback exists for every destructive / migration step
+- [ ] Every `Mode: HITL` slice has `Gate`, `SLA`, and `Checkpoint` populated
+- [ ] Every UI slice names `Design brief states` and binary `Visual acceptance`
+- [ ] `Key links` rows cover every cross-slice wiring (or state `none`)
+- [ ] Any wide mechanical refactor is sliced expand → migrate batches → contract, with green migrate batches or an integration branch + final verify slice
+- [ ] No `Gate: blocking` slice is implicitly chained behind an AFK slice without surfacing the dependency
+```

package/pack/generated/claude/skills/rite-doctor/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: rite-doctor
+description: Doctor DevRites setup or index health. Use when workflow wiring is broken, the user asks to check DevRites, or says "reindex". Not for application bugs.
+argument-hint: "[--code | --reindex]"
+user-invocable: true
+---
+
+# /rite-doctor — health check
+
+The on-demand deep report. The same checks run **silently at session start** (the orient
+hook surfaces issues only when there are any); `/rite-doctor` runs them **verbosely** —
+printing every check, pass or fail — so you can inspect health even when nothing is broken.
+It covers version drift, Claude Code wiring, optional Codex mirrors/hooks, stale host artifacts, and missing install markers when those files are present. With `--code`, it also runs the read-only project code-health dashboard (`devrites-engine health`).
+It also reports an in-progress git merge/rebase and points to `git-workflow.md`'s conflict
+recovery playbook.
+
+It is **read-only**: it never edits the workspace, never advances a phase, never blocks.
+
+## Workflow
+1. Run the diagnose core verbosely (resolve across install layouts):
+   ```bash
+   devrites-engine doctor --verbose; echo "doctor rc=$?"
+   ```
+1a. **Surface the learnings nudge** — point the user at `/rite-learn` when a pattern recurs across
+   shipped features (read-only; silent when there's nothing to say):
+   ```bash
+   devrites-engine learnings nudge
+   ```
+1b. **Code-health dashboard (only when `$ARGUMENTS` includes `--code`).** Run the read-only check and surface the PASS/WARN/FAIL table; it appends `.devrites/health.jsonl` for trends and never blocks doctor:
+   ```bash
+   devrites-engine health; echo "health rc=$?"
+   ```
+1c. **Validate project extensions + overrides** (read-only — report, don't sync). A user rite/
+   reviewer under `.devrites/extensions/` is held to the same schema as the shipped pack; a
+   reviewer override under `.devrites/overrides/` may add emphasis but never relax a gate:
+   ```bash
+   devrites-engine extensions validate; echo "extensions rc=$?"
+   devrites-engine overrides validate;  echo "overrides rc=$?"
+   ```
+   - **extensions rc=1** — an extension is malformed (missing frontmatter, empty, duplicate name).
+     Fix the named file; once valid, the user mirrors it into the harness with
+     `devrites-engine extensions sync`.
+   - **overrides rc=1** — an override reads like it waives a gate. That is the one thing overrides
+     must not do — hand the user the offending file to rewrite as added emphasis, not a waiver.
+1d. **Refresh indexes only when `$ARGUMENTS` includes `--reindex`.** Load and execute
+   `devrites-refresh-indexes`; report its synchronous refresh result, then continue the
+   diagnostic. This changes optional indexes, never project source or DevRites state.
+2. Report the result. **rc=0** → "DevRites healthy" + the `ok:` checks. **rc=1** → list each
+   `issue:` line with the fix it names, then the single command that resolves the most urgent
+   one (a stale ACTIVE → `rite use <slug>` or `/rite-status`; an orphaned gate →
+   `/rite-resolve <qid>`; an incomplete install → reinstall). If the output includes
+   `git-state: merge in progress` or `git-state: rebase in progress`, make the next action the
+   `git-workflow.md` merge-conflict recovery playbook.
+3. **Do not fix anything yourself** — doctor is diagnostic. Hand the user the fix command.
+   **Completion:** exactly one highest-priority fix command is reported and no source/workspace file changed.
+
+## Gotchas
+- Read-only — never write the workspace or advance a phase (that's the lifecycle skills' job).
+- It diagnoses **DevRites** health, not the user's application — code bugs go to
+  `devrites-debug-recovery`; feature progress goes to `/rite-status`.
+- Healthy is the common case; say so plainly and stop. Don't invent issues.
+
+## Output
+Reply-contract exception: workspace-less diagnostic. It does not render `devrites
+progress`, but it follows the compact labels and one-next-action rule from
+[`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md).
+
+```
+Done: DevRites health checked; <OK | n issues>.
+Changed: workspace only
+Evidence: devrites-engine doctor --verbose rc=<0|1>; health <skipped|PASS|WARN|FAIL>; reindex <skipped|result>; learnings nudge <summary|none>; extensions/overrides <ok|n issues>
+Open: <none | issue count and top issue>
+Next: <single command for the most urgent issue>
+Record: not applicable
+↻ Hygiene: /clear if stopping; /compact (doctor issue) if fixing now
+```