devrites 6.0.4 → 6.1.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [6.1.1](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.0...v6.1.1) (2026-10-16)
+
+### Fixed
+
+* **devrites:** escalate spent recovery strategies instead of dead-ending ([#107](https://github.com/ViktorsBaikers/DevRites/issues/107)) ([bf1c986](https://github.com/ViktorsBaikers/DevRites/commit/bf1c986e28e6ea8fb63aa47a342b036536cb0e38))
+
+## [6.1.0](https://github.com/ViktorsBaikers/DevRites/compare/v6.0.4...v6.1.0) (2026-10-15)
+
+### Added
+
+* **devrites:** omp links, plan-mode exit, recall, eval controls ([#106](https://github.com/ViktorsBaikers/DevRites/issues/106)) ([cbf429f](https://github.com/ViktorsBaikers/DevRites/commit/cbf429ffb0a68189e21ee231da9af100ea63a6cc))
+
 ## [6.0.4](https://github.com/ViktorsBaikers/DevRites/compare/v6.0.3...v6.0.4) (2026-10-15)
 
 ### Changed

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v6.0.4`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.0.4): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v6.1.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.1): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 
@@ -56,6 +56,14 @@ install and run DevRites. Development in this repository (`npm ci`, which
 npx devrites@latest
 ```
 
+Or paste this to your coding agent:
+
+```text
+Install DevRites in this project: run `npx devrites@latest` from the repository
+root, then run /rite-doctor ($rite-doctor in Codex) and report any FAIL line
+with its fix.
+```
+
 The installer adds project-local support for Claude Code, Codex, omp, pi, and
 Devin CLI. It does not write skills, agents, or hooks to `~/.claude`,
 `~/.codex`, `~/.pi`, or `~/.config/devin`.
@@ -299,7 +307,7 @@ Run `npx devrites@latest --help` for common flags and
 | `--no-devin` | Skip `.devin` skills, agents, and the Devin `AGENTS.md` block. |
 | `--no-agents` | Skip hook-free native specialist profiles. |
 | `--no-skills` | Skip skills and their bundled standards. |
-| `--no-binary` | Do not keep the shared `devrites-engine` binary in a user or system bin directory. |
+| `--no-binary` | Do not keep the shared `devrites-engine` binary in a user or system bin directory. On `uninstall`, keep the existing binary. |
 | `--short-aliases=all` | Add `/define`, `/build`, `/prove`, and `/seal` aliases. |
 
 </details>
@@ -370,9 +378,12 @@ The installer records every managed project file and its SHA-256 in
 `.claude/devrites.manifest`. Before an update or uninstall changes anything, it
 checks every managed path. It preserves customized files and tells you to retry
 with `--force`; legacy manifests without hashes also require `--force`.
-`--force --dry-run` lists the exact destructive actions. Marker-merged files
-keep user content outside the DevRites block, and `.devrites/` runtime state
-stays in place. The installer refuses symlinks, junctions, and paths that
+`--force --dry-run` lists the exact destructive actions. Every settings and
+marker merge is checked before the first write, so a rejected merge (such as a
+Codex config that already sets top-level `default_permissions`) leaves the project untouched.
+Marker-merged files keep user content outside the DevRites block, and
+`.devrites/` runtime state stays in place. `update` reuses the install flags
+recorded in the manifest; flags you pass explicitly win and are recorded. The installer refuses symlinks, junctions, and paths that
 escape the target.
 
 The optional shared `devrites-engine` binary is the only artifact installed
@@ -416,15 +427,18 @@ that the intended publishing step produced it. See
 | --- | --- | --- | --- | --- |
 | **Claude Code** | `.claude/skills/` | `.claude/agents/` | Native root permissions merged into `.claude/settings.json` | `/rite-spec` |
 | **Codex** | `.agents/skills/` | `.codex/agents/` | Permissions in `.codex/config.toml`, marked block in `AGENTS.md` | `$rite-spec` or `/skills` |
-| **omp** | `.omp/skills/` | `.omp/agents/` | Command stubs in `.omp/commands/` | `/rite-spec` or `/skill:rite-spec` |
-| **pi** | `.pi/skills/` | `.pi/agents/` | Prompt commands in `.pi/prompts/`, marked block in `AGENTS.md` | `/rite-spec` or `/skill:rite-spec` |
+| **omp** | `.omp/skills/` | `.omp/agents/` | Command stubs in `.omp/commands/`; `.omp/config.yml` hiding duplicate DevRites skills (only if absent) | `/rite-spec` or `/skill:rite-spec` |
+| **pi** | `.pi/skills/` | `.pi/agents/` | Prompt commands in `.pi/prompts/`, marked block in `AGENTS.md`; with Codex, `.pi/settings.json` skipping the `.agents/skills` copies (only if absent) | `/rite-spec` or `/skill:rite-spec` |
 | **Devin CLI** | `.devin/skills/` | `.devin/agents/` | Marked block in `AGENTS.md` | `/rite-spec` |
 
 On every host, among the lifecycle `devrites-*` specialists only
 `devrites-slice-wright` is writable and the rest are read-only and hook-free;
 the shipped profiles are the full role-to-permission map, and `/rite-doctor`
 step 3 checks them. Existing
-settings and user content stay in place. On Devin CLI, dispatch goes through
+settings and user content stay in place; when `.omp/config.yml` or
+`.pi/settings.json` already exists, the installer leaves it unchanged and
+prints the setting to add. Once you edit one the installer created, it is
+yours: update, uninstall, and `--force` leave it in place. On Devin CLI, dispatch goes through
 `run_subagent` with the exact `devrites-<role>` profile, and a missing profile
 stops for HITL instead of substituting `subagent_general`. Profiles load when a
 session starts, so reopen the project after installing.
@@ -492,7 +506,8 @@ traces. DevRites detects these tools but does not install them.
   binds proof, review, and verdict to the strict project candidate rather than
   to modification times
   ([ADR-0026](docs/adr/0026-content-bound-proof-and-bounded-inputs.md)).
-- The installer never writes `defaultMode: bypassPermissions`. Skills use
+- The installer never sets a Claude `permissions.defaultMode`; it keeps yours, and an
+  update removes the `plan` mode older DevRites versions wrote. Skills use
   networked research only through host tools you invoke or configure.
 
 Read [`SECURITY.md`](SECURITY.md) for the threat model, managed deployment

package/SECURITY.md

@@ -67,8 +67,9 @@ they need. No generated summary stands between the host and the authoritative
 ledger.
 Mutating engine commands are explicit and confined to DevRites state/artifacts;
 the root owns workflow records, while source/tests route through the sole
-wright. Claude enforces root non-writing with plan mode; Codex enforces it as
-workflow policy on its workspace-capable root.
+wright. Root non-writing is workflow policy on both hosts: Claude's root writes
+`.devrites/**` and is not in plan mode (ADR-0035); Codex's root is
+workspace-capable.
 
 After Build, `touched-files.md` is the sole project-candidate authority. The
 engine rejects malformed, escaped, symlinked, special-file, missing, ambiguous,
@@ -180,10 +181,12 @@ separate type-`GO` workflow gate still applies.
 
 ### Native host policy and writer boundary
 
-Reviewer profiles are natively read-only. Claude keeps the root in project plan
-mode. Codex uses a workspace-capable root because a child cannot elevate above
-its parent; root source/test non-writing is therefore a workflow rule, not a
-Codex sandbox guarantee. Among the lifecycle `devrites-*` specialists,
+Reviewer profiles get no Edit/Write tools; Claude's `permissionMode: plan` on
+them is best-effort (ignored while the parent runs in acceptEdits/auto/bypass),
+and Codex makes them `:read-only`. The Claude root is not in plan mode
+(ADR-0035), and Codex uses a workspace-capable root because a child cannot
+elevate above its parent; root source/test non-writing is therefore a workflow
+rule on both hosts, not a sandbox guarantee. Among the lifecycle `devrites-*` specialists,
 `devrites-slice-wright` is the only writable one on either host; the shipped
 profiles are the full role-to-permission map, and `/rite-doctor` step 3 checks
 them. Its task states the exact project-relative paths. The root

package/bin/devrites.mjs

@@ -65,14 +65,15 @@ Common flags:
   --target DIR          Install into DIR (default: current directory)
   --dry-run             Show the plan, change nothing
   --force               Overwrite existing non-DevRites files
-  --no-codex            Skip Codex support files (.agents, .codex, AGENTS.md)
+  --no-codex            Skip Codex support files (.agents, .codex, the Codex AGENTS.md block)
   --no-omp              Skip OMP support files (.omp/skills, .omp/agents, .omp/commands)
   --no-pi               Skip pi support files (.pi/skills, .pi/agents, .pi/prompts)
   --no-devin            Skip Devin CLI support files (.devin/skills, .devin/agents)
   --short-aliases=all   Also install /define /build /prove /seal
   --no-agents           Skip hook-free native specialist profiles
   --no-skills           Skip skills and bundled engineering standards
-  --no-binary           Skip installing the global devrites-engine binary
+  --no-binary           Skip installing the global devrites-engine binary (uninstall: keep it)
+  --keep-binary         Uninstall only: keep the global devrites-engine binary
   --no-rules            Deprecated no-op; standards ship inside devrites-lib
   --rules-only          Deprecated no-op; installs normally for compatibility
 
@@ -112,12 +113,35 @@ async function acquireEngine() {
   const tag = normalizeReleaseTag(process.env.DEVRITES_REF || pkgVersion());
   if (!validRepository(repo) || !tag) throw new Error('DevRites repository and release tag must identify an exact release');
   const envEngine = process.env.DEVRITES_ENGINE_CLI || process.env.DEVRITES_CLI;
-  if (envEngine && existsSync(envEngine)) return envEngine;
+  if (envEngine && existsSync(envEngine)) {
+    // Like install-lib.sh dr_engine_compatible: install/update need this exact release.
+    // A probe that cannot launch falls through so the launch error is reported.
+    if (command !== 'install' && command !== 'update') return envEngine;
+    const probe = spawnSync(envEngine, ['version'], { encoding: 'utf8' });
+    const got = probe.error ? null : probe.status === 0 ? String(probe.stdout).trim().replace(/^v/, '') : '';
+    if (got === null || got === tag.slice(1)) return envEngine;
+    acquisitionFailure = `${envEngine} reports version '${got}', want ${tag}`;
+    return null;
+  }
   if (command === 'uninstall' && spawnSync('devrites-engine', ['uninstall', '-h'], { stdio: 'ignore' }).status === 0) return 'devrites-engine';
 
+  // A git checkout's payload can be ahead of the published engine of the same
+  // version, so a checkout builds its own engine before downloading one.
+  const checkout = existsSync(join(root, '.git'));
+  const fromSource = checkout ? buildEngine(tag) : null;
+  if (fromSource) return fromSource;
   const downloaded = await downloadEngine();
   if (downloaded) return downloaded;
+  const built = checkout ? null : buildEngine(tag);
+  if (built) return built;
 
+  if (command === 'uninstall') return 'devrites-engine';
+  const probe = spawnSync('devrites-engine', ['version'], { encoding: 'utf8' });
+  if (!probe.error && probe.status === 0 && String(probe.stdout).trim().replace(/^v/, '') === tag.slice(1)) return 'devrites-engine';
+  return null;
+}
+
+function buildEngine(tag) {
   const engineDir = join(root, 'engine');
   if (existsSync(join(engineDir, 'go.mod'))) {
     const goBin = findGo();
@@ -136,10 +160,6 @@ async function acquireEngine() {
       if (!build.error && build.status === 0) return out;
     }
   }
-
-  if (command === 'uninstall') return 'devrites-engine';
-  const probe = spawnSync('devrites-engine', ['version'], { encoding: 'utf8' });
-  if (!probe.error && probe.status === 0 && String(probe.stdout).trim().replace(/^v/, '') === tag.slice(1)) return 'devrites-engine';
   return null;
 }
 
@@ -317,11 +337,7 @@ if (command === 'install' || command === 'update') {
 }
 args.push(...rest);
 
-let lastError = null;
-for (const candidate of [engine, 'devrites-engine']) {
-  lastError = await runEngine(candidate, args, engineEnv);
-  if (lastError.code !== 'ENOENT') break;
-}
+const lastError = await runEngine(engine, args, engineEnv);
 if (lastError.code !== 'ENOENT') {
   console.error('devrites: failed to launch devrites-engine:', lastError.message);
 } else {

package/docs/adr/0035-claude-root-leaves-plan-mode.md

@@ -0,0 +1,33 @@
+# ADR-0035: The Claude root no longer runs in plan mode
+
+- **Status:** Accepted
+- **Date:** 2026-10-15
+
+## Context
+
+ADR-0015 and ADR-0017 kept the Claude root source-read-only with project
+`permissions.defaultMode: plan`. Claude Code plan mode forbids every edit except
+the plan file, so the root could not write the `.devrites/work/<slug>/` artifacts
+every lifecycle skill requires. No skill told the root to leave plan mode, and
+approving a plan switches the session out of plan mode for good. Once the parent
+runs in `acceptEdits`, auto, or bypass mode, Claude also ignores a subagent's own
+`permissionMode`, so the read-only reviewer modes stopped being enforced.
+
+## Decision
+
+- DevRites settings no longer set `defaultMode`. The installer stops writing
+  `plan` and removes a `plan` it wrote earlier; it never overrides a mode the
+  user chose.
+- The root stays source- and test-read-only as workflow policy, as on Codex.
+  Allow rules cover the engine commands and `/.devrites/**` edits; source edits
+  go through `devrites-slice-wright` (and the `fast-builder` / `overhaul-*`
+  writers of ADR-0031 and ADR-0033).
+- Read-only roles keep `permissionMode: plan` as a best-effort guard. Their
+  guarantee is a tool list without Edit/Write plus their instructions.
+  `overhaul-implementer` gets `permissionMode: acceptEdits` like the other writers.
+
+## Consequences
+
+- Supersedes the Claude root plan-mode clauses of ADR-0015 and ADR-0017.
+- `/rite-doctor` checks writer tool grants and modes, not root plan mode.
+- Claude root source safety is now instruction-backed on every host.

package/docs/adr/0036-archive-recall-is-a-read-time-query.md

@@ -0,0 +1,32 @@
+# ADR-0036: Archive recall is a read-time query
+
+- **Status:** Accepted
+- **Date:** 2026-10-15
+
+## Context
+
+Shipped features are archived with their decisions, review and seal findings,
+drift, and candidate manifest. Only `/rite-spec` consulted the archive, by
+keyword. Define, Review, and debugging never saw what an earlier feature decided
+or found about the same files, so a constraint learned once had to be learned
+again. ADR-0014 and ADR-0022 removed engine index workers, ingestion, and
+telemetry, and `/rite-learn` forbids a learning ledger or index.
+
+## Decision
+
+- `devrites-engine recall --paths <paths>` answers one question on read: which
+  archived features touched these paths, and which of their decisions,
+  carry-forward constraints, and review/seal/drift lines name them. The links
+  are derived from `touched-files.md` and the `Files:` fields already in the
+  archive. Nothing is written, cached, or indexed.
+- Define folds relevant pointers into `Prior-slice learnings`, Review hands
+  them to lane reviewers as context (never as findings), and debug recovery
+  reads prior dead ends before ranking hypotheses.
+- Build records confirmed causes as `decisions.md` carry-forward constraints,
+  which later slices quote and recall surfaces to later features.
+  `/rite-learn` stays the only route from a recurring lesson to project guidance.
+
+## Consequences
+
+- Recall cost grows with the archive and is paid only when called.
+- A pointer is prior context: live source and the current spec still win.

package/docs/adr/README.md

@@ -60,9 +60,9 @@ architecture; per-feature `decisions.md` files stay scoped to that feature.
 | [0012](0012-semantic-workspace-upgrades.md) | Separate semantic workspace upgrades from structural migration | Accepted in intent; detection and repair mechanics superseded by 0025 | historical |
 | [0013](0013-native-codex-agent-orchestration.md) | Native Codex agent orchestration | Accepted; Codex writer clause superseded by 0016 | `tests/codex-agent-generation-test.sh`, `tests/codex-generator-test.sh` |
 | [0014](0014-native-host-hook-boundary.md) | Native host capability boundary | Superseded by 0015 | historical |
-| [0015](0015-read-only-root-native-orchestration.md) | Read-only root with native host orchestration | Accepted; Codex root/writer clauses superseded by 0017; exact-path/hook/reconcile clauses superseded by 0018 | `engine/internal/install/install_test.go`, `tests/codex-agent-generation-test.sh` |
+| [0015](0015-read-only-root-native-orchestration.md) | Read-only root with native host orchestration | Accepted; Codex root/writer clauses superseded by 0017; exact-path/hook/reconcile clauses superseded by 0018; Claude root plan mode superseded by 0035 | `engine/internal/install/install_test.go`, `tests/codex-agent-generation-test.sh` |
 | [0016](0016-codex-writer-fail-closed.md) | Codex source writing fails closed | Superseded by 0017 | historical |
-| [0017](0017-native-codex-writer-agent.md) | Native Codex writer-agent execution | Accepted; exact-path/reconcile clauses superseded by 0018 | `tests/codex-agent-generation-test.sh`, `tests/codex-generator-test.sh`, `tests/codex-runtime-smoke.sh` |
+| [0017](0017-native-codex-writer-agent.md) | Native Codex writer-agent execution | Accepted; exact-path/reconcile clauses superseded by 0018; Claude root plan mode superseded by 0035 | `tests/codex-agent-generation-test.sh`, `tests/codex-generator-test.sh`, `tests/codex-runtime-smoke.sh` |
 | [0018](0018-native-sandbox-instruction-writer-boundary.md) | Native sandbox and instruction writer boundary | Accepted in part; native sandbox/writer boundary retained, superseded clauses resolved by 0022 | `engine/internal/install/install_test.go`, `tests/codex-agent-generation-test.sh` |
 | [0019](0019-native-boundary-with-deterministic-gates.md) | Native boundary with deterministic gates | Accepted in part; semantic gates superseded by 0022, native writer and fresh approval retained | `engine/internal/gate/gate_test.go` |
 | [0020](0020-thin-engine-native-orchestration-boundary.md) | Thin engine and native host orchestration | Accepted in part; engine-surface/migration scope superseded by 0022, native orchestration retained | `tests/native-orchestration-contract-test.sh`, `engine/root_routing_test.go` |
@@ -80,3 +80,5 @@ architecture; per-feature `decisions.md` files stay scoped to that feature.
 | [0032](0032-single-lint-gate-and-cached-pr-tests.md) | One engine lint gate, and PR tests that reuse main's results | Accepted | `tests/validation-governance-test.sh` |
 | [0033](0033-rite-fast-own-agents.md) | `/rite-fast` ships its own agents and its own writer | Accepted; adds `fast-builder` as a writer outside the `devrites-*` one-writer rule | `scripts/validate-agent-composition.py`, `tests/rite-fast-contract-test.sh` |
 | [0034](0034-workflow-artifact-byte-corrections-get-code-review.md) | Workflow Artifact byte corrections get code review, not a plan loop | Accepted; narrows 0027's semantic review for contract-preserving Workflow Artifact byte fixes | `engine/internal/lib/drift_test.go` |
+| [0035](0035-claude-root-leaves-plan-mode.md) | The Claude root no longer runs in plan mode | Accepted; supersedes the Claude root plan-mode clauses of 0015/0017 | `tests/native-orchestration-contract-test.sh`, `engine/internal/install/install_test.go` |
+| [0036](0036-archive-recall-is-a-read-time-query.md) | Archive recall is a read-time query | Accepted; consistent with 0014/0022 (no engine index or store) | `engine/internal/lib/recall_test.go` |

package/docs/architecture.md

@@ -383,7 +383,9 @@ when the answer is required.
 AFK always pauses for genuine product/scope/policy choices, irreversible risk,
 and human-only access or actions, regardless of the sentinel. Objective test,
 type, lint, runtime, and coverage failures stay inside bounded technical
-recovery; exhaustion records a blocker without inventing a question. See
+recovery; a spent strategy escalates to a new correction class, and a fully
+escalated fingerprint parks while independent work continues, without inventing a
+question. See
 [`pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md`](../pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md) for the full
 contract.
 

package/docs/cli.md

@@ -40,6 +40,7 @@ devrites-engine orient <slug>
 devrites-engine observe slice <slug> <SLICE-ID>
 devrites-engine next [slug]
 devrites-engine handoff [slug]
+devrites-engine recall --paths <p1,p2,...> [--limit n]
 devrites-engine context [slug] (--phase <p>|--skill <name>) [--role <r>]
 devrites-engine metrics record <slug> --phase <p> --event <e>
 devrites-engine metrics summary [slug]
@@ -92,8 +93,10 @@ canonical command names.
 
 Use `npx devrites update --check` to perform the equivalent adapter-level
 comparison without changing the installation. Use
-`npx devrites uninstall --keep-binary` to remove managed host artifacts while
-retaining the shared `devrites-engine` binary.
+`npx devrites uninstall --keep-binary` (or `--no-binary`) to remove managed host
+artifacts while retaining the shared `devrites-engine` binary. `update` reuses
+the install flags recorded in the manifest; host and binary flags passed to
+`update` override them and are recorded for the next run.
 
 If an older direct engine reports `missing codex/hooks.json` or asks for
 `--source-dir`, run `npx devrites@latest update`, or use a release `install.sh` that is
@@ -170,6 +173,26 @@ self-contained updater.
   `ambiguous`/`lost` by relocating the quote repo-wide (dependency and workspace
   trees excluded); `check --repair` rewrites a `moved` subject; `rm` deletes by
   `NOTE-###`. `check seal` refuses a malformed file or any non-`exact` anchor.
+- `recall --paths <p1,p2,...> [--limit n]` points planning and review at what
+  earlier archived features decided or found about the same files. It lists
+  each `.devrites/archive/<slug>/` whose candidate manifest covers a queried
+  path (exact or directory prefix, case-folded), ranked by overlap, then newest
+  archive-directory mtime, then slug, with up to 8 pointers per feature:
+  `decisions.md` `DEC-###` entries and carry-forward constraints whose `Files:`
+  overlap, and `review.md`/`seal.md`/`drift.md` lines naming a queried path.
+  It is computed on every read and never writes, caches, or indexes. Output:
+
+  ```text
+  recall: 1 archived feature(s) touched these paths
+  feature add-csv-export overlap=1 paths=src/routes
+    archive/add-csv-export/decisions.md:5  ## DEC-001 — Reuse the route and stream CSV
+    archive/add-csv-export/decisions.md:11  - Close the stream on every error path — from SLICE-002 (EVID-003); Files: src/routes/transactions/export.ts
+    archive/add-csv-export/review.md:3  - `src/routes/transactions/export.ts:41` closes the stream on error
+  ```
+
+  `recall: no archive` and `recall: no archived feature touched these paths`
+  exit `0`; an unreadable archive file prints `unreadable: <file> (<reason>)`
+  and the scan continues; usage errors exit `2`.
 
 Semantic readiness, traceability, acceptance interpretation, evidence quality,
 doubt, test quality, reviewer reconciliation, and capability interpretation

package/docs/command-map.md

@@ -88,7 +88,7 @@ See [`cli.md`](cli.md).
 | Command | Phase | Argument | What it does | Reads | Writes |
 |---|---|---|---|---|---|
 | [`/rite`](../pack/.claude/skills/rite/SKILL.md) | menu | `[verb [args...]]` | Compact menu + router. No-argument menu mode does **not** read state because `/rite-status` owns that job. | none | none |
-| [`/rite use <slug>`](../pack/.claude/skills/rite/SKILL.md) | menu | `<slug>` | Inline context switch: confirms the workspace exists and re-points the active feature without running a phase. | `.devrites/work/<slug>/` | `.devrites/ACTIVE` |
+| [`/rite use <slug>`](../pack/.claude/skills/rite/SKILL.md) | menu | `<slug>` | Inline context switch: confirms the workspace's `state.md` exists and re-points the active feature without running a phase. | `.devrites/work/<slug>/state.md` | `.devrites/ACTIVE` |
 | [`/rite guide`](../pack/.claude/skills/rite/SKILL.md) | guided lifecycle | none | Inline walkthrough of one real, small first feature; explains and pauses at every phase boundary. | chosen change + lifecycle context | lifecycle-owned artifacts |
 | [`/rite-spec`](../pack/.claude/skills/rite-spec/SKILL.md) | spec | `<feature>` | **New feature.** Deep investigation → writes a product-focused `spec.md` (WHAT/WHY, requirements, ACs, boundaries, gaps, design references, and one capability-impact declaration). MODIFIED deltas preserve prior scenarios/claims unless an accepted decision authorizes removal. | codebase + native file/code search + shipped archive Markdown | `README.md`, `brief.md`, `spec.md`, `references/`, `references.md`, `questions.md`, `decisions.md`, `assumptions.md`, `state.md` |
 | [`/rite-clarify`](../pack/.claude/skills/rite-clarify/SKILL.md) | clarify | `[slug]` | **Required, adaptive.** Topology-first coverage scan of the written spec; searches facts, closes human-owned decisions, audits assumptions, and takes a zero-question fast path when already clear. Writes a semantic `CLEAR` verdict reconciled against the spec, decisions, assumptions, and evidence; later-phase retrofits persist and restore their return cursor when the contract is unchanged. | spec workspace + code/docs/decisions | `decision-coverage.md`, `spec.md`, `decisions.md`, `assumptions.md`, `questions.md`, `state.md` |
@@ -105,12 +105,12 @@ See [`cli.md`](cli.md).
 | [`/rite-seal`](../pack/.claude/skills/rite-seal/SKILL.md) | seal | `[feature-slug] [--full]` | Candidate-bound GO / NO-GO **decision**. Rechecks exact proof/review bindings and runs no git; on GO sets `Next step: /rite-ship`. | all artifacts + candidate | `seal.md`, `state.md` |
 | [`/rite-ship`](../pack/.claude/skills/rite-ship/SKILL.md) | ship | `[slug]` | Starts with a read-only Seal/candidate check and exact plan disclosure, then requires fresh literal `GO`. Only then may it collapse checkpoints, stage exact candidate paths, validate staged scope/bytes/bindings/secrets, commit and reverify, perform optional separately approved push/tag/PR actions, and archive/close. | `seal.md` + candidate + Git index | `ship.md`, `state.md`, archive |
 | [`/rite-autocomplete`](../pack/.claude/skills/rite-autocomplete/SKILL.md) | (orchestrator) | `[idea] [--ship\|--yolo] [--max-slices N] [--full] [--cross-model]` | Full lifecycle (spec → clarify → … → seal → ship). Spec + clarify form the one interactive window; AFK/checkpoint mode arms only after decision coverage is CLEAR. Pauses for irreversible risk, escalating, unanswered blocking with no recommended option, human-only access, or remaining NO-GO — not recommended-option blocking questions, temper expand, validating gates, `--max-slices`, or default resource caps. Objective red checks use bounded technical recovery. Default stops at Seal GO; `--ship` (`--yolo`) reaches Ship preflight but still requires fresh literal `GO` and native approval; `--full` selects the Full profile and `--cross-model` arms Vet's second opinion. | idea + workspace | whole workspace (drives every phase) |
-| [`/rite-quick`](../pack/.claude/skills/rite-quick/SKILL.md) | (express) | `<change>` | Express lane for a **small, reversible, unambiguous** change: one-line contract → TDD build → scoped prove → review-lite → ship, no full artifact tree. **Significance gate first**: auth / migration / public-API / destructive / multi-slice / ambiguous → escalates to `/rite-spec`. Triggers: "quick fix", "small change", "tiny tweak", "just do X". | the change + codebase | code + commit (optional `brief.md` / `evidence.md`) |
+| [`/rite-quick`](../pack/.claude/skills/rite-quick/SKILL.md) | (express) | `<change>` | Express lane for a **small, reversible, unambiguous** change: one-line contract → TDD build (via `devrites-slice-wright`) → scoped prove → review-lite → standalone commit (a change in the active candidate routes to `/rite-prove` → `/rite-review` → `/rite-seal`), no full artifact tree. **Significance gate first**: auth / migration / public-API / destructive / multi-slice / ambiguous → escalates to `/rite-spec`. Triggers: "quick fix", "small change", "tiny tweak", "just do X". | the change + codebase | code + commit (optional `brief.md` / `evidence.md`) |
 | [`/rite-fast`](../pack/.claude/skills/rite-fast/SKILL.md) | (fast lane) | `<task \| slug>` | **Explicit-only** shortened lane for mid-size work: one SHAPE step (`fast-planner` drafts spec + ≤10 slices, root asks ≤5 ranked questions, 10 when risk is flagged, user approves) → BUILD with `fast-builder` and **no per-slice gate** → one CHECK (`fast-checker` completeness pass, ≤2 gap-fix rounds) → REFINE (`fast-critic` review + polish) → PROVE on the final tree. Outside the engine lifecycle: no `state.md`, no `ACTIVE`, no seal; commits only on confirmation. | the task + codebase | `spec.md`, `plan.md`, `evidence.md` under `.devrites/work/<slug>/` + code |
 | [`/rite-frame`](../pack/.claude/skills/rite-frame/SKILL.md) | lens | `[ask \| diff]` | Pre-flight + self-audit lens for ad-hoc work the lifecycle gates never see: **FRAME** turns an imperative ask into a falsifiable success criterion + verify command before code; **AUDIT** checks a raw diff against the four LLM coding failure modes (silent assumption / overcomplication / out-of-scope edit / unverifiable goal). Top of `/rite-quick` or before a plain "just do X". | the ask / a raw diff | success criterion + verify command (inline) |
 | [`/rite-adopt`](../pack/.claude/skills/rite-adopt/SKILL.md) | onboard | `[path or area to adopt] [+ what you want to build next]` | Reverse-derive the existing baseline and next objective; propose any durable project guidance in the nearest native instruction file. | codebase + project instructions | workspace spec/state artifacts + optional guidance proposal |
 | [`/rite-status`](../pack/.claude/skills/rite-status/SKILL.md) | status | `[slug]` | Active feature: phase, run mode, status, persisted next action, evidence, questions, drift, risks, and handoff readiness. | direct workspace ledger/artifacts | none |
-| [`/rite-resolve`](../pack/.claude/skills/rite-resolve/SKILL.md) | resume | `<qid> "<answer>" \| --drop <qid> ["<reason>"] \| --batch <path-to-yaml>` | Answer / drop / batch-resolve open `questions.md` entries; clears `state.md` `Awaiting human` and sets `Status: running`. Canonical writer for `status: open → answered`. | `questions.md` + `state.md` | `questions.md`, `state.md` |
+| [`/rite-resolve`](../pack/.claude/skills/rite-resolve/SKILL.md) | resume | `<qid> "<answer>" \| --drop <qid> ["<reason>"] \| --batch <plain-text-file>` | Answer / drop / batch-resolve open `questions.md` entries; clears `state.md` `Awaiting human` and sets `Status: running`. Canonical writer for `status: open → answered`. | `questions.md` + `state.md` | `questions.md`, `state.md` |
 | [`/rite-zoom-out`](../pack/.claude/skills/rite-zoom-out/SKILL.md) | utility | `[symbol \| file \| area to map]` | One-pass structural map of an unfamiliar area (modules, in-callers, out-calls, decisions) in project vocabulary. Prefers codegraph/graphify. | codebase + ADRs/CONTEXT.md | none |
 | [`/rite-prototype`](../pack/.claude/skills/rite-prototype/SKILL.md) | utility | `[question]` | Throwaway code answering ONE design question. Logic harness OR 2 to 4 UI variations on one route. Captures verdict to `decisions.md`. | spec / surrounding code | prototype scratch + `decisions.md` |
 | [`/rite-handoff`](../pack/.claude/skills/rite-handoff/SKILL.md) | utility | `[next-session-focus]` | Compacts the chat into a handoff doc. Syncs chat-only context into workspace canonical files. References existing artifacts by path. | chat + workspace | `handoff.md` + sync into canonical files |
@@ -119,7 +119,7 @@ See [`cli.md`](cli.md).
 | [`/rite-explain`](../pack/.claude/skills/rite-explain/SKILL.md) | utility | `[concept \| diff: \| walkthrough: \| since: \| idea]` | The **human** half of the learning loop (complement of `/rite-learn`, which teaches the repo). Turns a concept, diff, idea, or window of the user's own recent work into a dense personal explainer; diff inputs can produce a concern-ordered human review walkthrough. Grounds off `seal.md` / `evidence.md` / the diff / the archive. Read-only against source. | workspace + archive + diff + code | `.devrites/explainers/<date>-<slug>/explainer.md` or `walkthrough.md` |
 | [`/rite-pov`](../pack/.claude/skills/rite-pov/SKILL.md) | utility | `[candidate/link/question]` | Project-grounded verdict on one outside option after live repository and primary-source evidence. | live code/docs + external sources | `decisions.md` or ADR only on request |
 | [`/rite-dogfood`](../pack/.claude/skills/rite-dogfood/SKILL.md) | utility | `[feature-slug\|branch] [--port N]` | Diff-scoped browser QA: map changed user journeys, run scenario matrix, fix small obvious breakages, write dogfood report. Explicit-only. | diff + app routes + browser | `.devrites/work/<slug>/dogfood.md` + safe fixes |
-| [`/rite-pr-feedback`](../pack/.claude/skills/rite-pr-feedback/SKILL.md) | utility | `[PR number\|thread URL\|blank for current branch]` | Resolve GitHub PR review feedback: fetch unresolved threads, judge centrally, fix valid items, reply, resolve. Explicit-only. | PR threads + code | code/tests + PR replies/resolutions |
+| [`/rite-pr-feedback`](../pack/.claude/skills/rite-pr-feedback/SKILL.md) | utility | `[PR number\|thread URL\|blank for current branch]` | Resolve GitHub PR review feedback: fetch unresolved threads, judge centrally, fix valid items via `devrites-slice-wright`, then commit/push/reply/resolve only after fresh approval of the disclosed plan. Explicit-only. | PR threads + code | code/tests + PR replies/resolutions |
 | [`/rite-watch-pr`](../pack/.claude/skills/rite-watch-pr/SKILL.md) | utility | `[PR number\|PR URL\|blank for current branch]` | Observe one GitHub PR/CI/review snapshot, classify one next action, and stop. Safe for capability-admitted native schedules/events; never mutates code, Git, checks, threads, or PR state. | PR/check/review metadata + bounded failed-log excerpts | none |
 | [`/rite-pressure-test`](../pack/.claude/skills/rite-pressure-test/SKILL.md) | utility | `[idea]` | Pressure-test a rough idea: 3 to 5 genuinely different options → converge on one with trade-off + hinge. | spec / surrounding code | `decisions.md` (optional) |
 | [`/rite-doctor`](../pack/.claude/skills/rite-doctor/SKILL.md) | diagnostic | none | Diagnose the DevRites binary, pack, schema, and native host permission/profile configuration. | install + host config | none |
@@ -177,10 +177,12 @@ write-capable `devrites-slice-wright`.
 
 Only the root dispatches; leaves never dispatch other leaves. It dispatches the
 exact named project role; if that role is unavailable, the workflow stops for
-HITL. The root never executes a specialist role. Reviewer profiles are
-natively read-only. Claude keeps its root in plan mode; Codex uses a
-workspace-capable root so its child can write, while workflow policy forbids
-that root from editing source/tests. Among the lifecycle `devrites-*` specialists, both hosts expose only
+HITL. The root never executes a specialist role. Claude reviewer profiles have
+no Edit/Write tools and are read-only by instruction; their
+`permissionMode: plan` is best-effort (ignored while the parent runs
+acceptEdits/auto/bypass). Codex reviewers are natively `:read-only`; Codex uses a
+workspace-capable root so its child can write. On both hosts workflow policy
+forbids the root from editing source/tests. Among the lifecycle `devrites-*` specialists, both hosts expose only
 `devrites-slice-wright` as a writable one. The shipped profiles are the full
 role-to-permission map; `/rite-doctor` step 3 checks them. See
 [`standards/agents.md`](../pack/.claude/skills/devrites-lib/reference/standards/agents.md#source-writing-boundary).

package/docs/engine/commands.md

@@ -18,7 +18,7 @@ workflow strategy.
 | `check path-disjoint [--root <dir>] [<json-file> | -]` | Verify slice path sets are pairwise disjoint. |
 | `parallel select --cap <1-10> [--root <dir>] [<json-file> | -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices. |
 | `parallel <create\|integrate\|cleanup\|status\|abort\|lease-read\|lease-write\|lease-clear\|record-green>` | Deterministic parallel worktree leases, integration, and cleanup for parallel writer batches. |
-| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. |
+| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. Prints a non-blocking `ADVISORY size:` line (and records a `size-advisory` metric) for each slice with 12+ Writer allowlist files and no `Size rationale:`. A `Dependencies` ID may carry a `(via <interface>)` suffix (empty or unclosed is a malformed token); prints a non-blocking `ADVISORY edge:` line (and records an `edge-advisory` metric) for each edge with no via, or whose via text is not a case-insensitive substring of the dependency's `Consumes / Produces:`. Advisories print only when the graph is valid. |
 | `check regression <slug> [--update]` | Compare the workspace's structural progress facts (phase ordinal, checked ACs, met/abandoned gates, done slices, resolved questions, present artifacts) against the recorded `regression-baseline.json` high-water mark; `--update` ratchets the baseline forward under the feature lock and prints each blessed regression. |
 | `check drift <slug> [--record]` | Attribute readiness-input changes to the exact artifact. `--record` writes the per-input `readiness-inputs.json` digest baseline under the feature lock; without it the workspace diffs current inputs against that baseline (or falls back to the aggregate binding recorded in `eng-review.md`). Advisory: exit `0` on drift; a corrupt baseline exits `3`. A `test-plan.md` change limited to exact `Workflow Artifact reviewed identity: <64hex>` lines is reported as `reviewed-identity-only` (ADR-0034). |
 | `check windows <slug> [--worktree\|--staged\|--base <ref>]` | Fail on deferral and bar-lowering markers the change introduces without a waiver row in the workspace's `windows.md`: added TODO/FIXME/XXX/HACK, skipped/focused-test and stub idioms, checker suppressions, one-line empty catch; removed `deleted-test` files and net `removed-assertion` lines in remaining test files. |
@@ -32,6 +32,7 @@ workflow strategy.
 | `observe slice <slug> <SLICE-ID>` | Print one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. |
 | `next [slug]` | Print the minimal remaining lifecycle path plus advisory skips. |
 | `handoff [slug]` | Emit the deterministic resume record: cursor fields, `awaiting_human`, open `questions.md` gate kinds, the `gates.md` reduction with unmet/stale/abandoned ids, `decisions.md` dead ends, missing required files, and the canonical read-next order. Read-only; the `/rite-handoff` spine and the compaction-fallback entry point. |
+| `recall --paths <p1,p2,...> [--limit n]` | Read-time query over `.devrites/archive/`: list archived features whose `touched-files.md` candidate manifest covers a queried project-relative path (exact or directory prefix, case-folded), ranked by overlap count, then newest archive-directory mtime, then slug (default 10 features). Each feature prints up to 8 `archive/<slug>/<file>:<line>` pointers, then `+N more`: `decisions.md` `DEC-###` entries and `## Carry-forward constraints` bullets whose `Files:` overlap (or a constraint naming no files), plus `review.md`/`seal.md`/`drift.md` lines that mention a queried path; fenced examples are ignored. Never writes, caches, or indexes (no metric either); symlinked archive entries are refused. An unreadable archive file prints `unreadable:` and the scan continues. Exit `0` (including `recall: no archive`), `1` invalid archive directory, `2` usage. |
 | `context [slug] (--phase <p>\|--skill <name>) [--role <r>] [--slice <SLICE-ID>] [--trigger a,b]` | Emit one deduplicated read-set bundle per phase/role/skill from each skill's `loads:` manifest; `--skill` works without a workspace when `--out` is given. A bundle without `--role` (the root's own read) gives over-budget artifacts as by-reference indexes; a `--role` bundle leads with the role's agent contract and names the manifest's `rootOnly` paths instead of inlining them. `--slice` inlines that slice's `tasks.md` block and turns each over-budget artifact into a by-reference index (path, SHA-256, headings, line hits for every ID the block cites); repeat `--slice` for several slices; an unknown slice exits `3`. |
 | `dispatch <slug> <open\|start\|seal\|return\|status\|abandon>` | Launch-wave barrier for parallel dispatch: seal needs a handle per role, return needs seal; start/return auto-record metrics. A build wave with a wright role needs `--slice <SLICE-ID>` per slice, and a slice-bound vet wave takes it too; every 5 rounds of either kind on one slice, `open` exits `3` until `--reslice-review <DRIFT-ID>` names an unused `drift.md` `## <DRIFT-ID>` heading for that slice. `open` also warns when an earlier wave for the same slice never returned. |
 | `metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]` | Append an event to the workspace's `metrics.jsonl` ledger. |
@@ -145,7 +146,7 @@ network. The skill documents the record schemas and when to call each tool.
 
 | Tool | Forms | Exit codes |
 | --- | --- | --- |
-| `records` | `init <repo> <run-id>`, `digest <file>`, `stage <run>`, `publish <run>`, `validate <run>` | 0 ok; 1 violations (listed as `VIOLATION:` lines); 2 usage or I/O |
+| `records` | `init <repo> <run-id>`, `digest <file>`, `stage <run>`, `publish <run>`, `validate <run>`, `prune <run> [--keep K]` | 0 ok; 1 violations (listed as `VIOLATION:` lines); 2 usage or I/O |
 | `admit` | `receipt <run> <receipt.json> [--observed <file>]`, `anchor <tree> <proposals.json>` | 0 admissible; 1 rejected; 2 usage or I/O; 3 duplicate or late receipt |
 | `snapshot` | `capture <repo> <out>`, `fingerprint <repo>`, `verify <repo> <out> [--agent-paths <file>]`, `state <repo> <out.json>`, `delta <before.json> <repo>` | 0 ok; 1 index changed or changes outside agent paths; 2 refusal, usage or I/O |
 | `score` | `--rubric <r> --results <s> --gates <g> [--out <file>]`, `compare --rubric <r> --baseline <a> --candidate <b>` | 0 computed; 2 invalid input (nothing counts as scored) |
@@ -165,7 +166,9 @@ ignore it, adds `/.devrites/overhaul/` to the local `.git/info/exclude`, never t
 the shared `.gitignore`.
 `admit receipt` checks the attempt in the open staged generation (`g<N>.tmp` whose
 `.base` is `CURRENT`) when one exists, otherwise in `CURRENT`, so a phase can record
-many dispatches and admissions before one publish.
+many dispatches and admissions before one publish. The receipt must be the file at
+`<run>/receipts/<run_id>__<task_id>__<attempt_id>__<role>.json` (and match the attempt's
+recorded `receipt` path); extra or misspelled arguments exit `2`.
 
 ## Output and exit contracts
 

package/docs/harness-compliance.md

@@ -16,9 +16,9 @@ generation/install/permission/routing tests that exercise them.
 | Surface | Claude Code | Codex | Phase impact | Fallback | Native doctor | Confidence | Notes |
 | --- | --- | --- | --- | --- | --- | --- | --- |
 | Session context and compaction | Native | Native | all phases | explicit skill state read | no | high | Both hosts own transcript, session, resume, and compaction context; DevRites does not inject a duplicate lifecycle hook. |
-| Root orchestrator permissions | Native | Instruction-backed | all source mutations | stop if the root edits source | yes | medium | Claude uses project plan mode; Codex needs a workspace-capable parent for native writer-child execution, so its root no-source-writing boundary is instruction-enforced. |
+| Root orchestrator permissions | Instruction-backed | Instruction-backed | all source mutations | stop if the root edits source | yes | medium | Claude's root writes `.devrites/**`, so it does not run in plan mode (ADR-0035); Codex needs a workspace-capable parent for native writer-child execution. On both hosts the root no-source-writing boundary is instruction-enforced. |
 | Slice-wright exact paths | Instruction-backed | Instruction-backed | build safety | reject an out-of-scope returned diff | yes | medium | Both hosts run the exact write-capable slice-wright under native sandboxing. The task states exact paths; the root compares the returned file list and `git diff --name-only` with that contract. |
-| Native reviewer permissions | Native | Native | review/seal safety | HITL stop; no root inline review | yes | high | Claude lifecycle `devrites-*` reviewer profiles use permissionMode plan; Codex lifecycle `devrites-*` reviewer profiles use `default_permissions = ":read-only"`. No engine reviewer classifier is involved. |
+| Native reviewer permissions | Instruction-backed | Native | review/seal safety | HITL stop; no root inline review | yes | medium | Claude lifecycle `devrites-*` reviewer profiles have no Edit/Write tools and use permissionMode plan (honored while the parent is not in acceptEdits/auto/bypass); Codex lifecycle `devrites-*` reviewer profiles use `default_permissions = ":read-only"`. No engine reviewer classifier is involved. |
 | Skill invocation | Native | Native | all public rites | explicit file read | yes | high | Claude invokes /rite natively. Codex invokes $rite natively from the generated/mirrored .agents/skills tree; the mirror delivers artifacts rather than adapting execution. |
 | Candidate identity | Adapter-backed | Adapter-backed | Build through Ship | stop; never substitute a host hash | partial | high | Both hosts expose read-only `devrites-engine check candidate <slug>` with exact two-field output and preserve one binding across evidence, optional browser evidence, review, and seal. Build writes scope, Polish closes it, and Ship is candidate-read-only. |
 | Reviewer subagent dispatch | Native | Native | review/seal confidence | HITL stop; no root inline review | yes | high | Both hosts dispatch the exact named project role. Codex loads developer instructions and the `:read-only` permission profile from the generated custom-agent TOML. |

package/docs/orchestration.md

@@ -23,9 +23,10 @@ root reconciles semantics; engine checks deterministic structure/state/safety
 - Build maintains the strict candidate manifest. Prove, Review, and Seal bind
   their artifacts to the engine-computed digest; Polish owns final durable
   rollups and affected re-proof; Ship is candidate-read-only.
-- The root never writes source or tests. Claude enforces that with plan mode;
-  Codex enforces it as workflow policy because the parent must be
-  workspace-capable for its writer child to execute.
+- The root never writes source or tests. Both hosts enforce that as workflow
+  policy (ADR-0035): Claude's root is not in plan mode because it must write
+  `.devrites/**`, and Codex's parent must be workspace-capable for its writer
+  child to execute.
 - The role catalog has one source/test writer, `devrites-slice-wright`. Claude
   and Codex make only that exact specialist writable.
 - Leaves never invoke leaves, ask the human, change phase, push, deploy, migrate live
@@ -45,7 +46,7 @@ inserted between a skill and the host's native agent call.
 
 ## Native permission boundary
 
-Claude project settings use `permissions.defaultMode: plan`; its slice-wright
+Claude project settings set no `defaultMode` (ADR-0035); its slice-wright
 profile uses `permissionMode: acceptEdits`. Codex uses a workspace-capable root
 because children cannot elevate above the parent permission ceiling. Its exact
 slice-wright uses `default_permissions = ":workspace"` and the other 16

package/docs/release.md

@@ -11,8 +11,9 @@ version and run these steps:
 2. Regenerates `CHANGELOG.md` from the commits.
 3. Syncs the new version into `package.json` and the README status line (`scripts/sync-version.sh`), then stages only those known overlays plus the generated changelog so the release index owns their bytes.
 4. Builds `dist/devrites-v<version>.tar.gz` and `dist/install.sh`, each with an exact-filename SHA-256 sidecar, via `scripts/build-release-tarball.sh`. Payload paths and bytes are materialized from the repository-root Git index; the build fails outside that index and never copies a divergent live worktree file. A stdlib Go packager sorts member names and normalizes ownership, modes, timestamps, and the gzip header, so identical indexed sources produce identical archives. `SOURCE_DATE_EPOCH` selects the canonical timestamp and defaults to `0`. The bundle includes the checked-in host-native Claude/Codex artifacts under `pack/generated/`; symlinks and other non-regular payload entries are rejected.
-5. Cross-compiles five `devrites-engine` release binaries (macOS arm64/amd64, Linux arm64/amd64, Windows amd64) plus a SHA-256 sidecar for each.
-6. Publishes the `devrites` package to npm through `@semantic-release/npm` with
+5. Cross-compiles six `devrites-engine` release binaries (macOS, Linux and Windows, each arm64/amd64) plus a SHA-256 sidecar for each.
+6. Commits the version bump + changelog as `chore(release): <version> [skip ci]`, creates tag `v<version>`, and publishes a GitHub Release with the tarball, verified installer, binaries, and every checksum sidecar attached. The GitHub Release is published before npm, so a published npm version always finds its release assets; if the GitHub step fails, npm is not published. The release job then attests the artifacts with build provenance (`actions/attest-build-provenance`), independent of npm provenance.
+7. Publishes the `devrites` package to npm through `@semantic-release/npm` with
    provenance attestation. The job requests OIDC (`id-token: write`) so a
    future npm Trusted Publisher can take over, and today authenticates with
    `secrets.NPM_TOKEN` because npm's OIDC exchange still returns
@@ -20,12 +21,11 @@ version and run these steps:
    `devrites`. This is what `npx devrites@latest` resolves. `npm publish`
    ships the committed, validate-checked `pack/generated/` (the repo `.npmrc`
    sets `ignore-scripts=true`, so no lifecycle script runs).
-7. Commits the version bump + changelog as `chore(release): <version> [skip ci]`, creates tag `v<version>`, and publishes a GitHub Release with the tarball, verified installer, binaries, and every checksum sidecar attached. The release job then attests the artifacts with build provenance (`actions/attest-build-provenance`), independent of npm provenance.
 
 The release archive
 consumes the validated generated files from the same Git index as the rest of
 its payload. Package and release installs validate and copy
-`pack/generated/{claude,codex}`. When a shell install or update shim runs from a
+`pack/generated/{claude,codex,omp,pi,devin}`. When a shell install or update shim runs from a
 source checkout whose generated payload is incomplete, the shim may regenerate
 the missing host payload before handing that local candidate to the engine. The
 engine itself only validates and copies host payloads; it never generates them.

package/docs/skills.md

@@ -16,8 +16,8 @@ merges native Codex configuration and guidance. Devin CLI receives skills under
 `.devin/skills`, custom subagent profiles under `.devin/agents`, and a marked
 guidance block in `AGENTS.md`.
 
-The root and reviewers never write source. Claude enforces the root boundary in
-plan mode. Codex uses a workspace-capable root so its sole write-capable
+The root and reviewers never write source. On Claude the root boundary is
+workflow policy (ADR-0035). Codex uses a workspace-capable root so its sole write-capable
 slice-wright can execute, while all other specialists remain read-only. On
 Devin, `allowed-tools` gives `edit`, `write`, and `exec` only to
 `devrites-slice-wright` among lifecycle roles (plus `fast-builder` for

package/engine/commands.go

@@ -30,7 +30,7 @@ func rootModeFor(command string, args []string) rootMode {
 	}
 	subcommand := firstRootOperand(args)
 	switch command {
-	case "secret-scan", "open-visual", "detect":
+	case "secret-scan", "open-visual", "detect", "recall":
 		return rootLenient
 	case "state":
 		switch subcommand {