devrites 6.0.2 → 6.0.4

package/engine/internal/lib/metrics.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -23,7 +24,7 @@ const MetricsFile = "metrics.jsonl"
 const metricsUsage = `usage: devrites-engine metrics <record|summary> ...
 
   metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]
-  metrics summary [slug]
+  metrics summary [slug] [--by-slice]
 `
 
 type metricEvent struct {
@@ -150,6 +151,8 @@ func recordMetric(root, slug, phase, event, role string, bytes int64) {
 }
 
 func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
+	bySlice := slices.Contains(args, "--by-slice")
+	args = slices.DeleteFunc(slices.Clone(args), func(a string) bool { return a == "--by-slice" })
 	slug, code, err := ActiveSlug(root, args)
 	if err != nil {
 		fmt.Fprintf(stderr, "metrics: %v\n", err)
@@ -163,6 +166,9 @@ func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "metrics: %v\n", err)
 		return 2
 	}
+	if bySlice {
+		return sliceCostSummary(root, slug, stdout, stderr)
+	}
 	f, err := os.Open(filepath.Join(dir, MetricsFile)) // #nosec G304 -- dir is a validated workspace and filename is fixed
 	if err != nil {
 		fmt.Fprintf(stdout, "metrics: no events recorded for %s\n", slug)
@@ -258,3 +264,70 @@ func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 	fmt.Fprintln(stdout)
 	return 0
 }
+
+// sliceCostSummary reports, per slice named on dispatch waves, the build wright
+// rounds, slice-bound Vet rechecks, and agent-minutes (role start to return; a
+// wave naming several slices splits its minutes evenly). Abandoned waves are
+// excluded, and waves recorded before returns were timestamped count rounds only.
+func sliceCostSummary(root, slug string, stdout, stderr io.Writer) int {
+	f, _, err := loadDispatch(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "metrics: %v\n", err)
+		return 2
+	}
+	type cost struct {
+		wright, vet int
+		minutes     float64
+		timed       bool
+	}
+	per := map[string]*cost{}
+	for _, w := range f.Waves {
+		kind := roundKind(w)
+		if kind == "" || w.State == "abandoned" {
+			continue
+		}
+		minutes, timed := 0.0, false
+		for _, r := range w.Roles {
+			start, startErr := time.Parse(time.RFC3339, r.StartedAt)
+			end, endErr := time.Parse(time.RFC3339, r.ReturnedAt)
+			if startErr == nil && endErr == nil && !end.Before(start) {
+				minutes += end.Sub(start).Minutes()
+				timed = true
+			}
+		}
+		for _, id := range w.Slices {
+			c := per[id]
+			if c == nil {
+				c = &cost{}
+				per[id] = c
+			}
+			if kind == "wright" {
+				c.wright++
+			} else {
+				c.vet++
+			}
+			if timed {
+				c.minutes += minutes / float64(len(w.Slices))
+				c.timed = true
+			}
+		}
+	}
+	if len(per) == 0 {
+		fmt.Fprintf(stdout, "metrics: no slice-tagged dispatch waves for %s\n", slug)
+		return 0
+	}
+	ids := make([]string, 0, len(per))
+	for id := range per {
+		ids = append(ids, id)
+	}
+	sort.Strings(ids)
+	for _, id := range ids {
+		c := per[id]
+		minutes := "n/a"
+		if c.timed {
+			minutes = strconv.FormatFloat(c.minutes, 'f', 0, 64)
+		}
+		fmt.Fprintf(stdout, "metrics: %s wright_rounds=%d vet_rechecks=%d agent_minutes=%s\n", id, c.wright, c.vet, minutes)
+	}
+	return 0
+}

package/engine/internal/lib/observe_budgets_test.go

@@ -394,3 +394,35 @@ func TestObserveArtifactBudgetsOversizedArtifactIsOverWithoutFullRead(t *testing
 		t.Fatalf("allocated %d bytes for a %d byte artifact; the read must be bounded", allocated, size)
 	}
 }
