structverify 0.3.0__py3-none-any.whl

structverify/utils/logger.py

@@ -0,0 +1,81 @@
+"""
+utils/logger.py — 로깅 + 중앙 설정(configure_logging)
+
+기본(설정 안 함): 각 모듈 로거가 stdout 핸들러로 INFO 출력.
+`configure_logging(...)` 호출 시: 콘솔(+선택적 파일)에 깔끔한 포맷으로 출력하고,
+verbose=False면 내부 상세 로그는 숨기고 검증/에이전트 핵심 로그만 남긴다.
+"""
+import logging
+import sys
+
+logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)
+
+_DEFAULT_FMT = logging.Formatter(
+    "[%(asctime)s] %(levelname)s %(name)s — %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+
+# verbose=False일 때 조용히 할 내부 모듈 (핵심 결과 로그만 남긴다)
+_NOISY = (
+    "structverify.utils", "structverify.retrieval", "structverify.graph",
+    "structverify.storage", "structverify.preprocessing", "structverify.memory",
+)
+
+# 중앙 로깅 설정 상태
+_CONF: dict = {"on": False, "level": logging.INFO, "verbose": False,
+               "file": None, "handlers": []}
+
+
+def _apply(logger: logging.Logger, name: str) -> None:
+    """중앙 설정을 한 로거에 적용."""
+    logger.handlers = list(_CONF["handlers"])
+    logger.propagate = False
+    # 핵심(agent/verification/core 등)은 설정 레벨, 내부 소음 모듈은 ERROR로 침묵.
+    quiet = (not _CONF["verbose"]) and name.startswith(_NOISY)
+    logger.setLevel(logging.ERROR if quiet else _CONF["level"])
+
+
+def get_logger(name: str, level: str = "INFO") -> logging.Logger:
+    logger = logging.getLogger(name)
+    if _CONF["on"]:
+        # 중앙 설정 활성 — 새로 만들어진 로거도 동일 정책 적용
+        _apply(logger, name)
+        return logger
+    if not logger.handlers:
+        h = logging.StreamHandler(sys.stdout)
+        h.setFormatter(_DEFAULT_FMT)
+        logger.addHandler(h)
+        logger.propagate = False
+    logger.setLevel(getattr(logging, level.upper(), logging.INFO))
+    return logger
+
+
+def configure_logging(file: str | None = None, *, level: str = "INFO",
+                      verbose: bool = False) -> None:
+    """StructVerify 로깅을 설정한다.
+
+    콘솔에 로그를 출력하고, ``file`` 을 주면 그 파일에도 함께 저장한다.
+    이후 생성되는 로거에도 자동 적용된다.
+
+    Args:
+        file: 로그를 함께 저장할 파일 경로 (예: ``"verification.log"``). None이면 콘솔만.
+        level: 로그 레벨 — ``"INFO"`` | ``"DEBUG"`` | ``"WARNING"``.
+        verbose: False(기본)면 검증·에이전트 등 **핵심 로그만**, True면 내부 상세까지.
+
+    Example:
+        >>> import structverify as sv
+        >>> sv.configure_logging("verification.log")   # 콘솔 + 파일 저장
+        >>> rules = sv.Ruleset.from_file("rules.pdf", provider="upstage", agent=True)
+        >>> rules.check("...")   # 에이전트 검색·판정 로그가 콘솔·파일에 남는다
+    """
+    lvl = getattr(logging, level.upper(), logging.INFO)
+    console = logging.StreamHandler(sys.stdout)
+    console.setFormatter(logging.Formatter("%(message)s"))
+    handlers: list[logging.Handler] = [console]
+    if file:
+        fh = logging.FileHandler(file, mode="w", encoding="utf-8")
+        fh.setFormatter(logging.Formatter("[%(asctime)s] %(message)s", datefmt="%H:%M:%S"))
+        handlers.append(fh)
+    _CONF.update(on=True, level=lvl, verbose=verbose, file=file, handlers=handlers)
+    # 이미 생성된 structverify 로거에 즉시 적용
+    for name, lg in list(logging.Logger.manager.loggerDict.items()):
+        if isinstance(lg, logging.Logger) and name.startswith("structverify"):
+            _apply(lg, name)

structverify/verification/_config.py

@@ -0,0 +1,45 @@
+"""[리팩] Step 8 설정 로드 — verification/config.yaml (default.yaml 미수정)"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+import yaml
+
+_VERIFICATION_CONFIG_PATH = Path(__file__).parent / "config.yaml"
+
+VerificationProfile = Literal["agent", "fallback"]
+
+_DEFAULT_PROFILE: VerificationProfile = "fallback"
+
+
+def get_verification_settings(
+    config: dict | None,
+    profile: VerificationProfile = _DEFAULT_PROFILE,
+) -> dict:
+    """판정 프로필 설정 병합.
+
+    우선순위 (낮음 → 높음):
+      1. verification/config.yaml → profiles[profile]
+      2. config['verification']['profiles'][profile]
+      3. config['verification'] flat 키 (프로필 네임스페이스 밖 — 하위 호환)
+    """
+    merged: dict = {}
+    if _VERIFICATION_CONFIG_PATH.is_file():
+        with open(_VERIFICATION_CONFIG_PATH, encoding="utf-8") as f:
+            file_cfg = yaml.safe_load(f) or {}
+        profiles = file_cfg.get("profiles") or {}
+        merged.update(profiles.get(profile) or {})
+
+    user_cfg = (config or {}).get("verification") or {}
+    user_profiles = user_cfg.get("profiles") or {}
+    if isinstance(user_profiles.get(profile), dict):
+        merged.update(user_profiles[profile])
+
+    # [리팩] 기존 config.verification flat 키 (예: exaggeration_diff_percent) 하위 호환
+    for key, value in user_cfg.items():
+        if key == "profiles":
+            continue
+        merged.setdefault(key, value)
+
+    return merged

structverify/verification/adapters.py

@@ -0,0 +1,405 @@
+"""[리팩] agent Observation / verifier Evidence → decide_verdict 공통 입력 (판정 규칙 없음)"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from structverify.agent.schemas import ActionType, ClaimType, Plan
+from structverify.core.schemas import (
+    Claim,
+    Evidence,
+    MismatchType,
+    VerificationResult,
+    VerdictType,
+)
+from structverify.utils.logger import get_logger
+
+from .row_match import (
+    aggregate_rows_from_fetches,
+    extract_criteria_from_row,
+    find_value_for_time_with_criteria,
+)
+
+if TYPE_CHECKING:
+    from structverify.graph.claim_graph import ClaimGraph
+    from structverify.memory.working_memory import DocumentWorkingMemory
+
+logger = get_logger(__name__)
+
+_GROWTH_INDICATOR_KEYWORDS = ("증가율", "증감률", "증감율", "성장률", "비율", "퍼센트", "%")
+_DIFF_INDICATOR_KEYWORDS = ("차이", "증감", "감소", "증가분", "감소분", "변화량", "격차")
+_RANK_INDICATOR_KEYWORDS = ("순위", "1위", "최고", "최대", "최저", "최소", "가장 높")
+_GROWTH_UNITS = ("%", "%p", "퍼센트", "%P", "pp")
+_DERIVED_SUFFIXES = ("증가율", "감소율", "증감률", "변화율", "상승률", "하락률")
+
+
+@dataclass
+class VerdictDecision:
+    """agent 경로 판정 결과 — loop가 AgentVerdict로 포장 (commit 8)."""
+
+    claim_id: str
+    verdict: VerdictType
+    confidence: float
+    explanation: str
+
+
+@dataclass
+class NormalizedInput:
+    """decide_verdict가 소비하는 fallback 경로 입력."""
+
+    evidence: Evidence
+    claim_year: str | None = None
+    claim_year_month: str | None = None
+
+
+@dataclass
+class AgentFetchInput:
+    """agent fetch observation 판정 입력."""
+
+    claim_id: str
+    evidence: dict
+    claim_actual_type: ClaimType
+    plan_claim_type: ClaimType
+    tolerance: float
+    all_fetch_observations: list = field(default_factory=list)
+
+
+@dataclass
+class AgentCalculateInput:
+    """agent calculate observation 판정 입력."""
+
+    claim_id: str
+    calc_value: float
+    claim_actual_type: ClaimType
+    calc_summary: str = ""
+
+
+def infer_claim_type(claim: Claim) -> ClaimType | None:
+    """Claim의 *실제* 유형을 schema에서 추론 (loop._infer_claim_type).
+
+    Planner LLM이 source_text 전체 의미로 일괄 분류하기 때문에,
+    같은 문장에서 추출된 absolute / growth_rate claim들이 모두 growth_rate로
+    뭉뚱그려지는 문제가 있음. claim.schema의 indicator/unit/prev_value를 보면
+    정확하게 알 수 있으므로 그것으로 보정.
+
+    우선순위 (v6.17 — prev_value를 unit보다 먼저 체크):
+      1. ClaimSchema.comparison_type (명시되어 있으면)
+      2. Claim.canonical_type
+      3. indicator 키워드 (순위/차이 → ranking/difference)
+      4. prev_value 있음 + unit % → growth_rate
+      5. prev_value 있음 (unit % 아님) → comparison
+      6. prev_value 없음 → ABSOLUTE (unit=%여도 비교 기준 없으면 growth_rate 아님)
+    """
+    schema = claim.schema
+    if schema is None:
+        return None
+
+    # 1. schema.comparison_type 명시
+    comp = getattr(schema, "comparison_type", None)
+    if isinstance(comp, ClaimType):
+        return comp
+
+    # 2. claim.canonical_type
+    canon = getattr(claim, "canonical_type", None)
+    if isinstance(canon, ClaimType):
+        return canon
+
+    indicator = (schema.indicator or "").strip()
+    unit = (schema.unit or "").strip()
+    prev_value = getattr(schema, "prev_value", None)
+
+    # 3. indicator 키워드 — 순위/차이는 unit과 무관하게 먼저 판정
+    if any(kw in indicator for kw in _RANK_INDICATOR_KEYWORDS):
+        return ClaimType.RANKING
+    if any(kw in indicator for kw in _DIFF_INDICATOR_KEYWORDS):
+        return ClaimType.DIFFERENCE
+    if any(kw in indicator for kw in _GROWTH_INDICATOR_KEYWORDS):
+        return ClaimType.GROWTH_RATE
+
+    # 4. prev_value 있음 → 두 시점 비교 claim
+    if prev_value is not None:
+        if unit in _GROWTH_UNITS:
+            return ClaimType.GROWTH_RATE
+        return ClaimType.COMPARISON
+
+    # 5. prev_value 없음 → 단일 시점 절대값 (unit=%여도 growth_rate 아님)
+    return ClaimType.ABSOLUTE
+
+
+def from_agent_fetch(
+    claim: Claim,
+    last_observation: Any,
+    plan: Plan,
+    *,
+    tolerance: float = 0.05,
+    all_fetch_observations: list | None = None,
+) -> tuple[AgentFetchInput | None, VerdictDecision | None]:
+    """fetch Observation → AgentFetchInput 또는 즉시 VerdictDecision."""
+    claim_id = str(claim.claim_id)
+
+    if last_observation is None:
+        return None, None
+    if getattr(last_observation, "action", None) != ActionType.FETCH_EVIDENCE:
+        return None, None
+
+    if not getattr(last_observation, "success", False):
+        summary = (getattr(last_observation, "summary", None) or "")[:200]
+        return None, VerdictDecision(
+            claim_id=claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.25,
+            explanation=f"데이터 조회 실패: {summary}",
+        )
+
+    evidence = dict((getattr(last_observation, "output", None) or {}).get("evidence") or {})
+    fetched_value = evidence.get("value")
+    fetched_time = evidence.get("time_period", "") or ""
+
+    schema = claim.schema
+    claim_time = (schema.time_period or "") if schema is not None else ""
+
+    # ── [패치 H-3] aggregated rows에서 claim_time + 지표 criteria 매칭 row 찾기 ──
+    # 시나리오: LLM이 current(2025-04) fetch → prev(2024-04) fetch 순으로 호출하면
+    # last_fetch_observation은 prev 시점만 들어있고 그 fetch의 rows[]에는 2025-04
+    # row가 아예 없다. 단일 fetch만 보면 claim_time row 못 찾아 unverifiable.
+    # → 같은 claim의 모든 fetch observation rows를 합쳐서 풀을 만들고,
+    #   matched_row의 ITM_NM·C1_NM~C4_NM을 criteria로 같은 지표의 다른 시점 row를
+    #   찾는다. 시점만 보고 row 잡으면 출생아 수/혼인 건수 같이 PRD_DE 공유하는
+    #   다른 지표가 잘못 매칭됨 — criteria 필터로 차단.
+    matched_row_from_last = evidence.get("matched_row") or {}
+    criteria = extract_criteria_from_row(matched_row_from_last)
+    pool_rows = aggregate_rows_from_fetches(all_fetch_observations or [])
+    # last fetch의 rows도 합집합에 포함 (보통은 이미 포함됐을 것이나 안전)
+    for r in evidence.get("rows") or []:
+        if isinstance(r, dict) and r not in pool_rows:
+            pool_rows.append(r)
+
+    if claim_time and pool_rows:
+        hit = find_value_for_time_with_criteria(pool_rows, claim_time, criteria)
+        if hit is not None:
+            row_val_for_claim_time, _picked_row = hit
+            claim_time_norm = str(claim_time).replace("-", "")
+            fetched_time_norm = str(fetched_time).replace("-", "")
+            # 마지막 fetch가 이미 claim_time이면 그대로, 아니면 덮어씀
+            if claim_time_norm not in fetched_time_norm:
+                logger.info(
+                    f"[loop] {claim_id}: aggregated rows에서 claim_time={claim_time} + "
+                    f"criteria={list(criteria.keys()) or '없음'} row 매칭 "
+                    f"→ value={row_val_for_claim_time} "
+                    f"(마지막 fetch 시점={fetched_time}/value={fetched_value} → 덮어씀)"
+                )
+                evidence["value"] = row_val_for_claim_time
+                evidence["time_period"] = claim_time_norm
+
+    claim_actual_type = infer_claim_type(claim) or plan.claim_type
+
+    return AgentFetchInput(
+        claim_id=claim_id,
+        evidence=evidence,
+        claim_actual_type=claim_actual_type,
+        plan_claim_type=plan.claim_type,
+        tolerance=tolerance,
+        all_fetch_observations=list(all_fetch_observations or []),
+    ), None
+
+
+def from_agent_calculate(
+    claim: Claim,
+    last_calc_observation: Any,
+    plan: Plan,
+    *,
+    last_fetch_observation: Any | None = None,
+    workspace: Any | None = None,
+) -> tuple[AgentCalculateInput | None, VerdictDecision | None]:
+    """calculate Observation → AgentCalculateInput (가드 통과 시).
+
+    [안전장치] last_fetch_observation이 없으면 calculate 결과를 신뢰하지 않는다.
+    fetch 0건 상태에서 LLM이 prev/current를 임의로 박아 계산한 값이
+    MATCH로 통과하는 환각을 차단.
+
+    [P22 2026-05-22] sibling base evidence가 있으면 fetch 0건이어도 합성 시도.
+    calc.input.current가 sibling base value와 *크게 다르면(>2%)* 환각으로 거부.
+    """
+    claim_id = str(claim.claim_id)
+
+    if last_calc_observation is None or not getattr(last_calc_observation, "success", False):
+        return None, None
+    if getattr(last_calc_observation, "action", None) != ActionType.CALCULATE:
+        return None, None
+
+    if last_fetch_observation is None:
+        # [P22] sibling 검증으로 fetch 0건 케이스 구제 시도
+        sib_current: float | None = None
+        try:
+            sent_id = str(getattr(claim, "sent_id", "") or "").strip()
+            if workspace is not None and sent_id and hasattr(workspace, "read_sibling_evidence"):
+                sibs = workspace.read_sibling_evidence(sent_id) or []
+                schema = claim.schema
+                tp = (schema.time_period or "") if schema else ""
+                tp_norm = str(tp).replace("-", "")
+                for s in sibs:
+                    if s.get("role") != "base":
+                        continue
+                    # 같은 시점의 base sibling 찾기
+                    s_tp = str(s.get("time_period") or "").replace("-", "")
+                    if s_tp == tp_norm and s.get("value") is not None:
+                        sib_current = float(s.get("value"))
+                        break
+        except Exception:
+            sib_current = None
+
+        if sib_current is None:
+            logger.info(
+                f"[loop] {claim_id}: calculate 합성 가드 — fetch evidence 0건 + "
+                f"sibling base도 없음 → calculate 결과 신뢰 X (LLM 환각 차단)"
+            )
+            return None, None
+
+        # calc input의 current와 sibling base value 비교
+        calc_input = getattr(last_calc_observation, "input", None) or {}
+        calc_current = calc_input.get("current")
+        try:
+            cc = float(calc_current) if calc_current is not None else None
+        except (TypeError, ValueError):
+            cc = None
+        if cc is not None:
+            gap_ratio = abs(cc - sib_current) / max(abs(sib_current), 1e-9)
+            if gap_ratio > 0.02:
+                logger.warning(
+                    f"[loop] {claim_id}: calculate 합성 거부 — calc.input.current="
+                    f"{cc} vs sibling base={sib_current} (gap {gap_ratio*100:.1f}%)"
+                )
+                return None, None
+
+    # [패치 2026-05-20] base claim은 calculate 합성 거부 — derived suffix만 허용
+    schema = claim.schema
+    schema_indicator = (schema.indicator or "").strip() if schema else ""
+    if not any(schema_indicator.endswith(s) for s in _DERIVED_SUFFIXES):
+        logger.info(
+            f"[loop] {claim_id}: calculate 합성 가드 — base indicator "
+            f"'{schema_indicator}' (derived 아님) → 합성 거부"
+        )
+        return None, None
+
+    raw_result = (getattr(last_calc_observation, "output", None) or {}).get("result")
+    if raw_result is None:
+        return None, None
+    try:
+        calc_value = float(raw_result)
+    except (TypeError, ValueError):
+        return None, None
+
+    if claim.schema is None or claim.schema.value is None:
+        return None, None
+
+    claim_actual_type = infer_claim_type(claim) or plan.claim_type
+    calc_summary = getattr(last_calc_observation, "summary", None) or ""
+
+    return AgentCalculateInput(
+        claim_id=claim_id,
+        calc_value=calc_value,
+        claim_actual_type=claim_actual_type,
+        calc_summary=calc_summary,
+    ), None
+
+
+def from_evidence(
+    claim: Claim,
+    evidence: Evidence | None,
+    *,
+    graph: ClaimGraph | None = None,
+    memory: DocumentWorkingMemory | None = None,
+) -> tuple[NormalizedInput | None, VerificationResult | None]:
+    """Evidence·claim·graph·memory → NormalizedInput 또는 즉시 반환할 VerificationResult."""
+    if evidence is None or evidence.official_value is None:
+        return None, VerificationResult(
+            claim_id=claim.claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.3,
+            evidence=evidence,
+        )
+
+    claimed = claim.schema.value if claim.schema else None
+    if claimed is None:
+        return None, VerificationResult(
+            claim_id=claim.claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.2,
+            evidence=None,
+        )
+
+    if claimed == 0.0:
+        return None, VerificationResult(
+            claim_id=claim.claim_id,
+            verdict=VerdictType.UNVERIFIABLE,
+            confidence=0.2,
+            evidence=None,
+        )
+
+    if memory is not None and evidence.category_path:
+        if not memory.domain_matches_category(evidence.category_path):
+            logger.info(
+                f"[verifier 도메인 가드] reject: "
+                f"doc.domain={memory.domain} ↔ evidence.category={evidence.category_path}"
+            )
+            memory.record_stat_id_rejected(
+                evidence.stat_table_id or "unknown",
+                f"domain mismatch: {memory.domain} vs {evidence.category_path}",
+            )
+            return None, VerificationResult(
+                claim_id=claim.claim_id,
+                verdict=VerdictType.UNVERIFIABLE,
+                confidence=0.4,
+                evidence=evidence,
+                mismatch_type=MismatchType.DOMAIN_MISMATCH,
+            )
+
+    claim_year, claim_year_month = _resolve_claim_time(claim, graph)
+
+    return NormalizedInput(
+        evidence=evidence,
+        claim_year=claim_year,
+        claim_year_month=claim_year_month,
+    ), None
+
+
+def _resolve_claim_time(
+    claim: Claim,
+    graph: ClaimGraph | None,
+) -> tuple[str | None, str | None]:
+    claim_year = None
+    claim_year_month = None
+
+    schema_tp = (
+        claim.schema.time_period if claim.schema and claim.schema.time_period else ""
+    )
+
+    if schema_tp:
+        m = re.search(r"(\d{4})", schema_tp)
+        if m:
+            claim_year = m.group(1)
+        ym = re.search(r"(\d{4})[-/]?(\d{2})", schema_tp)
+        if ym:
+            claim_year_month = ym.group(1) + ym.group(2)
+        if claim_year:
+            logger.info(
+                f"[verifier] 시점 해소: schema.time_period={schema_tp!r} "
+                f"→ year={claim_year}, ym={claim_year_month}"
+            )
+
+    if not claim_year and graph is not None:
+        resolved = graph.resolve_time_for_claim(claim)
+        if resolved:
+            m = re.search(r"(\d{4})", resolved)
+            if m:
+                claim_year = m.group(1)
+                logger.info(
+                    f"[verifier] 시점 해소 (fallback): 그래프에서 resolved year={claim_year} "
+                    f"(from {resolved})"
+                )
+            ym = re.search(r"(\d{4})[-/]?(\d{2})", resolved)
+            if ym:
+                claim_year_month = ym.group(1) + ym.group(2)
+
+    return claim_year, claim_year_month

structverify/verification/conformance.py

@@ -0,0 +1,117 @@
+"""structverify.verification.conformance — 문서형 준수판정 (P3).
+
+수치비교(decide_verdict)가 아니라, **검색된 규정 조항 텍스트**에 대해 신청/주장이
+준수하는지 판정한다. (custom_docs verdict_mode="conformance"에서 사용)
+
+신뢰성 설계(§7c):
+  · LLM은 *추출만* — 적용 조항 + 기준값(rule_value) + 측정값(claim_value) + 비교방향(comparison).
+  · **verdict는 코드가 결정론적으로 계산** (LLM verdict 필드의 근거-결론 불일치 제거).
+  · 빈/무효 응답이면 재시도.
+원칙: 근거 없으면 unverifiable(환각 방지).
+계획: docs/indexing-agent-plan.md §4
+"""
+from __future__ import annotations
+
+import asyncio
+from collections import Counter
+from typing import Any
+
+from structverify.utils.llm_client import LLMClient
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+CONFORMANCE_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "applicable_article": {"type": ["string", "null"]},   # 적용한 조항(단위·대상 맞는 것)
+        "rule_value": {"type": ["number", "null"]},           # 기준값(한도)
+        "claim_value": {"type": ["number", "null"]},          # 측정/신청값
+        "unit": {"type": ["string", "null"]},
+        # 조항이 규정한 기준의 성격 (측정 결과가 아니라 *규정 자체*의 방향)
+        "rule_type": {"type": "string", "enum": ["max", "min", "exact", "none"]},
+        "explanation": {"type": "string"},
+    },
+    "required": ["rule_type", "explanation"],
+}
+
+_PROMPT = """너는 규정 준수 검사관이다. [측정/신청]을 [관련 규정 조항]과 대조해 아래를 추출하라.
+
+[관련 규정 조항] (여러 개면 측정 단위·제품 종류에 맞는 것 하나 선택)
+{article}
+
+[측정/신청]
+{claim}
+
+추출 항목:
+- applicable_article: 적용한 조항. ㎍/g 측정은 mg/kg 조항과 매칭하지 말 것.
+- **같은 원소라도 기준이 여러 개면 측정 '유형'에 맞는 것을 골라라.** [측정]에 "총함량"이면
+  총함량 허용치를, "용출"이면 용출 허용치를 rule_value로 사용. (예: 총 납 300mg/kg vs 용출 납 90mg/kg
+  은 서로 다른 기준 — 총함량 측정에 90을 쓰면 오답)
+- rule_value: 그 조항의 기준값(숫자만) / claim_value: 측정·신청값(숫자만) / unit: 단위
+- rule_type: **조항(규정) 자체**가 '~이하 한도'면 max, '~이상 최소'면 min, '일치'면 exact, 맞는 조항 없으면 none
+  (주의: 측정값이 기준보다 큰지 작은지가 아니라, *규정이 상한/하한 중 무엇인지* 를 넣어라)
+- explanation: 어느 조항의 무엇을 근거로 하는지 1~2문장
+
+* rule_value와 claim_value는 **같은 단위**로 맞춰서 숫자만. 맞는 조항 없으면 rule_type=none.
+JSON만 출력."""
+
+
+def _compute_verdict(rule: Any, claim: Any, rule_type: str) -> str:
+    """추출된 값 + 규정 성격(max/min/exact)으로 verdict 결정 (LLM verdict 신뢰 안 함).
+
+    max=상한(이하): 측정 ≤ 기준이면 적합 · min=하한(이상): 측정 ≥ 기준이면 적합.
+    """
+    if rule is None or claim is None or rule_type in (None, "none"):
+        return "unverifiable"
+    try:
+        r, c = float(rule), float(claim)
+    except (TypeError, ValueError):
+        return "unverifiable"
+    ok = {"max": c <= r, "min": c >= r, "exact": c == r}.get(rule_type)
+    if ok is None:
+        return "unverifiable"
+    return "compliant" if ok else "violation"
+
+
+async def _one_judgment(llm: LLMClient, claim_text: str, article_text: str) -> dict[str, Any]:
+    try:
+        res = await llm.generate_structured(
+            _PROMPT.format(article=article_text, claim=claim_text),
+            CONFORMANCE_SCHEMA,
+            system_prompt="규정 준수 검사관. 반드시 JSON만 출력.",
+        )
+    except Exception as e:  # noqa: BLE001
+        logger.debug(f"[conformance] 판정 시도 실패: {e}")
+        res = {}
+    if not isinstance(res, dict):
+        res = {}
+    res["verdict"] = _compute_verdict(res.get("rule_value"), res.get("claim_value"),
+                                      res.get("rule_type", "none"))
+    return res
+
+
+async def judge_conformance(
+    claim_text: str,
+    article_text: str,
+    config: dict[str, Any] | None = None,
+    *,
+    votes: int = 3,
+) -> dict[str, Any]:
+    """(측정/신청, 규정 조항) → 준수판정. verdict는 코드가 결정론 계산 + self-consistency 투표(§7c).
+
+    solar 모델 변동성(빈 응답·오판) 대응: votes회 *병렬* 판정 후 다수결.
+    (병렬이라 지연은 1회 호출 수준)
+    """
+    llm = LLMClient(config=(config or {}).get("llm", {}))
+    results = await asyncio.gather(
+        *[_one_judgment(llm, claim_text, article_text) for _ in range(max(1, votes))]
+    )
+    # 확정 판정(compliant/violation) 중 다수결. 없으면 unverifiable.
+    concrete = [r for r in results if r.get("verdict") in ("compliant", "violation")]
+    if concrete:
+        winner = Counter(r["verdict"] for r in concrete).most_common(1)[0][0]
+        best = next(r for r in concrete if r["verdict"] == winner)
+        logger.info(f"[conformance] 투표 {Counter(r['verdict'] for r in results)} → {winner}")
+        return best
+    return results[0] if results else {"verdict": "unverifiable", "explanation": ""}