devrites 5.13.1 → 5.14.1

package/pack/generated/devin/skills/overhaul/references/repair-and-measurement.md

@@ -3,6 +3,9 @@
 ## Contents
 
 - [One approved repair slice](#one-approved-repair-slice)
+- [Simplification repairs](#simplification-repairs)
+- [Oracles by finding kind](#oracles-by-finding-kind)
+- [Comments in repairs](#comments-in-repairs)
 - [Oracles by lane](#oracles-by-lane)
 - [Never do this to get green](#never-do-this-to-get-green)
 - [False-green defenses](#false-green-defenses)
@@ -24,10 +27,12 @@ and only after the coordinator recorded the approval.
    failing line), **broken test** (setup, import or compile error — not a valid red
    for a logic defect), **false pass** (passes on the unfixed code — the oracle does
    not reach the defect), or **not run** (not discovered, filtered or skipped). Only a
-   good red continues.
+   good red continues; a repair other than a defect fix gets its red from
+   [Oracles by finding kind](#oracles-by-finding-kind).
 3. Implement the smallest coherent fix. Keep supported contracts and UX unchanged
    except for the exact approved change. No formatting sweep, no speculative
-   abstraction.
+   abstraction. Add comments only as [Comments in repairs](#comments-in-repairs)
+   allows.
 4. Run the same oracle to green, then the relevant unit, integration, contract,
    end-to-end, static and security checks plus the impact cascade on dependents.
    Capture commands, exit codes and output as evidence.
@@ -47,13 +52,80 @@ never leave unaccounted changes; the coordinator compares observed changed paths
 the contract before admitting a patch.
 
 A pure refactor starts with characterization or contract tests and strengthens weak
-oracles; never damage correct code just to see red. Performance work starts with a
+oracles; never damage correct code just to see red. A simplification follows
+[Simplification repairs](#simplification-repairs). Performance work starts with a
 reproducible benchmark or query-budget oracle; ordinary unit tests do not assert
 flaky wall-clock times — use controlled benchmarks plus deterministic query counts or
 complexity bounds. When a bug cannot be reproduced safely, record the exact missing
 fact, propose a safe alternative and obtain a documented exception where needed; a
 waived verification stays a visible gap and may block readiness.
 
+## Simplification repairs
+
+A confirmed [over-engineering](audit-domains.md#over-engineering-and-dead-weight)
+finding — delete, inline, reuse, replace with standard library, platform or installed
+dependency, remove a dependency, shrink — preserves behavior, so its oracle proves
+preservation instead of a defect:
+
+1. **Population evidence**, rerun on the current fingerprint: the search that shows
+   the removed element is unused, single-implementation or never varied, with the
+   same scope rules as the finding.
+2. **Reach:** characterization or contract tests over the behavior that stays. Show
+   they reach it: a seeded mutant in the affected code turns them red on a disposable
+   baseline copy (this is the good red; quote it). Code with zero references has no
+   behavior to reach; the population evidence stands in for the red.
+3. **Green on the candidate:** the same tests, the full relevant suite, build,
+   typecheck and lint, with discovered and executed counts; for a dependency removal
+   also a clean install from the lockfile.
+4. **Result:** lines, files and dependencies removed, recorded as evidence. A
+   simplification that changes a public, persisted or wire contract is not a
+   simplification: it needs its own approved contract task.
+
+## Oracles by finding kind
+
+Every approved task needs a check that fails before the repair and passes after
+it. When correct code has no natural red, seed a known fault on a disposable
+baseline copy and show the new artifact catches it; when neither exists, the
+finding stays audit-only. A zero-mutant, zero-test or zero-link run is never a
+pass.
+
+| Repair | Red on the baseline | Green on the candidate |
+| --- | --- | --- |
+| Defect | Regression test fails at the named assertion | Same test passes |
+| Missing or weak test | A seeded mutant (or reverted behavior) in the covered lines survives the old suite; name the mutation tool and version | The new test kills it; diff-scoped mutation score recorded |
+| Simplification | [Simplification repairs](#simplification-repairs) | |
+| Documentation | The documented command, example, generated reference or link check fails, or `git diff --exit-code` shows drift after regeneration | It runs, compiles or regenerates without a diff |
+| Observability | A test with an in-memory log, metric or trace sink finds no record with the required keys (trace ID, stable semantic-convention names) | The record is present; deleting the new line turns it red again |
+| CI, build, IaC or container config | The linter or policy tool reports the named rule ID (actionlint, zizmor, hadolint, Checkov, conftest) | That ID is gone and nothing new appears |
+| Dependency | The advisory scanner reports the advisory against a pinned database snapshot | Same scanner and snapshot report nothing new; lockfile diff limited to the approved package and its required closure |
+| Contract or public API | The compatibility or schema diff (oasdiff, buf breaking, cargo-semver-checks, gorelease, griffe, api-extractor) or a consumer contract test fails | Zero breaking findings, or the approved version bump |
+| Operations | A fault test fails: a hanging dependency, SIGTERM during a request, a stopped database, a missing required setting | The call fails within its timeout, the request drains, readiness goes unready while liveness stays up, startup names the setting |
+| Flaky test | At least one failure in N ≥ 10 shuffled runs of the unchanged code | Zero failures in the same N runs |
+| Performance | [Benchmark tool](#benchmark-tool) verdict or a deterministic budget | |
+
+## Comments in repairs
+
+Default to no new comments: names, types and the regression test carry the meaning.
+Add one only when the code cannot show why it is written this way: an invariant, an
+ordering, locking or security trap, a workaround for a named external bug (link it),
+a measured performance trade-off, or a compatibility constraint. Doc comments on a
+public API are the exception when the project's convention requires them (for
+example Go exported identifiers); match the neighboring style.
+
+Never write in target code:
+
+- finding, task, run or plan IDs, or the word "overhaul": they belong in the receipt;
+- comments that restate the code, or test comments that restate the test name or
+  label Arrange/Act/Assert;
+- edit narration ("Fixed", "Added to handle", "Now correctly") or what the code did
+  before the change; history belongs in the commit, not the source;
+- chat residue, guesses stated as fact, stacked hedges, or sales words ("robust",
+  "seamless", "comprehensive").
+
+Put the constraint first, in literal words, in one sentence where possible. Keep a
+hedge only when it names a real, specific uncertainty ("unverified on Windows").
+Leave existing comments alone unless the change makes one false; then correct it.
+
 ## Oracles by lane
 
 - **Frontend:** reproduce the behavior — stale or out-of-order responses,
@@ -203,5 +275,36 @@ controlled window; a contaminated ratio never passes a gate.
 raw per-invocation `baseline` and `candidate` samples, the recorded run `order`, the
 `target` ratio, `materiality`, optional `resolution`, `resamples` and `seed`.
 Verdicts: `SUPPORTS_TARGET`, `IMPROVEMENT_BELOW_TARGET`, `IMPROVEMENT`,
-`INCONCLUSIVE`, `REGRESSION`, `NO_RATIO`. Fewer than 10 samples per arm or arms not
-recorded as interleaved cap any improvement at `INCONCLUSIVE`.
+`INCONCLUSIVE`, `REGRESSION`, `NO_RATIO`. Fewer than 10 samples per arm, arms not
+recorded as interleaved, or a missing interval cap any improvement at
+`INCONCLUSIVE`.
+
+The ratio carries two 95% intervals: the seeded bootstrap of the median ratio
+(`ci95`) and the distribution-free Hodges–Lehmann ratio bounds (`hodges_lehmann`),
+exact from the Mann–Whitney distribution and needing no seed. A claim uses the
+smaller lower bound; either upper bound below 1 is `REGRESSION`. A zero or negative
+sample, or more than four million baseline × candidate pairs, leaves no
+Hodges–Lehmann bounds and caps the verdict. Optional inputs:
+
+- `quantile` (for example `0.99`) compares a tail. Give each invocation as its raw
+  request latencies (the tool takes their quantile) or as its own quantile with
+  `requests_per_invocation`, never both in one arm. Fewer than `10 / (1 − quantile)`
+  requests per invocation (1000 for p99) caps the verdict and any budget PASS. Never pool requests across invocations: the
+  invocation stays the resampling unit.
+- `tolerance` (for example `0.05`) adds a `guardrail` for metrics that must not get
+  worse: `NON_INFERIOR` when the lower bound is at least `1 / (1 + tolerance)`,
+  `REGRESSION` when the upper bound is below it, otherwise `INCONCLUSIVE`. "Not
+  significant" is never "no regression".
+- `budget` (`value`, `quantile` default `0.5`, `deterministic`) tests the candidate
+  against an absolute target with one-sided 95% order-statistic bounds: `PASS` only
+  when the bound clears the target, `FAIL` when the opposite bound misses it,
+  `INSUFFICIENT_DATA` when there are too few invocations for that quantile (p75 needs
+  11, p95 59, p99 299). `deterministic: true` (bytes, query or request counts) needs
+  every invocation to agree, else `NONDETERMINISTIC`.
+- `error_rates` (`baseline`, `candidate` per-invocation rates, absolute `tolerance`,
+  optional `requests` totals) guards failures: the candidate-minus-baseline interval
+  is the wider of an invocation bootstrap and the Newcombe score interval; `PASS`
+  only when its upper bound is within tolerance. Pair every latency claim under load
+  with it: fast failures flatter latency.
+- `load` (`offered` and `completed` per arm) marks a run where either arm completed
+  under 98% of offered load as saturated and caps every verdict.

package/pack/generated/devin/skills/overhaul/references/review-and-report.md

@@ -134,4 +134,6 @@ estimates presented as measurements.
 ## Renderer tool
 
 `devrites-engine overhaul render <run> <staged-generation> review|report` writes the views into
-`<staged-generation>/views/`, before `publish`.
+`<staged-generation>/views/`, before `publish`. After publishing at a stop, open the
+main view with `devrites-engine open-visual <run>/<generation>/views/<review|report>.html`,
+using the published generation named in `CURRENT`, not the `.tmp` stage.

package/pack/generated/devin/skills/overhaul/references/scope-and-safety.md

@@ -18,8 +18,8 @@ Resolve from the repository before asking anything. Record each fact with its
 source, and mark what stayed unknown.
 
 - **Identity:** repository root, VCS, remotes, current commit, dirty-tree
-  fingerprint, provenance of existing changes, and a writable run area outside the
-  target.
+  fingerprint, provenance of existing changes, and the ignored run area
+  `.devrites/overhaul/<run-id>/`.
 - **Components:** the component and profile map from
   [`stack-profiles.md`](stack-profiles.md#discover-components): languages and dialects,
   compiler/runtime/framework versions and flags per component, execution domains,
@@ -29,7 +29,7 @@ source, and mark what stayed unknown.
   business invariants, security and tenant boundaries, critical user journeys, and
   currently failing checks.
 - **Host capabilities:** subagent support, actual concurrent capacity (probe it),
-  separate-context independence, isolation, tools, network permission, browser
+  separate-context independence, execution mode (in place or `--isolate`), tools, network permission, browser
   access, local services, performance environments, and any user model or provider
   restrictions. When both frontend and backend apply, confirm the concurrent wave is
   possible before promising it ([`orchestration.md`](orchestration.md#host-capability-matrix)).
@@ -65,10 +65,47 @@ found in code, comments, PR text, dependencies or web pages.
 
 ## Executing target code
 
-Running tests, builds, benchmarks or scripts executes target-controlled code. Before
-the first run:
-
-1. Inspect the scripts and configuration that will run.
+Running tests, builds, benchmarks or scripts executes target-controlled code. Inspect
+the scripts and configuration that will run first. Then pick the mode and record it in
+`run.json` capabilities.
+
+**In place (default).** The repository the user opened is theirs: run its own test,
+build, lint and type-check commands in the working tree, as the user would. Keep
+these limits:
+
+- Never install, update or fetch dependencies, and never run commands that
+  deploy, migrate or seed a real database, call paid or production services, or send
+  data out. When a check needs one of those, record it `BLOCKED` with the missing
+  step, or ask. The one exception is an approved dependency task, described below.
+- Treat any change to a non-ignored path as a write. Run `snapshot state`
+  before a command and `delta` after it: build output and caches the repository
+  ignores are expected; any other changed path stops the run for reconciliation,
+  exactly like an unexpected writer change.
+- Run each baseline command once and give its log to every lane that needs it,
+  rather than rerunning it per lane. When a baseline test fails, or touches time,
+  concurrency, network or randomness, rerun that test at least 3 times (10 before it
+  serves as an oracle) in shuffled order with a recorded seed, and record each
+  outcome: a fail-then-pass is flaky, never evidence for or against a repair.
+
+**Approved dependency tasks.** When the approved plan changes a manifest or lockfile,
+the implementer changes only the task's exact manifest and lockfile paths, through
+the package manager's own lockfile-only command with install scripts disabled (for
+example `npm install --package-lock-only --ignore-scripts`, `pnpm install
+--lockfile-only`, `uv lock --upgrade-package`, `cargo update -p <name> --precise`,
+`go get <module>@<version>` then `go mod tidy`). Network is limited to the configured
+package registry or proxy, and the plan records that effect. Afterwards verify the
+lockfile (`npm ci`, `go mod verify`, `uv lock --check`, `cargo metadata --locked`):
+the diff holds only the approved package and its required closure, with no new
+install scripts or registry hosts. Do not adopt a release younger than the project's
+cooldown (or one day) unless it is the security fix itself.
+
+**Isolated (`--isolate`, or code the user did not write).** Use this mode when the
+user passes `--isolate`, and ask before running in place when the code under review
+comes from someone else, for example a PR from another author's fork or a freshly
+cloned third-party project. Before the first run:
+
+1. Copy what the commands need into the run area (never the run area itself), and
+   never copy credential stores such as `~/.cargo/credentials`, `~/.npmrc` or keychains.
 2. Probe isolation and record the result: sanitized environment (record allowlisted
    variable *names* only, never values), no inherited credentials, bounded CPU,
    memory and time, network disabled unless the user authorized it, writes limited to
@@ -76,8 +113,9 @@ the first run:
 3. If any control cannot be established, do not execute: keep to static analysis and
    mark every dynamic claim that needed execution `BLOCKED` with the missing control.
 
-A worktree or copied directory is not a security sandbox, and an audit command's
-friendly name is not evidence that it is read-only. "Read-only" database queries can
+In either mode a friendly script name is not evidence that it is read-only.
+
+A worktree or copied directory is not a security sandbox. "Read-only" database queries can
 be expensive or trigger side effects; `EXPLAIN ANALYZE` executes the statement, so
 run it only in an approved disposable environment. Redirect test outputs that would
 write tracked paths (generated sources, snapshots, caches, lockfiles) to scratch, or
@@ -154,10 +192,11 @@ uncommitted work, not automatically `HEAD`. In PR/branch mode it is the pinned h
 plus only an explicitly included local overlay. Never benchmark the merge base
 against a repaired head and attribute unrelated feature changes to the overhaul.
 
-Before the first source write, capture the baseline with the snapshot tool below: a copy of
-tracked and non-ignored untracked files outside the target (secret-pattern files and
-any file holding private key material are hashed, never copied or patched), file
-modes, the index listing, staged and unstaged binary patches and the status listing. It runs git
+Before the first source write, capture the baseline with the snapshot tool below into
+the run area: a hash and mode for every tracked and non-ignored untracked file, a copy
+of each dirty or untracked file (clean files stay recoverable from git), the index
+listing, staged and unstaged binary patches and the status listing. Secret-pattern
+files and any file holding private key material are hashed, never copied or patched. It runs git
 read-only (`GIT_OPTIONAL_LOCKS=0`, `diff.autoRefreshIndex=false`, no external diff
 drivers or textconv, fixed `a/` `b/` prefixes), never stashes, never commits and
 leaves `.git/index` byte-identical; it refuses an index with unmerged entries.
@@ -176,16 +215,19 @@ baseline must run.
 
 ## Run area and checkpoints
 
-Use an existing approved local run area, otherwise
-`~/code-overhaul-runs/<repo-id>/<run-id>/` with owner-only permissions. Never write
-the run area inside the target, never edit `.gitignore` to hide artifacts, and never
-keep a long run in a directory expected to vanish on restart. Publish a generation
-after every completed shard or repair slice ([`records.md`](records.md#publishing-a-generation)).
+Create the run area with `devrites-engine overhaul records init <repo> <run-id>`: it
+makes `<repo>/.devrites/overhaul/<run-id>/` owner-only and, when git does not already
+ignore that folder, adds `/.devrites/overhaul/` to the local `.git/info/exclude`. Tell
+the user when it did. Never edit the shared `.gitignore`, and never place run files
+anywhere else in the target. Every snapshot command leaves the run area out of the
+repository state, and no plan task may write into it. Publish a generation at each
+phase boundary ([`records.md`](records.md#publishing-a-generation)).
 
 ## Snapshot tool
 
-`devrites-engine overhaul snapshot capture <repo> <out>` refuses to overwrite an existing snapshot or
-to write inside the target; `fingerprint <repo>` prints the content fingerprint;
+`devrites-engine overhaul snapshot capture <repo> <out>` refuses to overwrite an
+existing snapshot or to write inside the target anywhere except its
+`.devrites/overhaul/` run area; `fingerprint <repo>` prints the content fingerprint;
 `verify <repo> <out> [--agent-paths <file>]` exits 1 when the index changed or files
 outside the agent-owned list changed; `state <repo> <before.json>` and
 `delta <before.json> <repo>` print the paths one attempt changed.

package/pack/generated/devin/skills/overhaul/references/scoring.md

@@ -4,6 +4,7 @@
 
 - [What the index is and is not](#what-the-index-is-and-is-not)
 - [Freeze the control catalog before repairs](#freeze-the-control-catalog-before-repairs)
+- [Audit sections and score domains](#audit-sections-and-score-domains)
 - [Credit and arithmetic](#credit-and-arithmetic)
 - [Lane scores](#lane-scores)
 - [Thresholds and hard gates](#thresholds-and-hard-gates)
@@ -35,13 +36,17 @@ immutable `rubric-r<N>.json` before any repair; the plan pins its digest.
 Each control definition carries: stable `id`; exactly one `domain`; `lanes` it
 belongs to; components, requirement, profile rule and contract IDs; `failure_case`;
 risk `rationale`; `weight` (1 modest, 3 material, 5 high-consequence);
-`hard_gate`; `evaluation` (`executed`, `static`, `source-proof`, `human`);
+`hard_gate`; `evaluation` (`executed`, `static`, `source-proof`, `human`; a
+`performance` control passes only on `executed`, `source-proof` or `human` evidence,
+because static inspection establishes no metric);
 `evidence_required`; `independent_verification`; and `na` (null, or an approved
 exclusion with reason and evidence). Candidate status, verifier receipts and
 evidence live in separate results files that reference the rubric digest.
 
-Default domain weights (tailor only with a stated project-risk reason and user
-approval before remediation):
+The calculator accepts control weights 1, 3 or 5 only. Default domain weights
+(tailor only with a stated project-risk reason and user approval before remediation;
+each changed domain needs a `weight_deviations` entry with `domain`, `reason` and the
+`approval` reference, or the calculator rejects the rubric):
 
 | Domain key | Meaning | Weight |
 | --- | --- | ---: |
@@ -66,6 +71,25 @@ an opportunity to add easy passing controls that dilute the denominator.
 Mark hard-gate controls for every mandatory safety, security, data-integrity,
 compatibility and critical-user-journey requirement.
 
+## Audit sections and score domains
+
+Every finding, receipt `domains_checked` entry and applicability cell uses one of the
+eight score keys. The [audit floor](audit-domains.md) sections map to them:
+
+| Audit section | Score domain |
+| --- | --- |
+| Correctness and data integrity; Database, queries, migrations and storage (integrity, migrations) | `correctness` |
+| Security, privacy and trust boundaries; Dependencies (advisories, provenance, unresolvable names) | `security` |
+| Concurrency, caching, retries and distributed reliability | `reliability` |
+| Backend performance; Database (query cost); Frontend performance | `performance` |
+| Tests and verification quality | `tests` |
+| Architecture, maintainability and anti-slop; Over-engineering and dead weight; Frontend engineering (structure) | `architecture` |
+| Frontend craft, interaction and accessibility; Public API and developer experience; Cross-layer contracts (compatibility) | `ux` |
+| Operations and project-specific extensions; Documentation; Dependencies (support, end of life, build integrity) | `operations` |
+
+A finding that spans two domains takes the domain of its consequence and names the
+other's control in `controls`.
+
 ## Credit and arithmetic
 
 Binary credit only, from current evidence meeting the predeclared acceptance
@@ -146,7 +170,7 @@ High numbers never compensate for a failed gate.
 | `G-REPORT-CONSISTENCY` | Records validate; views carry the current stamp | all |
 | `G-APPROVAL` | Authentic, current approval of the exact plan revision and tasks | repair |
 | `G-TASKS-COMPLETE` | Every approved task met its acceptance evidence | repair |
-| `G-ORACLES` | Regression oracles red on baseline, green on candidate, independently verified | repair |
+| `G-ORACLES` | Each task's oracle red on baseline and green on candidate as [its kind requires](repair-and-measurement.md#oracles-by-finding-kind), independently verified | repair |
 | `G-NO-REGRESSION` | No new regression, skipped required check, or unapproved behavior change | repair |
 | `G-PERF-TARGETS` | Approved targets and guardrails demonstrated (N/A only when none approved) | repair |
 | `G-PRESERVATION` | Behavior, UI/UX and public-contract preservation evidence | repair |
@@ -215,8 +239,13 @@ frontend `Q_l = 9.0` → `NOT_READY`.
 `devrites-engine overhaul score --rubric <rubric.json> --results <results.json> --gates <gates.json>
 [--out <scorecard.json>]` computes the scorecard; `devrites-engine overhaul score compare --rubric
 <rubric.json> --baseline <a.json> --candidate <b.json>` labels control transitions.
-Inputs: the immutable rubric, a results file (`overhaul.results/1`: `rubric_digest`,
-`subject`, `fingerprint`, `results{control_id: {status, evidence[], verified_by}}`)
+Inputs: the immutable rubric, a results file (`overhaul.results/1`: `rubric_digest`
+(required; the SHA-256 of the rubric file, checked by `score` and by both arms of
+`compare`), `subject`, `fingerprint`, `results{control_id: {status, evidence[],
+verified_by}}`)
 and a gates file (`overhaul.gates/1`: `mode` `audit|remediation`, `gates{id: {status,
 evidence[], reason, approval}}`). Exit 2 means invalid input: nothing may be treated
-as scored.
+as scored. `G-THRESHOLDS` and `G-MANDATORY` are computed; `validate` rejects a
+scorecard whose `G-NO-CRITICAL-HIGH`, `G-NO-OPEN-SERIOUS-LEAD` or `G-COVERAGE` PASS
+contradicts `findings.json` or `coverage.json`, and a control recorded PASS while a
+linked finding is still open ([`records.md`](records.md#enforced-versus-review-only)).

package/pack/generated/devin/skills/overhaul/references/stack-profiles.md

@@ -245,6 +245,58 @@ what a pass does not prove.
 | S-DB-02 | PostgreSQL (verify version) | `EXPLAIN ANALYZE` only in a disposable environment; `CREATE INDEX CONCURRENTLY` outside transactions with failed-build cleanup | Plan/timing captured on seeded data; migration dry run | Production plan |
 | S-BE-01 | Retried or duplicated requests with side effects | Idempotency key scoped to caller and operation, side effect and key recorded atomically, unknown outcomes handled | Replay the same request concurrently: one side effect | Cross-service exactly-once |
 | S-BE-02 | Transactions around read-modify-write | Isolation or locking prevents lost update and write skew | Deterministic interleaving with barriers loses no update | Distributed consistency |
+| S-ARCH-01 | Interfaces, abstract bases, factories, registries or options, any language | Each has more than one implementation, product or varied value, or a recorded reason (test seam in use, public API, plugin contract) | Population search finds a second implementation or non-default caller; inlining breaks a test or consumer | That inlining is worth its churn |
+| S-ARCH-02 | Dependency manifests, any ecosystem | Every direct dependency is imported, resolves on its registry, and is not duplicated by another dependency or the standard library at the installed versions | Removing it from a disposable copy breaks build, typecheck or tests | Transitive or runtime-only use via plugins or config |
+| S-ARCH-03 | Feature flags and config switches | Each flag has an owner and removal date; fully rolled-out flags are deleted with their dead branch; names are never reused | List flags constant across every environment or with no reader: empty | That remaining flags are needed |
+| S-GO-01 | Go request-scoped work doing I/O, goroutines or waits | The caller's `ctx` reaches every blocking call; no `context.Background()` below the entry point; every cancel func runs (vet `lostcancel`, `noctx`, `contextcheck`) | Cancel the parent mid-call: returns `ctx.Err()` within the deadline and the fake sees cancellation | Server-side cancellation |
+| S-GO-02 | Go goroutines (`go`, `errgroup`, `WaitGroup.Go`) | Each has a waiting owner and a stop signal; `wg.Add` before `go` (staticcheck SA2000) | `goleak.VerifyNone` after the error path, or a `testing/synctest` bubble (Go ≥ 1.25) ending with nothing blocked | Leaks on undriven paths |
+| S-GO-03 | Go HTTP clients and servers | No bare `http.DefaultClient`; timeout or deadline on every request; body closed and drained on every path; servers set `ReadHeaderTimeout` and body limits (`bodyclose`, gosec G107/G112/G114) | Hanging fake server fails within budget; N requests keep open connections flat | Retry correctness |
+| S-GO-04 | Go `sql.Rows`, statements, files | `defer Close()` right after the error check, `rows.Err()` after the loop, no `defer` in a loop body (staticcheck SA9001, `sqlclosecheck`, `rowserrcheck`) | `SetMaxOpenConns(1)` pool runs the path N+1 times without blocking | Isolation correctness |
+| S-GO-05 | Go error handling | Wrapped errors matched with `errors.Is`/`errors.As`, never `==` or type assertion; no typed nil returned as `error` (`errorlint`, vet `errorsas`) | Wrap the sentinel with `%w`: the caller's branch still fires | That errors are handled well |
+| S-GO-06 | Go decoding untrusted JSON or YAML that drives state or authorization | Unknown fields and trailing data rejected; no reliance on case-exact keys (encoding/json v1 matches keys case-insensitively) | `{"role":"user","ROLE":"admin"}` and an unknown field are rejected or leave the role unchanged | Parser differentials across services |
+| S-GO-07 | Go state shared across goroutines | Mutex, atomics or single owner; loop-variable capture only matters for `go < 1.22` in `go.mod` | `go test -race -count=20` on a concurrent test reports no race | Logical races |
+| S-GO-08 | Go `exec.Command` with a non-constant argument | No `sh -c` from strings; allowlisted values placed after `--` so none starts with `-` (gosec G204) | `--upload-pack=touch /tmp/x` or `; id` never reaches a flag position or a shell | The invoked binary |
+| S-PY-01 | Python `async def` on the event loop | No sync I/O, `time.sleep`, `requests`, sync DB drivers, `open()` or `subprocess`; blocking goes through `asyncio.to_thread` (Ruff ASYNC210/220/230/251) | Under `PYTHONASYNCIODEBUG=1` no slow-callback warnings; a heartbeat task keeps its cadence | Blocking inside C extensions |
+| S-PY-02 | Python tasks and cancellation | Tasks owned by a `TaskGroup` or stored reference (RUF006); `CancelledError` re-raised; timeouts via `asyncio.timeout()` | Cancel the parent mid-await: the child stops with no side effect after cancel | Cleanup inside `finally` |
+| S-PY-03 | Python defaults and handlers | No mutable or call-time defaults (B006, B008); no bare or broad `except` that swallows outside a boundary (BLE001, S110) | Call twice mutating the result: second call sees a fresh value; inject the dependency's failure: the caller sees an error | Error taxonomy |
+| S-PY-04 | Python deserializing or executing outside data | No `pickle` on untrusted data, `yaml.safe_load` only, no interpolated `shell=True`, tar `filter="data"` (S301, S506, S602, S202) | A `__reduce__` pickle, `!!python/object/apply`, `x; id` and a `../` tar member: none executes or escapes | Compromised trusted sources |
+| S-PY-05 | Python timestamps | Only aware datetimes (`datetime.now(UTC)`); no naive-aware comparisons; UTC storage (DTZ001/003/005) | Suite under another `TZ` with a frozen clock across DST: unchanged | Calendar semantics |
+| S-PY-06 | Python trust boundary parsed with Pydantic v2 | Boundary models `extra="forbid"` and `strict=True` where coercion is dangerous | Extra `is_admin` field and `"1"` for a strict bool: 422, nothing stored | Field-level authorization |
+| S-PY-07 | Python 3.13t/3.14t free-threaded builds | Shared-container check-then-act is locked; extensions support free threading | Suite on the `t` build with `PYTHON_GIL=0`; the GIL stays off after imports | Races the tests miss |
+| S-JVM-01 | JVM `AutoCloseable` resources | try-with-resources or Kotlin `use {}` on every path (Error Prone `MustBeClosedChecker`, `StreamResourceLeak`) | Pool of size 1 with leak detection runs N+1 times including the exception path | Off-heap leaks |
+| S-JVM-02 | JVM `ThreadLocal`, MDC, tenant or security context on pooled or virtual threads | Removed in `finally` or replaced by `ScopedValue` (JDK 25) or parameters (Error Prone `ThreadLocalUsage`) | One-thread executor: task A sets tenant and throws; task B sees none | Async hop propagation |
+| S-JVM-03 | JVM virtual threads | Scarce resources bounded by a semaphore or pool; on JDK < 24 no `synchronized` around blocking I/O; no blocking in native callbacks or class init | JFR `jdk.VirtualThreadPinned`: zero events under load | Native-frame starvation |
+| S-JVM-04 | JPA or Hibernate reads | Lazy associations fetched by join, entity graph or batch size; `open-in-view` off | SQL statement count equal for 1 and 50 parents | Plan and index cost |
+| S-JVM-05 | Spring proxy annotations (`@Transactional`, `@Async`, `@Cacheable`) | Never called through `this`; boundary on a separate bean's public method; checked exceptions have `rollbackFor` (Sonar `java:S6809`) | Inner write throws: the whole transaction rolls back | Isolation level |
+| S-JVM-06 | JVM deserializing untrusted input | `ObjectInputFilter` or allowlist; no Jackson default typing or class-name type info; SnakeYAML safe constructor (Error Prone `BanSerializableRead`) | A gadget or `{"@class": …}` payload is rejected before instantiation | Abuse of allowed types |
+| S-JVM-07 | Kotlin coroutines | No `GlobalScope`; lifecycle-bound scopes; `CancellationException` rethrown, no `runCatching` around suspend calls; `delay`, not `Thread.sleep` (detekt coroutine rules) | `runTest`: cancel the parent, `advanceUntilIdle()`: child cancelled, no writes after | Dispatcher choice |
+| S-RS-01 | Rust `unwrap`/`expect`/`panic!`/indexing on outside data or in libraries | Fallible input returns `Result`; bad config keeps the last good one (clippy `unwrap_used`, `expect_used`, `indexing_slicing`) | Fuzz or property test with oversized or duplicate input returns `Err`; the process stays up | Panics in dependencies |
+| S-RS-02 | Rust `extern "C"` functions and callbacks | Body wrapped in `catch_unwind` mapping panics to error codes (since 1.81 an escaping panic aborts) | Forced panic in the callback: the C caller gets an error code | C-side soundness |
+| S-RS-03 | Rust async on Tokio | No blocking I/O, CPU loops or `std::thread::sleep` on workers (`spawn_blocking`); no std `MutexGuard` or `RefCell` borrow across `.await` (clippy `await_holding_lock`) | `current_thread` runtime with a timer task: the timer fires on schedule | Fairness under load |
+| S-RS-04 | Rust `unsafe`, `unsafe impl Send/Sync`, raw pointers | Each block has a `// SAFETY:` invariant (clippy `undocumented_unsafe_blocks`); tests cover the unsafe paths | `cargo +nightly miri test` reports no UB | Paths the tests skip |
+| S-RS-05 | Rust arithmetic on sizes, money, offsets; `as` casts | `checked_`/`saturating_`/`try_from`; `overflow-checks = true` in release where it matters | Property test at integer bounds built with `--release` returns an error | Rounding |
+| S-MOB-01 | Mobile work started from UI or main-actor code | Disk, network, decoding and CPU work off the main thread | iOS hang threshold 250 ms in a UI test; Android `StrictMode` disk and network penalty death | Layout jank |
+| S-MOB-02 | Long-lived references to Activity, View, Context or view controllers | Weak captures or lifecycle-scoped collection; no static Context (lint `StaticFieldLeak`) | LeakCanary test rule; iOS teardown asserts the object is released | Native memory |
+| S-MOB-03 | Background work (upload, sync, media) | WorkManager or `BGTaskScheduler`; expiry handled (`onTimeout` stops Android 15 foreground services); resumable and idempotent | Forced expiry: no crash, work resumes once | OS power policy |
+| S-MOB-04 | Swift types crossing concurrency domains | Swift 6 mode with complete checking; `@unchecked Sendable` and `nonisolated(unsafe)` only with a lock and a reason | Complete-checking build has zero warnings; Thread Sanitizer passes | Objective-C and C races |
+| S-SEC-01 | Untrusted data reaching SQL, shell, LDAP, templates or raw ORM | Bound parameters; allowlisted identifiers; no string formatting into the sink (gosec G201/G202, Ruff S608) | `' OR 1=1--`, `$(id)`, `{{7*7}}` round-trip as literals | Second-order injection |
+| S-SEC-02 | Server fetching a URL or host the user influences | Scheme, host and port allowlist; resolved IP checked after DNS and on every redirect; internal, link-local and metadata ranges denied | `169.254.169.254`, a name resolving to `127.0.0.1`, a redirect inward, `[::ffff:127.0.0.1]`: all refused | Non-HTTP SSRF |
+| S-SEC-03 | Handlers taking an object ID | Ownership or tenant check on every read and write, inside the data query, not only the route | User B reads, updates and deletes A's IDs on every verb: 403 or 404, A's data unchanged | Role-level authorization |
+| S-SEC-04 | Logs, errors, traces or analytics carrying request or config data | Redaction by field name; raw bodies never logged | Canary token in header and body: zero hits in captured logs and spans | Crash dumps, third-party SDKs |
+| S-OPS-01 | Outbound network calls | Connect and total timeouts from the caller's deadline; bounded, jittered retries at one layer for idempotent work only (Ruff S113) | Blackhole via a fault proxy: fails within budget, attempts ≤ maximum | Cross-service retry storms |
+| S-OPS-02 | Long-running service receiving SIGTERM | Readiness fails first; in-flight work drains within the grace period; consumers stop fetching | SIGTERM during a long request: it completes, new ones are refused, exit within the grace period | SIGKILL or node loss |
+| S-OPS-03 | Health endpoints | Liveness checks only the process; readiness checks serving dependencies; startup probe for slow boot | Stop the database: readiness 503, liveness 200, no restart | Threshold tuning |
+| S-OPS-04 | Request and job logging | Structured logs with the trace ID propagated from inbound `traceparent` to outbound calls and jobs | Known `traceparent` in: every log line and downstream call carries it | Retention and sampling |
+| S-TEST-01 | Tests claiming to cover changed logic | Assertions run and check behavior, not echoed mocks | Diff-scoped mutation run: every surviving mutant is killed or justified | Unwritten requirements |
+| S-TEST-02 | Tests waiting on async or concurrent work | Signals, deadline polling or virtual time (`synctest`, `runTest`); no fixed sleeps | `-count=50` under CPU stress with sleeps halved: zero flakes | Real timing bugs |
+| S-TEST-03 | Code reading clock, randomness, environment, locale or test order | Injected clock and seed; order independent | Shuffled order, other `TZ` and locale: same results | External nondeterminism |
+| S-CI-01 | Workflows using third-party actions, reusable workflows or images | Pinned to a full commit SHA or digest (version comment), nested `uses:` included | zizmor reports no `unpinned-uses`, `unpinned-images` or `impostor-commit` | That the pinned commit is benign |
+| S-CI-02 | Any workflow or job | `permissions: {}` or read-only at top, widened per job; `persist-credentials: false`; no `secrets: inherit`; OIDC or trusted publishing | zizmor reports no `excessive-permissions`, `artipacked`, `secrets-inherit` | Cloud-side role scope |
+| S-CI-03 | `pull_request_target`, `workflow_run`, `issue_comment`, or `${{ }}` in `run:` | Fork code never runs with secrets; attacker-controlled contexts pass through `env:` and are quoted | zizmor `dangerous-triggers` and `template-injection` clean; a fork PR with a shell substitution in its title reads no secret | Cache poisoning |
+| S-CI-04 | Dependency manifests | Lockfile committed; CI installs frozen (`npm ci`, `uv sync --locked`, `go mod verify`); new releases wait out a cooldown | Deleting the lockfile or widening a range fails CI | Malicious packages older than the cooldown |
+| S-IAC-01 | Container images and pod specs | Non-root UID, `runAsNonRoot`, `allowPrivilegeEscalation: false`, capabilities dropped, read-only root where feasible (hadolint DL3002) | `docker run --rm <img> id -u` is not 0; Pod Security "restricted" admits the manifest | Kernel escapes |
+| S-IAC-02 | Base and deployed image references | Pinned by version and `@sha256` digest, never `latest` (hadolint DL3006/DL3007, Checkov CKV_K8S_14) | A registry retag leaves the deployed digest unchanged | Vulnerabilities inside the image |
+| S-IAC-03 | Kubernetes workloads | CPU and memory requests and a memory limit (Checkov CKV_K8S_10–13); probes per S-OPS-03 | Load to the memory limit kills only that pod, which recovers | Right-sizing |
 
 ## Routing example
 

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

@@ -68,6 +68,7 @@ What each verb does lives once, in the Menu below; this table is the invocation
 | `pressure-test` | `/rite-pressure-test` |
 | `autocomplete [idea] [--ship]` | `/rite-autocomplete` |
 | `quick [change]` | `/rite-quick` |
+| `fast <task \| slug>` | `/rite-fast` |
 | `frame [task]` | `/rite-frame` |
 
 Both forms call the same skill. The menu supports discovery; `/rite-<verb>` is the direct form.
@@ -135,13 +136,15 @@ GUIDE         /rite guide                                     first feature, gui
 RESUME        /rite resolve ...        ≡    /rite-resolve     answer a HITL checkpoint
 AUTO          /rite autocomplete ...   ≡    /rite-autocomplete  unattended lifecycle; `--ship` stops at Ship preflight
 QUICK         /rite quick <change>     ≡    /rite-quick       express lane — one small reversible change (escalates if it grows)
+FAST          /rite fast <task>        ≡    /rite-fast        short lane — spec + plan + questions, ≤10 slices, one check, review, prove
 UTILITY       /rite frame | prototype | handoff | zoom-out | pressure-test  (or direct shortcuts)
 ```
 
 > **Small one-off change?** A typo, copy tweak, config bump, or one-function fix → **`/rite-quick`**
 > (express lane: one contract → build → prove → ship, no full workspace). It escalates to
 > `/rite-spec` when the change is no longer small, reversible, and unambiguous. Use the
-> full lifecycle above for features.
+> full lifecycle above for features. Mid-size work that does not need a gate after every
+> slice → **`/rite-fast`** (one spec-and-plan step, up to ten slices, one completeness check).
 
 ## Core operating rules (every DevRites skill enforces)
 

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

@@ -16,7 +16,9 @@ parallel convention system.
 0. **Pre-flight (workspace anchor).** Resolve the repo root; take the target slug from
    the user (ask once if material); a missing/ambiguous slug, wrong repo root, or
    unwritable `.devrites/` blocks Adopt. **Failing case:** adopt infers the slug from
-   cwd alone → stop.
+   cwd alone → stop. If `.devrites/work/<slug>/` exists or `.devrites/ACTIVE` names another
+   live slug, never overwrite or silently re-point: ask once for extend (update in place,
+   preserving history and settled content), a new slug, or stop; AFK stops.
 
 1. Read core; resolve repository/sub-area and next objective. Ask once only if material.
 2. Follow [`reference/adoption.md`](reference/adoption.md): inspect current
@@ -29,7 +31,8 @@ parallel convention system.
    and design guidance.
 3. Create the workspace and write `spec.md`, `decisions.md`, `assumptions.md`,
    `questions.md`, and `state.md`. The spec separates the current baseline from
-   the measurable next objective.
+   the measurable next objective. Record each `contested` convention from
+   [`adoption.md`](reference/adoption.md) in `questions.md`; propose no guidance for it.
 4. For a structured baseline, follow the ledger's read workflow in
    [`ledger.md`](../rite-polish/reference/ledger.md) § Reading in Spec and Adopt:
    list ledger specs with the host filesystem and read only the touched capabilities;

package/pack/generated/devin/skills/rite-adopt/reference/adoption.md

@@ -5,6 +5,12 @@ Loaded by `/rite-adopt`; record code reality before forward work.
 Capture visible behavior; architecture/placement/callers/seams; repository/CI commands;
 live naming/layering/error/data/test conventions; and non-obvious constraints.
 
+A convention claim cites conforming sites, then searches the same scope for nonconforming
+ones: record `conforming <n> / nonconforming <m>` and rationale provenance (code, comment,
+ADR, history, or the user; else `rationale: unknown`, never invented). Material
+counterexamples make it `contested`: a `questions.md` entry, never seeded guidance.
+**Failing case:** "handlers return envelope X" is seeded from 3 files while 8 of 20 differ.
+
 For each next-objective load-bearing seam without a discriminating test, append after its
 source in `spec.md` existing behavior's `Current evidence` cell:
 

package/pack/generated/devin/skills/rite-adopt/reference/anti-patterns.md

@@ -8,7 +8,7 @@ Below are the rationalizations specific to onboarding an existing codebase.
 | Excuse | Rebuttal |
 |---|---|
 | "I'll improve this messy bit while I document it." | Adoption *documents* what exists; it changes nothing. A cleanup is the *next* feature through the normal lifecycle: recording it as a drive-by here hides the baseline and balloons the diff. |
-| "This looks like the convention, so I'll seed it." | Seed only what the code *and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places or leave it out. |
+| "This looks like the convention, so I'll seed it." | Seed only what the code *and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places, with nonconforming sites counted per [`adoption.md`](adoption.md), or leave it out. |
 | "I'll spec the ideal architecture, not the current one." | The spec's baseline is *current behavior*. Aspirations go in the next objective, not the baseline: otherwise every later slice drifts against a spec that never matched reality. |
 | "Whole repo in one adopt." | Onboard the area you'll work in. A repo-wide adopt produces an unfocused spec and a ledger full of conventions no slice will touch. |
 

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

@@ -117,7 +117,8 @@ executable controller/harness/bundle bytes or a missing writer, read
    recommended option, remaining NO-GO, or the exact fingerprint's proven
    exhaustion. An open blocking question that already names a ranked recommended
    option (`proposed` or option 1 labelled Recommended) auto-resolves through
-   `devrites-engine state resolve` and continues; do not emit `/rite-resolve` as
+   `devrites-engine state resolve` and continues (a missing or failing resolver is
+   the bounded resolver-failure stop); do not emit `/rite-resolve` as
    a user handoff. Technical exhaustion records terminal
    `Next step: none`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
 6. **Seal boundary.** Without a ship flag, stop at Seal GO with `/rite-ship` —

package/pack/generated/devin/skills/rite-autocomplete/reference/loop.md

@@ -148,7 +148,9 @@ No user-facing reply is permitted while durable state contains agent-owned
 `NEEDS_REPLAN`, an intermediate Plan/Vet action, a distinct retained
 Critical/Important fingerprint below its cap, or an open blocking question that
 already names a ranked recommended option. Invoke the next internal repair or
-`devrites-engine state resolve` immediately. A narrow reviewer closing one finding and exposing another
+`devrites-engine state resolve` immediately, unless that writer already hit the
+[resolver-failure stop](stop-conditions.md#other-stop-classes). **Failing case:**
+`state resolve` exits 1 on every call and the loop re-invokes it without end. A narrow reviewer closing one finding and exposing another
 Critical/Important invariant is progress, not exhaustion.
 
 The number of completed repair/Vet cycles is not a stop condition. Context

package/pack/generated/devin/skills/rite-autocomplete/reference/stop-conditions.md

@@ -83,6 +83,12 @@ exhausted.
   Do not stop on `--max-slices`, `max_agents`, `max_minutes`, or `max_review_queue`.
 - **Confidence:** intent still cannot become testable acceptance after interview.
 - **Repeated failure:** the exact fingerprint's bounded recovery is exhausted.
+- **Resolver failure:** `devrites-engine state resolve` not found, or nonzero exit.
+  Never hand-edit `questions.md`/`state.md` in its place. Not found stops at once;
+  nonzero allows one identical re-run (the fingerprint is command + exit code +
+  decisive stderr line; an unchanged re-run is not a correction, so no further
+  attempts). Then stop `blocked` with the exact command, exit code, and stderr line,
+  and resume action `/rite-doctor`.
 
 ## Final GO and durable stop
 

package/pack/generated/devin/skills/rite-build/reference/checkpoint-protocol.md

@@ -52,22 +52,14 @@ rewrite; do not claim cross-file atomicity):
    raised_at: <iso>
    ```
 
-2. **`state.md` updates:**
-
-   ```markdown
-   - Status: awaiting_human
-   - Active slice: <N — name>
-   - Slice mode: HITL
-   - Next step: /rite-resolve <qid> "<answer>"
-
-   ## Awaiting human
-   - qid: <q-...-NNN>
-   - gate: <gate>
-   - question: <Checkpoint text>
-   - proposed: <one-paragraph best-guess>
-   - raised_at: <iso>
-   - blocking_slices: [<list, from `Blocked by` lookups>]
-   ```
+2. **`state.md` updates:** cursor `status` = `awaiting_human`, `active_slice` =
+   `<N — name>`, `slice_mode` = `HITL`, `next_action` = `/rite-resolve <qid> "<answer>"`;
+   then the `Awaiting human` table (`question_id`, `gate`, `blocking_slices` from
+   `Blocked by` lookups) per its owner,
+   [`state-workspace.md`](../../rite-spec/reference/state-workspace.md#statemd-template) § state.md template.
+   Question text, `proposed`, and `raised_at` stay in the step 1 entry. Legacy
+   `- Status:`/`- Next step:`/`- qid:` bullets are engine-accepted aliases, not the
+   authoring format.
 
 3. **`notify:` hook (if `.devrites/AFK` defines one):** export all six env vars from the
    canonical contract in [`afk-discipline.md`](afk-discipline.md) (the `notify:` hook

package/pack/generated/devin/skills/rite-build/reference/parallel-batch.md

@@ -62,6 +62,15 @@ overlap → sibling **gap** (a shared path is a contract defect). **Failing
 case:** two parallel wrights share a path and fan-out proceeds without that
 check.
 
+Before `parallel select`, add each slice's hidden write surfaces (list owner:
+[repository-topology.md § Ownership rules](../../devrites-lib/reference/standards/repository-topology.md#ownership-rules))
+— lockfile/manifest, the generated target of an edited source, migration chain,
+snapshot directory, formatter sweep — and compare paths case-folded
+(`src/Api.ts` = `src/api.ts`). Slices colliding on either run serially; the rest
+stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. **Failing
+case:** two slices each add a dependency, run in parallel, and integrate fails or
+lands a broken lockfile.
+
 ## Control vs workers
 
 Control owns `.devrites/work/<slug>/` (lease + bookkeeping).

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

@@ -95,7 +95,11 @@ not normal cleanup.
 1. Compare the returned file list and `git diff --name-only` with task paths.
    `devrites-engine check diff-scope <slug> --allow <task-paths>` is the
    mechanical subset gate — run it before any reviewer dispatch; a violation
-   restores through the bounded wright without spending review.
+   restores through the bounded wright without spending review, but only for a
+   path the wright's `files_changed` or diff trace attributes to it. An
+   unattributed extra path that was clean at the step-3 baseline is preserved
+   (never restored), recorded as drift, and stops for the human. **Failing case:**
+   a user edits `README.md` during a same-tree dispatch and the wright reverts it.
    Reject a result that omits any required key — the bookkeeping arrays count
    whether empty or filled — or adds a path. Root never widens scope or edits
    source.