+
+func TestUnreturnedWavesWarnAndSurfaceInOrient(t *testing.T) {
+	root, _ := writeBudgetWorkspace(t, map[string]string{
+		"state.md": "| phase | build |\n| schema | 4 |\n",
+		"tasks.md": budgetTasks,
+	})
+	open := func(wave string) string {
+		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+		args := []string{"feature", "open", "--phase", "build", "--wave", wave, "--role", "slice-wright", "--slice", "SLICE-001"}
+		if code := RunDispatch(root, args, stdout, stderr); code != 0 {
+			t.Fatalf("open %s: code=%d\n%s%s", wave, code, stdout, stderr)
+		}
+		return stdout.String()
+	}
+	if out := open("r1"); strings.Contains(out, "WARNING") {
+		t.Fatalf("first wave must not warn:\n%s", out)
+	}
+	if out := open("r2"); !strings.Contains(out, "WARNING: SLICE-001 earlier wave(s) r1 never returned") {
+		t.Fatalf("unreturned earlier wave not warned:\n%s", out)
+	}
+	summary, err := ObserveSummaryFor(root, "feature")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(summary.InflightWaves) != 2 {
+		t.Fatalf("inflight waves=%+v", summary.InflightWaves)
+	}
+	first := summary.InflightWaves[0]
+	if first.Wave != "r1" || first.State != "open" || len(first.Pending) != 1 || first.Pending[0] != "slice-wright" || first.Slices[0] != "SLICE-001" {
+		t.Fatalf("inflight wave=%+v", first)
+	}
+}

package/engine/internal/lib/observe_summary.go

@@ -51,6 +51,7 @@ type ObserveSummary struct {
 	ArtifactBudgets   []ArtifactBudget       `json:"artifact_budgets,omitempty"`
 	BulkFiles         []BulkFile             `json:"bulk_files,omitempty"`
 	Sequence          *ObserveSequenceCursor `json:"sequence,omitempty"`
+	InflightWaves     []InflightWave         `json:"inflight_waves,omitempty"`
 }
 
 // ObserveSummaryFor builds a summary for one feature slug.
@@ -91,6 +92,13 @@ func ObserveSummaryFor(root, slug string) (ObserveSummary, error) {
 			OK:         len(graph.Problems) == 0,
 		}
 	}
