devrites 3.0.5 → 3.0.7

package/engine/internal/install/install_test.go

@@ -4,9 +4,12 @@ import (
 	"archive/tar"
 	"bytes"
 	"compress/gzip"
+	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io/fs"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -195,7 +198,7 @@ func TestInstallMergesClaudeHooksIntoExistingSettings(t *testing.T) {
 }`+"\n")
 	target := t.TempDir()
 	testutil.WriteFile(t, filepath.Join(target, ".claude", "settings.json"), `{
-  "$comment": "DevRites hooks — keep my local notes",
+  "$comment": "DevRites hooks: keep my local notes",
   "theme": "dark",
   "statusLine": {"type":"command","command":"DEVRITES_THEME=dark echo user-status"},
   "hooks": {"Stop":[{"hooks":[
@@ -209,7 +212,7 @@ func TestInstallMergesClaudeHooksIntoExistingSettings(t *testing.T) {
 	runInstall(t, target, payload, func(o *Options) { o.Stderr = &stderr })
 
 	settings := testutil.ReadFile(t, filepath.Join(target, ".claude", "settings.json"))
-	for _, preserved := range []string{"DevRites hooks — keep my local notes", `"theme": "dark"`, "echo user-status", "echo user-stop"} {
+	for _, preserved := range []string{"DevRites hooks: keep my local notes", `"theme": "dark"`, "echo user-status", "echo user-stop"} {
 		if !strings.Contains(settings, preserved) {
 			t.Fatalf("Claude settings lost user content %q:\n%s", preserved, settings)
 		}
@@ -229,7 +232,7 @@ func TestInstallMergesClaudeHooksIntoExistingSettings(t *testing.T) {
 
 	runUninstall(t, target)
 	settings = testutil.ReadFile(t, filepath.Join(target, ".claude", "settings.json"))
-	for _, preserved := range []string{"DevRites hooks — keep my local notes", `"theme": "dark"`, "echo user-status", "echo user-stop"} {
+	for _, preserved := range []string{"DevRites hooks: keep my local notes", `"theme": "dark"`, "echo user-status", "echo user-stop"} {
 		if !strings.Contains(settings, preserved) {
 			t.Fatalf("Claude settings uninstall lost user content %q:\n%s", preserved, settings)
 		}
@@ -347,6 +350,111 @@ func TestInstallBinaryUsesEngineHandoff(t *testing.T) {
 	}
 }
 
+func TestAcquireBinaryBuildsWithoutVCSMetadata(t *testing.T) {
+	t.Setenv("DEVRITES_ENGINE_CLI", "")
+	t.Setenv("DEVRITES_UPDATE_BUNDLE", "")
+	t.Setenv("GOFLAGS", "-buildvcs=true")
+	source := t.TempDir()
+	if err := os.Mkdir(filepath.Join(source, ".git"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	testutil.WriteFile(t, filepath.Join(source, "engine", "go.mod"), "module github.com/devrites/devrites\n\ngo 1.23\n")
+	testutil.WriteFile(t, filepath.Join(source, "engine", "main.go"), "package main\nfunc main() {}\n")
+
+	r := runner{source: source}
+	staged, cleanup, err := r.acquireBinary("v1.2.3", githubBaseURL)
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("acquireBinary with unavailable VCS metadata: %v", err)
+	}
+	if !exists(staged) {
+		t.Fatalf("acquireBinary did not build %s", staged)
+	}
+}
+
+func TestAcquireBinaryPrefersVerifiedReleaseOverStaleHandoff(t *testing.T) {
+	stale := filepath.Join(t.TempDir(), "devrites-engine")
+	testutil.WriteExecutable(t, stale, "#!/bin/sh\nif [ \"$1\" = version ]; then echo v1.2.2; fi\n")
+	t.Setenv("DEVRITES_ENGINE_CLI", stale)
+	t.Setenv("DEVRITES_UPDATE_BUNDLE", "")
+	t.Setenv("DEVRITES_REPO", "owner/repo")
+	tag := "v1.2.3"
+	asset := fmt.Sprintf("devrites-%s-%s", runtime.GOOS, runtime.GOARCH)
+	if runtime.GOOS == "windows" {
+		asset += ".exe"
+	}
+	path := "/owner/repo/releases/download/" + tag + "/" + asset
+	body := []byte("verified release binary")
+	sum := fmt.Sprintf("%x  %s\n", sha256.Sum256(body), asset)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		switch req.URL.Path {
+		case path:
+			_, _ = w.Write(body)
+		case path + ".sha256":
+			_, _ = w.Write([]byte(sum))
+		default:
+			http.NotFound(w, req)
+		}
+	}))
+	defer server.Close()
+
+	r := runner{releaseBinaryTag: tag}
+	staged, cleanup, err := r.acquireBinary(tag, server.URL)
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("acquire verified release binary: %v", err)
+	}
+	got, err := os.ReadFile(staged)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(got, body) {
+		t.Fatalf("acquired binary = %q, want %q", got, body)
+	}
+}
+
+func TestAcquireBinaryRejectsReleaseChecksumMismatch(t *testing.T) {
+	t.Setenv("DEVRITES_ENGINE_CLI", "")
+	t.Setenv("DEVRITES_UPDATE_BUNDLE", "")
+	t.Setenv("DEVRITES_REPO", "owner/repo")
+	tag := "v1.2.3"
+	source := t.TempDir()
+	testutil.WriteFile(t, filepath.Join(source, "engine", "go.mod"), "module github.com/devrites/devrites\n\ngo 1.23\n")
+	testutil.WriteFile(t, filepath.Join(source, "engine", "main.go"), "package main\nfunc main() {}\n")
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		if strings.HasSuffix(req.URL.Path, ".sha256") {
+			_, _ = w.Write([]byte("deadbeef\n"))
+			return
+		}
+		_, _ = w.Write([]byte("tampered release binary"))
+	}))
+	defer server.Close()
+
+	r := runner{source: source, releaseBinaryTag: tag}
+	_, cleanup, err := r.acquireBinary(tag, server.URL)
+	defer cleanup()
+	if err == nil || !strings.Contains(err.Error(), "checksum mismatch") {
+		t.Fatalf("acquireBinary error = %v, want checksum mismatch", err)
+	}
+}
+
+func TestInstallBinaryFailsWhenPreparedUpdateCannotBeWritten(t *testing.T) {
+	prepared := filepath.Join(t.TempDir(), "devrites-engine")
+	testutil.WriteExecutable(t, prepared, "#!/bin/sh\n")
+	blocked := filepath.Join(t.TempDir(), "not-a-directory")
+	testutil.WriteFile(t, blocked, "file\n")
+	t.Setenv("DEVRITES_BIN_DIR", filepath.Join(blocked, "bin"))
+	t.Setenv("DEVRITES_REF", "v1.2.3")
+
+	r := runner{
+		opts:           DefaultOptions(ModeInstall),
+		preparedBinary: prepared,
+	}
+	if err := r.installBinary(); err == nil {
+		t.Fatal("installBinary accepted a prepared update it could not write")
+	}
+}
+
 func TestInstallBinaryWarnsWhenHooksCannotResolveEngine(t *testing.T) {
 	payload := testPayload(t)
 	target := t.TempDir()

package/engine/internal/iohooks/detach_unix.go

@@ -5,7 +5,7 @@ package iohooks
 import "syscall"
 
 // detachSysProcAttr starts the refresh worker in its own session so it outlives the
-// Stop hook that spawned it — the detached-background contract of refresh-indexes.
+// Stop hook that spawned it: the detached-background contract of refresh-indexes.
 func detachSysProcAttr() *syscall.SysProcAttr {
 	return &syscall.SysProcAttr{Setsid: true}
 }

package/engine/internal/iohooks/iohooks.go

@@ -1,6 +1,6 @@
 package iohooks
 
-// IO hooks: the ported bash hooks that do network or process-orchestration IO —
+// IO hooks: the ported bash hooks that do network or process-orchestration IO:
 // the source-citation cache (a conditional-HEAD revalidation cache) and the
 // code-index refresher (a detached background reindex). Unlike the deterministic
 // control-plane hooks these reach the network / spawn processes; they are kept in
@@ -47,7 +47,7 @@ type sourceCacheEntry struct {
 
 func sourceCacheOff() bool { return os.Getenv("DEVRITES_SOURCE_CACHE") == "off" }
 
-// ioProjectDir is the repo root the IO hooks key off — CLAUDE_PROJECT_DIR or CWD,
+// ioProjectDir is the repo root the IO hooks key off: CLAUDE_PROJECT_DIR or CWD,
 // like the shell hooks. (The cache is project-global under .devrites/, not
 // feature-scoped, so it does not use the feature-dir resolver.)
 func ioProjectDir() string {
@@ -61,7 +61,7 @@ func ioProjectDir() string {
 }
 
 // sourceCachePath is the entry path for a URL: .devrites/source-cache/<key>.json,
-// keyed on the first 32 hex chars of sha256(url) — matching the shell hooks.
+// keyed on the first 32 hex chars of sha256(url): matching the shell hooks.
 func sourceCachePath(url string) string {
 	sum := sha256.Sum256([]byte(url))
 	key := hex.EncodeToString(sum[:])[:32]
@@ -69,7 +69,7 @@ func sourceCachePath(url string) string {
 }
 
 // hookSourceCachePre serves a cached page reading ONLY after revalidating it with a
-// conditional HEAD that returns 304 — a fresh verification, not a memory read.
+// conditional HEAD that returns 304: a fresh verification, not a memory read.
 // Ported from devrites-source-cache-pre.sh. Cache hit → the reading on stderr +
 // exit 2 (Claude hands that to the agent in place of the fetch); miss/uncertain →
 // exit 0 (the real WebFetch proceeds). Fail-open on every uncertainty.
@@ -124,7 +124,7 @@ func SourceCachePre(stdin io.Reader, stdout, stderr io.Writer) int {
 		fetched = "a previous fetch"
 	}
 	fmt.Fprintf(stderr, "[devrites-source-cache] Cache hit for %s\n", url)
-	fmt.Fprintf(stderr, "Revalidated via HTTP 304 — the page is unchanged since %s, so this cached reading is still a valid citation.\n", fetched)
+	fmt.Fprintf(stderr, "Revalidated via HTTP 304: the page is unchanged since %s, so this cached reading is still a valid citation.\n", fetched)
 	if e.Prompt != "" {
 		fmt.Fprintf(stderr, "Cached under the prompt: %q. If your angle differs, judge whether this reading still covers it before re-fetching.\n", e.Prompt)
 	}
@@ -135,7 +135,7 @@ func SourceCachePre(stdin io.Reader, stdout, stderr io.Writer) int {
 }
 
 // hookSourceCachePost stores a completed WebFetch keyed on sha256(url) together with
-// the origin's validator headers — but only when the origin supplies a validator
+// the origin's validator headers, but only when the origin supplies a validator
 // (else a later 304 could never prove freshness). Ported from
 // devrites-source-cache-post.sh. Always exit 0.
 func SourceCachePost(stdin io.Reader, stdout, stderr io.Writer) int {
@@ -390,7 +390,7 @@ func computeRefreshState(root string) refreshState {
 }
 
 // repoChangedSince reports whether any tracked file under root is newer than the
-// stamp, skipping the excluded directories — the Go form of the script's `find
+// stamp, skipping the excluded directories: the Go form of the script's `find
 // -newer`. It returns on the first newer file found.
 func repoChangedSince(root, stamp string) bool {
 	info, err := os.Stat(stamp)
@@ -505,7 +505,7 @@ func runIndexTool(out io.Writer, timeout time.Duration, name string, args ...str
 	}
 }
 
-// cbmRegistered reports whether codebase-memory-mcp is installed AND tracks root —
+// cbmRegistered reports whether codebase-memory-mcp is installed AND tracks root:
 // a cheap repo-local marker first, then the project registry.
 func cbmRegistered(root string) bool {
 	if !hasTool("codebase-memory-mcp") {

package/engine/internal/lib/adoption.go

@@ -320,7 +320,7 @@ func Decisions(root string, args []string, stdout, stderr io.Writer) int {
 			}
 		}
 		for _, e := range matches {
-			fmt.Fprintf(stdout, "%s:%d %s — %s\n", e.Path, e.Line, e.Slug, e.Text)
+			fmt.Fprintf(stdout, "%s:%d %s: %s\n", e.Path, e.Line, e.Slug, e.Text)
 		}
 		if len(matches) == 0 {
 			fmt.Fprintln(stdout, "decisions: no matches.")

package/engine/internal/lib/analyze.go

@@ -15,10 +15,10 @@ import (
 // written, so a coverage gap surfaces as a one-line plan edit rather than a reslice
 // mid-build. It emits a markdown report and flags:
 //
-//	Coverage     — a spec AC id that no slice Satisfies                 (CRITICAL)
-//	Consistency  — a slice that Satisfies an AC the spec never defines (CRITICAL)
-//	Orphan slice — a slice that satisfies no acceptance criterion       (warn)
-//	Ambiguity    — an unquantified vague adjective or unresolved
+//	Coverage    : a spec AC id that no slice Satisfies                 (CRITICAL)
+//	Consistency : a slice that Satisfies an AC the spec never defines (CRITICAL)
+//	Orphan slice: a slice that satisfies no acceptance criterion       (warn)
+//	Ambiguity   : an unquantified vague adjective or unresolved
 //	               placeholder in the spec                              (warn)
 //
 // It closes with a Metrics line (criteria count, coverage %, orphan + ambiguity
@@ -69,14 +69,14 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 	covered := 0
 	fmt.Fprintln(stdout, "## Coverage")
 	if len(specACs) == 0 {
-		fmt.Fprintln(stdout, "- [warn] spec.md — no AC-### acceptance ids found; tag criteria for a machine-checkable gate.")
+		fmt.Fprintln(stdout, "- [warn] spec.md: no AC-### acceptance ids found; tag criteria for a machine-checkable gate.")
 	} else {
 		for _, ac := range specACs {
 			if taskSet[ac] {
 				covered++
-				fmt.Fprintf(stdout, "- [ok] %s — covered\n", ac)
+				fmt.Fprintf(stdout, "- [ok] %s: covered\n", ac)
 			} else {
-				fmt.Fprintf(stdout, "- [CRITICAL] %s (spec.md) — no slice Satisfies it (uncovered)\n", ac)
+				fmt.Fprintf(stdout, "- [CRITICAL] %s (spec.md): no slice Satisfies it (uncovered)\n", ac)
 				crit++
 			}
 		}
@@ -88,7 +88,7 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 	if len(taskACs) > 0 {
 		for _, ac := range taskACs {
 			if !specSet[ac] {
-				fmt.Fprintf(stdout, "- [CRITICAL] %s (tasks.md) — referenced by a slice but not defined in spec.md (dangling)\n", ac)
+				fmt.Fprintf(stdout, "- [CRITICAL] %s (tasks.md): referenced by a slice but not defined in spec.md (dangling)\n", ac)
 				crit++
 			}
 		}
@@ -99,7 +99,7 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 	for _, name := range orphanSlices(tasksData) {
 		if name != "" {
 			orphans++
-			fmt.Fprintf(stdout, "- [warn] slice '%s' — satisfies no acceptance criterion (add Satisfies: or justify)\n", name)
+			fmt.Fprintf(stdout, "- [warn] slice '%s': satisfies no acceptance criterion (add Satisfies, or justify)\n", name)
 		}
 	}
 
@@ -127,17 +127,17 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 
 	fmt.Fprintln(stdout)
 	if crit > 0 {
-		fmt.Fprintf(stdout, "## Verdict: BLOCKED — %d CRITICAL finding(s). Resolve before %s.\n", crit, workflow.ForVerb("build").Both())
+		fmt.Fprintf(stdout, "## Verdict: BLOCKED: %d CRITICAL finding(s). Resolve before %s.\n", crit, workflow.ForVerb("build").Both())
 		return 1
 	}
-	fmt.Fprintln(stdout, "## Verdict: clear — spec/tasks consistent and fully mapped.")
+	fmt.Fprintln(stdout, "## Verdict: clear: spec/tasks consistent and fully mapped.")
 	return 0
 }
 
 // ambiguityFindings scans spec text for unfalsifiable criteria: a vague quality
 // adjective (fast, robust, secure …) on a line with no number to pin it down, or an
 // unresolved placeholder (TODO, ???, <placeholder> …). Code fences are skipped. One
-// finding per line — a placeholder takes precedence over an adjective. 1-based lines.
+// finding per line: a placeholder takes precedence over an adjective. 1-based lines.
 func ambiguityFindings(specData []byte) []string {
 	var out []string
 	inFence := false
@@ -151,16 +151,16 @@ func ambiguityFindings(specData []byte) []string {
 		}
 		ln := i + 1
 		if m := placeholderRe.FindString(line); m != "" {
-			out = append(out, fmt.Sprintf("- [warn] spec.md:L%d — unresolved placeholder %q", ln, m))
+			out = append(out, fmt.Sprintf("- [warn] spec.md:L%d: unresolved placeholder %q", ln, m))
 			continue
 		}
-		// Strip the AC id before the digit gate — else the id's own digit masks
+		// Strip the AC id before the digit gate: else the id's own digit masks
 		// a vague adjective on the very criterion line it tags.
 		bare := acIDRe.ReplaceAllString(line, "")
 		bare = taskACRe.ReplaceAllString(bare, "")
 		if !analyzeDigitRe.MatchString(bare) {
 			if m := vagueAdjRe.FindString(bare); m != "" {
-				out = append(out, fmt.Sprintf("- [warn] spec.md:L%d — %q is not quantified; state a measurable target", ln, m))
+				out = append(out, fmt.Sprintf("- [warn] spec.md:L%d: %q is not quantified; state a measurable target", ln, m))
 			}
 		}
 	}

package/engine/internal/lib/archivesearch.go

@@ -10,7 +10,7 @@ import (
 )
 
 // ArchiveSearch surfaces shipped features whose spec.md overlaps a query, so
-// /rite-spec can spot prior art before writing a new spec — an extension, a
+// /rite-spec can spot prior art before writing a new spec: an extension, a
 // conflict, or a re-spec of solved work. It is advisory, not a gate: it always
 // exits 0 when it runs (empty output means no overlap), and reserves exit 2 for
 // a missing query. The query is the feature's key nouns, one or many args; a
@@ -36,7 +36,7 @@ func ArchiveSearch(root string, args []string, stdout, stderr io.Writer) int {
 
 	entries, err := os.ReadDir(filepath.Join(root, "archive"))
 	if err != nil {
-		// No archive yet — no prior art to surface. Silent, successful no-op.
+		// No archive yet: no prior art to surface. Silent, successful no-op.
 		return 0
 	}
 
@@ -80,7 +80,7 @@ func ArchiveSearch(root string, args []string, stdout, stderr io.Writer) int {
 }
 
 // specTitle returns the spec's first Markdown heading, or its first non-empty
-// line, as a one-line label — empty when the spec has neither.
+// line, as a one-line label: empty when the spec has neither.
 func specTitle(b []byte) string {
 	for _, line := range strings.Split(string(b), "\n") {
 		line = strings.TrimSpace(line)

package/engine/internal/lib/budget.go

@@ -10,7 +10,7 @@ import (
 // The context-budget lint. A feature is deliberately a directory of small,
 // single-concern files rather than one long document: each file stays
 // context-cheap to read, and completeness is self-evident from which files
-// exist. That discipline only holds if the files stay small — a spec.md that
+// exist. That discipline only holds if the files stay small: a spec.md that
 // grows to 800 lines is a "sausage" that an agent must load whole, spending the
 // context window it was meant to conserve. Budget measures every workspace file
 // against a per-file line ceiling and flags the overgrown ones.
@@ -107,10 +107,10 @@ func Budget(root string, args []string, stdout, stderr io.Writer) int {
 		return 0
 	}
 	if strict {
-		fmt.Fprintf(stdout, "budget: %d file(s) over the line budget — split or trim them\n", over)
+		fmt.Fprintf(stdout, "budget: %d file(s) over the line budget: split or trim them\n", over)
 		return 3
 	}
-	fmt.Fprintf(stdout, "budget: %d file(s) over the line budget (advisory — pass --strict to fail)\n", over)
+	fmt.Fprintf(stdout, "budget: %d file(s) over the line budget (advisory: pass --strict to fail)\n", over)
 	return 0
 }
 

package/engine/internal/lib/buildreadiness.go

@@ -12,7 +12,7 @@ import (
 )
 
 // BuildReadiness decides whether a feature is ready to build, reading only its
-// recorded state (state.md) — an open HITL question, a blocked plan, or an
+// recorded state (state.md): an open HITL question, a blocked plan, or an
 // unapproved plan each stops the build with a distinct, actionable exit code
 // rather than trusting the model to honour a prose checklist. It never mutates
 // the workspace.
@@ -33,7 +33,7 @@ func BuildReadiness(root string, args []string, stdout, stderr io.Writer) int {
 		if shown == "" {
 			shown = "<unset>"
 		}
-		fmt.Fprintf(stderr, "readiness: no active workspace/state.md (slug=%s) — run %s <feature>\n", shown, workflow.ForVerb("spec").Both())
+		fmt.Fprintf(stderr, "readiness: no active workspace/state.md (slug=%s): run %s <feature>\n", shown, workflow.ForVerb("spec").Both())
 		return 5
 	}
 
@@ -43,16 +43,16 @@ func BuildReadiness(root string, args []string, stdout, stderr io.Writer) int {
 	status := readinessField(lines, "Status")
 	switch status {
 	case "awaiting_human":
-		fmt.Fprintf(stderr, "readiness: STOP — Status: awaiting_human. Resume with %s <qid> \"<answer>\".\n", workflow.ForVerb("resolve").Both())
+		fmt.Fprintf(stderr, "readiness: STOP: Status: awaiting_human. Resume with %s <qid> \"<answer>\".\n", workflow.ForVerb("resolve").Both())
 		return 3
 	case "blocked":
-		fmt.Fprintf(stderr, "readiness: STOP — Status: blocked. Repair with %s repair (or unblock).\n", workflow.ForVerb("plan").Both())
+		fmt.Fprintf(stderr, "readiness: STOP: Status: blocked. Repair with %s repair (or unblock).\n", workflow.ForVerb("plan").Both())
 		return 4
 	}
 
 	approved := readinessField(lines, "Plan approved")
 	if approved == "" || approved == "none" {
-		fmt.Fprintf(stderr, "readiness: STOP — plan not approved (state.md has no \"Plan approved\"). Run %s.\n", workflow.ForVerb("define").Both())
+		fmt.Fprintf(stderr, "readiness: STOP: plan not approved (state.md has no \"Plan approved\"). Run %s.\n", workflow.ForVerb("define").Both())
 		return 2
 	}
 
@@ -60,7 +60,7 @@ func BuildReadiness(root string, args []string, stdout, stderr io.Writer) int {
 	if shownStatus == "" {
 		shownStatus = "running"
 	}
-	fmt.Fprintf(stdout, "readiness: OK — plan approved %s, status %s. Ready to build.\n", approved, shownStatus)
+	fmt.Fprintf(stdout, "readiness: OK: plan approved %s, status %s. Ready to build.\n", approved, shownStatus)
 	return 0
 }
 

package/engine/internal/lib/checkacceptance.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 )
 
-// Executable acceptance criteria — a port of check-acceptance.sh. Grades the
+// Executable acceptance criteria: a port of check-acceptance.sh. Grades the
 // AC-### acceptance criteria in spec.md against seal.md: each spec
 // criterion must be checked ([x]) in seal.md. Without ids it falls back to a
 // count/unchecked heuristic. The spec-time mirror is SpecValidate (shape); this
@@ -41,7 +41,7 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 		return 5
 	}
 	if !isFile(seal) {
-		fmt.Fprintf(stderr, "check-acceptance: no seal.md in %s — feature not sealed\n", ws)
+		fmt.Fprintf(stderr, "check-acceptance: no seal.md in %s: feature not sealed\n", ws)
 		return 5
 	}
 
@@ -57,14 +57,14 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 	}
 
 	if sectionEmpty(specBody) {
-		fmt.Fprintln(stderr, "check-acceptance: spec.md has no \"## Acceptance criteria\" section — nothing to grade")
+		fmt.Fprintln(stderr, "check-acceptance: spec.md has no \"## Acceptance criteria\" section: nothing to grade")
 		return 1
 	}
 
 	specIDs := sortedUniqueIDs(specBody)
 
 	if len(specIDs) > 0 {
-		// ID mode — each spec AC id must be checked ([x]) in seal.md.
+		// ID mode: each spec AC id must be checked ([x]) in seal.md.
 		checkedIDs := map[string]bool{}
 		for _, line := range sealBody {
 			if checkedRe.MatchString(line) {
@@ -85,18 +85,18 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 				total-len(missing), total, " "+strings.Join(missing, " "))
 			return 1
 		}
-		fmt.Fprintf(stdout, "check-acceptance: OK — all %d acceptance criteria (%s) proven + checked in seal.md\n",
+		fmt.Fprintf(stdout, "check-acceptance: OK: all %d acceptance criteria (%s) proven + checked in seal.md\n",
 			total, strings.Join(specIDs, " "))
 		return 0
 	}
 
-	// Fallback (no ids) — count spec criteria vs seal checked/unchecked items.
+	// Fallback (no ids): count spec criteria vs seal checked/unchecked items.
 	specN := countMatching(specBody, bulletRe)
 	sealTotal := countMatching(sealBody, checkboxRe)
 	sealUnchecked := countMatching(sealBody, uncheckedRe)
 
 	if sealTotal < specN {
-		fmt.Fprintf(stderr, "check-acceptance: seal.md lists %d acceptance items but spec.md has %d criteria — %d dropped. (Tag criteria AC-### to grade by id.)\n",
+		fmt.Fprintf(stderr, "check-acceptance: seal.md lists %d acceptance items but spec.md has %d criteria: %d dropped. (Tag criteria AC-### to grade by id.)\n",
 			sealTotal, specN, specN-sealTotal)
 		return 1
 	}
@@ -104,12 +104,12 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "check-acceptance: %d acceptance criterion(s) unchecked in seal.md (unproven). (Tag criteria AC-### to grade by id.)\n", sealUnchecked)
 		return 1
 	}
-	fmt.Fprintf(stdout, "check-acceptance: OK — %d acceptance items all checked in seal.md (no ids; add AC-### for id-level grading)\n", sealTotal)
+	fmt.Fprintf(stdout, "check-acceptance: OK: %d acceptance items all checked in seal.md (no ids; add AC-### for id-level grading)\n", sealTotal)
 	return 0
 }
 
 // acSection returns the body lines under an "## Acceptance Criteria" heading
-// (case-insensitive on the words), up to the next "## " heading — mirroring the
+// (case-insensitive on the words), up to the next "## " heading: mirroring the
 // awk one-liner in check-acceptance.sh.
 func acSection(file string) ([]string, error) {
 	f, err := os.Open(file)
@@ -140,7 +140,7 @@ func acSection(file string) ([]string, error) {
 // sectionEmpty reports whether the acceptance body is empty in the bash sense:
 // awk emits each in-section line with a trailing newline, $() strips the trailing
 // newlines, and `[ -z ]` tests the remainder. A body of only blank lines collapses
-// to "" — so a heading followed by blanks is "nothing to grade", not a fallback.
+// to "", so a heading followed by blanks is "nothing to grade", not a fallback.
 func sectionEmpty(lines []string) bool {
 	return strings.TrimRight(strings.Join(lines, "\n"), "\n") == ""
 }

package/engine/internal/lib/closeout.go

@@ -9,7 +9,7 @@ import (
 
 // CloseOut retires a shipped feature: it moves the feature directory into the
 // archive and, when the feature is still the active one, clears the ACTIVE cursor
-// so the next /rite-spec starts clean. The workspace is relocated, never deleted —
+// so the next /rite-spec starts clean. The workspace is relocated, never deleted:
 // the audit trail is preserved under archive/<slug>.
 //
 // args is `<slug> [devrites-dir]`. The optional second argument overrides the
@@ -18,7 +18,7 @@ import (
 //
 //	0  archived (ACTIVE cleared if it pointed here)
 //	4  no slug given, or the feature has no workspace
-//	5  an archive already exists at the destination — refuse to clobber it
+//	5  an archive already exists at the destination: refuse to clobber it
 func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 	slug := argAt(args, 0)
 	dv := argAt(args, 1)
@@ -41,12 +41,12 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 	// A broken symlink at the destination still counts as "already there", so use
 	// Lstat rather than Stat to avoid silently overwriting it.
 	if _, err := os.Lstat(arch); err == nil {
-		fmt.Fprintf(stderr, "close-out: archive already exists at %s — refusing to clobber\n", arch)
+		fmt.Fprintf(stderr, "close-out: archive already exists at %s: refusing to clobber\n", arch)
 		return 5
 	}
 
 	// Fail closed: if the move does not happen, leave the cursor alone and do not
-	// claim success — a lost audit trail must never look like a clean close-out.
+	// claim success: a lost audit trail must never look like a clean close-out.
 	if err := os.MkdirAll(filepath.Join(dv, "archive"), 0o755); err != nil {
 		fmt.Fprintf(stderr, "close-out: cannot create archive dir: %v\n", err)
 		return 1
@@ -64,6 +64,6 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 			return 0
 		}
 	}
-	fmt.Fprintf(stdout, "close-out: archived %s -> %s (ACTIVE pointed elsewhere — left as-is)\n", slug, filepath.ToSlash(arch))
+	fmt.Fprintf(stdout, "close-out: archived %s -> %s (ACTIVE pointed elsewhere: left as-is)\n", slug, filepath.ToSlash(arch))
 	return 0
 }

package/engine/internal/lib/conventions.go

@@ -162,7 +162,7 @@ func conventionsPromote(args []string, stdout, stderr io.Writer) int {
 	}
 	if !already {
 		e.Corroborations++
-		e.Proofs = append(e.Proofs, fmt.Sprintf("%s %s — %s", slug, conventionDate(date), evidence))
+		e.Proofs = append(e.Proofs, fmt.Sprintf("%s %s: %s", slug, conventionDate(date), evidence))
 	}
 	entries[key] = e
 	if err := saveConventions(root, entries); err != nil {
@@ -202,7 +202,7 @@ func conventionsContradict(args []string, stdout, stderr io.Writer) int {
 	}
 	when := conventionDate(date)
 	e.Contradictions++
-	e.Proofs = append(e.Proofs, fmt.Sprintf("%s %s — CONTRADICTED: %s", slug, when, evidence))
+	e.Proofs = append(e.Proofs, fmt.Sprintf("%s %s: CONTRADICTED: %s", slug, when, evidence))
 	entries[key] = e
 	if err := saveConventions(root, entries); err != nil {
 		fmt.Fprintln(stderr, err)
@@ -240,7 +240,7 @@ func conventionsContradict(args []string, stdout, stderr io.Writer) int {
 			return 1
 		}
 	}
-	fmt.Fprintf(stdout, "DRIFT: convention '%s' contradicted by %s — now %s\n", key, slug, state)
+	fmt.Fprintf(stdout, "DRIFT: convention '%s' contradicted by %s: now %s\n", key, slug, state)
 	return 0
 }
 

package/engine/internal/lib/coverage.go

@@ -49,11 +49,11 @@ func Coverage(root string, args []string, stdout, stderr io.Writer) int {
 
 	specBytes, err := os.ReadFile(filepath.Join(dir, "spec.md"))
 	if err != nil {
-		fmt.Fprintln(stderr, "coverage: no spec.md — nothing to map.")
+		fmt.Fprintln(stderr, "coverage: no spec.md: nothing to map.")
 		return 2
 	}
 
-	// tasks.md / seal.md are optional inputs — a missing one just yields
+	// tasks.md / seal.md are optional inputs: a missing one just yields
 	// UNCOVERED slices / pending proof, never an error.
 	tasks, haveTasks := readFileOK(filepath.Join(dir, "tasks.md"))
 	seal, haveSeal := readFileOK(filepath.Join(dir, "seal.md"))
@@ -69,7 +69,7 @@ func Coverage(root string, args []string, stdout, stderr io.Writer) int {
 			slices = slicesForAC(tasks, ac)
 		}
 		if slices == "" {
-			slices = "— (UNCOVERED)"
+			slices = "(UNCOVERED)"
 		}
 		proven := "pending"
 		if haveSeal && provenInSeal(seal, ac) {
@@ -108,7 +108,7 @@ func acIDs(spec string) []string {
 // slicesForAC returns the `;`-joined slice headers whose `Satisfies:` line names
 // ac, in file order. It reproduces the script's awk exactly, including its two
 // quirks: the current `## Slice …` header persists to the next Satisfies line,
-// and the match is a substring test — so ac "AC1" also matches a slice that
+// and the match is a substring test, so ac "AC1" also matches a slice that
 // satisfies "AC10". Faithful parity requires preserving both.
 func slicesForAC(tasks, ac string) string {
 	var matched []string