devrites 3.2.28 → 4.0.0

package/pack/generated/claude/skills/rite-build/reference/wright-dispatch.md

@@ -1,135 +1,45 @@
 # Slice-wright dispatch
 
-`/rite-build` delegates one slice or correction to `devrites-slice-wright`.
-The root owns scope, questions, `.devrites/**`, reconciliation, and routing.
-Production builds and browser/E2E runs are root-owned gates only when their exact
-command, cwd, prerequisites, and artifact boundary are already frozen in
-`test-plan.md` and the unchanged packet.
-The wright only writes source/tests, runs writer-safe proof, and never invokes agents.
-
-The universal packet, result, budget, await, retry, and host fallback contract is
-[`standards/agents.md`](../../devrites-lib/reference/standards/agents.md). This file adds
-only the source-write lifecycle.
-
-## Prepare and dispatch
-
-1. Derive the smallest exact file allowlist from the selected slice, current code
-   placement, and accepted correction set. Entries are normalized project-relative file
-   paths: no directories, globs, traversal, symlink escapes, duplicates, or
-   `.devrites/**`.
-2. Write that list, one path per line, to
-   `.devrites/work/<slug>/.wright-allowlist` (or the active compatibility workspace).
-   The root owns this file; the wright's returned `Files changed` is evidence, never
-   authorization. If a necessary unlisted path appears, the wright stops and returns it.
-3. Create `agent-packet/v1` for `devrites-slice-wright`. Put the identical paths in
-   `scope.allowed_repo_writes`; include the slice goal, verbatim acceptance, boundary,
-   exact context paths, test-plan targets, and applicable standards. Do not include the
-   root's implementation reasoning.
-4. Immediately before a serial dispatch:
-
-   ```bash
-   devrites-engine stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>"
-   devrites-engine reconcile snapshot
-   ```
-
-   A Forge slice runs `forge plan` first, then takes this same snapshot; see
-   [`forge.md`](forge.md). The first snapshot captures the original dirty-tree baseline, private Git objects,
-   allowlist, and canonical-state fingerprint. A later snapshot after a clean check
-   refreshes only the dispatch boundary; it retains the original slice baseline.
-5. Fresh-context dispatch the wright through the capability ladder and await its typed
-   result. Never run two possible writers in one tree.
-
-## Forge candidate binding
-
-[`forge.md`](forge.md) owns the state machine. This file owns the candidate packet:
-use the same project-relative allowlist and slice contract, add only the manifest-recorded
-candidate strategy, and set all five bindings before the first tool call:
-
-```text
-DEVRITES_FORGE_RUN_ID
-DEVRITES_FORGE_CANDIDATE
-DEVRITES_FORGE_WORKER_ID
-DEVRITES_FORGE_WORKER_PID
-DEVRITES_FORGE_PROCESS_START
-```
-
-The candidate cwd must equal its manifest worktree, and the environment is all-or-none.
-Only a real adapter declared as `manifest-env-v1` may supply it. The live PID,
-engine `forge process-token` value, and worker ID must match the prior `forge record ... started`
-transition. A partial or mismatched binding denies the writer; return to the orchestrator
-instead of widening scope. The candidate writes only source/tests in its own tree and
-returns the normal typed artifact.
-
-## Validate the return before accepting it
-
-Validate the `agent-result/v1` identity, baseline, budget, payload type, side effects,
-and exact changed-file set. Before the root writes any canonical record, run:
-
-```bash
-devrites-engine reconcile check; echo "reconcile rc=$?"
-devrites-engine test-integrity; echo "test-integrity rc=$?"
-```
-
-- Reconcile `5`: reject; run standalone `devrites-engine reconcile abort` to restore
-  pre-snapshot source/user work and close with a receipt. Never widen scope.
-- Test integrity `3`: a test was deleted, muted, focused, or de-asserted. Treat it as a
-  Critical protocol failure and correct it through the wright.
-- A setup/corrupt-baseline error blocks acceptance; never fall back silently to `HEAD`.
-
-The clean reconcile check records that source has not changed since inspection. The
-baseline and private object database stay open until every later gate succeeds.
-
-## Decisions, failures, and bounded recovery
-
-After the immediate check, independently doubt every `Decisions stood` item. Human-owned
-product, policy, public-contract, irreversible-risk, or human-only access decisions use
-their real gate. Objective red tests, browser/runtime failures, missing technical
-coverage, package-scanner defects, and review corrections stay agent-owned.
-
-Classify each causal fingerprint through
-[`cleanup-and-classify.md`](../../devrites-debug-recovery/reference/cleanup-and-classify.md).
-The engine route is canonical; technical defects stay agent-owned.
-Each objective root cause then shares one durable three-attempt budget:
-
-```bash
-devrites-engine recovery route <class>
-devrites-engine recovery record --class <class> "<root cause>" "<exact failure>" <slug>
-devrites-engine recovery check "<root cause>" <slug>
-```
-
-Before every retry:
-
-1. update `.wright-allowlist` only for an accepted path still inside the settled slice;
-2. run `devrites-engine reconcile snapshot`.
-
-That refresh requires the prior clean check, re-fingerprints root-owned state, and keeps
-the original source baseline. Re-dispatch with the exact output, attempt count, and dead
-ends. Then repeat reconcile and `test-integrity` from zero. Clear recovery only after
-green with `recovery clear --class <class> "<root cause>" <slug>`. An exhausted objective
-failure becomes a technical blocker with its reproduction, not a `rite-resolve` question.
-
-## Close and record
-
-Run the root gates and final reconciliation from `phase-contract.md` step 5. Then:
-
-```bash
-devrites-engine reconcile close
-```
-
-Only then persist `state.md`, `evidence.md`, `touched-files.md`, decision/doubt records,
-and browser evidence. Keep the retained window across a genuine human wait that will
-resume the same slice. Close it before abandoning the slice for a scope/plan transition.
-
-## Host dispatch
-
-Use the named wright. Hidden V2 `agent_type` is not V1/unavailable: send
-`agent_type=devrites-slice-wright` anyway. Use guarded generic only after explicit
-V1; if V2 rejects the call, stop before generic/default. The rollout proves role,
-wait, and result. Root hooks keep the pending canonical boundary current until spawn, then freeze it apart from the
-retained source baseline: pre-start root recovery records are excluded, while
-post-start canonical changes fail.
-Any generic worker still needs the exact allowlist or an isolated checkout;
-reconciliation alone is insufficient. If no safe fresh-agent rung is available, stop
-for HITL. On Codex, `reconcile check` and `reconcile close` require the completed
-wright receipt bound to the current reconcile snapshot.
-The root never performs wright work.
+`/rite-build` gives one bounded task to exact `devrites-slice-wright`.
+Root owns scope, artifacts, inspection, and routing but never writes source/tests; only
+the wright writes them and invokes no agent.
+
+## Host gate
+
+Follow the canonical [source-writing boundary](../../devrites-lib/reference/standards/agents.md#source-writing-boundary):
+Claude grants only the exact wright `acceptEdits`; Codex uses its workspace root,
+the exact `:workspace` wright, and read-only specialists. Never bypass/substitute
+the wright or recreate an engine bridge.
+
+## Prepare
+
+1. Derive the smallest exact project-relative source/test path list; reject
+   directories/globs, traversal, symlink escapes, duplicates, and `.devrites/**`.
+2. Put it in the task with goal, verbatim acceptance, exclusions, context,
+   `test-plan.md` proof commands, and applicable standards.
+   A new path requires a new bounded contract; the wright cannot widen the task.
+3. Record `git diff --name-only` before dispatch so unrelated work remains
+   distinguishable.
+
+## Run
+
+Ask the host for the exact writer in fresh context and wait. Never run two
+writers in one worktree or substitute a generic agent.
+
+## Inspect and prove
+
+1. Compare the returned file list and `git diff --name-only` with task paths.
+   Reject a result that omits any required key, including empty-or-filled
+   bookkeeping arrays, or adds a path. Restore only through the same bounded
+   wright; root never widens scope or edits source.
+2. Inspect the test diff for deletion, skipping, focus markers, or loosened
+   assertions. Dedicated test analysis treats weakening as Critical.
+3. Run only repository proof already approved by `test-plan.md`, then inspect
+   `git diff --name-only` again in case a proof tool changed source.
+4. Challenge decisions. Human choices return; native diagnosis routes failures.
+   The root counts the wright plus recovery failures by causal fingerprint from
+   the current context and recorded Dead ends/evidence. Three total failed
+   attempts is the limit; persist each and never dispatch a fourth related try.
+5. Reconcile returned reuse, conventions, principles, sources, assumptions,
+   decisions, dead ends, follow-ups, gates, and touched files. Persist the
+   relevant facts in canonical artifacts, not the wholesale report.

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

@@ -1,9 +1,8 @@
 ---
 name: rite-clarify
-description: Run the topology-first decision-coverage scan after rite-spec and before strategy or architecture. Audit actors, journeys, states, data, integrations, operations, proof, assumptions, and must-NOT boundaries; close Partial/Missing rows and emit decision-coverage.md CLEAR. Use for missing/stale coverage or a missed pre-build product decision.
+description: Audit a completed spec for missing decisions before strategy or architecture. Use after /rite-spec when coverage is incomplete or stale; not for spec writing.
 argument-hint: "[feature-slug]"
 user-invocable: true
-required-agent-roles: none
 ---
 
 # /rite-clarify: resolve product decisions
@@ -36,46 +35,53 @@ dispatch uses
 
 ## Workflow
 
-0. **Orient.** Run `devrites-engine preamble` and `snapshot`. Require `spec.md` plus
-   `Spec gate: passed`; otherwise STOP → `/rite-spec`. For a later-phase retrofit, run
-   `devrites-engine clarify-return enter <slug>` **before any pause**; this persists the
-   return cursor and enters `Phase: clarify`.
-1. **Enumerate topology** from the spec, references, live code, and prior decisions: actors,
-   journeys/components, states, data lifecycles, interfaces/integrations, operations, and
-   proof. Add omitted surfaces to the spec. **Completion:** every material surface appears
-   once with a source or canonical spec reference.
-2. **Scan coverage** with `devrites-interview /clarify mode` and the reference taxonomy.
-   Mark each surface Clear/Partial/Missing with evidence; include must-NOT and out-of-scope
-   behavior. Unmentioned never means not applicable. **Completion:** the matrix records every
-   surface with evidence.
-3. **Eliminate factual unknowns** through code intelligence, project/decision docs,
-   manifests/lockfiles, and authoritative external docs. Dispatch independent topology/fact
-   questions to `devrites-evidence-scout` (maximum three at once), await the cited dossiers,
-   and reconcile them in the root context. The root folds accepted facts into `spec.md` or
-   `assumptions.md`; the scout never asks or writes. **Completion:** each factual unknown is
-   source-backed or reclassified as an owned decision/assumption.
-4. **Audit assumptions and decisions.** Record the fields required above. For high-cost or
-    hard-to-reverse product/constraint choices, present two or three viable options, recommendation
-   first. A genuinely undecidable behavior may take one bounded `/rite-prototype` detour.
-5. **Close human-owned gaps** using the shared option-set contract: one highest-impact packet
-   per turn. Persist answers immediately in `spec.md` plus `decisions.md`/`questions.md`.
-   AFK remains within its gate ceiling; irreversible risk and principle exceptions pause.
-6. **Re-scan after edits** until each material row is `closed`, `agent-owned`,
-   `not-applicable`, or justified `deferred-nonblocking` with owner and validation gate.
-   Partial/Missing, an unowned material assumption, or an open blocking/escalating question
-   means `NEEDS CLARIFICATION`.
-7. **Write the verdict.** Update `decision-coverage.md`; success requires exactly one
-   `DevRites contract: devrites.readiness-artifacts.v2` field and exactly
-   `Decision coverage: CLEAR`. Normal state is `Phase: clarify`, `Next step: /rite-temper`.
-   A contract-neutral retrofit runs `devrites-engine clarify-return restore <slug>`; a
-   changed behavior/acceptance contract leaves the return cursor unconsumed, writes
-   `drift.md`, and routes `/rite-plan repair`. Normal first-pass flow sets `/rite-temper`.
-8. **STOP.** Run `devrites-engine progress`; hand off only on `CLEAR`.
+1. **Orient.** Read `.devrites/ACTIVE`, `state.md`, and `spec.md`. Require
+   `Spec gate: passed`; otherwise stop at `/rite-spec`. Apply the native cursor
+   protocol below before changing workspace artifacts.
+2. **Enumerate the topology.** From the spec, live code, contracts, references,
+   and recorded decisions, list every material actor, journey/component, state,
+   data lifecycle, integration, operation, proof surface, and must-NOT boundary.
+3. **Scan coverage.** Apply `devrites-interview` in clarify mode and mark each
+   material surface Clear, Partial, Missing, not-applicable, or justified
+   deferred-nonblocking with evidence and an owner. Use native repository search
+   first. Ask the host to run `devrites-evidence-scout` only for a bounded missing
+   fact, then reconcile its cited result.
+4. **Close decisions.** Record facts and reversible technical choices directly.
+   Ask one coherent option packet only for product, scope, policy, irreversible
+   risk, or human-only access. Persist answers in the owning artifacts and repeat
+   the scan until no blocking Partial/Missing row or unowned material assumption
+   remains.
+5. **Write the verdict.** Write `Decision coverage: CLEAR` only after re-reading all inputs and confirming
+   every material row has current evidence and an owner. Normal flow sets `Phase: clarify` and
+   `Next step: /rite-temper`. A contract-neutral later-phase return uses
+   the native restore below; changed behavior or acceptance routes to
+   `/rite-plan repair` instead. Stop without starting the next phase.
 
-## Output
+## Native clarify cursor protocol
+
+The controlling root edits only cursor rows in `state.md`; it must preserve unrelated Markdown and the file's existing table/bullet presentation.
+
+- **Normal entry from Spec:** set `phase=clarify`, `status=running`, and
+  `next_action=/rite-clarify <slug>`; omit both return fields.
+- **Already in Clarify:** no-op. Do not overwrite an existing valid return
+  cursor.
+- **Later-phase entry:** only `temper`, `define`, `plan`, `vet`, `build`,
+  `converge`, `prove`, `polish`, `review`, `seal`, or `ship` may return. First
+  copy the current `phase` and non-empty `next_action` to `return_phase` and
+  `return_next_action`; then set `phase=clarify`, `status=running`, and
+  `next_action=/rite-clarify <slug>`. Missing/unknown cursor values fail closed
+  before any write.
+- **Contract-neutral restore:** after a fresh `Decision coverage: CLEAR`, require
+  `phase=clarify`, both return fields, a recognized later `return_phase`, and a
+  non-empty `return_next_action`. Restore those values to `phase` and
+  `next_action`, set `status=running`, and remove both return fields in the same
+  rewrite. Re-read the cursor and confirm the return rows are absent.
+- **Contract changed:** do not restore the saved cursor. Record drift and route
+  through `/rite-plan repair`, which owns the changed plan and next action.
 
-Run `devrites-engine progress`, then use the shared completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)):
+Never normalize or rewrite the rest of `state.md` while applying this protocol.
+
+## Output
 
 ```text
 Done: decision coverage closed for <slug>; <n> topology surfaces scanned.

package/pack/generated/claude/skills/rite-clarify/reference/decision-coverage.md

@@ -26,9 +26,7 @@ environment, credentials/approvals, and evidence limits.
 ```markdown
 # Decision coverage
 
