devrites 3.2.28 → 4.0.0

package/engine/internal/lib/budget.go

@@ -1,172 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// 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
-// 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.
-//
-// It is advisory by default (exit 0): the ceilings are guidance, and a passing
-// build is never blocked on a long file. Pass --strict to turn an overflow into
-// the standard block exit (3), so a gate or hook can hold on it.
-
-// budgetLimits is the per-file line ceiling for the known workspace files, in the
-// order they are reported. The order is the workflow's reading order (manifest
-// first, then the spec-through-proof arc, then the working and cross-cutting
-// notes), not alphabetical, so the report reads top-to-bottom like the workspace.
-var budgetLimits = []struct {
-	name  string
-	limit int
-}{
-	{"README.md", 120},           // workspace map and read-next table
-	{"index.md", 120},            // workspace map alias
-	{"feature.md", 120},          // legacy workspace map alias
-	{"brief.md", 80},             // objective and bounds
-	{"spec.md", 260},             // product WHAT/WHY and acceptance contract
-	{"ai-spec.md", 160},          // optional AI/LLM annex
-	{"architecture.md", 180},     // technical map
-	{"flows.md", 160},            // useful diagrams only
-	{"plan.md", 220},             // approach and slice strategy
-	{"tasks.md", 280},            // vertical slices
-	{"traceability.md", 220},     // AC/REQ -> slice -> proof matrix
-	{"decisions.md", 200},        // ADR-style decision log
-	{"assumptions.md", 160},      // assumption register
-	{"questions.md", 180},        // human questions and gates
-	{"drift.md", 160},            // spec/plan drift register
-	{"state.md", 120},            // compact cursor
-	{"status.md", 120},           // status checkpoint alias
-	{"evidence.md", 280},         // command/action proof
-	{"proof.md", 280},            // evidence alias
-	{"browser-evidence.md", 220}, // UI/browser proof
-	{"touched-files.md", 160},    // implementation file map
-	{"design-brief.md", 160},     // UI design contract
-	{"handoff.md", 120},          // cold-resume summary
-	{"references.md", 160},       // source pointers
-	{"learnings.md", 200},        // retrospective ledger
-}
-
-// defaultBudget is the ceiling applied to any other *.md file in the workspace
-// that has no explicit budget above.
-const defaultBudget = 200
-
-// Budget lints every present workspace file for a feature against its line
-// ceiling. root is the .devrites directory; the slug defaults to the active
-// feature at <root>/ACTIVE. Args: an optional slug and an optional --strict flag.
-func Budget(root string, args []string, stdout, stderr io.Writer) int {
-	strict := false
-	slug := ""
-	for _, a := range args {
-		switch {
-		case a == "--strict":
-			strict = true
-		case slug == "":
-			slug = a
-		default:
-			fmt.Fprintln(stderr, "usage: devrites-engine budget [slug] [--strict]")
-			return 2
-		}
-	}
-	if slug == "" {
-		slug = activeSlug(root)
-	}
-	if slug == "" {
-		fmt.Fprintln(stderr, "budget: no active feature (set one via ACTIVE or pass a slug)")
-		return 2
-	}
-	dir := featureDir(root, slug)
-	if !isDir(dir) {
-		fmt.Fprintf(stderr, "budget: no such feature: %s\n", slug)
-		return 2
-	}
-
-	rows := collectBudgetRows(dir)
-
-	fmt.Fprintf(stdout, "budget: %s\n", slug)
-	over := 0
-	for _, r := range rows {
-		status := "ok"
-		if r.lines > r.limit {
-			status = fmt.Sprintf("OVER by %d", r.lines-r.limit)
-			over++
-		}
-		fmt.Fprintf(stdout, "  %-14s %5d lines  ~%5d tok  limit %4d  %s\n",
-			r.name, r.lines, r.tokens, r.limit, status)
-	}
-
-	if over == 0 {
-		fmt.Fprintf(stdout, "budget: all %d file(s) within budget\n", len(rows))
-		return 0
-	}
-	if strict {
-		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)
-	return 0
-}
-
-// budgetRow is one measured file in the report.
-type budgetRow struct {
-	name   string
-	lines  int
-	tokens int
-	limit  int
-}
-
-// collectBudgetRows measures every present workspace file: the known files (in
-// canonical reading order) followed by any other *.md file (sorted), so the
-// output is a deterministic function of the directory contents.
-func collectBudgetRows(dir string) []budgetRow {
-	known := make(map[string]bool, len(budgetLimits))
-	var rows []budgetRow
-	for _, b := range budgetLimits {
-		known[b.name] = true
-		if lines, tokens, ok := measureFile(filepath.Join(dir, b.name)); ok {
-			rows = append(rows, budgetRow{b.name, lines, tokens, b.limit})
-		}
-	}
-	// Any other Markdown file in the workspace gets the default ceiling. feature.md
-	// et al. are already covered above; a stray notes.md is measured too so nothing
-	// grows unmeasured.
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return rows
-	}
-	var extras []string
-	for _, e := range entries {
-		name := e.Name()
-		if e.IsDir() || known[name] || filepath.Ext(name) != ".md" {
-			continue
-		}
-		extras = append(extras, name)
-	}
-	for _, name := range extras {
-		if lines, tokens, ok := measureFile(filepath.Join(dir, name)); ok {
-			rows = append(rows, budgetRow{name, lines, tokens, defaultBudget})
-		}
-	}
-	return rows
-}
-
-// measureFile returns a file's line count and an approximate token count
-// (bytes/4, the standard rough English heuristic), or ok=false if it cannot be
-// read. Lines count text records, ignoring a single trailing newline, so a
-// newline-terminated N-line file measures N, not N+1.
-func measureFile(path string) (lines, tokens int, ok bool) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return 0, 0, false
-	}
-	lines = len(splitLinesNoTrailing(data))
-	tokens = (len(data) + 3) / 4
-	return lines, tokens, true
-}

