devrites 3.0.5 → 3.0.7

package/engine/internal/lib/packageexistence.go

@@ -65,7 +65,7 @@ var fallbackPackageResolver = packageResolver{extract: quotedModulesFromAddedLin
 
 // PackageExistence catches hallucinated or typo-squatted dependencies: every new
 // third-party import in the slice diff must be DECLARED in a project manifest, not
-// merely imported. It is deterministic and offline — it checks the manifest, not a
+// merely imported. It is deterministic and offline: it checks the manifest, not a
 // package registry. The workspace is <root>/features/<slug>.
 //
 //	0  clean, nothing to check, or skipped (not a git repo / no manifest)
@@ -86,7 +86,7 @@ func PackageExistence(root string, args []string, stdout, stderr io.Writer) int
 	cwd, _ := os.Getwd()
 	gitRoot := gitToplevel(cwd)
 	if gitRoot == "" {
-		fmt.Fprintln(stderr, "package-existence: not a git repo — skipped.")
+		fmt.Fprintln(stderr, "package-existence: not a git repo: skipped.")
 		return 0
 	}
 	ref := "HEAD"
@@ -122,7 +122,7 @@ func PackageExistence(root string, args []string, stdout, stderr io.Writer) int
 	}
 
 	if !hasManifest {
-		fmt.Fprintln(stderr, "package-existence: no recognized manifest — skipped.")
+		fmt.Fprintln(stderr, "package-existence: no recognized manifest: skipped.")
 		return 0
 	}
 
@@ -132,14 +132,14 @@ func PackageExistence(root string, args []string, stdout, stderr io.Writer) int
 			packages = append(packages, pkg)
 		}
 		sort.Strings(packages)
-		fmt.Fprintf(stderr, "package-existence: %d imported package(s) are NOT declared in a manifest — verify each exists and add it via the package manager:\n", len(packages))
+		fmt.Fprintf(stderr, "package-existence: %d imported package(s) are NOT declared in a manifest: verify each exists and add it via the package manager:\n", len(packages))
 		for _, pkg := range packages {
 			fmt.Fprintf(stderr, "  - %s: imported but not declared in any manifest\n", pkg)
 		}
 		fmt.Fprintln(stderr, "An undeclared import is how hallucinated/typo-squatted packages slip in. Confirm the name on the registry before trusting it.")
 		return 3
 	}
-	fmt.Fprintln(stdout, "package-existence: OK — every new third-party import is declared in a manifest.")
+	fmt.Fprintln(stdout, "package-existence: OK: every new third-party import is declared in a manifest.")
 	return 0
 }
 

package/engine/internal/lib/preamble.go

@@ -11,7 +11,7 @@ import (
 	"github.com/devrites/devrites/internal/workflow"
 )
 
-// spaceChars is the POSIX [[:space:]] set under the C locale — the collation the
+// spaceChars is the POSIX [[:space:]] set under the C locale: the collation the
 // parity oracle pins (LC_ALL=C), so trimming matches the bash awk/sed exactly.
 const spaceChars = " \t\n\v\f\r"
 
@@ -22,7 +22,7 @@ func featureDir(root, slug string) string {
 }
 
 // activeSlug reads the active-feature pointer at <root>/ACTIVE (trimmed), or ""