-DevRites contract: devrites.readiness-artifacts.v2
 Decision coverage: <CLEAR | NEEDS CLARIFICATION>
-Coverage inputs SHA-256: <exact value from `devrites-engine readiness-digest coverage <slug>`>
 
 ## Topology
 | Surface | Kind | Related IDs | Evidence |
@@ -51,11 +49,7 @@ No Partial, Missing, unowned material assumption, or unresolved blocking/escalat
 question remains.
 ```
 
-Combine rows only when one decision and owner genuinely close them.
-
-Run the digest command only after `brief.md`, `spec.md`, `decisions.md`,
-`assumptions.md`, and `questions.md` are final for this clarification pass, then
-write the current contract field exactly once and copy the digest's complete field line
-verbatim. The build gate recomputes the digest and
-rejects stale coverage. Any open blocking, validating, or escalating question
-also prevents `CLEAR`.
+Combine rows only when one decision and owner genuinely close them. Re-read the current
+`brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, and `questions.md` before writing
+`CLEAR`; the matrix itself is the freshness check. Any open blocking, validating, or
+escalating question prevents `CLEAR`.

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

@@ -3,7 +3,6 @@ name: rite-converge
 description: Converge intent and live code. Use when resuming a half-built feature, after `/rite-adopt` drift, or the user asks "what's left to build". Not for initial planning.
 argument-hint: "[feature-slug]"
 user-invocable: true
