devrites 5.10.2 → 5.12.0

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

@@ -0,0 +1,104 @@
+---
+name: rite-handoff
+description: "User-invoked handoff writer: sync chat-only context into `.devrites/` and write a fresh-agent handoff."
+argument-hint: "[what the next session will focus on]"
+triggers:
+  - user
+---
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","rite-handoff/reference/handoff-template.md","devrites-lib/reference/reply-contract.md"],"triggers":{"hygiene":["devrites-lib/reference/standards/context-hygiene.md"]}} -->
+> Read-set manifest: `devrites-engine context [slug] --skill rite-handoff` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+# /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, and run
+`devrites-engine handoff [slug]` — its resume record (cursor, `awaiting_human`,
+blocking question gates, the `gates.md` reduction, `decisions.md` dead ends,
+read-next order) is the deterministic spine of the handoff doc's **Resume**,
+**Read next**, and **Next action** sections. The chat adds what the workspace
+cannot hold; the engine supplies what the workspace already knows.
+
+## 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`](../devrites-lib/reference/standards/context-hygiene.md)):
+```
+↻ Hygiene: /clear
+```

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

@@ -0,0 +1,74 @@
+---
+name: rite-learn
+description: Review recurring cross-feature evidence and propose durable project guidance.
+argument-hint: "[\"<lesson or rejected direction>\"]"
+triggers:
+  - user
+---
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/documentation.md","devrites-lib/reference/standards/tooling.md"],"workspace":["state.md","decisions.md","drift.md","evidence.md","review.md","seal.md","questions.md"],"workspaceByRole":{"retrospector":["state.md","decisions.md","drift.md","evidence.md","review.md","seal.md","questions.md"]},"triggers":{"agents":["devrites-lib/reference/standards/agents.md"]}} -->
+> Read-set manifest: `devrites-engine context [slug] --skill rite-learn` bundles every file named below into one deduplicated read.
+
+# /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`](../devrites-lib/reference/standards/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/devin/skills/rite-plan/SKILL.md

