devrites 3.2.27 → 4.0.0

package/engine/internal/lib/cursor_compat_test.go

@@ -1,11 +1,12 @@
 package lib
 
 import (
-	"bytes"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/devrites/devrites/internal/state"
 )
 
 const canonicalCursor = `# State
@@ -20,55 +21,17 @@ const canonicalCursor = `# State
 | afk_slices_remaining | 2 |
 `
 
-func TestCanonicalCursorReadAndWriteConsumers(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "work", "demo")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	statePath := filepath.Join(dir, "state.md")
-	if err := os.WriteFile(statePath, []byte(canonicalCursor), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	t.Run("build readiness", func(t *testing.T) {
-		readyState := strings.Replace(canonicalCursor, "| phase | temper |", "| phase | vet |", 1)
-		if err := os.WriteFile(statePath, []byte(readyState), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		writeValidReadinessArtifacts(t, root, "demo")
-		var stdout, stderr bytes.Buffer
-		if code := BuildReadiness(root, []string{"demo"}, &stdout, &stderr); code != 0 {
-			t.Fatalf("code=%d, stderr=%s", code, stderr.String())
-		}
-		if err := os.WriteFile(statePath, []byte(canonicalCursor), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	t.Run("progress", func(t *testing.T) {
-		var stdout bytes.Buffer
-		if code := Progress(root, []string{"demo"}, &stdout, &bytes.Buffer{}); code != 0 {
-			t.Fatalf("code=%d", code)
-		}
-		if !strings.Contains(stdout.String(), "rite-temper") || !strings.Contains(stdout.String(), "temper ◉") {
-			t.Fatalf("progress ignored table phase:\n%s", stdout.String())
-		}
-	})
-
-	t.Run("tick AFK", func(t *testing.T) {
-		var stdout, stderr bytes.Buffer
-		if code := TickAfk([]string{statePath}, &stdout, &stderr); code != 0 {
-			t.Fatalf("code=%d, stderr=%s", code, stderr.String())
-		}
-		raw, err := os.ReadFile(statePath)
-		if err != nil {
-			t.Fatal(err)
+func TestOfficialBulletCursorAndKeyAliasesRemainReadable(t *testing.T) {
+	lines := strings.Split("- Phase: build\n- Next step: continue\n- qid: Q-001\n", "\n")
+	for key, want := range map[string]string{
+		state.CursorPhase:      "build",
+		state.CursorNextAction: "continue",
+		state.CursorQuestionID: "Q-001",
+	} {
+		if got, ok := state.CursorField(lines, key); !ok || got != want {
+			t.Fatalf("CursorField(%q)=(%q,%v), want %q", key, got, ok, want)
 		}
-		if !strings.Contains(string(raw), "| afk_slices_remaining | 1 |") {
-			t.Fatalf("tick AFK did not preserve/update table:\n%s", raw)
-		}
-	})
+	}
 }
 
 func TestClearAwaitingSupportsCanonicalCursor(t *testing.T) {
@@ -100,29 +63,3 @@ func TestClearAwaitingSupportsCanonicalCursor(t *testing.T) {
 		t.Fatalf("canonical awaiting state resumed the wrong phase:\n%s", text)
 	}
 }
-
-func TestProgressReadsCanonicalSlicesAndShowsPlanPhase(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "work", "demo")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	stateText := strings.Replace(canonicalCursor, "| phase | temper |", "| phase | plan |", 1)
-	stateText = strings.Replace(stateText, "| afk_slices_remaining | 2 |", "| active_slice | SLICE-002 |", 1)
-	if err := os.WriteFile(filepath.Join(dir, "state.md"), []byte(stateText), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	tasks := "## SLICE-001 First\nStatus: built\n\n## SLICE-002 Second\nStatus: pending\n"
-	if err := os.WriteFile(filepath.Join(dir, "tasks.md"), []byte(tasks), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	var stdout bytes.Buffer
-	if code := Progress(root, []string{"demo"}, &stdout, &bytes.Buffer{}); code != 0 {
-		t.Fatalf("code=%d", code)
-	}
-	text := stdout.String()
-	if !strings.Contains(text, "Slice 1/2") || !strings.Contains(text, "plan ◉") || strings.Contains(text, "build ◉") {
-		t.Fatalf("progress missed canonical slice/plan state:\n%s", text)
-	}
-}

package/engine/internal/lib/evidencefresh.go

@@ -1,31 +1,18 @@
 package lib
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
-	"regexp"
+	"strings"
 
-	"github.com/devrites/devrites/internal/fsutil"
 	"github.com/devrites/devrites/internal/workflow"
 )
 
-// touchedPathRe captures each `backtick-quoted` path listed in touched-files.md.
-var touchedPathRe = regexp.MustCompile("`([^`]+)`")
-
-// EvidenceFresh reports whether a feature's proof still post-dates the code it
-// proves. It compares the newest modification time among the touched files (the
-// backtick-quoted paths in touched-files.md that still exist) against the proof
-// (evidence.md / proof.md / browser-evidence.md); if any touched file is newer, the proof
-// is stale and must be regenerated before a GO decision.
-//
-// base is the project directory that contains the .devrites tree. slug defaults
-// to the active feature named in .devrites/ACTIVE.
-//
-//	0  fresh: the proof post-dates every touched file, or there is nothing to compare
-//	3  stale: a touched file is newer than the proof
-//	5  no workspace, or no proof to check
+// EvidenceFresh verifies that proof, review, and Seal bind the current candidate.
+// The call surface is retained for the final Seal aggregate.
 func EvidenceFresh(root string, args []string, stdout, stderr io.Writer) int {
 	slug := ""
 	if len(args) > 0 {
@@ -34,7 +21,6 @@ func EvidenceFresh(root string, args []string, stdout, stderr io.Writer) int {
 	if slug == "" {
 		slug = activeSlug(root)
 	}
-
 	workDir := featureDir(root, slug)
 	if slug == "" || !isDir(workDir) {
 		name := slug
@@ -45,41 +31,66 @@ func EvidenceFresh(root string, args []string, stdout, stderr io.Writer) int {
 		return 5
 	}
 
-	newestProof, haveProof := fsutil.NewestModTime(
-		filepath.Join(workDir, "evidence.md"),
-		filepath.Join(workDir, "proof.md"),
-		filepath.Join(workDir, "browser-evidence.md"),
-	)
-	if !haveProof {
-		fmt.Fprintf(stderr, "evidence-fresh: no evidence.md / proof.md / browser-evidence.md in %s: run %s\n", workDir, workflow.ForVerb("prove").Both())
-		return 5
+	identity, err := loadCandidateIdentity(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "evidence-fresh: BLOCKED: %v. Refresh the candidate and re-run %s.\n", err, workflow.ForVerb("prove").Both())
+		return 3
 	}
+	artifacts := []string{"evidence.md", "review.md", "seal.md"}
+	browser := filepath.Join(workDir, "browser-evidence.md")
+	if _, err := os.Lstat(browser); err == nil {
+		artifacts = append(artifacts, "browser-evidence.md")
+	} else if !os.IsNotExist(err) {
+		fmt.Fprintf(stderr, "evidence-fresh: BLOCKED: inspect browser-evidence.md: %v\n", err)
+		return 3
+	}
+	for _, name := range artifacts {
+		if err := requireCandidateDigest(filepath.Join(workDir, name), identity.digest); err != nil {
+			fmt.Fprintf(stderr, "evidence-fresh: BLOCKED: %s: %v. Record exactly one current candidate digest and retry.\n", name, err)
+			return 3
+		}
+	}
+	fmt.Fprintf(stdout, "evidence-fresh: OK: candidate digest %s matches evidence, review, and seal.\n", identity.digest)
+	return 0
+}
 
-	touched, err := os.ReadFile(filepath.Join(workDir, "touched-files.md"))
+func requireCandidateDigest(name, want string) error {
+	content, err := readBoundedRegularFile(name, maxCandidateArtifactBytes)
 	if err != nil {
-		fmt.Fprintln(stdout, "evidence-fresh: no touched-files.md: nothing to compare (treating as fresh).")
-		return 0
+		return err
 	}
-
-	var newestCode int64
-	var newestPath string
-	for _, match := range touchedPathRe.FindAllStringSubmatch(string(touched), -1) {
-		listed := match[1]
-		// touched-files.md lists PROJECT-relative paths; the project directory is
-		// the parent of the .devrites root. An absolute path is taken as given.
-		path := listed
-		if !filepath.IsAbs(path) {
-			path = filepath.Join(filepath.Dir(root), path)
-		}
-		if m, ok := fsutil.FileModTime(path); ok && m > newestCode {
-			newestCode, newestPath = m, listed
+	var tagged []string
+	for _, line := range strings.Split(strings.ReplaceAll(string(content), "\r\n", "\n"), "\n") {
+		if strings.Contains(line, "Candidate SHA-256:") {
+			tagged = append(tagged, line)
 		}
 	}
+	switch len(tagged) {
+	case 0:
+		return errors.New("candidate digest line is missing")
+	case 1:
+	default:
+		return errors.New("candidate digest line is duplicate")
+	}
+	const prefix = "Candidate SHA-256: "
+	line := tagged[0]
+	if !strings.HasPrefix(line, prefix) || len(line) != len(prefix)+64 || !lowerHexDigest(line[len(prefix):]) {
+		return errors.New("candidate digest line is malformed")
+	}
+	if line[len(prefix):] != want {
+		return errors.New("candidate digest line does not match current candidate digest")
+	}
+	return nil
+}
 
-	if newestCode > newestProof {
-		fmt.Fprintf(stderr, "evidence-fresh: STALE: %s is newer than the proof. Re-run %s before GO.\n", newestPath, workflow.ForVerb("prove").Both())
-		return 3
+func lowerHexDigest(value string) bool {
+	if len(value) != 64 {
+		return false
 	}
-	fmt.Fprintln(stdout, "evidence-fresh: OK: evidence post-dates every touched file.")
-	return 0
+	for _, char := range value {
+		if (char < '0' || char > '9') && (char < 'a' || char > 'f') {
+			return false
+		}
+	}
+	return true
 }

package/engine/internal/lib/evidencefresh_test.go

@@ -0,0 +1,120 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func writeBoundCandidateWorkspace(t *testing.T, browser bool) (project, root, digest string) {
+	t.Helper()
+	project, root = writeCandidateTestWorkspace(t, candidateTestManifest(candidateTestRow{state: "present", path: "source.go", slice: "S-1", reason: "Implementation."}))
+	writeCandidateTestFile(t, project, "source.go", "package source\n")
+	digest, _, err := CandidateIdentity(root, "feature")
+	if err != nil {
+		t.Fatal(err)
+	}
+	line := "Candidate SHA-256: " + digest + "\n"
+	workspace := filepath.Join(root, "work", "feature")
+	for _, name := range []string{"evidence.md", "review.md", "seal.md"} {
+		if err := os.WriteFile(filepath.Join(workspace, name), []byte("# Artifact\n\n"+line), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if browser {
+		if err := os.WriteFile(filepath.Join(workspace, "browser-evidence.md"), []byte("# Browser evidence\n\n"+line), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return project, root, digest
+}
+
+func runEvidenceFresh(t *testing.T, root string) (int, string, string) {
+	t.Helper()
+	var stdout, stderr bytes.Buffer
+	code := EvidenceFresh(root, []string{"feature"}, &stdout, &stderr)
+	return code, stdout.String(), stderr.String()
+}
+
+func TestEvidenceFreshUsesCandidateContentNotMtime(t *testing.T) {
+	project, root, _ := writeBoundCandidateWorkspace(t, false)
+	path := filepath.Join(project, "source.go")
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chtimes(path, time.Unix(2_000_000_000, 0), time.Unix(2_000_000_000, 0)); err != nil {
+		t.Fatal(err)
+	}
+	if code, stdout, stderr := runEvidenceFresh(t, root); code != 0 || !strings.Contains(stdout, "evidence-fresh: OK") {
+		t.Fatalf("unchanged touch: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+	}
+
+	writeCandidateTestFile(t, project, "source.go", "package changed\n")
+	if err := os.Chtimes(path, info.ModTime(), info.ModTime()); err != nil {
+		t.Fatal(err)
+	}
+	if code, stdout, stderr := runEvidenceFresh(t, root); code == 0 || !strings.Contains(stderr, "candidate digest") {
+		t.Fatalf("restored-mtime change: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+	}
+}
+
+func TestEvidenceFreshRequiresOneExactMatchingDigestLine(t *testing.T) {
+	tests := []struct {
+		name string
+		body func(string) string
+		want string
+	}{
+		{name: "missing", body: func(string) string { return "# Evidence\n\nNo binding.\n" }, want: "missing"},
+		{name: "duplicate", body: func(digest string) string {
+			return "Candidate SHA-256: " + digest + "\nCandidate SHA-256: " + digest + "\n"
+		}, want: "duplicate"},
+		{name: "malformed", body: func(string) string { return "Candidate SHA-256: ABCD\n" }, want: "malformed"},
+		{name: "mismatch", body: func(string) string { return "Candidate SHA-256: " + strings.Repeat("0", 64) + "\n" }, want: "does not match"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, root, digest := writeBoundCandidateWorkspace(t, false)
+			path := filepath.Join(root, "work", "feature", "evidence.md")
+			if err := os.WriteFile(path, []byte(test.body(digest)), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			code, stdout, stderr := runEvidenceFresh(t, root)
+			if code == 0 || stdout != "" || !strings.Contains(stderr, test.want) {
+				t.Fatalf("code=%d stdout=%q stderr=%q, want %q", code, stdout, stderr, test.want)
+			}
+		})
+	}
+}
+
+func TestEvidenceFreshRequiresOptionalBrowserBinding(t *testing.T) {
+	_, root, digest := writeBoundCandidateWorkspace(t, true)
+	path := filepath.Join(root, "work", "feature", "browser-evidence.md")
+	if err := os.WriteFile(path, []byte("# Browser evidence\n\nNo binding.\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if code, _, stderr := runEvidenceFresh(t, root); code == 0 || !strings.Contains(stderr, "browser-evidence.md") {
+		t.Fatalf("missing browser binding: code=%d stderr=%q", code, stderr)
+	}
+	if err := os.WriteFile(path, []byte("Candidate SHA-256: "+digest+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if code, stdout, stderr := runEvidenceFresh(t, root); code != 0 {
+		t.Fatalf("browser binding: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+	}
+}
+
+func TestEvidenceFreshBoundsDigestArtifacts(t *testing.T) {
+	_, root, digest := writeBoundCandidateWorkspace(t, false)
+	path := filepath.Join(root, "work", "feature", "review.md")
+	body := "Candidate SHA-256: " + digest + "\n" + strings.Repeat("x", 1<<20)
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if code, stdout, stderr := runEvidenceFresh(t, root); code == 0 || stdout != "" || !strings.Contains(stderr, "1 MiB") {
+		t.Fatalf("oversized proof: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+	}
+}

package/engine/internal/lib/resolve.go

@@ -1,10 +1,8 @@
 package lib
 
 import (
-	"errors"
 	"fmt"
 	"io"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -19,16 +17,11 @@ import (
 // Resolve answers or drops an open question and keeps questions.md and state.md
 // consistent by updating the question block. When state.md is waiting for that
 // question, it clears the "Awaiting human" block and restores the running status.
-// The workspace is <root>/features/<slug>.
+// The workspace is <root>/work/<slug>.
 //
 //	0  resolved         2  no active workspace      3  qid not found
-//	4  qid not open      5  bad arguments            6  qid collision (next-qid)
+//	4  qid not open      5  bad arguments
 func Resolve(root string, args []string, stdout, stderr io.Writer) int {
-	// next-qid works on an explicit questions.md path, without an active workspace.
-	if argAt(args, 0) == "next-qid" {
-		return resolveNextQID(argAt(args, 1), stdout, stderr)
-	}
-
 	slug := activeSlug(root)
 	if slug == "" {
 		return fail(stderr, "No active workspace. Run "+workflow.ForVerb("spec").Both()+" <feature> first.", 2)
@@ -59,7 +52,7 @@ func Resolve(root string, args []string, stdout, stderr io.Writer) int {
 			return fail(stderr, "Batch file not found: "+payload, 5)
 		}
 	case "":
-		return fail(stderr, `Usage: devrites-engine resolve <qid> "<answer>"  |  --drop <qid> ["<reason>"]  |  --batch <file>`, 5)
+		return fail(stderr, `Usage: devrites-engine state resolve <qid> "<answer>"  |  state resolve --drop <qid> ["<reason>"]  |  state resolve --batch <file>`, 5)
 	default:
 		mode = "answer"
 		qid = first
@@ -143,6 +136,16 @@ func fail(stderr io.Writer, msg string, code int) int {
 	return code
 }
 
+func isDir(path string) bool {
+	info, err := os.Stat(path)
+	return err == nil && info.IsDir()
+}
+
+func isFile(path string) bool {
+	info, err := os.Stat(path)
+	return err == nil && info.Mode().IsRegular()
+}
+
 // batchLines returns the newline-terminated lines of a batch file. An unterminated
 // final line is dropped, matching a shell `read` loop, so a partial trailing line
 // is never applied as an entry.
@@ -178,27 +181,6 @@ func clockNow() time.Time {
 // nowUTC returns the current time as an ISO-8601 UTC timestamp.
 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.
-func resolveNextQID(qpath string, stdout, stderr io.Writer) int {
-	if qpath == "" {
-		return fail(stderr, "Usage: devrites-engine resolve next-qid <questions.md path>", 5)
-	}
-	content, err := os.ReadFile(qpath)
-	if err != nil {
-		if !errors.Is(err, fs.ErrNotExist) {
-			return fail(stderr, "read questions.md: "+err.Error(), 5)
-		}
-		content = nil
-	}
-	qid, err := nextQuestionID(content, clockNow())
-	if err != nil {
-		return fail(stderr, "qid already present: "+qid+" (questions.md edited out of sequence)", 6)
-	}
-	fmt.Fprintln(stdout, qid)
-	return 0
-}
-
 // resolveQuestion rewrites the <qid> block in questions.md so it records the new
 // status, answer, and answered-at time in one pass. Returns 0, or 3 (qid
 // not found) / 4 (qid not open), writing the message on failure.
@@ -207,10 +189,6 @@ func resolveQuestion(qfile, qid, status, answer string, stderr io.Writer) int {
 	if err != nil {
 		return fail(stderr, "questions.md missing at "+qfile, 2)
 	}
-	answer, err = normalizeGitAuthorityResolution(data, qid, status, answer)
-	if err != nil {
-		return fail(stderr, err.Error(), 5)
-	}
 	ts := nowUTC()
 	target := regexp.MustCompile(`^## ` + regexp.QuoteMeta(qid) + `([[:space:]]|$)`)
 

package/engine/internal/lib/resolve_remediation_test.go

@@ -6,6 +6,8 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/devrites/devrites/internal/testutil"
 )
 
 func TestResolveTreatsQuestionIDAsLiteralText(t *testing.T) {
@@ -48,25 +50,11 @@ func TestResolveAcceptsCanonicalUppercaseQuestionID(t *testing.T) {
 	}
 }
 
-func TestResolveNextQIDReportsUnreadableQuestions(t *testing.T) {
-	qpath := filepath.Join(t.TempDir(), "questions.md")
-	if err := os.Mkdir(qpath, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	var stdout, stderr bytes.Buffer
-	if code := resolveNextQID(qpath, &stdout, &stderr); code != 5 {
-		t.Fatalf("code = %d, want 5; stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "read questions.md") {
-		t.Fatalf("stderr = %q, want read error", stderr.String())
-	}
-}
-
 func resolveWorkspace(t *testing.T, questions string) string {
 	t.Helper()
 	root := t.TempDir()
-	mustWrite(t, filepath.Join(root, "ACTIVE"), "feat\n")
-	mustWrite(t, filepath.Join(root, "work", "feat", "questions.md"), questions)
-	mustWrite(t, filepath.Join(root, "work", "feat", "state.md"), "- Status: running\n- Next step: continue\n")
+	testutil.WriteFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
+	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "questions.md"), questions)
+	testutil.WriteFile(t, filepath.Join(root, "work", "feat", "state.md"), "- Status: running\n- Next step: continue\n")
 	return root
 }