devrites 3.0.5 → 3.0.6

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 {

package/engine/internal/lib/specparse.go

@@ -12,7 +12,7 @@ import (
 // — capability: <c>" section they sit under. It is the shared reader behind two
 // consumers: the spec-validate `--against` ledger cross-check (specvalidate.go)
 // and the capability-ledger fold (ledger.go). The grammar linter (lintSpec) is
-// deliberately left untouched — delta H2 headers are transparent to it — so this
+// deliberately left untouched (delta H2 headers are transparent to it) so this
 // parser adds delta-awareness without perturbing the flat-spec lint contract.
 
 // Delta kinds, lower-cased. A requirement outside any delta section has kind "".
@@ -35,7 +35,7 @@ var (
 // Requirement is one "### Requirement: <name>" block with its delta context.
 type Requirement struct {
 	Name       string // header text after "Requirement:", trailing space trimmed
-	Key        string // strings.ToLower(Name) — the identity used to match across specs
+	Key        string // strings.ToLower(Name): the identity used to match across specs
 	Kind       string // added | modified | removed | "" (flat, no delta section)
 	Capability string // from the section tag; "" when untagged
 	HeaderLine int    // 1-based line of the "### Requirement:" header
@@ -48,7 +48,7 @@ type SpecDoc struct {
 	HasDelta     bool // at least one "## … Requirements" delta section was seen
 }
 
-// ParseSpec reads and structures a spec.md. It never fails on grammar problems —
+// ParseSpec reads and structures a spec.md. It never fails on grammar problems:
 // that is lintSpec's job; ParseSpec only extracts blocks and their delta context.
 func ParseSpec(file string) (*SpecDoc, error) {
 	f, err := os.Open(file)
@@ -109,7 +109,7 @@ func ParseSpec(file string) (*SpecDoc, error) {
 }
 
 // requirementKeys returns the set of lower-cased requirement names present in a
-// spec file — the identity index a cross-spec existence check consults. A missing
+// spec file: the identity index a cross-spec existence check consults. A missing
 // or unreadable file yields an empty set (the caller decides whether that is an
 // error), matching how the ledger treats an unseeded capability.
 func requirementKeys(file string) map[string]bool {

package/engine/internal/lib/specskeleton.go

@@ -45,11 +45,11 @@ func SpecSkeleton(arg, cwd string, stdout, stderr io.Writer) int {
 		}
 	}
 	if len(missing) > 0 {
-		fmt.Fprintf(stdout, "spec-skeleton: BLOCKED — %s: missing top-level section(s): %s\n", rel, strings.Join(missing, ", "))
+		fmt.Fprintf(stdout, "spec-skeleton: BLOCKED: %s: missing top-level section(s): %s\n", rel, strings.Join(missing, ", "))
 		return 3
 	}
 
-	fmt.Fprintf(stdout, "spec-skeleton: OK — %s: all required top-level sections present\n", rel)
+	fmt.Fprintf(stdout, "spec-skeleton: OK: %s: all required top-level sections present\n", rel)
 	return 0
 }
 

package/engine/internal/lib/specvalidate.go

@@ -1,6 +1,6 @@
 // Package lib holds native Go implementations of the deterministic, zero-token
 // workflow checks DevRites used to run as individual .sh helpers. Each exported
-// function owns its logic outright — it does not shell out — and reproduces the
+// function owns its logic outright (it does not shell out) and reproduces the
 // legacy behavior (stdout + exit code) exactly, verified in the CLI test suite
 // by golden assertions or, transitionally, a bash-parity comparison.
 package lib
@@ -15,11 +15,11 @@ import (
 	"strings"
 )
 
-// Spec-grammar validator — deterministic lint of the structured
+// Spec-grammar validator: deterministic lint of the structured
 // Requirement/Scenario acceptance grammar in a spec.md. A port of
 // spec-validate.sh; see standards/spec-grammar.md for the grammar.
 //
-// Exit codes: 0 valid (or no structured requirements — nothing to lint) ·
+// Exit codes: 0 valid (or no structured requirements: nothing to lint) ·
 // 1 grammar violation(s) · 2 usage · 5 missing spec.md.
 var (
 	reqHeaderRe  = regexp.MustCompile(`^[[:space:]]*###[[:space:]]+[Rr]equirement:`)
@@ -57,13 +57,13 @@ func SpecValidate(arg, against, cwd string, stdout, stderr io.Writer) int {
 	rel := strings.TrimPrefix(spec, cwd+"/")
 
 	if reqs == 0 && len(findings) == 0 {
-		fmt.Fprintf(stdout, "spec-validate: %s uses the simple acceptance form (no \"### Requirement:\" blocks) — nothing to lint\n", rel)
+		fmt.Fprintf(stdout, "spec-validate: %s uses the simple acceptance form (no \"### Requirement:\" blocks): nothing to lint\n", rel)
 		return 0
 	}
 
 	// Delta cross-check (opt-in via --against): a spec written as deltas against a
 	// living ledger must classify each requirement correctly. Skipped for a flat
-	// snapshot (no delta sections) — there is nothing to reconcile.
+	// snapshot (no delta sections): there is nothing to reconcile.
 	if against != "" {
 		findings = append(findings, checkAgainstLedger(spec, against, defaultCapability(arg))...)
 	}
@@ -72,12 +72,12 @@ func SpecValidate(arg, against, cwd string, stdout, stderr io.Writer) int {
 		for _, f := range findings {
 			fmt.Fprintln(stderr, f)
 		}
-		fmt.Fprintf(stderr, "spec-validate: %s — %d requirement(s) / %d scenario(s); %d grammar error(s) (see standards/spec-grammar.md)\n",
+		fmt.Fprintf(stderr, "spec-validate: %s: %d requirement(s) / %d scenario(s); %d grammar error(s) (see standards/spec-grammar.md)\n",
 			rel, reqs, scens, len(findings))
 		return 1
 	}
 
-	fmt.Fprintf(stdout, "spec-validate: OK — %s: %d requirement(s) / %d scenario(s) well-formed (SHALL + WHEN/THEN, unique headers)\n",
+	fmt.Fprintf(stdout, "spec-validate: OK: %s: %d requirement(s) / %d scenario(s) well-formed (SHALL + WHEN/THEN, unique headers)\n",
 		rel, reqs, scens)
 	return 0
 }
@@ -220,7 +220,7 @@ func lintSpec(file string) (reqCount, scenCount int, findings []string, err erro
 			}
 			if scenInReq == 0 {
 				if looseWhenThen {
-					findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement \"%s\" (line %d) has WHEN/THEN lines but no \"#### Scenario:\" header — wrap them in a scenario", file, curReq, reqLine))
+					findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement \"%s\" (line %d) has WHEN/THEN lines but no \"#### Scenario:\" header: wrap them in a scenario", file, curReq, reqLine))
 				} else {
 					findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement \"%s\" (line %d) has no \"#### Scenario:\" block", file, curReq, reqLine))
 				}
@@ -245,7 +245,7 @@ func lintSpec(file string) (reqCount, scenCount int, findings []string, err erro
 			looseWhenThen = false
 			key := strings.ToLower(name)
 			if first, dup := seen[key]; dup {
-				findings = append(findings, fmt.Sprintf("ERROR:%s: duplicate Requirement header \"%s\" (lines %d and %d) — headers must be unique", file, name, first, nr))
+				findings = append(findings, fmt.Sprintf("ERROR:%s: duplicate Requirement header \"%s\" (lines %d and %d): headers must be unique", file, name, first, nr))
 			} else {
 				seen[key] = nr
 			}
@@ -311,7 +311,7 @@ func resolveSpecPath(command, arg string, stderr io.Writer) (string, int, bool)
 	var spec string
 	switch {
 	case isDir(arg):
-		spec = arg + "/spec.md" // string concat, not filepath.Join — preserve the exact path bytes
+		spec = arg + "/spec.md" // string concat, not filepath.Join: preserve the exact path bytes
 	case isFile(arg):
 		spec = arg
 	default:
@@ -359,11 +359,11 @@ func checkAgainstLedger(spec, ledgerRoot, defaultCap string) []string {
 		switch r.Kind {
 		case DeltaAdded:
 			if exists {
-				findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement %q (line %d) is marked ADDED but already exists in ledger capability %q — use MODIFIED, or drop the delta", spec, r.Name, r.HeaderLine, capability))
+				findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement %q (line %d) is marked ADDED but already exists in ledger capability %q: use MODIFIED, or drop the delta", spec, r.Name, r.HeaderLine, capability))
 			}
 		case DeltaModified, DeltaRemoved:
 			if !exists {
-				findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement %q (line %d) is marked %s but is absent from ledger capability %q — use ADDED, or fix the capability tag", spec, r.Name, r.HeaderLine, strings.ToUpper(r.Kind), capability))
+				findings = append(findings, fmt.Sprintf("ERROR:%s: Requirement %q (line %d) is marked %s but is absent from ledger capability %q: use ADDED, or fix the capability tag", spec, r.Name, r.HeaderLine, strings.ToUpper(r.Kind), capability))
 			}
 		}
 	}
@@ -371,7 +371,7 @@ func checkAgainstLedger(spec, ledgerRoot, defaultCap string) []string {
 }
 
 // defaultCapability derives the fallback capability for an untagged delta section:
-// the workspace slug — the basename of the workspace dir, or of the spec.md's
+// the workspace slug: the basename of the workspace dir, or of the spec.md's
 // parent directory when a bare file path was given.
 func defaultCapability(arg string) string {
 	if isDir(arg) {