devrites 4.7.0 → 5.0.0

package/pack/generated/omp/skills/rite-frame/reference/failure-modes.md

@@ -0,0 +1,66 @@
+# Four failure modes and their DevRites controls
+
+`rite-frame` checks four common LLM failure modes. Existing DevRites controls address
+each one. Use these names for quick checks on ad hoc or express-lane work that does not
+reach the normal gates.
+
+## The map
+
+| # | Failure mode | The tell in a diff / a reply | Cure already in the pack |
+|---|---|---|---|
+| 1 | **Silent assumption** | A value, contract, edge case, or interpretation was *guessed* and run with: no note, no question. The ask had two readings and one was picked silently. | `core.md` #2 (no silent assumptions) / #3 (no guessing through confusion); the Spec Drift Guard; `devrites-doubt` for a single high-stakes call; `devrites-interview` when the ask is underspecified. |
+| 2 | **Overcomplication** | An abstraction, flag, config knob, or indirection nobody asked for. 200 lines where 50 would do. A single-use factory. Defensive `try/catch` + null checks inside trusted code. A dependency added where an in-repo option exists. | `coding-style.md` (simplicity, reuse-first), `patterns.md` (avoid over-engineering), `devrites-audit simplify` (deletion test, Chesterton's Fence), the "over-defensive guarding is slop" anti-pattern. |
+| 3 | **Out-of-scope edit** | Touched code, comments, or formatting outside the ask. A "while I'm here" refactor. Renamed something orthogonal. Reflowed an import block. | `core.md` #7 (feature scope only), the exact paths stated in the writer task, `git diff --name-only` plus `touched-files.md`, and the "it's only a small refactor" anti-pattern. |
+| 4 | **Unverifiable goal** | "It works" with no command, no output, no test. A success criterion that can't be false ("make it better"). A tautological test that passes no matter what. | `rite-spec/reference/acceptance-criteria.md` (measurable acceptance), `core.md` #6 (evidence over confidence), `testing.md` (assertion strength, see it fail first), the TDD wright. |
+
+Karpathy named the first three. The fourth supplies the falsifiable criterion needed
+for an agent to work without repeated human confirmation. FRAME defines that criterion
+before auditing the other three modes.
+
+## FRAME: rewrite an imperative as a falsifiable condition
+
+Rewrite the request as a condition that can be false. If that is impossible, the
+request is ambiguous and triggers mode 1 before any diff exists.
+
+| Imperative ask | Weak (still a wish) | Falsifiable criterion + verify |
+|---|---|---|
+| "Add validation" | "validate the inputs" | "`{empty, oversize, wrong-type}` → 4xx + message; a test asserts each and is red today." → `npm test path/to.spec` |
+| "Fix the bug" | "make the bug go away" | "Test reproducing the report is red now, green after, nothing else changes." → the repro test |
+| "Make it faster" | "improve performance" | "Endpoint X p95 `<baseline ms>` → `<target ms>` on `<named bench>`." → the benchmark cmd |
+| "Refactor X" | "clean up X" | "Existing suite green before and after; behavior byte-identical." → full suite, twice |
+| "Handle errors" | "add error handling" | "On `<failure F>` the system fails closed with `<observable>`; a test forces F." → that test |
+| "Improve the UX" | "make it nicer" | *(no falsifiable check → ambiguous → `devrites-ux-shape` / ask which states/flows)* |
+
+A criterion is ready when a reviewer can run the verification command and get a clear
+pass or fail without asking what it means.
+
+## AUDIT: worked finding lines
+
+Findings read like the rest of the pack: one line, severity-tagged, cite `file:line`, route
+to the cure. Severity ladder is the pack standard (`Critical / Important / Suggestion / Nit /
+FYI`).
+
+```
+auth.ts:42  Important  mode 1 (assumption): assumes `role` is always present — unset on legacy rows. → validate at boundary or ask (core #2).
+cart.ts:88  Suggestion mode 2 (overcomplication): single-use `StrategyFactory` for one caller. → inline; deletion test fails it (devrites-audit simplify).
+utils.ts:5  FYI        mode 3 (scope): reflowed an unrelated import block. → revert to boundary; not in this ask (core #7).
+sum.spec:12 Important  mode 4 (unverifiable): test asserts `mock.called`, not the result — passes if the fn is empty. → assert the value; see it fail first (testing.md).
+```
+
+Record clean modes explicitly (`1 assumption: clean`) so an empty result is not mistaken
+for a skipped check.
+
+## Related tools
+
+- **`devrites-doubt`:** adversarial *fresh-context subagent* pre-mortem on **one** decision.
+  It is independent and avoids anchoring. rite-frame is self-applied and covers all four
+  modes; use doubt for one consequential claim.
+- **`devrites-audit <axis>`:** *fresh-context subagent* review of an **active feature's** diff
+  on one axis (security / perf / simplify). Needs a `.devrites/` workspace. rite-frame needs no
+  workspace and runs in the current context, with less independence.
+- **`/rite-review` · `/rite-seal`:** the **gates**: parallel reviewer fan-out, blocking
+  severities, written verdict. rite-frame is the inline reflex for work that never reaches a
+  gate and does not replace one.
+
+Use rite-frame for the quickest self-check. Use doubt, audit, or the full gates when the
+work needs independent or feature-level review.

package/pack/generated/omp/skills/rite-handoff/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: rite-handoff
+description: User-invoked handoff writer: sync chat-only context into `.devrites/` and write a fresh-agent handoff.
+user-invocable: true
+disable-model-invocation: true
+argument-hint: "[what the next session will focus on]"
+---
+
+# /rite-handoff: chat-only context, into a fresh-agent doc
+
+DevRites' workspace `.devrites/work/<slug>/` already captures everything that *should*
+persist (spec, plan, tasks, decisions, evidence, drift, review). This skill captures
+what the **chat** is holding that is **not** in the workspace, so a fresh agent (or
+the same user after `/clear`) can pick the work up without re-reading the transcript.
+
+Read [`core.md`](../devrites-lib/reference/standards/core.md) first: its "Persistence before stopping" discipline is
+exactly what this skill executes. The other rule files load on demand.
+
+Then read the explicit or active workspace's `state.md` directly.
+
+## Where to write
+
+- **Active feature exists** → `.devrites/work/<slug>/handoff.md` (overwrites the previous
+  handoff; the workspace is the canonical home for this slug).
+- **No active feature** → OS temp dir (`$TMPDIR` / `/tmp` / `%TEMP%`) as
+  `rite-handoff-<ISO-timestamp>.md`. Print the absolute path after writing.
+
+## Before you write: sync, don't duplicate
+
+For each of these, write the content into its **canonical home** first, then merely
+*note* in the handoff that the sync happened:
+
+- **Open mid-flight question** → append to `questions.md` (with best-guess attached if
+  possible).
+- **Decision discussed but not yet recorded** → append to `decisions.md` with the *why*,
+  not just the *what*.
+- **Assumption** about behaviour / API / user intent → append to `assumptions.md`.
+- **Drift event raised but not fully resolved** → update `drift.md` with the current
+  resolution status (open / asked-user / repaired).
+- **Files modified in chat not yet in `touched-files.md`** → append to
+  `touched-files.md`.
+
+The handoff doc itself then says "synced N entries into decisions.md", not the entries
+themselves. The workspace is the canonical store; the handoff is the chat-only delta.
+
+## What to include in the handoff
+
+1. **Suggested next action.** ONE command, not three options. If the active feature is
+   mid-phase, name the next `rite-*` command. If a question blocks progress, point at
+   it. If the user passed `[what the next session will focus on]`, tailor this section
+   to the named focus. Where you were mid-thought, **quote the most recent next-step
+   verbatim** from the chat (the exact sentence describing what to do next) so no nuance
+   is lost to paraphrase.
+2. **What just happened in this chat** (3-5 bullets). Distil: do not transcribe.
+3. **External references** that exist only in chat: URLs, Figma links, screenshot paths,
+   video timestamps the user pasted. List as references; do not embed.
+4. **Live assumptions the agent is acting on** that the workspace doesn't reflect yet
+   (after the sync above, this section should be near-empty: flag anything that
+   remains).
+5. **How to resume:** fixed boilerplate (see template below).
+
+## What NOT to include
+
+- Anything already in `spec.md`, `plan.md`, `tasks.md`, `state.md`, `decisions.md`,
+  `evidence.md`, `review.md`: link by path instead.
+- `git diff` output: the next agent runs `git diff` themselves.
+- The full conversation transcript: distil.
+- Secrets (API keys, tokens, PII, credentials). Redact aggressively.
+- **New ideas the user didn't confirm.** A handoff records what *happened* and what's *next*.
+  Leave out fresh suggestions, scope the user didn't agree to, and redesigns you thought of. Capture
+  the state, not your opinions about it.
+
+## Output template
+
+Loaded on demand from [`reference/handoff-template.md`](reference/handoff-template.md).
+Fill in each section and write to `.devrites/work/<slug>/handoff.md` (or to a temp
+file when no active feature). Then use the compact reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)):
+
+```
+Done: handoff written for <slug | session>.
+Changed: handoff.md plus synced workspace artifacts <n>
+Evidence: not applicable; chat-only context persisted
+Open: <none | unsynced caveats>
+Next: <single resume command>
+Record: <absolute path to handoff.md>
+↻ Hygiene: /clear
+```
+
+Print the absolute path in `Record:` so the user or next agent can open it without searching.
+
+## Session hygiene
+Close with the one-line hygiene advisory + the single resume command. This skill *is* the
+pre-`/clear` bridge, so it's where the advisory matters most (`context-hygiene.md`):
+```
+↻ Hygiene: /clear
+```

