seal-gate 0.3.0

package/src/adapters/openai-provider.ts

@@ -0,0 +1,171 @@
+/**
+ * GenericOpenAIProvider — config-driven LLM reviewer.
+ * Reads provider config from ~/.anima/providers.d/<name>.yaml (same format ANIMA uses).
+ * Resolves ${ENV_VAR} in apiKey automatically.
+ * Auto-appends /chat/completions to baseUrl.
+ *
+ * Usage:
+ *   Seal.withLLM(createReviewerFromProvider('minimax'))
+ *   Seal.withLLM(createReviewerFromProvider('xiaomi'))
+ *   Seal.withLLM(createReviewerFromProvider('gemini'))
+ *   Seal.withLLM(new GenericOpenAIProvider({
+ *     baseUrl: 'https://api.custom.com/v1',
+ *     model: 'my-model',
+ *     apiKey: 'sk-...',
+ *   }))
+ */
+import { LLMReviewerAdapter, LLMSignals, SealInput, PartialVerdict } from '../types.js'
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export interface ProviderConfig {
+  baseUrl: string
+  model: string
+  apiKey: string
+  timeoutMs?: number
+}
+
+const SYSTEM_PROMPT = `You are Seal, a quality gate in an AI engineering workflow.
+
+Your job is NOT to be polite or creative. Detect semantic issues the deterministic rules could not catch.
+
+Review AI agent output for semantic correctness, subtle logic bugs, and missing requirements.
+The deterministic layer already checked: evidence presence, risk keywords, spec headers, test logs.
+Your focus: semantic reasoning, prose logic, subtle edge cases, spec compliance.
+
+Return ONLY valid JSON:
+{
+  "suspected_issues": ["string — exact reasoning error, max 3"],
+  "missing_requirements": ["string — spec requirement clearly absent"],
+  "possible_edge_cases": ["string — edge cases to consider"],
+  "evidence_gaps": ["string — claims needing evidence that slipped through"],
+  "risk_guess": "LOW | MEDIUM | HIGH | CRITICAL",
+  "confidence": 0.0
+}
+
+confidence: 0.0–1.0. Empty arrays if output is correct. No padding.`
+
+function buildMessage(input: SealInput, partial: PartialVerdict): string {
+  const parts: string[] = []
+  if (input.spec) parts.push(`=== SPEC ===\n${input.spec}`)
+  parts.push(`=== OUTPUT (${input.artifact_type}) ===\n${input.output}`)
+  const blocking = partial.deterministic_findings.filter(f => f.is_blocking)
+  if (blocking.length) {
+    parts.push(`=== ALREADY FLAGGED ===\n${blocking.map(f => `- [${f.rule_id ?? f.type}] ${f.evidence}`).join('\n')}`)
+  }
+  parts.push(`=== PARTIAL VERDICT ===\ntrust_score: ${partial.trust_score}, risk: ${partial.risk_level}`)
+  return parts.join('\n\n')
+}
+
+function extractJSON(raw: string): string {
+  const stripped = raw.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
+  const m = stripped.match(/\{[\s\S]*\}/)
+  return m ? m[0] : stripped
+}
+
+function resolveEnvRef(value: string): string {
+  // Resolve ${VAR_NAME} pattern
+  return value.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? '')
+}
+
+/** Load and parse a provider YAML from ~/.anima/providers.d/<name>.yaml */
+export function loadProviderConfig(name: string, modelIndex = 0): ProviderConfig {
+  const path = join(homedir(), '.anima', 'providers.d', `${name}.yaml`)
+  let raw: string
+  try {
+    raw = readFileSync(path, 'utf-8')
+  } catch {
+    throw new Error(`Provider config not found: ${path}`)
+  }
+
+  // Minimal YAML parser — handles the providers.d format
+  const get = (key: string) => {
+    const m = raw.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))
+    return m ? m[1].trim().replace(/^["']|["']$/g, '') : ''
+  }
+
+  const baseUrl = get('baseUrl')
+  const rawKey  = get('apiKey')
+  const apiKey  = resolveEnvRef(rawKey)
+
+  // Extract models list (lines like "  - id: MiniMax-M3")
+  const models = [...raw.matchAll(/^\s+-\s+id:\s+(.+)$/gm)].map(m => m[1].trim())
+  const model = models[modelIndex] ?? models[0] ?? 'default'
+
+  if (!baseUrl) throw new Error(`Provider ${name}: baseUrl missing`)
+
+  return { baseUrl, model, apiKey }
+}
+
+export class GenericOpenAIProvider implements LLMReviewerAdapter {
+  private config: Required<ProviderConfig>
+
+  constructor(config: ProviderConfig) {
+    this.config = { timeoutMs: 30_000, ...config }
+  }
+
+  async review(input: SealInput, partial: PartialVerdict): Promise<LLMSignals> {
+    const { baseUrl, model, apiKey, timeoutMs } = this.config
+    const endpoint = baseUrl.endsWith('/chat/completions')
+      ? baseUrl
+      : `${baseUrl.replace(/\/$/, '')}/chat/completions`
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+    let response: Response
+    try {
+      response = await fetch(endpoint, {
+        signal: controller.signal,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': apiKey ? `Bearer ${apiKey}` : 'Bearer none',
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user',   content: buildMessage(input, partial) },
+          ],
+          response_format: { type: 'json_object' },
+          temperature: 0.1,
+          max_tokens: 1024,
+        }),
+      })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`[${model}] ${response.status}: ${body.slice(0, 200)}`)
+    }
+
+    const data = await response.json() as { choices: Array<{ message: { content: string } }> }
+    const raw = data.choices?.[0]?.message?.content ?? '{}'
+
+    let signals: Partial<LLMSignals>
+    try { signals = JSON.parse(extractJSON(raw)) }
+    catch { throw new Error(`[${model}] invalid JSON: ${raw.slice(0, 200)}`) }
+
+    const VALID_RISKS = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']
+    return {
+      suspected_issues:     Array.isArray(signals.suspected_issues)    ? signals.suspected_issues    : [],
+      missing_requirements: Array.isArray(signals.missing_requirements) ? signals.missing_requirements : [],
+      possible_edge_cases:  Array.isArray(signals.possible_edge_cases)  ? signals.possible_edge_cases  : [],
+      evidence_gaps:        Array.isArray(signals.evidence_gaps)        ? signals.evidence_gaps        : [],
+      risk_guess:           VALID_RISKS.includes(signals.risk_guess ?? '') ? signals.risk_guess as LLMSignals['risk_guess'] : 'MEDIUM',
+      confidence:           typeof signals.confidence === 'number' ? Math.max(0, Math.min(1, signals.confidence)) : 0.5,
+    }
+  }
+}
+
+/**
+ * Create a reviewer from ~/.anima/providers.d/<name>.yaml
+ * modelIndex: which model from the models list (default 0 = first/best)
+ */
+export function createReviewerFromProvider(name: string, modelIndex = 0): GenericOpenAIProvider {
+  return new GenericOpenAIProvider(loadProviderConfig(name, modelIndex))
+}

