korean-law-mcp 4.2.1 → 4.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Korean Law MCP
 
-**법제처 42개 API를 17개 도구로.** 법령, 판례, 행정규칙, 자치법규, 조약, 해석례(국세청 포함) + **LLM 환각 방지 인용 검증** + **조문 영향 그래프** + **시점 비교 자동 diff** + **이럴 땐 이렇게 — 5단계 안내**를 AI 어시스턴트나 터미널에서 바로 사용.
+**법제처 42개 API를 19개 도구로.** 법령, 판례, 행정규칙, 자치법규, 조약, 해석례(국세청 포함) + **LLM 환각 방지 인용 검증** + **조문 영향 그래프** + **시점 비교 자동 diff** + **이럴 땐 이렇게 — 5단계 안내** + **판례 생사 확인(Citator)** + **행위시법 판단**을 AI 어시스턴트나 터미널에서 바로 사용.
 
 [![npm version](https://img.shields.io/npm/v/korean-law-mcp.svg)](https://www.npmjs.com/package/korean-law-mcp)
 [![MCP 1.27](https://img.shields.io/badge/MCP-1.27-blue)](https://modelcontextprotocol.io)
@@ -14,6 +14,35 @@
 
 ---
 
+## v4.3 — 판례 생사 확인 + 행위시법 판단
+
+**"이 판례 아직 유효한가?" + "사건 시점엔 어떤 법이 적용되나?"** — 법률 실무에서 가장 위험한 두 실수를 잡는다.
+
+### 1. `cite_check` — 판례 생사 확인 (한국형 Shepard's Citator)
+
+```
+"2007다27670 아직 유효해?"
+```
+
+→ 그 사건번호를 **인용한 후속 판례를 본문검색으로 역추적** + 전원합의체 후속 판결 본문 정밀 스캔 → 변경·폐기 선언 감지:
+
+```
+📊 판정: ❌ 변경·폐기 신호 감지 — 2018다248626(판례 변경 선언, 저촉 범위 변경)
+   맥락: "…2008년 전원합의체 판결은 이 판결의 견해와 배치되는 범위에서 변경하기로 한다…"
+```
+
+판결문이 사건번호 대신 "(이하 '2008년 전원합의체 판결'이라 한다)" 별칭으로 변경 선언하는 관행까지 추적. 변경된 판례를 살아있는 것처럼 인용하는 사고를 차단한다. 무료 도구 중 유일.
+
+### 2. `applicable_law` — 행위시법 판단 + 부칙 경과규정
+
+```
+"2023.5.10 당시 도로교통법 제44조"
+```
+
+→ 기준일에 **시행 중이던 버전(MST) 특정** → 그 시점 조문 본문 → 현행과 비교 → **이후 개정 부칙의 적용례·경과조치 자동 발췌** + 행위시법(형법 §1)·제재처분 위반행위시법(행정기본법 §14③) 법리 안내. LLM이 현행법으로 오답하는 것을 구조적으로 방지.
+
+---
+
 ## v4.0 — 3개 킬러 기능 동시 추가
 
 **조문 영향 그래프 + 시점 비교 + 단계별 안내.** 법무팀·연구자·실수요자가 매뉴얼로 며칠 걸리던 작업이 한 번에.
@@ -328,7 +357,7 @@ lexdiff에서 "산안기준규칙" 질의가 법제처 aiSearch의 키워드 부
 **v3.0.2** — Unified Architecture + Setup Wizard
 
 법제처 41개 API를 89개 MCP 도구로 구조화했던 v2.
-v3는 같은 41개 API를 **14개 도구**로 재압축했습니다 (v3.2.2 이후 15개, v4.0 현재 17개).
+v3는 같은 41개 API를 **14개 도구**로 재압축했습니다 (v3.2.2 이후 15개, v4.3 현재 19개).
 
 | | 법제처 원본 | v2 | v3 |
 |---|:---:|:---:|:---:|
@@ -392,7 +421,7 @@ MCP 도구 설계에서 **도구 수 ≠ 기능 수**입니다.
 
 대한민국에는 **1,600개 이상의 현행 법률**, **10,000개 이상의 행정규칙**, 그리고 대법원·헌법재판소·조세심판원·관세청까지 이어지는 방대한 판례 체계가 있습니다. 이 모든 게 [법제처](https://www.law.go.kr)라는 하나의 사이트에 있지만, 개발자 경험은 최악입니다.
 
-이 프로젝트는 그 전체 법령 시스템을 **17개 도구**로 감싸서, AI 어시스턴트나 스크립트에서 바로 호출할 수 있게 만듭니다. 법제처를 수백 번 수동 검색하다 지친 공무원이 만들었습니다.
+이 프로젝트는 그 전체 법령 시스템을 **19개 도구**로 감싸서, AI 어시스턴트나 스크립트에서 바로 호출할 수 있게 만듭니다. 법제처를 수백 번 수동 검색하다 지친 공무원이 만들었습니다.
 
 ---
 
@@ -497,7 +526,7 @@ https://korean-law-mcp.fly.dev/mcp?oc=honggildong
 
 > **참고**: 커넥터 URL을 수정하려면 삭제 후 다시 추가해야 합니다.
 
-> v3부터 프로필 선택이 필요 없습니다. 17개 도구가 42개 API 전체를 커버합니다.
+> v3부터 프로필 선택이 필요 없습니다. 19개 도구가 42개 API 전체를 커버합니다.
 > 기존에 `?profile=lite&oc=...` 주소를 넣으셨다면 **그대로 두셔도 됩니다** — 동일하게 작동합니다.
 
 ---
@@ -719,9 +748,9 @@ reg delete "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /
 
 ---
 
-## 도구 구조 (17개)
+## 도구 구조 (19개)
 
-v4는 17개 도구만 노출합니다. 나머지 전문 도구는 `discover_tools` → `execute_tool`로 접근.
+v4는 19개 도구만 노출합니다. 나머지 전문 도구는 `discover_tools` → `execute_tool`로 접근.
 
 | 구분 | 도구 | 설명 | 시나리오 확장 |
 |------|------|------|-------------|
@@ -738,8 +767,10 @@ v4는 17개 도구만 노출합니다. 나머지 전문 도구는 `discover_tool
 | | `get_annexes` | 별표/서식 조회 (금액표·요율표·별지서식) |
 | **통합** (2) | `search_decisions` | **17개 도메인** 통합 검색 (판례·헌재·조세심판·공정위·노동위·관세·해석례·행심·개인정보위·권익위·소청심사·학칙·공사공단·공공기관·조약·영문법령) |
 | | `get_decision_text` | **17개 도메인** 전문 조회 |
-| **킬러** (2) | `verify_citations` | LLM 환각 방지 — 인용 조문 실존 여부 일괄 검증 (v3.5) |
+| **킬러** (4) | `verify_citations` | LLM 환각 방지 — 인용 조문 실존 여부 일괄 검증 (v3.5) |
 | | `impact_map` | 조문 영향 그래프 — 인용 판례·해석·자치법규 역방향 탐색 + mermaid (v4.0) |
+| | `cite_check` | 판례 생사 확인 — 후속 인용 역추적 + 변경·폐기 감지, 한국형 Citator (v4.3) |
+| | `applicable_law` | 행위시법 판단 — 시점 적용 버전 + 부칙 경과규정 발췌 (v4.3) |
 | **메타** (2) | `discover_tools` | 전문 도구 검색 (용어·별표·이력·비교 등) |
 | | `execute_tool` | 전문 도구 프록시 실행 |
 
@@ -749,7 +780,7 @@ v4는 17개 도구만 노출합니다. 나머지 전문 도구는 `discover_tool
 
 ## 주요 특징
 
-- **42개 API → 17개 도구** — 법령, 판례, 행정규칙, 자치법규, 헌재결정, 조세심판, 관세해석, 국세청 해석례, 조약, 학칙/공단/공공기관 규정, 법령용어
+- **42개 API → 19개 도구** — 법령, 판례, 행정규칙, 자치법규, 헌재결정, 조세심판, 관세해석, 국세청 해석례, 조약, 학칙/공단/공공기관 규정, 법령용어
 - **MCP + CLI** — Claude Desktop에서도, 터미널에서도 같은 도구 사용
 - **법률 도메인 특화** — 약칭 자동 인식(`화관법` → `화학물질관리법`), 조문번호 변환(`제38조` ↔ `003800`), 3단 위임 구조 시각화
 - **별표/별지서식 본문 추출** — HWPX·HWP·PDF·XLSX·DOCX 자동 변환 ([kordoc](https://github.com/chrisryugj/kordoc) 엔진)

package/build/lib/errors.js

@@ -1,6 +1,7 @@
 /**
  * 통일된 에러 처리 모듈
  */
+import { maskSensitiveUrl } from "./fetch-with-retry.js";
 /**
  * 에러 코드
  */
@@ -114,7 +115,8 @@ export function formatToolError(error, context) {
         suggestions = [];
     }
     const lines = [];
-    lines.push(`[${code}] ${msg}`);
+    // 최종 방어선 — 도구 코드가 URL 포함 에러를 직접 만들어도 API 키가 클라이언트로 새지 않게
+    lines.push(`[${code}] ${maskSensitiveUrl(msg)}`);
     if (context) {
         lines.push(`도구: ${context}`);
     }

package/build/lib/law-search.js

@@ -64,45 +64,43 @@ export async function findLaws(apiClient, query, apiKey, max = 3, searchDisplay
     if (cached)
         return cached.slice(0, max);
     const effectiveMax = Math.max(max, searchDisplay); // 정렬 대상 전체 수집
+    // 인프라 에러(타임아웃·5xx·파싱 실패)는 "법령 없음"과 구분해야 한다.
+    // 삼키면 법제처 장애 중 verify_citations가 실존 조문을 NOT_FOUND로 오판한다.
+    let lastInfraError;
+    const trySearch = async (q) => {
+        try {
+            const xmlText = await apiClient.searchLaw(q, apiKey, searchDisplay);
+            return parseLawXml(xmlText, effectiveMax);
+        }
+        catch (e) {
+            if (e instanceof Error && /429|401|403|API 키/.test(e.message))
+                throw e;
+            lastInfraError = e;
+            return [];
+        }
+    };
     // 1차: 원본 쿼리
-    let results = [];
-    try {
-        const xmlText = await apiClient.searchLaw(query, apiKey, searchDisplay);
-        results = parseLawXml(xmlText, effectiveMax);
-    }
-    catch (e) {
-        if (e instanceof Error && /429|401|403|API 키/.test(e.message))
-            throw e;
-    }
+    let results = await trySearch(query);
     // 2차: 부가 키워드 제거
     if (results.length === 0) {
         const stripped = stripNonLawKeywords(query);
         if (stripped && stripped !== query) {
-            try {
-                const xmlText = await apiClient.searchLaw(stripped, apiKey, searchDisplay);
-                results = parseLawXml(xmlText, effectiveMax);
-            }
-            catch (e) {
-                if (e instanceof Error && /429|401|403|API 키/.test(e.message))
-                    throw e;
-            }
+            results = await trySearch(stripped);
         }
     }
     // 3차: 법령명 패턴 직접 추출
     if (results.length === 0) {
         const lawNameMatch = query.match(/[가-힣]+(법|시행령|시행규칙|규칙|규정|령)(?:\s|$)/);
         if (lawNameMatch) {
-            const extracted = lawNameMatch[0].trim();
-            try {
-                const xmlText = await apiClient.searchLaw(extracted, apiKey, searchDisplay);
-                results = parseLawXml(xmlText, effectiveMax);
-            }
-            catch (e) {
-                if (e instanceof Error && /429|401|403|API 키/.test(e.message))
-                    throw e;
-            }
+            results = await trySearch(lawNameMatch[0].trim());
         }
     }
+    // 전 단계가 인프라 에러로만 끝났으면 "없음"이 아니라 "실패"로 전파
+    if (results.length === 0 && lastInfraError !== undefined) {
+        throw lastInfraError instanceof Error
+            ? new Error(`법령 검색 실패 (법제처 API 오류 — 법령이 없다는 뜻이 아님): ${lastInfraError.message}`)
+            : lastInfraError;
+    }
     // 관련도 정렬
     if (results.length > 1) {
         const queryWords = query.replace(NON_LAW_NAME_RE, " ")

package/build/lib/query-router.js

@@ -29,15 +29,16 @@ function extractLawName(query) {
         // 수식어: 단독 키워드만 제거 (법령명 일부인 경우 보존)
         // "별표 1", "별표" 등 독립적 사용만 제거
         .replace(/별표\s*\d*/g, "")
-        .replace(/(?:^|\s)(판례|판결|사례|대법원|헌재|행정심판)(?:\s|$)/g, " ")
-        .replace(/(?:^|\s)(해석례?|유권해석|질의회신)(?:\s|$)/g, " ")
-        .replace(/(?:^|\s)(개정|이력|변경|연혁|신구대조)(?:\s|$)/g, " ")
-        .replace(/(?:^|\s)(3단비교|위임|인용|체계)(?:\s|$)/g, " ")
-        .replace(/(?:^|\s)(영문|영어|English)(?:\s|$)/gi, " ")
-        .replace(/(?:^|\s)(서식|양식|별지|신청서)(?:\s|$)/g, " ")
+        // 뒤 경계는 lookahead(소비 안 함) — 소비하면 "개정 연혁"처럼 연속 키워드의 두 번째가 살아남음
+        .replace(/(?:^|\s)(판례|판결|사례|대법원|헌재|행정심판)(?=\s|$)/g, " ")
+        .replace(/(?:^|\s)(해석례?|유권해석|질의회신)(?=\s|$)/g, " ")
+        .replace(/(?:^|\s)(개정|이력|변경|연혁|신구대조)(?=\s|$)/g, " ")
+        .replace(/(?:^|\s)(3단비교|위임|인용|체계)(?=\s|$)/g, " ")
+        .replace(/(?:^|\s)(영문|영어|English)(?=\s|$)/gi, " ")
+        .replace(/(?:^|\s)(서식|양식|별지|신청서)(?=\s|$)/g, " ")
         // 조례/규칙은 법령명 일부이므로 유지
         // 동사형 수식어 제거
-        .replace(/(?:^|\s)(검색|조회|확인|알려줘|찾아줘|보여줘)(?:\s|$)/g, " ")
+        .replace(/(?:^|\s)(검색|조회|확인|알려줘|찾아줘|보여줘)(?=\s|$)/g, " ")
         // 정리
         .replace(/\s+/g, " ")
         .trim();
@@ -70,6 +71,11 @@ const routePatterns = [
             if (/(?:파급|영향\s*그래프|impact|인용한\s*(?:모든|판례|판결|어디))/i.test(query)) {
                 return { _skip: true };
             }
+            // applicable_law 양보: 기준일 + 시점 키워드 (예: "2023.5.10 당시 도로교통법 제44조")
+            if (/행위시법/.test(query) ||
+                (/\d{4}\s*[년.\-/]\s*\d{1,2}/.test(query) && /당시|시점|기준|에\s*적용/.test(query))) {
+                return { _skip: true };
+            }
             const jo = extractArticleNumber(query);
             const lawName = extractLawName(query);
             return { _searchQuery: lawName, jo, _needsMst: true };
@@ -592,6 +598,55 @@ const routePatterns = [
         reason: "시민 상황 키워드 → chain_full_research (action_plan 5단계 가이드)",
         priority: 7,
     },
+    // ── 29-0-3. 판례 생사 확인 (cite_check, v4.3) ──
+    // "2013다61381 아직 유효해?", "이 판례 변경됐어?", "2018두42559 인용 추적"
+    {
+        name: "cite_check",
+        patterns: [
+            /\d{2,4}\s*[가-힣]{1,5}\s*\d{1,7}.*?(?:유효|살아|변경|폐기|뒤집|생사|추적|아직|citator)/i,
+            /판례\s*(?:생사|유효성|변경\s*여부|폐기\s*여부|인용\s*추적)/,
+            /(?:변경|폐기)된?\s*판례(?:인지|냐|인가요?|\s*확인)/,
+        ],
+        tool: "cite_check",
+        extract: (query) => {
+            const m = query.match(/(\d{2,4})\s*([가-힣]{1,5})\s*(\d{1,7})/);
+            if (!m)
+                return { _fallback: true, query };
+            return { caseNumber: `${m[1]}${m[2]}${m[3]}` };
+        },
+        reason: "사건번호 + 유효성 키워드 → cite_check (후속 인용 역추적 + 변경·폐기 감지)",
+        priority: 2,
+    },
+    // ── 29-0-4. 행위시법 판단 (applicable_law, v4.3) ──
+    // "2023년 5월 당시 도로교통법 제44조", "사건 시점에 적용되는 법", "행위시법"
+    {
+        name: "applicable_law",
+        patterns: [
+            /(\d{4})\s*[년\.\-\/]\s*(\d{1,2})\s*[월\.\-\/]?\s*(\d{1,2})?\s*일?\s*(?:당시|시점|기준|에\s*적용)/,
+            /(?:행위\s*시|사건\s*당시|계약\s*당시|위반\s*당시)\s*(?:의\s*)?(?:법|적용)/,
+            /행위시법|적용\s*법령\s*판단|당시\s*시행/,
+        ],
+        tool: "applicable_law",
+        extract: (query) => {
+            const dm = query.match(/(\d{4})\s*[년\.\-\/]\s*(\d{1,2})(?:\s*[월\.\-\/]\s*(\d{1,2}))?/);
+            if (!dm)
+                return { _fallback: true, query };
+            const date = `${dm[1]}${dm[2].padStart(2, "0")}${(dm[3] || "1").padStart(2, "0")}`;
+            const jo = extractArticleNumber(query);
+            // 키워드 strip은 단어 경계 필수 — "근로기준법"의 "기준"을 떼면 법령명 파괴
+            const lawName = extractLawName(query.replace(/(\d{4})\s*[년\.\-\/]\s*\d{1,2}\s*[월\.\-\/]?\s*\d{0,2}\s*일?/g, " ")
+                .replace(/(?:^|\s)(당시|시점|기준일?|행위시법|사건|적용|시행)(?=\s|$)/g, " ")
+                .replace(/에\s*적용되?는?\s*법령?/g, " "));
+            if (!lawName)
+                return { _fallback: true, query };
+            const params = { lawName, date };
+            if (jo)
+                params.jo = jo;
+            return params;
+        },
+        reason: "기준일 + 법령명 → applicable_law (시점 적용 버전 + 부칙 경과규정)",
+        priority: 2,
+    },
     // ── 29-1. 인용 검증 (citation validator) ──
     {
         name: "verify_citations",
@@ -709,8 +764,10 @@ export function routeQuery(query) {
     // 자연어 날짜 조건 추출 (검색어에서 시간 표현 분리)
     const dateParsed = parseDateRange(q);
     const dateRange = dateParsed.range;
+    // 행위시법(applicable_law) 의도는 날짜 자체가 파라미터 — 날짜 제거 전 원문으로 매칭해야 함
+    const applicableLawHint = /행위시법|\d{4}\s*[년.\-/].{0,14}(?:당시|시점|기준|에\s*적용)/.test(q);
     // 날짜 표현이 제거된 순수 검색어로 패턴 매칭
-    const routeInput = dateParsed.cleanQuery || q;
+    const routeInput = applicableLawHint ? q : (dateParsed.cleanQuery || q);
     const result = _matchRoute(routeInput);
     // 날짜 범위가 있으면 결과에 첨부
     if (dateRange) {

package/build/lib/tool-profiles.js

@@ -35,6 +35,8 @@ export const TOOL_ALIASES = {
     "해석례": ["법제처 해석", "유권해석", "질의회신"],
     // 도구 의도 별칭
     "인용검증": ["verify_citations", "조문 실존 확인", "환각 검증"],
+    "판례생사": ["cite_check", "판례 유효성", "판례 변경 여부", "인용 추적", "citator"],
+    "행위시법": ["applicable_law", "당시 법령", "적용 법령 판단", "경과조치", "부칙"],
     "문서검토": ["analyze_document", "chain_document_review", "계약서 검토", "약관 검토"],
     "처분기준": ["chain_action_basis", "과태료 기준", "과징금 기준", "영업정지 기간"],
     "절차매뉴얼": ["chain_procedure_detail", "처리 절차", "신청 방법", "수수료"],
@@ -70,5 +72,7 @@ export const TOOL_CATEGORIES = {
     "영문법령": ["search_english_law", "get_english_law_text"],
     "용어": ["search_legal_terms", "get_legal_term_kb", "get_legal_term_detail", "get_daily_term", "get_daily_to_legal", "get_legal_to_daily", "get_term_articles", "get_related_laws"],
     "문서분석": ["analyze_document"],
+    "판례생사": ["cite_check"],
+    "행위시법": ["applicable_law"],
     "유틸리티": ["parse_jo_code", "get_law_abbreviations"],
 };

package/build/lib/xml-parser.d.ts

@@ -7,6 +7,11 @@
  * 예: <strong class="tbl_tx_type">지방</strong>자치법 → 지방자치법
  */
 export declare function stripHtml(text: string): string;
+/**
+ * 단일 객체 정규화 (Critical Rule 6) — API 응답의 배열 필드가 단일 객체로 올 수 있음.
+ * 기존 수동 패턴 `Array.isArray(x) ? x : x ? [x] : []`과 의미 동일 (falsy → []).
+ */
+export declare function toArray<T>(x: T | T[] | null | undefined): T[];
 /**
  * XML 태그에서 텍스트 추출 (CDATA 지원)
  */

package/build/lib/xml-parser.js

@@ -9,6 +9,13 @@
 export function stripHtml(text) {
     return text.replace(/<[^>]+>/g, "");
 }
+/**
+ * 단일 객체 정규화 (Critical Rule 6) — API 응답의 배열 필드가 단일 객체로 올 수 있음.
+ * 기존 수동 패턴 `Array.isArray(x) ? x : x ? [x] : []`과 의미 동일 (falsy → []).
+ */
+export function toArray(x) {
+    return Array.isArray(x) ? x : x ? [x] : [];
+}
 /**
  * XML 태그에서 텍스트 추출 (CDATA 지원)
  */

package/build/server/http-server.js

@@ -9,6 +9,7 @@ import express from "express";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { requestContext } from "../lib/session-state.js";
 import { maskSensitiveUrl } from "../lib/fetch-with-retry.js";
+import { TOOL_COUNTS } from "../tool-registry.js";
 import { VERSION } from "../version.js";
 /**
  * 에러 메시지에서 민감 정보(API 키 포함 URL) scrub.
@@ -97,26 +98,49 @@ export async function startHTTPServer(createServer, port) {
                 health: "/health",
             },
             tools: {
-                exposed: 16,
-                total: 92,
-                description: "V3_EXPOSED 16개 직노출, 나머지 76개는 execute_tool 경유",
+                exposed: TOOL_COUNTS.exposed,
+                total: TOOL_COUNTS.total,
+                description: `V3_EXPOSED ${TOOL_COUNTS.exposed}개 직노출, 나머지 ${TOOL_COUNTS.total - TOOL_COUNTS.exposed}개는 execute_tool 경유`,
             },
         });
     });
     app.get("/health", (req, res) => {
         res.json({ status: "ok", timestamp: new Date().toISOString() });
     });
+    // 서버 LAW_OC 폴백 사용량 전역 상한 — 키 없는 분산 요청이 서버 키의 법제처 quota를
+    // 소진시키는 것 방지 (IP당 limit만으로는 막을 수 없음). 0이면 폴백 비활성.
+    const fallbackRpm = parseInt(process.env.FALLBACK_RATE_LIMIT_RPM || "120", 10);
+    const fallbackBucket = { count: 0, resetAt: 0 };
+    function fallbackAllowed() {
+        if (fallbackRpm <= 0)
+            return false;
+        const now = Date.now();
+        if (now >= fallbackBucket.resetAt) {
+            fallbackBucket.count = 0;
+            fallbackBucket.resetAt = now + 60000;
+        }
+        return ++fallbackBucket.count <= fallbackRpm;
+    }
     // POST /mcp - stateless 요청 처리
     app.post("/mcp", async (req, res) => {
-        // Extract API key: URL query > header
-        const apiKeyFromQuery = req.query.oc;
-        const apiKey = apiKeyFromQuery ||
-            req.headers["apikey"] ||
+        // Extract API key: header > URL query
+        // 쿼리스트링 키는 프록시/엣지 액세스 로그에 평문으로 남으므로 헤더 사용 권장 (하위호환용 유지)
+        const apiKey = req.headers["apikey"] ||
             req.headers["law_oc"] ||
             req.headers["law-oc"] ||
             req.headers["x-api-key"] ||
             req.headers["authorization"]?.replace(/^Bearer\s+/i, "") ||
-            req.headers["x-law-oc"];
+            req.headers["x-law-oc"] ||
+            req.query.oc;
+        // 자체 키 없는 요청은 서버 LAW_OC로 폴백 — 전역 상한 적용
+        if (!apiKey && !fallbackAllowed()) {
+            res.status(429).json({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: "Shared API quota exceeded. Provide your own key via 'apiKey' header (free: https://open.law.go.kr)." },
+                id: null,
+            });
+            return;
+        }
         let server;
         let transport;
         try {
@@ -180,12 +204,19 @@ export async function startHTTPServer(createServer, port) {
         console.error(`✓ MCP endpoint: http://0.0.0.0:${port}/mcp`);
         console.error(`✓ Health check: http://0.0.0.0:${port}/health`);
     });
-    // 종료 처리
-    async function gracefulShutdown(signal) {
+    // 종료 처리 — in-flight 요청 완료 대기 (최대 10초), 이후 강제 종료
+    function gracefulShutdown(signal) {
         console.error(`${signal} received, shutting down server...`);
-        expressServer.close();
-        console.error("Server shutdown complete");
-        process.exit(0);
+        const forceExit = setTimeout(() => {
+            console.error("Shutdown timeout (10s) — forcing exit");
+            process.exit(1);
+        }, 10000);
+        forceExit.unref();
+        expressServer.close(() => {
+            clearTimeout(forceExit);
+            console.error("Server shutdown complete");
+            process.exit(0);
+        });
     }
     process.on("SIGINT", () => gracefulShutdown("SIGINT"));
     process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));

package/build/tool-registry.d.ts

@@ -9,4 +9,9 @@ import type { McpTool } from "./lib/types.js";
  * 모든 MCP 도구 정의
  */
 export declare const allTools: McpTool[];
+/** 노출/전체 도구 수 — 헬스체크 등 표기용 파생값 (하드코딩 금지) */
+export declare const TOOL_COUNTS: {
+    exposed: number;
+    total: number;
+};
 export declare function registerTools(server: Server, apiClient: LawApiClient): void;

package/build/tool-registry.js

@@ -53,6 +53,8 @@ import { getLinkedOrdinances, LinkedOrdinancesSchema, getLinkedOrdinanceArticles
 import { analyzeDocument, AnalyzeDocumentSchema } from "./tools/document-analysis.js";
 import { verifyCitations, VerifyCitationsSchema } from "./tools/verify-citations.js";
 import { impactMap, ImpactMapSchema } from "./tools/impact-map.js";
+import { citeCheck, CiteCheckSchema } from "./tools/cite-check.js";
+import { applicableLaw, ApplicableLawSchema } from "./tools/applicable-law.js";
 // Chain tool imports
 import { chainLawSystem, chainLawSystemSchema, chainActionBasis, chainActionBasisSchema, chainDisputePrep, chainDisputePrepSchema, chainAmendmentTrack, chainAmendmentTrackSchema, chainOrdinanceCompare, chainOrdinanceCompareSchema, chainFullResearch, chainFullResearchSchema, chainProcedureDetail, chainProcedureDetailSchema, chainDocumentReview, chainDocumentReviewSchema, } from "./tools/chains.js";
 /**
@@ -618,6 +620,20 @@ export const allTools = [
         schema: ImpactMapSchema,
         handler: impactMap
     },
+    // === 판례 인용 추적 (v4.3 killer feature) ===
+    {
+        name: "cite_check",
+        description: "[판례생사] 한국형 Shepard's Citator — 사건번호(예: 2013다61381)로 ① 그 판례를 인용한 후속 판례 역추적(본문검색) ② 전원합의체 후속 판결의 변경·폐기 문구 정밀 스캔 ③ 계속인용/변경가능성 판정. '이 판례 아직 유효한가' 확인용. 변경·폐기된 판례 인용 사고 방지.",
+        schema: CiteCheckSchema,
+        handler: citeCheck
+    },
+    // === 행위시법 판단 (v4.3 killer feature) ===
+    {
+        name: "applicable_law",
+        description: "[행위시법] '사건 시점(예: 2023.5.10)에 적용되는 법은?' — 기준일에 시행 중이던 법령 버전(MST) 특정 + 그 시점 조문 본문 + 현행과 비교 + 이후 개정 부칙의 적용례·경과조치 자동 발췌 + 행위시법/처분시법 법리 안내. lawName + date 필수, jo 선택. LLM이 현행법으로 오답하는 것 방지.",
+        schema: ApplicableLawSchema,
+        handler: applicableLaw
+    },
     // === 메타 도구 (lite 프로필용) ===
     {
         name: "discover_tools",
@@ -687,18 +703,19 @@ const V3_EXPOSED = new Set([
     "discover_tools", "execute_tool",
     "verify_citations", // v3.5: LLM 환각 방지 인용 검증
     "impact_map", // v4.0: 조문 영향 그래프 (역방향 탐색 + mermaid)
+    "cite_check", // v4.3: 판례 생사 확인 (한국형 Shepard's Citator)
+    "applicable_law", // v4.3: 행위시법 판단 (시점 적용 버전 + 부칙 경과규정)
 ]);
 // 이름 기반 O(1) 조회용 Map
-const toolMap = new Map();
+// allTools는 정적 — 모듈 로드 시 1회만 구성 (HTTP 모드에서 요청마다 재구성 방지)
+const toolMap = new Map(allTools.map(tool => [tool.name, tool]));
+// 메타 도구가 전체 도구 목록 참조할 수 있도록 주입
+setAllToolsRef(allTools);
+// V3_EXPOSED만 노출 (나머지는 execute_tool 경유)
+const exposedTools = allTools.filter(t => V3_EXPOSED.has(t.name));
+/** 노출/전체 도구 수 — 헬스체크 등 표기용 파생값 (하드코딩 금지) */
+export const TOOL_COUNTS = { exposed: exposedTools.length, total: allTools.length };
 export function registerTools(server, apiClient) {
-    // Map 초기화
-    toolMap.clear();
-    for (const tool of allTools)
-        toolMap.set(tool.name, tool);
-    // 메타 도구가 전체 도구 목록 참조할 수 있도록 주입
-    setAllToolsRef(allTools);
-    // V3_EXPOSED 16개만 노출 (나머지는 execute_tool 경유)
-    const exposedTools = allTools.filter(t => V3_EXPOSED.has(t.name));
     // ListTools 핸들러
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: exposedTools.map(tool => ({

package/build/tools/applicable-law.d.ts

@@ -0,0 +1,30 @@
+/**
+ * applicable_law — 행위시법 판단 (v4.3 killer feature)
+ *
+ * 문제: "사건 발생 시점(예: 2023.5.10)에 어떤 법이 적용되나"는 법률 실무 최빈 질문인데,
+ *       LLM은 항상 현행법으로 답해서 오답을 낸다. 결론은 부칙 경과조치가 뒤집을 수 있다.
+ *
+ * 입력: 법령명 + 기준일(행위·계약·처분 시점) + 조문(선택)
+ * 처리:
+ *   1. lsHistory 연혁으로 기준일에 시행 중이던 버전(MST) 특정
+ *   2. 그 버전의 해당 조문 본문 조회 (eflaw는 MST가 버전 고유)
+ *   3. 현행 조문과 동일/변경 비교
+ *   4. 이후 개정 부칙에서 적용례·경과조치 자동 발췌 (공포번호 매칭)
+ *   5. 행위시법/재판시법/제재처분 법리 주의 문구
+ *
+ * 차별점: time_travel은 두 시점 diff. 이 도구는 "특정 시점의 적용 법령 버전 특정 + 경과규정".
+ * 한계: 경과조치 '해석'은 하지 않음 — 발췌와 경고까지만 (해석은 사람/LLM 몫).
+ */
+import { z } from "zod";
+import type { LawApiClient } from "../lib/api-client.js";
+import type { ToolResponse } from "../lib/types.js";
+export declare const ApplicableLawSchema: z.ZodObject<{
+    lawName: z.ZodString;
+    date: z.ZodString;
+    jo: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ApplicableLawInput = z.infer<typeof ApplicableLawSchema>;
+/** 다양한 날짜 표기 → YYYYMMDD. 실패 시 null */
+export declare function normalizeDate(input: string): string | null;
+export declare function applicableLaw(apiClient: LawApiClient, input: ApplicableLawInput): Promise<ToolResponse>;

package/build/tools/applicable-law.js

@@ -0,0 +1,248 @@
+/**
+ * applicable_law — 행위시법 판단 (v4.3 killer feature)
+ *
+ * 문제: "사건 발생 시점(예: 2023.5.10)에 어떤 법이 적용되나"는 법률 실무 최빈 질문인데,
+ *       LLM은 항상 현행법으로 답해서 오답을 낸다. 결론은 부칙 경과조치가 뒤집을 수 있다.
+ *
+ * 입력: 법령명 + 기준일(행위·계약·처분 시점) + 조문(선택)
+ * 처리:
+ *   1. lsHistory 연혁으로 기준일에 시행 중이던 버전(MST) 특정
+ *   2. 그 버전의 해당 조문 본문 조회 (eflaw는 MST가 버전 고유)
+ *   3. 현행 조문과 동일/변경 비교
+ *   4. 이후 개정 부칙에서 적용례·경과조치 자동 발췌 (공포번호 매칭)
+ *   5. 행위시법/재판시법/제재처분 법리 주의 문구
+ *
+ * 차별점: time_travel은 두 시점 diff. 이 도구는 "특정 시점의 적용 법령 버전 특정 + 경과규정".
+ * 한계: 경과조치 '해석'은 하지 않음 — 발췌와 경고까지만 (해석은 사람/LLM 몫).
+ */
+import { z } from "zod";
+import { truncateResponse } from "../lib/schemas.js";
+import { formatToolError, notFoundResponse } from "../lib/errors.js";
+import { findLaws } from "../lib/law-search.js";
+import { fetchHistoricalVersionsFull } from "../lib/historical-utils.js";
+import { buildJO } from "../lib/law-parser.js";
+import { cleanHtml } from "../lib/article-parser.js";
+import { toArray } from "../lib/xml-parser.js";
+export const ApplicableLawSchema = z.object({
+    lawName: z.string().describe("법령명 (예: '도로교통법', '근로기준법')"),
+    date: z.string().describe("기준일 — 행위·계약·처분 시점 (예: '2023-05-10', '2023.5.10', '20230510')"),
+    jo: z.string().optional().describe("조문 번호 (예: '제44조', '제10조의2'). 지정 시 해당 시점 조문 본문 + 현행 비교 제공"),
+    apiKey: z.string().optional().describe("법제처 Open API 인증키(OC). 사용자가 제공한 경우 전달"),
+});
+/** 다양한 날짜 표기 → YYYYMMDD. 실패 시 null */
+export function normalizeDate(input) {
+    const m = input.trim().match(/(\d{4})\s*[.\-/년\s]?\s*(\d{1,2})\s*[.\-/월\s]?\s*(\d{1,2})\s*일?/);
+    if (!m) {
+        const digits = input.replace(/\D/g, "");
+        return /^\d{8}$/.test(digits) ? digits : null;
+    }
+    const y = parseInt(m[1], 10);
+    const mo = parseInt(m[2], 10);
+    const d = parseInt(m[3], 10);
+    if (y < 1900 || y > 2100 || mo < 1 || mo > 12 || d < 1 || d > 31)
+        return null;
+    return `${y}${String(mo).padStart(2, "0")}${String(d).padStart(2, "0")}`;
+}
+function fmtYmd(ymd) {
+    if (!/^\d{8}$/.test(ymd))
+        return ymd;
+    return `${ymd.slice(0, 4)}.${parseInt(ymd.slice(4, 6), 10)}.${parseInt(ymd.slice(6, 8), 10)}.`;
+}
+/** eflaw JSON에서 조문 본문 추출 (항·호 평탄화) */
+function extractJoText(jsonText) {
+    try {
+        const json = JSON.parse(jsonText);
+        const units = toArray(json?.법령?.조문?.조문단위);
+        const found = units.find((u) => u?.조문여부 === "조문");
+        if (!found)
+            return "";
+        const parts = [];
+        parts.push(cleanHtml(String(found.조문내용 || "")));
+        for (const h of toArray(found.항)) {
+            if (h?.항내용)
+                parts.push(cleanHtml(String(h.항내용)));
+            for (const ho of toArray(h?.호)) {
+                if (ho?.호내용)
+                    parts.push(cleanHtml(String(ho.호내용)));
+            }
+        }
+        return parts.join("\n").trim();
+    }
+    catch {
+        return "";
+    }
+}
+/** 부칙내용(중첩 배열/문자열)을 라인 배열로 평탄화 */
+function flattenAddendum(content) {
+    if (content === null || content === undefined)
+        return [];
+    if (typeof content === "string") {
+        return content.split(/\n/).map(s => cleanHtml(s).trim()).filter(Boolean);
+    }
+    if (Array.isArray(content))
+        return content.flatMap(flattenAddendum);
+    return [cleanHtml(String(content)).trim()].filter(Boolean);
+}
+/** 경과규정·적용례 신호 패턴 */
+const TRANSITION_RE = /적용례|경과조치|종전의\s*규정|시행\s*전에?\s*|행위에\s*대하여|예에\s*따른다|불구하고.*적용/;
+function extractTransitionExcerpts(units, relevantAncNos, joDisplay, maxAddenda = 6, maxLinesPer = 3) {
+    const out = [];
+    // 최신 부칙부터 (공포일자 내림차순)
+    const sorted = [...units].sort((a, b) => String(b?.부칙공포일자 || "").localeCompare(String(a?.부칙공포일자 || "")));
+    for (const unit of sorted) {
+        if (out.length >= maxAddenda)
+            break;
+        const ancNo = String(parseInt(String(unit?.부칙공포번호 || "0"), 10));
+        if (relevantAncNos.size > 0 && !relevantAncNos.has(ancNo))
+            continue;
+        const lines = flattenAddendum(unit?.부칙내용);
+        if (lines.length === 0)
+            continue;
+        // 원문 첫 줄이 "부칙 <제N호,...>" 형식이면 사용, "부칙"만 있으면 공포번호·일자로 구성
+        const header = lines[0].startsWith("부칙") && /제\s*\d+\s*호/.test(lines[0]) ? lines[0]
+            : `부칙 <제${unit?.부칙공포번호}호, ${fmtYmd(String(unit?.부칙공포일자 || ""))}>`;
+        // 조문 지정 시: 해당 조문 언급 라인 최우선 → 경과규정 신호 라인
+        const joHits = joDisplay ? lines.filter(l => l.includes(joDisplay)) : [];
+        const transitionHits = lines.filter(l => TRANSITION_RE.test(l) && !joHits.includes(l));
+        const picked = [...joHits, ...transitionHits].slice(0, maxLinesPer);
+        if (picked.length === 0)
+            continue;
+        out.push({ header, lines: picked.map(l => l.length > 250 ? l.slice(0, 250) + "…" : l) });
+    }
+    return out;
+}
+export async function applicableLaw(apiClient, input) {
+    try {
+        const date = normalizeDate(input.date);
+        if (!date) {
+            return notFoundResponse(`기준일 '${input.date}'을(를) 해석하지 못했습니다.`, [
+                "지원 형식: 2023-05-10 / 2023.5.10 / 20230510 / 2023년 5월 10일",
+            ]);
+        }
+        // 1. 법령 식별
+        const laws = await findLaws(apiClient, input.lawName, input.apiKey, 1);
+        if (laws.length === 0) {
+            return notFoundResponse(`'${input.lawName}' 법령을 찾을 수 없습니다.`, [
+                "search_law로 정확한 법령명을 먼저 확인하세요.",
+            ]);
+        }
+        const law = laws[0];
+        // 2. 연혁 → 기준일 시행 버전 특정 (versions는 시행일 내림차순)
+        const { versions } = await fetchHistoricalVersionsFull(apiClient, law.lawName, input.apiKey);
+        if (versions.length === 0) {
+            return notFoundResponse(`'${law.lawName}' 연혁을 조회하지 못했습니다.`, [
+                "get_law_history 또는 search_historical_law로 직접 확인하세요.",
+            ]);
+        }
+        const applicable = versions.find(v => v.efYd && v.efYd <= date);
+        const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+        const current = versions.find(v => v.efYd && v.efYd <= today);
+        const laterVersions = versions.filter(v => v.efYd && v.efYd > date && v.efYd <= today);
+        const lines = [];
+        lines.push(`═══ 행위시법 판단: ${law.lawName} @ ${fmtYmd(date)} ═══`);
+        lines.push("");
+        if (!applicable) {
+            const earliest = versions[versions.length - 1];
+            lines.push(`✗ 기준일 ${fmtYmd(date)} 당시 이 법령은 시행 전입니다.`);
+            lines.push(`  최초 시행일: ${fmtYmd(earliest?.efYd || "")} (${earliest?.rrCls || "제정"})`);
+            lines.push("");
+            lines.push("⚠️ 기준일에 적용할 이 법령의 버전이 없습니다. 당시 규율하던 구법(폐지 법령)이 있는지 search_historical_law로 확인하세요.");
+            return { content: [{ type: "text", text: truncateResponse(lines.join("\n")) }] };
+        }
+        // 적용 버전 표시
+        lines.push(`▶ 기준일에 시행 중이던 버전`);
+        const promulgation = [`제${applicable.ancNo}호`, applicable.ancYd ? fmtYmd(applicable.ancYd) : "", applicable.rrCls]
+            .filter(Boolean).join(", ");
+        lines.push(`  ${law.lawName} [시행 ${fmtYmd(applicable.efYd)}] [${promulgation}] (MST ${applicable.mst})`);
+        if (laterVersions.length > 0) {
+            lines.push(`  ↳ 기준일 이후 현재까지 ${laterVersions.length}차례 개정·시행됨 (현행: 시행 ${fmtYmd(current?.efYd || "")})`);
+        }
+        else {
+            lines.push(`  ↳ 이 버전이 현행입니다 (기준일 이후 개정 없음)`);
+        }
+        // 3. 조문 비교 (jo 지정 시)
+        const joDisplay = input.jo ? (input.jo.startsWith("제") ? input.jo : `제${input.jo}`) : undefined;
+        if (joDisplay) {
+            const joCode = buildJO(joDisplay);
+            // eflaw는 MST 단독 조회 불가 — 해당 버전의 efYd 동반 필수 (없으면 "일치하는 법령이 없습니다")
+            const [thenJson, nowJson] = await Promise.all([
+                apiClient.getLawText({ mst: applicable.mst, jo: joCode, efYd: applicable.efYd, apiKey: input.apiKey }).catch(() => ""),
+                current && current.mst !== applicable.mst
+                    ? apiClient.getLawText({ mst: current.mst, jo: joCode, efYd: current.efYd, apiKey: input.apiKey }).catch(() => "")
+                    : Promise.resolve(""),
+            ]);
+            const thenText = thenJson ? extractJoText(thenJson) : "";
+            const nowText = nowJson ? extractJoText(nowJson) : "";
+            lines.push("");
+            lines.push(`▶ 기준일 시점 조문: ${joDisplay}`);
+            if (thenText) {
+                lines.push(thenText.length > 2000 ? thenText.slice(0, 2000) + "\n…(생략)" : thenText);
+            }
+            else {
+                lines.push(`  [NOT_FOUND] 해당 버전에서 ${joDisplay}를 찾지 못했습니다 (당시 미신설이거나 조회 실패). LLM은 본문을 추측하지 마세요.`);
+            }
+            if (current && current.mst !== applicable.mst) {
+                lines.push("");
+                const norm = (s) => s.replace(/\s+/g, "");
+                if (thenText && nowText) {
+                    if (norm(thenText) === norm(nowText)) {
+                        lines.push(`▶ 현행과 비교: ✅ 동일 (기준일 이후 이 조문은 개정되지 않음)`);
+                    }
+                    else {
+                        lines.push(`▶ 현행과 비교: △ 변경됨 — 현행 본문과 다릅니다. 인용 시 반드시 기준일 버전을 사용하세요.`);
+                        lines.push(`  상세 diff: chain_amendment_track(query="${law.lawName}", scenario="time_travel", fromDate="${date}", toDate="${today}")`);
+                    }
+                }
+                else {
+                    lines.push(`▶ 현행과 비교: 비교 불가 (한쪽 본문 조회 실패)`);
+                }
+            }
+        }
+        // 4. 이후 개정 부칙의 적용례·경과조치 발췌
+        if (laterVersions.length > 0 && current) {
+            try {
+                const lawJson = await apiClient.fetchApi({
+                    endpoint: "lawService.do",
+                    target: "law",
+                    type: "JSON",
+                    extraParams: { MST: current.mst },
+                    apiKey: input.apiKey,
+                });
+                const parsed = JSON.parse(lawJson);
+                const units = toArray(parsed?.법령?.부칙?.부칙단위);
+                // 기준일 이후 시행 개정들의 공포번호 + 적용 버전 자신의 부칙
+                const relevant = new Set([
+                    ...laterVersions.map(v => String(parseInt(v.ancNo || "0", 10))),
+                    String(parseInt(applicable.ancNo || "0", 10)),
+                ]);
+                const excerpts = extractTransitionExcerpts(units, relevant, joDisplay);
+                lines.push("");
+                if (excerpts.length > 0) {
+                    lines.push(`▶ 적용례·경과조치 발췌 (기준일 사건에 영향 가능 — 반드시 확인)`);
+                    for (const ex of excerpts) {
+                        lines.push(`  ◆ ${ex.header}`);
+                        ex.lines.forEach(l => lines.push(`    ${l}`));
+                    }
+                }
+                else {
+                    lines.push(`▶ 적용례·경과조치: 이후 개정 부칙에서 경과규정 신호 미발견 (부칙 원문 확인: get_law_text)`);
+                }
+            }
+            catch {
+                lines.push("");
+                lines.push(`▶ 적용례·경과조치: [FAILED] 부칙 조회 실패 — get_law_text(mst="${current.mst}")로 부칙을 직접 확인하세요.`);
+            }
+        }
+        // 5. 법리 주의 문구
+        lines.push("");
+        lines.push("⚖️ 적용 법령 판단 시 주의");
+        lines.push("  - 형사처벌: 행위시법 원칙 (형법 제1조제1항). 단, 재판 시 법이 더 가벼우면 신법 적용 (같은 조 제2항)");
+        lines.push("  - 제재처분(과징금·영업정지 등): 위반행위 시 법령 적용 (행정기본법 제14조제3항 본문). 단, 제재 기준이 가벼워졌으면 변경된 법령 (같은 항 단서)");
+        lines.push("  - 인허가 등 일반 처분: 원칙적으로 처분 시 법령 (행정기본법 제14조제2항)");
+        lines.push("  - 위 원칙은 부칙 경과규정이 우선합니다 — 위 발췌를 반드시 확인하세요. 이 도구는 발췌만 제공하며 해석하지 않습니다.");
+        return { content: [{ type: "text", text: truncateResponse(lines.join("\n")) }] };
+    }
+    catch (error) {
+        return formatToolError(error, "applicable_law");
+    }
+}

package/build/tools/article-detail.js

@@ -6,6 +6,7 @@ import { truncateResponse } from "../lib/schemas.js";
 import { buildJO } from "../lib/law-parser.js";
 import { cleanHtml } from "../lib/article-parser.js";
 import { formatToolError } from "../lib/errors.js";
+import { toArray } from "../lib/xml-parser.js";
 export const GetArticleDetailSchema = z.object({
     mst: z.string().optional().describe("법령일련번호 (search_law에서 획득)"),
     lawId: z.string().optional().describe("법령ID (search_law에서 획득)"),
@@ -67,7 +68,7 @@ export async function getArticleDetail(apiClient, input) {
         resultText += `조회 위치: ${locationLabel}\n\n`;
         // 조문 추출
         const rawUnits = lawData.조문?.조문단위;
-        const articleUnits = Array.isArray(rawUnits) ? rawUnits : rawUnits ? [rawUnits] : [];
+        const articleUnits = toArray(rawUnits);
         if (articleUnits.length === 0) {
             return {
                 content: [{ type: "text", text: resultText + "[NOT_FOUND] 해당 조문을 찾을 수 없습니다.\n⚠️ LLM은 조문 내용을 추측/생성하지 마세요." }],

package/build/tools/chains.js

@@ -156,9 +156,6 @@ function noResult(query) {
         isError: true,
     };
 }
-function isSearchFailure(result) {
-    return result.isError || /\[NOT_FOUND\]|\[FAILED\]|검색 결과가 없습니다|조회 실패/.test(result.text);
-}
 function filterReliableLawResults(laws, query) {
     const queryWords = query.replace(NON_LAW_NAME_RE, " ")
         .trim()

package/build/tools/cite-check.d.ts

@@ -0,0 +1,28 @@
+/**
+ * cite_check — 판례 생사 확인 / 인용 추적 (v4.3 killer feature, 한국형 Shepard's Citator)
+ *
+ * 문제: 전원합의체로 변경·폐기된 판례를 살아있는 것처럼 인용하는 것이
+ *       판례 인용에서 가장 위험한 실수. LLM도 사람도 자주 범한다.
+ *
+ * 입력: 사건번호 (예: '2013다61381')
+ * 처리:
+ *   1. nb= 정확 검색으로 대상 판례 특정
+ *   2. 본문검색(search=2)으로 그 사건번호를 인용한 후속 판례 역추적
+ *   3. 후속 판례 중 전원합의체 우선 본문 정밀 스캔 → 변경·폐기 문구 감지
+ *   4. 판정: 계속 인용 / 전합 후속 존재 / 변경 신호 감지 + 인용 타임라인
+ *
+ * 차별점: impact_map은 조문→판례 방향만 다룸. 판례→판례 인용 관계는 이 도구가 유일.
+ * 한계: 법제처 수록 판례(대법원 중심) 범위 내 — 출력에 명시하여 과신 방지.
+ */
+import { z } from "zod";
+import type { LawApiClient } from "../lib/api-client.js";
+import type { ToolResponse } from "../lib/types.js";
+export declare const CiteCheckSchema: z.ZodObject<{
+    caseNumber: z.ZodString;
+    display: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    deepScan: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CiteCheckInput = z.infer<typeof CiteCheckSchema>;
+export declare function extractCaseNumbers(text: string): string[];
+export declare function citeCheck(apiClient: LawApiClient, input: CiteCheckInput): Promise<ToolResponse>;

package/build/tools/cite-check.js

@@ -0,0 +1,244 @@
+/**
+ * cite_check — 판례 생사 확인 / 인용 추적 (v4.3 killer feature, 한국형 Shepard's Citator)
+ *
+ * 문제: 전원합의체로 변경·폐기된 판례를 살아있는 것처럼 인용하는 것이
+ *       판례 인용에서 가장 위험한 실수. LLM도 사람도 자주 범한다.
+ *
+ * 입력: 사건번호 (예: '2013다61381')
+ * 처리:
+ *   1. nb= 정확 검색으로 대상 판례 특정
+ *   2. 본문검색(search=2)으로 그 사건번호를 인용한 후속 판례 역추적
+ *   3. 후속 판례 중 전원합의체 우선 본문 정밀 스캔 → 변경·폐기 문구 감지
+ *   4. 판정: 계속 인용 / 전합 후속 존재 / 변경 신호 감지 + 인용 타임라인
+ *
+ * 차별점: impact_map은 조문→판례 방향만 다룸. 판례→판례 인용 관계는 이 도구가 유일.
+ * 한계: 법제처 수록 판례(대법원 중심) 범위 내 — 출력에 명시하여 과신 방지.
+ */
+import { z } from "zod";
+import { truncateResponse } from "../lib/schemas.js";
+import { formatToolError, notFoundResponse } from "../lib/errors.js";
+import { parsePrecedentXML } from "../lib/xml-parser.js";
+import { cleanHtml } from "../lib/article-parser.js";
+export const CiteCheckSchema = z.object({
+    caseNumber: z.string().describe("사건번호 (예: '2013다61381', '대법원 2018.10.30. 선고 2013다61381'처럼 문장 포함 가능)"),
+    display: z.number().optional().default(20).describe("후속 인용 판례 최대 표시 수 (기본 20)"),
+    deepScan: z.boolean().optional().default(true).describe("후속 인용 상위 판례 본문 정밀 스캔 (변경·폐기 문구 감지, 기본 true)"),
+    apiKey: z.string().optional().describe("법제처 Open API 인증키(OC). 사용자가 제공한 경우 전달"),
+});
+/** 텍스트에서 사건번호 추출 (예: 2013다61381, 96누4671, 2010두28604) */
+const CASE_NO_RE = /(\d{2,4})\s*([가-힣]{1,5})\s*(\d{1,7})/g;
+export function extractCaseNumbers(text) {
+    const out = [];
+    const seen = new Set();
+    let m;
+    CASE_NO_RE.lastIndex = 0;
+    while ((m = CASE_NO_RE.exec(text)) !== null) {
+        const cn = `${m[1]}${m[2]}${m[3]}`;
+        if (!seen.has(cn)) {
+            seen.add(cn);
+            out.push(cn);
+        }
+    }
+    return out;
+}
+/** 변경·폐기 treatment 신호 패턴 (대법원 전원합의체 판례변경 상투 문구) */
+const CHANGE_PATTERNS = [
+    { re: /변경하기로\s*(?:한다|하면서|함|하였)/, label: "판례 변경 선언" },
+    { re: /폐기하기로|폐기한다|폐기되었/, label: "판례 폐기 선언" },
+    { re: /더\s*이상\s*유지(?:될\s*수\s*없|하기\s*어렵)/, label: "선례 유지 불가 판시" },
+    { re: /배치되는\s*범위\s*에?서?\s*(?:이를\s*)?(?:모두\s*)?변경/, label: "저촉 범위 변경" },
+];
+function toYmd(date) {
+    return (date || "").replace(/[^\d]/g, "");
+}
+function isEnBancItem(item) {
+    return /전원합의체/.test(`${item.판례명 || ""} ${item.판결유형 || ""}`);
+}
+async function fetchPrecedentDetail(apiClient, id, apiKey) {
+    try {
+        const text = await apiClient.fetchApi({
+            endpoint: "lawService.do",
+            target: "prec",
+            type: "JSON",
+            extraParams: { ID: id },
+            apiKey,
+        });
+        const json = JSON.parse(text);
+        return json?.PrecService || json || null;
+    }
+    catch {
+        return null;
+    }
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * 본문에서 대상 판례 언급 주변 ±window 자 내 변경 문구 감지 + 인용 맥락 추출.
+ *
+ * 판결문 관행 주의: 사건번호를 한 번 쓰고 "(이하 '2008년 전원합의체 판결'이라 한다)"로
+ * 별칭을 정의한 뒤, 정작 변경 선언은 별칭으로 한다 (예: 2018다248626 → 2007다27670 변경).
+ * 사건번호만 추적하면 false negative — 별칭 정의를 감지해 별칭 출현 지점도 함께 스캔한다.
+ */
+function scanTreatment(body, targetCaseNo, window = 250) {
+    const clean = cleanHtml(body).replace(/\s+/g, " ");
+    // 사건번호는 본문에서 "2013다61381" 또는 "2013 다 61381" 형태
+    const targetSrc = targetCaseNo.replace(/(\d)([가-힣]+)(\d)/, "$1\\s*$2\\s*$3");
+    const refIndices = [];
+    let m;
+    const targetRe = new RegExp(targetSrc, "g");
+    while ((m = targetRe.exec(clean)) !== null)
+        refIndices.push(m.index);
+    // 별칭 정의: "…2007다27670 전원합의체 판결(이하 '2008년 전원합의체 판결'이라 한다)"
+    const aliasDefRe = new RegExp(targetSrc + "[^(]{0,40}\\(\\s*이하\\s*[‘'\"“]?([^’'\"”)]{2,40}?)[’'\"”]?\\s*(?:이?라\\s*고?\\s*)?한다", "g");
+    const aliases = new Set();
+    while ((m = aliasDefRe.exec(clean)) !== null)
+        aliases.add(m[1].trim());
+    for (const alias of aliases) {
+        const aliasRe = new RegExp(escapeRe(alias), "g");
+        while ((m = aliasRe.exec(clean)) !== null)
+            refIndices.push(m.index);
+    }
+    const signals = new Set();
+    let context;
+    for (const idx of refIndices.sort((a, b) => a - b)) {
+        const win = clean.slice(Math.max(0, idx - window), Math.min(clean.length, idx + window));
+        if (!context)
+            context = win.slice(0, 300);
+        for (const { re, label } of CHANGE_PATTERNS) {
+            if (re.test(win)) {
+                signals.add(label);
+                context = win.slice(0, 300); // 신호 잡힌 맥락을 우선 노출
+            }
+        }
+    }
+    return { changeSignals: [...signals], context };
+}
+export async function citeCheck(apiClient, input) {
+    try {
+        const candidates = extractCaseNumbers(input.caseNumber);
+        if (candidates.length === 0) {
+            return notFoundResponse(`'${input.caseNumber}'에서 사건번호를 추출하지 못했습니다.`, [
+                "사건번호 형식 예: 2013다61381, 96누4671, 2018두42559",
+            ]);
+        }
+        const caseNo = candidates[0];
+        // 1단계: 대상 판례 특정 (nb= 정확 검색)
+        const targetXml = await apiClient.fetchApi({
+            endpoint: "lawSearch.do",
+            target: "prec",
+            extraParams: { nb: caseNo, display: "10" },
+            apiKey: input.apiKey,
+        });
+        const targetParsed = parsePrecedentXML(targetXml);
+        // 동일 사건번호 정확 매칭 우선, 대법원 우선
+        const exact = targetParsed.items.filter(i => (i.사건번호 || "").replace(/\s/g, "").includes(caseNo));
+        const pool = exact.length > 0 ? exact : targetParsed.items;
+        const target = pool.find(i => /대법원/.test(i.법원명 || "")) || pool[0];
+        if (!target) {
+            return notFoundResponse(`사건번호 '${caseNo}' 판례를 법제처 DB에서 찾을 수 없습니다.`, [
+                "법제처 수록 판례는 대법원 중심입니다. 하급심은 search_decisions(query=키워드)로 검색하세요.",
+                "사건번호 오탈자 확인 (예: 다/두/도/누 구분)",
+            ]);
+        }
+        // 2~3단계 병렬: 대상 상세(참조판례) + 후속 인용 역추적(본문검색)
+        const [targetDetail, citingXml] = await Promise.all([
+            fetchPrecedentDetail(apiClient, target.판례일련번호, input.apiKey),
+            apiClient.fetchApi({
+                endpoint: "lawSearch.do",
+                target: "prec",
+                extraParams: { search: "2", query: caseNo, display: "50" },
+                apiKey: input.apiKey,
+            }),
+        ]);
+        const citingParsed = parsePrecedentXML(citingXml);
+        const citing = citingParsed.items
+            .filter(i => i.판례일련번호 !== target.판례일련번호)
+            .filter(i => (i.사건번호 || "").replace(/\s/g, "") !== caseNo)
+            .map(i => ({ ...i, isEnBanc: isEnBancItem(i) }))
+            .sort((a, b) => toYmd(b.선고일자).localeCompare(toYmd(a.선고일자)));
+        // 4단계: 정밀 스캔 — 전원합의체 > 대법원 > 최신 순으로 최대 3건
+        const scanResults = [];
+        if (input.deepScan && citing.length > 0) {
+            const prioritized = [...citing].sort((a, b) => {
+                if (a.isEnBanc !== b.isEnBanc)
+                    return a.isEnBanc ? -1 : 1;
+                const aSup = /대법원/.test(a.법원명 || "") ? 1 : 0;
+                const bSup = /대법원/.test(b.법원명 || "") ? 1 : 0;
+                if (aSup !== bSup)
+                    return bSup - aSup;
+                return toYmd(b.선고일자).localeCompare(toYmd(a.선고일자));
+            }).slice(0, 3);
+            const details = await Promise.all(prioritized.map(i => fetchPrecedentDetail(apiClient, i.판례일련번호, input.apiKey)));
+            details.forEach((d, idx) => {
+                const body = String(d?.판례내용 || "");
+                if (!body)
+                    return;
+                const { changeSignals, context } = scanTreatment(body, caseNo);
+                scanResults.push({ item: prioritized[idx], signals: changeSignals, context });
+            });
+        }
+        // 판정
+        const changed = scanResults.filter(r => r.signals.length > 0);
+        const enBancCiting = citing.filter(c => c.isEnBanc);
+        const scannedIds = new Set(scanResults.map(r => r.item.판례일련번호));
+        const enBancUnscanned = enBancCiting.filter(c => !scannedIds.has(c.판례일련번호));
+        let verdict;
+        if (changed.length > 0) {
+            verdict = `❌ 변경·폐기 신호 감지 — ${changed.map(r => `${r.item.사건번호}(${r.signals.join(", ")})`).join("; ")}\n   ⚠️ 이 판례를 현재 법리로 인용하기 전에 반드시 해당 후속 판결 전문을 확인하세요.`;
+        }
+        else if (enBancUnscanned.length > 0) {
+            // 스캔 안 된 전합 후속이 남아있을 때만 경고 (판례 변경은 전원합의체에서만 가능, 법원조직법 제7조)
+            verdict = `⚠️ 미스캔 전원합의체 후속 판결 ${enBancUnscanned.length}건 존재 — 법리 변경 여부 본문 확인 권장 (${enBancUnscanned.slice(0, 3).map(c => c.사건번호).join(", ")})`;
+        }
+        else if (citing.length > 0) {
+            const enBancNote = enBancCiting.length > 0 ? ` (전원합의체 ${enBancCiting.length}건 포함 정밀 스캔 완료)` : "";
+            verdict = `✅ 후속 인용 ${citing.length}건, 변경·폐기 신호 미감지 — 계속 인용되는 것으로 추정${enBancNote}`;
+        }
+        else {
+            verdict = `ℹ️ 법제처 수록 범위 내 후속 인용 없음 — 미수록 판례의 인용 가능성은 배제 못 함`;
+        }
+        // 출력 조립
+        const refCases = extractCaseNumbers(String(targetDetail?.참조판례 || "")).filter(c => c !== caseNo);
+        const lines = [];
+        lines.push(`═══ 판례 인용 추적 (Citator): ${caseNo} ═══`);
+        lines.push(`대상: ${target.법원명 || ""} ${target.선고일자 || ""} 선고 ${target.사건번호 || caseNo} ${isEnBancItem(target) ? "전원합의체 " : ""}판결`);
+        if (target.판례명)
+            lines.push(`사건명: ${target.판례명}`);
+        lines.push("");
+        lines.push(`📊 판정: ${verdict}`);
+        if (citing.length > 0) {
+            lines.push("");
+            lines.push(`▶ 이 판례를 인용한 후속 판례 (${citing.length}건, 최신순)`);
+            citing.slice(0, input.display).forEach((c, i) => {
+                const enBanc = c.isEnBanc ? " ⚡전원합의체" : "";
+                lines.push(`  ${i + 1}. ${c.법원명 || ""} ${c.선고일자 || ""} ${c.사건번호 || ""}${enBanc} — ${(c.판례명 || "").slice(0, 60)}`);
+            });
+            if (citing.length > input.display)
+                lines.push(`  … 외 ${citing.length - input.display}건`);
+        }
+        if (scanResults.length > 0) {
+            lines.push("");
+            lines.push(`▶ 본문 정밀 스캔 (${scanResults.length}건)`);
+            for (const r of scanResults) {
+                const mark = r.signals.length > 0 ? `🚨 ${r.signals.join(", ")}` : "인용 확인 (변경 문구 없음)";
+                lines.push(`  - ${r.item.사건번호}: ${mark}`);
+                if (r.context)
+                    lines.push(`    맥락: "…${r.context}…"`);
+            }
+        }
+        if (refCases.length > 0) {
+            lines.push("");
+            lines.push(`▶ 이 판례가 인용한 판례 (참조판례 ${refCases.length}건)`);
+            lines.push(`  ${refCases.join(", ")}`);
+            lines.push(`  ↳ 각 판례의 생사 확인: cite_check(caseNumber="...")`);
+        }
+        lines.push("");
+        lines.push("⚠️ 한계: 법제처 수록 판례(대법원 중심) 범위 내 검색입니다. 하급심·미수록 판례의 인용은 포함되지 않으며,");
+        lines.push("   변경 신호 감지는 휴리스틱입니다. 최종 확인은 후속 판결 전문 검토(get_decision_text) 및 종합법률정보 병행을 권장합니다.");
+        return { content: [{ type: "text", text: truncateResponse(lines.join("\n")) }] };
+    }
+    catch (error) {
+        return formatToolError(error, "cite_check");
+    }
+}

package/build/tools/law-text.js

@@ -191,11 +191,13 @@ export async function getLawText(apiClient, input) {
                 tocText += `lawId="${input.lawId}", jo="제XX조")`;
             }
             tocText += `\n여러 조문 일괄 조회: get_batch_articles 도구 사용`;
-            lawCache.set(cacheKey, tocText);
+            // 절단본을 캐시 — 캐시 히트 경로는 절단 없이 반환하므로 미절단 캐시 시 50KB 제한 우회됨
+            const truncatedToc = truncateResponse(tocText);
+            lawCache.set(cacheKey, truncatedToc);
             return {
                 content: [{
                         type: "text",
-                        text: truncateResponse(tocText)
+                        text: truncatedToc
                     }]
             };
         }

package/build/tools/ordinance.js

@@ -6,6 +6,7 @@ import { cleanHtml } from "../lib/article-parser.js";
 import { buildJO } from "../lib/law-parser.js";
 import { truncateResponse } from "../lib/schemas.js";
 import { formatToolError } from "../lib/errors.js";
+import { toArray } from "../lib/xml-parser.js";
 export const GetOrdinanceSchema = z.object({
     ordinSeq: z.string().describe("자치법규 일련번호"),
     jo: z.string().optional().describe("조문 번호 (예: '제20조'). 지정 시 해당 조문 본문만 반환"),
@@ -46,7 +47,7 @@ export async function getOrdinance(apiClient, input) {
         resultText += `\n---\n\n`;
         // 조문 내용 (단일 객체 → 배열 정규화)
         const rawArticles = lawService.조문?.조;
-        const articles = Array.isArray(rawArticles) ? rawArticles : rawArticles ? [rawArticles] : [];
+        const articles = toArray(rawArticles);
         if (articles.length > 0) {
             // jo 파라미터가 있으면 해당 조문만 필터링
             if (input.jo) {

package/build/tools/scenarios/index.js

@@ -28,9 +28,18 @@ export async function runScenario(type, ctx) {
     try {
         return await runner(ctx);
     }
-    catch {
-        // 시나리오 실패는 체인 전체를 중단시키지 않음
-        return { sections: [], suggestedActions: [] };
+    catch (e) {
+        // 시나리오 실패는 체인 전체를 중단시키지 않되, 무음 증발 금지 —
+        // 실패 섹션을 반환해 LLM이 "결과 없음"과 "실행 실패"를 구분하게 한다 (secOrSkip과 동일 원칙)
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            sections: [{
+                    title: `시나리오(${type}) [FAILED]`,
+                    content: `⚠️ 시나리오 실행 실패 — LLM은 이 섹션 내용을 추측/생성하지 마세요.\n사유: ${msg.slice(0, 200)}`,
+                    isError: true,
+                }],
+            suggestedActions: [],
+        };
     }
 }
 /** query-router 자동감지용: 쿼리에서 시나리오 타입 추론 */

package/build/tools/scenarios/time-travel.js

@@ -1,4 +1,5 @@
 import { fetchHistoricalVersionsFull } from "../../lib/historical-utils.js";
+import { toArray } from "../../lib/xml-parser.js";
 function normalizeText(s) {
     return (s || "")
         .replace(/<[^>]+>/g, " ")
@@ -11,7 +12,7 @@ function normalizeText(s) {
 }
 function extractArticleSnapshots(lawJson) {
     const raw = lawJson?.법령?.조문?.조문단위;
-    const units = Array.isArray(raw) ? raw : raw ? [raw] : [];
+    const units = toArray(raw);
     const snapshots = [];
     for (const u of units) {
         if (u?.조문여부 !== "조문")
@@ -21,10 +22,10 @@ function extractArticleSnapshots(lawJson) {
         const title = String(u.조문제목 || "");
         let body = normalizeText(String(u.조문내용 || ""));
         // 항/호/목 본문 합산 (정규화)
-        const hangs = Array.isArray(u.항) ? u.항 : u.항 ? [u.항] : [];
+        const hangs = toArray(u.항);
         for (const h of hangs) {
             body += " " + normalizeText(String(h.항내용 || ""));
-            const hos = Array.isArray(h.호) ? h.호 : h.호 ? [h.호] : [];
+            const hos = toArray(h.호);
             for (const ho of hos) {
                 body += " " + normalizeText(String(ho.호내용 || ""));
             }

package/build/tools/verify-citations.js

@@ -20,6 +20,7 @@ import { findLaws } from "../lib/law-search.js";
 import { parseHangNumber } from "../lib/article-parser.js";
 import { truncateResponse } from "../lib/schemas.js";
 import { formatToolError } from "../lib/errors.js";
+import { toArray } from "../lib/xml-parser.js";
 export const VerifyCitationsSchema = z.object({
     text: z.string().min(1).describe("검증할 법률 텍스트 (LLM 답변/계약서/판결문 등). 조문 인용이 포함된 문자열"),
     maxCitations: z.number().min(1).max(30).optional().default(15).describe("검증할 최대 인용 개수 (기본 15, 많을수록 느림)"),
@@ -120,7 +121,7 @@ async function verifyOne(apiClient, cite, apiKey) {
         const jsonText = await apiClient.getLawText({ mst: chosen.mst, jo: cite.joCode, apiKey });
         const json = JSON.parse(jsonText);
         const rawUnits = json?.법령?.조문?.조문단위;
-        const units = Array.isArray(rawUnits) ? rawUnits : rawUnits ? [rawUnits] : [];
+        const units = toArray(rawUnits);
         const found = units.find((u) => u.조문여부 === "조문");
         if (!found) {
             // 전체 조회로 범위 힌트
@@ -128,7 +129,7 @@ async function verifyOne(apiClient, cite, apiKey) {
             try {
                 const fullJson = JSON.parse(await apiClient.getLawText({ mst: chosen.mst, apiKey }));
                 const fullRaw = fullJson?.법령?.조문?.조문단위;
-                const fullUnits = Array.isArray(fullRaw) ? fullRaw : fullRaw ? [fullRaw] : [];
+                const fullUnits = toArray(fullRaw);
                 const nums = fullUnits
                     .filter((u) => u.조문여부 === "조문" && u.조문번호)
                     .map((u) => parseInt(u.조문번호, 10))
@@ -145,7 +146,7 @@ async function verifyOne(apiClient, cite, apiKey) {
         const officialLabel = `${chosen.lawName} ${cite.displayArticle}`;
         if (cite.hang) {
             const rawHang = found.항;
-            const hangs = Array.isArray(rawHang) ? rawHang : rawHang ? [rawHang] : [];
+            const hangs = toArray(rawHang);
             const hangNumbers = hangs
                 .map((h) => parseHangNumber(h.항번호))
                 .filter((n) => !isNaN(n));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "korean-law-mcp",
-  "version": "4.2.1",
-  "description": "법제처 42개 API → 17개 MCP 도구. 법령·판례·조례·조약 + LLM 환각 방지 인용 검증 + 조문 영향 그래프(impact_map) + 시점 비교(time_travel) + 상황별 5단계 안내(action_plan) + 국세청 해석례(nts)",
+  "version": "4.3.0",
+  "description": "법제처 42개 API → 19개 MCP 도구. 법령·판례·조례·조약 + LLM 환각 방지 인용 검증 + 조문 영향 그래프(impact_map) + 시점 비교(time_travel) + 상황별 5단계 안내(action_plan) + 판례 생사 확인(cite_check, 한국형 Citator) + 행위시법 판단(applicable_law) + 국세청 해석례(nts)",
   "type": "module",
   "main": "build/index.js",
   "types": "build/index.d.ts",