package/engine/internal/lib/buildreadiness.go

@@ -1,111 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"regexp"
-	"strings"
-
-	"github.com/devrites/devrites/internal/state"
-	"github.com/devrites/devrites/internal/workflow"
-)
-
-// BuildReadiness decides whether a feature is ready to build from its recorded
-// state plus the upstream readiness artifacts. An open HITL question, a
-// blocked or unapproved plan, incomplete decision coverage, or an unvetted 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.
-//
-// The command is `build-readiness` (the plain `readiness` name is the separate
-// completeness gate), but its messages keep the `readiness:` prefix. Stable exit
-// reasons and remediation verbs are owned by readiness_contract.json.
-func BuildReadiness(root string, args []string, stdout, stderr io.Writer) int {
-	slug := slugOrActive(root, args)
-	s := featureFile(root, slug, "state.md")
-	if slug == "" || !isFile(s) {
-		shown := slug
-		if shown == "" {
-			shown = "<unset>"
-		}
-		fmt.Fprintf(stderr, "readiness: no active workspace/state.md (slug=%s): run %s <feature>\n", shown, workflow.ForVerb("spec").Both())
-		return readinessCode("workspace-missing")
-	}
-
-	data, err := os.ReadFile(s)
-	if err != nil {
-		fmt.Fprintf(stderr, "readiness: cannot read state.md: %v\n", err)
-		return readinessCode("workspace-missing")
-	}
-	lines := splitLinesNoTrailing(data)
-
-	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())
-		return readinessCode("awaiting-human")
-	case "blocked":
-		fmt.Fprintf(stderr, "readiness: STOP: Status: blocked. Repair with %s repair (or unblock).\n", workflow.ForVerb("plan").Both())
-		return readinessCode("plan-blocked")
-	}
-
-	// Lifecycle order matters: clarification owns written-spec decision gaps.
-	// Check it before plan approval so a workspace missing both does not bounce
-	// through define merely to be sent back to clarify.
-	if err := validateDecisionCoverage(root, slug); err != nil {
-		fmt.Fprintf(stderr, "readiness: STOP: decision coverage is not buildable (%v). Run %s.\n", err, workflow.ForVerb("clarify").Both())
-		return readinessCode("coverage-not-clear")
-	}
-	if err := validateArtifactContract(root, slug, readinessContract.Coverage); err != nil {
-		fmt.Fprintf(stderr, "readiness: STOP: planning artifacts need a semantic upgrade (%v). Run %s.\n", err, workflow.ForVerb("upgrade").Both())
-		return readinessCode("upgrade-required")
-	}
-
-	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())
-		return readinessCode("plan-unapproved")
-	}
-
-	phase := strings.ToLower(strings.TrimSpace(readinessField(lines, "Phase")))
-	if fields := strings.Fields(phase); len(fields) > 0 {
-		phase = fields[0]
-	}
-	if phase != string(state.PhaseVet) && phase != string(state.PhaseBuild) {
-		fmt.Fprintf(stderr, "readiness: STOP: plan is not in a vetted/build phase. Run %s.\n", workflow.ForVerb("vet").Both())
-		return readinessCode("engineering-not-ready")
-	}
-
-	if err := validateEngineeringReadiness(root, slug); err != nil {
-		fmt.Fprintf(stderr, "readiness: STOP: implementation readiness is not buildable (%v). Run %s.\n", err, workflow.ForVerb("vet").Both())
-		return readinessCode("engineering-not-ready")
-	}
-	if err := validateArtifactContract(root, slug, readinessContract.TestPlan, readinessContract.Engineering); err != nil {
-		fmt.Fprintf(stderr, "readiness: STOP: planning artifacts need a semantic upgrade (%v). Run %s.\n", err, workflow.ForVerb("upgrade").Both())
-		return readinessCode("upgrade-required")
-	}
-
-	shownStatus := status
-	if shownStatus == "" {
-		shownStatus = "running"
-	}
-	fmt.Fprintf(stdout, "readiness: OK: plan approved %s, decision coverage CLEAR, implementation READY, status %s. Ready to build.\n", approved, shownStatus)
-	return readinessCode("ready")
-}
-
-// fieldAnnotation trims a trailing " # comment" or " | none" annotation off a
-// state.md field value.
-var fieldAnnotation = regexp.MustCompile(`[[:space:]]*(#|\|).*$`)
-
-// readinessField reads canonical cursor tables and legacy bullet fields, then
-// trims the legacy trailing annotations accepted by the original command.
-func readinessField(lines []string, key string) string {
-	value, ok := state.CursorField(lines, key)
-	if !ok {
-		return ""
-	}
-	if m := fieldAnnotation.FindStringIndex(value); m != nil {
-		value = value[:m[0]]
-	}
-	return strings.TrimRight(value, spaceChars)
-}