package/src/cli.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { Seal } from './index.js'
+import { ArtifactType, RiskLevel } from './types.js'
+import { readFileSync, existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const BOLD = '\x1b[1m'
+const DIM = '\x1b[2m'
+const RED = '\x1b[31m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const CYAN = '\x1b[36m'
+const RESET = '\x1b[0m'
+
+function colorForVerdict(v: string): string {
+  if (v === 'PASS') return GREEN
+  if (v === 'PASS_WITH_WARNINGS') return YELLOW
+  return RED
+}
+
+function usage() {
+  console.log(`
+${BOLD}seal${RESET} — AI quality gate
+
+${BOLD}USAGE${RESET}
+  seal <command> [options]
+
+${BOLD}COMMANDS${RESET}
+  ${CYAN}code${RESET}     <file>       Review code output / diff (default mode)
+  ${CYAN}plan${RESET}     <file>       Review plan, design, or spec (plan_review mode)
+  ${CYAN}review${RESET}   <file>       Review with full control over artifact type
+
+${BOLD}OPTIONS${RESET}
+  --spec <file>                Spec file for compliance check
+  --locked-criteria <file>     JSON file with locked acceptance criteria (plan_review)
+  --risk <level>               Risk hint: low, medium, high, critical
+  --agent-id <id>              Agent identifier for trust memory
+  --json                       Raw JSON output (no formatting)
+  --artifact-type <type>       Override: llm_response, code_diff, test_plan, design, migration, plan_review
+
+${BOLD}EXAMPLES${RESET}
+  ${DIM}# Review a code change${RESET}
+  seal code src/auth.ts --spec specs/auth.md
+
+  ${DIM}# Review a plan/spec against locked criteria${RESET}
+  seal plan spec.md --locked-criteria intent-criteria.json
+
+  ${DIM}# Full control mode${RESET}
+  seal review output.md --artifact-type plan_review --locked-criteria criteria.json
+`)
+  process.exit(2)
+}
+
+function parseArgs(args: string[]) {
+  const parsed: Record<string, string | boolean> = {}
+  let positional: string[] = []
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2)
+      if (['json'].includes(key)) { parsed[key] = true; continue }
+      parsed[key] = args[++i] ?? ''
+    } else {
+      positional.push(args[i])
+    }
+  }
+  return { positional, parsed }
+}
+
+function formatVerdict(v: any, json: boolean) {
+  if (json) {
+    console.log(JSON.stringify(v, null, 2))
+    return
+  }
+
+  const c = colorForVerdict(v.verdict)
+  const scoreBar = v.trust_score >= 90 ? '██████████' :
+                   v.trust_score >= 70 ? '███████░░░' :
+                   v.trust_score >= 50 ? '█████░░░░░' :
+                   v.trust_score >= 30 ? '███░░░░░░░' : '█░░░░░░░░░'
+
+  console.log(`\n${BOLD}┌─ Seal Verdict ──────────────────────────────┐${RESET}`)
+  console.log(`${BOLD}│${RESET}  ${c}${BOLD}${v.verdict}${RESET}  ${DIM}(trust: ${v.trust_score})${RESET}  ${scoreBar}`)
+  console.log(`${BOLD}│${RESET}  Risk: ${v.risk_level}`)
+  console.log(`${BOLD}│${RESET}  ${v.summary}`)
+
+  if (v.blocking_issues?.length > 0) {
+    console.log(`${BOLD}│${RESET}`)
+    console.log(`${BOLD}│${RESET}  ${RED}${BOLD}Blocking Issues:${RESET}`)
+    for (const issue of v.blocking_issues) {
+      console.log(`${BOLD}│${RESET}    ${RED}✗${RESET} [${issue.rule_id}] ${issue.evidence}`)
+    }
+  }
+
+  if (v.non_blocking_issues?.length > 0) {
+    console.log(`${BOLD}│${RESET}`)
+    console.log(`${BOLD}│${RESET}  ${YELLOW}Non-blocking:${RESET}`)
+    for (const issue of v.non_blocking_issues) {
+      console.log(`${BOLD}│${RESET}    ${YELLOW}⚠${RESET} [${issue.rule_id}] ${issue.evidence}`)
+    }
+  }
+
+  if (v.deterministic_findings?.length === 0 && v.blocking_issues?.length === 0) {
+    console.log(`${BOLD}│${RESET}`)
+    console.log(`${BOLD}│${RESET}  ${GREEN}✓${RESET} No issues found`)
+  }
+
+  console.log(`${BOLD}│${RESET}  ${DIM}Next: ${v.next_action}${RESET}`)
+  console.log(`${BOLD}└────────────────────────────────────────────┘${RESET}`)
+}
+
+async function run(args: string[]) {
+  const { positional, parsed } = parseArgs(args)
+  const cmd = positional[0]
+
+  if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') usage()
+
+  let artifactFile: string | null = null
+  let artifactType: ArtifactType = 'llm_response'
+  let specFile: string | null = null
+  let lockedCriteriaFile: string | null = null
+  let riskHint: RiskLevel | null = null
+  let agentId: string | null = null
+  let jsonOutput = !!parsed['json']
+
+  switch (cmd) {
+    case 'code':
+      artifactFile = positional[1]
+      artifactType = 'code_diff'
+      break
+    case 'plan':
+    case 'spec':
+    case 'design':
+      artifactFile = positional[1]
+      artifactType = 'plan_review'
+      break
+    case 'review':
+      artifactFile = positional[1]
+      artifactType = (parsed['artifact-type'] as ArtifactType) ?? 'llm_response'
+      break
+    default:
+      // `seal <file>` shorthand — treat first arg as file
+      if (existsSync(cmd)) {
+        artifactFile = cmd
+        artifactType = 'llm_response'
+      } else {
+        console.error(`Unknown command or file not found: ${cmd}`)
+        usage()
+      }
+  }
+
+  if (!artifactFile) { console.error('Error: no file specified'); usage() }
+
+  const filePath = artifactFile as string
+  if (!existsSync(filePath)) {
+    console.error(`Error: file not found: ${filePath}`)
+    process.exit(2)
+  }
+
+  // Resolve optional flags
+  if (parsed['spec']) { specFile = parsed['spec'] as string }
+  if (parsed['locked-criteria']) { lockedCriteriaFile = parsed['locked-criteria'] as string }
+  if (parsed['risk']) { riskHint = parsed['risk'] as RiskLevel }
+  if (parsed['agent-id']) { agentId = parsed['agent-id'] as string }
+  // Load files
+  const output = readFileSync(resolve(filePath), 'utf-8')
+  const spec = specFile && existsSync(specFile) ? readFileSync(resolve(specFile), 'utf-8') : null
+  const evidence = { test_log: '', build_log: '', diff: '', references: [] }
+
+  const lockedCriteria = lockedCriteriaFile && existsSync(lockedCriteriaFile)
+    ? JSON.parse(readFileSync(resolve(lockedCriteriaFile), 'utf-8'))
+    : []
+
+  const context: Record<string, unknown> = {}
+  if (agentId) context.agent_id = agentId
+  if (lockedCriteria.length > 0) context.locked_criteria = lockedCriteria
+
+  if (!jsonOutput) {
+    console.log(`${DIM}Seal reviewing ${artifactFile} (${artifactType})...${RESET}`)
+  }
+
+  const verdict = await Seal.review({
+    artifact_type: artifactType,
+    spec,
+    output,
+    evidence,
+    risk_hint: riskHint,
+    context: Object.keys(context).length > 0 ? context : undefined,
+  })
+
+  formatVerdict(verdict, jsonOutput)
+
+  const passing = verdict.verdict === 'PASS' || verdict.verdict === 'PASS_WITH_WARNINGS'
+  process.exit(passing ? 0 : 1)
+}
+
+run(process.argv.slice(2)).catch(err => {
+  console.error(`Error: ${err.message}`)
+  process.exit(1)
+})