package/pack/generated/omp/skills/rite-handoff/reference/handoff-template.md

@@ -0,0 +1,44 @@
+# Handoff doc template
+
+Loaded on demand by `/rite-handoff`. Write the filled-in template to
+`.devrites/work/<slug>/handoff.md` (or to a `$TMPDIR` file when no active feature).
+
+```
+# Handoff — <feature slug | "no active feature"> — <ISO date>
+
+## Resume
+Current objective: <one sentence>
+Last completed slice: <SLICE-### | none>
+Blockers: <none | q-YYYY-MM-DD-NNN / released Q-### / DRIFT-###>
+
+## Read next
+1. `.devrites/work/<slug>/README.md` — workspace map.
+2. `.devrites/work/<slug>/state.md` — current cursor.
+3. `.devrites/work/<slug>/traceability.md` — acceptance coverage.
+4. <phase-specific source artifact; link, do not duplicate>.
+
+## Next action
+<one command or action, no option set>
+
+## What changed this turn
+- <short event; link to source artifact instead of copying full content>
+
+## External references (chat-only)
+- <URL / Figma / screenshot path / video timestamp>
+
+## Live assumptions (not yet in assumptions.md)
+- ...   (this section should be near-empty after the sync step)
+
+## Synced this turn
+- decisions.md: <N entries appended>
+- questions.md: <N appended>
+- assumptions.md: <N appended>
+- drift.md: <updated? yes/no>
+- touched-files.md: <N appended>
+
+## How to resume
+1. Read this file.
+2. Read `.devrites/work/<slug>/state.md` for the workspace cursor.
+3. Run `/rite-status` for the current phase / next action / open drift.
+4. Continue with the `Next action` above.
+```

