Fix Google provider for large specs and improve JSON robustness

- google.go: set ResponseMIMEType=application/json to suppress code fence
  wrapping; create genai.Client per-call using caller context with defer Close()
- llm.go: handle orphaned opening fence (truncated fenced responses) in
  stripMarkdownFences; add fixInvalidJSONEscapes sanitizer for \d/\w/\s
  regex patterns LLMs embed unescaped in JSON strings
- main.go: update default Google model to gemini-2.5-flash (65k output
  tokens vs 8k for gemini-2.0-flash, required for large spec/plan files)
- README.md: update default model reference for Google provider

Smoke tested all three providers against the full specs/SPEC.md + specs/PLAN.md:
  anthropic  DRIFT_DETECTED score=78  (134s)
  openai     VIOLATION      score=60  ( 10s)
  google     VIOLATION      score=73  (117s)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Davin Hills

README.md

@@ -74,7 +74,7 @@ realitycheck check [path] [flags]
 --strict                   No inferred intent; escalate drift severities
 --fail-on <verdict>        Exit 2 if verdict >= level (ALIGNED|PARTIALLY_ALIGNED|DRIFT_DETECTED|VIOLATION)
 --severity-threshold <s>   Filter output to findings at or above INFO|WARN|CRITICAL
---model <id>               Model ID (default: claude-opus-4-6 / gpt-4o / gemini-2.0-flash per provider)
+--model <id>               Model ID (default: claude-opus-4-6 / gpt-4o / gemini-2.5-flash per provider)
 --offline                  Skip API key pre-flight check
 --verbose                  Print execution trace to stderr
 --debug                    Dump assembled prompt to stderr

cmd/realitycheck/main.go

@@ -416,7 +416,7 @@ func defaultModelForProvider(provider string) string {
 	case "openai":
 		return "gpt-4o"
 	case "google":
-		return "gemini-2.0-flash"
+		return "gemini-2.5-flash"
 	default:
 		return "claude-opus-4-6"
 	}

internal/llm/google.go

@@ -47,6 +47,9 @@ func (p *googleProvider) Complete(
 	m.MaxOutputTokens = &maxOut
 	temp32 := float32(temperature)
 	m.Temperature = &temp32
+	// Force JSON output mode to prevent the model from wrapping the response
+	// in markdown code fences.
+	m.ResponseMIMEType = "application/json"
 
 	resp, err := m.GenerateContent(ctx, genai.Text(userPrompt))
 	if err != nil {

internal/llm/llm.go

@@ -126,13 +126,24 @@ func needsRepair(errs []ValidationError) bool {
 // `.*?` (not `.+?`) to allow empty bodies inside fences.
 var fenceRe = regexp.MustCompile("(?s)^(?:`{3}|~{3})[^\\n]*\\n(.*?)(?:`{3}|~{3})\\s*$")
 
+// openFenceRe matches only an opening fence line (no closing fence required).
+// Used to strip orphaned opening fences from truncated responses.
+var openFenceRe = regexp.MustCompile("^(?:`{3}|~{3})[^\\n]*\\n")
+
 // stripMarkdownFences removes leading/trailing markdown code fences that LLMs
 // sometimes wrap around JSON output (e.g., "```json\n...\n```").
+// If only an opening fence is present (e.g., the response was truncated before
+// the closing fence), the opening line is stripped so that the JSON content can
+// still be parsed.
 func stripMarkdownFences(s string) string {
 	s = strings.TrimSpace(s)
 	if m := fenceRe.FindStringSubmatch(s); m != nil {
 		return strings.TrimSpace(m[1])
 	}
+	// Handle truncated fenced responses: strip the opening fence line only.
+	if loc := openFenceRe.FindStringIndex(s); loc != nil {
+		return strings.TrimSpace(s[loc[1]:])
+	}
 	return s
 }
 
@@ -147,14 +158,21 @@ func ValidateResponse(raw string, index codeindex.Index) (*schema.PartialReport,
 
 	raw = stripMarkdownFences(raw)
 
-	// 1. JSON parse.
+	// 1. JSON parse. If parsing fails due to invalid escape sequences (common
+	// when LLM output includes regex patterns like \d+ inside JSON strings),
+	// attempt a one-shot sanitization before giving up.
 	var report schema.PartialReport
 	if err := json.Unmarshal([]byte(raw), &report); err != nil {
-		errs = append(errs, ValidationError{
-			Field:   "json_parse",
-			Message: err.Error(),
-		})
-		return nil, errs
+		fixed := fixInvalidJSONEscapes(raw)
+		if err2 := json.Unmarshal([]byte(fixed), &report); err2 != nil {
+			errs = append(errs, ValidationError{
+				Field:   "json_parse",
+				Message: err.Error(),
+			})
+			return nil, errs
+		}
+		// Sanitized successfully; continue with the fixed payload.
+		raw = fixed
 	}
 
 	// 2. Required field check.
@@ -207,6 +225,19 @@ var (
 	violationIDRe = regexp.MustCompile(`^VIOLATION-\d+$`)
 )
 
+// invalidJSONEscapeRe matches a backslash followed by any character that is not
+// a valid JSON string escape character ("\/bfnrtu). LLMs sometimes emit regex
+// patterns (e.g. \d+, \w+) unescaped inside JSON strings; this sanitizer
+// converts them to properly double-escaped sequences (\\d, \\w, etc.) so that
+// the JSON parser accepts the response.
+var invalidJSONEscapeRe = regexp.MustCompile(`\\([^"\\/bfnrtu])`)
+
+// fixInvalidJSONEscapes replaces invalid JSON escape sequences in s with their
+// correctly double-escaped equivalents.
+func fixInvalidJSONEscapes(s string) string {
+	return invalidJSONEscapeRe.ReplaceAllString(s, `\\$1`)
+}
+
 // validateEnums checks that all enum fields contain valid constants.
 func validateEnums(r *schema.PartialReport) []ValidationError {
 	var errs []ValidationError