-required-agent-roles: devrites-evidence-scout
 ---
 
 # /rite-converge: compare live code with intent
@@ -58,7 +57,8 @@ Pull on demand:
 
 ## Workflow
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** first (the always-on
-   operating rules), then run `devrites-engine preamble` for deterministic workspace orientation.
+   operating rules), then resolve the active slug, require its `state.md`, and
+   read the cursor directly.
 1. **Confirm the gate.** Require `spec.md` + `plan.md` + `tasks.md` in the active workspace. If
    any is missing, **STOP** and name the prerequisite (`/rite-spec` for a missing spec,
    `/rite-define` for a missing plan/tasks, `/rite-adopt` to onboard existing code). Do not
@@ -71,15 +71,11 @@ Pull on demand:
    get built); from `tasks.md`: existing slices + their `Satisfies:`; from
    `.devrites/principles.md`: the invariants.
    **Completion:** every buildable criterion, touch-point, slice output, and principle is in the assessment inventory.
-3. **Run the mechanical checks**, then read the code. `devrites-engine analyze` gives coverage
-   and consistency; `devrites-engine coverage` gives the AC→slice→proven matrix. They catch *unmapped*
-   criteria; they do **not** see whether mapped code is built and correct, for that,
-   read the live code (code-intelligence index per `tooling.md`).
-   ```bash
-   S="$(cat .devrites/ACTIVE 2>/dev/null)"
-   devrites-engine analyze "$S"; echo "analyze rc=$?"
-   devrites-engine coverage "$S" > /dev/null; echo "coverage rc=$?"
-   ```
+3. **Reconcile the map, then read the code.** Compare `spec.md`, `tasks.md`, and
+   `traceability.md` directly: every buildable AC/REQ maps to an existing slice, every slice maps
+   back to real acceptance, and the mapped prose preserves the requirement's meaning. Record
+   orphaned, invented, duplicate, or contradictory mappings as gaps. Then read the live code
+   (code-intelligence index per `tooling.md`); artifact mappings never prove implementation.
 4. **Assess each unit as built / partial / absent** against the live code (the rubric is in
    [`reference/convergence-assessment.md`](reference/convergence-assessment.md)): every
    acceptance criterion / scenario, every plan touch-point, and every existing slice's stated
