Close the F5 silent-corruption path in taskCheckBoxEdits

The previous round's nil/empty-Lines guards did NOT prevent the
silent-corruption case the F5 finding pointed at: NearestBlockAncestor
SKIPS ancestors with empty Lines() and keeps walking up, so a
TaskCheckBox under a Paragraph-with-empty-Lines under a
ListItem-with-populated-Lines yields block=ListItem and start =
bullet-position, not '['-position. The guards both pass; start+3
deletes three bytes from the wrong block.

Add an explicit `f.Source[start] != '['` check that declines the
edit when the byte at Lines.At(0).Start is not the bracket the
task-list parser's invariant promises, plus a bounds check on
start+3 against len(f.Source) for the truly-short-source case.

Three new red/green tests pin the guard:
- non-bracket start (paragraph with arbitrary Lines)
- nil block ancestor (orphan TaskCheckBox)
- bracket runs past EOF (2-byte source)

https://claude.ai/code/session_0144ZKUS2Zrg7xBft54qyoti

Author: claude

internal/rules/markdownflavor/fix.go

@@ -145,15 +145,14 @@ func delimiterPairEdits(n ast.Node, markerLen int) []markdown.Edit {
 // taskCheckBoxEdits removes the "[X]" run plus a single trailing
 // space when present. Per the plan, the bullet itself is preserved.
 //
-// Relies on the goldmark task-list parser's invariant: it always
-// wraps a TaskCheckBox in a TextBlock whose first Lines() segment
-// starts at the '['. NearestBlockAncestor returns that TextBlock,
-// so block.Lines().At(0).Start indexes the bracket. If a hand-built
-// AST violates the invariant — TextBlock has empty Lines so
-// NearestBlockAncestor returns the enclosing ListItem instead —
-// start would point at the bullet ('- ') and start+3 would silently
-// delete the wrong bytes. The fix declines via the block==nil /
-// empty-Lines guards rather than producing corrupt output.
+// Relies on the goldmark task-list parser's invariant: it wraps a
+// TaskCheckBox in a TextBlock whose first Lines() segment starts at
+// the '['. The explicit `source[start] == '['` guard rejects the
+// case where a hand-built AST violates the invariant —
+// NearestBlockAncestor skips ancestors with empty Lines() so it can
+// return the enclosing ListItem (whose Lines start at the bullet,
+// not at '[') — and decline rather than silently delete three
+// arbitrary bytes from the wrong block.
 func taskCheckBoxEdits(f *lint.File, n *extast.TaskCheckBox) []markdown.Edit {
 	block := flavor.NearestBlockAncestor(n)
 	if block == nil {
@@ -164,7 +163,13 @@ func taskCheckBoxEdits(f *lint.File, n *extast.TaskCheckBox) []markdown.Edit {
 		return nil
 	}
 	start := lines.At(0).Start
+	if start < 0 || start >= len(f.Source) || f.Source[start] != '[' {
+		return nil
+	}
 	end := start + 3
+	if end > len(f.Source) {
+		return nil
+	}
 	if end < len(f.Source) && f.Source[end] == ' ' {
 		end++
 	}

internal/rules/markdownflavor/fix_test.go

@@ -5,7 +5,11 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/yuin/goldmark/ast"
+	extast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/text"
 
+	"github.com/jeduden/mdsmith/internal/lint"
 	"github.com/jeduden/mdsmith/pkg/markdown/flavor/ext"
 )
 
@@ -174,6 +178,57 @@ func TestRuleDualNodeEditsSupportedFeaturesReturnNil(t *testing.T) {
 	assert.Nil(t, r.dualNodeEdits(nil, &ext.SubscriptNode{}))
 }
 
+// TestTaskCheckBoxEditsDeclinesOnNonBracketStart hand-constructs an
+// AST that breaks the goldmark task-list invariant — a TaskCheckBox
+// whose NearestBlockAncestor returns a block starting at a non-'['
+// byte (here a bare paragraph). The guard must decline rather than
+// silently delete the wrong three bytes; this is the F5 case the
+// per-node Lines-empty check missed.
+func TestTaskCheckBoxEditsDeclinesOnNonBracketStart(t *testing.T) {
+	// Source where offset 0 is 'p', not '['; NearestBlockAncestor's
+	// returned block.Lines().At(0).Start will point at 'p'.
+	src := []byte("plain paragraph text\n")
+	f, err := lint.NewFile("t.md", src)
+	require.NoError(t, err)
+
+	para := ast.NewParagraph()
+	para.Lines().Append(text.NewSegment(0, len(src)-1))
+	cb := extast.NewTaskCheckBox(true)
+	para.AppendChild(para, cb)
+
+	got := taskCheckBoxEdits(f, cb)
+	assert.Nil(t, got,
+		"taskCheckBoxEdits must decline when Lines.At(0) is not at '['")
+}
+
+// TestTaskCheckBoxEditsDeclinesOnNilBlock exercises the block==nil
+// guard with a TaskCheckBox that has no parent at all.
+func TestTaskCheckBoxEditsDeclinesOnNilBlock(t *testing.T) {
+	src := []byte("- [ ] task\n")
+	f, err := lint.NewFile("t.md", src)
+	require.NoError(t, err)
+	orphan := extast.NewTaskCheckBox(true)
+	assert.Nil(t, taskCheckBoxEdits(f, orphan))
+}
+
+// TestTaskCheckBoxEditsDeclinesWhenBracketRunsPastEOF guards the
+// end > len(source) branch: a TaskCheckBox at offset len-1 (last
+// byte is '[' with no body after it) cannot produce a 3-byte edit.
+func TestTaskCheckBoxEditsDeclinesWhenBracketRunsPastEOF(t *testing.T) {
+	// Two bytes: "[\n" — start points at '['; start+3 exceeds the
+	// 2-byte body. The fix must decline rather than build an edit
+	// whose End is past EOF (which markdown.Splice would panic on).
+	src := []byte("[\n")
+	f, err := lint.NewFile("t.md", src)
+	require.NoError(t, err)
+	para := ast.NewParagraph()
+	para.Lines().Append(text.NewSegment(0, len(src)))
+	cb := extast.NewTaskCheckBox(true)
+	para.AppendChild(para, cb)
+
+	assert.Nil(t, taskCheckBoxEdits(f, cb))
+}
+
 // Splice's single-pass behaviour (adjacent edits, pure insertion,
 // replacement bytes) is exercised in pkg/markdown's TestSplice; the
 // rule layer just feeds edits into markdown.Splice.