package/engine/internal/lib/checkacceptance.go

@@ -1,176 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// 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
-// grades proof. Legacy [ACn] ids remain supported for existing workspaces.
-//
-// Exit codes: 0 every criterion proven · 1 gap (uncovered/unproven) · 2 usage ·
-// 5 missing spec.md or seal.md.
-var (
-	acHeadingRe = regexp.MustCompile(`^##[[:space:]]+[Aa]cceptance [Cc]riteria`)
-	h2Re        = regexp.MustCompile(`^##[[:space:]]`)
-	acIDRe      = regexp.MustCompile(`\[AC[0-9]+\]|\bAC-[0-9]{3}\b`)
-	checkedRe   = regexp.MustCompile(`^[[:space:]]*-[[:space:]]*\[[xX]\]`)
-	bulletRe    = regexp.MustCompile(`^[[:space:]]*-[[:space:]]`)
-	checkboxRe  = regexp.MustCompile(`^[[:space:]]*-[[:space:]]*\[[ xX]\]`)
-	uncheckedRe = regexp.MustCompile(`^[[:space:]]*-[[:space:]]*\[[[:space:]]\]`)
-)
-
-// CheckAcceptance grades the acceptance criteria of the workspace dir `ws`. It
-// writes to stdout/stderr and returns the process exit code.
-func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
-	if ws == "" || !isDir(ws) {
-		fmt.Fprintln(stderr, "usage: devrites-engine check-acceptance <workspace-dir>")
-		return 2
-	}
-	spec := ws + "/spec.md"
-	seal := ws + "/seal.md"
-	if !isFile(spec) {
-		fmt.Fprintf(stderr, "check-acceptance: no spec.md in %s\n", ws)
-		return 5
-	}
-	if !isFile(seal) {
-		fmt.Fprintf(stderr, "check-acceptance: no seal.md in %s: feature not sealed\n", ws)
-		return 5
-	}
-
-	specBody, err := acSection(spec)
-	if err != nil {
-		fmt.Fprintf(stderr, "check-acceptance: %v\n", err)
-		return 2
-	}
-	sealBody, err := acSection(seal)
-	if err != nil {
-		fmt.Fprintf(stderr, "check-acceptance: %v\n", err)
-		return 2
-	}
-
-	if sectionEmpty(specBody) {
-		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.
-		checkedIDs := map[string]bool{}
-		for _, line := range sealBody {
-			if checkedRe.MatchString(line) {
-				for _, id := range acIDRe.FindAllString(line, -1) {
-					checkedIDs[id] = true
-				}
-			}
-		}
-		var missing []string
-		for _, id := range specIDs {
-			if !checkedIDs[id] {
-				missing = append(missing, id)
-			}
-		}
-		total := len(specIDs)
-		if len(missing) > 0 {
-			fmt.Fprintf(stderr, "check-acceptance: %d/%d criteria proven; UNPROVEN/UNCOVERED:%s (must be checked [x] in seal.md)\n",
-				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",
-			total, strings.Join(specIDs, " "))
-		return 0
-	}
-
-	// 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",
-			sealTotal, specN, specN-sealTotal)
-		return 1
-	}
-	if sealUnchecked > 0 {
-		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)
-	return 0
-}
-
-// acSection returns the body lines under an "## Acceptance Criteria" heading
-// (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)
-	if err != nil {
-		return nil, fmt.Errorf("read acceptance section: %w", err)
-	}
-	defer f.Close()
-
-	var body []string
-	in := false
-	sc := newLineScanner(f)
-	for sc.Scan() {
-		line := sc.Text()
-		if acHeadingRe.MatchString(line) {
-			in = true
-			continue // the heading itself is not body (awk's `next`)
-		}
-		if h2Re.MatchString(line) {
-			in = false
-		}
-		if in {
-			body = append(body, line)
-		}
-	}
-	return body, sc.Err()
-}
-
-// 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.
-func sectionEmpty(lines []string) bool {
-	return strings.TrimRight(strings.Join(lines, "\n"), "\n") == ""
-}
-
-// sortedUniqueIDs extracts canonical AC-### and legacy [ACn] ids from the lines,
-// then returns them sorted and de-duplicated.
-func sortedUniqueIDs(lines []string) []string {
-	set := map[string]bool{}
-	for _, line := range lines {
-		for _, id := range acIDRe.FindAllString(line, -1) {
-			set[id] = true
-		}
-	}
-	if len(set) == 0 {
-		return nil
-	}
-	ids := make([]string, 0, len(set))
-	for id := range set {
-		ids = append(ids, id)
-	}
-	sort.Strings(ids) // byte order == `sort` under LC_ALL=C
-	return ids
-}
-
-func countMatching(lines []string, re *regexp.Regexp) int {
-	n := 0
-	for _, line := range lines {
-		if re.MatchString(line) {
-			n++
-		}
-	}
-	return n
-}

