devrites 6.0.4 → 6.1.0

package/engine/internal/state/cmd/workflowmanifest/main_test.go

@@ -1,96 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/state"
-)
-
-func TestRunWritesDeterministicManifest(t *testing.T) {
-	dir := t.TempDir()
-	out := filepath.Join(dir, "workflow_manifest.json")
-
-	if code := run([]string{"--out", out}, os.Stderr); code != 0 {
-		t.Fatalf("run exit=%d", code)
-	}
-	first, err := os.ReadFile(out)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var document struct {
-		GeneratedBy   string `json:"generatedBy"`
-		SchemaVersion int    `json:"schemaVersion"`
-		Phases        []struct {
-			ID              state.Phase `json:"id"`
-			TransitionRight string      `json:"transitionRight"`
-		} `json:"phases"`
-	}
-	if err := json.Unmarshal(first, &document); err != nil {
-		t.Fatalf("manifest is not valid JSON: %v", err)
-	}
-	if document.SchemaVersion != state.SchemaVersion {
-		t.Fatalf("schemaVersion=%d want %d", document.SchemaVersion, state.SchemaVersion)
-	}
-	if !strings.HasPrefix(document.GeneratedBy, "go generate ./internal/state") {
-		t.Fatalf("generatedBy %q", document.GeneratedBy)
-	}
-	if len(document.Phases) == 0 {
-		t.Fatal("manifest must list phases")
-	}
-
-	// Deterministic: a second run produces identical bytes.
-	if code := run([]string{"--out", out}, os.Stderr); code != 0 {
-		t.Fatalf("second run exit=%d", code)
-	}
-	second, err := os.ReadFile(out)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(first, second) {
-		t.Fatal("manifest output is not deterministic")
-	}
-}
-
-func TestRunCheckPassesOnCurrentAndFailsOnStale(t *testing.T) {
-	dir := t.TempDir()
-	out := filepath.Join(dir, "workflow_manifest.json")
-
-	if code := run([]string{"--out", out}, os.Stderr); code != 0 {
-		t.Fatalf("generate exit=%d", code)
-	}
-	if code := run([]string{"--out", out, "--check"}, os.Stderr); code != 0 {
-		t.Fatalf("check on current manifest exit=%d", code)
-	}
-
-	if err := os.WriteFile(out, []byte("{\"stale\": true}\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	stderr := &strings.Builder{}
-	if code := run([]string{"--out", out, "--check"}, stderr); code != 1 {
-		t.Fatalf("check on stale manifest exit=%d want 1", code)
-	}
-	if !strings.Contains(stderr.String(), "is stale") {
-		t.Fatalf("stderr should name the stale manifest, got %q", stderr.String())
-	}
-}
-
-func TestRunCheckFailsOnMissingManifest(t *testing.T) {
-	dir := t.TempDir()
-	missing := filepath.Join(dir, "absent.json")
-	stderr := &strings.Builder{}
-	if code := run([]string{"--out", missing, "--check"}, stderr); code != 1 {
-		t.Fatalf("check on missing manifest exit=%d want 1", code)
-	}
-}
-
-func TestRunRejectsUnknownFlags(t *testing.T) {
-	stderr := &strings.Builder{}
-	if code := run([]string{"--bogus"}, stderr); code != 2 {
-		t.Fatalf("unknown flag exit=%d want 2", code)
-	}
-}

package/engine/internal/state/concurrency_test.go

@@ -1,184 +0,0 @@
-package state
-
-// Issue 07: prove the concurrency primitives. These exercise in-process
-// contention (goroutines); the multi-process CLI stress test lives beside the
-// binary (concurrency_cli_test.go).
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// TestAppendLogConcurrentNoInterleaveNoLoss spawns many concurrent appenders,
-// each writing a distinct small record, and asserts every record landed exactly
-// once and intact: no interleaving, no lost writes.
-func TestAppendLogConcurrentNoInterleaveNoLoss(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "events.log")
-	const n = 64
-
-	var wg sync.WaitGroup
-	for i := 0; i < n; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			if err := AppendLog(path, fmt.Sprintf("record-%03d-fixed-width-payload", i)); err != nil {
-				t.Errorf("append %d: %v", i, err)
-			}
-		}(i)
-	}
-	wg.Wait()
-
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	lines := strings.Split(strings.TrimRight(string(raw), "\n"), "\n")
-	if len(lines) != n {
-		t.Fatalf("got %d lines, want %d (lost or torn writes)", len(lines), n)
-	}
-	seen := make(map[string]bool, n)
-	for _, l := range lines {
-		if !strings.HasPrefix(l, "record-") || !strings.HasSuffix(l, "-fixed-width-payload") {
-			t.Fatalf("interleaved/torn record: %q", l)
-		}
-		if seen[l] {
-			t.Fatalf("duplicate record: %q", l)
-		}
-		seen[l] = true
-	}
-}
-
-// TestAtomicWriteReaderNeverSeesPartial has many writers overwrite one path with
-// distinct full-size contents while readers read concurrently. A reader must
-// always observe a complete, self-consistent file: never a half-written or
-// mixed one: which is exactly what temp-file + atomic rename guarantees.
-func TestAtomicWriteReaderNeverSeesPartial(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("Windows does not allow replacing a file while another handle is reading it")
-	}
-	path := filepath.Join(t.TempDir(), "structured.md")
-	const size = 8192
-	if err := AtomicWrite(path, bytes.Repeat([]byte{'A'}, size), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	var writers, readers sync.WaitGroup
-	stop := make(chan struct{})
-
-	// Writers: each writes a homogeneous block of a distinct byte until stopped.
-	for _, b := range []byte("BCDEFGHIJKLMNOP") {
-		writers.Add(1)
-		go func(b byte) {
-			defer writers.Done()
-			for {
-				select {
-				case <-stop:
-					return
-				default:
-					if err := AtomicWrite(path, bytes.Repeat([]byte{b}, size), 0o644); err != nil {
-						t.Errorf("write %c: %v", b, err)
-						return
-					}
-				}
-			}
-		}(b)
-	}
-
-	// Readers: every read must be full-size and homogeneous (one writer's block),
-	// proving no partial or interleaved content is ever visible.
-	for r := 0; r < 4; r++ {
-		readers.Add(1)
-		go func() {
-			defer readers.Done()
-			for i := 0; i < 2000; i++ {
-				data, err := os.ReadFile(path)
-				if err != nil {
-					t.Errorf("read: %v", err)
-					return
-				}
-				if len(data) != size {
-					t.Errorf("partial read: len=%d, want %d", len(data), size)
-					return
-				}
-				first := data[0]
-				for _, c := range data {
-					if c != first {
-						t.Errorf("torn read: mixed bytes %c and %c", first, c)
-						return
-					}
-				}
-			}
-		}()
-	}
-
-	readers.Wait() // readers finish their fixed loops; then stop the writers
-	close(stop)
-	writers.Wait()
-
-	// No temp files left behind after all writes.
-	litter, _ := filepath.Glob(filepath.Join(filepath.Dir(path), ".*.tmp-*"))
-	if len(litter) != 0 {
-		t.Errorf("atomic write left temp litter: %v", litter)
-	}
-}
-
-// TestWithFeatureLockSerializesReadModifyWrite runs a lost-update-prone counter
-// increment concurrently under the per-feature lock. Serialized correctly, the
-// final value is exactly the number of increments.
-func TestWithFeatureLockSerializesReadModifyWrite(t *testing.T) {
-	root := t.TempDir()
-	slug := "counter"
-	if err := os.MkdirAll(featureDir(root, slug), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	counter := filepath.Join(featureDir(root, slug), "count")
-	if err := os.WriteFile(counter, []byte("0"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	const n = 50
-	var wg sync.WaitGroup
-	for i := 0; i < n; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			err := WithFeatureLock(root, slug, func() error {
-				raw, err := os.ReadFile(counter)
-				if err != nil {
-					return err
-				}
-				v, _ := strconv.Atoi(strings.TrimSpace(string(raw)))
-				return os.WriteFile(counter, []byte(strconv.Itoa(v+1)), 0o644)
-			})
-			if err != nil {
-				t.Errorf("locked increment: %v", err)
-			}
-		}()
-	}
-	wg.Wait()
-
-	raw, _ := os.ReadFile(counter)
-	if got := strings.TrimSpace(string(raw)); got != strconv.Itoa(n) {
-		t.Fatalf("counter = %s, want %d: lost updates under contention", got, n)
-	}
-}
-
-// TestAtomicWriteFailsCleanlyOnMissingDir asserts a write whose directory does
-// not exist returns an error rather than a partial file, and leaves no temp
-// litter to find.
-func TestAtomicWriteFailsCleanlyOnMissingDir(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "no-such-dir", "file.md")
-	if err := AtomicWrite(path, []byte("data"), 0o644); err == nil {
-		t.Fatal("expected an error writing into a missing directory")
-	}
-	if _, err := os.Stat(path); !os.IsNotExist(err) {
-		t.Errorf("a failed atomic write left a file behind")
-	}
-}

