devrites 6.7.3 → 6.8.0

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.8.0](https://github.com/ViktorsBaikers/DevRites/compare/v6.7.4...v6.8.0) (2026-10-18)
+
+### Added
+
+* **devrites:** reuse unchanged gates and refuse voided review waves ([#129](https://github.com/ViktorsBaikers/DevRites/issues/129)) ([51349fe](https://github.com/ViktorsBaikers/DevRites/commit/51349fe0ce8f96ad890461c0e796bf3184e49079))
+
+## [6.7.4](https://github.com/ViktorsBaikers/DevRites/compare/v6.7.3...v6.7.4) (2026-10-17)
+
+### Fixed
+
+* **devrites:** a host reminder is not a turn end ([#128](https://github.com/ViktorsBaikers/DevRites/issues/128)) ([45f4922](https://github.com/ViktorsBaikers/DevRites/commit/45f492269f568449572f27d355641d181d6dd21c))
+
 ## [6.7.3](https://github.com/ViktorsBaikers/DevRites/compare/v6.7.2...v6.7.3) (2026-10-17)
 
 ### Fixed

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.7.3`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.7.3): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v6.8.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.8.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/engine/commands.md

@@ -11,7 +11,7 @@ workflow strategy.
 | `install [flags]` | Install manifest-owned host artifacts and the optional shared binary. |
 | `update [flags]` | Refresh an existing managed installation. |
 | `uninstall [flags]` | Remove managed artifacts while preserving runtime workspace state. |
-| `check candidate <slug>` | Validate the strict manifest and compute the content-bound project-candidate identity. |
+| `check candidate <slug>` | Validate the strict manifest and compute the content-bound project-candidate identity. Exits `3` when the manifest omits a path the feature's `WIP(<slug>):` checkpoint commits changed (net from the feature base to HEAD). |
 | `check readiness <slug>` | Check target-Phase files, open human gates from Clarify onward, the `tasks.md` slice graph when that artifact is required, canonical `AC-###` presence in `tasks.md`/`test-plan.md` when those artifacts are required, and the current stable Build-input binding when applicable. |
 | `check readiness --emit-binding <slug>` | Render the exact stable Build-input binding for Vet to record after review. |
 | `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the `tasks.md` slice graph, canonical `AC-###` presence when `tasks.md`/`test-plan.md` are required, the stable Build-input binding, and exact candidate bindings. |
@@ -34,12 +34,12 @@ workflow strategy.
 | `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, and each artifact over 16 KiB except `spec.md`, 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; a reviewer, auditor, or test-analyst wave needs `--packet <file>` and `open` exits `3` on a packet that seeds a conclusion (gate `*-PASS` token, `no-findings`, an `Outcome:`/`Counts:` line, an "already passed" claim, or zero Critical/Important counts); 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. |
+| `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; a reviewer, auditor, or test-analyst wave needs `--packet <file>` and `open` exits `3` on a packet that seeds a conclusion (gate `*-PASS` token, `no-findings`, an `Outcome:`/`Counts:` line, an "already passed" claim, or zero Critical/Important counts); a Review or Seal reviewer wave also exits `3` unless the packet names an existing non-empty `.diff`/`.patch` file and the manifest covers every checkpointed path; 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. |
 | `metrics summary [slug] [--by-slice]` | Reduce `metrics.jsonl` into a per-phase roll-up. `--by-slice` reads `dispatch.json` instead: per slice, build wright rounds, slice-bound Vet rechecks, and agent-minutes (role start to `returned_at`; abandoned waves excluded). |
 | `claim <add\|release\|list\|check>` | Advisory session-scoped file claims in `.devrites/claims.jsonl` (append-only). `add` records intent to write a path set with a TTL (1–240 min, default 30); a live claim by another session exits `3` and names the holder. `release` appends a release event owned by the claiming session. `list` shows live claims (`--all` includes expired/released); a claim whose holding session has provably exited on this host shows `dead` and no longer conflicts. `check` is the read-only preflight for a path set. Coordination aid only — never a substitute for one-writer-per-worktree. |
 | `note <add\|list\|check\|rm> <slug> ...` | Anchored workspace notes in `notes.md`: `add <slug> <subject> <quote> <title> [body]` binds a note to a verbatim quote in one repository file and assigns `NOTE-###`; `list` and `check` regrade each anchor `exact`/`moved`/`stale`/`ambiguous`/`lost` by searching the repo for the quote (dependency and workspace trees excluded); `check --repair` rewrites a `moved` subject to its new file; `rm` deletes by ID. `check seal` refuses a malformed `notes.md` and any non-`exact` anchor. |
-| `gates <scaffold\|status\|run\|reverify\|lint\|attest\|abandon> <slug>` | Operate the `gates.md` acceptance ledger: seed per-AC gates, execute runnable gates bound to `test-plan.md` preflight rows, attest manual gates, and reduce to `all-met`/`not-met`/`handoff`/`malformed`. |
+| `gates <scaffold\|status\|run\|reverify\|lint\|attest\|abandon> <slug>` | Operate the `gates.md` acceptance ledger: seed per-AC gates, execute runnable gates bound to `test-plan.md` preflight rows, attest manual gates, and reduce to `all-met`/`not-met`/`handoff`/`malformed`. A gate with `INPUTS:` records its files' content digest and is reused by `run` and `reverify` while they are unchanged. |
 | `state resolve <qid> "<answer>"` | Resolve an open question and update `questions.md` plus `state.md` atomically. |
 | `state merge-manifest <slug> [pred...]` | Fold the recorded predecessor chain's manifests into the release candidate manifest. |
 | `state close <slug>` | Archive a shipped workspace and clear matching `ACTIVE`. |

package/engine/internal/acceptance/evidence.go

@@ -25,14 +25,19 @@ const (
 // manual gate keeps human attestation.
 const EvidenceMarker = "automatic-evidence=v1"
 
-var automaticEvidenceRE = regexp.MustCompile(`^automatic-evidence=v1; def=([0-9a-f]{64}); exit=0; expect=matched; output-sha256=([0-9a-f]{64}); output-bytes=([0-9]+); at=(\S+)$`)
+var automaticEvidenceRE = regexp.MustCompile(`^automatic-evidence=v1; def=([0-9a-f]{64}); exit=0; expect=matched; output-sha256=([0-9a-f]{64}); output-bytes=([0-9]+)(?:; inputs=([0-9a-f]{64}))?; at=(\S+)$`)
 
 // DefinitionDigest is the environment-independent SHA-256 binding of the
-// parsed CHECK, EXPECT, and raw CWD fields. Editing any bound input renders
-// previously recorded evidence stale. The digest is unkeyed drift detection,
-// not tamper proof: a ledger editor can write a syntactically valid line.
+// parsed CHECK, EXPECT, raw CWD and (when declared) INPUTS fields. Editing any
+// bound input renders previously recorded evidence stale. The digest is unkeyed
+// drift detection, not tamper proof: a ledger editor can write a syntactically
+// valid line.
 func DefinitionDigest(gate *Gate) string {
-	sum := sha256.Sum256([]byte("v1\x00" + gate.Check + "\x00" + gate.Expect + "\x00" + gate.Cwd))
+	definition := "v1\x00" + gate.Check + "\x00" + gate.Expect + "\x00" + gate.Cwd
+	if gate.Inputs != "" {
+		definition += "\x00inputs\x00" + gate.Inputs
+	}
+	sum := sha256.Sum256([]byte(definition))
 	return hex.EncodeToString(sum[:])
 }
 
@@ -42,6 +47,24 @@ func FormatEvidence(gate *Gate, outputDigest string, outputBytes int, at string)
 		EvidenceMarker, DefinitionDigest(gate), outputDigest, outputBytes, at)
 }
 
+// withInputs adds the INPUTS content digest to an evidence payload, so a later
+// run can tell whether the files the result depends on are unchanged.
+func withInputs(evidence, inputsDigest string) string {
+	if inputsDigest == "" {
+		return evidence
+	}
+	at := strings.LastIndex(evidence, "; at=")
+	return evidence[:at] + "; inputs=" + inputsDigest + evidence[at:]
+}
+
+// recordedInputs is the INPUTS digest a gate's automatic evidence carries, or "".
+func recordedInputs(gate *Gate) string {
+	if match := automaticEvidenceRE.FindStringSubmatch(strings.TrimSpace(gate.Evidence)); match != nil {
+		return match[4]
+	}
+	return ""
+}
+
 // OutputDigest is the recorded fingerprint of the canonical successful output
 // string. Raw output is never persisted.
 func OutputDigest(output string) string {

package/engine/internal/acceptance/inputs.go

@@ -0,0 +1,93 @@
+package acceptance
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// maxInputFiles bounds one INPUTS expansion so a broad glob cannot turn a
+// gate's reuse check into a repository-wide hash.
+const maxInputFiles = 20000
+
+// InputsDigest hashes every regular file an INPUTS spec names under project:
+// whitespace-separated project-relative paths, directories (walked
+// recursively, .git skipped) or globs. Each pattern must match at least one
+// file, so a typo fails closed (the gate re-executes) instead of hashing
+// nothing. The digest binds each sorted relative path to its content.
+func InputsDigest(project, spec string) (string, error) {
+	files := map[string]bool{}
+	for _, pattern := range strings.Fields(spec) {
+		clean := path.Clean(pattern)
+		if path.IsAbs(clean) || clean == ".." || strings.HasPrefix(clean, "../") || strings.Contains(pattern, `\`) {
+			return "", fmt.Errorf("INPUTS %q must be a project-relative slash path", pattern)
+		}
+		matches, err := filepath.Glob(filepath.Join(project, filepath.FromSlash(clean)))
+		if err != nil {
+			return "", fmt.Errorf("INPUTS %q: %w", pattern, err)
+		}
+		before := len(files)
+		for _, match := range matches {
+			if err := addInputFiles(project, match, files); err != nil {
+				return "", err
+			}
+		}
+		if len(files) == before {
+			return "", fmt.Errorf("INPUTS %q matches no file", pattern)
+		}
+		if len(files) > maxInputFiles {
+			return "", fmt.Errorf("INPUTS names more than %d files", maxInputFiles)
+		}
+	}
+	names := make([]string, 0, len(files))
+	for name := range files {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	digest := sha256.New()
+	for _, name := range names {
+		file, err := os.Open(filepath.Join(project, filepath.FromSlash(name))) // #nosec G304 -- path enumerated under the project root
+		if err != nil {
+			return "", err
+		}
+		content := sha256.New()
+		_, err = io.Copy(content, file)
+		_ = file.Close()
+		if err != nil {
+			return "", err
+		}
+		fmt.Fprintf(digest, "%d:%s\x00%x\n", len(name), name, content.Sum(nil))
+	}
+	return hex.EncodeToString(digest.Sum(nil)), nil
+}
+
+func addInputFiles(project, start string, files map[string]bool) error {
+	return filepath.WalkDir(start, func(name string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			if entry.Name() == ".git" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if !entry.Type().IsRegular() {
+			return nil
+		}
+		rel, err := filepath.Rel(project, name)
+		if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+			return errors.New("INPUTS path escapes the project")
+		}
+		files[filepath.ToSlash(rel)] = true
+		return nil
+	})
+}

package/engine/internal/acceptance/ledger.go

@@ -30,6 +30,7 @@ type Gate struct {
 	Check    string
 	Expect   string
 	Cwd      string
+	Inputs   string // optional whitespace-separated paths/globs the result depends on
 	Evidence string
 	Line     int // 1-based line of the "- [ ]" row in the original text
 }
@@ -46,8 +47,8 @@ type Document struct {
 
 var (
 	gateLineRE      = regexp.MustCompile(`^\s*- \[([ xX])\] ([^\s:]+): (.*)$`)
-	attrLineRE      = regexp.MustCompile(`^(\s+)(CHECK|EXPECT|CWD|EVIDENCE):(.*)$`)
-	unindentedAttr  = regexp.MustCompile(`^(CHECK|EXPECT|CWD|EVIDENCE):`)
+	attrLineRE      = regexp.MustCompile(`^(\s+)(CHECK|EXPECT|CWD|INPUTS|EVIDENCE):(.*)$`)
+	unindentedAttr  = regexp.MustCompile(`^(CHECK|EXPECT|CWD|INPUTS|EVIDENCE):`)
 	abandonLineRE   = regexp.MustCompile(`^ABANDON: (\S+)\s*(.*)$`)
 	indentedAbandon = regexp.MustCompile(`^\s+ABANDON:`)
 	expectSlashRE   = regexp.MustCompile(`^/(.*)/([ims]*)$`)
@@ -114,6 +115,8 @@ func ParseLedger(text string) *Document {
 				current.Expect = value
 			case "CWD":
 				current.Cwd = value
+			case "INPUTS":
+				current.Inputs = value
 			case "EVIDENCE":
 				current.Evidence = value
 			}

package/engine/internal/acceptance/run.go

@@ -87,9 +87,22 @@ func RunGates(ctx context.Context, root, ledgerPath string, doc *Document, appro
 			results = append(results, GateResult{ID: gate.ID, Detail: "manual gate; evidence is judged, not executed"})
 			continue
 		}
-		if GateState(gate, doc) == StateMet && !reverify {
-			results = append(results, GateResult{ID: gate.ID, Passed: true, Detail: "already met"})
-			continue
+		inputs := ""
+		if gate.Inputs != "" {
+			// An unreadable or unmatched spec yields "", which never matches, so the gate re-executes.
+			inputs, _ = InputsDigest(root, gate.Inputs)
+		}
+		if GateState(gate, doc) == StateMet {
+			if gate.Inputs == "" && !reverify {
+				results = append(results, GateResult{ID: gate.ID, Passed: true, Detail: "already met"})
+				continue
+			}
+			// A gate that declares INPUTS is reused, under run and reverify alike,
+			// exactly while the files it depends on are byte-identical; any change re-executes it.
+			if inputs != "" && inputs == recordedInputs(gate) {
+				results = append(results, GateResult{ID: gate.ID, Passed: true, Detail: "reused: inputs unchanged"})
+				continue
+			}
 		}
 		if !Approved(gate.Check, gate.Cwd, approved) {
 			results = append(results, GateResult{ID: gate.ID, Detail: "CHECK/CWD is not an approved test-plan.md preflight row; not executed"})
@@ -111,7 +124,7 @@ func RunGates(ctx context.Context, root, ledgerPath string, doc *Document, appro
 			outcomes[key] = outcome
 		}
 		if outcome.Err == nil && outcome.ExitCode == 0 && expectation.Matches(outcome.Output) {
-			evidence := FormatEvidence(gate, OutputDigest(outcome.Output), outcome.OutputBytes, time.Now().UTC().Format(time.RFC3339))
+			evidence := withInputs(FormatEvidence(gate, OutputDigest(outcome.Output), outcome.OutputBytes, time.Now().UTC().Format(time.RFC3339)), inputs)
 			writeErr := write(gate, evidence, true)
 			results = append(results, GateResult{
 				ID: gate.ID, Ran: true, Passed: true,
@@ -170,7 +183,7 @@ func writeResult(ledgerPath string, ran *Gate, evidence string, checked bool) er
 	if current == nil {
 		return fmt.Errorf("%w: gate %s disappeared", ErrOracleMoved, ran.ID)
 	}
-	if current.Check != ran.Check || current.Expect != ran.Expect || current.Cwd != ran.Cwd {
+	if current.Check != ran.Check || current.Expect != ran.Expect || current.Cwd != ran.Cwd || current.Inputs != ran.Inputs {
 		return fmt.Errorf("%w: gate %s definition edited", ErrOracleMoved, ran.ID)
 	}
 

package/engine/internal/lib/candidate_coverage.go

@@ -0,0 +1,147 @@
+package lib
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+)
+
+// CandidateOmissions lists the project paths the feature's own
+// `WIP(<slug>):` checkpoint commits changed (net, feature base to HEAD) that
+// touched-files.md lists neither present nor deleted. The base is the parent
+// of the oldest such commit, or the empty tree for a root commit. A project
+// outside Git, or with no checkpoint yet, has nothing to compare.
+func CandidateOmissions(root, slug string) ([]string, error) {
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return nil, err
+	}
+	raw, err := readBoundedRegularFile(filepath.Join(workspace, "touched-files.md"), maxCandidateManifestBytes)
+	if err != nil {
+		return nil, fmt.Errorf("candidate manifest: %w", err)
+	}
+	rows, err := parseCandidateManifest(raw)
+	if err != nil {
+		return nil, fmt.Errorf("candidate manifest: %w", err)
+	}
+	project := projectDir(root)
+	if _, err := runGitCommand(project, nil, "rev-parse", "--verify", "--quiet", "HEAD"); err != nil {
+		return nil, nil
+	}
+	log, err := runGitCommand(project, nil, "log", "--fixed-strings", "--grep=WIP("+slug+"):", "--format=%H%x1f%P%x1f%s", "HEAD")
+	if err != nil {
+		return nil, err
+	}
+	var commits []string
+	base := ""
+	for _, line := range strings.Split(strings.TrimSpace(string(log)), "\n") {
+		fields := strings.SplitN(line, "\x1f", 3)
+		if len(fields) != 3 || !strings.HasPrefix(fields[2], "WIP("+slug+"):") {
+			continue
+		}
+		commits = append(commits, fields[0])
+		base = "" // log lists newest first, so the oldest commit's parent wins
+		if parents := strings.Fields(fields[1]); len(parents) > 0 {
+			base = parents[0]
+		}
+	}
+	if len(commits) == 0 {
+		return nil, nil
+	}
+	if base == "" {
+		tree, err := runGitCommandIO(project, nil, []byte{}, nil, "hash-object", "-t", "tree", "--stdin")
+		if err != nil {
+			return nil, err
+		}
+		base = strings.TrimSpace(string(tree))
+	}
+	touched := map[string]bool{}
+	for _, commit := range commits {
+		names, err := runGitCommand(project, nil, "diff-tree", "-r", "--root", "--no-commit-id", "--name-only", "--no-renames", "--relative", "-z", commit)
+		if err != nil {
+			return nil, err
+		}
+		for _, name := range strings.Split(string(names), "\x00") {
+			if name != "" {
+				touched[name] = true
+			}
+		}
+	}
+	net, err := runGitCommand(project, nil, "diff", "--name-only", "--no-renames", "--relative", "-z", base, "HEAD")
+	if err != nil {
+		return nil, err
+	}
+	listed := make(map[string]bool, len(rows))
+	for _, row := range rows {
+		listed[row.path] = true
+	}
+	var omitted []string
+	for _, name := range strings.Split(string(net), "\x00") {
+		if name != "" && touched[name] && !listed[name] && !forbiddenCandidateStatePath(name) {
+			omitted = append(omitted, name)
+		}
+	}
+	sort.Strings(omitted)
+	return omitted, nil
+}
+
+// CheckCandidateCoverage fails when touched-files.md omits a path the
+// feature's checkpoints changed.
+func CheckCandidateCoverage(root, slug string) error {
+	omitted, err := CandidateOmissions(root, slug)
+	if err != nil {
+		return err
+	}
+	if len(omitted) > 0 {
+		return omissionError(omitted)
+	}
+	return nil
+}
+
+// omissionError renders a bounded BLOCKED reason for omitted candidate paths.
+func omissionError(omitted []string) error {
+	shown := omitted
+	if len(shown) > 10 {
+		shown = shown[:10]
+	}
+	more := ""
+	if len(omitted) > len(shown) {
+		more = ", …"
+	}
+	return fmt.Errorf("candidate manifest omits %d path(s) the feature's WIP checkpoints changed: %s%s; add each to touched-files.md (present or deleted) before freezing the candidate",
+		len(omitted), strings.Join(shown, ", "), more)
+}
+
+var diffPathRE = regexp.MustCompile(`[A-Za-z0-9_./@+-]+\.(?:diff|patch)\b`)
+
+// lintReviewCandidate gates a Review or Seal reviewer wave: the candidate
+// manifest must cover every path the feature's checkpoints changed, and the
+// packet must name the frozen candidate diff the reviewers judge. A digest
+// alone, or a manifest that drops changed files, voids every reviewer at once.
+func lintReviewCandidate(root, slug, packet string) error {
+	if err := CheckCandidateCoverage(root, slug); err != nil {
+		return err
+	}
+	raw, err := readBoundedRegularFile(packet, maxContractBytes)
+	if err != nil {
+		return fmt.Errorf("reviewer packet %s: %w", packet, err)
+	}
+	for _, name := range diffPathRE.FindAllString(string(raw), -1) {
+		for _, dir := range []string{projectDir(root), featureDir(root, slug), ""} {
+			candidate := name
+			if dir != "" {
+				candidate = filepath.Join(dir, filepath.FromSlash(name))
+			}
+			if info, err := os.Stat(candidate); err == nil && info.Mode().IsRegular() && info.Size() > 0 {
+				return nil
+			}
+		}
+	}
+	return errors.New("a Review or Seal reviewer packet must name the frozen candidate diff (an existing non-empty .diff or .patch file); reviewers cannot judge a digest alone")
+}

package/engine/internal/lib/dispatch.go

@@ -223,6 +223,11 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 				if err := lintReviewerPacket(packet); err != nil {
 					return fail("BLOCKED: %v", err)
 				}
+				if strings.EqualFold(phase, "review") || strings.EqualFold(phase, "seal") {
+					if err := lintReviewCandidate(root, slug, packet); err != nil {
+						return fail("BLOCKED: %v", err)
+					}
+				}
 				break
 			}
 		}

package/engine/main.go

@@ -225,6 +225,10 @@ func cmdCandidate(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "candidate: BLOCKED: %v\n", err)
 		return exitBlocked
 	}
+	if err := lib.CheckCandidateCoverage(root, args[0]); err != nil {
+		fmt.Fprintf(stderr, "candidate: BLOCKED: %v\n", err)
+		return exitBlocked
+	}
 	fmt.Fprintf(stdout, "candidate-sha256: %s\ncandidate-files: %d\n", digest, files)
 	return exitOK
 }

package/pack/.claude/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/.claude/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

package/pack/.claude/skills/rite-autocomplete/SKILL.md

@@ -63,7 +63,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

package/pack/.claude/skills/rite-review/SKILL.md

@@ -89,7 +89,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](../devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/pack/generated/claude/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/generated/claude/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

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

@@ -65,7 +65,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

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

@@ -89,7 +89,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](../devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/pack/generated/codex/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/generated/codex/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

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

@@ -65,7 +65,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

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

@@ -89,7 +89,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](../devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/pack/generated/devin/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/generated/devin/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

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

@@ -64,7 +64,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

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

@@ -88,7 +88,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](../devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/pack/generated/omp/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/generated/omp/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

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

@@ -65,7 +65,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

package/pack/generated/omp/skills/rite-review/SKILL.md

@@ -89,7 +89,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](skill://devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/pack/generated/pi/skills/devrites-lib/reference/parallel-dispatch.md

@@ -50,7 +50,8 @@ If the candidate diff has no matching surfaces, record
    (`devrites-engine dispatch <slug> open --phase <p> --wave <w> --role <r>...`;
    a reviewer, auditor, or test-analyst wave adds `--packet <file>`, the exact packet
    those agents receive, and `open` refuses one that seeds a gate result, outcome,
-   count, or "already passed" claim), launch every native agent nonblocking, record each returned host handle
+   count, or "already passed" claim; at Review and Seal it also needs the packet to
+   name the frozen candidate diff and the manifest to cover every checkpointed path), launch every native agent nonblocking, record each returned host handle
    (`dispatch ... start --wave <w> --role <r> --handle <id>`), then `seal` —
    seal fails until every declared role has a distinct handle, which makes a
    serial launch-then-wait pattern impossible to record. Record each completion

package/pack/generated/pi/skills/devrites-lib/reference/standards/gates.md

@@ -19,6 +19,7 @@ every later phase requires its presence; proof phases require every gate met.
   CHECK: <exact command from test-plan.md Build-entry preflight>
   EXPECT: <substring | /regex/flags>
   CWD: <repository-relative path; omit for repo root>
+  INPUTS: <optional project-relative paths, directories or globs>
   EVIDENCE: pending
 
 - [x] AC-002: <human-judged outcome>
@@ -33,6 +34,10 @@ ABANDON: AC-003 <why the outcome can never be met>
 - Attributes are indented beneath their gate. Fenced code examples never parse.
 - `EXPECT` is a substring, or `/pattern/flags` with `i`, `m`, `s` flags.
 - `CWD` is repository-relative; absolute paths and `..` segments are rejected.
+- `INPUTS` (optional) lists every file the gate's result depends on: sources,
+  tests, fixtures, build and lock files, and the gate's own scripts. Each pattern
+  must match a file. A gate whose verdict depends on state that no file
+  captures (network, wall clock, live host load) takes no `INPUTS`.
 - `ABANDON:` starts at column 1, names a known gate, and requires a reason.
   An abandoned gate blocks completion and demands a handoff — it can never
   read as a pass.
@@ -53,8 +58,8 @@ directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Output is captured but never persisted — only its digest.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
-loosening EXPECT, changing CHECK or CWD, or removing a row is Plan repair plus
-re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
+loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
+a row is Plan repair plus re-Vet, never a Prove or Seal edit. A runnable gate that cannot execute stays unmet
 with `unavailable: <reason>`. Prove attests only gates that were manual at Vet,
 checked by diffing `gates.md` against the Vet record. **Failing case:** AC-003's
 runnable gate fails at Prove, the root deletes CHECK/EXPECT and attests "verified
@@ -63,9 +68,13 @@ manually", and `gates status` reads `all-met`.
 ## Evidence binding
 
 A successful run writes `EVIDENCE: automatic-evidence=v1; def=<sha256>; …`
-where `def` binds the exact CHECK/EXPECT/CWD the run executed. Editing any of
-the three renders prior evidence `stale-unmet` — a stale pass cannot hide
-behind an edited oracle. Prose evidence on a runnable gate is also stale:
+where `def` binds the exact CHECK/EXPECT/CWD (and INPUTS, when declared) the run
+executed. Editing any of them renders prior evidence `stale-unmet` — a stale pass
+cannot hide behind an edited oracle. A gate with `INPUTS` also records
+`inputs=<sha256>` of those files' content. `gates run` and `gates reverify`
+both reuse such a gate while the files are byte-identical, and re-execute it
+when any of them changes. A gate without `INPUTS` keeps the plain rule:
+`run` skips it once met, and `reverify` re-executes it. Prose evidence on a runnable gate is also stale:
 only automatic evidence bound to the current definition counts.
 
 Manual gates are met when checked with non-placeholder human evidence;
@@ -85,8 +94,8 @@ self-attests.
 ```text
 devrites-engine gates scaffold <slug>     create gates.md from spec.md AC ids
 devrites-engine gates status <slug>       reduce without executing; all-met/handoff/not-met/malformed
-devrites-engine gates run <slug>          execute unmet runnable gates, write bound evidence
-devrites-engine gates reverify <slug>     re-execute every runnable gate; demote stale passes
+devrites-engine gates run <slug>          execute unmet runnable gates (and INPUTS gates whose files changed)
+devrites-engine gates reverify <slug>     re-execute every runnable gate except INPUTS gates with unchanged files
 devrites-engine gates lint <slug>         audit oracle quality without executing
 devrites-engine gates attest <slug> <id> <note>   record human evidence on a manual gate
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff

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

@@ -65,7 +65,9 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Never end the turn with a progress note while a wave runs or a next step
   exists: on a headless host a text-only reply ends the session and kills
   running children. Wait with the host's wait tool and keep working; end only
-  at a recorded stop.
+  at a recorded stop. A host reminder or rule notice (style rule, advisory) is
+  not a stop either: follow it in your next tool call, never in a text-only
+  acknowledgement.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.

package/pack/generated/pi/skills/rite-review/SKILL.md

@@ -89,7 +89,12 @@ Pull these via `Read` when the diff demands them:
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
    Separate contexts prevent one axis from masking the other. This is the initial
    full pass; a correction uses step 7's bounded recheck:
-   - Freeze that closed digest and give the same digest to the **two** axis reviewers (three when
+   - Freeze that closed digest: write the candidate diff (feature base to HEAD, plus any
+     uncommitted candidate change) to `packets/<wave>.diff` and name that file in the
+     packet. `dispatch open` refuses a Review or Seal reviewer wave whose packet names
+     no existing diff, or whose manifest omits a path the feature's `WIP(<slug>):`
+     checkpoints changed.
+     Give the same digest and diff to the **two** axis reviewers (three when
      [engineering lanes](../devrites-lib/reference/parallel-dispatch.md) split the code axis) in
      parallel, each with its own narrow brief and no
      cross-pollination — and evaluate the frontend (step 4), security (step 5),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "6.7.3",
+  "version": "6.8.0",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code, Codex, omp, pi, and Devin CLI",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",