devrites 4.0.12 → 4.2.0

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

@@ -7,34 +7,38 @@ user-invocable: true
 
 # $rite-plan: (re)plan an active feature
 
-Update an existing plan when implementation evidence, drift, or a user decision makes it
-wrong. **Read the active workspace first.** If `.devrites/ACTIVE` is empty or its workspace
-is missing, stop and tell the
-user to run `$rite-spec <feature>`. **Revise mode is artifact-only**: reconcile
+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 `.agents/skills/devrites-lib/reference/standards/`)
-Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD criteria.
+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 `.agents/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.
-- If a change alters product behavior, scope, architecture, data model, UX, security,
-  or migration risk → search facts first, then route the human-owned contract decision
-  through `$rite-clarify` (using the Spec Drift Guard). Reversible technical repair is
-  agent-owned and must not become a question.
 - Keep each slice small enough for one focused build → prove cycle.
-- **Slice count is derived, never dictated:** reslice when a slice fails the sizing rule
-  (multiple "and"s, can't build+prove in one cycle), not to hit a user-named tally. A
-  requested count is a hint at most; slice logically and explain if it differs. See
-  [`reference/slicing.md`](reference/slicing.md) ("How many slices?").
+- **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 all planning-artifact writes.
+  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
@@ -47,12 +51,9 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
 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`.
-   If a code-intelligence
-   index is available: `codebase-memory-mcp` first, cross-checked with `codegraph`
-   (`.codegraph/` / `codegraph_*` tools) + `graphify` (`graphify-out/`), else standard methods
-   (LSP / `Read`/`Grep`/`Glob`); see `.agents/skills/devrites-lib/reference/standards/tooling.md`:
-   prefer it for structural questions (what calls X, what would
-   changing Y break) over reading whole files, to keep planning context lean. For an external
+   Apply `.agents/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):
    - **decompose:** first/again break the feature into vertical slices.
@@ -61,41 +62,39 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
    - **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:** a deliberate mid-build *pivot* (the user changed their mind), distinct
-     from accidental drift: classify the change, assess its impact across the remaining slices,
-     decide rollback vs forward-fix, and update `spec.md` + `plan.md` + `tasks.md` + `decisions.md`
-     atomically. An acceptance/behavior change still goes through the user first. When the plan
-     names an `MVP cut`, offer it as the retreat option: falling back to the cut is a pre-agreed
-     scope, not a new negotiation.
-   - **revise:** apply a requested planning-artifact revision and reconcile existing artifacts in
-     any direction; propose the file edit set first, confirm each file before writing, and **never
-     edit source code**. The sole confirmation exception is explicit `$rite-upgrade` with an
-     admitted `repairable` assessment naming current rule, evidence, gate, exact paths, and
-     delta; it authorizes only that neutral workspace edit, never source or history.
-     **Gate first: revise or new?** Same intent? More than 50% of existing scope
-     survives? original *not* completable without this? Two "no"s → new work: recommend
-     sealing/shipping the current workspace (MVP cut if named) then `$rite-spec` for the new
-     intent, and stop. Revise preserves context; a new workspace separates the work.
+   - **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 the repair from fresh context.** Freeze the inputs and dispatch
-   `devrites-plan-drafter` in `repair` mode with only the selected mode, affected artifact
-   paths, settled contract, and observed failure/drift. Await one atomic `plan-candidate`;
-   the drafter writes nothing and returns human-owned choices separately.
+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
+   `plan-candidate`; 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 alone is not a terminal conclusion.
-   The drafter never supplies implementation bodies. Bind the exact active
-   `.devrites/work/<slug>/` targets and complete executable contract; after Vet
-   READY, the controlling root materializes the exact vetted workflow-artifact paths
-   under
+   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.
@@ -106,23 +105,21 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
    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 and reconfirm it when the contract changed. If you stopped for drift,
+   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. If product behavior/acceptance criteria change, confirm through `$rite-clarify` before
-   writing, re-close `decision-coverage.md`, then reconcile the plan. After any edit to
-   `brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, or `questions.md`, including a
-   behavior-neutral technical rationale appended to `decisions.md`, re-scan the affected coverage
-   rows, assumption audit, residual uncertainty, and closed gates. Partial/Missing, an unowned
-   material assumption, or an open blocking/escalating question routes `$rite-clarify`/HITL.
-   Re-read every affected row and require current evidence before restoring `CLEAR`.
-   **Completion:** the change is classified, and every behavior/acceptance change has explicit
-   confirmation recorded before the artifacts are updated.
+6. Apply the marked action before writes and retain its decision/coverage evidence.
+   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, behavior-change-vs-not is confirmed (`no`, or clarified), and every changed
-   plan ends at `$rite-vet` rather than returning directly to build. The `Shared contract proof`
+   `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.
 

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

@@ -5,6 +5,14 @@ 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: `.agents/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 |
@@ -13,7 +21,9 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 | "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." | Behavior change always asks the user first, no exceptions. |
+| "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
 

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