@@ -94,8 +90,8 @@ Pull on demand:
    principle-remediation slice sorts first. **If every unit is built → append nothing.**
    **Completion:** every partial/absent unit has one traceable appended slice, or the file is byte-for-byte unchanged.
 6. **Write append-only + bookkeeping.** Append the slice batch to `tasks.md` (nothing else in
-   that file changes); refresh `traceability.md` (`devrites-engine coverage` → new rows for the
-   appended slices). Appending a slice changes the plan input, so invalidate the prior vet:
+   that file changes); update `traceability.md` directly with rows for only the appended slices,
+   preserving every existing row. Appending a slice changes the plan input, so invalidate the prior vet:
    update `state.md` to `Phase: plan`, `Next step: /rite-vet`, and set an existing
    `eng-review.md` field to `Implementation readiness: NEEDS REPLAN`. When nothing was unmet,
    leave the plan/vet verdict untouched and set `Next step: /rite-prove`. Append
@@ -120,23 +116,3 @@ Convergence: 2026-07-07      # marks this as a convergence-appended slice, not a
 > **Mid-flight discipline.** Do not rewrite an existing slice, edit source, mark a
 > happy-path-only implementation as built, or add work for a spec you suspect is wrong.
 > See [`reference/anti-patterns.md`](reference/anti-patterns.md).