package/engine/internal/lib/clarifyreturn.go

@@ -1,91 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/devrites/devrites/internal/fsutil"
-	"github.com/devrites/devrites/internal/state"
-	"github.com/devrites/devrites/internal/workflow"
-)
-
-// ClarifyReturn persists and restores the later-phase cursor when an existing
-// workspace is routed back through clarification.
-//
-//	clarify-return enter [slug]
-//	clarify-return restore [slug]
-func ClarifyReturn(root string, args []string, stdout, stderr io.Writer) int {
-	if len(args) < 1 || len(args) > 2 {
-		fmt.Fprintln(stderr, "usage: devrites-engine clarify-return <enter|restore> [slug]")
-		return 2
-	}
-	sub := strings.ToLower(strings.TrimSpace(args[0]))
-	slug := slugOrActive(root, args[1:])
-	if slug == "" {
-		fmt.Fprintln(stderr, "clarify-return: no active workspace")
-		return 2
-	}
-	path := featureFile(root, slug, "state.md")
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		fmt.Fprintf(stderr, "clarify-return: read state.md: %v\n", err)
-		return 2
-	}
-	lines := splitLinesNoTrailing(raw)
-
-	switch sub {
-	case "enter":
-		return changeClarifyReturn(path, lines, state.ClarifyEnter, stdout, stderr)
-	case "restore":
-		if err := validateDecisionCoverage(root, slug); err != nil {
-			fmt.Fprintf(stderr, "clarify-return: decision coverage is not CLEAR/fresh: %v\n", err)
-			return 3
-		}
-		return changeClarifyReturn(path, lines, state.ClarifyRestore, stdout, stderr)
-	default:
-		fmt.Fprintf(stderr, "clarify-return: unknown subcommand %q\n", sub)
-		return 2
-	}
-}
-
-func changeClarifyReturn(path string, lines []string, intent state.ClarifyIntent, stdout, stderr io.Writer) int {
-	current, err := state.ParseClarifyCursor(lines)
-	if err != nil {
-		fmt.Fprintf(stderr, "clarify-return: %v\n", err)
-		return 2
-	}
-	resumePhase := current.Phase
-	if intent == state.ClarifyRestore && current.HasReturn {
-		resumePhase = current.ReturnPhase
-	}
-	next, err := state.NextClarifyCursor(intent, state.ClarifyTransitionInput{
-		Cursor:                  current,
-		ClarifyNextAction:       workflow.ForVerb("clarify").Both(),
-		DefaultReturnNextAction: workflow.ForVerb(state.ResumeVerb(resumePhase)).Both(),
-	})
-	if err != nil {
-		fmt.Fprintf(stderr, "clarify-return: %v\n", err)
-		return 2
-	}
-	if next == current {
-		if intent == state.ClarifyEnter {
-			fmt.Fprintln(stdout, "clarify-return: already in clarify; preserved existing return cursor")
-		} else {
-			fmt.Fprintln(stdout, "clarify-return: no later-phase return cursor")
-		}
-		return 0
-	}
-	lines = state.ApplyClarifyCursor(lines, next)
-	if err := fsutil.WriteFileAtomic(path, joinRecords(lines), 0o644); err != nil {
-		fmt.Fprintf(stderr, "clarify-return: update state.md: %v\n", err)
-		return 1
-	}
-	if intent == state.ClarifyEnter {
-		fmt.Fprintf(stdout, "clarify-return: saved %s and entered clarify\n", current.Phase)
-	} else {
-		fmt.Fprintf(stdout, "clarify-return: restored %s\n", next.Phase)
-	}
-	return 0
-}