package/pack/generated/omp/skills/rite-learn/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: rite-learn
+description: Review recurring cross-feature evidence and propose durable project guidance.
+argument-hint: "[\"<lesson or rejected direction>\"]"
+user-invocable: true
+disable-model-invocation: true
+---
+
+# /rite-learn: review durable lessons
+
+Use reviewed Markdown/native memory, not miners or registries. This proposes maintenance
+of one authority; it cannot promote a rule alone.
+
+## Modes
+
+- `/rite-learn` reviews recurring evidence across shipped work.
+- `/rite-learn "<lesson>"` evaluates one lesson or rejected direction.
+
+## Workflow
+
+1. Read [durable promotion](../devrites-lib/reference/standards/documentation.md#promote-durable-guidance);
+   bound the archive; inspect applicable `AGENTS.md`/`CLAUDE.md`, accepted ADRs, and relevant `.devrites/archive/*/{decisions,drift,review,seal}.md`.
+2. Broad mode dispatches exact fresh/read-only `devrites-retrospector`; reconcile its claims against cited files.
+3. Keep corrections repeated in two features, a judgement call made twice, or a defect class seen twice; drop one-off preferences, task-specific detail, generic advice.
+4. Verify claims against live authoritative sources; state currentness signal, applies/does-not-apply scope, `unknown` where unverifiable.
+   **Research promotion requires:** each external claim carries a dated citation per
+   [`tooling.md` § Research provenance](../devrites-lib/reference/standards/tooling.md#research-provenance-staleness-and-cost).
+   **Failing case:** "best practice is X" with no source → reject promotion.
+5. Apply durable promotion's recoverability test; search same/contrary rules, choose one existing owner (nearest instruction/standard, ADR, or feature `decisions.md`), and name discovery.
+6. Show the exact edit + duplicate/conflict/supersession disposition; update/narrow/replace/retire contradictions; apply only after user approval of exact edits.
+
+## Rules
+
+- Live repository evidence outranks memory; unverifiable is unknown, not false.
+- A lesson's premise is graded **established / working / open** with its source
+  (retrospector output): only established premises — or working premises whose
+  confirming check is named — may be proposed; open premises return as recorded
+  assumptions, not lessons.
+- Never create a learning ledger/index/queue, score, timeline, or parallel authority; rejected directions return only when evidence changes their rationale.
+- A declined lesson persists as a declined decision entry (reason recorded) in the
+  nearest owning decisions file **in the same round** — a refusal recorded only in
+  conversation or on an unmerged branch is lost and will be re-litigated.
+  **Failing case:** the same rejected proposal returns next round because no tracked
+  entry exists.
+- A lesson proposing a new recurring check names its **controls**: the real past
+  instance it would have caught (positive) and a near-miss class it must not fire on
+  (negative). **Failing case:** a trigger patterned on an imagined command that never
+  matched real history.
+- Contradiction outranks staleness: actively misleading guidance outranks merely old guidance.
+- A proposal names the **retrospective failing case**: the concrete past feature/artifact the
+  rule would have caught. None → generic advice — drop.
+- ≤3 accepted lessons per round; proposals extend/narrow but never lower an existing bar (revisions show old text beside new); duplicates consolidate into one canonical edit — simplification (deletions/merges) counts toward the cap.
+- An accepted lesson ships with a **follow-through owner and deadline**: the exact edit
+  lands in the named canonical file in the same round; a lesson unapplied at round end
+  returns to candidates with its blocker recorded. **Failing case:** an accepted lesson
+  with no applied edit and no recorded blocker — promotion failed; re-raise it.
+
+## Output
+
+```text
+Done: reviewed <scope>.
+Changed: none (proposal only)
+Candidate: <specific proposal or none>
+Currentness: <live source + signal | unknown>
+Scope: applies <trigger>; does not apply <boundary>
+Authority: existing <path|none>; canonical <path>; consumers/discovery <route>
+Disposition: <no conflict | update/narrow/replace/retire path + reason>
+Evidence: <feature/file references>
+Awaiting: <approval for exact edits | none>
+Next: <single action>
+Record: <nearest owning decisions file | chat-only>
+```

package/pack/generated/omp/skills/rite-plan/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: rite-plan
+description: Re-plan existing work when reality invalidates the plan: reslice a slice that is too big, repair drift, reorder dependencies, split boundaries, or unblock work. Not first-pass decomposition.
+argument-hint: "[mode: decompose|reslice|repair|reorder|split|unblock|course-correct|revise]"
+user-invocable: true
+---
+
+# /rite-plan: (re)plan an active feature
+
+Update a plan invalidated by evidence, drift, or user decision. **Read the active workspace
+first.** Missing `.devrites/ACTIVE`/workspace stops to `/rite-spec <feature>`. **Revise is
+artifact-only**: reconcile
+`spec.md` / `architecture.md` / `plan.md` / `tasks.md` / `traceability.md` without
+editing source code.
+
+## Rules consulted (read on demand from `.omp/skills/devrites-lib/reference/standards/`)
+Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD
+criteria.
+Load `repository-topology.md`, `data-integrity.md`, or `integration-reliability.md`
+when the spec applicability map or observed drift triggers them.
+Before classifying any Reslice, read `.omp/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → reconcile `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md` atomically; invalidate Vet/readiness; Vet.
+- `GUARD_AND_REPAIR` → no planning writes; Spec Drift Guard → Clarify → Plan repair → Vet.
+- `BLOCKED_INPUT` → no planning writes; exact diagnostic; recover input; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## Operating rules
+- Update the spec when needed, but never plan around a known-wrong assumption.
+- Keep each slice small enough for one focused build → prove cycle.
+- **Derive slice count:** reslice when work cannot build+prove in one cycle, not to hit a
+  requested tally. Treat counts as hints and explain honest differences; see
+  [`slicing.md`](reference/slicing.md).
+- **Size by complexity, order by dependency.** A slice carries a `Complexity: N/5` score (from
+  `/rite-define`); a slice scoring **>3** is a reslice trigger unless its inline reason justifies
+  the irreducible complexity. Honor each slice's `depends_on:`: the next *buildable* slice is the
+  lowest pending one whose dependencies are all built. This preserves one-slice-at-a-time execution.
+- **Root writes; drafter proposes.** Follow
+  [`agents.md`](../devrites-lib/reference/standards/agents.md). The controlling chat owns
+  human questions, decisions, reconciliation, and planning writes.
+- **Nested repair preserves its caller.** When `state.md` contains a valid
+  technical-backtracking return cursor, preserve any valid return cursor
+  byte-for-byte. `/rite-vet` is the next internal prerequisite, not a command to
+  hand back to the human.
+
+## Workflow
+0. Read `.omp/skills/devrites-lib/reference/standards/core.md` (operating rules) before reshaping anything.
+   Then resolve the explicit or active slug, require its `state.md`, and read
+   the cursor directly.
+1. Read `spec.md`, `decision-coverage.md`, `plan.md`, `tasks.md`, `state.md`, `drift.md`,
+   `eng-review.md`, and the current `git diff` (if a repo). Read `decisions.md` and
+   `assumptions.md`. Require `Decision coverage: CLEAR`; otherwise STOP → `/rite-clarify`.
+   Apply `.omp/skills/devrites-lib/reference/standards/tooling.md`: use the
+   primary available structural index, and cross-check only for a named unresolved
+   predicate rather than reassurance. For an external
+   dependency's current API surface, consult context7 if available.
+2. **Pick the mode** (`$ARGUMENTS` or infer): Apply the marked action before writes and
+   retain its decision/coverage evidence.
+   - **decompose:** first/again break the feature into vertical slices.
+   - **reslice:** a slice is too large; split into thinner end-to-end slices.
+   - **repair:** a Spec Drift Guard event; fold the resolution into plan + tasks.
+   - **reorder:** fix the dependency order.
+   - **split:** separate backend/frontend contracts (see `devrites-api-interface`).
+   - **unblock:** a verification failed; re-route around the blocker.
+   - **course-correct:** mid-build user pivot; apply the marked action, choose
+     rollback/forward-fix, and update permitted artifacts atomically (`MVP cut` is the named retreat).
+   - **revise:** reconcile a requested artifact revision; propose/confirm its file set and
+     **never edit source**. Only explicit `/rite-upgrade` with a `repairable` assessment naming
+     rule, evidence, gate, paths, and delta can authorize its neutral workspace edit—not source/history.
+     **Revise or new?** Same intent? >50% scope survives? Original not completable without it?
+     Two “no” answers mean new work: seal/ship current scope (`MVP cut` if named), then
+     `/rite-spec`, and stop.
+   See [replan-and-repair](reference/replan-and-repair.md) for each mode's steps.
+2a. **Draft fresh.** Dispatch `devrites-plan-drafter` in `repair` mode with frozen mode,
+   affected artifacts, settled contract, and failure/drift. Await one atomic, read-only
+   the drafter's `candidate_files` bundle; human choices return separately.
+   When the observed failure is missing or ambiguous consumptive-action evidence,
+   require the drafter to apply `one-shot-actions.md` and return the bounded
+   diagnostic-amplification design, injective boundary map, per-seam fixtures, and
+   collision mutant. Past evidence loss is not terminal. The drafter supplies no bodies.
+   Bind exact active `.devrites/work/<slug>/` targets and executable contract; after Vet READY, root
+   materializes the exact vetted workflow-artifact paths under
+   [`workflow-artifacts.md`](../devrites-lib/reference/standards/workflow-artifacts.md)
+   without dispatching the product wright.
+3. Reason about dependencies: [dependency-graph](reference/dependency-graph.md).
+   Reconcile the horizon register against `../rite-define/reference/plan-template.md`.
+   Preserve every `HZN-###` and unresolved item. Cite evidence when reclassifying the earliest
+   honest decision point; resolution or supersession also needs evidence. Never silently delete
+   an item. Planning choices resolve from source evidence or become bounded risk spikes with
+   discriminating criteria and fallback branches; local/checkpoint entries retain their owner,
+   trigger, bounds/fallback, and proof. A new human-owned blocker stops to `/rite-clarify`.
+   Reconcile `plan.md`'s canonical `Shared contract proof`: changed provider/consumer
+   boundaries keep one reused contract artifact ahead of both asserting tests, and unaffected
+   plans retain the specific no-impact statement. Missing, one-sided, duplicated-contract, vague, or
+   non-consuming proof routes to `/rite-vet` only after repair.
+   Reconcile the spec applicability map and retain every applicable standard's required
+   topology/data/integration owner, failure/recovery, deployment order, and proof output.
+   **Completion:** the slice graph is cycle-free and every dependency names an existing slice.
+4. Re-slice using vertical-slice rules: [slicing](reference/slicing.md) and
+   [task-breakdown](reference/task-breakdown.md). Prefer thin, shippable, verifiable.
+   **Completion:** every slice is independently shippable/provable or carries an irreducibility reason.
+5. Reconcile the candidate against steps 3 and 4, then the root updates `plan.md`, `tasks.md`,
+   `state.md`, and appends rationale to `decisions.md`.
+   Any change to `architecture.md`, `plan.md`, `tasks.md`, or `traceability.md` invalidates
+   the previous vet verdict: set `Phase: plan`, `Next step: /rite-vet`, and, when
+   `eng-review.md` exists, set `Implementation readiness: NEEDS REPLAN`. Never retain READY
+   across changed planning inputs. Preserve `Plan approved` only for behavior/acceptance-neutral
+   technical repair; clear it for a contract-changing or newly blocking horizon item and
+   reconfirm only after Clarify and Vet close it. If you stopped for drift,
+   mark the `drift.md` entry resolved. Never remove or overwrite a valid caller
+   return cursor while writing the Plan checkpoint.
+6. After editing `brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, or `questions.md`,
+   re-scan affected coverage, assumptions, uncertainty, and gates. Partial/Missing, unowned
+   material assumption, or open blocking/escalating question routes `/rite-clarify`/HITL.
+   Restore `CLEAR` only from current evidence.
+7. **Done when:** every slice is sized (builds + proves in one cycle; no slice scoring >3
+   left unjustified), the dependency order is acyclic, every `drift.md` entry you stopped for
+   is marked resolved, revised artifacts agree with each other, no source files changed in
+   `revise` mode, the marked action is complete, and every changed
+   plan ends at `/rite-vet` rather than returning directly to build; horizon IDs stay stable,
+   reclassifications cite evidence, and no unresolved item vanished. The `Shared contract proof`
+   table or justified no-impact statement must still match the revised boundary set.
+   If any check fails, loop back: don't hand off a half-reshaped plan.
+
+When invoked inline by a controlling rite, return the completed Plan checkpoint
+to that caller so it can invoke Vet immediately. The phase boundary is not a
+user-facing stop unless a genuine HITL, safety/access, or exhausted-recovery
+condition was recorded.
+
+> **Mid-flight discipline.** Do not change product behavior without confirmation or
+> absorb drift silently. See [`anti-patterns`](reference/anti-patterns.md).

package/pack/generated/omp/skills/rite-plan/reference/anti-patterns.md

@@ -0,0 +1,34 @@
+# rite-plan: anti-patterns
+
+Load this when standing a non-trivial re-plan decision, or when the agent
+feels reluctance toward asking the user before a behavior change.
+
+Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
+
+Authority: `.omp/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → reconcile `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md` atomically; invalidate Vet/readiness; Vet.
+- `GUARD_AND_REPAIR` → no planning writes; Spec Drift Guard → Clarify → Plan repair → Vet.
+- `BLOCKED_INPUT` → no planning writes; exact diagnostic; recover input; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## Phase-specific rationalizations
+
+| Excuse | Rebuttal |
+| --- | --- |
+| "User didn't ask for a re-plan." | A Spec Drift Guard event *is* a re-plan trigger: ask is courtesy, the route is automatic. |
+| "I can fix the slice mid-build, no need to update tasks." | `tasks.md` is the contract `/rite-build` reads. A fix that isn't there isn't visible to the next phase. |
+| "Reordering slices is cosmetic." | Dependency order controls risk discovery; risk-first wins because it surfaces blockers early. |
+| "This drift is small enough to absorb silently." | Silent drift = unrecorded decision = future "why does this work?" debugging session. |
+| "I can change product behavior to make the plan fit." | **RSLICE-PLAN-001** — Implementation convenience cannot rewrite product behavior. |
+| "Topology or a small criterion delta decides the route." | **RSLICE-PLAN-002** — Topology/count and “small” never override the canonical classifier; sufficient authoritative contract delta follows its mapped action. |
+| "Chat, stale material, or the convenient map is enough." | **RSLICE-PLAN-003** — Exact current byte-bound directives are authority; cached, remembered, summarized, paraphrased, or inferred chat and stale material are not. |
+
+## Red Flags
+
+- About to change product behavior, acceptance, or scope without asking the user.
+- `drift.md` entry unresolved while planning the next slice.
+- A "mode" invented that isn't one of `decompose / reslice / repair / reorder / split / unblock / course-correct / revise`.
+- Slices reordered without updating dependency notes: order changed, rationale didn't.
+- Repairing a drift event by silently widening the spec rather than narrowing the plan.

package/pack/generated/omp/skills/rite-plan/reference/dependency-graph.md

@@ -0,0 +1,48 @@
+# Dependency graph
+
+Order slices by what must exist before what. Keep it in `plan.md` as plain text.
+
+## Build the graph
+1. For each slice, list its hard prerequisites (a model it queries, an endpoint it
+   calls, a component it composes, a contract/schema/config it consumes, or a deployable
+   version that must already tolerate the change).
+2. Draw edges prerequisite → dependent.
+3. Topologically sort. Independent slices can be built in any order (or noted as
+   parallelizable for the user).
+
+```
+SLICE-001 (schema)  ->  SLICE-002 (write API)  ->  SLICE-003 (UI form)
+                   \->  SLICE-004 (read API)   ->  SLICE-005 (UI list)
+SLICE-006 (config)  -> independent
+```
+
+## Within a tier: risk-first
+Among slices that are equally unblocked, do the **riskiest** first: the one most
+likely to invalidate the plan (new integration, uncertain library behavior, migration).
+Finding drift early is cheap; finding it at seal time is not.
+
+## Smells
+- A slice with many prerequisites → probably too big; reslice for a thinner cut that
+  stands alone.
+- A cycle (A needs B needs A) → the boundary is wrong; split the contract
+  (`devrites-api-interface`) so one side can land against one canonical contract.
+  Do not hide the cycle with duplicated types, a service locator, or an unowned stub.
+- Everything depends on slice 1 → slice 1 is doing too much.
+- File-disjoint slices share a database migration chain, generated contract, lockfile,
+  queue/port, environment, or deployable → serialize that resource or isolate it explicitly.
+
+## Cross-boundary edges
+Mark edges that cross a frontend/backend or service boundary. Those slices should
+define the contract first (so both sides can proceed) and trigger `devrites-doubt`
+before standing the interface.
+
+After editing `tasks.md`, run `devrites-engine check task-graph <slug>` before Vet.
+`check readiness` and `check seal` also reject cycles, unknown dependencies,
+malformed tokens, duplicate slice IDs, a missing `Dependencies`/`depends_on`
+line, and a `depends_on` set that disagrees with `Dependencies`. Cycles or
+unknown dependencies block readiness.
+
+For monorepos/multiple repositories, annotate the proven root and deployable on each node.
+For data/integration changes, include recovery ordering: expand before new writers,
+backfill before contract, consumer compatibility before provider exposure, and monitoring
+before rollout. The graph is incomplete if code order is safe but deploy order is not.

package/pack/generated/omp/skills/rite-plan/reference/replan-and-repair.md

@@ -0,0 +1,73 @@
+# Re-plan & repair modes
+
+`/rite-plan` runs in one of these modes. Pick from `$ARGUMENTS` or infer from state.
+
+Authority: `.omp/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → reconcile `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md` atomically; invalidate Vet/readiness; Vet.
+- `GUARD_AND_REPAIR` → no planning writes; Spec Drift Guard → Clarify → Plan repair → Vet.
+- `BLOCKED_INPUT` → no planning writes; exact diagnostic; recover input; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## decompose
+
+First (or fresh) breakdown into vertical slices. Use `task-breakdown.md` +
+`slicing.md`. Output: a populated `tasks.md` and an ordered `plan.md` graph.
+
+## reslice
+
+A slice proved too large (couldn't build+prove in one cycle, or its goal has multiple
+"and"s). Split into thinner end-to-end slices, preserving acceptance coverage: split
+**by the sizing rule, not to a target count**. Update `tasks.md`; renumber; fix
+dependency edges.
+
+## repair (after Spec Drift Guard)
+
+A drift event stopped the build. Steps:
+
+1. Read the `drift.md` entry and its classification.
+2. If the user answered a drift question, encode that decision in `decisions.md`.
+3. Update `spec.md` (only the affected sections) and `plan.md`/`tasks.md` to match
+   reality. Adjust acceptance criteria if they were wrong.
+4. Mark the `drift.md` entry **resolved** with the resolution + date.
+5. Resume at the corrected slice.
+Never quietly delete a requirement; use the marked action before contract edits.
+
+## reorder
+
+Dependency order is wrong or suboptimal. Recompute the graph (`dependency-graph.md`),
+re-sort risk-first within tiers, update `plan.md`'s implementation order.
+
+## split (backend/frontend contract)
+
+A slice couples two sides too tightly. Define the contract first (shape, status codes,
+errors: `devrites-api-interface`), then split into a backend slice (can land with a
+stub consumer) and a frontend slice (can land against a mock/real contract).
+
+## unblock
+
+An exhausted fingerprint blocks diagnosis, not symptom. Route around/reslice; escalate
+only for scope change. If proof removed that cause but symptom remains, keep the dead
+end and plan a new diagnosis/proof fingerprint. Never clear/reuse old one.
+
+## course-correct
+
+Mid-build user pivot. Apply the marked action, choose rollback or forward-fix, and
+update permitted artifacts atomically (`MVP cut` is the named retreat). Invalidate
+Vet/readiness when contract or topology changes.
+
+## revise
+
+Artifact-only reconciliation of `spec.md`, `architecture.md`, `plan.md`, `tasks.md`,
+or `traceability.md` — never source. Propose/confirm the file set first. Only explicit
+`/rite-upgrade` with a `repairable` assessment may authorize neutral workspace edits.
+
+Unchanged acceptance/behavior with non-equivalent `proposed_coverage` is a
+contradictory input: the canonical classifier blocks it — there is no fourth
+route (see `acceptance-preserving-reslice.md`).
+
+## Always
+
+Update `state.md` (phase, next step) and append a dated line to `decisions.md`
+explaining *why* the plan changed. Preserve mapped-action decisions.

package/pack/generated/omp/skills/rite-plan/reference/slicing.md

@@ -0,0 +1,65 @@
+# Slicing
+
+DevRites builds in **thin vertical slices**: each slice cuts through every layer it
+needs (data → logic → API → UI) and leaves the system in a working, testable state.
+
+## Vertical, not horizontal
+Horizontal ("build all models, then all controllers, then all views") delays working
+software and hides integration risk until the end. Vertical delivers a usable path each
+slice:
+```
+SLICE-001: Create a task   (DB + API + minimal UI)   -> user can create + test passes
+SLICE-002: List tasks      (query + API + UI)         -> user can see them
+SLICE-003: Edit a task     (update + API + UI)        -> user can modify
+SLICE-004: Delete a task   (delete + API + UI + confirm) -> full CRUD
+```
+
+## Sizing a slice
+A slice is the right size when it:
+- delivers one observable capability end-to-end;
+- can be built and proven in a single `/rite-build` → `/rite-prove` cycle;
+- has acceptance criteria you can verify with evidence;
+- can be rolled back on its own;
+- is worth its own review gate: a reviewer could meaningfully reject *this* slice while
+  approving its neighbor. If two slices can only pass or fail together, they're one slice.
+
+Too big if: it touches many unrelated files, or you can't name its single observable outcome.
+**The "and" test:** if the slice's *name* needs an "and" ("create **and** list tasks"), it's two
+slices: split on the "and". → reslice.
+
+Sizing isn't cosmetic. An agent builds a small or medium slice reliably in one pass but drifts on
+an outsized one, which is why a slice over `Complexity: 3/5` reslices (the `tasks.md` slice format
+in [`rite-define`](../../rite-define/SKILL.md)). Push every slice to the smallest cut that still
+stands alone end-to-end.
+
+## How many slices?: derive, don't dictate
+The slice **count is an output, not an input.** It falls out of the work: one slice per
+independently-shippable vertical increment that satisfies one (or a tight group of)
+acceptance criteria and passes the sizing test above. A 2-criterion feature is 1-2 slices;
+a 12-criterion feature is however many thin end-to-end cuts those 12 need.
+
+- **Never slice to a target number.** Don't pad a small feature into "5 slices" or
+  compress a large one into "3" because a figure was named.
+- **A user-supplied count is a hint at most.** If the user says "do it in 4", slice the
+  work logically first; if your honest decomposition differs, present the logical count
+  and *why*, then let them redirect: don't silently force their number.
+- **Re-size by the rule, not the tally** (`/rite-plan reslice`): split a slice because it
+  failed the sizing test, not to hit a count.
+
+Not to be confused with `.devrites/AFK` `max_slices`. That's an AFK *iteration budget*
+capping how many slices the unattended loop builds before it stops, **not** the plan's
+decomposition. The plan always holds exactly the slices the work needs; `max_slices` only
+limits how many run unattended.
+
+## First slice
+Make slice 1 the **thinnest useful end-to-end path**. It flushes out integration and
+convention surprises early, while changes are cheap.
+
+**Risk-first exception.** When the biggest risk is a technical *unknown*: "will this library
+even do X?", "can we hit the latency target?": let slice 1 (or a throwaway spike ahead of it)
+prove that unknown, even if it isn't the thinnest user-facing path. Fail the risky bet first,
+while pivoting is still cheap.
+
+## Slice independence
+Order by dependency, but minimize coupling. A slice that needs three other slices first
+is a smell: look for a thinner cut that stands alone.