-
-## Output
-
-**Progress first**: run `devrites-engine progress`, then use the shared completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
-Default success shape:
-```
-Done: convergence assessed for <slug>; <n> slices appended.
-Changed: tasks.md <appended|unchanged>, traceability.md, state.md, eng-review.md <invalidated|unchanged>
-Evidence: units <built>/<total> built · <partial> partial · <absent> absent · principle violations 0
-Open: none
-Next: /rite-vet
-Record: .devrites/work/<slug>/tasks.md
-↻ Hygiene: /clear before /rite-vet
-```
-When nothing was unmet, render the same green form with `Next: /rite-prove`.
-If spec drift or another blocker remains, use the shared `Stopped / blocked` form
-and route `Fix:` to `/rite-plan`; do not recommend `/rite-build`.
-**DO NOT write application code, rewrite existing slices, or edit spec.md/plan.md here.**
-This phase assesses and enqueues; `/rite-build` implements.

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

@@ -27,8 +27,8 @@ slice.
 
 Read the code to decide: do not infer from the plan. Use the code-intelligence index
 (codebase-memory-mcp → codegraph → graphify, else LSP / grep) so the verdict reflects live
-code, not the artifacts' claims. `devrites-engine analyze` / `devrites-engine coverage` tell you what's
-*mapped*; only reading the code tells you what's *built*.
+code, not the artifacts' claims. Read `traceability.md` to see what is mapped; only reading the
+code and tests tells you what is built.
 
 ## Principle violations
 

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