package/engine/internal/lib/clarifyreturn_test.go

@@ -1,123 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/state"
-)
-
-func TestClarifyReturnSurvivesResolveAndRestoresLaterPhase(t *testing.T) {
-	root := t.TempDir()
-	slug := "retrofit"
-	writeReadinessFile(t, root, slug, "state.md", `# State
-
-## Cursor
-| Key | Value |
-| --- | --- |
-| phase | build |
-| status | running |
-| next_action | /rite-build |
-`)
-	if err := os.WriteFile(filepath.Join(root, "ACTIVE"), []byte(slug+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	var stdout, stderr bytes.Buffer
-	if code := ClarifyReturn(root, []string{"enter", slug}, &stdout, &stderr); code != 0 {
-		t.Fatalf("enter code=%d stderr=%q", code, stderr.String())
-	}
-	lines := readStateLines(t, root, slug)
-	assertCursor(t, lines, state.CursorPhase, "clarify")
-	assertCursor(t, lines, state.CursorReturnPhase, "build")
-	assertCursor(t, lines, state.CursorReturnNextAction, "/rite-build")
-
-	writeReadinessFile(t, root, slug, "questions.md", `# Questions
-
-## q-2026-07-23-001
-status: open
-gate: blocking
-question: choose behavior
-`)
-	statePath := filepath.Join(root, "work", slug, "state.md")
-	stateRaw, err := os.ReadFile(statePath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	waiting := strings.Replace(string(stateRaw), "| status | running |", "| status | awaiting_human |", 1) + `
-## Awaiting human
-| Key | Value |
-| --- | --- |
-| question_id | q-2026-07-23-001 |
-| gate | blocking |
-`
-	if err := os.WriteFile(statePath, []byte(waiting), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if code := Resolve(root, []string{"q-2026-07-23-001", "decided"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("resolve code=%d stderr=%q", code, stderr.String())
-	}
-	lines = readStateLines(t, root, slug)
-	assertCursor(t, lines, state.CursorPhase, "clarify")
-	next, _ := state.CursorField(lines, state.CursorNextAction)
-	if !strings.Contains(next, "rite-clarify") || strings.Contains(next, "rite-build") {
-		t.Fatalf("resolve next_action=%q, want clarify", next)
-	}
-
-	writeReadinessFile(t, root, slug, "brief.md", "# Brief\n\nOutcome.\n")
-	writeReadinessFile(t, root, slug, "spec.md", "# Spec\n\n## Acceptance criteria\n- AC-001 succeeds.\n")
-	writeReadinessFile(t, root, slug, "decisions.md", "# Decisions\n\nThe resolved answer is reflected in the spec.\n")
-	writeReadinessFile(t, root, slug, "assumptions.md", "# Assumptions\n\nNone material.\n")
-	digest, err := readinessInputsDigest(root, slug, readinessContract.Coverage.Inputs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	writeReadinessFile(t, root, slug, "decision-coverage.md", validCoverage(digest))
-
-	stdout.Reset()
-	stderr.Reset()
-	if code := ClarifyReturn(root, []string{"restore", slug}, &stdout, &stderr); code != 0 {
-		t.Fatalf("restore code=%d stderr=%q", code, stderr.String())
-	}
-	lines = readStateLines(t, root, slug)
-	assertCursor(t, lines, state.CursorPhase, "build")
-	assertCursor(t, lines, state.CursorNextAction, "/rite-build")
-	if _, ok := state.CursorField(lines, state.CursorReturnPhase); ok {
-		t.Fatalf("return phase was not cleared:\n%s", strings.Join(lines, "\n"))
-	}
-}
-
-func TestClarifyReturnRefusesRestoreBeforeFreshClear(t *testing.T) {
-	root := t.TempDir()
-	slug := "unclear"
-	writeReadinessFile(t, root, slug, "state.md", "- Phase: build\n- Status: running\n- Next step: /rite-build\n")
-	if code := ClarifyReturn(root, []string{"enter", slug}, &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {
-		t.Fatalf("enter code=%d", code)
-	}
-	if code := ClarifyReturn(root, []string{"restore", slug}, &bytes.Buffer{}, &bytes.Buffer{}); code != 3 {
-		t.Fatalf("restore code=%d, want 3 before CLEAR", code)
-	}
-}
-
-func readStateLines(t *testing.T, root, slug string) []string {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join(root, "work", slug, "state.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	return strings.Split(string(raw), "\n")
-}
-
-func assertCursor(t *testing.T, lines []string, key, want string) {
-	t.Helper()
-	got, ok := state.CursorField(lines, key)
-	if !ok || got != want {
-		t.Fatalf("%s=(%q,%v), want %q\n%s", key, got, ok, want, strings.Join(lines, "\n"))
-	}
-}

package/engine/internal/lib/command_other.go

@@ -1,7 +0,0 @@
-//go:build !unix
-
-package lib
-
-import "os/exec"
-
-func configureBoundedCommand(_ *exec.Cmd) {}