schema: count out-of-order run before reporting min shortfall

claimOutOfOrder previously emitted "matched 1 times, required at
least N" the moment it recovered, even when the document
contained a contiguous run of N+ same-scope headings before the
expected position. A doc like `## B, ## B, ## A` against an
`A, B (repeat: min 2)` schema satisfies B's minimum count — only
the ordering is wrong, which the out-of-order message already
calls out. The spurious cardinality diagnostic added confusion.

The recovery path still claims only the leading occurrence so
child recursion has a single anchor; the new countMatchingRun
helper walks ahead at the expected level (skipping deeper
headings as body content) and reports the actual run length.

Regression: TestPlan156_OutOfOrderRunCountsAvailableMatches.

https://claude.ai/code/session_012GGH62fZUzLuzP8T4ocGkJ

Author: claude

internal/schema/plan156_acceptance_test.go

@@ -1111,3 +1111,46 @@ func TestPlan156_AcronymScopeMatchesByHeadingText(t *testing.T) {
 		"acronyms.scope must match the actual matched heading text, "+
 			"not just the schema label or the raw regex body")
 }
+
+// TestPlan156_OutOfOrderRunCountsAvailableMatches regresses a
+// Copilot review finding: when an out-of-order recovery occurs on
+// a scope with `repeat.min > 1`, the diagnostic must count the
+// available run of consecutive matches rather than always
+// emitting "matched 1 times". Otherwise a document that contains
+// enough occurrences of B (just before A) gets a spurious
+// "matched 1 times, required at least 2" diagnostic on top of
+// the legitimate out-of-order message.
+func TestPlan156_OutOfOrderRunCountsAvailableMatches(t *testing.T) {
+	raw := map[string]any{
+		"sections": []any{
+			map[string]any{"heading": "A"},
+			map[string]any{
+				"heading": map[string]any{
+					"regex":  "B",
+					"repeat": map[string]any{"min": 2, "max": 5},
+				},
+			},
+		},
+	}
+	sch, err := ParseInline(raw, "kind x")
+	require.NoError(t, err)
+	// Two B's before the expected A — B's min cardinality is
+	// satisfied by the run, only the ordering is wrong.
+	doc := newDocFile(t, "doc.md",
+		"# T\n\n## B\n\n## B\n\n## A\n")
+	diags := Validate(doc, sch, nil, false, makeDiagForTest)
+	var outOfOrder, falseMin int
+	for _, d := range diags {
+		if strings.Contains(d.Message, "out of order") {
+			outOfOrder++
+		}
+		if strings.Contains(d.Message, "matched 1 times") {
+			falseMin++
+		}
+	}
+	assert.GreaterOrEqual(t, outOfOrder, 1,
+		"the out-of-order condition must still be reported")
+	assert.Zero(t, falseMin,
+		"a contiguous B-run that satisfies min must not get a "+
+			"`matched 1 times, required at least 2` diagnostic")
+}

internal/schema/validate.go

@@ -728,25 +728,20 @@ func claimOutOfOrder(
 			formatHeading(dh.Level, dh.Text),
 			formatHeading(expectedLevel, displayHeading(sc))))}
 	diags = append(diags, levelDiagIfNeeded(f, dh, expectedLevel, mkDiag)...)
-	// The out-of-order claim only consumes one heading. A repeated
-	// late scope (`repeat.min > 1`) gets a cardinality diagnostic
-	// so the min contract is enforced even on the recovery path.
-	// `repeat.max > 1` and `sequential: true` constraints are not
-	// fully enforced here — the trailing-leftover loop flags
-	// additional matching headings via claimedScopeMatches as
-	// "exceeds scope's allowed occurrences", but the run-style
-	// sequential check is not retraced for out-of-order claims.
-	// Authors who need contiguous-run guarantees should put the
-	// repeated scope at its natural position in the schema; the
-	// in-order matchScope path is the canonical enforcement
-	// surface for max and sequential.
-	if ooSc.Matcher != nil && ooSc.Matcher.Repeat.Min > 1 {
+	// Count the contiguous run of same-level headings starting at
+	// docIdx that match ooSc. The recovery path still claims only
+	// the leading occurrence (so child recursion has a single
+	// anchor), but counting the full run avoids reporting a false
+	// `repeat.min` shortfall when the document does contain enough
+	// occurrences — they are simply in the wrong position, which
+	// the out-of-order diagnostic already calls out.
+	runLen := countMatchingRun(ooSc, docHeads, docIdx, expectedLevel, docFM)
+	if ooSc.Matcher != nil && runLen < ooSc.Matcher.Repeat.Min {
 		diags = append(diags, mkDiag(f.Path, dh.Line,
 			fmt.Sprintf(
-				"section %q matched 1 times, required at least %d "+
-					"(out-of-order recovery only counts the first occurrence)",
+				"section %q matched %d times, required at least %d",
 				formatHeading(expectedLevel, displayHeading(ooSc)),
-				ooSc.Matcher.Repeat.Min)))
+				runLen, ooSc.Matcher.Repeat.Min)))
 	}
 	if ooSc.Matcher != nil && ooSc.Matcher.Sequential {
 		diags = append(diags, mkDiag(f.Path, dh.Line,
@@ -769,6 +764,34 @@ func claimOutOfOrder(
 	return docIdx, diags
 }
 
+// countMatchingRun returns the number of contiguous same-level
+// headings starting at docIdx that match sc's matcher. Deeper
+// headings (level > expectedLevel) are skipped as body content of
+// an already-matched section, mirroring matchScope's run
+// semantics. The walk stops at the first same-level non-match or
+// the first shallower-than-expected heading.
+func countMatchingRun(
+	sc Scope, docHeads []DocHeading, docIdx, expectedLevel int,
+	docFM map[string]any,
+) int {
+	run := 0
+	for i := docIdx; i < len(docHeads); i++ {
+		dh := docHeads[i]
+		if dh.Level < expectedLevel {
+			return run
+		}
+		if dh.Level > expectedLevel {
+			continue
+		}
+		if matched, _ := matchHeading(sc.Matcher, dh, docFM); matched {
+			run++
+			continue
+		}
+		return run
+	}
+	return run
+}
+
 // findOutOfOrderIdx returns the first unclaimed scope at index >=
 // minIdx that matches dh.
 func findOutOfOrderIdx(