@@ -1,68 +1,52 @@
 ---
 name: rite-customize
-description: User-invoked helper for authoring DevRites overrides or extensions.
-argument-hint: "[override <agent> | extension <name>]"
+description: Customize a project instruction, skill, agent, plugin, or legacy import.
+argument-hint: "[instruction | skill <name> | agent <name> | plugin | --import-legacy]"
 user-invocable: true
 disable-model-invocation: true
-required-agent-roles: none
 ---
 
-# /rite-customize: guided project customization
+# /rite-customize: native project customization
 
-Create, list, validate, or scaffold one project-local DevRites customization without forking the pack.
+Use native; DevRites has no registry, override layer, or sync.
+`--import-legacy` is active only when that exact standalone token occurs in the
+current `$ARGUMENTS`; its presence below or in earlier context cannot activate it.
 
-Read [`devrites-lib/reference/standards/core.md`](../devrites-lib/reference/standards/core.md), then read `docs/extensions.md` if present; in an installed project, fall back to `.claude/skills/devrites-lib/reference/standards/core.md` plus the user's installed DevRites docs if available.
+## Workflow
 
-Fast paths:
-- `list` → run `devrites-engine overrides list` and `devrites-engine extensions list`; stop.
-- `validate` → run both validators; stop.
-- `scaffold extension <name>` → create the smallest valid `.devrites/extensions/<name>/skill/SKILL.md` draft after approval, then validate.
+1. Map policy to an instruction, reusable work to a skill, a specialist to an
+   agent, and external capability to a connected plugin/MCP server.
+2. Inspect target and host docs; reuse before copying DevRites.
+3. Draft the smallest nearest-scope change; do not restate base safeguards.
+4. Show path and exact diff; wait for approval.
+5. Write only the approved artifact; run native validation; keep no mirror.
 