package/engine/internal/state/cursor_fuzz_test.go

@@ -1,80 +0,0 @@
-package state
-
-import (
-	"bytes"
-	"slices"
-	"strings"
-	"testing"
-	"unicode/utf8"
-)
-
-var cursorFuzzKeys = []string{
-	CursorPhase, CursorStatus, CursorNextAction, CursorQuestionID,
-	CursorActiveSlice, CursorAFKSlicesRemaining, CursorReturnPhase,
-	CursorReturnNextAction, CursorSchema,
-}
-
-func FuzzCursorRoundTrip(f *testing.F) {
-	f.Add(uint8(0), "spec", []byte("# Feature\n\n## Cursor\n\n| phase | init |\n| --- | --- |\n| status | running |"))
-	f.Add(uint8(1), "", []byte("- phase: spec\n- status: running"))
-	f.Add(uint8(8), "5", []byte("## Cursor\n\n| phase | init |"))
-	f.Add(uint8(2), "a|b", []byte("| status | running |"))
-	f.Add(uint8(4), "two\nlines", []byte("| status | running |"))
-	f.Add(uint8(5), "value with spaces", []byte{})
-	f.Fuzz(func(t *testing.T, keyIndex uint8, value string, doc []byte) {
-		// Docs and values with NUL bytes or invalid UTF-8 are outside the
-		// format: the read and write paths refuse them, so round-trip says
-		// nothing there.
-		if !utf8.Valid(doc) || bytes.IndexByte(doc, 0) >= 0 ||
-			!utf8.ValidString(value) || strings.IndexByte(value, 0) >= 0 {
-			return
-		}
-		key := cursorFuzzKeys[int(keyIndex)%len(cursorFuzzKeys)]
-		lines := strings.Split(string(doc), "\n")
-		upserted := UpsertCursorField(lines, key, value)
-		if strings.ContainsAny(value, "\r\n") {
-			// Line breaks are representable in no form: the write must be
-			// declined with the document unchanged.
-			if !slices.Equal(upserted, lines) {
-				t.Fatal("newline value was not declined unchanged")
-			}
-			return
-		}
-		// The upsert contract: either the document is unchanged, or the value
-		// is readable from the result.
-		got, ok := CursorField(upserted, key)
-		if !slices.Equal(upserted, lines) && (!ok || got != strings.TrimSpace(value)) {
-			t.Fatalf("upsert changed the document but %q is not readable (got %q, ok %v)", value, got, ok)
-		}
-		deleted := DeleteCursorField(upserted, key)
-		if _, ok := CursorField(deleted, key); ok {
-			t.Fatalf("deleted key %q still readable", key)
-		}
-		replaced, ok := SetCursorField(upserted, key, value)
-		if ok {
-			got, ok := CursorField(replaced, key)
-			if !ok || got != strings.TrimSpace(value) {
-				t.Fatalf("set %q not readable (got %q, ok %v)", value, got, ok)
-			}
-		}
-	})
-}
-
-func FuzzCursorParsing(f *testing.F) {
-	f.Add([]byte("| phase | spec |"), "phase", "x")
-	f.Add([]byte("```\n| q | a |\n```"), "qid", "y")
-	f.Add([]byte("- nextstep: run"), "next_action", "z")
-	f.Add([]byte("## Cursor\n\n| a | b | extra |"), "", "")
-	f.Fuzz(func(t *testing.T, doc []byte, key, value string) {
-		if !utf8.Valid(doc) || bytes.IndexByte(doc, 0) >= 0 {
-			return
-		}
-		lines := strings.Split(string(doc), "\n")
-		_, _ = CursorField(lines, key)
-		_ = CursorForm(lines)
-		out, _ := SetCursorField(lines, key, value)
-		out = UpsertCursorField(out, key, value)
-		_ = DeleteCursorField(out, key)
-		_, _ = ConvertCursorToTable(lines)
-	})
-}