package/src/detectors/artifact-classifier.ts

@@ -0,0 +1,21 @@
+import { ArtifactType } from '../types.js'
+
+export interface ArtifactContext {
+  artifact_type: ArtifactType
+  activates: string[]
+}
+
+const RULE_ACTIVATIONS: Record<ArtifactType, string[]> = {
+  migration:    ['AX503', 'TW201'],
+  code_diff:    ['TW201', 'TW203'],
+  test_plan:    ['TW202'],
+  llm_response: ['TW201'],
+  design:       [],
+  plan_review:  ['PR001', 'PR002', 'PR003', 'PR004'],
+}
+
+export class ArtifactClassifier {
+  static classify(artifact_type: ArtifactType): ArtifactContext {
+    return { artifact_type, activates: RULE_ACTIVATIONS[artifact_type] ?? [] }
+  }
+}

package/src/detectors/claim-extractor.ts

@@ -0,0 +1,209 @@
+import { Claim, ClaimType, StructuralClaim, StructuralClaimType } from '../types.js'
+
+const CLAIM_PATTERNS: Array<{ type: ClaimType; pattern: RegExp }> = [
+  { type: 'test_result_claim',    pattern: /\b(all tests? pass(?:ed)?|tests? pass(?:ed)?|verified|tested)\b/gi },
+  { type: 'implementation_claim', pattern: /\b(implemented|fixed|completed|resolved|built|deployed)\b/gi },
+  { type: 'compatibility_claim',  pattern: /\b(backward.?compatible|no breaking changes|fully compatible)\b/gi },
+  { type: 'risk_claim',           pattern: /\b(no security impact|safe|secure|no risk)\b/gi },
+  { type: 'build_claim',          pattern: /\b(build succeeded|compiled|build pass(?:ed)?|build is (?:clean|green))\b/gi },
+  { type: 'production_claim',     pattern: /\b(production.?ready|ready for (?:production|deploy|release))\b/gi },
+  { type: 'generic_claim',        pattern: /\b(definitely|guaranteed|fully|completely|all good|no issues)\b/gi },
+]
+
+/**
+ * Structural patterns for extracting claims from code diffs.
+ * Each pattern targets a specific structural concern.
+ */
+const STRUCTURAL_PATTERNS: Array<{
+  type: StructuralClaimType
+  detect: RegExp
+  extract: (match: RegExpExecArray, lineNum: number, diff: string) => StructuralClaim | null
+}> = [
+  // HTTP endpoint detection (Express/Fastify, NestJS, Hono, Python Flask/FastAPI, Go Gin)
+  {
+    type: 'structural_endpoint',
+    detect: /(?:app|router|route|server)\.(?:get|post|put|delete|patch|all)\(['"`](\/[^'"`]+)['"`]/gi,
+    extract: (match, lineNum) => ({
+      type: 'structural_endpoint' as StructuralClaimType,
+      target: match[1],
+      line: lineNum,
+      description: `HTTP endpoint: ${match[1]}`,
+      change_type: 'added',
+    }),
+  },
+  // Decorator-based endpoints (NestJS, Spring, FastAPI)
+  {
+    type: 'structural_endpoint',
+    detect: /@(?:Get|Post|Put|Delete|Patch)\(['"`]?(\/[^'"`) ]*)?['"`]?\)/gi,
+    extract: (match, lineNum) => ({
+      type: 'structural_endpoint' as StructuralClaimType,
+      target: match[1] || '/',
+      line: lineNum,
+      description: `Decorator endpoint: ${match[1] || '/'}`,
+      change_type: 'added',
+    }),
+  },
+  // Auth-related changes — match auth, guard, middleware constructs
+  {
+    type: 'structural_auth',
+    detect: /(?:@Authenticated|@Authorize|requireAuth|ensureAuth|authenticate|authorize)\b|\b(auth|guard)\b/gi,
+    extract: (match, lineNum) => ({
+      type: 'structural_auth' as StructuralClaimType,
+      target: match[0],
+      line: lineNum,
+      description: `Auth construct: ${match[0]}`,
+      change_type: 'modified',
+    }),
+  },
+  // Database migrations — SQL + ORM-based (createTable, create_table)
+  {
+    type: 'structural_migration',
+    detect: /\b(CREATE\s+TABLE|ALTER\s+TABLE|DROP\s+TABLE|migration.*\.[a-z]+|schema\.php|createTable|create_table)\b/gi,
+    extract: (match, lineNum, diff) => {
+      const lines = diff.split('\n')
+      const context = lines.slice(Math.max(0, lineNum - 3), lineNum + 2).join('\n')
+      const hasRollback = /\b(rollback|down\s+migration|revert)\b/i.test(context)
+      return {
+        type: 'structural_migration' as StructuralClaimType,
+        target: match[0],
+        line: lineNum,
+        description: `Migration: ${match[0]}`,
+        has_rollback: hasRollback,
+        change_type: 'added',
+      }
+    },
+  },
+  // Dependency manifest changes
+  {
+    type: 'structural_dependency',
+    detect: /^[+-]\s+(['"`]?@?\w[^'"]*['"`]?\s*:\s*['"`]?\^?[\d.]+['"`]?)/gm,
+    extract: (match, lineNum, diff) => {
+      const isAdded = match[0].startsWith('+')
+      return {
+        type: 'structural_dependency' as StructuralClaimType,
+        target: match[1]?.trim() || match[0].trim(),
+        line: lineNum,
+        description: `Dependency ${isAdded ? 'added' : 'removed'}: ${match[1]?.trim() || ''}`,
+        change_type: isAdded ? 'added' : 'removed',
+      }
+    },
+  },
+]
+
+function stripCodeFences(text: string): { stripped: string; fenceRanges: Array<[number, number]> } {
+  const fenceRanges: Array<[number, number]> = []
+  const blockFence = /```[\s\S]*?```/g
+  let match: RegExpExecArray | null
+  while ((match = blockFence.exec(text)) !== null) {
+    fenceRanges.push([match.index, match.index + match[0].length])
+  }
+  const inlineFence = /`[^`\n]+`/g
+  while ((match = inlineFence.exec(text)) !== null) {
+    fenceRanges.push([match.index, match.index + match[0].length])
+  }
+  return { stripped: text, fenceRanges }
+}
+
+function isInFence(pos: number, fenceRanges: Array<[number, number]>): boolean {
+  return fenceRanges.some(([start, end]) => pos >= start && pos < end)
+}
+
+function getLineNumber(text: string, pos: number): number {
+  return text.slice(0, pos).split('\n').length
+}
+
+export class ClaimExtractor {
+  /** Extract behavioral claims from output text */
+  static extract(text: string): Claim[] {
+    const { fenceRanges } = stripCodeFences(text)
+    const usedSpans = new Set<string>()
+    const claims: Claim[] = []
+
+    for (const { type, pattern } of CLAIM_PATTERNS) {
+      pattern.lastIndex = 0
+      let match: RegExpExecArray | null
+      while ((match = pattern.exec(text)) !== null) {
+        const start = match.index
+        const end = match.index + match[0].length
+        const spanKey = `${start}-${end}`
+
+        if (isInFence(start, fenceRanges)) continue
+        if (usedSpans.has(spanKey)) continue
+
+        let overlaps = false
+        for (const span of usedSpans) {
+          const [s, e] = span.split('-').map(Number)
+          if (start < (e ?? 0) && end > (s ?? 0)) { overlaps = true; break }
+        }
+        if (overlaps) continue
+
+        usedSpans.add(spanKey)
+        claims.push({ text: match[0], type, start_pos: start, end_pos: end, requires_evidence: true })
+      }
+    }
+
+    return claims.sort((a, b) => a.start_pos - b.start_pos)
+  }
+
+  static getUsedSpans(claims: Claim[]): Set<string> {
+    return new Set(claims.map(c => `${c.start_pos}-${c.end_pos}`))
+  }
+
+  /**
+   * Extract structural claims from a code diff.
+   * The diff should be in unified diff format (git diff output or similar).
+   */
+  static extractStructural(diff: string): StructuralClaim[] {
+    if (!diff || diff.trim() === '') return []
+
+    const claims: StructuralClaim[] = []
+    const lines = diff.split('\n')
+
+    // If it looks like a git diff, only scan added/modified lines
+    const isGitDiff = diff.includes('diff --git') || diff.includes('--- a/')
+    const contentLines: Array<{ text: string; lineNum: number }> = []
+
+    if (isGitDiff) {
+      let currentLine = 0
+      for (const line of lines) {
+        currentLine++
+        // Only scan added/modified lines (starting with +) and context/diff headers
+        if (line.startsWith('+')) {
+          contentLines.push({ text: line.slice(1), lineNum: currentLine })
+        }
+        // Also check diff headers for file names (package.json, migrations, etc.)
+        if (line.startsWith('diff --git')) {
+          contentLines.push({ text: line, lineNum: currentLine })
+        }
+        // Check for migration files in diff headers
+        if (line.startsWith('+++ b/') || line.startsWith('--- a/')) {
+          contentLines.push({ text: line, lineNum: currentLine })
+        }
+      }
+    } else {
+      // Plain text — use all lines
+      lines.forEach((text, i) => contentLines.push({ text, lineNum: i + 1 }))
+    }
+
+    // Scan for structural patterns
+    for (const { type, detect, extract } of STRUCTURAL_PATTERNS) {
+      detect.lastIndex = 0
+      const singleContent = contentLines.map(l => l.text).join('\n')
+
+      let match: RegExpExecArray | null
+      while ((match = detect.exec(singleContent)) !== null) {
+        const matchLineNum = getLineNumber(singleContent, match.index)
+        // Find the closest content line
+        const contentLine = contentLines.find(l => l.lineNum >= matchLineNum) ?? contentLines[contentLines.length - 1]
+        if (!contentLine) continue
+
+        const claim = extract(match, contentLine.lineNum, singleContent)
+        if (claim && !claims.some(c => c.type === claim.type && c.target === claim.target && c.line === claim.line)) {
+          claims.push(claim)
+        }
+      }
+    }
+
+    return claims
+  }
+}