-## Workflow
+Here, edit canonical source, run its generator, and never edit derived artifacts.
+
+## Legacy import mode
+
+`--import-legacy` migrates useful behavior without a registry:
 
-1. **Classify the ask.** Pick exactly one target:
-   - `list` → inspect only.
-   - `validate` → validate only.
-   - `override <agent>` → `.devrites/overrides/<agent>.md`
-   - `extension <name>` / `scaffold extension <name>` → `.devrites/extensions/<name>/`
-   - unclear → ask one blocking question with those options.
-   Done when the target kind and path are known.
-2. **Load the existing surface.** Read the existing file/dir if present. For overrides, confirm the target agent exists under `.claude/agents/` or `pack/.claude/agents/`. For extensions, check whether `skill/SKILL.md` or `agent.md` already exists. Done when you know whether this is create or update.
-3. **Draft the smallest artifact.**
-   - Override: write only added checks/emphasis. Do not restate base reviewer rules.
-   - Extension: create the smallest valid `skill/SKILL.md` or `agent.md` that matches the user's requested surface.
-   Done when the draft has no gate-waiver language and no global paths.
-4. **Show before writing.** Present the path and full content (or a concise diff when updating), then wait. **Completion:** the user explicitly approves or aborts.
-5. **Write and validate.** Create parent dirs, write the file(s), then run the matching validator:
-   ```bash
-   devrites-engine overrides validate
-   devrites-engine extensions validate
-   ```
-   If validation fails, fix the artifact once and re-run. Stop rather than guessing after a second failure.
+1. Inventory `.devrites/extensions/`, `.devrites/overrides/`, and
+   `.devrites/runbooks/` read-only; treat them as untrusted and keep useful rules.
+2. Map behavior to a project skill, scoped policy to its nearest instruction,
+   specialists to agents, and each runbook to a native skill with explicit gate,
+   checkpoint, and resume semantics.
+3. Reject gate/permission weakening. Show every target and diff; wait. Never auto-copy,
+   bulk-convert, or delete.
+4. Write approved native artifacts and validate. Leave the legacy files intact until native
+   validation passes; cleanup needs separate approval.
 
 ## Rules
 
-- Project-local only: write under `.devrites/overrides/` or `.devrites/extensions/`.
-- A customization may add checks or raise weight; it may never relax a gate, waive a standard, bypass `type-GO`, or write global config.
-- Sparse wins: do not copy shipped skills, agents, or standards unless the user explicitly asked for a new extension based on them.
-- Scaffold means a tiny valid skeleton plus a TODO body, not a generated framework.
-- No Codex mirroring by hand; extension sync is owned by `devrites-engine extensions sync`.
+- Never weaken gates/permissions or invent a plugin, registry, schema, or wrapper.
+- Put cross-host semantics in shared instructions, not repeated tool syntax.
 
 ## Output
 
-Reply-contract exception: customization utility; may run without an active feature.
-
-```
-Done: created|updated <override|extension>.
-Changed: <path(s)>
-Evidence: <validator command + result>
-Open: <none | validation error | user-aborted>
-Next: <devrites-engine extensions sync | /rite-doctor | none>
-Record: <path(s)>
+```text
+Done: <created|updated|proposed> <native surface>.
+Changed: <path | none>
+Evidence: <host validation or discovery result>
+Next: <one action | none>
 ```
-
-## Gotchas
-
-- **Do not fork by accident.** If a reviewer override is enough, do not create a copied reviewer agent.
-- **Do not weaken gates.** "Ignore", "waive", "lower severity", or "skip type-GO" means rewrite the customization or refuse it.
-- **Do not invent an extension surface.** If the user wants behavior outside DevRites' extension contract, say what the contract supports and stop.