@@ -0,0 +1,191 @@
+---
+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]"
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/acceptance-preserving-reslice.md","devrites-lib/reference/standards/tooling.md","devrites-lib/reference/standards/agents.md","rite-plan/reference/slicing.md","rite-plan/reference/replan-and-repair.md","rite-plan/reference/dependency-graph.md","rite-plan/reference/task-breakdown.md","rite-plan/reference/anti-patterns.md","rite-define/reference/plan-template.md"],"triggers":{"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"one-shot":["devrites-lib/reference/standards/one-shot-actions.md"],"assumption-delta":["devrites-lib/reference/standards/assumption-checkpoints.md"],"workflow":["devrites-lib/reference/standards/development-workflow.md"],"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","drift.md"],"workspaceByRole":{"plan-drafter":["brief.md","spec.md","plan.md","tasks.md","decision-coverage.md","questions.md","decisions.md","assumptions.md","architecture.md","state.md","drift.md"]}} -->
+> Read-set manifest: `devrites-engine context <slug> --phase plan` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+
+# /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 `.devin/skills/devrites-lib/reference/standards/`)
+Pull [`development-workflow.md`](../devrites-lib/reference/standards/development-workflow.md) via `Read` when reshaping slice cadence or DoD
+criteria.
+Load [`repository-topology.md`](../devrites-lib/reference/standards/repository-topology.md), [`data-integrity.md`](../devrites-lib/reference/standards/data-integrity.md), or [`integration-reliability.md`](../devrites-lib/reference/standards/integration-reliability.md)
+when the spec applicability map or observed drift triggers them.
+Load [`assumption-checkpoints.md`](../devrites-lib/reference/standards/assumption-checkpoints.md) (trigger `assumption-delta`)
+when scope introduces a second case, an optional field, or a chosen-over-derived value.
+Before classifying any Reslice, read `.devin/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 `.devin/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 `.devin/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`](../devrites-lib/reference/standards/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.
+   A repair candidate carries a delta self-check scoped to what the patch
+   touches: which intersected invariants it re-verified, with evidence of no
+   correction-created regression. Global re-derivation (ID/edge/HZN counts,
+   acyclicity) runs on materialized artifacts at the step-7 gate — the drafter
+   never re-derives them by exhaustive search. It also carries a bounded
+   self-attack over the delta (`self_attack_exposures`), catching the shallow
+   next-round findings before Vet's dispatch rather than after a full loop.
+   Root dispositions every exposure — fold as a finding, accept as a declared
+   residual, or reject with reason; none silently drops.
+   Packet mechanics: dedupe at assembly — findings with an identical
+   required-fix and site set merge into one entry that closes all their
+   fingerprints. The packet may carry digest-pinned site excerpts so the
+   drafter spot-verifies anchors instead of re-scanning whole files, and root
+   may partition findings into anchor-disjoint clusters with one drafter per
+   cluster in parallel — findings sharing any anchor or mirrored clause stay
+   in one cluster, and each bundle applies independently. A `partial`-
+   continuation re-dispatch continues the same packet; it does not advance the
+   same-seam counter. Count consecutive repair packets whose findings' cited clause sets overlap
+   the immediately previous packet's — the overlap is the seam. Carry it as an explicit
+   integer `same_seam_count` in every packet (previous value + 1 when the seam repeats,
+   else 1) so the threshold is counted rather than judged; a packet that reports the same
+   seam without the counter is malformed. At the third
+   same-seam packet, mark it `convergence_pressure: true` with the seam named.
+   Under pressure the drafter may close a finding marked as a refinement of an
+   already-pinned clause by folding an explicit, bounded declared
+   residual/limitation into the contract text instead of another precision
+   pin — never for a `new_failure_mode` finding. Every finding still gets one
+   disposition; none is skipped. A fourth same-seam packet that still carries
+   `new_failure_mode` findings means the seam is under-specified, not
+   under-repaired: route a declare-limitation-or-continue choice to
+   `/rite-clarify`. AFK records the suspect seam in `state.md` and continues
+   within budgets — a coverage limitation is a product decision and is never
+   auto-declared.
+   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`. A rejected candidate
+   (malformed bundle, stale or non-unique anchor) or a drafter `Outcome: gap`
+   is one no-progress outcome on every open fingerprint in the fold; the
+   re-dispatch packet must name the rejection so the same hunks don't recur.
+   A gap naming genuinely human-owned information routes to `/rite-clarify`.
+   A drafter `Outcome: partial` is progress: materialize its complete findings,
+   then re-dispatch a narrowed packet for `remaining_findings` with anchors
+   re-derived from the just-updated files — same repair pass, fresh context.
+   A partial covering zero findings counts as no-progress. Findings in
+   `blocked_findings` route to `/rite-clarify`, never the re-dispatch.
+   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 open `drift.md` entry
+   was folded in one pass and marked resolved, the delta self-check is recorded,
+   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.
+
+When invoked directly with no controlling caller and a planning artifact
+changed, become the caller for the mandated next step: save a return cursor
+(`return_phase`/`return_next_action`) naming this Plan pass as the caller —
+a direct Plan has no caller above it, so without the saved cursor Vet reads
+itself as top-level and its verdict becomes a user-facing command. Invoke
+`/rite-vet` inline and consume its results — `NEEDS REPLAN` re-enters repair
+internally under the fingerprint caps and is never emitted as a user-facing
+command; `NEEDS CLARIFICATION` and human-owned gates still reach the user.
+Stop only at Vet's boundary (READY readback; next step `/rite-build`). An
+unchanged plan keeps its recorded next step.
+
+> **Mid-flight discipline.** Do not change product behavior without confirmation or
+> absorb drift silently. See [`anti-patterns`](reference/anti-patterns.md).

package/pack/generated/devin/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: `.devin/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/devin/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/devin/skills/rite-plan/reference/replan-and-repair.md

@@ -0,0 +1,105 @@
+# Re-plan & repair modes
+
+`/rite-plan` runs in one of these modes. Pick from `$ARGUMENTS` or infer from state.
+
+Authority: `.devin/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` entries and their classifications. Fold EVERY open entry
+   and accepted finding for the affected artifacts in ONE pass, never serially.
+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.
+   **Write the pointer, not the history.** Name the findings a fold closes by ID, one line
+   of meaning each; never restate prior folds, prior DEC lists, or closed-round narrative in
+   `architecture.md`/`plan.md`/`tasks.md`/`traceability.md`. That text belongs in
+   `decisions.md`, or in `history/` via [Budget relocation](#revise) once closed, so each
+   fold appends a bounded line. A banner that grows with the round count is the defect.
+4. Mark each `drift.md` entry **resolved** with the resolution + date.
+5. **Self-check and self-attack the repaired candidate on the delta before
+   handoff** — re-verify every invariant the correction touched (acyclic
+   dependency graph, bidirectional traceability, Shared contract proof vs
+   boundary set, sizing, no correction-created regression), then probe the
+   delta against the reviewers' attack classes (race/observation windows,
+   alias escapes, ordering gaps, capability gaps, unbounded blocking,
+   happy-path-only coverage); fold a fix or a named bounded residual into
+   the same pass. Record both in the Plan
+   checkpoint; Vet's recheck verifies it rather than rediscovering the defect a
+   loop later.
+6. 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.
+
+**Feature-ceiling cut.** When unbuilt slices exceed the
+[feature ceiling](slicing.md#feature-ceiling-split-an-epic-never-override-the-budget),
+`MVP cut` keeps the built slices plus the thinnest shippable unbuilt subset here; the
+remaining slices, their REQ/AC IDs and proof rows move verbatim into a named
+continuation list (spec `Non-goals` → future `/rite-spec <slug>-2`, `-3`, …) through
+the Spec Drift Guard. IDs never renumber; each ID is owned by exactly one workspace.
+Record the sequence once in `decisions.md`.
+
+## 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`](../../devrites-lib/reference/standards/acceptance-preserving-reslice.md)).
+
+**Budget relocation** (admitted by `/rite-upgrade`, or by the phase owner when
+`orient` reports `over: true`): move checkpoint narrative, historical fold text and
+closed-round accounts verbatim from `state.md`/`tasks.md`/`plan.md`/`architecture.md`/
+`eng-review.md` into `history/<file>-<YYYYMMDD>.md`, packets/accounts from the root
+into `packets/`, leaving a one-line pointer. Cursor, live slices, open findings, IDs,
+answers, decisions and bindings stay unchanged; nothing is deleted or reworded.
+Re-emit the readiness binding when a readiness input moved.
+
+## Always
+
+Update `state.md` (phase, next step) and append a dated line to `decisions.md`
+explaining *why* the plan changed. Preserve mapped-action decisions.