MDS060: tighten ATX-heading guard and post-prefix indent

Two header-detection bugs surfaced by Copilot review:

- `isHeader` rejected any line whose trimmed content started with
  `#`, but `#1 | Title` is a valid first cell, not an ATX heading.
  Limit the guard to actual ATX shape — one to six `#` followed
  by space, tab, or end of line — via a new `isATXHeading` helper.
- `parseRow` checked `HasPrefix(c, "|")` against the un-trimmed
  row content, so a row like `>  | a | b |` (extra indent after
  the blockquote marker) had `leading` come out false even though
  `logicalCells` already trimmed and treated it as a real edge.
  Trim the same way before edge detection.

Addresses Copilot review feedback on PR #353.

https://claude.ai/code/session_012X1wVbY7u9DNMpGRhNurzT

Author: claude

internal/rules/tablestructure/rule.go

@@ -400,12 +400,32 @@ func isHeader(line []byte, prefix string) bool {
 	if c == "" || !containsUnescapedPipe(c) {
 		return false
 	}
-	if strings.HasPrefix(strings.TrimSpace(c), "#") {
-		return false // ATX heading, not a table header
+	if isATXHeading(c) {
+		return false
 	}
 	return !isSeparatorContent(c)
 }
 
+// isATXHeading reports whether s has the shape of a CommonMark ATX
+// heading: one to six `#` characters followed by a space, tab, or
+// end-of-line. A bare `#` at the start (e.g. `#1 | x`) is not a
+// heading and must not exclude a candidate from table parsing.
+func isATXHeading(s string) bool {
+	s = strings.TrimSpace(s)
+	n := 0
+	for n < len(s) && n < 6 && s[n] == '#' {
+		n++
+	}
+	if n == 0 {
+		return false
+	}
+	if n == len(s) {
+		return true // bare hashes, empty heading
+	}
+	c := s[n]
+	return c == ' ' || c == '\t'
+}
+
 // containsUnescapedPipe reports whether s contains a `|` that is a
 // real delimiter — that is, not escaped by a preceding `\` (with
 // backslash parity respected so `\\|` counts as unescaped).
@@ -463,8 +483,13 @@ func endsWithUnescapedPipe(s string) bool {
 
 func parseRow(line []byte, lineNum int, prefix string) tableRow {
 	c := rowContent(line, prefix)
-	lead := strings.HasPrefix(c, "|")
-	trail := endsWithUnescapedPipe(c)
+	// Extra whitespace between the prefix and the first cell — common
+	// inside list items and blockquotes with double-space indent —
+	// must not hide a real edge pipe; logicalCells already trims, so
+	// edge detection mirrors it.
+	t := strings.TrimSpace(c)
+	lead := strings.HasPrefix(t, "|")
+	trail := endsWithUnescapedPipe(t)
 	return tableRow{
 		lineNum:  lineNum,
 		leading:  lead,

internal/rules/tablestructure/rule_test.go

@@ -485,3 +485,27 @@ func TestEscapedPipeParagraphAfterTableEndsIt(t *testing.T) {
 	assert.Equal(t, "missing blank line after table", diags[0].Message)
 	assert.Equal(t, 5, diags[0].Line)
 }
+
+func TestHashStartingCellNotMistakenForHeading(t *testing.T) {
+	// `#1` (hash directly followed by a non-space) is not an ATX
+	// heading — it's a valid first cell, so the table must still
+	// be detected and clean.
+	src := "# T\n\n#1 | Title\n--- | -----\nA | B\n"
+	assert.Empty(t, check(t, StyleConsistent, src))
+}
+
+func TestIsATXHeading(t *testing.T) {
+	assert.True(t, isATXHeading("# Title"))
+	assert.True(t, isATXHeading("###### Six"))
+	assert.True(t, isATXHeading("##")) // empty heading
+	assert.False(t, isATXHeading("#1 | Title"))
+	assert.False(t, isATXHeading("####### Seven")) // >6 hashes
+	assert.False(t, isATXHeading("text"))
+}
+
+func TestParseRowIgnoresPostPrefixIndent(t *testing.T) {
+	// Extra spaces after the blockquote marker should not break
+	// leading-pipe detection: the table is valid and clean.
+	src := "# T\n\n> Intro.\n>\n>  | A | B |\n>  | - | - |\n>  | 1 | 2 |\n>\n> Outro.\n"
+	assert.Empty(t, check(t, StyleConsistent, src))
+}