devrites 5.14.4 → 6.0.0

package/engine/internal/state/budgets_test.go

@@ -2,6 +2,8 @@ package state
 
 import (
 	"strings"
+
+	"slices"
 	"testing"
 )
 
@@ -39,4 +41,95 @@ func TestHasBudgetOverrideIgnoresFencedExamples(t *testing.T) {
 	if !HasBudgetOverride([]byte(indented)) {
 		t.Fatal("leading whitespace must not hide a real override line")
 	}
+	for _, bare := range []string{"x\nBudget override:\n", "x\nBudget override:   \n", "x\n  Budget override:\t\n"} {
+		if HasBudgetOverride([]byte(bare)) {
+			t.Fatalf("an override line with no reason must not count: %q", bare)
+		}
+	}
+}
+
+// Every fence style that opens a CommonMark fenced block must reach the same
+// fenced-code guard, so a quoted example can never record an override.
+func TestHasBudgetOverrideMasksEveryFenceStyle(t *testing.T) {
+	for _, fence := range []string{"```", "~~~", "````", "~~~markdown", "   ~~~"} {
+		t.Run(fence, func(t *testing.T) {
+			closer := strings.TrimRight(fence, "abcdefghijklmnopqrstuvwxyz")
+			closed := "Intro paragraph.\n\n" + fence + "\nBudget override: <reason>\n" + closer + "\n\nClosing prose.\n"
+			if HasBudgetOverride([]byte(closed)) {
+				t.Fatalf("fence %q: a closed fenced example is not a structural override", fence)
+			}
+			unterminated := "Intro paragraph.\n\n" + fence + "\nBudget override: <reason>\n\nStill open.\n"
+			if HasBudgetOverride([]byte(unterminated)) {
+				t.Fatalf("fence %q: an unterminated fence masks to end of artifact", fence)
+			}
+			after := "Intro paragraph.\n\n" + fence + "\nSchema reference.\n" + closer + "\n\nBudget override: relocation pending\n"
+			if !HasBudgetOverride([]byte(after)) {
+				t.Fatalf("fence %q: the guard must close and a later real override line still counts", fence)
+			}
+		})
+	}
+}
+
+func TestHasBudgetOverrideFenceStyleIsNotOutcomeBearing(t *testing.T) {
+	bodies := []string{
+		"Budget override: relocation pending\n",
+		"text\nBudget override: <reason>\n```\nmore\n```\nBudget override: second\n",
+	}
+	for _, body := range bodies {
+		backtick := "```\n" + body + "```\n"
+		tilde := "~~~\n" + body + "~~~\n"
+		if got, want := HasBudgetOverride([]byte(tilde)), HasBudgetOverride([]byte(backtick)); got != want {
+			t.Fatalf("fence style changed the outcome for %q: tilde=%v backtick=%v", body, got, want)
+		}
+	}
+}
+
+func TestHasBudgetOverrideNestedAndIndentedFences(t *testing.T) {
+	cases := []struct {
+		name string
+		raw  string
+		want bool
+	}{
+		{"backtick block quoted inside tilde fence", "~~~markdown\n```\nBudget override: <reason>\n```\n~~~\n", false},
+		{"tilde block quoted inside backtick fence", "```markdown\n~~~\nBudget override: <reason>\n~~~\n```\n", false},
+		{"four-space indent is not a fence", "    ~~~\nBudget override: real\n", true},
+		{"malformed markdown has no structural override", "Budget override: real\n\x00", false},
+	}
+	for _, c := range cases {
+		if got := HasBudgetOverride([]byte(c.raw)); got != c.want {
+			t.Errorf("%s: got %v want %v", c.name, got, c.want)
+		}
+	}
+}
+
+func TestAcceptanceSectionIgnoresFencedExamples(t *testing.T) {
+	spec := []byte("# Spec\n\nHere is the shape we want:\n\n```markdown\n## Acceptance criteria\n- AC-900: phantom\n```\n\nNo real section exists.\n")
+	got := ParseAcceptanceMap(spec, []byte("no ids here"), []byte("no ids here"), true, true)
+	if len(got.SpecIDs) != 0 {
+		t.Fatalf("a fenced example must not fabricate acceptance ids: ids=%v", got.SpecIDs)
+	}
+	if len(got.Problems) != 0 {
+		t.Fatalf("no real section means no required ids: problems=%v", got.Problems)
+	}
+}
+
+func TestAcceptanceSectionKeepsRealSectionPastFencedHeadings(t *testing.T) {
+	spec := []byte("# Spec\n\n## Acceptance criteria\n\n```markdown\n## Non-goals\n- AC-900: phantom\n```\n\n- AC-001: export CSV\n\n## Non-goals\n- AC-998: outside\n")
+	tasks := []byte("Satisfies: AC-001\n")
+	plan := []byte("AC-001\n")
+	got := ParseAcceptanceMap(spec, tasks, plan, true, true)
+	if !slices.Equal(got.SpecIDs, []string{"AC-001"}) {
+		t.Fatalf("a fenced heading must not truncate the real section: ids=%v", got.SpecIDs)
+	}
+	if len(got.Problems) != 0 {
+		t.Fatalf("problems=%v", got.Problems)
+	}
+}
+
+func TestAcceptanceSectionIgnoresMalformedMarkdown(t *testing.T) {
+	spec := []byte("## Acceptance criteria\n- AC-001: export CSV\n\x00")
+	got := ParseAcceptanceMap(spec, []byte("no ids here"), []byte("no ids here"), true, true)
+	if len(got.SpecIDs) != 0 || len(got.Problems) != 0 {
+		t.Fatalf("malformed input carries no usable section: ids=%v problems=%v", got.SpecIDs, got.Problems)
+	}
 }

