devrites 6.1.5 → 6.2.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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.2.0](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.5...v6.2.0) (2026-10-16)
+
+### Added
+
+* **devrites:** lint wright contracts at dispatch open ([#112](https://github.com/ViktorsBaikers/DevRites/issues/112)) ([391a931](https://github.com/ViktorsBaikers/DevRites/commit/391a9317dba9f00941ed29c48cc1f3f2ae8551c4))
+
 ## [6.1.5](https://github.com/ViktorsBaikers/DevRites/compare/v6.1.4...v6.1.5) (2026-10-16)
 
 ### 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.1.5`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.1.5): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v6.2.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v6.2.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/engine/help.go

@@ -58,7 +58,7 @@ const (
   metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]
   metrics summary [slug] [--by-slice]
 `
-	dispatchUsage  = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>]`
+	dispatchUsage  = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>]`
 	claimUsageText = `usage: devrites-engine claim <add|release|list|check> ...
 
   claim add --session <id> [--ttl <minutes>] [--reason <s>] <path>...

package/engine/internal/lib/dispatch.go

@@ -21,9 +21,9 @@ import (
 // fan-out cannot silently degrade to serial (open -> every role started ->
 // seal -> returns -> complete). start/return also auto-record metrics events.
 //
-//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>]
+//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>]
 
-const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>]
+const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>]
 
 Wave barrier for parallel agent dispatch: seal fails until every declared
 role has a distinct handle; return fails before seal. status --wave exits
@@ -117,7 +117,7 @@ func nowStamp() string { return time.Now().UTC().Format(time.RFC3339) }
 
 // RunDispatch implements the dispatch wave state machine.
 func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
-	var slug, sub, phase, wave, role, handle, reason, review string
+	var slug, sub, phase, wave, role, handle, reason, review, contract string
 	var roles, sliceIDs []string
 	var positional []string
 	for i := 0; i < len(args); i++ {
@@ -138,6 +138,8 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			sliceIDs = append(sliceIDs, value)
 		case "--reslice-review":
 			review = value
+		case "--contract":
+			contract = value
 		default:
 			if strings.HasPrefix(args[i], "-") {
 				fmt.Fprintf(stderr, "dispatch: unknown flag %q\n", args[i])
@@ -161,7 +163,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	// an update and strand the wave short of complete.
 	code := 0
 	if err := state.WithFeatureLock(root, slug, func() error {
-		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, stdout, stderr)
+		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, contract, stdout, stderr)
 		return nil
 	}); err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -170,7 +172,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	return code
 }
 
-func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review string, stdout, stderr io.Writer) int {
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review, contract string, stdout, stderr io.Writer) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -209,6 +211,11 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if code != 0 {
 			return code
 		}