+	// Open or sealed waves are agents whose results the root never recorded;
+	// a resume reconciles them before starting new work.
+	if waves, _, err := loadDispatch(root, slug); err == nil {
+		summary.InflightWaves = inflightWaves(waves)
+	} else {
+		summary.Unreadable = append(summary.Unreadable, "dispatch.json")
+	}
 	if report.SequenceParent != "" || report.SequencePosition != "" || report.SequenceWorkspacesRemaining != "" || report.SequenceRole != "" {
 		summary.Sequence = &ObserveSequenceCursor{
 			Parent:              report.SequenceParent,

package/engine/internal/lib/slicecheck.go

@@ -29,6 +29,22 @@ var (
 	windowsDrivePath = regexp.MustCompile(`^[A-Za-z]:[\\/]`)
 )
 
+// sliceFileAdvisory is the Writer allowlist size at which a slice is flagged
+// for an acceptance-preserving split. Advisory only: it never changes an exit
+// code. Measured on real plans, slices at or above it averaged ~10 wright
+// rounds versus ~3.5 below it.
+const sliceFileAdvisory = 12
+
+// sliceSizeAdvisory returns the Writer allowlist size and whether the slice is
+// oversized without a recorded `Size rationale:`.
+func sliceSizeAdvisory(block string) (int, bool) {
+	fields := sliceFields(block)
+	raw, _ := fieldValue(fields, "writer allowlist")
+	n := len(parsePathList(raw))
+	rationale, _ := fieldValue(fields, "size rationale")
+	return n, n >= sliceFileAdvisory && rationale == ""
+}
+
 // sliceFields extracts the single-line `Field: value` pairs of a slice block.
 func sliceFields(block string) map[string]string {
 	fields := map[string]string{}
@@ -169,6 +185,9 @@ func RunCheckSlice(root string, args []string, stdout, stderr io.Writer) int {
 		problems = append(problems, "Tests/proof field missing or empty — no evidence plan for the slice")
 	}
 
+	if n, over := sliceSizeAdvisory(block); over {
+		fmt.Fprintf(stdout, "check slice: ADVISORY size: %s has %d Writer allowlist files (>= %d); consider an acceptance-preserving split\n", sliceID, n, sliceFileAdvisory)
+	}
 	if len(problems) > 0 {
 		fmt.Fprintf(stdout, "check slice: %s BLOCKED\n", sliceID)
 		for _, p := range problems {

package/engine/internal/lib/slicecheck_test.go

@@ -127,3 +127,44 @@ func TestCheckSliceTouchedComparesNormalizedPaths(t *testing.T) {
 		t.Fatalf("code=%d want 0\n%s%s", code, stdout, stderr)
 	}
 }
+
+func bigSliceTasks(rationale string) string {
+	var paths []string
+	for i := 1; i <= sliceFileAdvisory; i++ {
+		paths = append(paths, "`src/f"+strings.Repeat("x", i)+".go`")
+	}
+	return "# Tasks\n\n## SLICE-001 Big\nGoal: do it.\nSatisfies: AC-001\ndepends_on: []\nWriter allowlist: " +
+		strings.Join(paths, ", ") + "\nTests/proof: go test ./...\n" + rationale +
+		"\n## SLICE-002 Small\nGoal: tiny.\nSatisfies: AC-001\ndepends_on: [SLICE-001]\nWriter allowlist: `src/a.go`\nTests/proof: go test ./...\n"
+}
+
+func TestSliceSizeAdvisoryNeverBlocks(t *testing.T) {
+	root := sliceWorkspace(t, bigSliceTasks(""), "## Acceptance criteria\n- AC-001 works\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunCheckSlice(root, []string{"feat", "SLICE-001"}, stdout, stderr); code != 0 {
+		t.Fatalf("advisory must not block: code=%d\n%s%s", code, stdout, stderr)
+	}
+	if !strings.Contains(stdout.String(), "ADVISORY size: SLICE-001 has 12 Writer allowlist files") {
+		t.Fatalf("advisory missing:\n%s", stdout)
+	}
+	stdout.Reset()
+	if code := RunTaskGraphCheck(root, "feat", stdout, stderr); code != 0 {
+		t.Fatalf("task-graph code=%d\n%s%s", code, stdout, stderr)
+	}
+	out := stdout.String()
+	if !strings.Contains(out, "task-graph: ADVISORY size: SLICE-001 has 12") || strings.Contains(out, "SLICE-002 has") {
+		t.Fatalf("task-graph advisory wrong:\n%s", out)
+	}
+	stdout.Reset()
+	if code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr); code != 0 || !strings.Contains(stdout.String(), "size-advisory=1") {
+		t.Fatalf("size-advisory metric not recorded: code=%d\n%s", code, stdout)
+	}
+}
+
+func TestSliceSizeRationaleSilencesAdvisory(t *testing.T) {
+	root := sliceWorkspace(t, bigSliceTasks("Size rationale: one generated golden set moves together\n"), "## Acceptance criteria\n- AC-001 works\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunTaskGraphCheck(root, "feat", stdout, stderr); code != 0 || strings.Contains(stdout.String(), "ADVISORY") {
+		t.Fatalf("rationale must silence advisory: code=%d\n%s", code, stdout)
+	}
+}

package/engine/internal/lib/windows.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -12,17 +13,21 @@ import (
 	"github.com/devrites/devrites/internal/devritespaths"
 )
 
-// windows.go — the broken-windows check. Review prose flags a new TODO, stub, or
-// skipped test as a finding; this gate makes the register countable instead: any
-// deferral marker the change *introduces* must carry a recorded waiver row in the
-// workspace's windows.md, or the check fails. A silent deferral is the bug.
+// windows.go — the broken-windows check. Review prose flags a new TODO, stub,
+// skipped or focused test, checker suppression, swallowed error, deleted test
+// file, or stripped assertion as a finding; this gate makes the register
+// countable instead: any such marker the change *introduces* must carry a
+// recorded waiver row in the workspace's windows.md, or the check fails. A
+// silent deferral or lowered bar is the bug.
 //
 //	devrites-engine check windows <slug> [--worktree|--staged|--base <ref>] [--cwd <dir>]
 //
 //	0  no unwaived markers    2  usage error    3  unwaived markers or blocked
 //
 // Only added lines count: a marker already on the baseline is pre-existing debt,
-// never attributable to this change. Each windows.md row waives exactly one hit —
+// never attributable to this change. Removals count once per file: a deleted
+// test file (`deleted-test`) or a net loss of assertion lines in a test file
+// that remains (`removed-assertion`). Each windows.md row waives exactly one hit —
 // one blanket row cannot cover a file's five new TODOs.
 //
 // windows.md row grammar (one waiver per line):
@@ -34,8 +39,10 @@ import (
 
 const windowsUsage = `usage: devrites-engine check windows <slug> [--worktree|--staged|--base <ref>] [--cwd <dir>]
 
-Reports deferral markers introduced by the change (added lines only) and requires
-each to be waived by a row in .devrites/work/<slug>/windows.md:
+Reports deferral and bar-lowering markers introduced by the change (added lines:
+TODO/stub/skip/focus idioms, checker suppressions, empty-catch; removals:
+deleted-test, removed-assertion) and requires each to be waived by a row in
+.devrites/work/<slug>/windows.md:
   - <path> | <marker> | <reason>
 Each row waives one hit at that path with that marker token.
 Exit 0 clean or fully waived, 3 unwaived markers or blocked.`
@@ -55,8 +62,22 @@ var deferralIdioms = []string{
 	"panic(\"TODO", "panic(\"unimplemented", "panic(\"not implemented",
 	"throw new Error(\"unimplemented", "throw new Error(\"not implemented",
 	"TODO: implement", "not yet implemented",
+	// Focused tests and checker suppressions lower the bar the same way.
+	"it.only(", "describe.only(", "test.only(",
+	"@ts-ignore", "@ts-expect-error", "@ts-nocheck", "eslint-disable",
+	"biome-ignore", "deno-lint-ignore", "istanbul ignore", "c8 ignore",
+	"noqa", "type: ignore", "pylint: disable", "pragma: no cover",
+	"nolint", "#nosec", "nosemgrep", "NOSONAR", "gitleaks:allow",
+	"rubocop:disable", "@SuppressWarnings", "#[allow(", "shellcheck disable",
+	"Stryker disable",
 }
 
+// emptyCatchRe catches a one-line swallowed error: `catch (e) {}`, `except: pass`.
+var emptyCatchRe = regexp.MustCompile(`\bcatch\s*(?:\([^)]*\))?\s*\{\s*\}|\bexcept\b[^:\n]*:\s*pass\b`)
+
+// assertionRe matches a line carrying a test assertion in common frameworks.
+var assertionRe = regexp.MustCompile(`(?i)\bassert|XCTAssert|\bexpect\(|\bt\.(?:error|fatal)|\brequire\.|\.should\b`)
+
 type windowHit struct {
 	Path   string
 	Line   int
@@ -64,6 +85,14 @@ type windowHit struct {
 	Text   string
 }
 
+// location is path:line, or the bare path for a file-level hit (Line 0).
+func (h windowHit) location() string {
+	if h.Line == 0 {
+		return h.Path
+	}
+	return fmt.Sprintf("%s:%d", h.Path, h.Line)
+}
+
 type windowWaiver struct {
 	Path   string
 	Marker string
@@ -92,7 +121,73 @@ func windowsMarkers(line string) []string {
 			out = append(out, m[1])
 		}
 	}
-	return append(out, idioms...)
+	out = append(out, idioms...)
+	if emptyCatchRe.MatchString(line) {
+		out = append(out, "empty-catch")
+	}
+	return out
+}
+
+// isTestPath reports whether a project-relative path names a test source file.
+func isTestPath(p string) bool {
+	base := path.Base(p)
+	for _, suffix := range []string{"_test.go", "_test.py", "_spec.rb", "Test.java", "Tests.java", "Test.kt", "Test.cs", "Tests.cs"} {
+		if strings.HasSuffix(base, suffix) {
+			return true
+		}
+	}
+	return strings.Contains(base, ".test.") || strings.Contains(base, ".spec.") ||
+		strings.HasPrefix(base, "test_") && strings.HasSuffix(base, ".py") ||
+		strings.Contains("/"+p, "/__tests__/") ||
+		strings.Contains("/"+p, "/tests/") && strings.HasSuffix(base, ".rs")
+}
+
+// removedTestHits reports bar-lowering removals in a `git diff -U0` stream: a
+// deleted test file, or a test file that still exists but lost assertion lines
+// on net (moving an assertion within the file is not a loss). Renames are not
+// deletions when git rename detection pairs them.
+func removedTestHits(diff string) []windowHit {
+	var hits []windowHit
+	net := map[string]int{}
+	var order []string
+	var oldPath, file string
+	inHeader, deleted := false, false
+	for _, line := range strings.Split(diff, "\n") {
+		switch {
+		case strings.HasPrefix(line, "diff --git "):
+			inHeader, deleted, file = true, false, ""
+		case inHeader && strings.HasPrefix(line, "--- "):
+			oldPath = strings.TrimPrefix(strings.Trim(strings.TrimSpace(line[4:]), `"`), "a/")
+		case inHeader && strings.HasPrefix(line, "+++ "):
+			newPath := strings.Trim(strings.TrimSpace(line[4:]), `"`)
+			if newPath == "/dev/null" {
+				deleted = true
+				if isTestPath(oldPath) {
+					hits = append(hits, windowHit{Path: oldPath, Marker: "deleted-test", Text: "test file deleted"})
+				}
+				continue
+			}
+			if file = strings.TrimPrefix(newPath, "b/"); !isTestPath(file) {
+				file = ""
+			}
+		case strings.HasPrefix(line, "@@"):
+			inHeader = false
+		case inHeader || deleted || file == "":
+		case strings.HasPrefix(line, "-") && assertionRe.MatchString(line[1:]):
+			if _, seen := net[file]; !seen {
+				order = append(order, file)
+			}
+			net[file]++
+		case strings.HasPrefix(line, "+") && assertionRe.MatchString(line[1:]):
+			net[file]--
+		}
+	}
+	for _, f := range order {
+		if n := net[f]; n > 0 {
+			hits = append(hits, windowHit{Path: f, Marker: "removed-assertion", Text: fmt.Sprintf("net -%d assertion line(s)", n)})
+		}
+	}
+	return hits
 }
 
 // addedLinesFromDiff parses a `git diff -U0` stream into added (path, line,
@@ -180,17 +275,18 @@ func windowsHits(opts diffScopeOpts) ([]windowHit, error) {
 	var diffArgs []string
 	switch opts.mode {
 	case "staged":
-		diffArgs = []string{"diff", "--cached", "-U0", "--"}
+		diffArgs = []string{"diff", "--cached", "-M", "-U0", "--"}
 	case "base":
-		diffArgs = []string{"diff", opts.base, "-U0", "--"}
+		diffArgs = []string{"diff", opts.base, "-M", "-U0", "--"}
 	default:
-		diffArgs = []string{"diff", "HEAD", "-U0", "--"}
+		diffArgs = []string{"diff", "HEAD", "-M", "-U0", "--"}
 	}
 	diff, err := runGitCommand(dir, nil, diffArgs...)
 	var diffPaths map[string]bool
 	switch {
 	case err == nil:
 		hits, diffPaths = addedLinesFromDiff(string(diff))
+		hits = append(hits, removedTestHits(string(diff))...)
 	case opts.mode == "worktree" && isUnbornHEAD(dir):
 		// No commits yet: every changed file is wholly new.
 		diffPaths = map[string]bool{}
@@ -334,11 +430,11 @@ func RunCheckWindows(root string, args []string, stdout, stderr io.Writer) int {
 		if waivers[w] > 0 {
 			waivers[w]--
 			waived++
-			fmt.Fprintf(stdout, "windows: waived: %s:%d %s\n", h.Path, h.Line, h.Marker)
+			fmt.Fprintf(stdout, "windows: waived: %s %s\n", h.location(), h.Marker)
 			continue
 		}
 		unwaived++
-		fmt.Fprintf(stdout, "windows: unwaived: %s:%d %s — %s\n", h.Path, h.Line, h.Marker, h.Text)
+		fmt.Fprintf(stdout, "windows: unwaived: %s %s — %s\n", h.location(), h.Marker, h.Text)
 	}
 	switch {
 	case len(hits) == 0:

package/engine/internal/lib/windows_test.go

@@ -57,6 +57,12 @@ func TestWindowsMarkersTokensAndIdioms(t *testing.T) {
 		{"describe.skip(\"x\", fn)", []string{"describe.skip("}},
 		{"raise NotImplementedError", []string{"NotImplementedError"}},
 		{"panic(\"TODO wire cache\")", []string{"panic(\"TODO"}},
+		{"// @ts-ignore", []string{"@ts-ignore"}},
+		{"x = f()  # noqa: E501", []string{"noqa"}},
+		{"it.only(\"focus\", fn)", []string{"it.only("}},
+		{"try { f() } catch (e) {}", []string{"empty-catch"}},
+		{"except ValueError: pass", []string{"empty-catch"}},
+		{"} catch (e) { log(e) }", nil},
 		{"plain line", nil},
 	}
 	for _, tc := range cases {
@@ -333,3 +339,82 @@ func TestCheckWindowsFailsWhenStatusScanFails(t *testing.T) {
 		t.Fatalf("status failure must be reported on stderr: err=%q", errBuf.String())
 	}
 }
+
+func TestRemovedTestHits(t *testing.T) {
+	diff := "diff --git a/old_test.go b/old_test.go\ndeleted file mode 100644\n--- a/old_test.go\n+++ /dev/null\n@@ -1,2 +0,0 @@\n-package a\n-\tassert(true)\n" +
+		"diff --git a/a_test.go b/a_test.go\n--- a/a_test.go\n+++ b/a_test.go\n@@ -3,2 +3,0 @@\n-\tif got != 1 { t.Fatalf(\"got %d\", got) }\n-\trequire.NoError(t, err)\n" +
+		"diff --git a/moved.test.ts b/moved.test.ts\n--- a/moved.test.ts\n+++ b/moved.test.ts\n@@ -2 +2,0 @@\n-  expect(x).toBe(1)\n@@ -9,0 +9 @@\n+  expect(x).toBe(1)\n" +
+		"diff --git a/lib.go b/lib.go\n--- a/lib.go\n+++ b/lib.go\n@@ -1 +0,0 @@\n-\tassert(ok)\n" +
+		"diff --git a/gone.go b/gone.go\ndeleted file mode 100644\n--- a/gone.go\n+++ /dev/null\n@@ -1 +0,0 @@\n-package a\n"
+	hits := removedTestHits(diff)
+	if len(hits) != 2 {
+		t.Fatalf("hits=%+v", hits)
+	}
+	if hits[0].Path != "old_test.go" || hits[0].Marker != "deleted-test" {
+		t.Fatalf("deleted test hit=%+v", hits[0])
+	}
+	if hits[1].Path != "a_test.go" || hits[1].Marker != "removed-assertion" || !strings.Contains(hits[1].Text, "net -2") {
+		t.Fatalf("removed assertion hit=%+v", hits[1])
+	}
+}
+
+func TestIsTestPath(t *testing.T) {
+	for p, want := range map[string]bool{
+		"pkg/a_test.go": true, "src/a.test.ts": true, "src/a.spec.js": true,
+		"tests/test_api.py": true, "spec/user_spec.rb": true, "src/__tests__/a.js": true,
+		"FooTest.java": true, "tests/integration.rs": true,
+		"pkg/a.go": false, "src/latest.ts": false, "tests/fixture.json": false, "contest.py": false,
+	} {
+		if got := isTestPath(p); got != want {
+			t.Fatalf("isTestPath(%q)=%v want %v", p, got, want)
+		}
+	}
+}
+
+func TestCheckWindowsBlocksLoweredBarUntilWaived(t *testing.T) {
+	project := t.TempDir()
+	initWindowsRepo(t, project)
+	root := windowsWorkspace(t, project, "feat")
+	testutil.WriteFile(t, filepath.Join(project, "a_test.go"), "package a\n\nfunc TestA(t *testing.T) {\n\tif A() != 1 {\n\t\tt.Fatal(\"bad\")\n\t}\n}\n")
+	testutil.WriteFile(t, filepath.Join(project, "b_test.go"), "package a\n")
+	runSecretScanGit(t, project, "add", "--", "a_test.go", "b_test.go")
+	runSecretScanGit(t, project, "commit", "-qm", "baseline")
+	testutil.WriteFile(t, filepath.Join(project, "a_test.go"), "package a\n\nfunc TestA(t *testing.T) {\n\t_ = A()\n}\n")
+	if err := os.Remove(filepath.Join(project, "b_test.go")); err != nil {
+		t.Fatal(err)
+	}
+
+	var out, errBuf bytes.Buffer
+	if code := RunCheckWindows(root, []string{"feat"}, &out, &errBuf); code != 3 {
+		t.Fatalf("code=%d out=%q err=%q", code, out.String(), errBuf.String())
+	}
+	for _, want := range []string{"unwaived: a_test.go removed-assertion", "unwaived: b_test.go deleted-test"} {
+		if !strings.Contains(out.String(), want) {
+			t.Fatalf("missing %q in out=%q", want, out.String())
+		}
+	}
+
+	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "windows.md"),
+		"- a_test.go | removed-assertion | assertion moved to TestB in SLICE-002\n- b_test.go | deleted-test | feature removed per spec AC-3\n")
+	out.Reset()
+	if code := RunCheckWindows(root, []string{"feat"}, &out, &errBuf); code != 0 {
+		t.Fatalf("waived: code=%d out=%q", code, out.String())
+	}
+}
+
+func TestCheckWindowsRenamedTestIsNotDeleted(t *testing.T) {
+	project := t.TempDir()
+	initWindowsRepo(t, project)
+	root := windowsWorkspace(t, project, "feat")
+	runSecretScanGit(t, project, "config", "diff.renames", "false")
+	body := "package a\n\nfunc TestA(t *testing.T) {\n\tif A() != 1 {\n\t\tt.Fatal(\"bad\")\n\t}\n}\n"
+	testutil.WriteFile(t, filepath.Join(project, "a_test.go"), body)
+	runSecretScanGit(t, project, "add", "--", "a_test.go")
+	runSecretScanGit(t, project, "commit", "-qm", "baseline")
+	runSecretScanGit(t, project, "mv", "a_test.go", "b_test.go")
+
+	var out, errBuf bytes.Buffer
+	if code := RunCheckWindows(root, []string{"feat"}, &out, &errBuf); code != 0 {
+		t.Fatalf("rename flagged: code=%d out=%q err=%q", code, out.String(), errBuf.String())
+	}
+}

package/engine/main.go

@@ -48,11 +48,11 @@ Usage:
   devrites-engine orient <slug>            Alias for observe summary
   devrites-engine next [slug]              Print the minimal remaining lifecycle path with advisory skips
   devrites-engine handoff [slug]           Emit the deterministic resume record (cursor, blocking gates, ledger, dead ends)
-  devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--trigger a,b]
+  devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--slice <id>] [--trigger a,b]
                                          Emit one deduplicated read-set bundle for a phase, skill, or dispatch role
   devrites-engine metrics record <slug> --phase <p> --event <e> [--role r] [--bytes n] [--note s]
-  devrites-engine metrics summary [slug]   Summarize the per-feature metrics.jsonl event ledger
-  devrites-engine dispatch <slug> <sub>    Launch-wave barrier for parallel dispatch: open/start/seal/return/status/abandon
+  devrites-engine metrics summary [slug] [--by-slice]  Summarize the metrics ledger, or per-slice rounds and agent-minutes
+  devrites-engine dispatch <slug> <sub>    Launch-wave barrier for parallel dispatch: open/start/seal/return/status/abandon (build wright waves: --slice, round cap)
   devrites-engine claim <add|release|list|check>   Advisory session-scoped file claims for same-tree concurrent sessions (.devrites/claims.jsonl)
   devrites-engine note <subcommand> <slug>         Anchored workspace notes bound to verbatim code quotes; drift regrades them (notes.md)
   devrites-engine observe slice <slug> <SLICE-ID>  Print one SLICE-### section of tasks.md

package/pack/.claude/agents/devrites-slice-wright.md

@@ -120,7 +120,10 @@ unclear boundary is underspecified: return `Escalation` without proceeding.
    new fingerprint. At the limit return the gate and repro. `Escalation` is only for product/irreversible choices
    or human-only access; technical failure is a blocker.
    Before handoff, inspect your cumulative slice diff against the contract and
-   scenario matrix, including correction-affected adjacent variants. Fix supported
+   scenario matrix, including correction-affected adjacent variants, then against
+   the reviewers' own checks: [code review § What to check](../skills/devrites-lib/reference/standards/code-review.md#what-to-check-tests-first)
+   and test analysis (each acceptance criterion has a test that fails without the
+   change; no assertion-free, tautological, or mock-asserting test). Fix supported
    in-scope gaps together, rerun affected proof, and report remaining gaps. Self-check
    never replaces independent review; green tests do not prove all possible cases.
 5. **TRANSFER when isolated.** After green writer-safe proof, verify the diff again,
@@ -138,7 +141,9 @@ Stay inside the exact project-relative paths listed in the dispatch task.
 return an `Escalation`** when:
 - the slice is **underspecified**, the **plan looks wrong**, or requirements, code,
   and tests conflict;
-- the slice needs a **new dependency** or a **second design system**;
+- the slice needs a **new dependency** or a **second design system**, or a planned
+  package fails to install or resolve (report the failure; never retry under a
+  similar or alternative package name);
 - the work requires an unapproved product/security-policy choice, public API break,
   external-service contract change, destructive live migration, or filesystem
   destruction outside the workspace. A path allowlist alone does not approve those

package/pack/.claude/skills/devrites-debug-recovery/reference/hypotheses.md

@@ -3,6 +3,12 @@
 Generate **3-5 ranked hypotheses** *before* testing any of them.
 Single-hypothesis generation anchors on the first plausible idea.
 
+**Check past root causes first.** Search `.devrites/archive/*/evidence.md` with
+native file search for the failure's error text, symbol, and file names. A hit
+whose recorded correct hypothesis matches enters the ranked list with its
+recurrence noted; it is still tested, never assumed. No archive or no hit →
+skip silently.
+
 Each hypothesis must be **falsifiable**: state the prediction it makes.
 
 > Format: *"If <X> is the cause, then <changing Y> will make the failure

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

@@ -36,6 +36,7 @@ If the candidate diff has no matching surfaces, record
 2. Build each reviewer's read-set once with
    `devrites-engine context <slug> --phase <p> --role <role> --trigger <set>` and
    hand the bundle path as the packet's source list instead of a file roster.
+   Build roles add `--slice <SLICE-ID>` (slice-scoped, slice-named bundle).
    Evaluate the skill's trigger conditions and pass each that fires — a role's
    Trigger column maps to manifest names: `security-auditor` → `security`,
    `frontend-reviewer` → `ui`/`frontend`, `performance-reviewer` → `performance`.

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

@@ -59,7 +59,7 @@ topic's owner.
 | `architecture-health.md` | An audit needs a whole-codebase structural score from a code index — coupling, cohesion, cycles, god files, orphans, depth. |
 | `assumption-checkpoints.md` | Scope generalizes an existing boundary: a second case, a newly optional field, or a constant turned parameter. |
 | `debug-recovery.md` | Waiting on async readiness (server start, job completion, browser signal) needs a bounded condition-based poll. |
-| `windows.md` | A deferral marker (TODO/FIXME/skipped test/stub) is introduced or waived — the `check windows` ledger and grammar. |
+| `windows.md` | A deferral or bar-lowering marker (TODO/FIXME/skipped test/stub/suppression/removed test) is introduced or waived — the `check windows` ledger and grammar. |
 | `glossary.md` | A DevRites term is unclear; resolve it once here instead of inferring. |
 
 The table is a load trigger, not an exemption. [`core.md` § Rule summary](core.md#rule-summary-load-the-full-file-when-in-scope)

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

@@ -357,6 +357,8 @@ access, safety and irreversible-action boundaries independently stop work.
   renaming/splitting an unchanged cause does not. Suggestion/Nit/FYI cannot extend
   recovery. Initial discovery and expected test-first RED are not corrections;
   total rounds, re-batches and distinct-finding counts never exhaust recovery.
+  Every 5 Build wright rounds on one slice, the next first needs a reslice review
+  ([`wright-dispatch.md`](../../../rite-build/reference/wright-dispatch.md#run)).
 - **Rechecks are scoped; late findings never reopen the round.** *Late* applies only
   from a phase's **second** review pass (Vet 1b, Build's recheck after the first repair,
   Review step 7); an initial pass has no late findings and every supported finding is

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

@@ -30,6 +30,9 @@ If it does not, do not merge it.
    no justification), stripped assertions, deleted or skipped tests, and new
    unimplemented stubs or `throw`-only placeholders. Each names what it lowers and
    needs a recorded reason in the diff or `decisions.md`; unexplained is a finding.
+   `devrites-engine check windows` flags the mechanical subset (suppressions,
+   skip/focus, stubs, empty catch, deleted tests, stripped assertions) against
+   `windows.md` waivers; loosened thresholds remain this sweep's judgment.
 3. **Correctness:** logic, edge cases, error paths, race conditions, wrong assumptions. For branching or boundary changes, run the [`edge-case trace`](edge-case-trace.md): relevant probe classes, fixed-set siblings, real wiring, negative intent, and deletion contracts with an evidence disposition.
 4. **Readability:** names, function size, control flow, intent obvious without the author.
 5. **Architecture:** right seam, coupling/cohesion, fits existing patterns, no premature

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

@@ -35,6 +35,6 @@
 | Standards | The rule files in this directory; `core.md` is always-on, the rest load on trigger (`README.md` table). |
 | Transfer commit | The isolated wright's local unpushed `WIP(<slug>):` transport commit; never the control-branch checkpoint. |
 | Trigger | A named conditional read-set in a `loads:` manifest (e.g. `tdd`, `applicability`, `ui`); engine fails closed on unknown names. |
-| Windows ledger | `windows.md`: one waiver row per deferral marker the change introduces; `check windows` fails on unwaived hits. [`windows.md`](windows.md). |
+| Windows ledger | `windows.md`: one waiver row per deferral or bar-lowering marker the change introduces; `check windows` fails on unwaived hits. [`windows.md`](windows.md). |
 | Workflow Artifact | A Vet-ready, root-authored executable file under `.devrites/work/<slug>/`; [`workflow-artifacts.md`](workflow-artifacts.md). |
 | Wright | `devrites-slice-wright`: the sole product source/test writer under a path-bounded contract. |

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

@@ -96,6 +96,7 @@ On any security-relevant error: deny, roll back; never default to allow or half-
 - Install reproducibly from a committed lockfile (`npm ci` / frozen); never resolving installs in CI. Hand-editing lockfiles bypasses review.
 - Distrust install scripts (`postinstall` runs arbitrary code) — review before adding; prefer `--ignore-scripts`.
 - Typosquats are a delivery vector: confirm exact name/publisher, not install success.
+  After a failed install, never try a similarly named package; report the failure.
 - A CI/release change names the SLSA build provenance level it claims and where the build runs; a claimed level with no verified provenance attestation is `cannot_verify`, not a pass.
 
 ## Trust boundary (three tiers)