package/engine/internal/state/cursor.go

@@ -216,10 +216,15 @@ func DeleteCursorField(lines []string, key string) []string {
 
 // CursorForm reports the presentation of the state.md cursor: "table" when a
 // canonical table row exists, "legacy" when only bullet fields exist, and
-// "none" when neither is present.
+// "none" when neither is present. Fenced blocks are not structural, so a
+// cursor row inside one is not a cursor row.
 func CursorForm(lines []string) string {
+	structural, ok := structuralCursorLines(lines)
+	if !ok {
+		return "none"
+	}
 	form := "none"
-	for _, line := range lines {
+	for _, line := range structural {
 		_, _, kind, ok := parseCursorLine(line)
 		if !ok {
 			continue
@@ -237,14 +242,19 @@ func CursorForm(lines []string) string {
 // ConvertCursorToTable rewrites legacy bullet cursor fields into canonical
 // table rows in place. A bullet whose key resolves to a canonical cursor key
 // is a cursor field wherever it appears — the same rule CursorField uses to
-// read — so such a bullet is converted even inside prose sections. Prose
-// without a canonical cursor key is preserved, and a value carrying a raw pipe
-// keeps its bullet form because a table cell cannot represent it. It reports
-// whether any line changed.
+// read — so such a bullet is converted even inside prose sections. Fenced
+// blocks are not structural, so their bullets are left exactly as written.
+// Prose without a canonical cursor key is preserved, and a value carrying a
+// raw pipe keeps its bullet form because a table cell cannot represent it. It
+// reports whether any line changed.
 func ConvertCursorToTable(lines []string) ([]string, bool) {
+	structural, ok := structuralCursorLines(lines)
+	if !ok {
+		return append([]string(nil), lines...), false
+	}
 	changed := false
 	out := append([]string(nil), lines...)
-	for i, line := range out {
+	for i, line := range structural {
 		key, value, kind, ok := parseCursorLine(line)
 		if !ok || kind != cursorLineLegacy {
 			continue
@@ -259,7 +269,8 @@ func ConvertCursorToTable(lines []string) ([]string, bool) {
 		if !ok {
 			continue
 		}
-		indent := line[:len(line)-len(strings.TrimLeft(line, " \t"))]
+		original := out[i]
+		indent := original[:len(original)-len(strings.TrimLeft(original, " \t"))]
 		out[i] = indent + "| " + spelling + " | " + value + " |"
 		changed = true
 	}

package/engine/internal/state/cursor_test.go

@@ -154,3 +154,123 @@ func TestCursorHelpersRejectCorruptTextWithoutMutation(t *testing.T) {
 		}
 	}
 }
+
+// ConvertCursorToTable and CursorForm must obtain their
+// structural lines through structuralCursorLines (markdowntext.Structural), the
+// same way CursorField, SetCursorField, UpsertCursorField and DeleteCursorField
+// do. The cases below separate "the fence was masked" from "the call site never
+// consulted the masker at all".
+
+const ledgerWithFencedExample = `# State
+
+## Recovery note
+
+The pre-v5 ledger looked like this:
+
+~~~md
+- Phase: build
+- Status: running
+~~~
+
+## Cursor
+
+- Phase: build
+- Status: running
+`
+
+// Fenced-only legacy bullets and a live table row: a ledger whose only legacy
+// bullets sit inside a fence. Nothing here is structural, so nothing may change.
+func TestConvertCursorToTableIsByteIdenticalOnFencedOnlyLedger(t *testing.T) {
+	lines := strings.Split("# State\n\n~~~md\n- Phase: build\n~~~\n\n## Cursor\n| phase | spec |", "\n")
+	original := strings.Join(lines, "\n")
+	out, changed := ConvertCursorToTable(lines)
+	if changed {
+		t.Fatalf("ConvertCursorToTable reported a change for a fenced-only ledger:\n%s", strings.Join(out, "\n"))
+	}
+	if got := strings.Join(out, "\n"); got != original {
+		t.Fatalf("ConvertCursorToTable mutated a fenced-only ledger:\ngot  %q\nwant %q", got, original)
+	}
+}
+
+// The discriminating case: one document, the same key spelling inside and
+// outside a fence. The fenced bullet must survive untouched while the live
+// bullet is still converted, which neither "convert nothing" nor "convert
+// everything" can satisfy.
+func TestConvertCursorToTableConvertsLiveBulletsAndLeavesFencedOnes(t *testing.T) {
+	lines := strings.Split(ledgerWithFencedExample, "\n")
+	out, changed := ConvertCursorToTable(lines)
+	if !changed {
+		t.Fatalf("ConvertCursorToTable converted nothing; the live bullets must still convert:\n%s", strings.Join(out, "\n"))
+	}
+	if out[7] != "- Phase: build" || out[8] != "- Status: running" {
+		t.Fatalf("ConvertCursorToTable rewrote the fenced example:\n%s", strings.Join(out, "\n"))
+	}
+	if out[13] != "| phase | build |" || out[14] != "| status | running |" {
+		t.Fatalf("ConvertCursorToTable did not convert the live bullets:\n%s", strings.Join(out, "\n"))
+	}
+}
+
+// A fence that is still open masks the rest of the document, which is what
+// markdowntext.Structural does. The bullet after the unclosed fence is not converted.
+func TestConvertCursorToTableTreatsAnUnclosedFenceAsStructuralMasking(t *testing.T) {
+	lines := strings.Split("~~~md\n- Phase: build\n\n- Phase: build\n", "\n")
+	out, changed := ConvertCursorToTable(lines)
+	if changed {
+		t.Fatalf("ConvertCursorToTable converted content after an unclosed fence:\n%s", strings.Join(out, "\n"))
+	}
+	if out[1] != "- Phase: build" || out[3] != "- Phase: build" {
+		t.Fatalf("ConvertCursorToTable rewrote content after an unclosed fence:\n%s", strings.Join(out, "\n"))
+	}
+}
+
+// CursorForm must report the presentation of the structural document only.
+func TestCursorFormIgnoresFencedTableRows(t *testing.T) {
+	fenced := []string{"~~~md", "| phase | x |", "~~~"}
+	if got := CursorForm(fenced); got != "none" {
+		t.Fatalf("CursorForm(fenced-only table) = %q, want none", got)
+	}
+	if got := CursorForm([]string{"| phase | x |"}); got != "table" {
+		t.Fatalf("CursorForm(live table) = %q, want table", got)
+	}
+	if got := CursorForm([]string{"~~~md", "- phase: build", "~~~", "- Phase: build"}); got != "legacy" {
+		t.Fatalf("CursorForm(fenced bullet plus live bullet) = %q, want legacy", got)
+	}
+}
+
+// Proves the masker is consulted rather than the outcome being right by some
+// other route. markdowntext.Structural is the only thing in this package that
+// rejects NUL bytes, so a document that carries a valid, unfenced cursor bullet
+// next to one NUL byte must be declined whole: ConvertCursorToTable returns
+// changed=false and CursorForm reports "none". A parser that never calls the
+// masker reports changed=true / "table" on exactly this input.
+func TestCursorFormAndConvertConsultTheFenceMasker(t *testing.T) {
+	corrupt := []string{"- Phase: build", "- Status: run\x00ning"}
+	out, changed := ConvertCursorToTable(corrupt)
+	if changed {
+		t.Fatalf("ConvertCursorToTable converted a document the masker must decline:\n%q", strings.Join(out, "\n"))
+	}
+	if strings.Join(out, "\n") != strings.Join(corrupt, "\n") {
+		t.Fatalf("ConvertCursorToTable mutated a document the masker must decline:\n%q", strings.Join(out, "\n"))
+	}
+	if got := CursorForm([]string{"| phase | build |", "- Status: run\x00ning"}); got != "none" {
+		t.Fatalf("CursorForm(corrupt table) = %q, want none: the masker was not consulted", got)
+	}
+	if got := CursorForm([]string{"- Phase: build", "- Status: run\xffning"}); got != "none" {
+		t.Fatalf("CursorForm(corrupt legacy) = %q, want none: the masker was not consulted", got)
+	}
+}
+
+// Bullets in prose sections outside any fence still convert.
+func TestConvertCursorToTableStillConvertsProseSections(t *testing.T) {
+	lines := strings.Split("# State\n\n## Notes\n\n- Phase: build\n- owner: platform\n", "\n")
+	out, changed := ConvertCursorToTable(lines)
+	if !changed {
+		t.Fatalf("ConvertCursorToTable converted nothing:\n%s", strings.Join(out, "\n"))
+	}
+	if out[4] != "| phase | build |" {
+		t.Fatalf("ConvertCursorToTable did not convert the prose-section bullet:\n%s", strings.Join(out, "\n"))
+	}
+	if out[5] != "- owner: platform" {
+		t.Fatalf("ConvertCursorToTable converted a non-cursor bullet:\n%s", strings.Join(out, "\n"))
+	}
+}

package/engine/internal/state/lock_unix.go

@@ -19,13 +19,19 @@ func acquireLock(path string) (*fileLock, error) {
 	if err != nil {
 		return nil, fmt.Errorf("acquire lock: %w", err)
 	}
+	return lockOpened(f, path)
+}
+
+// lockOpened takes the flock on f, an already-open handle on path, and confirms
+// the lock is still the file at path.
+func lockOpened(f *os.File, path string) (*fileLock, error) {
 	// LOCK_EX blocks until the lock is available; contending devrites-engine processes
 	// queue here rather than racing the read-modify-write.
 	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
 		_ = f.Close()
 		return nil, fmt.Errorf("flock %s: %w", path, err)
 	}
-	return &fileLock{f: f}, nil
+	return confirmLock(&fileLock{f: f}, path)
 }
 
 func (l *fileLock) release() error {

package/engine/internal/state/lock_windows.go

@@ -26,6 +26,12 @@ func acquireLock(path string) (*fileLock, error) {
 	if err != nil {
 		return nil, fmt.Errorf("acquire lock: %w", err)
 	}
+	return lockOpened(f, path)
+}
+
+// lockOpened takes the LockFileEx lock on f, an already-open handle on path, and
+// confirms the lock is still the file at path.
+func lockOpened(f *os.File, path string) (*fileLock, error) {
 	l := &fileLock{f: f}
 	if ok, _, callErr := lockFileEx.Call(
 		f.Fd(),
@@ -38,7 +44,7 @@ func acquireLock(path string) (*fileLock, error) {
 		_ = f.Close()
 		return nil, fmt.Errorf("lock file %s: %w", path, callErr)
 	}
-	return l, nil
+	return confirmLock(l, path)
 }
 
 func (l *fileLock) release() error {

package/engine/internal/state/state_test.go

@@ -624,17 +624,6 @@ func writeStatusRequiredArtifacts(t *testing.T, root, slug string, phase Phase)
 	}
 }
 
-func writeSection(t *testing.T, root, slug, name, body string) {
-	t.Helper()
-	dir := filepath.Join(root, "work", slug)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
 func writeWorkSection(t *testing.T, root, slug, name, body string) {
 	t.Helper()
 	dir := filepath.Join(root, "work", slug)
@@ -651,12 +640,12 @@ func writeWorkSection(t *testing.T, root, slug, name, body string) {
 // evidence.md/state.md. The engine must load, list, and report it anyway.
 func TestStatusFromOfficialBulletLedger(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
-	writeSection(t, root, "live", "state.md", "- Phase: prove\n- Status: running\n")
-	writeSection(t, root, "live", "spec.md", "# Spec\n\nDo the thing.\n")
-	writeSection(t, root, "live", "plan.md", "# Plan\n\nApproach.\n")
-	writeSection(t, root, "live", "decisions.md", "# Decisions\n\nChose X.\n")
-	writeSection(t, root, "live", "tasks.md", "# Tasks\n\n- [x] slice 1\n")
-	writeSection(t, root, "live", "evidence.md", "# Evidence\n\nTests pass.\n")
+	writeWorkSection(t, root, "live", "state.md", "- Phase: prove\n- Status: running\n")
+	writeWorkSection(t, root, "live", "spec.md", "# Spec\n\nDo the thing.\n")
+	writeWorkSection(t, root, "live", "plan.md", "# Plan\n\nApproach.\n")
+	writeWorkSection(t, root, "live", "decisions.md", "# Decisions\n\nChose X.\n")
+	writeWorkSection(t, root, "live", "tasks.md", "# Tasks\n\n- [x] slice 1\n")
+	writeWorkSection(t, root, "live", "evidence.md", "# Evidence\n\nTests pass.\n")
 
 	rep, err := Status(root, "live")
 	if err != nil {
@@ -788,7 +777,7 @@ func TestStatusCursorCannotStandInForPhase(t *testing.T) {
 // clear error rather than silently falling back or mis-loading.
 func TestLedgerPhaseRejectsUnknownWord(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
-	writeSection(t, root, "bogus", "state.md", "- Phase: building\n")
+	writeWorkSection(t, root, "bogus", "state.md", "- Phase: building\n")
 	if _, err := Status(root, "bogus"); err == nil {
 		t.Error("Status on a ledger with an unknown phase word = nil error, want an error")
 	}
@@ -953,3 +942,45 @@ func TestListFeaturesIgnoresAllOperationalRemnants(t *testing.T) {
 		t.Fatalf("ListFeatures() = %v, want [live]; operational remnants became workspaces", got)
 	}
 }
+
+func TestRequireWorkspaceSchemaRefusesUnsafeStateFile(t *testing.T) {
+	tests := []struct {
+		name  string
+		setup func(t *testing.T, statePath string)
+		want  string
+	}{
+		{"symlink", func(t *testing.T, statePath string) {
+			outside := filepath.Join(t.TempDir(), "outside.md")
+			if err := os.WriteFile(outside, []byte("- schema: 4\n"), 0o644); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Symlink(outside, statePath); err != nil {
+				t.Skipf("symlinks unavailable: %v", err)
+			}
+		}, string(DiagnosticFinalSymlink)},
+		{"directory", func(t *testing.T, statePath string) {
+			if err := os.Mkdir(statePath, 0o755); err != nil {
+				t.Fatal(err)
+			}
+		}, string(DiagnosticNonRegular)},
+		{"oversize", func(t *testing.T, statePath string) {
+			if err := os.WriteFile(statePath, make([]byte, maxArtifactBytes+1), 0o644); err != nil {
+				t.Fatal(err)
+			}
+		}, string(DiagnosticFileTooLarge)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			root := t.TempDir()
+			dir := featureDir(root, "demo")
+			if err := os.MkdirAll(dir, 0o755); err != nil {
+				t.Fatal(err)
+			}
+			tt.setup(t, filepath.Join(dir, LedgerFile))
+			err := RequireWorkspaceSchema(root, "demo")
+			if err == nil || !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("RequireWorkspaceSchema err=%v, want it to mention %s", err, tt.want)
+			}
+		})
+	}
+}

package/engine/internal/state/taskgraph.go

@@ -5,6 +5,8 @@ import (
 	"regexp"
 	"strings"
 	"unicode"
+
+	"github.com/devrites/devrites/internal/markdowntext"
 )
 
 // TaskSlice is one SLICE-### block parsed from tasks.md.
@@ -37,11 +39,12 @@ func ValidSliceID(id string) bool { return sliceIDValidRE.MatchString(id) }
 // one slice instead of the whole file.
 func ExtractTaskSlice(tasksMarkdown []byte, id string) (string, bool) {
 	text := string(tasksMarkdown)
-	for _, match := range sliceHeaderRE.FindAllStringSubmatchIndex(text, -1) {
-		if text[match[2]:match[3]] != id {
+	masked := structuralTaskText(tasksMarkdown)
+	for _, match := range sliceHeaderRE.FindAllStringSubmatchIndex(masked, -1) {
+		if masked[match[2]:match[3]] != id {
 			continue
 		}
-		rest := text[match[1]:]
+		rest := masked[match[1]:]
 		end := len(text)
 		if next := anyH2HeaderRE.FindStringIndex(rest); next != nil {
 			end = match[1] + next[0]
@@ -53,7 +56,7 @@ func ExtractTaskSlice(tasksMarkdown []byte, id string) (string, bool) {
 
 // ParseTaskGraph reads tasks.md content and validates the slice dependency DAG.
 func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
-	text := string(tasksMarkdown)
+	text := structuralTaskText(tasksMarkdown)
 	result := TaskGraphResult{}
 	if strings.TrimSpace(text) == "" {
 		result.Problems = append(result.Problems, "tasks.md is empty")
@@ -107,6 +110,17 @@ func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
 	return result
 }
 
+// structuralTaskText blanks fenced code blocks, keeping byte offsets aligned, so
+// an example inside a fence is never read as slice structure. Input that cannot
+// be masked (malformed UTF-8, NUL) is parsed as written.
+func structuralTaskText(tasksMarkdown []byte) string {
+	masked, err := markdowntext.Structural(tasksMarkdown)
+	if err != nil {
+		return string(tasksMarkdown)
+	}
+	return string(masked)
+}
+
 func parseSliceGraph(id, block string) ([]string, []string) {
 	var problems []string
 	depsLine := firstLineValue(dependenciesRE, block)

package/engine/internal/state/taskgraph_test.go

@@ -0,0 +1,43 @@
+package state
+
+import (
+	"strings"
+	"testing"
+)
+
+const fenceLive = "## SLICE-001\nDependencies: SLICE-002\n\n## SLICE-002\nDependencies: none\n"
+
+const fenceDoc = "## SLICE-001\nDependencies: SLICE-002\n\nExample layout:\n\n```markdown\n## SLICE-002\nDependencies: none\n```\n"
+
+func TestParseTaskGraphUnfencedControlYieldsTwoSlices(t *testing.T) {
+	got := ParseTaskGraph([]byte(fenceLive))
+	if len(got.Slices) != 2 || len(got.Unknown) != 0 {
+		t.Fatalf("slices=%v unknown=%v, want two slices and no unknown", got.Slices, got.Unknown)
+	}
+}
+
+func TestParseTaskGraphIgnoresFencedSliceHeader(t *testing.T) {
+	got := ParseTaskGraph([]byte(fenceDoc))
+	if len(got.Slices) != 1 || got.Slices[0].ID != "SLICE-001" {
+		t.Fatalf("slices=%v, want only SLICE-001", got.Slices)
+	}
+	if len(got.Unknown) != 1 || got.Unknown[0] != "SLICE-002" {
+		t.Fatalf("unknown=%v, want the dangling SLICE-002 reported", got.Unknown)
+	}
+}
+
+func TestExtractTaskSliceIgnoresFencedSliceHeader(t *testing.T) {
+	if _, ok := ExtractTaskSlice([]byte(fenceDoc), "SLICE-002"); ok {
+		t.Fatal("fenced SLICE-002 reported as a live slice")
+	}
+	block, ok := ExtractTaskSlice([]byte(fenceDoc), "SLICE-001")
+	if !ok {
+		t.Fatal("live SLICE-001 not found")
+	}
+	if !strings.Contains(block, "```markdown") || !strings.Contains(block, "## SLICE-002") {
+		t.Fatalf("live slice must keep its fenced example verbatim, got %q", block)
+	}
+	if got, ok := ExtractTaskSlice([]byte(fenceLive), "SLICE-002"); !ok || !strings.HasPrefix(got, "## SLICE-002") {
+		t.Fatalf("unfenced control: got %q ok=%v", got, ok)
+	}
+}

package/engine/internal/state/workspaceschema.go

@@ -21,7 +21,21 @@ const workspaceSchemaKey = CursorSchema
 // WorkspaceSchema reports the schema version declared by the feature's
 // state.md cursor. A missing row means the pre-v5 (schema 2) contract.
 func WorkspaceSchema(root, slug string) (int, error) {
-	raw, err := os.ReadFile(filepath.Join(featureDir(root, slug), LedgerFile))
+	statePath := filepath.Join(featureDir(root, slug), LedgerFile)
+	info, err := os.Lstat(statePath)
+	if err != nil {
+		return 0, fmt.Errorf("read workspace schema for %s: %w", slug, err)
+	}
+	switch {
+	case info.Mode()&os.ModeSymlink != 0:
+		return 0, fmt.Errorf("read workspace schema for %s: state.md is unsafe (%s)", slug, DiagnosticFinalSymlink)
+	case !info.Mode().IsRegular():
+		return 0, fmt.Errorf("read workspace schema for %s: state.md is unsafe (%s)", slug, DiagnosticNonRegular)
+	case info.Size() > maxArtifactBytes:
+		return 0, fmt.Errorf("read workspace schema for %s: state.md is unsafe (%s)", slug, DiagnosticFileTooLarge)
+	}
+	// #nosec G304 -- fixed state.md under the engine-resolved feature workspace, checked above to be a regular non-symlink file within the size cap
+	raw, err := os.ReadFile(statePath)
 	if err != nil {
 		return 0, fmt.Errorf("read workspace schema for %s: %w", slug, err)
 	}
@@ -37,7 +51,7 @@ func RequireWorkspaceSchema(root, slug string) error {
 		return err
 	}
 	if version < SchemaVersion {
-		return fmt.Errorf("%w: workspace %s predates the v5 workspace schema (schema %d, engine requires %d); run devrites-engine migrate %s", ErrWorkspaceSchemaRefused, slug, version, SchemaVersion, slug)
+		return fmt.Errorf("%w: workspace %s predates the current workspace schema (schema %d, engine requires %d); run devrites-engine migrate %s", ErrWorkspaceSchemaRefused, slug, version, SchemaVersion, slug)
 	}
 	if version > SchemaVersion {
 		return fmt.Errorf("%w: workspace %s declares schema %d, newer than this engine's %d; upgrade devrites", ErrWorkspaceSchemaRefused, slug, version, SchemaVersion)

package/engine/internal/state/workspaceschema_test.go

@@ -1,8 +1,10 @@
 package state
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"testing"
 )
@@ -65,3 +67,35 @@ func TestWorkspaceSchemaMissingLedgerIsRefused(t *testing.T) {
 		t.Fatal("missing workspace must be refused")
 	}
 }
+
+func TestRefusalMessagesFormatSchemaVersionWithoutVersionLabel(t *testing.T) {
+	root, slug := writeSchemaWorkspace(t, "| phase | build |\n| schema | 2 |\n")
+	older := RequireWorkspaceSchema(root, slug)
+	root, slug = writeSchemaWorkspace(t, fmt.Sprintf("| phase | build |\n| schema | %d |\n", SchemaVersion+1))
+	newer := RequireWorkspaceSchema(root, slug)
+	for name, err := range map[string]error{"older": older, "newer": newer} {
+		if err == nil {
+			t.Fatalf("%s schema must be refused", name)
+		}
+		if strings.Contains(err.Error(), "v5") {
+			t.Fatalf("%s refusal hardcodes a version label: %v", name, err)
+		}
+		if want := fmt.Sprintf("%d", SchemaVersion); !strings.Contains(err.Error(), want) {
+			t.Fatalf("%s refusal must format SchemaVersion %s: %v", name, want, err)
+		}
+	}
+}
+
+func TestStateTemplateSchemaCellMatchesEngine(t *testing.T) {
+	raw, err := os.ReadFile(filepath.Join("..", "..", "..", "pack", ".claude", "skills", "rite-spec", "reference", "state-workspace.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	m := regexp.MustCompile(`(?m)^\|\s*schema\s*\|\s*(\d+)\s*\|`).FindSubmatch(raw)
+	if m == nil {
+		t.Fatal("template has no schema cell")
+	}
+	if want := fmt.Sprintf("%d", SchemaVersion); string(m[1]) != want {
+		t.Fatalf("template schema cell=%s, engine SchemaVersion=%s", m[1], want)
+	}
+}