devrites 2.6.1 → 3.0.1

package/pack/generated/codex/skills/rite-converge/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: rite-converge
+description: Converge intent and live code. Use when resuming a half-built feature, after `$rite-adopt` drift, or the user asks "what's left to build". Not for initial planning.
+argument-hint: "[feature-slug]"
+user-invocable: true
+---
+
+## Codex compatibility
+
+This is the Codex mirror of a DevRites skill. In Codex:
+
+- Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
+- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+
+
+# $rite-converge — make the code and the intent converge
+
+Read `spec.md` + `plan.md` + `tasks.md` as the **sole source of intent** (with
+`.devrites/principles.md` as governing constraints), assess what the **live codebase**
+actually implements, and **append every unmet piece as a new traceable `SLICE-###`** at the
+bottom of `tasks.md` so `$rite-build` can finish it. The recovery bridge for work that fell
+out of sync with its plan: a half-built feature picked up cold, a `$rite-adopt`'d codebase
+that drifted from its derived spec, or a build that stalled mid-slice. **Read the active
+workspace first**; if there's no `spec.md`/`plan.md`/`tasks.md`, tell the user which
+prerequisite skill to run.
+
+> **Not a diff tool.** `$rite-converge` assesses the **present state** of the code against
+> intent — no git, no branch comparison, no history. "What does this codebase do *now* vs
+> what the artifacts asked for" — not "what changed since commit X". For a change-scoped
+> review use `$rite-review`; to prove a finished feature use `$rite-prove`.
+
+## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
+Pull on demand:
+- `principles.md` — the project invariants (`.devrites/principles.md`); code that violates a
+  MUST principle is the highest-severity gap and produces a remediation slice.
+- `spec-grammar.md` — buildable acceptance criteria vs `## Success metrics` (outcome KPIs the
+  code can't make true and this pass never enqueues); structured `### Requirement:` /
+  `#### Scenario:` blocks, each scenario one behavior to check as built / partial / absent.
+- `tooling.md` — prefer a code-intelligence index (codebase-memory-mcp → codegraph → graphify,
+  else LSP / Read/Grep/Glob) to read the live code, not assumptions.
+- `testing.md` — a criterion with code but no covering test is *partial*, not done.
+
+## Operating rules
+- **APPEND-ONLY, never rewrite.** The only write to `tasks.md` is **appending** new
+  `SLICE-###` entries. Never rewrite, renumber, reorder, or delete an existing slice
+  (including slices a prior convergence appended). Never edit `spec.md` or `plan.md`. Never
+  touch application code — completing the appended slices is `$rite-build`'s job, not this
+  skill's.
+- **Clean means byte-for-byte unchanged.** When the code already satisfies everything, leave
+  `tasks.md` untouched — no empty convergence header — and report a clean result. Recommend
+  `$rite-prove`.
+- **Intent is the artifacts, not your memory.** The spec/plan/tasks (+ principles) are the
+  contract. If assessing reveals the *spec* is wrong (the code is right and the requirement is
+  stale), that's **Spec Drift** — stop and route it through the Spec Drift Guard
+  (`rite-build/reference/spec-drift-guard.md`) + a recorded decision; never paper over a spec
+  bug by appending a task that "fixes" the code to a wrong requirement.
+- **Partial is not done.** Code that exists but is untested, half-wired, or covers only the
+  happy path is an unmet gap — enqueue the remainder, don't round it up.
+- **Principles are non-negotiable.** A live violation of a declared invariant with no recorded
+  exception is the top-severity gap, walked first. Absent/empty principles file → none declared
+  → skip the check gracefully, never block for its absence.
+
+## Workflow
+0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`** first (the always-on
+   operating rules), then run `devrites-engine preamble` for deterministic workspace orientation.
+1. **Confirm the gate.** Require `spec.md` + `plan.md` + `tasks.md` in the active workspace. If
+   any is missing, **STOP** and name the prerequisite (`$rite-spec` for a missing spec,
+   `$rite-define` for a missing plan/tasks, `$rite-adopt` to onboard existing code). Do not
+   produce partial output.
+2. **Load intent** — [`reference/convergence-assessment.md`](reference/convergence-assessment.md).
+   From `spec.md`: buildable `AC-###` / `### Requirement:` scenarios (skip `## Success metrics`);
+   from `plan.md`: architecture decisions + named touch-points (files/components the plan says
+   get built); from `tasks.md`: existing slices + their `Satisfies:`; from
+   `.devrites/principles.md`: the invariants.
+   **Completion:** every buildable criterion, touch-point, slice output, and principle is in the assessment inventory.
+3. **Run the mechanical backbone**, then read the code. `devrites-engine analyze` gives coverage +
+   consistency; `devrites-engine coverage` gives the AC→slice→proven matrix. They catch *unmapped*
+   criteria; they do **not** see whether mapped code is actually built and correct — for that,
+   read the live code (code-intelligence index per `tooling.md`).
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine analyze "$S"; echo "analyze rc=$?"
+   devrites-engine coverage "$S" > /dev/null; echo "coverage rc=$?"
+   ```
+4. **Assess each unit as built / partial / absent** against the live code (the rubric is in
+   [`reference/convergence-assessment.md`](reference/convergence-assessment.md)): every
+   acceptance criterion / scenario, every plan touch-point, and every existing slice's stated
+   Produces. A principle violated in the current code is its own top-severity gap.
+   **Completion:** every inventory unit is classified once with live-code evidence.
+5. **Enqueue the remainder as new slices.** For each *partial* or *absent* unit, append a
+   `## SLICE-###` (continue the numbering after the highest existing id) in the `rite-define`
+   slice grammar, each with a `Satisfies:` line tracing to the AC/REQ it closes and a
+   `Convergence: <iso>` marker line. Dependency-order them after the existing slices; a
+   principle-remediation slice sorts first. **If every unit is built → append nothing.**
+   **Completion:** every partial/absent unit has one traceable appended slice, or the file is byte-for-byte unchanged.
+6. **Write append-only + bookkeeping.** Append the slice batch to `tasks.md` (nothing else in
+   that file changes); refresh `traceability.md` (`devrites-engine coverage` → new rows for the
+   appended slices); update `state.md` (`Phase: converge`, `Next step: $rite-build`; or, when
+   nothing was unmet, `Next step: $rite-prove`). Append `decisions.md` for any material call.
+7. **STOP.** Report units assessed, built / partial / absent counts, slices appended, and any
+   principle violation found; recommend `$rite-build` (or `$rite-prove` if the code already
+   converged).
+
+## Appended slice format
+Use the complete
+[`canonical slice grammar`](../devrites-lib/reference/workspace-artifact-schema.md#canonical-slice-grammar)
+with one added `Convergence:` field after `Satisfies:`:
+```markdown
+<!-- Convergence 2026-07-07: slices below appended by $rite-converge — live code assessed against intent. -->
+## SLICE-014 <name of the unmet capability>
+Satisfies: AC-007            # the criterion / scenario this closes
+Convergence: 2026-07-07      # marks this as a convergence-appended slice, not an original
+<all remaining canonical slice fields>
+```
+
+> **Mid-flight discipline.** When tempted to rewrite an existing slice instead of appending, to
+> edit the code directly "while you're in there", to mark a happy-path-only implementation as
+> built, or to enqueue a task that bends the code to a spec you suspect is wrong — see
+> [`reference/anti-patterns.md`](reference/anti-patterns.md). 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: convergence assessed for <slug>; <n> slices appended.
+Changed: tasks.md <appended|unchanged>, traceability.md, state.md
+Evidence: units <built>/<total> built · <partial> partial · <absent> absent · principle violations 0
+Open: none
+Next: $rite-build
+Record: .devrites/work/<slug>/tasks.md
+↻ Hygiene: /clear before $rite-build
+```
+When nothing was unmet, render the same green form with `Next: $rite-prove`.
+If spec drift or another blocker remains, use the shared `Stopped / blocked` form
+and route `Fix:` to `$rite-plan`; do not recommend `$rite-build`.
+**DO NOT write application code, rewrite existing slices, or edit spec.md/plan.md here** — convergence assesses and enqueues; `$rite-build` implements.

package/pack/generated/codex/skills/rite-converge/reference/anti-patterns.md

@@ -0,0 +1,35 @@
+# $rite-converge anti-patterns
+
+Load the moment you reach for one of these excuses.
+
+## Common rationalizations
+
+- *"I'll just fix this existing slice instead of appending a new one."* — No. The append-only
+  rule is what makes convergence **re-runnable** and its output **auditable**: a reader diffs
+  `tasks.md` and sees exactly what this pass added. Rewriting an existing slice destroys that
+  and can silently drop coverage. Append; never edit an existing `SLICE-###`.
+- *"The gap is tiny — I'll just patch the code while I'm here."* — No. Convergence **assesses
+  and enqueues**; `$rite-build` implements. The moment you edit application code you've skipped
+  the build's slice discipline, tests, and reviewer. Enqueue it, however small.
+- *"It's basically built — I'll call it done."* — Happy-path-only, untested, or half-wired is
+  **partial**, not built (`convergence-assessment.md`). Rounding partial up to built is how a
+  feature ships with the edge cases that were the whole reason for the scenario.
+- *"The code does X, the spec says Y — I'll enqueue a slice to make the code match the spec."* —
+  Only if you're sure the **spec** is right. If the code is right and the requirement is stale,
+  that's **Spec Drift** — route it through the guard, don't launder a spec bug into a code task.
+- *"The spec has no `AC-###` ids, so there's nothing to converge."* — Assess plan touch-points
+  and existing-slice Produces directly against the code; a coverage id is convenient, not
+  required. (And flag the untagged spec so `$rite-spec` can add ids.)
+- *"I'll rewrite the whole tasks.md to be clean while I'm at it."* — That is a **reslice**, and
+  it belongs to `$rite-plan`, not here. Convergence only ever *appends*.
+
+## Red flags in your own output
+
+- An edit to `tasks.md` that touches a line **above** the appended batch → you rewrote history.
+  Revert; append only.
+- Any change to `spec.md`, `plan.md`, or a source file in this pass → out of scope.
+- An appended slice with no `Satisfies:` line → it traces to nothing; either tie it to a
+  criterion/touch-point or it isn't convergence work.
+- A "clean" report that still left a `## Convergence` header or marker in `tasks.md` → clean
+  must be **byte-for-byte unchanged**.
+- Reusing or renumbering an existing `SLICE-###` id → ids are append-only and stable.

package/pack/generated/codex/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/codex/skills/rite-customize/SKILL.md

@@ -0,0 +1,79 @@
+---
+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
+---
+
+## Codex compatibility
+
+This is the Codex mirror of a DevRites skill. In Codex:
+
+- Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
+- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+
+
+# $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 `.agents/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 `.codex/agents/` or `.codex/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/codex/skills/rite-customize/agents/openai.yaml

@@ -0,0 +1,2 @@
+policy:
+  allow_implicit_invocation: false

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

@@ -0,0 +1,171 @@
+---
+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
+---
+
+## Codex compatibility
+
+This is the Codex mirror of a DevRites skill. In Codex:
+
+- Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
+- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+
+
+# $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 `.agents/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 `.agents/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
+   `.agents/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/codex/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.