-// when absent — the new-schema replacement for the old .devrites/ACTIVE lookup.
+// when absent: the new-schema replacement for the old .devrites/ACTIVE lookup.
 func activeSlug(root string) string {
 	slug, err := devritespaths.ActiveSlug(root)
 	if err != nil {
@@ -32,7 +32,7 @@ func activeSlug(root string) string {
 }
 
 // preambleArtifacts is the fixed order preamble.sh scans for present artifacts.
-// It is NOT sorted — the display order is the workflow order, so the port keeps
+// It is NOT sorted: the display order is the workflow order, so the port keeps
 // the literal list.
 var preambleArtifacts = []string{
 	"brief", "spec", "references", "strategy", "plan", "tasks", "eng-review",
@@ -41,7 +41,7 @@ var preambleArtifacts = []string{
 	"polish-report", "review", "seal", "ship", "handoff",
 }
 
-// Preamble prints the active feature's workspace state — the orientation every
+// Preamble prints the active feature's workspace state: the orientation every
 // workspace-operating rite-* skill runs first (step 0). Read-only. root is the
 // .devrites directory; slug defaults to the active feature at <root>/ACTIVE.
 // Always exits 0: orientation is never a hard dependency.
@@ -63,7 +63,7 @@ func Preamble(root string, args []string, stdout, stderr io.Writer) int {
 
 	if state, err := os.ReadFile(filepath.Join(workDir, "state.md")); err == nil {
 		fmt.Fprintln(stdout, "### state.md")
-		// Emit the file verbatim, like `cat` — no added trailing newline.
+		// Emit the file verbatim, like `cat`: no added trailing newline.
 		_, _ = stdout.Write(state)
 	}
 
@@ -148,7 +148,7 @@ func isHeadingLine(line string) bool {
 
 // splitLinesNoTrailing splits data into lines on '\n', dropping a single trailing
 // newline's empty final element so a "\n"-terminated file yields N lines, not N+1
-// — matching how awk/grep iterate records.
+// : matching how awk/grep iterate records.
 func splitLinesNoTrailing(data []byte) []string {
 	s := string(data)
 	s = strings.TrimSuffix(s, "\n")

package/engine/internal/lib/progress.go

@@ -12,18 +12,18 @@ import (
 )
 
 // State-parsing patterns ported verbatim from progress.sh's awk. Each name-strip
-// sub is anchored (^ or $), so it matches at most once per line — ReplaceAllString
+// sub is anchored (^ or $), so it matches at most once per line: ReplaceAllString
 // is therefore equivalent to awk's single-match sub.
 var (
 	sliceCheckRe   = regexp.MustCompile(`^- \[[^\]]*\][[:space:]]*`)             // drop "- [x] "
 	sliceNameRe    = regexp.MustCompile(`^Slice[[:space:]]*[0-9]+:[[:space:]]*`) // drop "Slice N: "
 	sliceStateRe   = regexp.MustCompile(`[[:space:]]+(built|pending)[[:space:]]*$`)
-	sliceSepRe     = regexp.MustCompile(`[[:space:]]+[^[:alnum:][:space:]]+[[:space:]]*$`) // drop " — "
+	sliceSepRe     = regexp.MustCompile(`[[:space:]]+[^[:alnum:][:space:]]+[[:space:]]*$`) // drop " · "
 	sliceCheckedRe = regexp.MustCompile(`\[[xX]\]`)
 	sliceHeadingRe = regexp.MustCompile(`^##[[:space:]]+(SLICE-[0-9]{3})(?:[[:space:]]+(.*))?$`)
 )
 
-// Progress renders the active feature's position — the deterministic footer every
+// Progress renders the active feature's position: the deterministic footer every
 // workspace-operating rite-* skill prints last. Read-only. Prints nothing and
 // exits 0 when there is no active workspace, so pre-spec callers stay silent. root
 // is the .devrites directory; slug defaults to the active feature at <root>/ACTIVE.
@@ -38,7 +38,7 @@ func Progress(root string, args []string, stdout, stderr io.Writer) int {
 	workDir := featureDir(root, slug)
 	statePath := filepath.Join(workDir, "state.md")
 	if slug == "" || !isFile(statePath) {
-		return 0 // silent — no active workspace
+		return 0 // silent: no active workspace
 	}
 	stateBytes, err := os.ReadFile(statePath)
 	if err != nil {
@@ -180,7 +180,7 @@ func parsePhase(lines []string) string {
 }
 
 // tallySlices reads the "## Slice progress" block: total slice lines, how many are
-// checked, and the display name of the last checked one — the awk in progress.sh.
+// checked, and the display name of the last checked one: the awk in progress.sh.
 func tallySlices(lines []string) (total, built int, lastbuilt string) {
 	inp := false
 	for _, line := range lines {

package/engine/internal/lib/reconcile.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 )
 
-// Reconcile enforces that the orchestrator never edits source itself — only the
+// Reconcile enforces that the orchestrator never edits source itself: only the
 // dispatched slice-wright writes code and tests, while the orchestrator writes
 // bookkeeping under .devrites/. `snapshot` records the working tree just before
 // the wright runs; `check` diffs it afterward and flags any changed path that is
@@ -17,8 +17,8 @@ import (
 // <root>/features/<slug>.
 //
 //	0  clean check, snapshot written, inline fallback, or skipped (not a git repo)
-//	5  VIOLATION — source changed outside the wright's claimed set
-//	6  setup error — bad args, missing snapshot, or missing claimed manifest
+//	5  VIOLATION: source changed outside the wright's claimed set
+//	6  setup error: bad args, missing snapshot, or missing claimed manifest
 func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 	mode := argAt(args, 0)
 	slug := argAt(args, 1)
@@ -29,7 +29,7 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 	cwd, _ := os.Getwd()
 	gitRoot := gitToplevel(cwd)
 	if gitRoot == "" {
-		fmt.Fprintln(stderr, "reconcile: not a git repo — gate skipped, verify the diff by hand.")
+		fmt.Fprintln(stderr, "reconcile: not a git repo: gate skipped, verify the diff by hand.")
 		return 0
 	}
 
@@ -37,28 +37,37 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 	base := filepath.Join(d, ".reconcile-base")
 	claimed := filepath.Join(d, ".reconcile-claimed")
 	inline := filepath.Join(d, ".reconcile-inline")
+	objects := filepath.Join(d, ".reconcile-objects")
 
 	if slug == "" || !isDir(d) {
 		s := slug
 		if s == "" {
 			s = "<unset>"
 		}
-		fmt.Fprintf(stderr, "reconcile: no active workspace (slug=%s) — nothing to reconcile.\n", s)
+		fmt.Fprintf(stderr, "reconcile: no active workspace (slug=%s): nothing to reconcile.\n", s)
 		return 6
 	}
 
-	closeWindow := func() { _ = os.Remove(base); _ = os.Remove(claimed); _ = os.Remove(inline) }
+	closeWindow := func() {
+		_ = os.Remove(base)
+		_ = os.Remove(claimed)
+		_ = os.Remove(inline)
+		_ = os.RemoveAll(objects)
+	}
 
 	switch mode {
 	case "snapshot":
 		_ = os.Remove(inline) // clear any stale sentinel / prior-slice manifest
 		_ = os.Remove(claimed)
-		tree, err := worktreeTree(gitRoot)
+		_ = os.RemoveAll(objects)
+		tree, err := worktreeTree(gitRoot, objects)
 		if err != nil {
+			_ = os.RemoveAll(objects)
 			fmt.Fprintf(stderr, "reconcile: cannot snapshot worktree: %v\n", err)
 			return 6
 		}
 		if err := os.WriteFile(base, []byte(tree+"\n"), 0o644); err != nil {
+			_ = os.RemoveAll(objects)
 			fmt.Fprintf(stderr, "reconcile: cannot write snapshot: %v\n", err)
 			return 6
 		}
@@ -67,16 +76,16 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 
 	case "check":
 		if isFile(inline) {
-			fmt.Fprintln(stderr, "reconcile: inline-fallback run (no wright dispatched) — gate skipped.")
+			fmt.Fprintln(stderr, "reconcile: inline-fallback run (no wright dispatched): gate skipped.")
 			closeWindow()
 			return 0
 		}
 		if !isFile(base) {
-			fmt.Fprintln(stderr, `reconcile: no snapshot (.reconcile-base) — run "devrites-engine reconcile snapshot" before dispatch.`)
+			fmt.Fprintln(stderr, `reconcile: no snapshot (.reconcile-base): run "devrites-engine reconcile snapshot" before dispatch.`)
 			return 6
 		}
 		if !isFile(claimed) {
-			fmt.Fprintln(stderr, "reconcile: no claimed manifest (.reconcile-claimed) — write the wright Files-changed paths first.")
+			fmt.Fprintln(stderr, "reconcile: no claimed manifest (.reconcile-claimed): write the wright Files-changed paths first.")
 			return 6
 		}
 		baseBytes, err := os.ReadFile(base)
@@ -86,19 +95,34 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 		}
 		baseTree := strings.TrimSpace(string(baseBytes))
 		if baseTree == "" {
-			fmt.Fprintln(stderr, "reconcile: empty snapshot (.reconcile-base) — re-run \"devrites-engine reconcile snapshot\" before dispatch.")
+			fmt.Fprintln(stderr, "reconcile: empty snapshot (.reconcile-base): re-run \"devrites-engine reconcile snapshot\" before dispatch.")
+			return 6
+		}
+		if !isDir(objects) {
+			fmt.Fprintln(stderr, "reconcile: missing snapshot object database (.reconcile-objects): re-run \"devrites-engine reconcile snapshot\" before dispatch.")
 			return 6
 		}
-		nowTree, err := worktreeTree(gitRoot)
+		nowTree, err := worktreeTree(gitRoot, objects)
 		if err != nil {
 			fmt.Fprintf(stderr, "reconcile: cannot capture worktree: %v\n", err)
 			return 6
 		}
+		diff := exec.Command("git", "-C", gitRoot, "diff", "--name-only", baseTree, nowTree)
+		diff.Env, err = reconcileGitEnv(gitRoot, objects)
+		if err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot compare worktree: %v\n", err)
+			return 6
+		}
+		diffOut, err := diff.CombinedOutput()
+		if err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot compare worktree: git diff --name-only: %v: %s\n", err, strings.TrimSpace(string(diffOut)))
+			return 6
+		}
 
 		claimedSet := claimedPaths(claimed)
 		viol := 0
 		var violist strings.Builder
-		for _, f := range gitDiffNames(gitRoot, baseTree, nowTree) {
+		for _, f := range splitLinesNoTrailing(diffOut) {
 			if f == "" || strings.HasPrefix(f, ".devrites/") {
 				continue
 			}
@@ -108,13 +132,13 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 			}
 		}
 		if viol > 0 {
-			fmt.Fprintf(stderr, "reconcile: STOP — %d source file(s) changed OUTSIDE the wright (A1 breach):\n", viol)
+			fmt.Fprintf(stderr, "reconcile: STOP: %d source file(s) changed OUTSIDE the wright (A1 breach):\n", viol)
 			fmt.Fprint(stderr, violist.String())
 			fmt.Fprintln(stderr, "The orchestrator must NOT edit source. Re-dispatch the wright (continue it once) or revert these.")
 			return 5
 		}
 		closeWindow()
-		fmt.Fprintln(stdout, "reconcile: OK — every source change is the wright's; orchestrator touched only bookkeeping.")
+		fmt.Fprintln(stdout, "reconcile: OK: every source change is the wright's; orchestrator touched only bookkeeping.")
 		return 0
 
 	default:
@@ -132,23 +156,36 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 // snapshot and the check would then record that same sha, the diff would come
 // back empty, and the gate would report OK on precisely the A1 breach it exists
 // to catch. Surface the error and let the caller fail closed.
-func worktreeTree(gitRoot string) (string, error) {
+func worktreeTree(gitRoot, objectDir string) (string, error) {
 	idx := filepath.Join(os.TempDir(), fmt.Sprintf("devrites-reconcile-%d.idx", os.Getpid()))
 	_ = os.Remove(idx)
 	defer func() { _ = os.Remove(idx) }()
-	env := append(os.Environ(), "GIT_INDEX_FILE="+idx)
+	if err := os.MkdirAll(objectDir, 0o700); err != nil {
+		return "", fmt.Errorf("create object directory: %w", err)
+	}
+	env, err := reconcileGitEnv(gitRoot, objectDir)
+	if err != nil {
+		return "", err
+	}
+	env = append(env, "GIT_INDEX_FILE="+idx)
 
 	add := exec.Command("git", "-C", gitRoot, "add", "-A")
 	add.Env = env
-	add.Stdout, add.Stderr = io.Discard, io.Discard
-	if err := add.Run(); err != nil {
+	addOut, err := add.CombinedOutput()
+	if err != nil {
+		if detail := strings.TrimSpace(string(addOut)); detail != "" {
+			return "", fmt.Errorf("git add -A: %w: %s", err, detail)
+		}
 		return "", fmt.Errorf("git add -A: %w", err)
 	}
 
 	write := exec.Command("git", "-C", gitRoot, "write-tree")
 	write.Env = env
-	out, err := write.Output()
+	out, err := write.CombinedOutput()
 	if err != nil {
+		if detail := strings.TrimSpace(string(out)); detail != "" {
+			return "", fmt.Errorf("git write-tree: %w: %s", err, detail)
+		}
 		return "", fmt.Errorf("git write-tree: %w", err)
 	}
 	tree := strings.TrimSpace(string(out))
@@ -158,6 +195,29 @@ func worktreeTree(gitRoot string) (string, error) {
 	return tree, nil
 }
 
+func reconcileGitEnv(gitRoot, objectDir string) ([]string, error) {
+	common := exec.Command("git", "-C", gitRoot, "rev-parse", "--git-common-dir")
+	out, err := common.CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("git rev-parse --git-common-dir: %w: %s", err, strings.TrimSpace(string(out)))
+	}
+	commonDir := strings.TrimSpace(string(out))
+	if !filepath.IsAbs(commonDir) {
+		commonDir = filepath.Join(gitRoot, commonDir)
+	}
+	alternates := []string{filepath.Join(commonDir, "objects")}
+	if inherited := os.Getenv("GIT_OBJECT_DIRECTORY"); inherited != "" {
+		alternates = append(alternates, inherited)
+	}
+	if inherited := os.Getenv("GIT_ALTERNATE_OBJECT_DIRECTORIES"); inherited != "" {
+		alternates = append(alternates, inherited)
+	}
+	return append(os.Environ(),
+		"GIT_OBJECT_DIRECTORY="+objectDir,
+		"GIT_ALTERNATE_OBJECT_DIRECTORIES="+strings.Join(alternates, string(os.PathListSeparator)),
+	), nil
+}
+
 // claimedPaths reads the .reconcile-claimed manifest into a set of the exact
 // paths the wright reported changing.
 func claimedPaths(path string) map[string]struct{} {

package/engine/internal/lib/reconcile_test.go

@@ -75,7 +75,7 @@ func runReconcile(t *testing.T, root string, args ...string) (int, string) {
 
 func TestWorktreeTreeErrorsOutsideGitRepo(t *testing.T) {
 	dir := t.TempDir()
-	tree, err := worktreeTree(dir)
+	tree, err := worktreeTree(dir, t.TempDir())
 	if err == nil {
 		t.Fatalf("worktreeTree(%q) = %q, nil; want an error outside a git repo", dir, tree)
 	}
@@ -86,13 +86,14 @@ func TestWorktreeTreeErrorsOutsideGitRepo(t *testing.T) {
 
 func TestWorktreeTreeCapturesUntrackedFiles(t *testing.T) {
 	dir := newGitRepo(t)
+	objects := t.TempDir()
 
-	before, err := worktreeTree(dir)
+	before, err := worktreeTree(dir, objects)
 	if err != nil {
 		t.Fatalf("worktreeTree: %v", err)
 	}
 	writeFile(t, filepath.Join(dir, "untracked.go"), "package main\n")
-	after, err := worktreeTree(dir)
+	after, err := worktreeTree(dir, objects)
 	if err != nil {
 		t.Fatalf("worktreeTree: %v", err)
 	}
@@ -100,7 +101,7 @@ func TestWorktreeTreeCapturesUntrackedFiles(t *testing.T) {
 		t.Errorf("worktreeTree did not observe the untracked file: both trees = %s", before)
 	}
 
-	// The user's real index must be untouched — the file stays untracked.
+	// The user's real index must be untouched: the file stays untracked.
 	out, err := exec.Command("git", "-C", dir, "status", "--porcelain", "untracked.go").Output()
 	if err != nil {
 		t.Fatalf("git status: %v", err)
@@ -113,6 +114,13 @@ func TestWorktreeTreeCapturesUntrackedFiles(t *testing.T) {
 func TestReconcileSnapshotThenCleanCheck(t *testing.T) {
 	gitRoot := newGitRepo(t)
 	root := workspace(t, "feat")
+	objects := t.TempDir()
+	if err := os.Chmod(objects, 0o500); err != nil {
+		t.Fatalf("make git objects read-only: %v", err)
+	}
+	t.Cleanup(func() { _ = os.Chmod(objects, 0o700) })
+	t.Setenv("GIT_OBJECT_DIRECTORY", objects)
+	writeFile(t, filepath.Join(gitRoot, "untracked.go"), "package main\n")
 
 	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
 		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
@@ -137,7 +145,7 @@ func TestReconcileCheckFlagsUnclaimedChange(t *testing.T) {
 	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
 		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
 	}
-	// The orchestrator edits source it never claimed — the A1 breach.
+	// The orchestrator edits source it never claimed: the A1 breach.
 	writeFile(t, filepath.Join(gitRoot, "rogue.go"), "package main\n")
 	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-claimed"), "seed.go\n")
 

package/engine/internal/lib/resolve.go

@@ -107,7 +107,7 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 				if err := clearAwaiting(sfile, bid); err != nil {
 					return fail(stderr, err.Error(), 1)
 				}
-				fmt.Fprintf(stdout, "Dropped:  %s — %s\n", bid, reason)
+				fmt.Fprintf(stdout, "Dropped:  %s: %s\n", bid, reason)
 			} else {
 				bid, ans := splitColon(line)
 				ans = strings.TrimPrefix(ans, " ")
@@ -169,7 +169,7 @@ func clockNow() time.Time {
 func nowUTC() string { return clockNow().UTC().Format("2006-01-02T15:04:05Z") }
 
 // resolveNextQID prints the next sequential question id for today, refusing (exit
-// 6) an id that already has a header — a sign questions.md was hand-edited.
+// 6) an id that already has a header: a sign questions.md was hand-edited.
 func resolveNextQID(qpath string, stdout, stderr io.Writer) int {
 	if qpath == "" {
 		return fail(stderr, "Usage: devrites-engine resolve next-qid <questions.md path>", 5)
@@ -363,7 +363,7 @@ func clearAwaiting(sfile, qid string) error {
 		out = append(out, fmt.Sprintf("- %s %s: resolved %s", ts, resumePhase, qid))
 	}
 	out, _ = state.SetCursorField(out, state.CursorStatus, "running")
-	out, _ = state.SetCursorField(out, state.CursorNextAction, "(resume — `"+resumeCommand.Both()+"` to continue the workflow)")
+	out, _ = state.SetCursorField(out, state.CursorNextAction, "(resume: `"+resumeCommand.Both()+"` to continue the workflow)")
 	if err := fsutil.WriteFileAtomic(sfile, joinRecords(out), 0o644); err != nil {
 		return fmt.Errorf("update state %s: %w", sfile, err)
 	}

package/engine/internal/lib/reviewerstats.go

@@ -29,7 +29,7 @@ type reviewerStatEntry struct {
 
 var reviewerAgentRe = regexp.MustCompile(`^devrites-[a-z][a-z-]*$`)
 
-// alwaysOnReviewers are the roster's unconditional axes — stats are recorded for
+// alwaysOnReviewers are the roster's unconditional axes: stats are recorded for
 // visibility but the verdict is always run.
 var alwaysOnReviewers = map[string]bool{
 	"devrites-spec-reviewer": true,
@@ -183,7 +183,7 @@ func reviewerVerdict(agent string, zeroStreak int) string {
 	case alwaysOnReviewers[agent]:
 		return "run (always-on)"
 	case insuranceReviewers[agent]:
-		return "run (insurance — never gated)"
+		return "run (insurance: never gated)"
 	case zeroStreak >= gateStreak:
 		return "gate-candidate"
 	default:

package/engine/internal/lib/reviewintegrity.go

@@ -8,14 +8,14 @@ import (
 	"strings"
 )
 
-// findingLabel matches a bold severity label — the shape a *real* finding carries
-// in review.md (`- **Critical** — ...`). A plain summary count ("Critical 0 /
+// findingLabel matches a bold severity label: the shape a *real* finding carries
+// in review.md (`- **Critical**: ...`). A plain summary count ("Critical 0 /
 // Important 0") is deliberately NOT matched: an all-zero tally is the rubber-stamp
 // this gate exists to catch, not evidence that review happened.
 var findingLabel = regexp.MustCompile(`\*\*(Critical|Important|Suggestion|Nit|FYI)\*\*`)
 
 // noFindingsMarker matches the justification an adversarial reviewer must leave
-// when it genuinely finds nothing — the axis stayed clean, and here is the
+// when it genuinely finds nothing: the axis stayed clean, and here is the
 // account of the passes that came back empty. Presence is all this gate checks;
 // the quality of the account is the reviewer fan-out's job (same contract as
 // doubt-coverage's `doubt: MISSING` and footprint's roster).
@@ -34,14 +34,14 @@ var reviewAxes = []struct {
 
 // ReviewIntegrity guards the opposite failure from the rest of review discipline:
 // not the noisy false positive (which confidence-banding suppresses) but the
-// silent false negative — a reviewer that returns "looks good, nothing found".
+// silent false negative: a reviewer that returns "looks good, nothing found".
 // An empty findings list is treated as suspicious, not as a pass: an adversarial
 // axis that reports nothing must justify the emptiness, exactly as it must quote a
 // line to raise a finding. Read-only; the workspace is <root>/work/<slug>.
 //
-//	0  every axis accounted for — has findings, has a no-findings justification, or review.md absent/freeform
+//	0  every axis accounted for: has findings, has a no-findings justification, or review.md absent/freeform
 //	2  usage (no slug)
-//	1  an adversarial axis is silent AND unjustified — a suspected rubber-stamp
+//	1  an adversarial axis is silent AND unjustified: a suspected rubber-stamp
 func ReviewIntegrity(root string, args []string, stdout, stderr io.Writer) int {
 	slug := argAt(args, 0)
 	if slug == "" {
@@ -55,15 +55,15 @@ func ReviewIntegrity(root string, args []string, stdout, stderr io.Writer) int {
 	dir := featureDir(root, slug)
 	review, ok := readFileOK(filepath.Join(dir, "review.md"))
 	if !ok {
-		fmt.Fprintln(stdout, "review-integrity: no review.md — nothing to assess (pass)")
+		fmt.Fprintln(stdout, "review-integrity: no review.md: nothing to assess (pass)")
 		return 0
 	}
 
 	sections := axisSections(review)
 	if len(sections) == 0 {
 		// A freeform review with no `## Spec` / `## Code review` headings can't be
-		// assessed mechanically — say so and pass rather than flag a format choice.
-		fmt.Fprintln(stdout, "review-integrity: no per-axis sections in review.md — heading-based check n/a (pass)")
+		// assessed mechanically: say so and pass rather than flag a format choice.
+		fmt.Fprintln(stdout, "review-integrity: no per-axis sections in review.md: heading-based check n/a (pass)")
 		return 0
 	}
 
@@ -71,7 +71,7 @@ func ReviewIntegrity(root string, args []string, stdout, stderr io.Writer) int {
 	for _, ax := range reviewAxes {
 		body, present := sections[ax.label]
 		if !present {
-			continue // axis not written as its own section — nothing to check here
+			continue // axis not written as its own section: nothing to check here
 		}
 		hasFinding := findingLabel.MatchString(body)
 		justified := noFindingsMarker.MatchString(body)
@@ -79,7 +79,7 @@ func ReviewIntegrity(root string, args []string, stdout, stderr io.Writer) int {
 		case hasFinding:
 			fmt.Fprintf(stdout, "  %s: findings present\n", ax.label)
 		case justified:
-			fmt.Fprintf(stdout, "  %s: clean — no-findings justification present\n", ax.label)
+			fmt.Fprintf(stdout, "  %s: clean: no-findings justification present\n", ax.label)
 		default:
 			fmt.Fprintf(stdout, "  %s: SILENT (no finding, no justification)\n", ax.label)
 			silent = append(silent, ax.label)
@@ -87,12 +87,12 @@ func ReviewIntegrity(root string, args []string, stdout, stderr io.Writer) int {
 	}
 
 	if len(silent) > 0 {
-		fmt.Fprintf(stdout, "review-integrity: SILENT — %s reviewed nothing and justified nothing.\n", strings.Join(silent, ", "))
+		fmt.Fprintf(stdout, "review-integrity: SILENT: %s reviewed nothing and justified nothing.\n", strings.Join(silent, ", "))
 		fmt.Fprintln(stdout, "A zero-findings axis is suspicious, not a pass. Re-run the axis, or record a")
 		fmt.Fprintln(stdout, "'No-findings:' justification naming the adversarial passes that came back empty.")
 		return 1
 	}
-	fmt.Fprintln(stdout, "review-integrity: OK — every adversarial axis has findings or a justified clean bill.")
+	fmt.Fprintln(stdout, "review-integrity: OK: every adversarial axis has findings or a justified clean bill.")
 	return 0
 }
 

package/engine/internal/lib/reviewintegrity_test.go

@@ -36,7 +36,7 @@ Everything matches the spec. Nothing to report.
 Critical 0 / Important 0 / Suggestion 0
 
 ## Code review
-- **Important** — off-by-one in pagination at api/list.go:42.
+- **Important**: off-by-one in pagination at api/list.go:42.
 `)
 	code, out := runReviewIntegrity(t, root, "feat")
 	if code != 1 {
@@ -59,13 +59,13 @@ No-findings: ran the missing/partial/incorrect passes against each AC; every
 criterion is implemented and no scope creep found.
 
 ## Code review
-- **Nit** — rename tmp to buf at util.go:9.
+- **Nit**: rename tmp to buf at util.go:9.
 `)
 	code, out := runReviewIntegrity(t, root, "feat")
 	if code != 0 {
 		t.Fatalf("justified clean axis should pass, got %d\n%s", code, out)
 	}
-	if !contains(out, "Spec: clean — no-findings justification present") {
+	if !contains(out, "Spec: clean: no-findings justification present") {
 		t.Fatalf("want Spec recognised as justified, got:\n%s", out)
 	}
 }
@@ -73,10 +73,10 @@ criterion is implemented and no scope creep found.
 func TestReviewIntegrityBothWithFindingsPasses(t *testing.T) {
 	root := t.TempDir()
 	writeReview(t, root, "feat", `## Spec
-- **Critical** — AC-003 unimplemented.
+- **Critical**: AC-003 unimplemented.
 
 ## Code review
-- **Important** — missing error path.
+- **Important**: missing error path.
 `)
 	if code, out := runReviewIntegrity(t, root, "feat"); code != 0 {
 		t.Fatalf("both-with-findings should pass, got %d\n%s", code, out)
@@ -95,7 +95,7 @@ func TestReviewIntegrityNoReviewPasses(t *testing.T) {
 
 func TestReviewIntegrityFreeformPasses(t *testing.T) {
 	root := t.TempDir()
-	// No per-axis headings — can't assess mechanically, must not false-positive.
+	// No per-axis headings: can't assess mechanically, must not false-positive.
 	writeReview(t, root, "feat", "# Review\n\nLooks fine overall, shipping.\n")
 	if code, out := runReviewIntegrity(t, root, "feat"); code != 0 {
 		t.Fatalf("freeform review should pass, got %d\n%s", code, out)

package/engine/internal/lib/runbook.go

@@ -44,7 +44,7 @@ func Runbook(root string, args []string, stdout, stderr io.Writer) int {
 			fmt.Fprintf(stderr, "runbook: %v\n", err)
 			return 1
 		}
-		fmt.Fprintf(stdout, "runbook: OK — %d step(s) in %s\n", len(steps), displayRunbookPath(root, path))
+		fmt.Fprintf(stdout, "runbook: OK: %d step(s) in %s\n", len(steps), displayRunbookPath(root, path))
 		return 0
 	case "run":
 		return runbookRun(root, args[1:], stdout, stderr)

package/engine/internal/lib/session.go

@@ -227,7 +227,7 @@ func ReviewFingerprints(root string, args []string, stdout, stderr io.Writer) in
 	dir := featureDir(root, slug)
 	review, ok := readFileOK(filepath.Join(dir, "review.md"))
 	if !ok {
-		fmt.Fprintln(stdout, "review-fingerprints: no review.md — nothing to fingerprint.")
+		fmt.Fprintln(stdout, "review-fingerprints: no review.md: nothing to fingerprint.")
 		return 0
 	}
 	records := reviewFindingFingerprints(review)

package/engine/internal/lib/session_test.go

@@ -76,10 +76,10 @@ func TestReviewFingerprintsStableAndWritable(t *testing.T) {
 	writeReview(t, root, "feat", `# Review
 
 ## Spec
-- **Critical** — AC-003 is unproven.
+- **Critical**: AC-003 is unproven.
 
 ## Code review
-- **Important** — missing error handling.`)
+- **Important**: missing error handling.`)
 	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
 	code := ReviewFingerprints(root, []string{"--write", "feat"}, stdout, stderr)
 	if code != 0 {