package/engine/internal/state/cursor_test.go

@@ -1,276 +0,0 @@
-package state
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCursorFieldReadsCanonicalTableAndLegacyLines(t *testing.T) {
-	table := []string{
-		"| Key | Value |",
-		"| --- | --- |",
-		"| phase | temper |",
-		"| status | awaiting_human |",
-		"| next_action | /rite-define |",
-	}
-	legacy := []string{
-		"- Phase: build",
-		"- Status: running",
-		"- Next step: /rite-prove",
-	}
-
-	for _, tc := range []struct {
-		name  string
-		lines []string
-		key   string
-		want  string
-	}{
-		{"table phase", table, "phase", "temper"},
-		{"table status", table, "status", "awaiting_human"},
-		{"table next alias", table, "Next step", "/rite-define"},
-		{"legacy phase", legacy, "phase", "build"},
-		{"legacy next alias", legacy, "next_action", "/rite-prove"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			got, ok := CursorField(tc.lines, tc.key)
-			if !ok || got != tc.want {
-				t.Fatalf("CursorField(%q) = %q, %v; want %q, true", tc.key, got, ok, tc.want)
-			}
-		})
-	}
-}
-
-func TestSetCursorFieldPreservesCanonicalAndLegacyFormats(t *testing.T) {
-	for _, tc := range []struct {
-		name  string
-		lines []string
-		key   string
-		value string
-		want  string
-	}{
-		{"table", []string{"| status | awaiting_human |"}, "status", "running", "| status | running |"},
-		{"legacy", []string{"- AFK slices remaining: 2"}, "afk_slices_remaining", "1", "- AFK slices remaining: 1"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			got, ok := SetCursorField(tc.lines, tc.key, tc.value)
-			if !ok || len(got) != 1 || got[0] != tc.want {
-				t.Fatalf("SetCursorField() = %v, %v; want [%q], true", got, ok, tc.want)
-			}
-		})
-	}
-}
-
-func TestUpsertAndDeleteCursorFieldStayInsideCursorTable(t *testing.T) {
-	lines := []string{
-		"# State",
-		"",
-		"## Cursor",
-		"| Key | Value |",
-		"| --- | --- |",
-		"| phase | build |",
-		"| status | running |",
-		"",
-		"## Awaiting human",
-		"| Key | Value |",
-		"| --- | --- |",
-		"| question_id | q-1 |",
-	}
-	lines = UpsertCursorField(lines, CursorReturnPhase, "build")
-	value, ok := CursorField(lines, CursorReturnPhase)
-	if !ok || value != "build" {
-		t.Fatalf("return phase=(%q,%v), want build", value, ok)
-	}
-	returnIndex, questionIndex := -1, -1
-	for i, line := range lines {
-		if strings.Contains(line, CursorReturnPhase) {
-			returnIndex = i
-		}
-		if strings.Contains(line, CursorQuestionID) {
-			questionIndex = i
-		}
-	}
-	if returnIndex < 0 || questionIndex < 0 || returnIndex > questionIndex {
-		t.Fatalf("upsert inserted outside cursor table:\n%s", strings.Join(lines, "\n"))
-	}
-	lines = DeleteCursorField(lines, CursorReturnPhase)
-	if _, ok := CursorField(lines, CursorReturnPhase); ok {
-		t.Fatalf("DeleteCursorField left return phase:\n%s", strings.Join(lines, "\n"))
-	}
-}
-
-func TestCursorHelpersIgnoreFencedExamples(t *testing.T) {
-	lines := strings.Split(`# State
-
-~~~md
-## Cursor
-| Key | Value |
-| --- | --- |
-| status | example |
-~~~
-
-## Cursor
-| Key | Value |
-| --- | --- |
-| phase | build |
-| status | running |`, "\n")
-
-	if got, ok := CursorField(lines, CursorStatus); !ok || got != "running" {
-		t.Fatalf("CursorField(status) = %q, %v; want running, true", got, ok)
-	}
-	lines, ok := SetCursorField(lines, CursorStatus, "complete")
-	if !ok || lines[6] != "| status | example |" || lines[13] != "| status | complete |" {
-		t.Fatalf("SetCursorField changed the wrong line:\n%s", strings.Join(lines, "\n"))
-	}
-	lines = UpsertCursorField(lines, CursorReturnPhase, "build")
-	if lines[6] != "| status | example |" {
-		t.Fatalf("UpsertCursorField changed fenced content:\n%s", strings.Join(lines, "\n"))
-	}
-	lines = DeleteCursorField(lines, CursorStatus)
-	if lines[6] != "| status | example |" {
-		t.Fatalf("DeleteCursorField changed fenced content:\n%s", strings.Join(lines, "\n"))
-	}
-	if _, ok := CursorField(lines, CursorStatus); ok {
-		t.Fatalf("DeleteCursorField left an authoritative status:\n%s", strings.Join(lines, "\n"))
-	}
-}
-
-func TestCursorHelpersRejectCorruptTextWithoutMutation(t *testing.T) {
-	for _, lines := range [][]string{
-		{"| status | run\x00ning |"},
-		{"| status | run\xffning |"},
-	} {
-		original := strings.Join(lines, "\n")
-		if value, ok := CursorField(lines, CursorStatus); ok || value != "" {
-			t.Fatalf("CursorField(corrupt) = %q, %v", value, ok)
-		}
-		if got, ok := SetCursorField(lines, CursorStatus, "complete"); ok || strings.Join(got, "\n") != original {
-			t.Fatalf("SetCursorField(corrupt) = %q, %v", got, ok)
-		}
-		if got := UpsertCursorField(lines, CursorStatus, "complete"); strings.Join(got, "\n") != original {
-			t.Fatalf("UpsertCursorField(corrupt) mutated input: %q", got)
-		}
-		if got := DeleteCursorField(lines, CursorStatus); strings.Join(got, "\n") != original {
-			t.Fatalf("DeleteCursorField(corrupt) mutated input: %q", got)
-		}
-	}
-}
-
-// 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"))
-	}
-}