+		if isBuildWrightWave(w) {
+			if err := lintWrightContract(contract); err != nil {
+				return fail("BLOCKED: %v", err)
+			}
+		}
 		f.Waves[wave] = w
 		if err := saveDispatch(path, f); err != nil {
 			return fail("%v", err)

package/engine/internal/lib/dispatch_contract.go

@@ -0,0 +1,51 @@
+package lib
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// maxContractBytes bounds a wright contract read; packets stay <= 64 KiB.
+const maxContractBytes = 64 << 10
+
+var (
+	// writerSafeLineRE is the contract line that names the checks the wright
+	// itself runs before returning.
+	writerSafeLineRE = regexp.MustCompile(`(?im)^[\s>*#-]*writer-safe checks\s*:\s*\S`)
+	// forbidExecutionRE catches contract text that leaves the wright blind:
+	// "skip tests", "no tests/build", "do not run any checks", "run nothing".
+	forbidExecutionRE = regexp.MustCompile(`(?i)\bskip(?:s|ping)?\s+(?:all\s+|the\s+)?(?:builds?|lint|tests?|testing|checks?|formatters?)\b` +
+		`|\bno\s+(?:leaf\s+)?(?:tests?|test\s+commands?|builds?|lint|execution|checks?)\b` +
+		`|\b(?:do\s+not|don't|never)\s+run\s+(?:any\s+)?(?:tests?|checks?|builds?|lint|commands?)\b` +
+		`|\brun\s+nothing\b`)
+	// allowedAfterRE marks a forbid match that is about not weakening tests,
+	// not about skipping their execution ("no tests weakened or deleted").
+	allowedAfterRE = regexp.MustCompile(`(?i)^[\s/,a-z-]{0,24}\b(?:weaken|delet|remov|disabl|skipp|xfail|loosen)`)
+)
+
+// lintWrightContract refuses a build wright contract that forbids the wright's
+// own writer-safe verification or names none, so a blind round is rejected
+// before launch rather than discovered after the wright returns.
+func lintWrightContract(path string) error {
+	if path == "" {
+		return fmt.Errorf("a build wright wave needs --contract <file> holding the exact wright contract (with a `Writer-safe checks:` line)")
+	}
+	raw, err := readBoundedRegularFile(path, maxContractBytes)
+	if err != nil {
+		return fmt.Errorf("wright contract %s: %w", path, err)
+	}
+	for i, line := range strings.Split(string(raw), "\n") {
+		for _, loc := range forbidExecutionRE.FindAllStringIndex(line, -1) {
+			if allowedAfterRE.MatchString(line[loc[1]:]) {
+				continue
+			}
+			return fmt.Errorf("wright contract %s:%d forbids writer-safe execution (%q); the wright runs syntax/type/lint, unit and self-check suites and a narrow local smoke itself — list them under `Writer-safe checks:` and keep only artifact-producing, consumptive, or full canonical gates root-owned",
+				path, i+1, strings.TrimSpace(line[loc[0]:loc[1]]))
+		}
+	}
+	if !writerSafeLineRE.Match(raw) {
+		return fmt.Errorf("wright contract %s names no `Writer-safe checks:` line; list the syntax/type/lint, unit/self-check and narrow smoke commands the wright runs before returning", path)
+	}
+	return nil
+}

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

@@ -29,8 +29,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/.claude/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](../../devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](../../devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

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

@@ -29,8 +29,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/generated/claude/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](../../devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](../../devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

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

@@ -29,8 +29,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/generated/codex/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](../../devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](../../devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

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

@@ -28,8 +28,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/generated/devin/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](../../devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](../../devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

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

@@ -29,8 +29,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/generated/omp/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](skill://devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](skill://devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

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

@@ -29,8 +29,8 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md)
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 Every wright contract names the writer-safe checks the wright runs (syntax/type/lint,
 unit and self-check suites, a narrow local smoke) and never forbids them; only
-artifact-producing, consumptive, or full canonical gates stay root-owned.
-Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
+artifact-producing, consumptive, or full canonical gates stay root-owned;
+`dispatch open --contract` refuses a contract that breaks this. Prior contracts in `evidence.md` are not a template for this. **Failing case:** the
 contract says "skip tests mid-flight; root runs them after return", and the wright
 returns three unit failures that a 20 s `go test` would have caught in-round.
 

package/pack/generated/pi/skills/rite-build/reference/one-slice-cycle.md

@@ -23,7 +23,9 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root, concurrent with the reviews on the same frozen candidate:
             required build/browser/E2E (narrow self-check/smoke first, full gate only
-            after it is green, long runs in the background), then returned-diff/path recheck; fail-on-red
+            after it is green, long runs in the background; cancel one still running once
+            review or proof sends the candidate back, keeping its partial output as
+            diagnostics), then returned-diff/path recheck; fail-on-red
             (red/gap → repair wright, then re-review and re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff

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

@@ -94,10 +94,14 @@ claim add --session <id> <task-paths>`; retain its returned `<claim-id>`, then r
 live foreign session releases the retained claim and stops the dispatch, per
 [`agents.md`](../../devrites-lib/reference/standards/agents.md). `.devrites/**`
 is never a task path; see [Workflow Artifact admission](../../devrites-lib/reference/standards/workflow-artifacts.md).
-Ask the host
-for the exact writer in fresh context and wait. Track it through the
-launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
-<slice-id> --role slice-wright --slice <SLICE-ID>`, then `start` with the host handle, `seal`, and
+Write the exact contract, with its `Writer-safe checks:` line, to
+`packets/<wave>.contract.md` and hand the wright that text verbatim. Ask the host
+for the exact writer in fresh context; a repair round on the same slice whose
+returned wright the host can still continue goes to that wright on its existing
+handle instead, so it does not re-read the slice from scratch. Wait, and track it
+through the launch barrier — `devrites-engine dispatch <slug> open --phase build --wave
+<slice-id> --role slice-wright --slice <SLICE-ID> --contract <file>` (it refuses a
+contract that forbids writer-safe checks or names none), then `start` with the host handle, `seal`, and
 `return` on completion (auto-records dispatch/return metrics). Every 5 wright
 rounds on one slice, `open` blocks for a reslice review: propose an
 acceptance-preserving split (`root_no_change_analysis` → `FOLD` per

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "6.1.5",
+  "version": "6.2.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",