@@ -4,7 +4,8 @@ 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).
+   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).
@@ -24,10 +25,18 @@ Finding drift early is cheap; finding it at seal time is not.
 - 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 with a stub.
+  (`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.
+
+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/codex/skills/rite-plan/reference/replan-and-repair.md

@@ -2,6 +2,14 @@
 
 `$rite-plan` runs in one of these modes. Pick from `$ARGUMENTS` or infer from state.
 
+Authority: `.agents/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.
@@ -20,8 +28,7 @@ A drift event stopped the build. Steps:
    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 repair by quietly deleting the inconvenient requirement, if behavior changes,
-that was a user question.
+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`),
@@ -39,4 +46,4 @@ end and plan a new diagnosis/proof fingerprint. Never clear/reuse old one.
 
 ## Always
 Update `state.md` (phase, next step) and append a dated line to `decisions.md`
-explaining *why* the plan changed. Ask the user before any product-behavior change.
+explaining *why* the plan changed. Preserve mapped-action decisions.

package/pack/generated/codex/skills/rite-plan/reference/task-breakdown.md

@@ -19,6 +19,8 @@ This reference owns decomposition; the shared schema owns field names and meanin
    provider/consumer boundary, map the plan's `Shared contract proof` artifact before its
    provider- and consumer-side asserting tests; both tests consume that same artifact and
    their slice dependencies preserve the order. Do not duplicate the contract in each slice.
+   For each applicable topology/data/integration row, assign its owner, failure/recovery
+   case, and proof to a slice; preserve deployment/resource ordering from the plan.
 5. Write or update `traceability.md` so every `AC-###` maps to ≥1 `SLICE-###`, a
    planned proof, evidence status, and likely touched files.
 6. Sanity check: every acceptance criterion in `spec.md` maps to ≥1 slice; no slice has

package/pack/generated/codex/skills/rite-polish/reference/adr-promotion.md

@@ -1,11 +1,11 @@
 # ADR promotion
 
-Promote only durable architecture or interface decisions from `decisions.md`; slice-local
-calls remain in the archived workspace. Do this during Polish before Review. If the
-project has no `docs/adr/`, ask before creating that convention.
+During Polish, promote a `decisions.md` architecture/interface choice only when it is
+hard to reverse, surprising without context, and a real trade-off. Otherwise leave it in
+the archived workspace. If the project has no `docs/adr/`, ask before creating that
+convention.
 
 Write the next append-only `docs/adr/ADR-NNN.md` with Context, Decision, Status
-`accepted`, and Consequences. Never rewrite an accepted ADR; supersede it with a new ADR
-that links the old one. Add every promoted ADR to the authoritative candidate
-manifest, run affected real re-proof, and refresh evidence/browser bindings before
-Review. Ship performs no ADR promotion.
+`accepted`, and Consequences. Never rewrite an accepted ADR; supersede it with a linked
+new ADR. Add it to the candidate manifest, run affected real re-proof, and refresh evidence
+and browser bindings before Review. Ship performs no ADR promotion.

package/pack/generated/codex/skills/rite-pressure-test/SKILL.md

@@ -7,42 +7,35 @@ user-invocable: true
 
 # $rite-pressure-test: diverge then converge
 
-Use when the *idea* (not just the requirements) is rough. Generate options, then commit
-to one, so `$rite-spec` has a real direction to specify.
-
-A thinking stance, not a build phase: capturing thinking is not implementing. Write
-workspace/ticket artifacts freely; source edits wait for `$rite-build`, via `$rite-spec`.
-
-Read `.agents/skills/devrites-lib/reference/standards/core.md` first: its operating rules (no silent assumptions, prefer
-existing conventions) shape the divergence. The other rule files load on demand.
+Use when the idea—not only requirements—is rough. Compare directions before
+`$rite-spec`; never implement. Read [`core.md`](../devrites-lib/reference/standards/core.md)
+first and write only workspace/ticket artifacts.
 
 ## Diverge (widen)
-- Search the current `decisions.md`, accepted ADRs, and directly relevant archived
-  Markdown for prior rejected directions. Reconsider one only when new evidence answers
-  its recorded reason; cite both the rejection and the new evidence.
-- Generate 3-5 genuinely different approaches to the underlying goal, not variations of
-  one. Cover at least: the obvious approach, a simpler/smaller approach, and a
-  different-shape approach (different data model, flow, or boundary).
-- Generate from **named lenses** so each option exists for a reason, not to pad the count:
-  *inversion* (do the opposite), *constraint-removal* (what if the hard limit vanished),
-  *audience-shift* (build it for a different user), *10×* (what if it had to handle ten times
-  the scale or scope), *expert-lens* (how a specialist in the domain would do it). Borrow the
-  *structure* of an analogous product, not its surface. "Uber for X" copies the veneer, not
-  the mechanism that made it work.
-- For each: one-line description, what it optimizes for, rough cost, main risk.
-- Stay concrete: name real entities, flows, and surfaces, not abstractions.
+- Search `decisions.md`, accepted ADRs, and relevant archives for rejected directions;
+  revive one only with evidence that answers its recorded reason, citing both.
+- Generate 3-5 different shapes, including obvious, smaller, and different-boundary/data/
+  flow options. Use named lenses— inversion, constraint removal, audience shift, 10×, or
+  expert practice—without padding. Borrow analogous mechanisms, not branding.
+- For each, name concrete entities/flows/surfaces, optimization, rough cost, and main risk.
 
 ## Converge (commit)
 - Weigh options against the goal, constraints, and existing codebase conventions.
-- **Painkiller or vitamin?** Score each on whether it removes a real, felt pain (a painkiller
-  users seek out) or is merely nice-to-have (a vitamin they forget). Prefer the painkiller: a
-  vitamin dressed as a painkiller is the most common ideation trap.
-- **Rank the differentiation**, strongest to weakest: a new capability > a 10× improvement > a
-  new audience > a new context > better UX > cheaper. The higher an option sits, the more
-  defensible the direction.
+- Prefer felt pain over nice-to-have. Rank differentiation: new capability > 10× gain >
+  new audience > new context > better UX > cheaper; do not dress a vitamin as a painkiller.
 - Recommend one, with the reason and the key trade-off accepted.
 - Note what would change the recommendation (the decision's hinge).
 
+## Premise evidence floor
+
+If the hinge is an uncertain material fact, freeze at most three questions for
+`devrites-evidence-scout`. Validate every citation; missing/malformed/unverifiable output is
+`unavailable`, never support. Record claim, support, strongest contrary evidence, and
+`supported | assumption | refuted`. Refutation changes the recommendation; an assumption
+advances only when non-decisive with bounded downside. Weak/conflicting decisive evidence
+returns **Hold** with the resolving evidence, never `$rite-spec`. Do not research preferences
+or reversible implementation choices.
+
 ## Boundaries
 - This is exploration, not specification. Output a **direction**, not a finished spec:
   `$rite-spec` writes the spec.
@@ -60,9 +53,9 @@ existing conventions) shape the divergence. The other rule files load on demand.
 ```
 Done: pressure test complete for <goal>.
 Changed: workspace only
-Evidence: options compared <n>; recommendation <option>; hinge <condition>
-Open: <none | unresolved premise>
-Next: $rite-spec <feature>
+Evidence: options compared <n>; recommendation <option>; hinge <condition>; premises <supported/assumption/refuted + sources>
+Open: <none | unresolved premise and resolving evidence>
+Next: <when supported: $rite-spec <feature>; when Hold: none — requires <resolving evidence>>
 Record: not applicable
 ↻ Hygiene: /clear before starting the lifecycle
 ```