moleg-api 0.2.0__tar.gz → 0.2.1__tar.gz

{moleg_api-0.2.0 → moleg_api-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moleg-api
-Version: 0.2.0
+Version: 0.2.1
 Summary: Task-level Python interface for loading Korean legal sources from law.go.kr
 Author: MOLEG-API maintainers
 License-Expression: MIT

{moleg_api-0.2.0 → moleg_api-0.2.1}/moleg_api/cli.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 import argparse
 import json
 import sys
+from importlib.metadata import PackageNotFoundError, version as _dist_version
 from typing import Any
 
 from .errors import (
@@ -42,6 +43,14 @@ from .errors import (
 from .laws import MolegApi
 from .models import DeferredLookup
 
+
+def _pkg_version() -> str:
+    try:
+        return _dist_version("moleg-api")
+    except PackageNotFoundError:
+        return "unknown"
+
+
 # Exit codes distinguish outcomes a shell/agent must branch on.
 EXIT_OK = 0            # includes a zero-hit search (ok:true, count:0)
 EXIT_AMBIGUOUS = 2     # multiple plausible identities — surface, don't pick
@@ -464,9 +473,19 @@ def signals_for(command: str, result: Any, args: argparse.Namespace) -> dict[str
         discipline.append("선택 조문의 전후 문구 델타만 — 개정이유·입법의도·전체 변경 조문 망라 아님. trace-law-history·국회 법안자료로 보강.")
 
     elif tname == "DelegationGraph":
-        if not getattr(result, "rules", None):
-            flags["count"] = 0
+        rules = getattr(result, "rules", None) or []
+        flags["count"] = len(rules)
+        if not rules:
             discipline.append("이 조회로 위임규정 못 찾음 ≠ 위임 없음 — 법령 체계도·다른 조문 범위·행정규칙·별표 경로를 더 확인.")
+        else:
+            discipline.append("위임 목록은 하위법령·인용법령 위임만 — 별표(과태료·범칙금액·기준표 등) 자체는 여기 없다. 금액·기준표는 위임된 시행령·시행규칙의 별표를 search-annex-forms(또는 load-delegated-criteria)로 확인.")
+            ident = getattr(result, "identity", None)
+            name = (getattr(ident, "name", None) or getattr(ident, "law_id", None) or "") if ident else ""
+            if name:
+                next_cmds.append({
+                    "why": "위임된 별표·금액·기준표 확인",
+                    "cmd": f"moleg search-annex-forms {json.dumps(name, ensure_ascii=False)} --source law",
+                })
 
     elif tname == "LawStructure":
         discipline.append("체계도는 계층 컨텍스트일 뿐 — 시행령·규칙·행정규칙이 이 법 아래 있음은 보이나, 조문 단위 위임·하위규칙 본문·운영기준 증명 아님. find-delegated-rules로 확인.")
@@ -632,6 +651,12 @@ def build_parser() -> argparse.ArgumentParser:
         description="법제처 law.go.kr 법령 자료 조회 CLI. 항상 JSON 엔벨로프 1개를 stdout으로 출력.",
     )
     parser.add_argument("--raw", action="store_true", help="원본 소스 payload(raw)까지 직렬화(디버그).")
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"moleg-api {_pkg_version()}",
+        help="설치된 moleg-api 버전을 출력하고 종료.",
+    )
     sub = parser.add_subparsers(dest="command", metavar="<command>")
 
     sub.add_parser("catalog", help="27개 서브커맨드·규약·kind 목록을 한 번에.")
@@ -740,9 +765,8 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--date-from", dest="date_from", default=None)
     p.add_argument("--date-to", dest="date_to", default=None)
 
-    p = sub.add_parser("compare-law-versions", help="개정 전후 조문 문구 비교.")
-    _add_law(p); p.add_argument("--before", default=None); p.add_argument("--after", default=None)
-    p.add_argument("--article", default=None)
+    p = sub.add_parser("compare-law-versions", help="개정 전후 조문 문구 비교(소스 제공 전후 쌍).")
+    _add_law(p); p.add_argument("--article", default=None)
 
     p = sub.add_parser("find-delegated-rules", help="위임 규정·하위 법령.")
     _add_law(p); p.add_argument("--article", default=None)
@@ -834,7 +858,7 @@ def _call(api: MolegApi, args: argparse.Namespace) -> Any:
         date_range = (args.date_from, args.date_to) if (args.date_from and args.date_to) else None
         return api.trace_law_history(args.law, date_range=date_range, article=args.article)
     if c == "compare-law-versions":
-        return api.compare_law_versions(args.law, before=args.before, after=args.after, article=args.article)
+        return api.compare_law_versions(args.law, article=args.article)
     if c == "find-delegated-rules":
         return api.find_delegated_rules(args.law, article=args.article)
     if c == "get-law-structure":

{moleg_api-0.2.0 → moleg_api-0.2.1}/moleg_api/laws.py

@@ -59,6 +59,7 @@ from .models import (
     LawHistory,
     LawIdentity,
     LawStructure,
+    LawStructureNode,
     LawText,
     StructuredTableData,
 )
@@ -249,6 +250,9 @@ INTERPRETATION_SOURCE_VALUES = ("moleg", "ministry", "all", "all_ministries")
 COURT_VALUES = ("all", "supreme", "lower")
 BUNDLE_MODE_VALUES = ("question", "promulgated_bill", "statute_review")
 BUNDLE_BUDGET_VALUES = ("minimal", "standard", "broad")
+# 헌재 사건번호 shape, e.g. 2005헌마1139 / 2015헌바9 (digits + 헌 + class letter(s)
+# + digits) — distinct from the pure-digit 헌재결정례일련번호 detail id.
+_CONSTITUTIONAL_CASE_NUMBER_RE = re.compile(r"^\d+헌[가-힣]+\d+$")
 
 
 @dataclass(frozen=True)
@@ -951,6 +955,7 @@ class MolegApi:
         `resolve_promulgated_law` before history when starting from a bill.
         """
         identity = identity_from_identifier(law_identifier, basis="effective")
+        identity = self._resolve_identity_name(identity)
         bill_id_map = normalize_history_bill_id_map(promulgation_bridge)
         if article is not None:
             params = identity_params(identity, as_of=None, basis="effective")
@@ -1017,10 +1022,7 @@ class MolegApi:
         # The lsHistory list search matches on the law *name*; a bare law_id
         # identity carries the id as its name, which returns a "no results"
         # table and a parse failure. Recover the real name first.
-        if not identity.name or str(identity.name).isdigit():
-            resolved_name = self._law_name_for(identity)
-            if resolved_name:
-                identity = replace(identity, name=resolved_name)
+        identity = self._resolve_identity_name(identity)
         rows: list[dict[str, Any]] = []
         page = 1
         pages_seen = 0
@@ -1118,6 +1120,15 @@ class MolegApi:
                 return str(name)
         return None
 
+    def _resolve_identity_name(self, identity: LawIdentity) -> LawIdentity:
+        """Backfill the real statute name when an identity still carries a bare
+        law_id as its name (degrades to the input unchanged on lookup failure)."""
+        if not identity.name or str(identity.name).isdigit():
+            resolved_name = self._law_name_for(identity)
+            if resolved_name:
+                return replace(identity, name=resolved_name)
+        return identity
+
     def _load_versioned_law_raw(self, identity: LawIdentity, mst: str) -> dict[str, Any]:
         """Load one statute version's raw payload by MST (promulgated detail)."""
         versioned = replace(identity, mst=mst)
@@ -1212,6 +1223,7 @@ class MolegApi:
         payload = self.source.service("lsDelegated", params)
         raw_delegation = unwrap_service_payload(payload, "lsDelegated")
         root_identity = maybe_identity(raw_delegation.get("법령정보"), basis="effective") or identity
+        root_identity = self._resolve_identity_name(root_identity)
         rules = normalize_delegated_rules(raw_delegation)
         if article is not None:
             wanted = article_label_for_filter(article)
@@ -1385,6 +1397,10 @@ class MolegApi:
         )
         if not text.strip():
             raise NoResultError("No annex/form body text returned")
+        # A bare-id identity keeps the numeric id as its title (and no
+        # related_name/annex_type); recover the authoritative label from the
+        # body header before deciding on structuring or returning the identity.
+        identity = enrich_annex_identity_from_body(identity, text)
         structured_data = (
             structure_annex_form_text(text, identity)
             if attempt_structuring and annex_form_is_table_like(identity)
@@ -1896,6 +1912,19 @@ class MolegApi:
         Related: call `search_constitutional_decisions` first; use `get_case`
         for ordinary judicial decisions.
         """
+        # The detail endpoint keys on the internal 헌재결정례일련번호 (a pure-digit
+        # serial), a different system from the 사건번호 (e.g. 2005헌마1139). When a
+        # 사건번호 is passed, resolve it to the serial via search first.
+        if isinstance(identifier, str) and _CONSTITUTIONAL_CASE_NUMBER_RE.match(identifier.strip()):
+            case_number = identifier.strip()
+            resolved = self.search_constitutional_decisions(
+                case_number, case_number=case_number, display=1
+            )
+            if not resolved:
+                raise NoResultError(
+                    f"No Constitutional Court decision found for case number {case_number!r}"
+                )
+            identifier = resolved[0].identity
         identity_hint = judicial_decision_identity_from_identifier(
             identifier,
             source_type="constitutional",
@@ -2912,6 +2941,49 @@ class MolegApi:
         annex_form_candidates = list(bundle.candidates.annex_forms)
         delegated_scope = delegated_criteria_target_scope(bundle)
 
+        # Criteria/amount 별표 live inside the delegated 시행령·시행규칙, not the
+        # parent Act, and law.go.kr's lsDelegated never surfaces 별표 pointers. On
+        # the bare-anchor path (no --query) the inherited discovery searches only
+        # the parent law's own name and finds nothing, so reach the subordinate
+        # legislation's annexes directly by their resolved names. With an explicit
+        # query the block below already drives annex discovery by that query.
+        delegated_rule_names = (
+            delegated_subordinate_rule_names(bundle, delegated_scope)
+            if not explicit_query
+            else []
+        )
+        if delegated_rule_names:
+            subordinate_annex_limit = candidate_limits["annex_forms"]
+            # Restrict to 별표 (criteria/amount tables); 서식·별지 forms are not
+            # operational criteria and would otherwise crowd out the penalty/fine
+            # tables the anchor articles delegate.
+            delegated_annex_candidates = dedupe_candidates(
+                [
+                    hit
+                    for rule_name in delegated_rule_names
+                    for hit in safe_list(
+                        lambda rule_name=rule_name: self.search_annex_forms(
+                            rule_name,
+                            source="law",
+                            search_scope="source",
+                            annex_type="별표",
+                            display=subordinate_annex_limit,
+                        ),
+                        source_notes,
+                        f"Delegated-criteria subordinate-rule annex/form search for {rule_name}",
+                        gaps=gaps,
+                        deferred=deferred,
+                        query=rule_name,
+                        recommended_interface="search_annex_forms",
+                        source_type="annex_form",
+                        filters={"source": "law", "search_scope": "source", "annex_type": "별표"},
+                    )
+                ]
+            )
+            annex_form_candidates = dedupe_candidates(
+                [*delegated_annex_candidates, *annex_form_candidates]
+            )[:subordinate_annex_limit]
+
         if explicit_query:
             query_administrative_candidates = dedupe_candidates(
                 [
@@ -3084,6 +3156,12 @@ class MolegApi:
             )
         )
 
+        # websearch_required is a generic "no first-party path succeeded" prompt
+        # inherited from load_institutional_system. When the delegated annex
+        # search did surface first-party 별표, that prompt is misleading — drop it.
+        if loaded_annex_forms or annex_form_candidates:
+            gaps = [gap for gap in gaps if getattr(gap, "kind", None) != "websearch_required"]
+
         return replace(
             bundle,
             loaded=replace(
@@ -3929,6 +4007,82 @@ def annex_form_is_table_like(identity: AnnexFormIdentity) -> bool:
     return any(token in signals for token in ("별표", "기준표", "표", "기준", "부과기준"))
 
 
+_ANNEX_HEADER_RE = re.compile(
+    r"^\s*■\s*(?P<law>.+?)\s*\[\s*(?P<label>(?:별표|별지)[^\]]*?)\s*\]"
+)
+_ANNEX_BOX_CHARS = "┏┓┗┛┃┠┨┯┷━│─┌┐└┘├┤┼╋┣┫┳┻╂┿"
+# Adopt a header's source-law as related_name only when it reads like a statute
+# or subordinate/administrative rule, so junk header text is not treated as a
+# citable source reference (which feeds delegated-criteria source verification).
+_LEGISLATION_SUFFIXES = ("법", "법률", "령", "규칙", "조례", "규정", "고시", "훈령", "예규", "지침", "준칙")
+
+
+def _looks_like_legislation_name(name: str) -> bool:
+    return name.endswith(_LEGISLATION_SUFFIXES)
+
+
+def enrich_annex_identity_from_body(
+    identity: AnnexFormIdentity, text: str
+) -> AnnexFormIdentity:
+    """Recover the authoritative annex/form label from the loaded body header.
+
+    The text-download endpoint returns plain text with no title field, so a
+    bare-id identity (loaded via ``--id`` with no title) keeps the numeric id as
+    its title, which also silences table structuring. Parse the
+    ``■ <법령> [별표 N] ...`` header to backfill title/related_name/annex_type,
+    filling only fields currently missing so a rich search-hit identity is never
+    overwritten.
+    """
+    lines = text.splitlines()
+    header_idx: int | None = None
+    match: re.Match[str] | None = None
+    for idx, line in enumerate(lines[:6]):
+        m = _ANNEX_HEADER_RE.match(line)
+        if m:
+            header_idx = idx
+            match = m
+            break
+    if match is None or header_idx is None:
+        return identity
+
+    law = match.group("law").strip()
+    label = match.group("label").strip()
+    annex_type = "별표" if label.startswith("별표") else "별지"
+
+    updates: dict[str, Any] = {}
+    if not identity.related_name and _looks_like_legislation_name(law):
+        updates["related_name"] = law
+    if not identity.annex_type:
+        updates["annex_type"] = annex_type
+    if not identity.annex_number:
+        number = re.search(r"\d+", label)
+        if number:
+            updates["annex_number"] = number.group(0)
+
+    if not identity.title or identity.title == identity.annex_id:
+        # 별표 bodies place the annex name on its own line after the header;
+        # forms carry it inside the bracket. Prefer the name line, fall back to
+        # the bracketed "<법령> [별표 N]" label.
+        name_line: str | None = None
+        for line in lines[header_idx + 1 : header_idx + 8]:
+            stripped = line.strip()
+            if not stripped or stripped in ("(앞쪽)", "(뒤쪽)"):
+                continue
+            if stripped[0] in _ANNEX_BOX_CHARS or stripped.startswith("■"):
+                break
+            if any("가" <= ch <= "힣" for ch in stripped):
+                name_line = stripped
+            break
+        if name_line and annex_type == "별표":
+            updates["title"] = f"{law} [{label}] {name_line}"
+        else:
+            updates["title"] = f"{law} [{label}]"
+
+    if not updates:
+        return identity
+    return replace(identity, **updates)
+
+
 def structure_annex_form_text(text: str, identity: AnnexFormIdentity) -> StructuredTableData:
     lines = [line.strip() for line in text.splitlines() if line.strip()]
     pipe_table = parse_pipe_table(lines, identity)
@@ -4526,6 +4680,54 @@ def delegated_criteria_target_scope(bundle: LegalContextBundle) -> dict[str, set
     return {"law_ids": law_ids, "law_msts": law_msts, "law_names": law_names, "articles": articles}
 
 
+def flatten_structure_nodes(nodes: list[LawStructureNode]) -> list[LawStructureNode]:
+    flat: list[LawStructureNode] = []
+    for node in nodes:
+        flat.append(node)
+        if node.children:
+            flat.extend(flatten_structure_nodes(node.children))
+    return flat
+
+
+def delegated_subordinate_rule_names(
+    bundle: LegalContextBundle, scope: dict[str, set[str]]
+) -> list[str]:
+    """Names of subordinate legislation (시행령·시행규칙) delegated from the target
+    statute, used to search their own annexes — criteria/amount 별표 live inside
+    the lower rules, and lsDelegated never surfaces 별표 pointers.
+
+    Delegations whose source article is in the requested scope are preferred; the
+    law-structure 시행령·시행규칙 nodes are always included as a fallback so a bare
+    anchor still reaches them.
+    """
+    names: list[str] = []
+    seen: set[str] = set()
+    scope_articles = scope.get("articles") or set()
+
+    def add(name: str | None) -> None:
+        if not name:
+            return
+        key = str(name).strip()
+        if not key or key in seen:
+            return
+        seen.add(key)
+        names.append(key)
+
+    for graph in bundle.loaded.delegations:
+        for rule in graph.rules:
+            if not rule.delegated_name:
+                continue
+            if scope_articles and rule.source_article:
+                if comparable_article_label(rule.source_article) not in scope_articles:
+                    continue
+            add(rule.delegated_name)
+    for structure in bundle.loaded.law_structures:
+        for node in flatten_structure_nodes(structure.instruments):
+            if node.instrument_type in ("enforcement_decree", "enforcement_rule"):
+                add(node.name)
+    return names
+
+
 def delegated_criteria_scope_label(scope: dict[str, set[str]]) -> str:
     law_label = ", ".join(sorted(scope["law_names"] or scope["law_ids"]))
     article_label = ", ".join(sorted(scope["articles"]))

{moleg_api-0.2.0 → moleg_api-0.2.1}/moleg_api/normalization.py

@@ -975,7 +975,23 @@ def unwrap_search_interpretations(payload: dict[str, Any], target: str) -> list[
 def unwrap_search_judicial_decisions(payload: dict[str, Any], target: str) -> list[dict[str, Any]]:
     for envelope in ("PrecSearch", "precSearch", "DetcSearch", "detcSearch"):
         if isinstance(payload.get(envelope), dict):
-            rows = payload[envelope].get(target)
+            env = payload[envelope]
+            # law.go.kr names the row-element key by its own casing, not the
+            # request target: "prec" (lowercase) for cases but "Detc"
+            # (capitalized) for constitutional decisions. Match it
+            # case-insensitively, excluding the scalar "target" echo field.
+            rows = env.get(target)
+            if rows is None:
+                rows = next(
+                    (
+                        env[key]
+                        for key in env
+                        if isinstance(key, str)
+                        and key.lower() == target.lower()
+                        and key != "target"
+                    ),
+                    None,
+                )
             return [row for row in ensure_list(rows) if isinstance(row, dict)]
     rows = payload.get(target)
     if rows is not None:
@@ -1545,36 +1561,47 @@ def normalize_delegated_rules(payload: dict[str, Any]) -> list[DelegatedRule]:
             continue
         if "위임정보" in row or "조정보" in row:
             source = row.get("조정보") if isinstance(row.get("조정보"), dict) else {}
-            info = row.get("위임정보") if isinstance(row.get("위임정보"), dict) else {}
+            raw_info = row.get("위임정보")
+            # 위임정보 is list-valued when one article delegates to several
+            # targets (e.g. 과태료·범칙금액 amount tables). Collapsing it to {}
+            # silently drops every multi-target article, so emit one rule per
+            # delegation target instead.
+            if isinstance(raw_info, list):
+                infos = [item for item in raw_info if isinstance(item, dict)]
+            elif isinstance(raw_info, dict):
+                infos = [raw_info]
+            else:
+                infos = [{}]
         else:
             source = row
-            info = row
-        rule = DelegatedRule(
-            source_article=article_label_from_parts(
-                first_value(source, "조문번호", "조번호", "조항호목"),
-                first_value(source, "조문가지번호", "조가지번호"),
-            ),
-            source_article_title=string_or_none(first_value(source, "조문제목", "조제목")),
-            delegated_type=string_or_none(first_value(info, "위임구분", "법종구분")),
-            delegated_name=string_or_none(
-                first_value(info, "위임법령제목", "위임행정규칙제목", "위임자치법규제목", "위임행정규칙명", "법령명")
-            ),
-            delegated_law_id=string_or_none(first_value(info, "법령ID", "위임법령ID")),
-            delegated_mst=string_or_none(first_value(info, "위임법령일련번호", "위임행정규칙일련번호", "위임자치법규일련번호", "법령일련번호")),
-            delegated_article=article_label_from_parts(
-                first_value(info, "위임법령조문번호", "위임행정규칙조번호"),
-                first_value(
-                    info,
-                    "위임법령조문가지번호",
-                    "위임행정규칙조가지번호",
-                    "위임행정규칙조문가지번호",
+            infos = [row]
+        for info in infos:
+            rule = DelegatedRule(
+                source_article=article_label_from_parts(
+                    first_value(source, "조문번호", "조번호", "조항호목"),
+                    first_value(source, "조문가지번호", "조가지번호"),
                 ),
-            ),
-            text=string_or_none(first_value(info, "라인텍스트", "조내용", "링크텍스트")),
-            raw=row,
-        )
-        if rule.delegated_name or rule.text:
-            rules.append(rule)
+                source_article_title=string_or_none(first_value(source, "조문제목", "조제목")),
+                delegated_type=string_or_none(first_value(info, "위임구분", "법종구분")),
+                delegated_name=string_or_none(
+                    first_value(info, "위임법령제목", "위임행정규칙제목", "위임자치법규제목", "위임행정규칙명", "법령명")
+                ),
+                delegated_law_id=string_or_none(first_value(info, "법령ID", "위임법령ID")),
+                delegated_mst=string_or_none(first_value(info, "위임법령일련번호", "위임행정규칙일련번호", "위임자치법규일련번호", "법령일련번호")),
+                delegated_article=article_label_from_parts(
+                    first_value(info, "위임법령조문번호", "위임행정규칙조번호"),
+                    first_value(
+                        info,
+                        "위임법령조문가지번호",
+                        "위임행정규칙조가지번호",
+                        "위임행정규칙조문가지번호",
+                    ),
+                ),
+                text=string_or_none(first_value(info, "라인텍스트", "조내용", "링크텍스트")),
+                raw=row,
+            )
+            if rule.delegated_name or rule.text:
+                rules.append(rule)
     return rules
 
 

{moleg_api-0.2.0 → moleg_api-0.2.1}/moleg_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moleg-api
-Version: 0.2.0
+Version: 0.2.1
 Summary: Task-level Python interface for loading Korean legal sources from law.go.kr
 Author: MOLEG-API maintainers
 License-Expression: MIT

{moleg_api-0.2.0 → moleg_api-0.2.1}/moleg_api.egg-info/SOURCES.txt

@@ -20,5 +20,6 @@ tests/test_cli.py
 tests/test_laws.py
 tests/test_live_smoke.py
 tests/test_models.py
+tests/test_sdk_fixes_0_2_1.py
 tests/test_source.py
 tests/test_versions.py

{moleg_api-0.2.0 → moleg_api-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "moleg-api"
-version = "0.2.0"
+version = "0.2.1"
 description = "Task-level Python interface for loading Korean legal sources from law.go.kr"
 readme = "README.md"
 requires-python = ">=3.10"

{moleg_api-0.2.0 → moleg_api-0.2.1}/tests/test_laws.py

@@ -2124,7 +2124,14 @@ def test_get_annex_form_body_loads_law_text_export_from_candidate():
 
     body = MolegApi(source).get_annex_form_body(identity)
 
-    assert body.identity == identity
+    # Caller-supplied identity fields are preserved; missing metadata
+    # (annex_type/annex_number) is backfilled from the loaded body header.
+    assert body.identity.annex_id == "17677511"
+    assert body.identity.title == "과태료의 부과기준(제67조 관련)"
+    assert body.identity.related_name == "식품위생법 시행령"
+    assert body.identity.source_target == "licbyl"
+    assert body.identity.annex_type == "별표"
+    assert body.identity.annex_number == "2"
     assert "과태료의 부과기준" in body.text
     assert body.file_type == "text/plain"
     assert body.extraction_method == "lsBylTextDownLoad.do"

{moleg_api-0.2.0 → moleg_api-0.2.1}/tests/test_live_smoke.py

@@ -184,3 +184,68 @@ def test_live_expand_legal_query_smoke():
 
     assert expansion.original_query == "자동차 방치"
     assert expansion.follow_up_searches
+
+
+def test_live_constitutional_search_high_frequency_term_smoke():
+    # 0.2.1 #4A: capitalized 'Detc' row key was dropping all hits to 0.
+    api = live_api()
+
+    hits = api.search_constitutional_decisions("개인정보", display=20)
+
+    assert hits, "high-frequency 헌재 term should return hits after the row-key fix"
+    assert hits[0].identity.decision_id
+
+
+def test_live_constitutional_detail_by_case_number_smoke():
+    # 0.2.1 #4B: get_constitutional_decision resolves a 사건번호 to its serial.
+    api = live_api()
+
+    hits = api.search_constitutional_decisions("개인정보", display=5)
+    hit = first_hit_or_skip(hits, "constitutional decision")
+    case_number = hit.identity.case_number
+    if not case_number:
+        pytest.skip("No 사건번호 on the sampled hit")
+
+    text = api.get_constitutional_decision(case_number)
+
+    assert text.identity.decision_id
+    assert text.text
+
+
+def test_live_find_delegated_rules_name_and_recall_smoke():
+    # 0.2.1 #2: resolved statute name + multi-target recall.
+    api = live_api()
+
+    graph = api.find_delegated_rules("001638")  # 도로교통법
+
+    assert graph.identity.name and not graph.identity.name.isdigit()
+    articles = {rule.source_article for rule in graph.rules}
+    assert "제160조" in articles and "제162조" in articles
+
+
+def test_live_load_delegated_criteria_reaches_subordinate_annex_smoke():
+    # 0.2.1 #1: 별표 in the delegated 시행령·시행규칙 are surfaced first-party,
+    # not pushed to websearch.
+    api = live_api()
+
+    bundle = api.load_delegated_criteria("001638", articles=["제160조", "제162조"])
+
+    annex_titles = [annex.identity.title for annex in bundle.loaded.annex_forms]
+    candidate_titles = [c.identity.title for c in bundle.candidates.annex_forms]
+    all_titles = " ".join(annex_titles + candidate_titles)
+    assert bundle.candidates.annex_forms or bundle.loaded.annex_forms
+    assert "과태료" in all_titles or "범칙" in all_titles
+    gap_kinds = [gap.kind for gap in bundle.gaps]
+    assert gap_kinds != ["websearch_required"]
+
+
+def test_live_annex_form_body_recovers_label_smoke():
+    # 0.2.1 #3: a bare-id annex body load recovers its authoritative label.
+    api = live_api()
+
+    hits = api.search_annex_forms("도로교통법 시행령", source="law", annex_type="별표", display=5)
+    hit = first_hit_or_skip(hits, "law annex")
+    body = api.get_annex_form_body(hit.identity.annex_id)  # bare id, no title
+
+    assert body.identity.title and body.identity.title != body.identity.annex_id
+    assert body.identity.related_name

moleg_api-0.2.1/tests/test_sdk_fixes_0_2_1.py

@@ -0,0 +1,375 @@
+"""Regression tests for the 0.2.1 defect fixes.
+
+Each group locks one consumer-facing defect surfaced by the published-package
+end-to-end pass:
+
+* #1  load-delegated-criteria reached 별표 in the delegated 시행령·시행규칙
+* #2  find-delegated-rules recall, resolved identity name, populated signals
+* #3  get-annex-form-body recovers the authoritative label from the body
+* #4  헌재 search parses capitalized row keys; detail accepts a 사건번호
+* #5  CLI: no dead --before/--after, a top-level --version
+"""
+
+import argparse
+
+import pytest
+
+from moleg_api import MolegApi
+from moleg_api.cli import build_parser, signals_for
+from moleg_api.laws import (
+    _CONSTITUTIONAL_CASE_NUMBER_RE,
+    delegated_criteria_target_scope,
+    delegated_subordinate_rule_names,
+    enrich_annex_identity_from_body,
+)
+from moleg_api.models import (
+    AnnexFormIdentity,
+    BundleRequest,
+    CandidateContext,
+    DelegatedRule,
+    DelegationGraph,
+    LawIdentity,
+    LawStructure,
+    LawStructureNode,
+    LegalContextBundle,
+    LoadedContext,
+)
+from moleg_api.normalization import (
+    normalize_delegated_rules,
+    unwrap_search_judicial_decisions,
+)
+
+
+class FakeSource:
+    def __init__(self, *, search_payloads=None, service_payloads=None):
+        self.search_payloads = list(search_payloads or [])
+        self.service_payloads = list(service_payloads or [])
+        self.calls = []
+
+    def search(self, target, params):
+        self.calls.append(("search", target, params))
+        return self.search_payloads.pop(0)
+
+    def service(self, target, params):
+        self.calls.append(("service", target, params))
+        return self.service_payloads.pop(0)
+
+    def search_html(self, target, params):  # pragma: no cover - unused here
+        raise AssertionError("search_html not expected")
+
+    def post_text(self, path, params):  # pragma: no cover - unused here
+        raise AssertionError("post_text not expected")
+
+
+def _args(**kw):
+    ns = argparse.Namespace(as_of=None)
+    for key, value in kw.items():
+        setattr(ns, key, value)
+    return ns
+
+
+# --------------------------------------------------------------------------- #
+# #4A — 헌재 search row-key casing (Detc vs prec)
+# --------------------------------------------------------------------------- #
+
+def test_unwrap_detc_capitalized_row_key_returns_rows():
+    payload = {
+        "DetcSearch": {
+            "totalCnt": 29,
+            "target": "detc",
+            "Detc": [
+                {"헌재결정례일련번호": "48654", "사건번호": "2015헌마1140"},
+                {"헌재결정례일련번호": "50600", "사건번호": "2016헌마492"},
+            ],
+        }
+    }
+    rows = unwrap_search_judicial_decisions(payload, "detc")
+    assert [row["헌재결정례일련번호"] for row in rows] == ["48654", "50600"]
+
+
+def test_unwrap_prec_lowercase_row_key_unchanged():
+    payload = {"PrecSearch": {"prec": [{"판례일련번호": "1"}]}}
+    assert len(unwrap_search_judicial_decisions(payload, "prec")) == 1
+
+
+def test_unwrap_detc_single_object_is_wrapped():
+    payload = {"DetcSearch": {"Detc": {"헌재결정례일련번호": "137475"}}}
+    rows = unwrap_search_judicial_decisions(payload, "detc")
+    assert len(rows) == 1 and rows[0]["헌재결정례일련번호"] == "137475"
+
+
+def test_unwrap_detc_scalar_target_echo_not_treated_as_rows():
+    payload = {"DetcSearch": {"target": "detc", "Detc": [{"헌재결정례일련번호": "1"}]}}
+    rows = unwrap_search_judicial_decisions(payload, "detc")
+    assert len(rows) == 1
+
+
+# --------------------------------------------------------------------------- #
+# #4B — get-constitutional-decision accepts a 사건번호
+# --------------------------------------------------------------------------- #
+
+def test_constitutional_case_number_regex():
+    assert _CONSTITUTIONAL_CASE_NUMBER_RE.match("2005헌마1139")
+    assert _CONSTITUTIONAL_CASE_NUMBER_RE.match("2015헌바9")
+    assert not _CONSTITUTIONAL_CASE_NUMBER_RE.match("48654")  # a bare serial
+    assert not _CONSTITUTIONAL_CASE_NUMBER_RE.match("개인정보")  # free text
+
+
+def test_get_constitutional_decision_resolves_case_number_via_search():
+    source = FakeSource(
+        search_payloads=[
+            {
+                "DetcSearch": {
+                    "Detc": [
+                        {
+                            "헌재결정례일련번호": "137475",
+                            "사건명": "공직자병역사항 위헌확인",
+                            "사건번호": "2005헌마1139",
+                            "종국일자": "20070101",
+                        }
+                    ]
+                }
+            }
+        ],
+        service_payloads=[
+            {
+                "detc": {
+                    "헌재결정례일련번호": "137475",
+                    "사건명": "공직자병역사항 위헌확인",
+                    "사건번호": "2005헌마1139",
+                    "종국일자": "20070101",
+                    "전문": "결정 전문",
+                }
+            }
+        ],
+    )
+
+    text = MolegApi(source).get_constitutional_decision("2005헌마1139")
+
+    assert text.identity.decision_id == "137475"
+    assert source.calls[0][:2] == ("search", "detc")
+    assert source.calls[1] == ("service", "detc", {"ID": "137475"})
+
+
+def test_get_constitutional_decision_numeric_serial_skips_search():
+    source = FakeSource(
+        service_payloads=[
+            {
+                "detc": {
+                    "헌재결정례일련번호": "58400",
+                    "사건명": "X",
+                    "사건번호": "2020헌마1",
+                    "종국일자": "20240229",
+                    "전문": "전문",
+                }
+            }
+        ]
+    )
+
+    MolegApi(source).get_constitutional_decision("58400")
+
+    assert source.calls[0] == ("service", "detc", {"ID": "58400"})
+
+
+# --------------------------------------------------------------------------- #
+# #2a — normalize_delegated_rules keeps multi-target (list-valued) delegations
+# --------------------------------------------------------------------------- #
+
+def test_normalize_delegated_rules_splits_list_valued_info():
+    payload = {
+        "위임조문정보": [
+            {
+                "조정보": {"조문번호": "160", "조문제목": "과태료"},
+                "위임정보": [
+                    {"위임구분": "위임규칙", "위임행정규칙제목": "도로교통법 시행규칙"},
+                    {"위임구분": "위임법령", "위임법령제목": "도로교통법 시행령"},
+                ],
+            }
+        ]
+    }
+    rules = normalize_delegated_rules(payload)
+    assert len(rules) == 2
+    assert {rule.delegated_name for rule in rules} == {"도로교통법 시행규칙", "도로교통법 시행령"}
+    assert all(rule.source_article == "제160조" for rule in rules)
+
+
+def test_normalize_delegated_rules_dict_valued_single_target_unchanged():
+    payload = {
+        "위임조문정보": [
+            {"조정보": {"조문번호": "163"}, "위임정보": {"위임법령제목": "도로교통법"}}
+        ]
+    }
+    rules = normalize_delegated_rules(payload)
+    assert len(rules) == 1 and rules[0].delegated_name == "도로교통법"
+
+
+def test_normalize_delegated_rules_flat_row_shape_preserved():
+    payload = {"위임법령": [{"위임법령제목": "어떤 시행령", "조문번호": "5"}]}
+    rules = normalize_delegated_rules(payload)
+    assert len(rules) == 1 and rules[0].delegated_name == "어떤 시행령"
+
+
+# --------------------------------------------------------------------------- #
+# #2b / #5c — resolved statute name replaces a bare law_id
+# --------------------------------------------------------------------------- #
+
+class _NamedApi(MolegApi):
+    def _law_name_for(self, identity):
+        return "주택임대차보호법" if str(identity.name).isdigit() else identity.name
+
+
+def test_resolve_identity_name_backfills_digit_name():
+    api = _NamedApi(source=object())
+    out = api._resolve_identity_name(LawIdentity(law_id="001248", name="001248", basis="effective"))
+    assert out.name == "주택임대차보호법"
+
+
+def test_resolve_identity_name_keeps_real_name():
+    api = _NamedApi(source=object())
+    ident = LawIdentity(law_id="001248", name="주택임대차보호법", basis="effective")
+    assert api._resolve_identity_name(ident) is ident
+
+
+# --------------------------------------------------------------------------- #
+# #2c — DelegationGraph signals are populated for a non-empty result
+# --------------------------------------------------------------------------- #
+
+def test_delegation_graph_signals_populated_when_rules_present():
+    graph = DelegationGraph(
+        identity=LawIdentity(law_id="001638", name="도로교통법", basis="effective"),
+        rules=[DelegatedRule(source_article="제160조", delegated_name="도로교통법 시행령")],
+    )
+    sig = signals_for("find-delegated-rules", graph, _args())
+    assert sig["flags"]["count"] == 1
+    assert any("별표" in line for line in sig["discipline"])
+    assert any("search-annex-forms" in cmd["cmd"] for cmd in sig["next"])
+
+
+def test_delegation_graph_signals_empty_keeps_absence_discipline():
+    graph = DelegationGraph(
+        identity=LawIdentity(law_id="x", name="x", basis="effective"), rules=[]
+    )
+    sig = signals_for("find-delegated-rules", graph, _args())
+    assert sig["flags"]["count"] == 0
+    assert sig["discipline"]
+
+
+# --------------------------------------------------------------------------- #
+# #3 — enrich_annex_identity_from_body recovers the authoritative label
+# --------------------------------------------------------------------------- #
+
+def _bare_annex(annex_id="18177371"):
+    return AnnexFormIdentity(
+        annex_id=annex_id, title=annex_id, source_type="law", source_target="licbyl"
+    )
+
+
+def test_enrich_annex_byeolpyo_recovers_title_and_metadata():
+    text = (
+        "■ 도로교통법 시행령 [별표 8] <개정 2025. 6. 2.>\n"
+        "\n"
+        "범칙행위 및 범칙금액(운전자)(제93조제1항 관련)\n"
+        "┏━━━┓"
+    )
+    out = enrich_annex_identity_from_body(_bare_annex(), text)
+    assert out.related_name == "도로교통법 시행령"
+    assert out.annex_type == "별표"
+    assert out.annex_number == "8"
+    assert "범칙행위 및 범칙금액(운전자)" in out.title
+    assert out.title != out.annex_id
+
+
+def test_enrich_annex_form_uses_bracket_label():
+    text = "■ 도로교통법 시행규칙 [별지 제159호의2서식] <개정 2024. 7. 31.>\n서식 본문"
+    out = enrich_annex_identity_from_body(_bare_annex("18148709"), text)
+    assert out.related_name == "도로교통법 시행규칙"
+    assert out.annex_type == "별지"
+    assert out.title == "도로교통법 시행규칙 [별지 제159호의2서식]"
+
+
+def test_enrich_annex_does_not_clobber_rich_identity():
+    ident = AnnexFormIdentity(
+        annex_id="1",
+        title="진짜 제목",
+        source_type="law",
+        source_target="licbyl",
+        related_name="식품위생법 시행령",
+        annex_type="별표",
+    )
+    out = enrich_annex_identity_from_body(ident, "■ 다른법 시행령 [별표 3]\n다른 이름")
+    assert out.title == "진짜 제목"
+    assert out.related_name == "식품위생법 시행령"
+    assert out.annex_type == "별표"
+
+
+def test_enrich_annex_without_header_leaves_identity():
+    out = enrich_annex_identity_from_body(_bare_annex("9"), "헤더 없는 그냥 본문")
+    assert out.title == "9"
+
+
+def test_enrich_annex_non_legislation_source_not_adopted_as_reference():
+    # A header that is not a statute/rule name must not become a citable
+    # related_name (it feeds delegated-criteria source verification).
+    out = enrich_annex_identity_from_body(
+        AnnexFormIdentity(annex_id="44", title="무단방치 기준", source_type="law", source_target="licbyl"),
+        "■ 출처 미상 [별표]\n표 내용",
+    )
+    assert out.related_name is None
+
+
+# --------------------------------------------------------------------------- #
+# #1 — delegated_subordinate_rule_names resolves the 시행령·시행규칙 to search
+# --------------------------------------------------------------------------- #
+
+def test_delegated_subordinate_rule_names_scopes_and_includes_structures():
+    ident = LawIdentity(law_id="001638", name="도로교통법", basis="effective")
+    delegation = DelegationGraph(
+        identity=ident,
+        rules=[
+            DelegatedRule(source_article="제160조", delegated_name="도로교통법 시행규칙"),
+            DelegatedRule(source_article="제999조", delegated_name="무관 시행령"),
+        ],
+    )
+    structure = LawStructure(
+        identity=ident,
+        instruments=[
+            LawStructureNode(name="도로교통법 시행령", source_type="law", instrument_type="enforcement_decree"),
+            LawStructureNode(name="도로교통법 시행규칙", source_type="law", instrument_type="enforcement_rule"),
+            LawStructureNode(name="상위 법률", source_type="law", instrument_type="related_law"),
+        ],
+    )
+    bundle = LegalContextBundle(
+        request=BundleRequest(query=None, mode="institutional_system", budget="standard", articles=["제160조"]),
+        loaded=LoadedContext(delegations=[delegation], law_structures=[structure]),
+        candidates=CandidateContext(),
+    )
+    names = delegated_subordinate_rule_names(bundle, delegated_criteria_target_scope(bundle))
+    assert "도로교통법 시행령" in names
+    assert "도로교통법 시행규칙" in names
+    assert "무관 시행령" not in names  # source article out of requested scope
+    assert "상위 법률" not in names  # related_law instrument excluded
+
+
+# --------------------------------------------------------------------------- #
+# #5a / #5b — CLI: dead flags removed, --version added
+# --------------------------------------------------------------------------- #
+
+def test_compare_law_versions_rejects_removed_before_after():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args(
+            ["compare-law-versions", "--law", "001248", "--before", "2020-01-01"]
+        )
+
+
+def test_compare_law_versions_accepts_law_and_article():
+    ns = build_parser().parse_args(
+        ["compare-law-versions", "--law", "001248", "--article", "제3조"]
+    )
+    assert ns.law == "001248" and ns.article == "제3조"
+
+
+def test_top_level_version_flag_prints_and_exits_zero(capsys):
+    with pytest.raises(SystemExit) as exc:
+        build_parser().parse_args(["--version"])
+    assert exc.value.code == 0
+    assert "moleg-api" in capsys.readouterr().out