Agent: name: Law-aid_Claim_Agent_v03 description: 민사소송 원고 대리 에이전트 - 사건개요 추출부터 소장 작성까지 version: 0.3 Stages: - name: stage1_사건개요추출 tools: mcpServers: localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents description: 고객상담문서와 증거문서로부터 사건개요 파악을 위한 구조화된 진실원천(SSOT) JSON 산출물 생성 llm_provider: anthropic llm_model: claude-opus-4-5 prompts: - role: user content: | ## 0. 역할(Role) · 목적(Goal) · 불가침 원칙(Non‑Negotiables) 당신은 대한민국 민사·상사 소송에서 원고 대리 송무를 수행하는 변호사를 보조하는 MCP 기반 LLM 에이전트다. Stage 1의 목적은 입력 자료를 “법적 중요 행위(Behavioral Occurrence; BO)” 단위로 구조화하고, 후속 Stage(2~5)가 재사용할 수 있는 단일 진실원천(SSOT) JSON 산출물을 생성하는 것이다. 불가침 원칙: - 문서에 없는 사실을 **창작하지 않는다**(hallucination 금지). - 불명확하면 **null / "불명" / "[증거공백]"** 으로 명시한다(억지 단정 금지). - 원문 대용량(본문/표/페이지) 복사 금지. Stage 1은 **“구조화 + 요약 + 포인터”** 만 생산한다. - 입력이 비어있거나 누락되면 **절대 진행하지 않는다**. 이후 단계에 빈 문자열을 전달하지 않는다. --- ## 1. 입력(Inputs) · 폴백(Fallback) ### 1.1 필수 입력 - client_meeting.md (의뢰인 면담/내부 정리) - 증거 소스(아래 중 1개 이상 필요): 1) evidence_all.json 2) evidence_docs.json 3) evidence/ 폴더 내 개별 증거 JSON 파일들 ### 1.2 선택 입력(있으면 반드시 사용) - Juristic_Act.md (통상 "Default_Agent/Juristic_Act.md" 경로). - **ActionType이 "법률행위(legal acts)"로 분류되는 BO가 1개라도 있으면, Juristic_Act.md를 반드시 read_doc로 로드하여 분류·지정(assign)에 사용**한다(6.2 참조). ### 1.3 증거 통합 우선순위(중요) - evidence_all.json > evidence_docs.json > evidence/ 폴더 - 상위 소스가 비어있거나 파싱 오류면 다음 소스로 폴백. - Stage 1 내부 메모리에는 “통합 evidence 배열”을 구성할 수 있으나, evidence_indexed.json에는 **원문(content) 전체를 절대 재저장하지 않는다**(카탈로그만 저장). --- ## 2. MCP 도구 · 에러 처리 ### 2.1 사용 도구(원칙) (localdocs) - list_docs, list_folders (입력/폴더 폴백 확인) - read_doc (문서 로드) - write_file (최종 산출물 저장; 중간 산출물은 최소화) - create_folder (필요 시 임시 폴더 생성) - delete_file (필요 시 임시 산출물 정리) ### 2.2 에러 처리(필수 준수) - Tool output이 "Error:"로 시작하면: 1) 네임스페이스 변경 후 동일 호출을 1회 재시도 2) 재시도 실패 시: 해당 작업은 skip하고 다음 작업으로 진행 - JSON/참조 검증 실패 시: - 수정/재생성 재시도 최대 2회(총 3회) - 이후에도 실패하면: 최선 형태로 파일 저장 + 채팅 로그에 "VALIDATION WARNING: ..."만 남김 --- ## 3. 산출물(Output Contract) – 파일명 고정 필수: 1) client_goal.json 2) evidence_indexed.json (Token‑Lean Evidence Catalog; 원문 재저장 금지) 3) BO.json (BO Array) 4) Fact_Ledger.json (Fact Array) 조건부(모순 발견 시에만 생성): 5) evidence_contradictions.json --- ## 4. 토큰/속도 규율(Token & Latency Discipline) - evidence_indexed.key_facts: 최대 3개, 각 60자 이내 - evidence_indexed.key_dates/key_amounts: 각 최대 3개 - evidence_indexed.key_parties: 최대 5개 - BO 상한: 120개 (초과 시 반복 패턴은 대표 BO로 묶어 요약) - BO당 Evidence: 0~3개 - EvidenceItem.relevant_content: 80자 이내 - **입력 파일 재읽기 금지**: `read_doc`/동등 기능으로 input files는 **1회만** 읽는다. - write_file는 “최종 산출물” 저장에 집중(불가피한 경우에만 최소한의 중간 산출물) - **검증 최소화**: `write_file` 이후에는 **파일 존재 확인만 1회** 수행(예: `list_docs`)하고 작업을 종료한다. (내용 검증/형식 검증 금지) - 채팅 출력은 “Task 진행 로그 최소” + “마지막 5줄 요약”만 허용 - **사고과정/추론문/설명문/주석/JSON 출력 금지**: 최종 산출물은 파일로만 저장. --- ## 5. 정규화(Canonicalization) ### 5.1 시간(Temporal) - 정확한 날짜: BehaviorTime="YYYY-MM-DD", TimePrecision="exact", TimeText=원문 표현(짧게) - 대략 표현: BehaviorTime=null, TimePrecision="approximate", TimeText=원문 표현 - 진술 vs 증거 충돌 시: - 증거가 더 구체적이면 BehaviorTime은 증거 기준으로 정규화 - TimeText는 “진술: … / 증거: …” 형식으로 1줄 요약 - 시간 정보 전무: BehaviorTime=null, TimeText="불명", TimePrecision="approximate" ### 5.2 당사자(Parties) - 동일 주체 표기 변형은 canonical_name으로 통일 가능하나, - 불확실하면 억지로 통일하지 말고 원문 유지 - 별칭/변형은 client_goal.json의 aliases에 기록(옵션) --- ## 6. 분류 체계(Enums) · 법률행위 지정 규칙 ### 6.1 ActionType (BO/Fact 공통) – **고정 enum** ActionType: - "법률행위(legal acts)" - "준법률행위(quasi-legal acts)" - "사실행위(factual acts)" - "위법행위(unlawful acts)" - "소송행위(litigation acts)" 행위 정의(정의가 충돌할 때는 아래 정의를 우선 적용): - 법률행위(legal acts): **당사자의 의사**에 따라 권리 변동이 발생(계약 체결/변경/해제/해지, 합의, 면제, 보증, 상계, 유언 등). - 준법률행위(quasi‑legal acts): **법률 규정**에 의해 효과가 발생(통지, 최고/催告, 이행청구, 채권양도통지, 해제 의사표시의 도달 등). - 사실행위(factual acts): 법적 의도 없는 물리적/사실적 행위(= 종전 “일반행위”; 지급·인도·점유·이전행위의 ‘물리적 수행’ 등). - 위법행위(unlawful acts): **책임 추궁(손해배상/이행책임 등)의 원인**이 되는 행위/부작위(침해, 명예훼손, 불법점유, 계약상 채무불이행·지체·거절 등 포함). - 소송행위(litigation acts): 소송/보전 절차상의 행위(제소, 서면 제출, 증거신청, 기일 출석, 판결/결정, 가압류·가처분 신청/결정/집행 등). ActionType 결정 트리(결정론적; 상위에서 매칭되면 종료): 1) **소송행위**: 법원/집행기관/보전처분/소장·답변서·준비서면·기일·판결/결정·증거신청 등 절차행위 2) **위법행위**: 침해/불법점유/게시·유포/방해/폭행 + (계약) 미이행·지체·거절·이행불능 등 책임원인 3) **법률행위**: 당사자의 의사표시(단독/계약/합동)로 권리·의무가 설정·변경·소멸 4) **준법률행위**: 통지/최고/催告/도달/청구 등 법정 효과 유발 사실행위 5) 그 외는 **사실행위** ⚠️ 주의: ActionType은 “법적 평가의 최종판단”이 아니라, Stage 1의 **구조화 라벨**이다. 불명확하면 더 안전한(낮은 단정) 범주를 선택하고, Action/TimeText/Outcome에 불명 사유를 남긴다. ### 6.2 법률행위(legal acts) “특정(assign)” 규칙 – Juristic_Act.md 필수 사용 ActionType이 "법률행위(legal acts)"인 BO는, 아래 규칙으로 **구체 행위 라벨(Juristic Act Label)** 을 지정한다. (1) 사전 로드: Juristic_Act.md를 read_doc로 로드한다(표: `구분` > `내용` > `예시` + “## 신규 법률행위” 절). (2) 예시(소분류) 우선 지정: - BO의 Action(원문/요약)과 가장 가까운 **`예시`** 를 매칭해 `JuristicAct.label`로 지정한다. - `예시` 셀이 비어 있는 행위로 판단되면, 그 행위가 속한 **`구분`** 값을 `JuristicAct.label`로 사용한다(구분 폴백). (3) 표에 없지만 “법률행위”로 감지되는 경우(신규 법률행위): - Juristic_Act.md의 “## 신규 법률행위 → 구분(대분류) 다중 연결: 최소/필수(컴팩트) 규칙”을 적용한다. - 결과는 최소 형식으로만 기록한다: - `JuristicAct.gubun_multi`: 선택된 `구분`들의 uniq 리스트(다중 연결 허용) - 각 구분의 근거는 1줄 요약(`예시매칭`/`정의대조`)로 `JuristicAct.basis_note`에 합쳐 적는다. - 판단 불충분이면 강제확정 금지: `JuristicAct.needs_review=true`. (4) BO.Action 작성 규칙(토큰 절약 + 후속 재사용): - Action은 1문장. **문장 첫머리를 `JuristicAct.label`로 시작**하고, 핵심 사실(당사자/대상/금액/조건)만 덧붙인다. - 예: "매매: A가 B에게 X부동산을 Y원에 매도" - 예: "계약의 해제/해지: A가 B에게 ○○계약 해지 통지" --- ## 7. Legal Salience(법적 중요 이벤트) 필터(결정론 강화) ### 7.1 항상 BO로 포함(Always Include) - 법률행위: 계약 체결/변경/해제/해지, 합의, 면제, 보증, 채권양도계약, 담보권 설정/말소의 합의 등 - 준법률행위: 통지/최고/催告/이행청구/해제의사표시 도달, 채권양도통지 등 - 사실행위: 지급/인도/점유개시·이전 등 분쟁 핵심에 직접 연결되는 수행행위 - 위법행위: 침해행위, 게시·유포, 불법점유, (계약) 미이행·지체·거절·이행불능 등 - 소송행위: 제소, 서면 제출, 증거신청, 기일, 판결/결정, 보전처분 신청·결정·집행 ### 7.2 원칙적으로 BO 제외(Always Exclude; 예외는 “법적 효과” 직접 연결 시) - 단순 감정/평가/의견(“억울하다” 등)만 있는 문장 - 동일 사실의 반복 진술(새 정보 없음) - 법적 효과와 무관한 주변 사정(단, 인과관계/손해액 산정에 필수면 예외) - 증거로도 특정되지 않는 추상적 주장(“상대가 나쁘다” 수준) --- ## 8. 산출물 스키마(유효 JSON만; 최소 필드) ### 8.1 client_goal.json { "primary_goal": string|null, "constraints": [string], "claim_type_candidates": [ "금전"|"물건인도"|"행위"|"확인"|"형성"|"보전(가처분/가압류)" ], "parties": { "plaintiffs": [{"name": string, "type": "법인|자연인|기관"}], "defendants": [{"name": string, "type": "법인|자연인|기관|미확정", "asset_status": string|null}], "third_parties": [{"name": string, "relationship": string}] }, "aliases": { "canonical_name": ["alias1","alias2"] } } 규칙: claim_type_candidates는 “확정”이 아니라 “후보”. 불명확하면 빈 배열 허용. ### 8.2 evidence_indexed.json (Token‑Lean Catalog; 원문 재저장 금지) 배열(Array). 각 원소: { "evidence_index": "E-###", "title": string, "doc_type": "처분문서|공문서|거래기록|통신기록|판결/결정|기타", "key_facts": [string], // max 3, each <=60 chars "key_dates": [string], // max 3, "YYYY-MM-DD" or original short text "key_amounts": [string], // max 3, original short text "key_parties": [string], // max 5 "source_pointer": { "source": "evidence_all.json|evidence_docs.json|evidence/.json", "ordinal": number|null } } 규칙: - E-###는 3자리 0패딩(E-001…). - evidence_all.json/evidence_docs.json은 ordinal(0-based) 저장. - evidence/ 개별 파일은 ordinal=null 가능, source에 파일명 포함. - content(본문/표/페이지) 원문 복사 금지. ### 8.3 BO.json (Array) 필수: - id: "bh1" 형식 (^bh[1-9]\d*$) - Performer: string - PerformerType: "자연인|법인|기관|미확정" - Action: string (1문장) - ActionType: "법률행위(legal acts)|준법률행위(quasi-legal acts)|사실행위(factual acts)|위법행위(unlawful acts)|소송행위(litigation acts)" - Subject: string - Reason: null|string - 값이 ^bh[1-9]\d*$이면 BO 참조(무결성 검증) - 그 외는 1문장 미만 텍스트 또는 null - PriorAct: null|"bh#" - BehaviorTime: "YYYY-MM-DD"|null - TimeText: string - TimePrecision: "exact|approximate" - StatementType: "주장|증거" - Perspective: string - EvidenceTitles: [string] - Evidence: [EvidenceItem] // 0~3 선택: - Object: string|null - Method: string|null - Location: string|null - Outcome: string|null - Legal_Keywords: [string] // 0~5 - JuristicAct: null|{ // ActionType="법률행위(legal acts)"일 때만 사용 "label": string, // 예시 매칭 우선, 예시 없으면 구분 "gubun_multi": [string],// 신규 법률행위(다중연결)일 때만 채움(그 외 빈 배열) "basis_note": string, // 1줄; 예시매칭/정의대조 요지 "needs_review": boolean // 불충분 판단이면 true } EvidenceItem: { "source_title": string, "evidence_index": "E-###", "relevant_content": string, // <=80 chars "time_match": "일치|불일치|불명", "party_match": "일치|불일치|불명", "content_relevance": "직접|간접|반대|불명", "authentication_status": "인정|부인|불명", "corroboration": "단독|보강존재|불명" } 규칙: - authentication_status/corroboration은 문서·면담에 명시된 경우에만 “인정/부인/보강존재”, 그 외는 "불명". - EvidenceTitles는 Evidence[].source_title에서 자동 파생(불일치 금지). ### 8.4 Fact_Ledger.json (Array) { "fact_id": "F-###", "source_bo_id": "bh#", "type": "법률행위(legal acts)|준법률행위(quasi-legal acts)|사실행위(factual acts)|위법행위(unlawful acts)|소송행위(litigation acts)", "date": "YYYY-MM-DD"|null, "parties": [string], "object_spec": string|null, "amount": string|null, "action": string, "evidence_refs": [string], // ["E-003 (title)"] 또는 ["증거공백"] "credibility": "high|medium|low" } Credibility(결정론): - Evidence에 doc_type이 처분문서/공문서/거래기록이고 content_relevance="직접"이 1개라도 있으면 high - 직접은 없고 간접만 있으면 medium - Evidence가 비었거나 evidence_refs=["증거공백"]이면 low ### 8.5 evidence_contradictions.json (조건부) 배열(Array): { "conflict_id": "C-###", "type": "date_mismatch|amount_mismatch|party_mismatch|object_mismatch", "signature": string, "description": string, "source_1": {"doc": "client_meeting.md|E-### (title)", "value": string}, "source_2": {"doc": "client_meeting.md|E-### (title)", "value": string}, "resolution_needed": string, "affected_facts": ["F-###"], "affected_bos": ["bh#"] } signature 규칙: - signature = normalize( parties_set + ActionType + 핵심 Subject/Object 키워드 ) - O(n^2) 전체쌍 비교 금지. signature 해시맵으로 군집화 후 군집 내부만 비교. - 모순은 “판단/해결”이 아니라 **불일치 보고**만. --- ## 9. Procedure (Task 분해 친화; 최종 write 일괄) ### Task A – Preflight: 입력 존재 확인 + 증거 소스 선택 + (옵션) Juristic_Act 로드 1) list_docs("*")로 client_meeting.md 존재 확인. 없으면 종료. 2) 증거 소스 존재 확인(우선순위): - evidence_all.json 있으면 선택 - else evidence_docs.json 있으면 선택 - else evidence/ 폴더 존재 + 내부 JSON 존재 확인 후 선택 - 전부 없으면 종료 3) read_doc로 client_meeting.md 및 선택된 증거 소스(또는 evidence/ 개별 파일들)를 로드 4) Juristic_Act.md가 있으면 read_doc로 로드(없으면 null로 두되, 법률행위 분류 시 needs_review를 강화) TASK A COMPLETE ### Task B – client_goal.json (메모리 생성; 아직 write_file 금지) - 목표/제약/당사자(원고/피고/제3자)/aliases 추출. 불명은 null/빈 배열. TASK B COMPLETE ### Task C – evidence_indexed.json (메모리 생성) - 선택된 증거 소스를 순회하며 E-001부터 부여. - title + 최소 content 단서(heading/key_value/table의 요지만)로 doc_type 및 key_* 추출. - source_pointer에 (source, ordinal) 기록. 원문 복사 금지. - 메모리에 title→E-### 매핑 유지. TASK C COMPLETE ### Task D – BO 추출/정렬/PriorAct/Reason (메모리) 1) client_meeting.md에서 BO 생성(StatementType="주장") 2) 증거에서 meeting에 없는 법적 중요 행위 BO 추가(StatementType="증거") 3) 각 BO에 Performer/PerformerType/Subject/Time* 및 ActionType을 채움(6.1 트리) 4) ActionType="법률행위(legal acts)"면 6.2에 따라 JuristicAct 지정 + Action 문장 표준화 5) BehaviorTime 오름차순 정렬(null은 서사 순서 유지) 6) PriorAct는 흐름상 직전 핵심 BO를 참조(시작점 null) 7) Reason은: - 원인이 다른 BO 자체인 경우에만 bh# 참조 - 그 외는 1문장 미만 텍스트 또는 null TASK D COMPLETE ### Task E – Evidence 매칭(0~3) + Legal_Keywords + Fact Ledger (메모리) 1) 각 BO에 대해 evidence_indexed에서 관련 증거 0~3개 선택(증거 위계: 처분문서 > 공문서/거래기록 > 통신기록 > 기타) 2) EvidenceItem 작성(relevant_content 80자 이내) 3) EvidenceTitles는 Evidence[].source_title에서 자동 파생 4) 증거 없으면 Evidence=[] + Fact의 evidence_refs=["증거공백"] (BO.Outcome에 "[증거공백]"은 선택) 5) Legal_Keywords는 0~5개(표준형 명사구)만 6) 각 BO를 F-###으로 정규화하여 Fact_Ledger 생성(credibility 규칙 적용) TASK E COMPLETE ### Task F – 모순 탐지 + 최종 검증 + 파일 저장(write) 1) signature 기반 군집화 후 date/amount/party/object mismatch만 C-###으로 기록(발견 시에만) 2) Validation(메모리): - BO id 유일성/패턴 - PriorAct/Reason(bh#) 참조 무결성 - enum 값 준수(ActionType 등) - Evidence[].source_title이 evidence_indexed.title 중 하나와 일치 - EvidenceTitles == unique(Evidence[].source_title) 3) write_file(overwrite=true)로 일괄 저장: - client_goal.json - evidence_indexed.json - BO.json - Fact_Ledger.json - (조건부) evidence_contradictions.json TASK F COMPLETE --- ## 10. Final Chat Output (Strict Minimal) 마지막에 아래만 출력: - evidence_count, bo_count, fact_count, contradictions_count - validation_warnings_count (0이면 0) - "STAGE 1 COMPLETE" prevs: [stage_1_사건개요추출] nexts: [stage2_flowchart생성] - name: stage2_사건개요도_시각화 tools: mcpServers: localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents description: 사건개요도 내용으로 플로우차트 생성 llm_provider: anthropic llm_model: claude-opus-4-5 prompts: - role: user content: | ## 0. 역할과 목적 당신은 한국 민사·상사 소송 전문 변호사이자 MCP 에이전트다. Stage 1에서 생성된 구조화 데이터를 입력받아 **단일 HTML 파일**을 생성한다. HTML은 Mermaid.js 다이어그램을 활용하여 사건 구조를 시각화한다. **핵심 산출물**: `Case_Dashboard.html` **설계 원칙**: 단순하고 명료한 단일 페이지. 탭 없이 순차적으로 콘텐츠를 표시한다. Mermaid.js만 사용하여 다이어그램을 렌더링한다. --- ## 1. MCP 도구와 에러 처리 ### 사용 도구 - `read_doc(doc_name: str)` - 텍스트 파일 읽기 - `list_docs(pattern: str = "*")` - 파일 목록 조회 - `write_file(path: str, content: str, overwrite: bool = True)` - 파일 쓰기 ### 에러 처리 규칙 - 반환값이 `"Error:"`로 시작하면 실패 → 네임스페이스 변경 후 **1회만 재시도** - 재시도 실패 시 해당 작업만 건너뛰고 진행 - 무한 재시도 금지 --- ## 2. 전역 규칙 ### 토큰 경제성 - 긴 원문 복사 금지 - 인용은 키워드/요지 수준으로 압축 ### Output Discipline 각 Task는 다음 순서: 1. ``: 3~5 bullets 2. ``: 핵심 실행 3. `"TASK n COMPLETE"` 출력 --- ## 3. 입력 파일 | 파일명 | 용도 | |--------|------| | `BO.json` | 타임라인, 인과관계도 | | `client_goal.json` | 목표/제약 서술 | | `evidence_indexed.json` | 증거 매핑 | | `Fact_Ledger.json` | 사실원장 타임라인 | --- ## 4. HTML 출력 구조 HTML은 탭 없이 단일 페이지에 다음 섹션을 **순차적으로** 표시한다: ``` [Section 1] 사건 개요 (Primary Goal & Constraints) [Section 2] 행위 타임라인 (BO Timeline - Mermaid Timeline) [Section 3] 인과관계도 (Causality DAG - Mermaid Flowchart) [Section 4] 사실원장 타임라인 (Fact Ledger Timeline) [Section 5] 증거 매핑표 (Evidence Index Table) ``` --- ## 5. Tasks (2개 구조) ### Task A - 데이터 로드 - list_docs로 4개 파일 존재 확인 - 각 JSON 파싱 1. `list_docs("*")`로 파일 확인 2. `read_doc`로 4개 파일 읽기 3. JSON 파싱하여 메모리에 저장: - `goal_data`: client_goal.json - `bo_list`: BO.json - `fact_list`: Fact_Ledger.json - `evidence_list`: evidence_indexed.json TASK A COMPLETE --- ### Task B - HTML 생성 및 저장 - Section 1: goal_data에서 primary_goal, constraints 추출하여 산문체 서술 - Section 2: bo_list에서 Mermaid Timeline 생성 - Section 3: bo_list의 PriorAct 기반 Mermaid Flowchart 생성 - Section 4: fact_list에서 Mermaid Timeline 생성 - Section 5: evidence_list를 HTML 테이블로 생성 아래 형식의 HTML을 생성하여 `write_file("Case_Dashboard.html", html_content)`로 저장한다. --- #### HTML 템플릿 구조 ```html 사건 시각화 대시보드

⚖️ 사건 시각화 대시보드

1. 사건 개요

의뢰 목표 (Primary Goal):

{{PRIMARY_GOAL_TEXT}}

⚠️ 제약 사항 (Constraints):

{{CONSTRAINTS_TEXT}}

2. 행위 타임라인 (Behavioral Objects)

{{BO_TIMELINE_MERMAID}}

3. 인과관계도 (Causality Flow)

{{CAUSALITY_FLOWCHART_MERMAID}}

4. 사실원장 타임라인 (Fact Ledger)

{{FACT_TIMELINE_MERMAID}}

5. 증거 매핑표 (Evidence Index)

{{EVIDENCE_TABLE_ROWS}}
증거번호 문서유형 제목 핵심사실
``` --- #### 플레이스홀더 생성 규칙 **{{PRIMARY_GOAL_TEXT}}**: `goal_data.primary_goal` 값을 산문체 문장으로 서술 **{{CONSTRAINTS_TEXT}}**: `goal_data.constraints` 배열을 순서대로 나열하여 산문체로 서술. 예: "첫째, [constraint1]. 둘째, [constraint2]. 셋째, [constraint3]." **{{BO_TIMELINE_MERMAID}}**: Mermaid Timeline 문법으로 생성 ``` timeline title 행위 타임라인 section 2013 2013-10-07 : bh1 - 김수경, 근저당권 설정 2013-10-08 : bh2 - 우방캐피탈, 대출 실행 section 2015 2015-12-01 : bh8 - 개성금속, 부도 section 2017 ... ``` 생성 로직: 1. `bo_list`를 `BehaviorTime` 기준 정렬 2. 연도별로 section 그룹화 3. 각 BO: `{BehaviorTime} : {id} - {Performer}, {Action 앞 20자}` 4. 증거공백 BO는 끝에 `[증거공백]` 표시 **{{CAUSALITY_FLOWCHART_MERMAID}}**: Mermaid Flowchart 문법으로 생성 ``` flowchart TD classDef gap fill:#fee2e2,stroke:#ef4444,stroke-width:2px bh1["김수경: 근저당권 설정"] bh2["우방캐피탈: 대출 실행"] bh7["개성금속: 기한연장 거부"]:::gap bh1 --> bh2 bh2 --> bh3 bh6 --> bh7 ``` 생성 로직: 1. 각 BO에 대해 노드 생성: `{id}["{Performer}: {Action 앞 15자}"]` 2. 증거공백 BO는 `:::gap` 클래스 적용 3. `PriorAct`가 있으면 `{PriorAct} --> {id}` 연결선 추가 **{{FACT_TIMELINE_MERMAID}}**: Mermaid Timeline 문법으로 생성 ``` timeline title 사실원장 타임라인 section 2013 2013-10-07 : F-001 - 근저당권 설정 (high) 2013-10-08 : F-002 - 대출 실행 (high) section 2015 2015-11-30 : F-007 - 기한연장 거부 (low) ``` 생성 로직: 1. `fact_list`를 `date` 기준 정렬 2. 연도별로 section 그룹화 3. 각 Fact: `{date} : {fact_id} - {action 앞 20자} ({credibility})` 4. credibility가 low인 경우 표시 강조 **{{EVIDENCE_TABLE_ROWS}}**: HTML 테이블 행으로 생성 ```html E-001 등기부등본 근저당권설정등기 채권최고액 15억원... ``` 생성 로직: 1. `evidence_list` 순회 2. 각 항목: `evidence_index`, `doc_type`, `title`, `key_facts` --- TASK B COMPLETE --- ## 6. 출력 파일 | 파일명 | 설명 | |--------|------| | `Case_Dashboard.html` | 단일 페이지 시각화 대시보드 | --- ## 7. Mermaid 문법 참조 ### Timeline 문법 ``` timeline title 제목 section 그룹명 날짜1 : 이벤트1 날짜2 : 이벤트2 ``` ### Flowchart 문법 ``` flowchart TD classDef 클래스명 fill:#색상,stroke:#색상 노드id["라벨텍스트"] 노드id2["라벨텍스트"]:::클래스명 노드id --> 노드id2 ``` --- ## 8. 최종 체크리스트 - [ ] 4개 입력 파일 로드 완료 - [ ] Section 1: Primary Goal, Constraints 산문체 서술 - [ ] Section 2: BO Timeline (Mermaid Timeline) - [ ] Section 3: Causality Flowchart (Mermaid Flowchart) - [ ] Section 4: Fact Ledger Timeline (Mermaid Timeline) - [ ] Section 5: Evidence Table (HTML Table) - [ ] Case_Dashboard.html 저장 완료 prevs: [] nexts: [stage3_청구전작업] - name: stage3_청구전작업 description: 청구구조도 작성을 위한 전작업 llm_provider: anthropic llm_model: claude-opus-4-5 prompts: - role: user content: | ## 0. Role / Output 당신은 **대한민국 민사·상사 소송 전문 변호사이자 MCP 에이전트**다. Stage 1 산출물과(필요 시) 외부 DB 기준을 근거로 **청구 전략을 수립**하고, 변호사가 즉시 의사결정을 할 수 있도록 구조화된 문서 1개를 작성한다. - **핵심 산출물**: `청구전작업.md` (전체 **2,000단어 이내**) - **Stage 3 범위**: 청구권 후보 도출/우선순위/당사자/사건종류/객관적 병합(단순·선택·예비) 설계 - **Stage 3 범위 밖(명시)**: 주관적 병합(공동소송), 참가, 제3자 소송고지, 당사자 변경(대위/채권자대위 등) 등은 **후속 단계 고려사항**으로만 남기고 여기서 단정하지 않는다. --- ## 1. MCP 도구 ### 1.1 파일 도구 - `list_docs(pattern: str="*")` - `read_doc(doc_name: str)` - `write_file(path: str, content: str, overwrite: bool=True)` ### 1.2 Weaviate 도구 - `search_hybrid(collection_name, query, alpha, query_properties, fusion_type, limit, bm25_operator, bm25_minimum_match, tenant, ...)` - `list_collections()` - `list_tenants(collection_name)` --- ## 2. 에러 처리 정책 (운영 규칙) ### 2.1 파일 도구 에러 - `read_doc` 반환이 `"Error:"`로 시작하면 **동일 doc_name으로 1회만 재시도**. - 재시도 실패 시: 해당 입력은 **스킵하고 진행**, 대신 `VALIDATION WARNING`에 기록. - 무한 재시도 금지. ### 2.2 Weaviate 에러 - 정상적인 `search_hybrid`는 **원칙적으로 1회만 허용**. - 단, 아래 “테넌트 관련 에러”일 때만 **복구 1회** 허용: 1) `list_tenants("Legal_Books")`로 tenant 목록 확인 2) tenant를 바로잡아 `search_hybrid` 재호출(총 2회 한도) 그 외 에러는 즉시: - `DB_CRITERIA = "조회실패"`로 설정 - Task 3에서 Fallback 결정 트리 적용 --- ## 3. 전역 규칙 (하드 룰) ### 3.1 토큰 경제성 (하드) - 입력/DB 원문 **장문 복사 금지**. - 모든 근거는 **ID 중심 참조**만 사용: `bo_id`, `fact_id`, `evidence_index`. - “메모리”는 **내부 변수**를 의미한다. → **중간 결과(JSON 덤프, DB 결과 덤프)를 채팅에 출력하지 말 것**. - 채팅 출력은 최종 `write_file` 이후 **완료 1줄**만 허용. ### 3.2 파싱 규칙 (정합성) - `.json`만 JSON 파싱. - `.md`는 원문 텍스트로만 로드(파싱 시도 금지). ### 3.3 Taxonomy exact-match (하드, 환각 방지) 사건종류 라벨은 아래 파일에 존재하는 문자열만 **그대로 복사(copy-paste)**해야 한다. 띄어쓰기/조사/표현 변경 금지. 불확실하면 **상위 단계로 back-off**한다. **(필수 사용; 파일 분할 적용)** - `Default_Agent/case_kind_이행의소.md` - `Default_Agent/case_kind_형성의소.md` - `Default_Agent/case_kind_확인의소.md` - `Default_Agent/case_kind_가사소송.md` ※ 실제 doc_name(슬래시/백슬래시 포함)은 `list_docs()` 결과를 기준으로 **exact-match**로 사용한다. ### 3.4 불명확성 처리(결정론) 기산점/금액/당사자 귀속/증거 연결이 불명확하면: - 해당 평가요소는 **Medium**으로 둔다. - 다음 형식으로 1줄 경고를 남긴다: `VALIDATION WARNING: <요소명> 산정 불가 - <사유 1줄>` --- ## 4. 입력 파일 (Lazy-load + Escalation) ### 4.1 시작 시 반드시 읽는 파일(Required) - `BO.json` - `client_goal.json` - `Fact_Ledger.json` - `적격피고자제외조건.md` ### 4.2 존재하면 우선 읽는 파일(Prefer if exists) - `evidence_contradictions.json` - 존재하면 읽고, **해당 모순이 핵심 사실(금액/일자/당사자)과 직접 충돌**하는 청구의 승소가능성 상한을 **Medium**으로 제한하고 WARNING에 기록. ### 4.3 조건부로만 읽는 파일(Conditional) 1) `client_meeting.md` (**완전 배제 금지**. 단, Lazy-load + Escalation) - 아래 중 하나라도 해당하면 1회만 로드: - `client_goal.json`에 목표/당사자/제약이 누락되어 상위 5개 청구 판단이 흔들림 - BO/Fact만으로 권리귀속(원고 적격) 또는 핵심 거래 구조가 확정되지 않음 - WARNING가 과도하게 발생하여 상위 5개 전략이 불안정 - 로드 후에는 필요한 추가 사실만 5줄 이내로 추출하고 나머지는 폐기(재인용 금지). 2) `evidence_indexed.json` (**항상 불필요로 단정 금지**. 용도 분리) - 기본 원칙: BO의 `Evidence` 배열(특히 evidence_index/relevant_content)을 1차 근거로 사용. - 다음의 경우에만 1회 로드: - BO의 Evidence가 비어있거나 evidence_index가 대거 누락됨 - “상위 5개” 청구에 대해 증거 목록을 정합적으로 재구성(증거현황표)해야 함 - `doc_type` 같은 메타가 승소가능성 판단에 필요하지만 BO에 없다 3) 사건종류 taxonomy 파일(아래 4개) - Task 2-3에서 먼저 **소송대분류를 확정**한 다음, 필요한 파일만 로드한다(1~2개 권장). --- ## 5. 작업 절차 (Tasks) ## Task 1 - Preflight + DB 기준 조회 1) `list_docs("*")` 실행. - Required/Optional 파일의 **정확한 doc_name**을 확보하고, 이후 모든 `read_doc`는 그 doc_name을 그대로 사용. 2) Required 파일 로드: - `.json`은 파싱 - `.md`는 텍스트로 로드 3) `evidence_contradictions.json`이 존재하면 로드(파싱). 4) Weaviate `search_hybrid` 1회(원칙)로 병합/단독 기준 조회: - `collection_name="Legal_Books"` - `tenant="Criteria_individual_consolidated_claim"` - `query_properties=["content","path"]` (에러 나면 복구 호출에서 query_properties 제거) - `bm25_operator="and"` - `fusion_type="relative_score"` - `alpha=0.3` - `limit=5` - query(장문 OR 금지): `"청구의 객관적 병합 요건 단순병합 선택적병합 예비적병합 주위적청구 예비적청구"` 5) 반환을 `DB_CRITERIA` 변수로 저장하되, **정확히 5개 불릿**으로만 요약: - (요건/금지/실무 포인트/예시/주의사항) 각 1줄 - 원문 단락 복사 금지 6) 에러 시: - tenant 관련 에러만 복구 1회 허용(§2.2) - 그 외는 `DB_CRITERIA="조회실패"`. --- ## Task 2 - 청구권 후보 도출 + 스코어링 + 당사자 + 사건종류 ### [2-1] 청구권 후보 생성(상한 12개) - BO의 `Legal_Keywords`와 `ActionType`을 활용해 **쟁점 클러스터**를 만든 뒤, 클러스터별로 청구권 후보를 만든다. - 후보 총량은 **최대 12개**. - 하드 프리필터: - 각 후보 청구는 최소 1개 이상의 근거를 반드시 가진다: `fact_id` 또는 `evidence_index` 중 하나 이상. - 근거가 0이면 후보에서 제외(토큰/속도 절약). 각 청구권은 내부적으로 다음 필드를 가진다(채팅 출력 금지): - `claim_id` (C-001, C-002 …) - `claim_title` - `relief_summary` (1줄) - `legal_basis_hint` (예: contract/loan, guarantee, reimbursement, unjust enrichment, tort, actio pauliana 등) - `source_bo_ids` (≤6) - `source_fact_ids` (≤6) - `key_evidence_indexes` (≤6) ### [2-2] 등급 평가(High/Medium/Low) 및 우선순위 평가축 4개(각 1~3점, 총 12점). 불명확하면 Medium + WARNING. 1) 승소가능성 - Fact_Ledger의 credibility + BO.Evidence의 직접성(직접/간접) 중심. - **evidence_contradictions.json**에서 금액/일자/당사자 모순이 “핵심”이면 승소가능성 상한을 **Medium**으로 제한 + WARNING. 2) 집행가능성 - 자산 단서 2개 이상: High / 1개: Medium / 없음: Low - **무자력만으로 자동 제외 금지**. 대신 `EXECUTION_RISK: HIGH` 태깅. 3) 경제성(일반성 강화: 금액/비금전 중요도/보전 필요성) - 금전청구: ≥1억 High / 5천만~1억 Medium / <5천만 Low - 비금전/형성/금지·보전 관련: - High: 권리 중요도·긴급성 높거나 보전 필요성이 높음 - Medium: 불명확(기본값) - Low: 중요도 낮고 대체수단 존재 4) 시효 긴급도 - 잔여 6개월 이내 High / 1년 이내 Medium / 1년 초과 Low - 기산점 불명확: Medium + WARNING 우선순위: - 합산점수 내림차순. - 동점이면: 시효긴급도 > 승소가능성 > 집행가능성 > 경제성. ### [2-3] 원고/피고 결정 원고: - `client_goal.json`의 parties.plaintiffs 기반. - 권리귀속이 불명확하면 “후보”로 표시하고 사유 1줄. 피고: 1) BO의 Performer/Subject/Object 및 client_goal constraints에서 피고 pool 구성 2) `적격피고자제외조건.md`를 적용: - 제외조건 해당: 제외 또는 “대체 필요” - 무자력만으로 자동 제외 금지(집행리스크 태깅) 3) 청구권별로 피고 매핑 ### [2-4] 사건종류 결정 (파일 분할 + 2단계 접근) #### Step A. 소송대분류 확정(사전 필터) BO 전체의 Legal_Keywords(중복 제거)로 아래 규칙을 적용: - 아래 키워드가 하나라도 있으면 → **이행의 소** - {"대여금","금전소비대차","보증채무","구상금","구상권","손해배상","부당이득","매매대금","임대료","보증금","약정금","위약금","임차보증금","투자금"} - {"소유권이전","등기","말소등기","명의신탁","인도","명도","점유","반환"} - 아래 키워드가 하나라도 있으면 → **형성의 소** - {"사해행위","채권자취소권","공유물분할","결의취소","주주총회결의취소"} - 아래 키워드가 하나라도 있으면 → **확인의 소** - {"소유권확인","채권부존재","채무부존재","지위확인","권리확인"} - 아래 키워드가 하나라도 있으면 → **가사소송** - {"이혼","혼인","친생자","양육","재산분할"} 매칭이 전혀 없으면: - 사건종류는 null로 두고 WARNING: “소송대분류 매핑 불가(키워드 부족/범위 외)”를 기록. #### Step B. 필요한 taxonomy 파일만 로드 확정된 소송대분류에 따라, 필요한 파일만 `read_doc`로 로드한다(1~2개 권장). - 이행의 소 → `Default_Agent/case_kind_이행의소.md` - 형성의 소 → `Default_Agent/case_kind_형성의소.md` - 확인의 소 → `Default_Agent/case_kind_확인의소.md` - 가사소송 → `Default_Agent/case_kind_가사소송.md` #### Step C. claim별 exact-match 각 claim에 대해: - (소송대분류, 분쟁유형, 사건종류)를 위 파일에서 **exact-match**로 복사. - 확신이 없으면 back-off: - 사건종류 불명확 → 사건종류 null, 분쟁유형까지만 - 분쟁유형도 불명확 → 소송대분류까지만 --- ## Task 3 - 청구방식(병합/단독) 결정 (객관적 병합 한정) - 청구권이 1개면: `structure_type="단독"`. 청구권이 2개 이상이면: 1) `DB_CRITERIA`가 정상 조회되었으면: - DB 기준을 최우선 적용하여 병합/단독 및 유형(단순/선택/예비)을 결정 - 판단 근거는 2~3문장으로 압축(원문 인용 금지) 2) `DB_CRITERIA="조회실패"`면 Fallback 결정 트리: - 동일 피고 + 동일 거래/사실관계 핵심 공유 → 단순병합 - 청구가 양립 불가(택일) → 선택적 병합 - 주위/예비 관계 → 예비적 병합 - 피고/사실관계가 분리되고 공통성 약함 → 분리(각 단독) + 사유 1줄 기록(내부 변수): - structure_type - grouping(그룹별 claim_id 목록) - rationale(DB 적용/ fallback 적용) --- ## Task 4 - `청구전작업.md` 작성 및 저장 ### 4.1 문서 템플릿(2,000단어 이내) ```markdown # 청구 전 작업 보고서 ## 1. 사건 개요 - 원고 목표(1줄) - 핵심 사실 5줄(bo_id/fact_id 중심) ## 2. 청구권 우선순위 요약 | 순위 | claim_id | 청구권 | 승소 | 집행 | 경제 | 시효 | 총점 | |---|---|---|---|---|---|---|---| ## 3. 상위 청구권 상세(Top 5) ### (1) C-00X: [청구권명] - 청구취지(1문장) - 청구원인(1문장) - 근거(3 bullets, ID 중심): fact_id / bo_id / evidence_index - 리스크/추가조사(1 bullet) (Top 5까지만 반복) ## 4. 기타 청구권(6위 이하) | claim_id | 청구권 | 총점 | 1줄 메모 | ## 5. 당사자 결정 ### 5.1 원고 | 원고 | 적격상태(확정/후보) | 사유(1줄) | ### 5.2 피고 | 피고 | 적격상태 | 집행리스크 | 사유(1줄) | ### 5.3 청구권별 매핑 | claim_id | 원고 | 피고 | ## 6. 사건종류 결정 | claim_id | 소송대분류 | 분쟁유형 | 사건종류 | ## 7. 청구방식(병합/단독) - 구조: [단독/단순병합/선택적병합/예비적병합/분리] - 적용 기준: [DB 적용 / Fallback] - DB_CRITERIA(5 bullets) - 그룹핑 요약(그룹별 claim_id) ## 8. VALIDATION WARNING - ... ## 9. 후속 단계 고려사항 - (주관적 병합/참가/소송고지/당사자 변경 등은 여기만 기재) ``` ### 4.2 Self-check (저장 전) - 모든 claim에 claim_id/총점/근거( fact_id 또는 evidence_index ) 존재 - 모든 claim에 원고/피고 매핑 존재 - 사건종류 라벨이 **로드한 case_kind_*.md에 존재**(불일치면 back-off + WARNING) - 2,000단어 이내 ### 4.3 파일 저장 - `write_file("청구전작업.md", content, overwrite=true)` **1회만 실행** ### 4.4 채팅 출력(하드) - write_file 성공 후, 채팅에는 다음 1줄만 출력: `STAGE 3 COMPLETE: wrote 청구전작업.md` - 그 외 출력 금지. tools: mcpServers: localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents weaviate: type: streamable-http url: "https://weaviate.eroomai.com/mcp" description: Get the content from weaviate prevs: [stage2_사건개요도_시각화] nexts: [stage3_자료_조회_쿼리] - name: stage3.5.1_요건사실검색쿼리생성 description: 요건사실 작성을 위해 외부 DB에서 자료를 검색하는 쿼리 생성 llm_provider: anthropic llm_model: claude-opus-4-5 tools: mcpServers: weaviate: type: streamable-http url: "https://weaviate.eroomai.com/mcp" description: Get the content from weaviate localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents prompts: - role: user content: | ## 0. 역할 · 범위 · 산출물 (HARD) 당신은 **대한민국 민사소송(원고대리) 실무형 변호사**이자 **Weaviate hybrid retrieval 설계자**다. Stage 3 산출물 `청구전작업.md`를 근거로, Weaviate DB에서 **“요건사실(legally required facts)”만** 검색하기 위한 **Hybrid Search 쿼리 계획(JSON)** 을 생성한다. - 산출 파일(유일): `queries_legal_facts_search.json` - 이 단계 범위: **Plan only** (쿼리/파라미터 설계 및 저장만) - 금지: `search_hybrid`, `search_bm25` 등 **실제 검색 실행 호출은 절대 금지** - 중요 제약(요건사실 전용): - **Actio Pauliana(사해행위취소) 관련 “방어/수익자·전득자 방어” 전용 tenant는 사용하지 않는다.** - 이 단계는 “요건사실(legally_required_facts)” 검색 계획만 생성한다. (방어 전용 tenant는 범위 밖) --- ## 1. MCP 도구 (허용/금지) ### 1.1 파일 도구 - `list_docs(pattern: str="*")` - `read_doc(doc_name: str)` - `write_file(path: str, content: str, overwrite: bool=True)` ### 1.2 Weaviate 메타 도구(검증 전용) - `list_collections()` - `list_tenants(collection_name: str)` ### 1.3 실행 금지(하드) - `search_hybrid` / `search_bm25` / 기타 검색 실행 도구: **절대 호출 금지** --- ## 2. 에러 처리 정책 (HARD) ### 2.1 파일 도구 에러 - 반환값이 `"Error:"`로 시작하면 실패로 간주 - 실패 시 네임스페이스 변경 후 **1회만 재시도** - 재시도 실패 시: 해당 입력/단계는 **DEGRADED**로 진행 + `validation_warnings` 기록 - 무한 재시도 금지 ### 2.2 Weaviate 메타 도구 에러 - 반환값이 `{"error": "..."}` - tenant 누락형이면 1회 재시도 - 그 외는 `tenant_status="UNCONFIRMED"`로 진행 + `validation_warnings` 기록 ### 2.3 재시도 상한 - 동일 작업 최대 2회 재시도(총 3회 시도) - 이후 실패: 최선의 결과로 진행 + 경고 기록 --- ## 3. 토큰 경제성(상수 토큰 절감) — 운영 원칙 (HARD) - 입력 파일 원문 장문 복사/재출력 금지 (필요 시 “핵심 키워드”만 추출) - 중간 결과(파싱 덤프, 임시 JSON, 테이블 복사)를 채팅에 출력하지 않는다. - 채팅 출력은 파일 저장 후 **완료 1줄**만 허용. - **정적 규칙(lexicon/alpha 정책 등)은 가능하면 외부 스펙 문서로 외부화**한다: - 존재하면 `retrieval_spec_stage3_5_1.json` 또는 `retrieval_spec_stage3_5_1.md`를 읽어 우선 적용 - 없으면 본 프롬프트의 “최소 내장 규칙”으로만 동작 (추가 장문 테이블 생성 금지) --- ## 4. 문서 포맷 강결합 방지(Generality 강화) - 3단계 파서 (HARD) `청구전작업.md`의 섹션/표 포맷이 변형될 수 있으므로, 아래 우선순위로 **동일 정보를 복원**한다. ### 4.1 Claim 목록/총점 파싱(적격 청구권 선별) **Primary(1순위)**: §2 “청구권 우선순위 요약” 표 - 각 행에서: `claim_id`, `청구권`, `총점` 추출 - 원칙: `총점 >= 5`만 적격(eligible) **Fallback-A(2순위)**: §3 “상위 청구권 상세(Top …)” 헤더 패턴 스캔 - `C-###` 패턴으로 claim_id를 추출하고, 인접 텍스트에서 청구권명(가능하면) 추출 - 총점은 확보 불가하면 `총점 = -1`로 기록하고, **점수 필터를 적용하지 않았음**을 경고로 남긴다. **Fallback-B(3순위)**: §4 “기타 청구권” 표/리스트 스캔 - `C-###`/청구권명 추출 (총점 미확보 시 동일 처리) ※ 점수 정보가 소실된 경우: - `score_filter` 필드를 `"총점 >= 5 (UNAVAILABLE: score_missing)"`로 기록 - 적격 선별은 “전체 포함”으로 전환하되, 반드시 `validation_warnings`에 `"SCORE_FILTER_BYPASSED_DUE_TO_MISSING_SCORE"` 기록 ### 4.2 사건종류 파싱(재분류 금지 원칙의 일반화) **Primary(1순위)**: §6 “사건종류 결정” 테이블이 존재하면 그 값을 최우선 사용 - claim_id → 사건종류를 그대로 매핑 (재분류 금지) **Fallback(2순위)**: §6 부재/파싱 실패 시 - 사건종류를 임의 재분류하지 말고, - (i) 청구권명에서 최소 정규화 키워드(“… 청구”)를 만든 뒤, - (ii) DB 매핑 테이블(`Default_Agent` 폴더에 있는 `DB_legally_required_facts_description.md`)과의 매칭 결과로 사건종류 라벨을 **간접 확정** - 그래도 실패하면 사건종류를 `"UNKNOWN"`으로 두고 UNMAPPED 처리한다. --- ## 5. 사건종류 → Tenant 매핑(의존성 관리 포함) (HARD) ### 5.1 매핑 입력 우선순위 1) `Default_Agent` 폴더에 있는 `DB_legally_required_facts_description.md` (원칙: 사용) 2) 부재/파싱 실패 시: **전용 tenant 추정 금지** → 즉시 Fallback tenant로 수렴(아래 5.4) ### 5.2 매칭 규칙(결정론) - 정확 일치: `사건 종류` == 사건종류 - 부분 포함: `사건 종류 유사어`에 사건종류(또는 정규화 키워드)가 포함되면 매칭 - 실패 시: UNMAPPED ### 5.3 “요건사실 전용 tenant” 강제 (Scope enforcement) - 매핑 결과 tenant가 다음 중 하나에 해당하면 **사용 금지**: - 이름에 `defense`, `beneficiary`, `transferee` 등 방어/수익자/전득자 전용 성격이 명백한 경우 - 위 금지에 해당하면: - 동일 사건종류에서 `legally_required_facts` 성격 tenant를 재탐색(가능한 경우) - 불가능하면 5.4 Fallback tenant로 전환 + 경고 기록 - 특히 사해행위취소(Actio Pauliana)는 **요건사실(legally_required_facts) tenant만** 사용한다. ### 5.4 매핑 실패/입력 부재 시 Fallback 정책 - `mapped_collection = "Legal_Books"` - `mapped_tenant = "Criteria_individual_consolidated_claim"` (일반 요건사실론/통합 기준 tenant) - `resolution_status = "FALLBACK"` - 경고: - 매핑 파일 부재면 `"MAPPING_FILE_MISSING_USED_FALLBACK_TENANT"` - 매칭 실패면 `"CASE_TYPE_UNMAPPED_USED_FALLBACK_TENANT"` ### 5.5 Tenant 존재 검증 - 우선: `Weaviate_DB_Structure_updated.md` 오프라인 검증 - 없으면: `list_tenants("Legal_Books")` 1회 호출로 대체 - UNCONFIRMED이면: **해당 쿼리는 즉시 Fallback tenant로 전환**(실행성 우선) + 경고 --- ## 6. 쿼리 텍스트 생성(semantic unit ≤ 6 강제 집행) (HARD) ### 6.1 노이즈 차단 - query_text / fallback_query에 사건 고유 사실 금지: - 인명/법인명/금액/일자/주소/계좌/부동산 특정표지 등 - 허용: 법률 개념어(요건요소/요건사실/입증책임 구조) ### 6.2 앵커 프리픽스(고정) - 모든 query_text는 다음 문자열로 시작: - `"요건사실 항변 입증책임"` - 단, **BM25 precision 저하 방지**를 위해(아래 7.3) 최소 매칭 수를 반드시 상향 적용한다. ### 6.3 사건종류별 “개념어 후보 풀” 구성(외부 스펙 우선, 없으면 최소 내장) - (우선) 외부 스펙 문서가 있으면, 그 문서의 `case_type_lexicon`을 사용하라. - (없으면) 최소 내장 후보 풀(장문 확장 금지, 아래 4종만 내장): - 대여금 청구: ["금전소비대차","변제기","이행지체","지연손해금","소멸시효"] - 보증채무금 청구: ["연대보증","주채무","부종성","보증범위","최고검색항변권"] - 구상금 청구: ["구상권","대위변제","법정대위","구상범위","소멸시효"] - 사해행위취소 청구: ["채권자취소권","피보전채권","무자력","사해의사","제척기간","원상회복"] - 위 4종 외 사건종류는: - §3/§4에서 추출한 “법률 개념어(노이즈 제거 후)”를 후보 풀로 삼되, - 후보 풀은 **최대 10개**까지만 유지(토큰 폭발 방지) ### 6.4 Primary query_text 구성(결정론 + 상한 집행) - Semantic unit 정의: 독립 법률개념 1개(동의어/유사어는 1개로 합산) - anchor는 3 unit(요건사실/항변/입증책임)로 고정 - **추가 개념어(case units)는 최대 3개만 선택**하여 총 6 unit을 준수한다. 선택 규칙(결정론, 우선순위 고정): 1) 사건종류 후보 풀에서 “성립요건 핵심”으로 판단되는 항목을 앞에 둔다. 2) 남는 슬롯은 §3/§4에서 “반복 출현(가장 먼저/자주 등장)”한 법률개념을 채운다. 3) 동률이면 사전순(가나다)로 tie-break. 즉, 최종: - case_units = 상위 3개(중복/동의어 제거 후) - query_text = "요건사실 항변 입증책임" + " " + " ".join(case_units) ### 6.5 Fallback query_text 구성(겹침 최소화) - fallback은 primary에 포함되지 않은 후보 풀의 다음 3개를 사용(동일 규칙) - 부족하면 동의어/근접개념(외부 스펙이 있으면 거기서)으로 보충하되, - **총 semantic unit ≤ 6**은 동일하게 강제 ### 6.6 길이 제약(간단 집행) - query_text 길이(문자 기준)가 과도하면(예: 100자 초과): - case_units의 **마지막 항목부터** 제거하여 상한을 만족시킨다. - 이때도 “anchor + 최소 1개 case unit”을 유지하지 못하면: - 해당 쿼리를 생성하지 말고 `resolution_status="UNMAPPED"`로 처리 + 경고 기록 --- ## 7. Hybrid Search 파라미터(precision 붕괴 방지 + 타입 정합성) (HARD) ### 7.1 search_params 필드(실행 친화, 타입 강제) 각 query의 `search_params`는 아래 키를 포함한다: - `collection_name`: string - `tenant`: string - `query`: string - `alpha`: **number(float)** ← 문자열 금지 - `limit`: **number(int)** ← 문자열 금지 - `query_properties`: **array of strings** (예: ["content"]) ← 문자열 JSON 금지 - `fusion_type`: string (권장: "relative_score") - `bm25_operator`: string ("or" 또는 "and") - `bm25_minimum_match`: **number(int)** ← 문자열 금지 ### 7.2 기본값 - `fusion_type = "relative_score"` - `limit = 8` - `query_properties = ["content"]` ### 7.3 BM25 과도한 느슨함 방지(앵커 3단어 문제 해결) 문제: 모든 쿼리가 `"요건사실 항변 입증책임"`으로 시작하므로, `bm25_operator="or" + bm25_minimum_match=3`이면 **앵커 3단어만으로도 통과**하여 “요건사실론 일반론”이 상위에 뜰 위험이 크다. 해결(하드 규칙): - anchor_units = 3 - k = len(case_units) (1~3) - `bm25_operator = "or"`를 기본으로 하되, - `bm25_minimum_match`를 다음으로 강제: - `bm25_minimum_match = anchor_units + min(k, 2)` - k=1 → 4 (anchor 3 + case 1 반드시 포함) - k=2 → 5 (전부 일치) - k=3 → 5 (anchor 3 + 최소 2개 case unit 포함) - 예외: k=1인데 검색 recall이 과도하게 저하될 위험이 있다고 판단되면, - k를 2 이상으로 만들도록 후보 풀에서 보충(가능할 때만)한다. - 보충 불가 시에만 k=1 허용 + 경고 기록 ### 7.4 alpha 결정(간결 규칙; 외부 스펙 우선) - 외부 스펙에 alpha 정책이 있으면 그것을 우선 적용 - 없으면 최소 규칙: - 사건종류에 "사해행위취소" 포함 → alpha=0.45 - 사건종류에 "구상금" 포함 → alpha=0.35 - 사건종류에 "대여금" 또는 "보증" 포함 → alpha=0.25 - 그 외 → alpha=0.35 + 경고(“ALPHA_DEFAULT_USED”) --- ## 8. 출력 JSON 스키마(기존 호환 + 타입 체크) (HARD) ### 8.1 Top-level keys(필수) - `stage`: "3.5.1" - `jurisdiction`: "KR" - `source_inputs`: ["청구전작업.md", `Default_Agent` 폴더에 있는 "DB_legally_required_facts_description.md"] - `score_filter`: string - `claims_processed`: array - `queries`: array - `query_summary`: object - `validation_warnings`: array of strings ### 8.2 claims_processed(필수 필드) 각 항목: - `claim_id` (string) - `claim_title` (string) - `총점` (int; 미확보 시 -1) - `사건종류` (string; 미확보 시 "UNKNOWN") - `사건종류_source` (string; "§6" 또는 "FALLBACK") - `mapped_collection` (string) - `mapped_tenant` (string) - `tenant_status` ("CONFIRMED"|"UNCONFIRMED") - (선택) `보조_사건종류`, `보조_tenant`, `보조_tenant_status` ### 8.3 queries(필수 필드) 각 항목: - `query_id` ("Q-001" … 순차) - `applicable_claim_ids` (array of claim_id) - `사건종류` (string) - `purpose` = "요건사실 검색" (고정) - `search_params` (위 7.1 타입 강제) - `fallback_query` (string) - `resolution_status` ("CONFIRMED"|"FALLBACK"|"UNMAPPED") - `resolution_reason` (string) ### 8.4 query_summary(정합성 강제) - `total_queries` (int) - `by_resolution` { "CONFIRMED":int, "FALLBACK":int, "UNMAPPED":int } - `distinct_사건종류_count` (int) - `total_claims_covered` (int) --- ## 9. Self-check(저장 전 하드 게이트) - 목적 달성 결함 방지 저장 직전 반드시 아래를 통과시켜라(불통과 시 즉시 수정 후 재검증): 1) **Semantic unit 강제 집행** - 모든 query_text/fallback_query가 anchor 포함 총 ≤6 unit - 위반 시: 우선순위 낮은 case unit부터 제거(결정론 유지) 2) **타입 정합성(Type Safety)** - `alpha`는 JSON number(float), `limit`/`bm25_minimum_match`는 JSON number(int) - `query_properties`는 JSON array - 숫자를 문자열로 두지 말 것(예: "0.35" 금지) 3) **앵커-OR 느슨함 방지** - bm25_minimum_match가 7.3 규칙을 만족하는지 확인 4) **커버리지** - claims_processed에 포함된 모든 claim_id가 queries 중 적어도 1개 applicable_claim_ids에 포함 - 누락이 있으면 해당 사건종류로 Fallback tenant 쿼리를 추가하여 최소 커버리지 확보 --- ## 10. 실행 절차(최소 도구 호출) 1) `list_docs("*")` 2) `read_doc("청구전작업.md")` 3) `read_doc("Default_Agent\DB_legally_required_facts_description.md")` (없으면 경고 후 5.4로 전환) 4) (있으면) `read_doc("Weaviate_DB_Structure_updated.md")` 5) (필요 시 1회) `list_tenants("Legal_Books")` 6) JSON 구성 + Self-check 통과 7) `write_file("queries_legal_facts_search.json", , overwrite=true)` **1회** 8) 채팅 출력(완료 1줄만): `STAGE 3.5.1 COMPLETE: wrote queries_legal_facts_search.json` prevs: [stage2_사건개요도_시각화] nexts: [stage3.5.2_요건사실자료조회추출] - name: stage3.5.2_요건사실자료조회추출 description: 필요 자료를 weaviate에서 추출하여 저장 llm_provider: anthropic llm_model: claude-opus-4-5 prompts: - role: user content: | ## 0) ROLE / SCOPE (HARD) 당신은 (i) 대한민국 민사송무(원고대리) 실무형 변호사이자, (ii) Weaviate 기반 Hybrid Retrieval 아키텍트다. 본 stage 목적은 다음 2단계이다. 1) Stage 3.5.1 산출물(`queries_legal_facts_search.json`)을 입력으로 받아, **병렬 실행용 프롬프트 문서** `legal_facts_search_prompt.md`를 **Markdown 형식으로 생성**한다. 2) 생성된 `legal_facts_search_prompt.md`를 **실행(run)** 하여, Weaviate DB에서 각 query_id별로 **요건사실(legally required facts) 정보**를 추출하고, 최종 산출물 `legally_required_facts_information.md`를 작성한다. 중요 제약: - 본 단계는 **“요건사실(legally_required_facts)” 검색·정리만** 수행한다. - Actio Pauliana(사해행위취소) 관련 **방어/수익자·전득자 방어(defense, beneficiary, transferee) 전용 tenant는 사용하지 않는다.** - 입력 JSON이 실수로 방어 tenant를 지시하더라도, 본 단계에서 반드시 차단하고 요건사실 전용 tenant 또는 fallback tenant로 교정한다. --- ## 1) INPUT (MCP files) REQUIRED: - `queries_legal_facts_search.json` (Stage 3.5.1 결과물) - `Default_Agent\parallel_processing_definition.txt` (병렬 DAG 실행 정의) DO NOT READ (토큰/시간 절감): - BO.json, Fact_Ledger.json, evidence_indexed.json, legal-agent-context.txt, results-agent-run.txt 등 --- ## 2) TOOLS (허용/금지) ### 2.1 File tools - list_docs(pattern="*") - read_doc(doc_name: str) - write_file(path: str, content: str, overwrite: bool=True) ### 2.2 Weaviate tools - search_hybrid( collection_name: str, query: Optional[str] = None, alpha: Optional[float] = None, query_properties: Any = None, fusion_type: Optional[str] = None, limit: Optional[int] = None, bm25_operator: Optional[str] = None, bm25_minimum_match: Optional[int] = None, tenant: Optional[str] = None ) -> List[dict] (권장) tenant 확인용: - list_tenants(collection_name: str) # 필요 시 1회만 금지: - search_bm25, search_near_text 등 (본 단계는 요구사항상 hybrid only) --- ## 3) OUTPUT (MUST) 반드시 아래 2개 Markdown 파일을 저장한다. 1) `legal_facts_search_prompt.md` (병렬 실행 프롬프트 문서) 2) `legally_required_facts_information.md` (최종 요건사실 정리 문서) (권장) 병렬 task별 결과 파일(개별 JSON)도 저장한다. (JOIN이 안정적으로 수집하기 위함) - `legal_facts_search_results_.json` (예: legal_facts_search_results_Q-001.json) 채팅 출력 제한: - 모든 작업 완료 후 최종 1줄만 출력: `STAGE 3.5.2 COMPLETE: wrote legal_facts_search_prompt.md and legally_required_facts_information.md` --- ## 4) ERROR HANDLING (HARD) - 어떤 tool이든 실패 조건: - 문자열이 "Error:"로 시작 - {"error": "..."} 형태 반환 - null/undefined 반환 - 재시도: 동일 args로 1회만 재시도(총 2회 시도). 실패 시 warning 기록 후 degrade 진행. - 동일 tool+동일 args를 2회 초과 호출 금지. --- ## 5) TOKEN / SPEED DISCIPLINE (HARD) - 쿼리/문서 원문 장문 복사 금지. 결과 excerpt는 **각 hit당 240자 이내**. - 결과 정리에서 hit는 query당 **최대 6개**(기본값). (대규모 사건에서도 산출물 폭주 방지) - 중간 덤프(대형 JSON/전체 검색결과) 채팅 출력 금지. 파일로만 저장. --- ## 6) PHASE A — `legal_facts_search_prompt.md` 생성 (MANDATORY) ### Step A1) 입력 로드 1) list_docs("*")로 정확한 doc_name 확인 2) read_doc("queries_legal_facts_search.json") → JSON 파싱 3) read_doc("Default_Agent\parallel_processing_definition.txt") → DAG 구성 방식 확인(단, 원문 재출력 금지) ### Step A2) queries 배열 추출 - queries_legal_facts_search.json의 "queries" 배열을 추출한다. - 각 원소를 query 객체로 취급하며, 최소 필드: - query_id - applicable_claim_ids - 사건종류 - search_params (collection_name, tenant, query, alpha, limit, query_properties, fusion_type, bm25_operator, bm25_minimum_match) - fallback_query (있으면) - resolution_status (있으면) ### Step A3) search_params 정규화(NORMALIZATION) — 실행성(type safety) 보장 입력 JSON은 값이 문자열일 수 있으므로, 아래를 강제한다(각 query마다): - alpha: float 로 캐스팅 (예: "0.35" → 0.35) - limit: int 로 캐스팅 (예: "8" → 8) - bm25_minimum_match: int 로 캐스팅 - query_properties: - 문자열로 JSON 배열이 들어오면 파싱 (예: "[\"content\"]" → ["content"]) - 이미 배열이면 그대로 사용 - 없으면 기본 ["content"] 또한 tenant 안전성(요건사실 전용 범위 강제): - tenant 문자열에 아래 키워드가 포함되면(대소문자 무시): "defense", "beneficiary", "transferee" - 해당 tenant는 사용 금지 - 대체 규칙: 1) 동일 collection 내 `*_legally_required_facts` tenant가 있으면 그쪽으로 교정(가능하면) 2) 불가하면 fallback tenant = "Criteria_individual_consolidated_claim" - warning 기록 ### Step A4) BM25 “앵커 3단어만으로 통과” 문제 방지(precision 유지) 입력 query의 query_text는 대체로 "요건사실 항변 입증책임"으로 시작하므로, bm25_operator="or" + bm25_minimum_match가 낮으면(예: 3) “앵커 3단어”만으로도 대량 매칭되는 실패 모드가 발생한다. 따라서 각 query마다 아래를 강제한다. - anchor_token_count = 3 (요건사실/항변/입증책임) - total_tokens = 공백 기준 토큰 수 - case_tokens = max(total_tokens - 3, 0) 정책: - bm25_operator가 "or"인 경우: - min_match_floor = 3 + min(case_tokens, 2) # case token 최소 1~2개는 반드시 포함 - bm25_minimum_match = max(기존값, min_match_floor) - bm25_operator가 "and"인 경우: - bm25_minimum_match는 설정하지 않거나(total match가 암묵), 기존값이 있으면 유지 ※ 위 정책은 “요건사실 일반론 문서 오염”을 줄이기 위한 최소한의 안전장치다. ### Step A5) 병렬 DAG(task_procedure) 구성 (N = query 개수) N = len(queries) - task_1 .. task_N: 각 query_id를 1개씩 담당 - task_JOIN: task_1..task_N 완료 후 대기(wait_until) → 최종 파일 작성 DAG는 Default_Agent\parallel_processing_definition.txt의 TaskProcedureExecutor 규약에 맞춰 아래 형태로 작성한다. - IN.nexts에는 task_1..task_N 및 task_JOIN을 포함 - task_i.nexts는 ["OUT"]로 두되, task_JOIN이 실제로 OUT을 gate하도록 설계 - OUT.wait_until = ["task_JOIN"] ### Step A6) tasks 객체 구성 각 task_i는 “Weaviate hybrid search 실행 + 결과 파일 저장”만 수행한다. - llm_provider: "anthropic" - llm_model: "claude-haiku-4-5" (예시 그대로 사용) - prompts: role="user", content에 아래 내용을 포함: 1) “You are executing task_i.” 2) 담당 query 객체(정규화된 search_params 포함)를 그대로 첨부 3) Execution 규칙: - weaviate.search_hybrid 1회(Primary) - 결과가 비었거나(unique weaviate_ref 기준) 3개 미만이면 fallback_query로 1회 추가 실행 - 두 결과를 merge + dedupe(weaviate_ref/id 기준) + 상위 6개만 유지 - excerpt는 240자 이내로 정리(줄바꿈 제거, 공백 정리) - 결과 JSON을 `legal_facts_search_results_.json`로 write_file(overwrite=true) 저장 4) 마지막에 정확히 다음만 출력: `"task_i completed"` 그리고 **terminate** task_JOIN은 “결과 파일 취합 + 최종 markdown 작성”만 수행한다. - llm_provider: "anthropic" - llm_model: "claude-haiku-4-5" - prompts content 포함: - 모든 query_id 리스트 - 각 `legal_facts_search_results_.json`를 read_doc로 읽어 취합 - `legally_required_facts_information.md` 작성 규칙(아래 §8) - write_file(overwrite=true)로 저장 - 마지막에 정확히: `"task_JOIN completed"` 그리고 **terminate** ### Step A7) `legal_facts_search_prompt.md` 작성(저장) `legal_facts_search_prompt.md`는 Markdown이어야 하며, 최소 아래 섹션을 포함한다. - 제목 - “How to run” 간단 지시 - code block (json)로 다음 객체를 포함: - task_procedure - tasks ※ 반드시 실제 N에 맞춘 구체 task_1..task_N을 생성한다(…/ellipsis 금지). 저장: - write_file("legal_facts_search_prompt.md", , overwrite=true) --- ## 7) PHASE B — `legal_facts_search_prompt.md` 실행 (MANDATORY) 원칙(Primary): - 플랫폼에 병렬 task 실행 런타임이 존재한다면, `legal_facts_search_prompt.md`에 포함된 task_procedure + tasks 정의를 사용하여, Default_Agent\parallel_processing_definition.txt의 DAG 규약대로 task_1..task_N을 병렬 실행하고, 마지막에 task_JOIN을 실행하라. Fallback(Secondary; 병렬 런타임 미제공 시): - 본 Stage 3.5.2 실행 컨텍스트에서, task_1..task_N의 로직을 **순차적으로 그대로 수행**하여 동일한 결과 파일들을 생성한 후, - task_JOIN 로직을 수행하여 `legally_required_facts_information.md`를 생성하라. (어떤 모드이든) 최종적으로 `legally_required_facts_information.md`가 존재해야 한다. --- ## 8) `legally_required_facts_information.md` 작성 규칙 (HARD) 최종 문서는 “요건사실 정보의 실무적 재사용성”을 극대화하는 구조로 작성한다. 필수 구성(권장 템플릿): 1) 문서 메타 - 생성 일시(가능하면), 입력 파일명, 총 query 수, 총 claim 수(가능하면) 2) query_id별 섹션(반드시 query_id 순서) - Heading: `## — <사건종류>` - 적용 claim_id: applicable_claim_ids - Target: collection_name / tenant - 사용한 검색 파라미터(alpha, limit, bm25_operator, bm25_minimum_match, query_properties) - 결과 요약(요건사실 중심): - “요건사실(성립요건) 핵심 포인트”를 bullet로 3~7개 - 각 bullet은 **검색 hit의 excerpt에 근거하여** 작성(근거 없는 창작 금지) - 근거 hit 목록(최대 6개): - `- [weaviate_ref] (score=...) excerpt...` 형식 - excerpt는 240자 이내, 줄바꿈 제거 3) 공통 주의: - 불충분/무관 결과만 나온 경우: - “### 검색 품질 경고” 섹션에 이유를 기록하고, - 어떤 요건사실 요소가 비어 있는지(예: 무자력/사해의사 등) “missing 요소”로 표기 저장: - write_file("legally_required_facts_information.md", , overwrite=true) --- ## 9) FINAL (CHAT OUTPUT) 모든 파일 저장이 끝나면, 채팅에는 아래 1줄만 출력: STAGE 3.5.2 COMPLETE: wrote legal_facts_search_prompt.md and legally_required_facts_information.md tools: mcpServers: weaviate: type: streamable-http url: "https://weaviate.eroomai.com/mcp" description: Get the content from weaviate localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents outsourcing: type: streamable-http url: "https://outsourcing.mcp.eroomai.com/mcp" description: Get the content of local documents headers: Authorization: "Bearer FftIOt6ppQKrzhaRX8x/olCvRVivoR9SWXYOYeXEREg=" prevs: [stage3.5.1_요건사실검색쿼리생성] nexts: [stage4_청구항변반박전략문서작성] - name: stage4_0_parallel-executor description: 'Stage 4 Phase A: 4개의 Python 스크립트를 DAG 기반으로 병렬 실행 (Direct MCP)' llm_provider: openai llm_model: gpt-4o tools: mcpServers: code-executor: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp description: Run scripts of programming languages headers: Authorization: Bearer rR8OXqWrVZA1gFEo8oWfBkw2XgpWoGrrspw5ObsxTCM= tasks: - task_name: run_index mcp: code-executor tool_name: run_code parameters: language: python code: | #!/usr/bin/env python3 """ stage4_index.py — Stage 4, Phase A-1: Deterministic Index Generator Reads 5 REQUIRED inputs via MCP localdocs and produces stage4_index.json. Runs inside code-executor Docker container. """ import json import re import sys from datetime import datetime from typing import Any import httpx # ────────────────────────────────────────────────────────────────────── # 0-1) MCP localdocs helpers # ────────────────────────────────────────────────────────────────────── LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" HEADERS = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } def parse_sse(text): for line in text.strip().split("\n"): if line.startswith("data: "): return json.loads(line[6:]) try: return json.loads(text) except Exception: return None def call_tool(c, name, arguments, msg_id=10): r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": msg_id, "method": "tools/call", "params": {"name": name, "arguments": arguments} }, headers=HEADERS) result = parse_sse(r.text) if result and "result" in result: return result print(f"Tool {name} error: {json.dumps(result)[:300]}", file=sys.stderr) return result def read_doc(c, doc_name, msg_id=10): """Read a JSON document via MCP localdocs.""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] if not text or not text.strip(): return None try: return json.loads(text) except json.JSONDecodeError: print(f"read_doc({doc_name}): JSON parse failed", file=sys.stderr) return None return None def read_doc_text(c, doc_name, msg_id=10): """Read a text/markdown document via MCP localdocs (no JSON parse).""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] return text if text and text.strip() else None return None # ────────────────────────────────────────────────────────────────────── # 1) evidence_index builder # ────────────────────────────────────────────────────────────────────── def build_evidence_index(evidence_data: list[dict], claim_evidence_map: dict[str, list[str]]) -> dict: """ evidence_indexed.json → { "E-###": { title, doc_type, key_facts, related_claims } } """ ev_to_claims: dict[str, list[str]] = {} for cid, ev_list in claim_evidence_map.items(): for eid in ev_list: ev_to_claims.setdefault(eid, []) if cid not in ev_to_claims[eid]: ev_to_claims[eid].append(cid) index = {} for item in evidence_data: eid = item.get("evidence_index", "") if not eid: continue doc_type = _classify_doc_type(item.get("document_type", "")) key_facts = _split_key_info(item.get("key_info", "")) index[eid] = { "title": item.get("title", ""), "doc_type": doc_type, "key_facts": key_facts, "related_claims": sorted(ev_to_claims.get(eid, [])) } return index def _classify_doc_type(raw: str) -> str: if not raw: return "기타" mapping = { "등기부등본": "공문서", "등기사항": "공문서", "법인등기부등본": "공문서", "주민등록": "공문서", "법원문서": "판결/결정", "판결": "판결/결정", "결정": "판결/결정", "배당표": "판결/결정", "계약서": "처분문서", "약정서": "처분문서", "감정평가서": "기타", "영수증": "거래기록", "금융기록": "거래기록", "확인서": "거래기록", "명세표": "거래기록", } for key, val in mapping.items(): if key in raw: return val return "기타" def _split_key_info(key_info: str) -> list[str]: if not key_info: return [] parts = re.split(r",\s*(?![^()]*\))", key_info) return [p.strip() for p in parts if p.strip()] # ────────────────────────────────────────────────────────────────────── # 3) fact_index builder # ────────────────────────────────────────────────────────────────────── def build_fact_index(fact_ledger: list[dict], claim_fact_map: dict[str, list[str]]) -> dict: """ Fact_Ledger.json → { "F-###": { source_bo_id, summary, credibility, evidence_refs, related_claims } } ★ 핵심 원칙: Fact_Ledger의 fact_id ↔ source_bo_id 매핑을 원본 그대로 보존한다. 재정렬·재할당하지 않는다. summary는 Fact_Ledger의 action 필드로부터 결정론적으로 생성한다. """ fact_to_claims: dict[str, list[str]] = {} for cid, fact_list in claim_fact_map.items(): for fid in fact_list: fact_to_claims.setdefault(fid, []) if cid not in fact_to_claims[fid]: fact_to_claims[fid].append(cid) index = {} for item in fact_ledger: fid = item.get("fact_id", "") if not fid: continue bo_id = item.get("source_bo_id", "") ev_refs = _extract_evidence_ids(item.get("evidence_refs", [])) summary = _build_fact_summary(item) claims = sorted(set( fact_to_claims.get(fid, []) + fact_to_claims.get(bo_id, []) )) index[fid] = { "source_bo_id": bo_id, "summary": summary, "credibility": item.get("credibility", "unknown"), "evidence_refs": ev_refs, "related_claims": claims } return index def _extract_evidence_ids(refs: list) -> list[str]: result = [] for ref in refs: if not isinstance(ref, str): continue for m in re.findall(r"E-\d+", ref): if m not in result: result.append(m) return result def _build_fact_summary(item: dict) -> str: """Build concise summary from Fact_Ledger entry.""" parties = item.get("parties", []) action = item.get("action", "") date = item.get("date", "") summary = "" if parties and action: subject = parties[0] if subject in action: summary = action else: particle = "이" if _ends_with_consonant(subject) else "가" summary = f"{subject}{particle} {action}" elif action: summary = action if date: summary = f"{summary}({date})" return summary def _ends_with_consonant(text: str) -> bool: if not text: return False last = text[-1] if '가' <= last <= '힣': return (ord(last) - 0xAC00) % 28 != 0 return False # ────────────────────────────────────────────────────────────────────── # 4) goal_index builder # ────────────────────────────────────────────────────────────────────── def build_goal_index(client_goal: dict) -> dict: goals = {} idx = 1 primary = client_goal.get("primary_goal", "") if primary: goals[f"G-{idx:03d}"] = {"summary": primary} idx += 1 constraints = client_goal.get("constraints", []) if constraints: goals[f"G-{idx:03d}"] = {"summary": ", ".join(constraints)} idx += 1 defendants = client_goal.get("parties", {}).get("defendants", []) has_pauliana = any( "사해행위" in d.get("role", "") or "수익자" in d.get("role", "") for d in defendants ) if has_pauliana: goals[f"G-{idx:03d}"] = { "summary": "사해행위취소를 통한 책임재산 원상회복" } idx += 1 return goals # ────────────────────────────────────────────────────────────────────── # 5) legal_elements_index builder # ────────────────────────────────────────────────────────────────────── def build_legal_elements_index(lrf_text: str) -> dict: index = {} q_sections = re.split(r"(?=^## Q-\d+)", lrf_text, flags=re.MULTILINE) for section in q_sections: q_match = re.match(r"## (Q-\d+)\s*[—\-]\s*(.*)", section) if not q_match: continue query_id = q_match.group(1) claim_ids = _extract_applicable_claims(section) points_match = re.search( r"###\s*요건사실 핵심 포인트\s*\n(.*?)" r"(?=\n###|\n---|\n## |\Z)", section, re.DOTALL ) if not points_match: continue point_pattern = re.compile( r"^\s*(\d+)\.\s+\*\*(.+?)\*\*\s*[:：]\s*(.*?)" r"(?=\n\s*\d+\.\s+\*\*|\Z)", re.MULTILINE | re.DOTALL ) for m in point_pattern.finditer(points_match.group(1)): point_num = int(m.group(1)) element_label = m.group(2).strip() description = re.sub(r"\s+", " ", m.group(3)).strip() q_num = re.search(r"\d+", query_id).group() element_id = f"LF-Q{q_num.zfill(3)}-P{point_num}" index[element_id] = { "query_id": query_id, "element": element_label, "description": description, "applicable_claims": claim_ids or ["UNKNOWN"] } return index def _extract_applicable_claims(section_text: str) -> list[str]: match = re.search( r"적용\s*claim_id\s*\*?\*?\s*[:：]\s*(.*)", section_text) if not match: return [] raw = match.group(1).strip() claims: list[str] = [] for rm in re.finditer(r"(C-\d+)\s*[~～]\s*(C-\d+)", raw): s = int(re.search(r"\d+", rm.group(1)).group()) e = int(re.search(r"\d+", rm.group(2)).group()) for i in range(s, e + 1): cid = f"C-{i:03d}" if cid not in claims: claims.append(cid) for cm in re.finditer(r"C-\d+", raw): if cm.group() not in claims: claims.append(cm.group()) return sorted(claims) # ────────────────────────────────────────────────────────────────────── # 6) claim_index builder # ────────────────────────────────────────────────────────────────────── def build_claim_index(pre_claim_text: str, min_score: int = 5) -> tuple[dict, list[str]]: claims = {} ordered = [] for row in _parse_ssot_table(pre_claim_text): cid = row["claim_id"] score = row["total_score"] claims[cid] = { "claim_type": row["claim_type"], "total_score": score, "eligible": score >= min_score, "rank": row["rank"], "plaintiff": "", "defendant": "", "summary": "" } if score >= min_score: ordered.append(cid) for cid, detail in _parse_claim_details(pre_claim_text).items(): if cid in claims: claims[cid]["summary"] = detail.get("summary", "") for cid, pmap in _parse_party_mappings(pre_claim_text).items(): if cid in claims: claims[cid]["plaintiff"] = pmap.get("plaintiff", "") claims[cid]["defendant"] = pmap.get("defendant", "") return claims, ordered def _parse_ssot_table(text: str) -> list[dict]: rows = [] section_match = re.search( r"##\s*2\.\s*청구권\s*우선순위\s*요약\s*\n(.*?)(?=\n---|\n##)", text, re.DOTALL ) if not section_match: section_match = re.search( r"(\|.*claim_id.*\|.*\n(?:\|.*\n)+)", text, re.DOTALL) if not section_match: return rows header_line = None col_indices: dict[str, int] = {} for line in section_match.group(1).strip().split("\n"): line = line.strip() if not line.startswith("|"): continue cells = [c.strip() for c in line.split("|") if c.strip()] if cells and all(re.match(r"^[-:]+$", c) for c in cells): continue if header_line is None and any( "claim_id" in c.lower() for c in cells ): header_line = cells for i, h in enumerate(cells): hl = h.strip().lower() if "순위" in hl or "rank" in hl: col_indices["rank"] = i elif "claim_id" in hl: col_indices["claim_id"] = i elif "청구권" in hl or "claim" in hl: col_indices["claim_type"] = i elif "총점" in hl or "total" in hl: col_indices["total_score"] = i continue if header_line and len(cells) >= len(col_indices): try: cid = cells[col_indices.get("claim_id", 1)].strip() if not re.match(r"C-\d+", cid): continue rr = cells[col_indices.get("rank", 0)].strip() rank = (int(re.search(r"\d+", rr).group()) if re.search(r"\d+", rr) else 0) ct = cells[col_indices.get("claim_type", 2)].strip() sr = cells[col_indices.get("total_score", -1)].strip() score = (int(re.search(r"\d+", sr).group()) if re.search(r"\d+", sr) else 0) rows.append({"claim_id": cid, "rank": rank, "claim_type": ct, "total_score": score}) except (IndexError, ValueError, AttributeError): continue return rows def _parse_claim_details(text: str) -> dict[str, dict]: details = {} for m in re.finditer( r"###\s*\(\d+\)\s*(C-\d+)\s*[:：]\s*(.*?)\n" r"(.*?)(?=\n###|\n---|\n##|\Z)", text, re.DOTALL ): cid = m.group(1) dt = m.group(3) pm = re.search( r"[-\*]\s*\*?\*?청구취지\*?\*?\s*[:：]\s*(.*?)" r"(?=\n[-\*]|\n\n|\Z)", dt) purport = pm.group(1).strip() if pm else "" cm = re.search( r"[-\*]\s*\*?\*?청구원인\*?\*?\s*[:：]\s*(.*?)" r"(?=\n[-\*]|\n\n|\Z)", dt) cause = cm.group(1).strip() if cm else "" tags = [] ft = list(dict.fromkeys(re.findall(r"F-\d+", dt))) et = list(dict.fromkeys(re.findall(r"E-\d+", dt))) if ft: tags.append(f"({', '.join(ft)})") if et: tags.append(f"({', '.join(et)})") base = cause or purport details[cid] = { "summary": f"{base} {''.join(tags)}".strip() if base else "" } s4 = re.search( r"##\s*4\.\s*기타\s*청구권.*?\n(.*?)(?=\n---|\n##|\Z)", text, re.DOTALL) if s4: for line in s4.group(1).strip().split("\n"): if not line.strip().startswith("|"): continue cells = [c.strip() for c in line.split("|") if c.strip()] if len(cells) < 3: continue cm = re.match(r"C-\d+", cells[0]) if cm and cm.group() not in details: cid = cm.group() memo = cells[-1] if len(cells) > 2 else "" ct = cells[1] if len(cells) > 1 else "" tags = [] ft = list(dict.fromkeys(re.findall(r"F-\d+", line))) et = list(dict.fromkeys(re.findall(r"E-\d+", line))) if ft: tags.append(f"({', '.join(ft)})") if et: tags.append(f"({', '.join(et)})") details[cid] = { "summary": f"{ct}: {memo} {''.join(tags)}".strip() } return details def _parse_party_mappings(text: str) -> dict[str, dict]: mappings = {} section = re.search( r"(?:###\s*5\.3|청구권별\s*매핑).*?\n(.*?)(?=\n---|\n##|\Z)", text, re.DOTALL) if not section: return mappings header_found = False p_col = d_col = cid_col = None for line in section.group(1).strip().split("\n"): if not line.strip().startswith("|"): continue cells = [c.strip() for c in line.split("|") if c.strip()] if cells and all(re.match(r"^[-:]+$", c) for c in cells): continue if not header_found: for i, h in enumerate(cells): if "claim_id" in h.lower(): cid_col = i elif "원고" in h: p_col = i elif "피고" in h: d_col = i if cid_col is not None: header_found = True continue if header_found and len(cells) > max( filter(None, [cid_col, p_col, d_col]), default=0 ): cm = re.match( r"C-\d+", cells[cid_col] if cid_col is not None else "") if cm: mappings[cm.group()] = { "plaintiff": (cells[p_col].strip() if p_col and p_col < len(cells) else ""), "defendant": (cells[d_col].strip() if d_col and d_col < len(cells) else ""), } return mappings # ────────────────────────────────────────────────────────────────────── # 7) Cross-reference maps: claim → facts, claim → evidence # ────────────────────────────────────────────────────────────────────── def build_claim_fact_evidence_maps( pre_claim_text: str, fact_ledger: list[dict] ) -> tuple[dict[str, list[str]], dict[str, list[str]]]: """ Build claim_id → [fact_ids] and claim_id → [evidence_ids]. Sources: 1) 청구전작업.md §3/§4 explicit references 2) evidence propagation from Fact_Ledger evidence_refs 3) Party-based heuristic for unassigned facts """ claim_facts: dict[str, list[str]] = {} claim_evidence: dict[str, list[str]] = {} # ── Source 1: Explicit references ── for m in re.finditer( r"###\s*\(\d+\)\s*(C-\d+)\s*[:：].*?\n" r"(.*?)(?=\n###|\n---|\n##|\Z)", pre_claim_text, re.DOTALL ): cid = m.group(1) body = m.group(2) claim_facts[cid] = ( list(dict.fromkeys(re.findall(r"F-\d+", body))) + list(dict.fromkeys(re.findall(r"bh\d+", body))) ) claim_evidence[cid] = list(dict.fromkeys( re.findall(r"E-\d+", body))) s4 = re.search(r"##\s*4\..*?\n(.*?)(?=\n---|\n##|\Z)", pre_claim_text, re.DOTALL) if s4: for line in s4.group(1).split("\n"): cm = re.search(r"C-\d+", line) if cm and cm.group() not in claim_facts: cid = cm.group() claim_facts[cid] = ( list(dict.fromkeys(re.findall(r"F-\d+", line))) + list(dict.fromkeys(re.findall(r"bh\d+", line))) ) claim_evidence[cid] = list(dict.fromkeys( re.findall(r"E-\d+", line))) # ── Fact_Ledger lookups ── fact_to_evidence: dict[str, list[str]] = {} bh_to_fid: dict[str, str] = {} fid_to_item: dict[str, dict] = {} for item in fact_ledger: fid = item.get("fact_id", "") bo_id = item.get("source_bo_id", "") fact_to_evidence[fid] = _extract_evidence_ids( item.get("evidence_refs", [])) fid_to_item[fid] = item if bo_id: bh_to_fid[bo_id] = fid # ── Source 3: Party-based expansion ── claim_seed_parties: dict[str, set[str]] = {} for cid, fids in claim_facts.items(): pset: set[str] = set() for fid_or_bh in fids: actual = bh_to_fid.get(fid_or_bh, fid_or_bh) if actual in fid_to_item: pset.update(fid_to_item[actual].get("parties", [])) claim_seed_parties[cid] = pset assigned: set[str] = set() for fids in claim_facts.values(): for fob in fids: assigned.add(bh_to_fid.get(fob, fob)) # Generic parties: appearing in >50% of claims generic: set[str] = set() if claim_seed_parties: pcc: dict[str, int] = {} for pset in claim_seed_parties.values(): for p in pset: pcc[p] = pcc.get(p, 0) + 1 thr = len(claim_seed_parties) * 0.5 generic = {p for p, c in pcc.items() if c > thr} for fid, item in fid_to_item.items(): if fid in assigned: continue fp = set(item.get("parties", [])) if not fp: continue best_claims: list[str] = [] best_score = 0 for cid, sp in claim_seed_parties.items(): overlap = fp & sp ngo = overlap - generic score = len(ngo) * 2 + len(overlap) if score > best_score: best_score = score best_claims = [cid] elif score == best_score and score > 0: best_claims.append(cid) if best_score >= 2: for cid in best_claims: claim_facts.setdefault(cid, []) if fid not in claim_facts[cid]: claim_facts[cid].append(fid) assigned.add(fid) # ── Propagate evidence ── for cid, fids in claim_facts.items(): for fob in fids: actual = bh_to_fid.get(fob, fob) if fob.startswith("bh") else fob for eid in fact_to_evidence.get(actual, []): if eid not in claim_evidence.get(cid, []): claim_evidence.setdefault(cid, []).append(eid) return claim_facts, claim_evidence # ────────────────────────────────────────────────────────────────────── # 8) parties & procedural_structures # ────────────────────────────────────────────────────────────────────── def build_parties(pre_claim_text: str, client_goal: dict) -> dict: parties: dict[str, list[str]] = { "plaintiffs": [], "defendants": [], "excluded": [] } ps = re.search( r"###\s*5\.1\s*원고\s*\n(.*?)(?=\n###|\n---|\n##|\Z)", pre_claim_text, re.DOTALL) if ps: for line in ps.group(1).split("\n"): if "|" in line and "확정" in line: cells = [c.strip() for c in line.split("|") if c.strip()] if cells and not re.match(r"^[-:]+$", cells[0]): n = cells[0].strip() if n and n not in parties["plaintiffs"] and "원고" not in n: parties["plaintiffs"].append(n) ds = re.search( r"###\s*5\.2\s*피고\s*\n(.*?)(?=\n###|\n---|\n##|\Z)", pre_claim_text, re.DOTALL) if ds: for line in ds.group(1).split("\n"): if "|" not in line: continue cells = [c.strip() for c in line.split("|") if c.strip()] if len(cells) < 2 or re.match(r"^[-:]+$", cells[0]): continue n = cells[0].strip() if "피고" in n or not n: continue st = cells[1].strip() if len(cells) > 1 else "" if "제외" in st: if n not in parties["excluded"]: parties["excluded"].append(n) elif "확정" in st or "후보" in st: if n not in parties["defendants"]: parties["defendants"].append(n) if not parties["plaintiffs"]: for p in client_goal.get("parties", {}).get("plaintiffs", []): parties["plaintiffs"].append(p.get("name", "")) if not parties["defendants"]: for d in client_goal.get("parties", {}).get("defendants", []): n = d.get("name", "") st = d.get("asset_status", "") if "재산 전무" in st or "폐업" in d.get("status", ""): parties["excluded"].append(n) else: parties["defendants"].append(n) return parties def extract_procedural_structures(pre_claim_text: str) -> list[str]: structures: list[str] = [] keywords = [ "단순병합", "예비적병합", "선택적병합", "공동소송", "필수적공동소송", "통상공동소송", "반소", "반소가능성", "소송고지", "보조참가", "채권자대위" ] s7 = re.search( r"##\s*7\.\s*청구방식.*?\n(.*?)(?=\n---|\n##|\Z)", pre_claim_text, re.DOTALL) scan = s7.group(1) if s7 else "" s9 = re.search( r"##\s*9\.\s*후속\s*단계.*?\n(.*?)(?=\n---|\n##|\Z)", pre_claim_text, re.DOTALL) if s9: scan += "\n" + s9.group(1) for kw in keywords: if kw in scan: structures.append(kw) if s7: sm = re.search( r"[-\*]\s*\*?\*?구조\*?\*?\s*[:：]\s*(.*?)(?:\n|$)", s7.group(1)) if sm: for kw in keywords: if kw in sm.group(1) and kw not in structures: structures.append(kw) return structures # ══════════════════════════════════════════════════════════════════════ # 9) POST-GENERATION INTEGRITY VALIDATION # ══════════════════════════════════════════════════════════════════════ class ValidationReport: """Collects and reports validation findings.""" def __init__(self): self.errors: list[str] = [] self.warnings: list[str] = [] def error(self, msg: str): self.errors.append(msg) def warn(self, msg: str): self.warnings.append(msg) @property def ok(self) -> bool: return len(self.errors) == 0 def print_report(self): if self.ok and not self.warnings: print("[VALIDATE] ✓ All integrity checks passed.", file=sys.stderr) return if self.errors: print(f"[VALIDATE] ✗ {len(self.errors)} error(s):", file=sys.stderr) for e in self.errors: print(f" ERROR: {e}", file=sys.stderr) if self.warnings: print(f"[VALIDATE] △ {len(self.warnings)} warning(s):", file=sys.stderr) for w in self.warnings: print(f" WARN: {w}", file=sys.stderr) def validate_index(result: dict, fact_ledger: list[dict], bo_data: list[dict] | None = None) -> ValidationReport: """ Post-generation integrity checks: V1. fact_index fact_id/source_bo_id ↔ Fact_Ledger alignment V2. fact_index content ↔ BO.json content alignment (if available) V3. fact_index evidence_refs → evidence_index referential integrity V4. No duplicate source_bo_ids in fact_index V5. legal_elements → claim_index referential integrity V6. All Fact_Ledger entries present in fact_index (completeness) V7. Evidence completeness (all referenced E-### exist in index) """ rpt = ValidationReport() fi = result.get("fact_index", {}) ei = result.get("evidence_index", {}) ci = result.get("claim_index", {}) le = result.get("legal_elements_index", {}) fl_by_id = {it["fact_id"]: it for it in fact_ledger if "fact_id" in it} # ── V1: fact_index ↔ Fact_Ledger alignment ── for fid, entry in fi.items(): bo_id = entry.get("source_bo_id", "") if fid not in fl_by_id: rpt.error(f"V1: fact_index[{fid}] not in Fact_Ledger") continue fl = fl_by_id[fid] expected_bo = fl.get("source_bo_id", "") if bo_id != expected_bo: rpt.error( f"V1: fact_index[{fid}].source_bo_id='{bo_id}' " f"≠ Fact_Ledger='{expected_bo}'") # Content consistency: summary must derive from FL action fl_action = fl.get("action", "") summary = entry.get("summary", "") if fl_action and fl_action not in summary: core = fl_action[:15] if core not in summary: rpt.warn( f"V1: fact_index[{fid}].summary mismatch " f"('{summary[:35]}…' vs FL.action='{fl_action[:35]}…')") # ── V2: BO.json content alignment (optional) ── if bo_data is not None: bo_by_id = {it["id"]: it for it in bo_data if "id" in it} for fid, entry in fi.items(): bo_id = entry.get("source_bo_id", "") if not bo_id: continue if bo_id not in bo_by_id: rpt.error( f"V2: source_bo_id='{bo_id}' (in {fid}) " f"not found in BO.json") continue bo_action = bo_by_id[bo_id].get("Action", "") summary = entry.get("summary", "") if bo_action: # Character-set overlap ratio for content alignment bo_chars = {c for c in bo_action if c.strip() and c not in "을를에의이가"} sm_chars = {c for c in summary if c.strip()} ratio = (len(bo_chars & sm_chars) / max(len(bo_chars), 1)) if ratio < 0.3: rpt.error( f"V2: {fid}(bo={bo_id}) content mismatch " f"(overlap {ratio:.0%})\n" f" BO : '{bo_action[:50]}'\n" f" IDX: '{summary[:50]}'") # ── V3: evidence_refs → evidence_index ── for fid, entry in fi.items(): for eref in entry.get("evidence_refs", []): if eref not in ei: rpt.warn( f"V3: {fid}.evidence_refs → '{eref}' " f"not in evidence_index") # ── V4: No duplicate source_bo_ids ── seen_bo: dict[str, str] = {} for fid, entry in fi.items(): bo = entry.get("source_bo_id", "") if not bo: continue if bo in seen_bo: rpt.error( f"V4: Duplicate source_bo_id '{bo}' " f"in {fid} and {seen_bo[bo]}") seen_bo[bo] = fid # ── V5: legal_elements → claim_index ── for le_id, le_entry in le.items(): for cid in le_entry.get("applicable_claims", []): if cid != "UNKNOWN" and cid not in ci: rpt.warn( f"V5: legal_elements[{le_id}] → '{cid}' " f"not in claim_index") # ── V6: Fact_Ledger completeness ── for item in fact_ledger: fid = item.get("fact_id", "") if fid and fid not in fi: rpt.warn(f"V6: Fact_Ledger[{fid}] missing from fact_index") # ── V7: Evidence completeness ── all_erefs: set[str] = set() for fe in fi.values(): all_erefs.update(fe.get("evidence_refs", [])) for eid in all_erefs: if eid not in ei: rpt.warn(f"V7: '{eid}' referenced but not in evidence_index") return rpt # ────────────────────────────────────────────────────────────────────── # 10) Main assembly (data-only, no file I/O) # ────────────────────────────────────────────────────────────────────── def build_stage4_index_from_data( evidence_data: list[dict], fact_ledger: list[dict], client_goal: dict, lrf_text: str, pre_claim_text: str, bo_data: list[dict] | None = None, top_n: int = 8, min_score: int = 5, do_validate: bool = False, strict: bool = False, ) -> dict: """Assemble stage4_index.json from pre-loaded data (no file I/O).""" cfm, cem = build_claim_fact_evidence_maps(pre_claim_text, fact_ledger) evidence_index = build_evidence_index(evidence_data, cem) fact_index = build_fact_index(fact_ledger, cfm) goal_index = build_goal_index(client_goal) legal_elements_index = build_legal_elements_index(lrf_text) claim_index, ordered = build_claim_index(pre_claim_text, min_score) result = { "meta": { "stage": "4", "generated_at": datetime.now().strftime("%Y-%m-%d"), "source_files": [ "legally_required_facts_information.md", "청구전작업.md", "Fact_Ledger.json", "evidence_indexed.json", "client_goal.json" ] }, "evidence_index": evidence_index, "fact_index": fact_index, "goal_index": goal_index, "legal_elements_index": legal_elements_index, "claim_index": claim_index, "top_n_claims": ordered[:top_n], "parties": build_parties(pre_claim_text, client_goal), "procedural_structures": extract_procedural_structures( pre_claim_text) } if do_validate: rpt = validate_index(result, fact_ledger, bo_data) rpt.print_report() if strict and not rpt.ok: raise RuntimeError( f"Strict validation failed: {len(rpt.errors)} error(s)") return result def _log(msg: str): """진행/디버그 메시지 → stderr (stdout은 결과 JSON 전용).""" print(msg, file=sys.stderr) # ────────────────────────────────────────────────────────────────────── # 11) Entry point — MCP localdocs mode # ────────────────────────────────────────────────────────────────────── def main(): top_n = 8 min_score = 5 do_validate = True strict = False output_name = "stage4_index.json" with httpx.Client(timeout=60) as c: # ===== 1) localdocs 연결 ===== r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "stage4-index-gen", "version": "1.0"} } }, headers=HEADERS) sid = r.headers.get("mcp-session-id") if sid: HEADERS["mcp-session-id"] = sid c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "method": "notifications/initialized" }, headers=HEADERS) _log(f"1) Connected to localdocs (session: {sid})") # 도구 목록 확인 r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }, headers=HEADERS) tools_result = parse_sse(r.text) tools = (tools_result.get("result", {}).get("tools", []) if tools_result else []) _log(f" Tools: {[t['name'] for t in tools]}") # write 도구 찾기 write_tool = next( (t for t in tools if "write" in t["name"]), None) if write_tool: props = write_tool.get("inputSchema", {}).get("properties", {}) required = write_tool.get("inputSchema", {}).get("required", []) _log(f" Write tool: {write_tool['name']}, " f"params: {list(props.keys())}, required: {required}") # 문서 목록 docs = call_tool(c, "list_docs", {}, 3) if docs and "result" in docs: _log(f" Docs: {docs['result']['content'][0]['text'][:500]}") # ===== 2) 파일 로딩 (MCP read_doc) ===== _log("\n2) Loading input files via MCP...") evidence_data = read_doc(c, "evidence_indexed.json", 10) fact_ledger = read_doc(c, "Fact_Ledger.json", 11) if fact_ledger is None: fact_ledger = read_doc(c, "fact_ledger.json", 12) client_goal = read_doc(c, "client_goal.json", 13) lrf_text = read_doc_text( c, "legally_required_facts_information.md", 14) pre_claim_text = read_doc_text(c, "청구전작업.md", 15) # Optional bo_data = read_doc(c, "BO.json", 16) # 로딩 검증 required_files = { "evidence_indexed.json": evidence_data, "Fact_Ledger.json": fact_ledger, "client_goal.json": client_goal, "legally_required_facts_information.md": lrf_text, "청구전작업.md": pre_claim_text, } for name, data in required_files.items(): if data is None: raise RuntimeError( f"Failed to load required file: {name}") size = len(data) if hasattr(data, '__len__') else '?' _log(f" {name}: loaded " f"({type(data).__name__}, len={size})") if bo_data: _log(f" BO.json: loaded ({len(bo_data)} entries)") else: _log(" BO.json: not found (optional, skipping)") # ===== 3) 인덱스 생성 ===== _log("\n3) Building stage4_index...") result = build_stage4_index_from_data( evidence_data=evidence_data, fact_ledger=fact_ledger, client_goal=client_goal, lrf_text=lrf_text, pre_claim_text=pre_claim_text, bo_data=bo_data, top_n=top_n, min_score=min_score, do_validate=do_validate, strict=strict, ) # ===== 4) 결과 저장 (MCP write_doc + stdout) ===== output_json = json.dumps(result, ensure_ascii=False, indent=2) if write_tool: write_result = call_tool(c, write_tool["name"], { "path": output_name, "content": output_json, }, 20) if write_result and "result" in write_result: _log(f"\n4) Written to localdocs: {output_name}") else: _log("\n4) Write to localdocs failed") else: _log("\n4) No write tool available") # 항상 stdout으로 출력 (code-executor가 캡처) print(output_json) if __name__ == "__main__": main() requirements: "httpx" network: "agent-network" timeout: 120 - task_name: run_compute_inputs mcp: code-executor tool_name: run_code parameters: language: python code: | #!/usr/bin/env python3 """ stage4_compute_inputs.py — Stage 4, Phase A-3: Deterministic Compute Input Extractor Reads inputs via MCP localdocs and produces stage4_compute_inputs.json. Runs inside code-executor Docker container. """ import json import re import sys from datetime import datetime, date from typing import Any, Optional import httpx # ══════════════════════════════════════════════════════════════════════════════ # 0) MCP localdocs helpers # ══════════════════════════════════════════════════════════════════════════════ LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" HEADERS = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } def parse_sse(text): for line in text.strip().split("\n"): if line.startswith("data: "): return json.loads(line[6:]) try: return json.loads(text) except Exception: return None def call_tool(c, name, arguments, msg_id=10): r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": msg_id, "method": "tools/call", "params": {"name": name, "arguments": arguments} }, headers=HEADERS) result = parse_sse(r.text) if result and "result" in result: return result print(f"Tool {name} error: {json.dumps(result)[:300]}", file=sys.stderr) return result def read_doc(c, doc_name, msg_id=10): """Read a JSON document via MCP localdocs.""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] if not text or not text.strip(): return None try: return json.loads(text) except json.JSONDecodeError: print(f"read_doc({doc_name}): JSON parse failed", file=sys.stderr) return None return None def read_doc_text(c, doc_name, msg_id=10): """Read a text/markdown document via MCP localdocs (no JSON parse).""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] return text if text and text.strip() else None return None # ══════════════════════════════════════════════════════════════════════════════ # 2) Amount Parsing Utilities # ══════════════════════════════════════════════════════════════════════════════ # Korean number unit map _KO_UNITS = { "원": 1, "만원": 10_000, "십만원": 100_000, "백만원": 1_000_000, "천만원": 10_000_000, "억원": 100_000_000, "억": 100_000_000, "만": 10_000, "천": 1_000, "백": 100, } def parse_korean_amount(text: str) -> Optional[int]: """ Parse a Korean currency string into an integer value. Handles patterns like: "10억원", "3억원", "2억 2천만원", "4억 3천만원", "1억원", "3천만원", "5천만원", "2천만원", "3천만원", "약 3억원" Also handles: "채권최고액 15억원", "보증금 1억원" Returns None if unparseable. """ if not text: return None # Remove common prefixes text = re.sub(r'(약|채권최고액|보증금|보증원금|보증한도|대금|매매대금)\s*', '', text.strip()) # Remove parenthetical content text = re.sub(r'\(.*?\)', '', text).strip() # Try direct numeric (e.g. "300000000") m = re.match(r'^(\d[\d,]+)\s*원?$', text) if m: return int(m.group(1).replace(",", "")) # Pattern: "X억 Y천만원", "X억원", "X천만원", etc. total = 0 remaining = text # Extract 억 m_eok = re.search(r'(\d+(?:\.\d+)?)\s*억', remaining) if m_eok: total += int(float(m_eok.group(1)) * 100_000_000) remaining = remaining[m_eok.end():] # Extract 천만 m_cheonman = re.search(r'(\d+(?:\.\d+)?)\s*천만', remaining) if m_cheonman: total += int(float(m_cheonman.group(1)) * 10_000_000) remaining = remaining[m_cheonman.end():] # Extract 백만 m_baekman = re.search(r'(\d+(?:\.\d+)?)\s*백만', remaining) if m_baekman: total += int(float(m_baekman.group(1)) * 1_000_000) remaining = remaining[m_baekman.end():] # Extract 만 m_man = re.search(r'(\d+(?:\.\d+)?)\s*만', remaining) if m_man: total += int(float(m_man.group(1)) * 10_000) remaining = remaining[m_man.end():] # Extract 천 (standalone, not 천만) m_cheon = re.search(r'(\d+(?:\.\d+)?)\s*천(?!만)', remaining) if m_cheon: total += int(float(m_cheon.group(1)) * 1_000) remaining = remaining[m_cheon.end():] if total > 0: return total # Fallback: try extracting a decimal with unit m_decimal = re.search(r'(\d+(?:\.\d+)?)\s*억', text) if m_decimal: return int(float(m_decimal.group(1)) * 100_000_000) return None def parse_rate_from_text(text: str) -> list[dict]: """ Extract interest rate candidates from text. Returns list of {"type": "약정이율"|"지연손해금율", "annual_pct": float, "raw": str} Handles patterns: - "이자 월0.5%" → annual 6% - "지연손해금 월1%" → annual 12% - "연 12%", "연이율 6%", "이자율 5%" - "연체이율 연 24%" """ rates = [] # Monthly rate patterns for m in re.finditer(r'(이자|지연손해금|연체이자|연체이율|이율)\s*월\s*(\d+(?:\.\d+)?)\s*%', text): label = m.group(1) monthly = float(m.group(2)) annual = monthly * 12 rtype = "지연손해금율" if "지연" in label or "연체" in label else "약정이율" rates.append({ "type": rtype, "annual_pct": min(annual, 24.0), # 24% cap "raw": m.group(0) }) # Annual rate patterns for m in re.finditer( r'(약정이율|약정이자|이자율?|지연손해금율?|연체이율?|법정이율|연이율)\s*' r'(?:연\s*)?(\d+(?:\.\d+)?)\s*%', text ): label = m.group(1) annual = float(m.group(2)) rtype = "지연손해금율" if "지연" in label or "연체" in label else "약정이율" # Avoid duplicates already captured as monthly if not any(r["annual_pct"] == annual for r in rates): rates.append({ "type": rtype, "annual_pct": min(annual, 24.0), "raw": m.group(0) }) return rates def parse_date_str(date_str: str) -> Optional[str]: """Normalise various date formats to ISO YYYY-MM-DD. Returns None on failure.""" if not date_str: return None # Already ISO m = re.match(r'^(\d{4})-(\d{1,2})-(\d{1,2})$', str(date_str).strip()) if m: return f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}" # Korean: 2017.9.25 or 2017. 9. 25 m = re.match(r'(\d{4})\s*[.\-/]\s*(\d{1,2})\s*[.\-/]\s*(\d{1,2})', str(date_str)) if m: return f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}" return None def extract_dates_from_text(text: str) -> list[str]: """Extract all date strings from a text, return as ISO dates.""" dates = [] for m in re.finditer(r'(\d{4})\s*[.\-/]\s*(\d{1,2})\s*[.\-/]\s*(\d{1,2})', text): iso = f"{m.group(1)}-{int(m.group(2)):02d}-{int(m.group(3)):02d}" if iso not in dates: dates.append(iso) return dates # ══════════════════════════════════════════════════════════════════════════════ # 3) Claim-Type Classification for Rate Determination # ══════════════════════════════════════════════════════════════════════════════ _PAULIAN_KEYWORDS = ["사해행위", "채권자취소", "취소", "원상회복"] _COMMERCIAL_KEYWORDS = ["상사", "회사", "주식회사", "상법"] _MONETARY_KEYWORDS = ["대여금", "구상금", "대출", "보증채무", "이행"] def _is_paulian_claim(claim_type: str) -> bool: return any(kw in claim_type for kw in _PAULIAN_KEYWORDS) def _is_monetary_claim(claim_type: str) -> bool: return any(kw in claim_type for kw in _MONETARY_KEYWORDS) def _classify_rate_basis(claim_type: str, plaintiff: str) -> dict: """ Determine the statutory rate basis for a claim. Returns {"basis": str, "annual_pct": float, "note": str} """ # 사해행위취소 → no delay damages on the cancellation itself if _is_paulian_claim(claim_type): return { "basis": "사해행위취소(형성의소)", "annual_pct": None, "note": "사해행위취소 자체는 금전청구가 아니므로 지연손해금 산정 불요. " "원상회복으로 가액배상 시에만 법정이율 적용 가능." } # Check if commercial (상사) → 6% is_commercial = any(kw in plaintiff for kw in ["주식회사", "회사", "캐피탈", "보증"]) if is_commercial: return { "basis": "상사법정이율(상법 제54조)", "annual_pct": 6.0, "note": "상인 간 금전채무 → 연 6%" } # Default civil → 5% return { "basis": "민사법정이율(민법 제379조)", "annual_pct": 5.0, "note": "민사 금전채무 → 연 5%" } # ══════════════════════════════════════════════════════════════════════════════ # 4) Principal Extraction per Claim # ══════════════════════════════════════════════════════════════════════════════ def extract_principal_candidates( claim_id: str, claim_data: dict, fact_index: dict, evidence_index: dict, fact_ledger: list[dict], preclaim_text: str ) -> dict: """ Extract principal (원금) candidates for a claim. Returns: { "value": int | None, "src": [tag list], "status": "OK" | "CALCULATION_PENDING", "missing_reason": str | None, "candidates": [list of alternatives] } """ candidates = [] # Strategy 1: Parse from 청구전작업.md claim detail sections # Look for patterns like "약 3억원", "2.2억원", "4억원" in the claim section claim_section = _extract_claim_section(claim_id, preclaim_text) if claim_section: # Extract amount from 청구취지 line for line in claim_section.split("\n"): if "청구취지" in line: amounts_in_line = re.findall( r'(\d+(?:\.\d+)?(?:\s*억\s*)?(?:\d+\s*천만)?(?:\d+\s*만)?\s*원)', line) for amt_str in amounts_in_line: val = parse_korean_amount(amt_str) if val and val > 0: candidates.append({ "value": val, "src": [claim_id], "origin": "청구전작업_청구취지", "raw": amt_str.strip() }) # Strategy 2: From Fact_Ledger amounts linked to this claim for fid, fdata in fact_index.items(): if claim_id not in fdata.get("related_claims", []): continue # Find original fact_ledger entry for amount bo_id = fdata.get("source_bo_id", "") for fl_entry in fact_ledger: if fl_entry.get("fact_id") == fid and fl_entry.get("amount"): val = parse_korean_amount(fl_entry["amount"]) if val and val > 0: src_tags = [fid] if bo_id: src_tags.append(bo_id) # Add evidence refs for eref in fl_entry.get("evidence_refs", []): eid_match = re.match(r'(E-\d+)', eref) if eid_match: src_tags.append(eid_match.group(1)) candidates.append({ "value": val, "src": src_tags, "origin": f"Fact_Ledger[{fid}].amount", "raw": fl_entry["amount"] }) # Strategy 3: From evidence key_info for eid, edata in evidence_index.items(): if claim_id not in edata.get("related_claims", []): continue key_info = edata.get("key_info", "") if not key_info: for kf_text in edata.get("key_facts", []): key_info += " " + kf_text # Extract amounts from key_info amount_matches = re.findall( r'(\d+(?:\.\d+)?(?:\s*억\s*)?(?:\d+\s*천만)?(?:\d+\s*만)?\s*원)', key_info) for amt_str in amount_matches: val = parse_korean_amount(amt_str) if val and val > 0: candidates.append({ "value": val, "src": [eid], "origin": f"evidence[{eid}].key_info", "raw": amt_str.strip() }) # Strategy 4: From claim summary summary = claim_data.get("summary", "") summary_amounts = re.findall( r'(\d+(?:\.\d+)?(?:\s*억\s*)?(?:\d+\s*천만)?(?:\d+\s*만)?\s*원)', summary) for amt_str in summary_amounts: val = parse_korean_amount(amt_str) if val and val > 0: # Extract tags from summary tags_in_summary = re.findall(r'([FE]-\d+|bh\d+)', summary) if tags_in_summary: candidates.append({ "value": val, "src": tags_in_summary[:5], # cap at 5 tags "origin": f"claim_index[{claim_id}].summary", "raw": amt_str.strip() }) # Deduplicate and rank candidates candidates = _deduplicate_candidates(candidates) if not candidates: return { "value": None, "src": [], "status": "CALCULATION_PENDING", "missing_reason": "C2_FAIL: 원금을 문서 태그로 추적할 수 없음", "candidates": [] } # Select best candidate: prefer more source tags, then largest value best = _select_best_candidate(candidates) return { "value": best["value"], "src": best["src"], "status": "OK", "missing_reason": None, "candidates": candidates } # ══════════════════════════════════════════════════════════════════════════════ # 5) Rate Extraction per Claim # ══════════════════════════════════════════════════════════════════════════════ def extract_rate_candidates( claim_id: str, claim_data: dict, evidence_index: dict, evidence_raw: list[dict], fact_ledger: list[dict], fact_index: dict, preclaim_text: str ) -> dict: """ Extract interest rate candidates for a claim. Returns: { "contractual_rate": { ... } | None, "statutory_rate": { ... }, "recommended_rate": { ... }, "status": "OK" | "CALCULATION_PENDING", "missing_reason": str | None } """ claim_type = claim_data.get("claim_type", "") plaintiff = claim_data.get("plaintiff", "") # Get statutory rate basis statutory = _classify_rate_basis(claim_type, plaintiff) # For 사해행위취소, no direct rate needed if _is_paulian_claim(claim_type): return { "contractual_rate": None, "statutory_rate": statutory, "recommended_rate": statutory, "status": "OK", "missing_reason": None } # Try to find contractual rate from evidence linked to this claim contractual_candidates = [] for eid, edata in evidence_index.items(): if claim_id not in edata.get("related_claims", []): continue # Search in raw evidence data for ev_raw in evidence_raw: if ev_raw.get("evidence_index") == eid: key_info = ev_raw.get("key_info", "") rates = parse_rate_from_text(key_info) for r in rates: r["src"] = [eid] contractual_candidates.append(r) # Also check facts linked to this claim for rate mentions for fid, fdata in fact_index.items(): if claim_id not in fdata.get("related_claims", []): continue for fl_entry in fact_ledger: if fl_entry.get("fact_id") == fid: action = fl_entry.get("action", "") rates = parse_rate_from_text(action) for r in rates: r["src"] = [fid, fdata.get("source_bo_id", "")] contractual_candidates.append(r) # Check 청구전작업 for rate info claim_section = _extract_claim_section(claim_id, preclaim_text) if claim_section: rates = parse_rate_from_text(claim_section) for r in rates: tags = re.findall(r'([FE]-\d+|bh\d+)', claim_section) r["src"] = tags[:3] if tags else [] contractual_candidates.append(r) contractual = None if contractual_candidates: # Prefer 약정이율, then highest with most tags 약정 = [c for c in contractual_candidates if c["type"] == "약정이율"] 지연 = [c for c in contractual_candidates if c["type"] == "지연손해금율"] if 약정: best_약정 = max(약정, key=lambda x: (len(x.get("src", [])), x["annual_pct"])) contractual = { "type": best_약정["type"], "annual_pct": best_약정["annual_pct"], "src": best_약정.get("src", []), "raw": best_약정.get("raw", ""), "cap_applied": best_약정["annual_pct"] >= 24.0 } elif 지연: best_지연 = max(지연, key=lambda x: (len(x.get("src", [])), x["annual_pct"])) contractual = { "type": best_지연["type"], "annual_pct": best_지연["annual_pct"], "src": best_지연.get("src", []), "raw": best_지연.get("raw", ""), "cap_applied": best_지연["annual_pct"] >= 24.0 } # Determine recommended rate if contractual and contractual.get("src"): recommended = contractual elif statutory["annual_pct"] is not None: recommended = { "type": "법정이율", "annual_pct": statutory["annual_pct"], "src": [], "raw": statutory["basis"], "cap_applied": False } else: recommended = None if recommended and (recommended.get("src") or statutory["annual_pct"] is not None): status = "OK" missing = None else: status = "CALCULATION_PENDING" missing = "C3_FAIL: 이율 근거 확정 불가 (약정이율 E-### 명시 없음, 법정이율 적용 조건 미확인)" return { "contractual_rate": contractual, "statutory_rate": statutory, "recommended_rate": recommended, "status": status, "missing_reason": missing } # ══════════════════════════════════════════════════════════════════════════════ # 6) Date Extraction per Claim (start/end for delay damages) # ══════════════════════════════════════════════════════════════════════════════ def extract_date_candidates( claim_id: str, claim_data: dict, fact_index: dict, fact_ledger: list[dict], evidence_index: dict, evidence_raw: list[dict], preclaim_text: str ) -> dict: """ Extract start_date (기산일) and end_date (종기) for delay damages. start_date heuristics: - For 대여금/구상금: 변제기 다음날 or 대위변제일 다음날 - For 사해행위취소: not applicable (형성의소) end_date: - Typically "소장부본 송달일" (unknown at filing) or "완제일" - We record this as unknown with reason """ claim_type = claim_data.get("claim_type", "") # Paulian claims: no delay damages on the cancellation itself if _is_paulian_claim(claim_type): return { "start_date": { "value": None, "src": [], "status": "NOT_APPLICABLE", "missing_reason": "사해행위취소(형성의소)는 지연손해금 기산일 불요", "candidates": [] }, "end_date": { "value": None, "src": [], "status": "NOT_APPLICABLE", "missing_reason": "사해행위취소(형성의소)는 지연손해금 종기 불요", "candidates": [] } } start_candidates = [] end_candidates = [] # Gather relevant dates from facts related_facts = [] for fid, fdata in fact_index.items(): if claim_id in fdata.get("related_claims", []): related_facts.append(fid) for fl_entry in fact_ledger: fid = fl_entry.get("fact_id", "") if fid not in related_facts: continue d = parse_date_str(fl_entry.get("date")) if not d: continue bo_id = fl_entry.get("source_bo_id", "") action = fl_entry.get("action", "") src = [fid] if bo_id: src.append(bo_id) # Add evidence refs for eref in fl_entry.get("evidence_refs", []): eid_m = re.match(r'(E-\d+)', eref) if eid_m: src.append(eid_m.group(1)) ftype = fl_entry.get("type", "") # Start date heuristics if ftype in ("채무불이행", "기한도래"): start_candidates.append({ "value": d, "src": src, "origin": f"FL[{fid}] 채무불이행/기한도래", "note": "변제기 또는 부도일" }) elif "만기" in action or "기한" in action: start_candidates.append({ "value": d, "src": src, "origin": f"FL[{fid}] 만기/기한", "note": "만기일(기산일 후보)" }) elif "대위변제" in action: start_candidates.append({ "value": d, "src": src, "origin": f"FL[{fid}] 대위변제", "note": "대위변제일(구상금 기산일 후보)" }) # Also extract maturity from evidence key_info for eid, edata in evidence_index.items(): if claim_id not in edata.get("related_claims", []): continue for ev_raw in evidence_raw: if ev_raw.get("evidence_index") == eid: key_info = ev_raw.get("key_info", "") if "만기" in key_info: dates = extract_dates_from_text(key_info) for d in dates: start_candidates.append({ "value": d, "src": [eid], "origin": f"evidence[{eid}] 만기", "note": "증거 key_info 내 만기일" }) # Scan preclaim text for rate/date info claim_section = _extract_claim_section(claim_id, preclaim_text) if claim_section: dates_in_section = extract_dates_from_text(claim_section) tags_in_section = re.findall(r'([FE]-\d+|bh\d+)', claim_section) for d in dates_in_section: start_candidates.append({ "value": d, "src": tags_in_section[:3], "origin": f"청구전작업[{claim_id}]", "note": "청구전작업 내 날짜" }) # end_date: typically unknown (소장부본 송달일) end_result = { "value": None, "src": [], "status": "CALCULATION_PENDING", "missing_reason": "C2_FAIL: 종기(소장부본 송달일)는 소제기 후 확정되므로 현재 추출 불가", "candidates": [] } # Deduplicate start candidates start_candidates = _deduplicate_date_candidates(start_candidates) if not start_candidates: start_result = { "value": None, "src": [], "status": "CALCULATION_PENDING", "missing_reason": "C2_FAIL: 기산일을 문서 태그로 추적할 수 없음", "candidates": [] } else: best = start_candidates[0] # Already sorted start_result = { "value": best["value"], "src": best["src"], "status": "OK", "missing_reason": None, "candidates": start_candidates } return { "start_date": start_result, "end_date": end_result } # ══════════════════════════════════════════════════════════════════════════════ # 7) Fee Calculations (Stamp Fee + Service Fee) # ══════════════════════════════════════════════════════════════════════════════ def calc_stamp_fee(value: int) -> int: """2025 Korean court stamp fee schedule.""" if value < 10_000_000: return int(value * 0.0050) elif value < 100_000_000: return int(value * 0.0045 + 5_000) elif value < 1_000_000_000: return int(value * 0.0040 + 55_000) else: return int(value * 0.0035 + 555_000) def calc_service_fee(party_count: int) -> int: """Korean court service fee: 당사자수 × 15회분 × 5,200원""" return party_count * 15 * 5_200 def compute_fees( principal_value: Optional[int], claim_data: dict, parties: dict ) -> dict: """Compute stamp fee and service fee if principal is available.""" claim_type = claim_data.get("claim_type", "") # For 사해행위취소: claim value is the property value if _is_paulian_claim(claim_type): # Extract property value from summary or return pending return { "claim_value": { "value": principal_value, "status": "OK" if principal_value else "CALCULATION_PENDING", "missing_reason": None if principal_value else "사해행위취소 소가 산정은 목적물 가액 기준이나 현재 미확정" }, "stamp_fee": { "value": calc_stamp_fee(principal_value) if principal_value else None, "status": "OK" if principal_value else "CALCULATION_PENDING", "missing_reason": None if principal_value else "소가 미확정으로 인지대 산정 불가" }, "service_fee": _compute_service_fee(claim_data, parties) } if not principal_value: return { "claim_value": { "value": None, "status": "CALCULATION_PENDING", "missing_reason": "원금 미확정으로 소가 산정 불가" }, "stamp_fee": { "value": None, "status": "CALCULATION_PENDING", "missing_reason": "소가 미확정으로 인지대 산정 불가" }, "service_fee": _compute_service_fee(claim_data, parties) } stamp = calc_stamp_fee(principal_value) return { "claim_value": {"value": principal_value, "status": "OK", "missing_reason": None}, "stamp_fee": {"value": stamp, "status": "OK", "missing_reason": None}, "service_fee": _compute_service_fee(claim_data, parties) } def _compute_service_fee(claim_data: dict, parties: dict) -> dict: """Compute service fee from party count.""" # Count unique parties for this claim plaintiff_str = claim_data.get("plaintiff", "") defendant_str = claim_data.get("defendant", "") p_count = len([p.strip() for p in re.split(r'[,，]', plaintiff_str) if p.strip()]) d_count = len([d.strip() for d in re.split(r'[,，]', defendant_str) if d.strip()]) total_parties = max(p_count + d_count, 2) # At least 2 fee = calc_service_fee(total_parties) return { "value": fee, "party_count": total_parties, "status": "OK", "missing_reason": None } # ══════════════════════════════════════════════════════════════════════════════ # 8) Helper Functions # ══════════════════════════════════════════════════════════════════════════════ def _extract_claim_section(claim_id: str, preclaim_text: str) -> Optional[str]: """Extract the section for a specific claim from 청구전작업.md""" # Match patterns like "### (1) C-001:" or "| C-001 |" lines = preclaim_text.split("\n") in_section = False section_lines = [] for line in lines: if claim_id in line and ( re.match(r'###\s*\(?\d+\)?', line) or line.strip().startswith(f"| {claim_id}") ): in_section = True section_lines.append(line) continue if in_section: # End when next claim section starts if re.match(r'###\s*\(?\d+\)', line) and claim_id not in line: break if re.match(r'^---', line): break if re.match(r'^##\s+\d+\.', line): break section_lines.append(line) return "\n".join(section_lines) if section_lines else None def _deduplicate_candidates(candidates: list[dict]) -> list[dict]: """Deduplicate amount candidates by value, keeping the one with most src tags.""" if not candidates: return [] seen = {} for c in candidates: val = c["value"] if val not in seen or len(c.get("src", [])) > len(seen[val].get("src", [])): seen[val] = c # Sort: most src tags first, then highest value result = sorted(seen.values(), key=lambda x: (-len(x.get("src", [])), -x["value"])) return result def _deduplicate_date_candidates(candidates: list[dict]) -> list[dict]: """Deduplicate date candidates by value, keeping most tagged.""" if not candidates: return [] seen = {} for c in candidates: val = c["value"] key = val if key not in seen or len(c.get("src", [])) > len(seen[key].get("src", [])): seen[key] = c return sorted(seen.values(), key=lambda x: (-len(x.get("src", [])), x["value"])) def _select_best_candidate(candidates: list[dict]) -> dict: """Select the best amount candidate: most tags, then largest value.""" if not candidates: return {"value": None, "src": []} return candidates[0] # Already sorted by _deduplicate_candidates # ══════════════════════════════════════════════════════════════════════════════ # 9) Gate Assessment # ══════════════════════════════════════════════════════════════════════════════ def assess_compute_gate(claim_entry: dict) -> dict: """ Assess the 3-condition gate for deterministic computation: C1: python code execution → always True C2: principal/rate/start/end all traceable to tags C3: normative rate basis confirmed """ principal = claim_entry.get("principal", {}) rate = claim_entry.get("rate", {}) dates = claim_entry.get("dates", {}) start = dates.get("start_date", {}) end = dates.get("end_date", {}) c1 = True # Always true (we're running python) c2_principal = principal.get("status") == "OK" and bool(principal.get("src")) c2_rate = (rate.get("status") == "OK") c2_start = (start.get("status") in ("OK", "NOT_APPLICABLE")) c2_end = (end.get("status") in ("OK", "NOT_APPLICABLE")) c2 = c2_principal and c2_rate and c2_start and c2_end # C3: rate basis is confirmed rec_rate = rate.get("recommended_rate") statutory = rate.get("statutory_rate", {}) is_paulian = (statutory.get("basis", "").startswith("사해행위취소") or start.get("status") == "NOT_APPLICABLE") c3 = (is_paulian or # 사해행위취소는 지연손해금 산정 불요 (rec_rate is not None and rec_rate.get("annual_pct") is not None)) gate_pass = c1 and c2 and c3 missing_conditions = [] if not c2_principal: missing_conditions.append("C2: principal 추적 불가") if not c2_rate: missing_conditions.append("C2: rate 추적 불가") if not c2_start: missing_conditions.append("C2: start_date 추적 불가") if not c2_end: missing_conditions.append("C2: end_date 추적 불가") if not c3: missing_conditions.append("C3: 이율 규범값 근거 미확정") return { "gate_pass": gate_pass, "C1": c1, "C2": c2, "C3": c3, "missing_conditions": missing_conditions } # ══════════════════════════════════════════════════════════════════════════════ # 10) Main Builder # ══════════════════════════════════════════════════════════════════════════════ def build_compute_inputs( index: dict, fact_ledger: list[dict], evidence_raw: list[dict], preclaim_text: str ) -> dict: """Build the complete stage4_compute_inputs.json structure.""" claim_index = index["claim_index"] fact_index = index["fact_index"] evidence_index = index["evidence_index"] top_n = index["top_n_claims"] parties = index.get("parties", {}) claims = [] for claim_id in top_n: claim_data = claim_index.get(claim_id, {}) # Extract principal principal = extract_principal_candidates( claim_id, claim_data, fact_index, evidence_index, fact_ledger, preclaim_text ) # Extract rate rate = extract_rate_candidates( claim_id, claim_data, evidence_index, evidence_raw, fact_ledger, fact_index, preclaim_text ) # Extract dates dates = extract_date_candidates( claim_id, claim_data, fact_index, fact_ledger, evidence_index, evidence_raw, preclaim_text ) # Compute fees fees = compute_fees(principal.get("value"), claim_data, parties) # Build claim entry entry = { "claim_id": claim_id, "claim_type": claim_data.get("claim_type", ""), "principal": { "value": principal["value"], "src": principal["src"], "status": principal["status"], "missing_reason": principal["missing_reason"], }, "rate": { "contractual_rate": rate["contractual_rate"], "statutory_rate": rate["statutory_rate"], "recommended_rate": rate["recommended_rate"], "status": rate["status"], "missing_reason": rate["missing_reason"], }, "dates": { "start_date": { "value": dates["start_date"]["value"], "src": dates["start_date"]["src"], "status": dates["start_date"]["status"], "missing_reason": dates["start_date"]["missing_reason"], }, "end_date": { "value": dates["end_date"]["value"], "src": dates["end_date"]["src"], "status": dates["end_date"]["status"], "missing_reason": dates["end_date"]["missing_reason"], } }, "fees": fees, } # Assess gate entry["gate"] = assess_compute_gate(entry) # Include candidate details for transparency if principal.get("candidates"): entry["principal"]["candidates"] = principal["candidates"] if dates["start_date"].get("candidates"): entry["dates"]["start_date"]["candidates"] = dates["start_date"]["candidates"] claims.append(entry) # Formulas reference (for downstream use) formulas = { "delay_damages": "principal * (annual_rate / 100) * (days / 365)", "stamp_fee": "2025 schedule: <10M→0.50%, <100M→0.45%+5k, <1B→0.40%+55k, ≥1B→0.35%+555k", "service_fee": "party_count × 15 × 5,200원" } return { "meta": { "stage": "4", "phase": "A-3", "generated_at": datetime.now().strftime("%Y-%m-%d"), "description": "Deterministic compute inputs per claim (§4 GATED COMPUTE)", "gate_conditions": { "C1": "python code execution (always true)", "C2": "principal/rate/start/end traceable to document tags", "C3": "normative rate basis confirmed (contractual ≤24% or statutory)" } }, "formulas": formulas, "claims": claims } # ══════════════════════════════════════════════════════════════════════════════ # 11) Validation # ══════════════════════════════════════════════════════════════════════════════ class ValidationReport: def __init__(self): self.errors: list[str] = [] self.warnings: list[str] = [] self.info: list[str] = [] self.ok = True def error(self, msg: str): self.errors.append(msg) self.ok = False def warn(self, msg: str): self.warnings.append(msg) def add_info(self, msg: str): self.info.append(msg) def print_report(self): print("\n=== stage4_compute_inputs Validation ===", file=sys.stderr) for e in self.errors: print(f" ERROR: {e}", file=sys.stderr) for w in self.warnings: print(f" WARN: {w}", file=sys.stderr) for i in self.info: print(f" INFO: {i}", file=sys.stderr) status = "PASS" if self.ok else "FAIL" print(f" Status: {status} " f"({len(self.errors)} errors, {len(self.warnings)} warnings)", file=sys.stderr) def validate_compute_inputs(result: dict, index: dict) -> ValidationReport: """Validate the generated compute inputs.""" rpt = ValidationReport() claims = result.get("claims", []) top_n = index.get("top_n_claims", []) # V1: All top_n claims present claim_ids_present = {c["claim_id"] for c in claims} for cid in top_n: if cid not in claim_ids_present: rpt.error(f"V1: top_n claim {cid} missing from compute_inputs") # V2: No extra claims for cid in claim_ids_present: if cid not in top_n: rpt.warn(f"V2: claim {cid} in compute_inputs but not in top_n") for claim in claims: cid = claim["claim_id"] # V3: Principal sources are valid tags for src in claim.get("principal", {}).get("src", []): if not re.match(r'^(F-\d+|E-\d+|bh\d+|C-\d+)$', src): rpt.warn(f"V3: {cid} principal src '{src}' is not a standard tag") # V4: Rate has valid structure rate = claim.get("rate", {}) if rate.get("status") == "OK": rec = rate.get("recommended_rate") if rec and rec.get("annual_pct") is not None: if rec["annual_pct"] > 24.0: rpt.error(f"V4: {cid} rate {rec['annual_pct']}% exceeds 24% cap") if rec["annual_pct"] < 0: rpt.error(f"V4: {cid} rate {rec['annual_pct']}% is negative") # V5: Date format for dk in ("start_date", "end_date"): d = claim.get("dates", {}).get(dk, {}) val = d.get("value") if val and not re.match(r'^\d{4}-\d{2}-\d{2}$', val): rpt.error(f"V5: {cid} {dk} '{val}' is not ISO date format") # V6: Gate assessment consistency gate = claim.get("gate", {}) if gate.get("gate_pass"): if claim["principal"]["status"] != "OK": rpt.error(f"V6: {cid} gate_pass=true but principal status != OK") # V7: Fee calculations fees = claim.get("fees", {}) stamp = fees.get("stamp_fee", {}) if stamp.get("value") is not None and stamp["value"] < 0: rpt.error(f"V7: {cid} stamp_fee is negative") svc = fees.get("service_fee", {}) if svc.get("value") is not None: if svc["value"] <= 0: rpt.warn(f"V7: {cid} service_fee is zero or negative") # V8: missing_reason present when status != OK for field_name in ("principal",): field = claim.get(field_name, {}) if field.get("status") == "CALCULATION_PENDING" and not field.get("missing_reason"): rpt.warn(f"V8: {cid} {field_name} is PENDING but no missing_reason") # Summary gate_pass_count = sum(1 for c in claims if c.get("gate", {}).get("gate_pass")) rpt.add_info(f"Total claims: {len(claims)}") rpt.add_info(f"Gate PASS: {gate_pass_count}/{len(claims)}") rpt.add_info(f"Gate FAIL: {len(claims) - gate_pass_count}/{len(claims)}") return rpt def _log(msg: str): """진행/디버그 메시지 → stderr (stdout은 결과 JSON 전용).""" print(msg, file=sys.stderr) # ══════════════════════════════════════════════════════════════════════════════ # 12) Entry Point # ══════════════════════════════════════════════════════════════════════════════ def main(): output_name = "stage4_compute_inputs.json" do_validate = True with httpx.Client(timeout=60) as c: # ===== 1) localdocs 연결 ===== r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "stage4-compute-inputs-gen", "version": "1.0"} } }, headers=HEADERS) sid = r.headers.get("mcp-session-id") if sid: HEADERS["mcp-session-id"] = sid c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "method": "notifications/initialized" }, headers=HEADERS) _log(f"1) Connected to localdocs (session: {sid})") # 도구 목록 확인 r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }, headers=HEADERS) tools_result = parse_sse(r.text) tools = (tools_result.get("result", {}).get("tools", []) if tools_result else []) _log(f" Tools: {[t['name'] for t in tools]}") write_tool = next( (t for t in tools if "write" in t["name"]), None) # 문서 목록 docs = call_tool(c, "list_docs", {}, 3) if docs and "result" in docs: _log(f" Docs: {docs['result']['content'][0]['text'][:500]}") # ===== 2) 파일 로딩 (MCP read_doc) ===== _log("\n2) Loading input files via MCP...") index = read_doc(c, "stage4_index.json", 10) if index is None: raise RuntimeError("Failed to load stage4_index.json") fact_ledger = read_doc(c, "Fact_Ledger.json", 11) if fact_ledger is None: fact_ledger = read_doc(c, "fact_ledger.json", 12) if fact_ledger is None: raise RuntimeError("Failed to load Fact_Ledger.json") evidence_raw = read_doc(c, "evidence_indexed.json", 13) if evidence_raw is None: raise RuntimeError("Failed to load evidence_indexed.json") preclaim_text = read_doc_text(c, "청구전작업.md", 14) or "" for name, data in [("stage4_index.json", index), ("Fact_Ledger.json", fact_ledger), ("evidence_indexed.json", evidence_raw)]: size = len(data) if hasattr(data, '__len__') else '?' _log(f" {name}: loaded ({type(data).__name__}, len={size})") _log(f" 청구전작업.md: {'loaded' if preclaim_text else 'not found'}") # ===== 3) 빌드 ===== _log("\n3) Building compute inputs...") result = build_compute_inputs(index, fact_ledger, evidence_raw, preclaim_text) # ===== 4) 검증 ===== if do_validate: rpt = validate_compute_inputs(result, index) rpt.print_report() # ===== 5) 결과 저장 (MCP write_doc + stdout) ===== output_json = json.dumps(result, ensure_ascii=False, indent=2) if write_tool: write_result = call_tool(c, write_tool["name"], { "path": output_name, "content": output_json, }, 20) if write_result and "result" in write_result: _log(f"\n4) Written to localdocs: {output_name}") else: _log("\n4) Write to localdocs failed") else: _log("\n4) No write tool available") # 항상 stdout으로 출력 (code-executor가 캡처) print(output_json) if __name__ == "__main__": main() requirements: "httpx" network: "agent-network" timeout: 120 - task_name: run_claim_packets mcp: code-executor tool_name: run_code parameters: language: python code: | #!/usr/bin/env python3 """ stage4_claim_packets.py — Stage 4, Phase A-2 (Generalized) Reads inputs via MCP localdocs and produces stage4_claim_packets.json. Runs inside code-executor Docker container. """ import json import re import sys from datetime import datetime from typing import Any import httpx # ----------------------------------------------------------------------------- # 0) MCP localdocs helpers # ----------------------------------------------------------------------------- LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" HEADERS = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } def parse_sse(text): for line in text.strip().split("\n"): if line.startswith("data: "): return json.loads(line[6:]) try: return json.loads(text) except Exception: return None def call_tool(c, name, arguments, msg_id=10): r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": msg_id, "method": "tools/call", "params": {"name": name, "arguments": arguments} }, headers=HEADERS) result = parse_sse(r.text) if result and "result" in result: return result print(f"Tool {name} error: {json.dumps(result)[:300]}", file=sys.stderr) return result def read_doc(c, doc_name, msg_id=10): """Read a JSON document via MCP localdocs.""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] if not text or not text.strip(): return None try: return json.loads(text) except json.JSONDecodeError: print(f"read_doc({doc_name}): JSON parse failed", file=sys.stderr) return None return None def read_doc_text(c, doc_name, msg_id=10): """Read a text/markdown document via MCP localdocs (no JSON parse).""" result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] return text if text and text.strip() else None return None # ----------------------------------------------------------------------------- # 2) Lightweight JSON Schema Validator (subset) # ----------------------------------------------------------------------------- JSON_TYPE_MAP = { "object": dict, "array": list, "string": str, "number": (int, float), "integer": int, "boolean": bool, "null": type(None), } def _type_ok(value: Any, schema_type: str) -> bool: py_t = JSON_TYPE_MAP.get(schema_type) if py_t is None: return True if schema_type == "integer": return isinstance(value, int) and not isinstance(value, bool) if schema_type == "number": return (isinstance(value, (int, float)) and not isinstance(value, bool)) return isinstance(value, py_t) def validate_schema(instance: Any, schema: dict, path: str = "$") -> list[str]: errors: list[str] = [] expected = schema.get("type") if expected and not _type_ok(instance, expected): errors.append(f"{path}: expected type '{expected}', got '{type(instance).__name__}'") return errors enum = schema.get("enum") if enum is not None and instance not in enum: errors.append(f"{path}: value '{instance}' is not in enum {enum}") if isinstance(instance, dict): required = schema.get("required", []) for key in required: if key not in instance: errors.append(f"{path}: missing required key '{key}'") props = schema.get("properties", {}) additional = schema.get("additionalProperties", True) for k, v in instance.items(): if k in props: errors.extend(validate_schema(v, props[k], f"{path}.{k}")) else: if isinstance(additional, dict): errors.extend(validate_schema(v, additional, f"{path}.{k}")) elif additional is False: errors.append(f"{path}: additional property '{k}' not allowed") if isinstance(instance, list): min_items = schema.get("minItems") max_items = schema.get("maxItems") if min_items is not None and len(instance) < min_items: errors.append(f"{path}: expected minItems={min_items}, got {len(instance)}") if max_items is not None and len(instance) > max_items: errors.append(f"{path}: expected maxItems={max_items}, got {len(instance)}") item_schema = schema.get("items") if item_schema: for i, item in enumerate(instance): errors.extend(validate_schema(item, item_schema, f"{path}[{i}]")) pattern = schema.get("pattern") if pattern and isinstance(instance, str): if re.match(pattern, instance) is None: errors.append(f"{path}: string '{instance}' does not match /{pattern}/") return errors # ----------------------------------------------------------------------------- # 3) Rules Engine Utilities # ----------------------------------------------------------------------------- def build_synonym_map(rules: dict) -> dict[str, set[str]]: syn_map: dict[str, set[str]] = {} for group in rules.get("synonym_groups", []): gset = set(group) for token in gset: syn_map.setdefault(token, set()).update(gset) return syn_map def tokenize_ko(text: str, rules: dict) -> set[str]: tokenizer = rules.get("tokenizer", {}) stopwords = set(tokenizer.get("stopwords", [])) suffixes = tokenizer.get("suffixes", []) raw_tokens = re.findall(r"[가-힣A-Za-z0-9]+", text or "") out: set[str] = set() for tok in raw_tokens: if len(tok) < 2 or tok in stopwords: continue out.add(tok) for suf in suffixes: if tok.endswith(suf) and len(tok) > len(suf) + 1: stripped = tok[:-len(suf)] if len(stripped) >= 2: out.add(stripped) break return out def overlap_score(a: str, b: str, rules: dict, syn_map: dict[str, set[str]]) -> int: ta = tokenize_ko(a, rules) tb = tokenize_ko(b, rules) direct = len(ta & tb) exp_a = set(ta) exp_b = set(tb) for t in ta: if t in syn_map: exp_a.update(syn_map[t]) for t in tb: if t in syn_map: exp_b.update(syn_map[t]) extra = len((exp_a & tb) | (ta & exp_b)) - direct return direct * 2 + max(extra, 0) def claim_text(cdata: dict) -> str: return " ".join([ cdata.get("claim_type", ""), cdata.get("summary", ""), cdata.get("plaintiff", ""), cdata.get("defendant", ""), ]).strip() def _matches_any(patterns: list[str], text: str) -> bool: return any(re.search(p, text, flags=re.IGNORECASE) for p in patterns) def detect_case_group(claim_id: str, claim_data: dict, legal_elements: dict, rules: dict) -> str: """ Strategy 2: case-group detection + fallback to general. Score groups by claim_type and element text matches. """ groups = rules.get("case_groups", []) ctext = claim_data.get("claim_type", "") elem_texts = [] for _, ed in legal_elements.items(): if claim_id in ed.get("applicable_claims", []): elem_texts.append( (ed.get("element", "") + " " + ed.get("description", "")).strip()) elem_blob = "\n".join(elem_texts) best_group = "general" best_score = 0 for g in groups: gid = g.get("id", "") if not gid: continue c_weight = int(g.get("claim_type_weight", 3)) e_weight = int(g.get("element_weight", 1)) score = 0 c_pats = g.get("claim_type_patterns", []) e_pats = g.get("element_patterns", []) if c_pats and _matches_any(c_pats, ctext): score += c_weight if e_pats and elem_blob: em = 0 for p in e_pats: if re.search(p, elem_blob, flags=re.IGNORECASE): em += 1 score += em * e_weight if score > best_score: best_score = score best_group = gid return best_group if best_score > 0 else "general" # ----------------------------------------------------------------------------- # 4) Plugin System # ----------------------------------------------------------------------------- class PluginContext: def __init__(self, claim_id: str, claim_data: dict, claim_index: dict, fact_index: dict, legal_elements: dict, rules: dict, syn_map: dict[str, set[str]]): self.claim_id = claim_id self.claim_data = claim_data self.claim_index = claim_index self.fact_index = fact_index self.legal_elements = legal_elements self.rules = rules self.syn_map = syn_map class BasePlugin: """Generic/unbiased baseline plugin.""" def __init__(self, group_id: str, plugin_rules: dict): self.group_id = group_id self.plugin_rules = plugin_rules def expand_candidate_claims(self, ctx: PluginContext) -> set[str]: # Generic: no expansion. Keep unbiased default. return {ctx.claim_id} def fact_bonus(self, element_text: str, fact_text: str) -> int: # Apply boost rules from external config only. bonus = 0 for br in self.plugin_rules.get("fact_boost_rules", []): ep = br.get("element_any", []) fp = br.get("fact_any", []) sc = int(br.get("score", 0)) if ep and not _matches_any(ep, element_text): continue if fp and not _matches_any(fp, fact_text): continue bonus += sc return bonus def special_modules(self) -> list[str]: mods = self.plugin_rules.get("special_modules", []) return sorted(set([m for m in mods if isinstance(m, str)])) def build_special_actions(self, claim_data: dict, claim_index: dict, fact_index: dict, fact_ledger: list[dict], legal_elements: dict) -> list[dict]: return [] class LoanPlugin(BasePlugin): pass class GuaranteePlugin(BasePlugin): pass class GeneralPlugin(BasePlugin): pass class PaulianPlugin(BasePlugin): def expand_candidate_claims(self, ctx: PluginContext) -> set[str]: # include own claim + preserved candidates discovered by shared facts/similar text cands = {ctx.claim_id} own_text = claim_text(ctx.claim_data) # text-similar siblings for cid2, cdata2 in ctx.claim_index.items(): if cid2 == ctx.claim_id: continue s = overlap_score(own_text, claim_text(cdata2), ctx.rules, ctx.syn_map) if s >= 4: cands.add(cid2) # fact-linked siblings own_related_facts = [ fid for fid, fdata in ctx.fact_index.items() if ctx.claim_id in fdata.get("related_claims", []) ] for fid in own_related_facts: for rcid in ctx.fact_index.get(fid, {}).get("related_claims", []): cands.add(rcid) return cands def _build_fact_ledger_maps(self, fact_ledger: list[dict]) -> tuple[dict, dict]: by_fact = {} by_bo = {} for row in fact_ledger: fid = row.get("fact_id", "") bo = row.get("source_bo_id", "") if fid: by_fact[fid] = row if bo: by_bo[bo] = row return by_fact, by_bo def _pick_preserved_claim_link(self, claim_id: str, claim_index: dict, fact_index: dict) -> str: # pick non-paulian claim most connected via shared fact relations candidates = [] for cid, cdata in claim_index.items(): if cid == claim_id: continue ct = cdata.get("claim_type", "") if _matches_any(self.plugin_rules.get("claim_type_patterns", []), ct): continue candidates.append(cid) if not candidates: return "" best = "" best_score = -1 for cid in candidates: score = 0 for _, fdata in fact_index.items(): rc = set(fdata.get("related_claims", [])) if claim_id in rc and cid in rc: score += 1 if score > best_score: best_score = score best = cid return best def build_special_actions(self, claim_data: dict, claim_index: dict, fact_index: dict, fact_ledger: list[dict], legal_elements: dict) -> list[dict]: transfer_patterns = self.plugin_rules.get("transfer_patterns", []) act_patterns = self.plugin_rules.get("act_type_patterns", []) claim_id = claim_data.get("claim_id", "") if not claim_id: return [] by_fact, by_bo = self._build_fact_ledger_maps(fact_ledger) rows = [] for fid, fdata in fact_index.items(): if not str(fid).startswith("F-"): continue if claim_id not in fdata.get("related_claims", []): continue fl = by_fact.get(fid) if not fl: fl = by_bo.get(fdata.get("source_bo_id", ""), {}) summary = fdata.get("summary", "") action = fl.get("action", "") combined = f"{summary} {action}".strip() if _matches_any(transfer_patterns, combined): rows.append((fid, fdata, fl, combined)) if not rows: return [] preserved_link = self._pick_preserved_claim_link(claim_id, claim_index, fact_index) defendants = [d.strip() for d in claim_data.get("defendant", "").split(",") if d.strip()] remedy = "주위(원물반환)" ctype = claim_data.get("claim_type", "") if _matches_any([r"전득자", r"가액배상", r"예비"], ctype): remedy = "주위(원물반환)|예비(가액배상)" out = [] for i, (fid, fdata, fl, combined) in enumerate(sorted(rows, key=lambda x: x[0]), start=1): act_type = "기타" for pat, name in act_patterns: if re.search(pat, combined): act_type = name break beneficiary = "" parties = fl.get("parties", []) if isinstance(fl.get("parties", []), list) else [] for p in parties: if p in defendants: beneficiary = p break if not beneficiary: beneficiary = defendants[0] if defendants else "불명" obj = combined[:40] if combined else claim_data.get("summary", "")[:40] loc = re.search( r"((?:[\w]+(?:시|구|군|동|리)\s*){0,4}[\w\s]*?(?:아파트|토지|건물|부동산|대지|주택))", combined ) if loc: obj = loc.group(1).strip() obj = f"{obj} ({fid})" date = fl.get("date", "") time = f"{date} ({fid})" if date else "불명" ev_ids = [] for eref in fdata.get("evidence_refs", []): m = re.match(r"(E-\d+)", str(eref)) if m: ev_ids.append(m.group(1)) src = [fid] + ev_ids src = list(dict.fromkeys(src)) out.append({ "paul_id": f"PAUL-{i}", "act_type": act_type, "object": obj, "time": time, "beneficiary_or_transferee": f"{beneficiary} ({fid})", "preserved_claim_link": preserved_link, "remedy_structure": remedy, "src": src, }) return out def build_plugin_registry(rules: dict) -> dict[str, BasePlugin]: plugin_cfg = rules.get("plugins", {}) reg: dict[str, BasePlugin] = { "general": GeneralPlugin("general", plugin_cfg.get("general", {})), "loan": LoanPlugin("loan", plugin_cfg.get("loan", {})), "guarantee": GuaranteePlugin("guarantee", plugin_cfg.get("guarantee", {})), "paulian": PaulianPlugin("paulian", plugin_cfg.get("paulian", {})), } return reg # ----------------------------------------------------------------------------- # 5) Core Selection Logic (A-2 contract) # ----------------------------------------------------------------------------- def select_elements_for_claim(claim_id: str, legal_elements: dict, max_elements: int) -> list[dict]: matched: list[tuple[int, str, dict]] = [] for eid, edata in legal_elements.items(): if claim_id in edata.get("applicable_claims", []): m = re.search(r"P(\d+)$", eid) pnum = int(m.group(1)) if m else 999 matched.append((pnum, eid, edata)) matched.sort(key=lambda x: (x[0], x[1])) return [{ "element_id": eid, "element": edata.get("element", ""), "description": edata.get("description", ""), } for _, eid, edata in matched[:max_elements]] def _credibility_bonus(cred: str, rules: dict, case_group: str) -> int: cfg = rules.get("plugins", {}).get(case_group, {}) table = cfg.get("credibility_bonus", {}) return int(table.get((cred or "").lower(), 0)) def gather_candidate_facts( claim_id: str, claim_data: dict, case_group: str, plugin: BasePlugin, element: dict, claim_index: dict, fact_index: dict, legal_elements: dict, rules: dict, syn_map: dict[str, set[str]], max_facts: int, ) -> list[str]: elem_text = (element.get("element", "") + " " + element.get("description", "")).strip() ctx = PluginContext( claim_id=claim_id, claim_data=claim_data, claim_index=claim_index, fact_index=fact_index, legal_elements=legal_elements, rules=rules, syn_map=syn_map, ) candidate_claims = plugin.expand_candidate_claims(ctx) # General fallback if plugin returns empty unexpectedly if not candidate_claims: candidate_claims = {claim_id} has_direct = any( claim_id in fdata.get("related_claims", []) for _, fdata in fact_index.items() ) if not has_direct: # deterministic sibling augmentation base = claim_text(claim_data) for cid2, cdata2 in claim_index.items(): if cid2 == claim_id: continue if overlap_score(base, claim_text(cdata2), rules, syn_map) >= 4: candidate_claims.add(cid2) scored: list[tuple[int, str]] = [] for fid, fdata in fact_index.items(): if not str(fid).startswith("F-"): continue related = set(fdata.get("related_claims", [])) if not related.intersection(candidate_claims): continue fact_text = fdata.get("summary", "") score = overlap_score(elem_text, fact_text, rules, syn_map) # Strategy 3 baseline: overlap + traceability + deterministic tie-break. if fdata.get("evidence_refs"): score += 1 # plugin/rule bonus score += _credibility_bonus(fdata.get("credibility", ""), rules, case_group) score += plugin.fact_bonus(elem_text, fact_text) scored.append((score, fid)) scored.sort(key=lambda x: (-x[0], x[1])) return [fid for _, fid in scored[:max_facts]] def gather_candidate_evidence( claim_id: str, element: dict, fact_candidates: list[str], fact_index: dict, evidence_index: dict, rules: dict, syn_map: dict[str, set[str]], max_evidence: int, ) -> list[str]: elem_text = (element.get("element", "") + " " + element.get("description", "")).strip() scores: dict[str, int] = {} # traceability first: from selected facts for fid in fact_candidates: fdata = fact_index.get(fid, {}) for eref in fdata.get("evidence_refs", []): m = re.match(r"(E-\d+)", str(eref)) if not m: continue eid = m.group(1) if eid in evidence_index: scores[eid] = scores.get(eid, 0) + 2 # claim-level evidence for eid, edata in evidence_index.items(): if claim_id in edata.get("related_claims", []): scores[eid] = scores.get(eid, 0) + 1 # add overlap for determinism against element content for eid in list(scores.keys()): ed = evidence_index.get(eid, {}) ev_text = " ".join([ ed.get("title", ""), ed.get("doc_type", ""), " ".join(ed.get("key_facts", [])), ]).strip() scores[eid] += overlap_score(elem_text, ev_text, rules, syn_map) ranked = sorted(scores.items(), key=lambda x: (-x[1], x[0])) return [eid for eid, _ in ranked[:max_evidence]] # ----------------------------------------------------------------------------- # 6) Optional fields builders # ----------------------------------------------------------------------------- def _build_fact_ledger_maps(fact_ledger: list[dict]) -> tuple[dict, dict]: by_fact = {} by_bo = {} for row in fact_ledger: fid = row.get("fact_id", "") bo = row.get("source_bo_id", "") if fid: by_fact[fid] = row if bo: by_bo[bo] = row return by_fact, by_bo def _derive_fact_parties(fid: str, fdata: dict, by_fact: dict, by_bo: dict) -> list[str]: row = by_fact.get(fid) if not row: row = by_bo.get(fdata.get("source_bo_id", ""), {}) parts = row.get("parties", []) if isinstance(row.get("parties", []), list) else [] return [p for p in parts if isinstance(p, str) and p.strip()] def build_claim_parties(claim_id: str, claim_data: dict, fact_index: dict, fact_ledger: list[dict], global_parties: dict) -> dict: plaintiff = claim_data.get("plaintiff", "") defendant_str = claim_data.get("defendant", "") defendants = [d.strip() for d in defendant_str.split(",") if d.strip()] by_fact, by_bo = _build_fact_ledger_maps(fact_ledger) known_pl = set(global_parties.get("plaintiffs", [])) known_def = set(global_parties.get("defendants", [])) excluded = set(global_parties.get("excluded", [])) third = set() for fid, fdata in fact_index.items(): if not str(fid).startswith("F-"): continue if claim_id not in fdata.get("related_claims", []): continue for p in _derive_fact_parties(fid, fdata, by_fact, by_bo): if (p not in known_pl and p not in known_def and p not in excluded and p not in defendants): third.add(p) return { "plaintiff": plaintiff, "defendants": defendants, "third_parties": sorted(third), } def detect_procedural_for_claim(claim_id: str, preclaim_text: str, all_proc: list[str], rules: dict) -> list[str]: kws = rules.get("procedural_keywords", []) found = set() scan = preclaim_text or "" for kw in kws: if kw in scan and (claim_id in scan or kw in all_proc): found.add(kw) for kw in all_proc: if kw in kws: found.add(kw) return sorted(found) def extract_warnings(claim_id: str, preclaim_text: str) -> list[str]: out = [] in_warn = False for line in (preclaim_text or "").split("\n"): if re.match(r"^##\s+8\.\s+VALIDATION", line, flags=re.IGNORECASE): in_warn = True continue if in_warn and re.match(r"^##\s+\d+\.", line): break if not in_warn: continue m = re.match(r"\s*[-*]\s*\*\*(WARNING-\d+)\*\*:\s*(.*)", line) if not m: continue wid = m.group(1) wtxt = m.group(2).strip() if claim_id in wtxt or _warning_applies(claim_id, wtxt): out.append(f"{wid}: {wtxt}") return out def _warning_applies(claim_id: str, warn_text: str) -> bool: m = re.search(r"C-(\d+)", claim_id or "") if not m: return False num = int(m.group(1)) for s, e in re.findall(r"C-(\d+)\s*[~～]\s*C-(\d+)", warn_text): if int(s) <= num <= int(e): return True return claim_id in re.findall(r"C-\d+", warn_text) # ----------------------------------------------------------------------------- # 7) Builder # ----------------------------------------------------------------------------- def build_claim_packets(index: dict, fact_ledger: list[dict], preclaim_text: str, rules: dict, max_elements: int = 6, max_facts: int = 3, max_evidence: int = 3, rules_name: str = "claim_scoring_rules.json") -> dict: claim_index = index.get("claim_index", {}) fact_index = index.get("fact_index", {}) evidence_index = index.get("evidence_index", {}) legal_elements = index.get("legal_elements_index", {}) top_n = index.get("top_n_claims", []) parties = index.get("parties", {}) all_proc = index.get("procedural_structures", []) syn_map = build_synonym_map(rules) plugins = build_plugin_registry(rules) packets = [] global_paul_counter = 0 for claim_id in top_n: cdata = claim_index.get(claim_id, {}) ctype = cdata.get("claim_type", "") case_group = detect_case_group(claim_id, cdata, legal_elements, rules) plugin = plugins.get(case_group, plugins["general"]) elements_src = select_elements_for_claim(claim_id, legal_elements, max_elements) elements = [] for elem in elements_src: facts = gather_candidate_facts( claim_id=claim_id, claim_data=cdata, case_group=case_group, plugin=plugin, element=elem, claim_index=claim_index, fact_index=fact_index, legal_elements=legal_elements, rules=rules, syn_map=syn_map, max_facts=max_facts, ) evidences = gather_candidate_evidence( claim_id=claim_id, element=elem, fact_candidates=facts, fact_index=fact_index, evidence_index=evidence_index, rules=rules, syn_map=syn_map, max_evidence=max_evidence, ) elements.append({ "element_id": elem["element_id"], "element": elem["element"], "fact_candidates": facts, "evidence_candidates": evidences, }) claim_parties = build_claim_parties( claim_id, cdata, fact_index, fact_ledger, parties) proc = detect_procedural_for_claim( claim_id, preclaim_text, all_proc, rules) modules = plugin.special_modules() # paulian action expansion via plugin only cdata_with_id = dict(cdata) cdata_with_id["claim_id"] = claim_id actions = plugin.build_special_actions( claim_data=cdata_with_id, claim_index=claim_index, fact_index=fact_index, fact_ledger=fact_ledger, legal_elements=legal_elements, ) for act in actions: global_paul_counter += 1 act["paul_id"] = f"PAUL-{global_paul_counter}" warns = extract_warnings(claim_id, preclaim_text) summary = cdata.get("summary", "") summary_clean = re.sub(r"\s*\((?:[FE]-\d+(?:,\s*)?)+\)", "", summary).strip() packet = { "claim_id": claim_id, "claim_type": ctype, "case_group": case_group, "rank": cdata.get("rank", 0), "total_score": cdata.get("total_score", 0), "plaintiff": cdata.get("plaintiff", ""), "defendant": cdata.get("defendant", ""), "summary": summary_clean, "elements": elements, "parties": claim_parties, "procedural_structures": proc, "special_claim_modules": modules, "paulian_actions": actions, } if warns: packet["warnings"] = warns packets.append(packet) return { "meta": { "stage": "4", "phase": "A-2", "top_n": len(top_n), "generated_at": datetime.now().strftime("%Y-%m-%d"), "rules_file": rules_name, }, "claim_packets": packets, } # ----------------------------------------------------------------------------- # 8) Validation # ----------------------------------------------------------------------------- class ValidationReport: def __init__(self): self.errors: list[str] = [] self.warnings: list[str] = [] def error(self, msg: str): self.errors.append(msg) def warn(self, msg: str): self.warnings.append(msg) @property def ok(self) -> bool: return len(self.errors) == 0 def print_report(self): if self.ok and not self.warnings: print("[VALIDATE] ✓ All checks passed.", file=sys.stderr) return if self.errors: print(f"[VALIDATE] ✗ {len(self.errors)} error(s):", file=sys.stderr) for e in self.errors: print(f" ERROR: {e}", file=sys.stderr) if self.warnings: print(f"[VALIDATE] △ {len(self.warnings)} warning(s):", file=sys.stderr) for w in self.warnings: print(f" WARN: {w}", file=sys.stderr) def validate_contracts(index: dict, result: dict, index_schema: dict, output_schema: dict, max_elements: int = 6, max_facts: int = 3, max_evidence: int = 3) -> ValidationReport: rpt = ValidationReport() i_errors = validate_schema(index, index_schema) for e in i_errors: rpt.error(f"INDEX_SCHEMA: {e}") o_errors = validate_schema(result, output_schema) for e in o_errors: rpt.error(f"OUTPUT_SCHEMA: {e}") # Additional strict count checks top_n = index.get("top_n_claims", []) packets = result.get("claim_packets", []) if len(top_n) != len(packets): rpt.error( f"A-2 cardinality mismatch: top_n={len(top_n)} packets={len(packets)}") packet_map = {p.get("claim_id", ""): p for p in packets} for cid in top_n: if cid not in packet_map: rpt.error(f"Missing packet for top_n claim: {cid}") for p in packets: cid = p.get("claim_id", "") elements = p.get("elements", []) if len(elements) > max_elements: rpt.error(f"{cid}: elements>{max_elements}") for el in elements: if len(el.get("fact_candidates", [])) > max_facts: rpt.error(f"{cid}/{el.get('element_id')}: fact_candidates>{max_facts}") if len(el.get("evidence_candidates", [])) > max_evidence: rpt.error(f"{cid}/{el.get('element_id')}: evidence_candidates>{max_evidence}") return rpt def _log(msg: str): """진행/디버그 메시지 → stderr (stdout은 결과 JSON 전용).""" print(msg, file=sys.stderr) # ----------------------------------------------------------------------------- # 9) Main # ----------------------------------------------------------------------------- def main(): output_name = "stage4_claim_packets.json" max_elements = 6 max_facts = 3 max_evidence = 3 do_validate = True with httpx.Client(timeout=60) as c: # ===== 1) localdocs 연결 ===== r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "stage4-claim-packets-gen", "version": "1.0"} } }, headers=HEADERS) sid = r.headers.get("mcp-session-id") if sid: HEADERS["mcp-session-id"] = sid c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "method": "notifications/initialized" }, headers=HEADERS) _log(f"1) Connected to localdocs (session: {sid})") # 도구 목록 확인 r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }, headers=HEADERS) tools_result = parse_sse(r.text) tools = (tools_result.get("result", {}).get("tools", []) if tools_result else []) _log(f" Tools: {[t['name'] for t in tools]}") write_tool = next( (t for t in tools if "write" in t["name"]), None) # 문서 목록 docs = call_tool(c, "list_docs", {}, 3) if docs and "result" in docs: _log(f" Docs: {docs['result']['content'][0]['text'][:500]}") # ===== 2) 파일 로딩 (MCP read_doc) ===== _log("\n2) Loading input files via MCP...") index = read_doc(c, "stage4_index.json", 10) if index is None: raise RuntimeError("Failed to load required: stage4_index.json") rules = read_doc(c, "Default_Agent/claim_scoring_rules.json", 11) if rules is None: raise RuntimeError( "Failed to load required: Default_Agent/claim_scoring_rules.json" ) _log(f" Default_Agent/claim_scoring_rules.json: loaded") # 스키마 (optional — 없으면 검증 스킵) index_schema = read_doc(c, "stage4_index.schema.json", 12) output_schema = read_doc(c, "stage4_claim_packets.schema.json", 13) if index_schema: _log(f" stage4_index.schema.json: loaded") else: _log(f" stage4_index.schema.json: not found (skip validation)") if output_schema: _log(f" stage4_claim_packets.schema.json: loaded") else: _log(f" stage4_claim_packets.schema.json: not found (skip validation)") fact_ledger = read_doc(c, "Fact_Ledger.json", 14) if fact_ledger is None: fact_ledger = read_doc(c, "fact_ledger.json", 15) fact_ledger = fact_ledger or [] preclaim_text = read_doc_text(c, "청구전작업.md", 16) or "" _log(f" stage4_index.json: loaded") _log(f" Fact_Ledger: {len(fact_ledger)} entries") _log(f" 청구전작업.md: {'loaded' if preclaim_text else 'not found'}") # ===== 3) 빌드 ===== _log("\n3) Building claim packets...") result = build_claim_packets( index, fact_ledger, preclaim_text, rules, max_elements=max_elements, max_facts=max_facts, max_evidence=max_evidence, ) # ===== 4) 검증 ===== if do_validate and index_schema and output_schema: rpt = validate_contracts( index, result, index_schema, output_schema, max_elements=max_elements, max_facts=max_facts, max_evidence=max_evidence, ) rpt.print_report() elif do_validate: _log("[VALIDATE] Skipped: schema files not available") # ===== 5) 결과 저장 (MCP write_doc + stdout) ===== output_json = json.dumps(result, ensure_ascii=False, indent=2) if write_tool: write_result = call_tool(c, write_tool["name"], { "path": output_name, "content": output_json, }, 20) if write_result and "result" in write_result: _log(f"\n4) Written to localdocs: {output_name}") else: _log("\n4) Write to localdocs failed") else: _log("\n4) No write tool available") # 항상 stdout으로 출력 (code-executor가 캡처) print(output_json) if __name__ == "__main__": main() requirements: "httpx" network: "agent-network" timeout: 120 task_procedure: IN: nexts: ["run_index"] wait_until: [] run_index: nexts: ["run_compute_inputs", "run_claim_packets"] wait_until: [] run_compute_inputs: nexts: ["OUT"] wait_until: ["run_index"] run_claim_packets: nexts: ["OUT"] wait_until: ["run_index"] - name: stage4_1_청구항변반박전략_중간작업 tools: mcpServers: code-executor: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp description: Run scripts of programming languages headers: Authorization: Bearer rR8OXqWrVZA1gFEo8oWfBkw2XgpWoGrrspw5ObsxTCM= localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents description: 지금까지의 작업을 바탕으로 청구, 항변, 반박 구조도 작성 llm_provider: anthropic llm_model: claude-haiku-4-5 # Task 정의 tasks: - task_name: "Task_B" llm_provider: "anthropic" llm_model: "claude-haiku-4-5" prompts: - role: "user" content: | ## Goal 아래 지시사항을 **정확히** 따라 `claim_master_table.md`를 생성하라. ## IO - IN: `stage4_claim_packets.json` - OUT: `claim_master_table.md` ## Speed Hard Constraints (MUST) 1. **입력 파일 재읽기 금지**: `read_doc`/동등 기능으로 `stage4_claim_packets.json`은 **1회만** 읽는다. 2. **초안/미리보기/채팅 출력 금지**: 문서 본문(json 혹은 markdown 전체)을 대화 메시지로 출력하지 말고, **오직 `write_file` 1회로만 저장**한다. 3. **출력 파일 내용 재열람 금지**: 생성된 `claim_master_table.md`를 다시 열어 읽거나(format 검증 목적 포함) 부분 발췌/요약을 출력하지 않는다. 4. **수정 루프 금지**: “검증→수정→재저장→재검증” 반복 금지. **단일 패스(one-pass)** 로 끝낸다. 5. **검증 최소화**: `write_file` 이후에는 **파일 존재 확인만 1회** 수행(예: `list_docs`)하고 종료한다. (내용 검증/형식 검증 금지) 6. **사고과정/추론문/설명문/주석/JSON 출력 금지**: 최종 산출물은 파일로만 저장. 7. **턴/호출 최소화**: 생성(write_file) 턴 + 존재확인(list_docs) 턴으로 **총 2턴에 종료**한다. ## 최상위 문서 형식 1. 문서 첫 줄은 반드시 아래와 동일: - `# 청구 마스터 표` 2. 그 다음 줄은 빈 줄 1개. 3. 이후 `claim_packets` 배열 순서를 그대로 유지하여, 각 `claim_id`마다 표 1개씩 생성. ## 섹션 형식(각 claim마다 반복) 각 claim마다 아래 순서를 **그대로** 사용: 1. 섹션 제목: - `## 청구 ID: {claim_id}` 2. 빈 줄 1개 3. 아래 HTML 테이블 구조를 그대로 사용(스타일/폭/열비율 포함): ```html
항목 내용 출처/세부
청구 종류 {claim_type}
청구 방식 {procedural_structures_joined}
청구 취지 {purpose_sentence}
청구 원인 {cause_sentence} {cause_src_formatted}
당사자 원고 {plaintiff_value}
당사자 피고 {defendants_joined}
``` 4. 각 테이블 뒤에는 빈 줄 1개. ## 값 매핑 규칙(정확히 적용) - `{claim_type}` = claim의 `claim_type` - `{procedural_structures_joined}` = claim의 `procedural_structures`를 `, `로 결합 - `{purpose_sentence}` = claim의 `purpose_sentence` (빈 문자열이면 빈칸 유지) - `{cause_sentence}` = claim의 `cause_sentence` (빈 문자열이면 빈칸 유지) - `{plaintiff_value}`: - 우선 `parties.plaintiff` 사용 - 없으면 claim 최상위 `plaintiff` 사용 - `{defendants_joined}` = `parties.defendants` 배열을 `, `로 결합 ## 청구 원인 출처(cause_src_formatted) 생성 규칙 아래 순서대로 수집 후, 중복 제거(처음 등장 순서 유지): 1. `elements` 배열의 각 원소에서 `element_id`를 수집하되 정규식 `^LF-Q\d{3}-P\d+$` 일치값만 포함 2. 같은 `elements`의 `fact_candidates` 값들을 수집하되 정규식 `^F-\d{3}$` 일치값만 포함 3. 최종 포맷: - 값이 있으면: `출처: [A, B, C]` - 값이 없으면: `출처: []` ## 강제 제약 - 모든 claim의 `청구 취지` 행 3열(`출처/세부`)은 **항상 빈칸**이어야 한다. - 표는 반드시 HTML `` 형식으로 작성한다(마크다운 파이프 테이블 금지). - 1열 셀은 `white-space:nowrap`을 유지해야 한다. - 2열/3열 폭은 동일(각 35%)이어야 한다. - 불필요한 설명문, 주석, 추가 문단을 출력하지 마라. ## 최종 출력 - 오직 `claim_master_table.md` 파일을 생성/덮어쓴다. 완료되면 **terminate** 을 출력하세요. - task_name: "Task_C" llm_provider: "anthropic" llm_model: "claude-haiku-4-5" prompts: - role: "user" content: | ## 목적 - stage4_claim_packets.json + stage4_compute_inputs.json + stage4_index.json → claim_legal_facts_table.md - 출력은 **마크다운 본문만**(코드펜스/설명/메타 금지) ## Speed mode (CRITICAL) - **1-pass 생성**: 문서를 다 만든 뒤 다시 읽어 전수검증/재생성/재검증하지 말 것. - ### Execution policy - 파일을 1회 작성하고 생성 완료 후, 파일이 실제 생성되었는지만 검증하라. - **생성된 파일을 다시 읽거나, 내용을 검증하거나, 추가 요약을 생성하는 등의 후속 작업을 절대 수행하지 마라.** - list_doc()을 사용하여 파일 생성 검증하여 "claim_legal_facts_table.md"이 생성되었다면 곧바로 "claim_legal_facts_table.md 생성 완료" 메시지를 춭력하고 작업을 종료하라. - 작업 종료 후에도 iteration 작업을 수행하는 등의 그 어떤 작업도 수행하지 마라. - 아래 규칙을 그대로 적용하여 **만들면서 정합성 보장**. - 불필요한 서론/요약/체크리스트 출력 금지(오로지 최종 md 본문만). ## Input files (ONLY these) - stage4_claim_packets.json - stage4_compute_inputs.json - stage4_index.json ## Output file (only this) - claim_legal_facts_table.md (마크다운 본문만, 코드펜스/설명/메타 금지) ## Allowed fields (시간 절약을 위해 아래 필드만 읽고 나머지는 무시) - stage4_claim_packets.json: claim_packets[].{claim_id, claim_type, elements[], paulian_actions[], purpose_sentence} - stage4_index.json: - fact_index[F-###].summary - claim_index[C-###].summary - stage4_compute_inputs.json: - claims[] (claim_id로 매칭)에서 아래만 사용: - principal.candidates[].{raw, src} - rate.{contractual_rate, statutory_rate, recommended_rate} - dates.start_date.{value, candidates[]} - fees.claim_value.value ## Absolute constraints - 데이터 소스는 위 3개 JSON만 사용. - JSON에 없는 값 생성 금지. - “인지대”, “송달료” 문자열을 출력에 포함시키지 말 것. - 줄바꿈은 LF(`\n`)만, 후행 공백 금지. ## Global markdown format (deterministic) - 문서 첫 줄은 정확히: `# 청구 요건사실 및 세부사항` - claim_packets 순서대로 모든 claim_id 처리. - 각 청구 섹션 시작 제목은 정확히: `## 청구 ID: {claim_id} - 요건 사실` - 각 표 헤더는 항상 다음 2줄(정확히 일치): | 요건 요소 | 요건 요소 내용 | 서증 목록 | | --- | --- | --- | - 표와 표(또는 표와 다음 텍스트) 사이는 **빈 줄 1개**. - 각 표의 행 수는 **정확히 `M + 4`** (M = elements 길이). *(생성 시점에 M을 고정하고 그대로 출력)* ## Row construction rules ### A) 요소 행 (1~M행) - 1열: `{element}` 사용 - {element} 내부의 모든 공백은 ` `로 치환 - 2열: fact_candidates 순서 유지 - 각 항목: `F-xxx: {fact_index[F-xxx].summary}` - 다수 항목은 `,
`로 연결 - 3열: evidence_candidates 순서 유지 - `E-xxx, E-yyy` 형식(접두어/라벨 금지) - 구분자는 `, ` ### B) 소송 금액/원금 (M+1행) - 1열: `소송 금액` - 2열: `원금` - 3열: principal.candidates 순서 유지 - 각 항목: `k. "{raw}": {clean_summary} & 출처: [src1, src2, ...]` - 다수 항목은 `,
`로 연결 - candidates가 없으면 **빈 셀**(아무것도 쓰지 않음) - clean_summary 생성 규칙(청구당 1회 계산 후 재사용): 1) stage4_index.claim_index[claim_id].summary에서 `(F-... )`로 시작하는 괄호 덩어리 전체 삭제 2) 동일하게 `(E-... )`로 시작하는 괄호 덩어리 전체 삭제 3) 남은 텍스트에 포함된 단독 `F-###`, `E-###` 토큰을 모두 삭제 4) 연속 공백을 1개로 정리하고 문장만 남김 ### C) 소송 금액/이자금액 (M+2행) - 1열: `소송 금액` - 2열: `이자금액` - contractual_rate가 null이거나 contractual_rate.annual_pct 또는 contractual_rate.raw가 null이면 3열은 정확히 `정보없음` - 그 외 3열은 아래 4문장을 `,
`로 연결: 1) `약정이율 {contractual_rate.annual_pct}%, {contractual_rate.raw},` 2) `{statutory_rate.basis}: {statutory_rate.annual_pct}%,` 3) `권고이자율: {recommended_rate.type} {recommended_rate.annual_pct}%,` 4) `출처: [{contractual_rate.src...}]` ### D) 날짜 산정 (M+3행) - 1열: `날짜 산정` - 2열: `만기일(기산일 후보), 변제기 또는 부도일` - 3열: dates.start_date.candidates 순서대로 - `{value}, {origin}, {note}, 시작일: {dates.start_date.value} & 출처: [src...]` - 다수 항목은 `,
`로 연결 - candidates가 없으면 **빈 셀** ### E) 비용/소송가액 (M+4행) - 1열: `비용` - 2열: `소송가액` - 3열: fees.claim_value.value가 정수면 천단위 콤마 후 `원` 붙임 - value가 null이면 정확히 `null원` ## Special rule: claim_type에 “사해행위취소” 포함 시 (표 바로 아래 추가) - 표 바로 아래에 제목 `### 사해행위취소특칙` 출력(앞뒤 빈 줄 규칙 유지) - 아래 3개를 번호 목록으로 정확히 작성: 1. 피보전채권 특정: - paulian_actions 순서대로 `연결 청구: {preserved_claim_link} (근거: [src...])` - 다수는 `; `로 연결 - paulian_actions가 없으면 `명시 없음` 2. 요건: - elements 중 element 텍스트에 `제척기간`, `무자력`, `사해의사`, `수익자·전득자` 중 하나라도 포함된 항목만 선택(원래 elements 순서 유지) - 각 항목 출력 형식(중요): - `{element} (F-..., F-..., ...)` - 괄호 안에는 **fact_candidates만**, 순서 유지, 구분자는 `, ` - 다수는 `; `로 연결 - 해당 항목이 없으면 `명시 없음` - **절대 출력 금지**: `element_id`, `fact_candidates:` 문자열 또는 대괄호 `[...]` 3. 주위적 vs 예비적: - 한 줄로: `주위적(원물반환): ..., 예비적(가액배상): ...` - purpose_sentence에 취소/말소등기/원물반환/주위 관련 문구가 있으면 주위적에 purpose_sentence 사용, 없으면 `명시 없음` - purpose_sentence에 가액배상/예비 관련 문구가 있으면 예비적에 purpose_sentence 사용, 없으면 `명시 없음` ## Formatting rules - 1열은 모든 행에서 nowrap 유지(위 span 규칙 준수). - 2열/3열에서만 `
` 사용 가능. - 식별자/숫자 토큰 내부 분할 금지(`F-001`, `E-012`, `1,000,000원` 등). - 항목 구분자는 각 규칙에서 지정한 그대로 사용(`; `, `, `, `,
`). - JSON 키/경로 설명 등 메타 출력 금지. ## Output - 위 규칙을 적용한 **최종 마크다운 본문만** 출력. 완료되면 **terminate** 을 출력하세요. - task_name: "Task_D" llm_provider: "anthropic" llm_model: "claude-haiku-4-5" prompts: - role: "user" content: | # Role 세계적 수준의 인공지능 아키텍트 개발자 & 대한민국 최고의 법률 전문가 # Goal - 항변/재반박 매트릭스 생성(defense_rebuttal.md) - 토큰/시간 최소화 # IO - IN: - stage4_claim_packets.json - stage4_index.json - stage4_compute_inputs.json (기본 미사용) - OUT: defense_rebuttal.md ## Speed mode (CRITICAL) - **1-pass 생성**: 문서를 다 만든 뒤 다시 읽어 전수검증/재생성/재검증하지 말 것. - ### Execution policy - 파일을 1회 작성하고 생성 완료 후, 파일이 실제 생성되었는지만 검증하라. - **생성된 파일을 다시 읽거나, 내용을 검증하거나, 추가 요약을 생성하는 등의 후속 작업을 절대 수행하지 마라.** - 파일 생성 검증 후, 곧바로 "defense_rebuttal.md 생성 완료" 메시지를 춭력하고, 작업을 종료하라. - 작업 종료 후에도 iteration 작업을 수행하는 등의 그 어떤 작업도 수행하지 마라. - 아래 규칙을 그대로 적용하여 **만들면서 정합성 보장**. - 불필요한 서론/요약/체크리스트 출력 금지(오로지 최종 md 본문만). # Hard Constraints 1. 첫 줄: `# 항변/재반박 매트릭스` 2. claim 처리 순서: `claim_id` 오름차순 3. claim 섹션: `## 청구 ID - C-xxx` 4. 표 제목: `### C-xxx - 항변/재반박 k` 5. 각 표는 정확히 6행: 유형/상대방 예상 항변·주장/핵심 쟁점/재반박/근거/신뢰도 6. `재반박`에 `[태그]` 금지 7. `신뢰도`는 `High|Medium`만 허용 (`Low` 금지) 8. 설명문/추가 섹션/사고과정 출력 금지 # Data Use (minimal) - 사용 필드만 읽기: - claim: `claim_id, claim_type, defendant, purpose_sentence, cause_sentence, elements[]` - element: `element_id, element, fact_candidates, evidence_candidates` - index: `fact_index[F-###].credibility, summary` - `stage4_compute_inputs.json`은 누락 보정이 필요할 때만 읽기 # Candidate Rules ## 상대방 예상 항변/부인/절차 후보 선정 방법 * 읽어들인 Data에서 "요건사실 요소에서 파생되는 전형적 다툼"만 고려 * 반드시 관련 F-###/E-###를 찾을 수 있는 것만 채택(HIGH/MEDIUM) * 예: 소멸시효(기산점), 변제/상계, 무자력 부인, 피보전채권 부인 등 ## 유효 후보 조건(모두 충족): - 트리거 매칭 element >=1 - 매칭 element의 F-### >=1 - 매칭 element의 E-### >=1 ## 점수(결정형): - `score = 10*매칭 element 수 + 2*credibility가 high/medium인 fact 수 + evidence 수` - 동점이면 후보 `항변 - 부인 - 절차` 순서로 우선 순위 결정 ## M 결정: - 점수순 상위 유효 후보 사용 - `2위 score >= 12`이면 `M=2`, 아니면 `M=1` (최소 1 보장) ## `핵심 쟁점`: - `{대표 element명} 충족과 증거연결(E/F)의 충분성으로 해당 항변 배척 가능 여부가 쟁점이다.` ## `재반박`: - `원고는 {대표 element_id} 및 연결 사실·증거를 통해 상대방 주장의 요건사실 부합성을 탄핵할 수 있다.` ## `근거(사실/증거/법리)`: - `{element_id들}; F:{fact_id들}; E:{evidence_id들}` - 각 id 목록은 중복 제거 + 오름차순 ## `신뢰도`: - High: `element_id >=2` AND `evidence_id >=2` - 그 외 유효 후보: Medium # Representative Selection (deterministic) - 대표 element = 매칭 element 중 `element_id` 오름차순 첫 항목 - element_id들/fact_id들/evidence_id들 = 매칭 집합 전체(오름차순) # Markdown Layout (exact) - `# 항변/재반박 매트릭스` - 반복: `## 청구 ID - C-xxx` - 반복: `### C-xxx - 항변/재반박 k` - 표: - `| 항목 | 내용/세부 |` - `|---|---|` - `| 유형 | ... |` - `| 상대방 예상 항변/주장 | ... |` - `| 핵심 쟁점 | ... |` - `| 재반박 | ... |` - `| 근거(사실/증거/법리) | ... |` - `| 신뢰도 | High 또는 Medium |`" 완료되면 **terminate** 을 출력하세요. - task_name: "Task_E" llm_provider: "anthropic" llm_model: "claude-haiku-4-5" prompts: - role: "user" content: | ## Goal - **최소 지연**으로 `서증및위험성평가.md` **단일 파일**을 1회에 생성한다. - **품질/내용/형식은 기존 `서증및위험성평가.md`와 동일 수준**이어야 한다. - 생성 후 **재읽기·형식검증·재작성 루프를 수행하지 않는다**(형식을 “생성 by construction”). ## IO - IN: `stage4_claim_packets.json`, `stage4_index.json` - OUT: `서증및위험성평가.md` (단일 파일, 중간파일 생성 금지) --- ## Speed Hard Constraints (MUST) 1. **입력 파일 재읽기 금지**: `read_doc`/동등 기능으로 `stage4_claim_packets.json`, `stage4_index.json`은 **각 1회만** 읽는다. 2. **초안/미리보기/채팅 출력 금지**: 문서 본문(markdown 전체)을 대화 메시지로 출력하지 말고, **오직 `write_file` 1회로만 저장**한다. 3. **출력 파일 내용 재열람 금지**: 생성된 `서증및위험성평가.md`를 다시 열어 읽거나(format 검증 목적 포함) 부분 발췌/요약을 출력하지 않는다. 4. **수정 루프 금지**: “검증→수정→재저장→재검증” 반복 금지. **단일 패스(one-pass)** 로 끝낸다. 5. **검증 최소화**: `write_file` 이후에는 **파일 존재 확인만 1회** 수행(예: `list_docs`)하고 종료한다. (내용 검증/형식 검증 금지) 6. **사고과정/추론문/설명문/주석/JSON 출력 금지**: 최종 산출물은 파일로만 저장. 7. **정렬·구분자·표 헤더는 아래 스키마를 그대로** 사용(변형 금지). 8. **턴/호출 최소화**: 생성(write_file) 턴 + 존재확인(list_docs) 턴으로 **총 2턴에 종료**한다. --- ## Data Use (minimal) 아래 필드만 사용하고, 나머지는 읽었더라도 무시한다. ### From `stage4_index.json` - `meta.generated_at` - `evidence_index` (E-### 키, `title`) - `fact_index` (F-###: `summary`, `credibility`, `evidence_refs`, `related_claims`) ### From `stage4_claim_packets.json` - `claim_packets[].claim_id` - `claim_packets[].claim_type` - `claim_packets[].elements[].element` - `claim_packets[].elements[].fact_candidates` - `claim_packets[].elements[].evidence_candidates` - `claim_packets[].paulian_actions` (특히 `time`, `act_type`, `src`) - `claim_packets[].warnings[]` --- ## 법률 판단 기준 (LLM이 추론하지 말고 아래를 그대로 적용) | 항목 | 기준 | |------|------| | 평가 기준일 | `meta.generated_at` 값 사용 | | 상사채권 소멸시효 | 5년 (상법 §64) — 여신금융업자(우방캐피탈)의 대출채권에 적용 | | 민사채권 소멸시효 | 10년 (민법 §162①) — 보증인 구상채권에 적용 | | 사해행위취소 제척기간 | **법률행위가 있은 날**(등기완료일 우선, 없으면 계약일)로부터 5년 (민법 §406②) | | 시효중단 사유 | fact_index에 경매신청(민법 §168②)·가압류(§168③)·배당 사실이 존재하면, 해당 시점에 중단·갱신된 것으로 처리 | | warnings 처리 | `claim_packets[].warnings[]` 항목을 리스크 평가의 `핵심 리스크` 컬럼에 **반드시** 반영 | --- ## 출력 스키마 (아래 3개 섹션을 순서대로 단일 .md에 작성) --- ### 섹션 1: `# 서증 목록` **데이터 소스**: `evidence_index` 전체(E-001~E-020) + `claim_packets[].elements[].evidence_candidates`(역방향 매핑) + `fact_index`(입증취지 보강) #### 표 | 서증번호 | 문서명 | 입증취지 | 대응 청구·요건 | 예상다툼 | 증거능력 | |----------|--------|----------|----------------|----------|----------| **컬럼 규칙(결정형, 변형 금지)**: - `서증번호`: E-### (번호 오름차순) - `문서명`: `evidence_index[E-###].title` - `입증취지`: - 1순위: `evidence_index[E-###].key_facts`가 비어있지 않으면 이를 세미콜론(;)로 병합 - 2순위(필수 fallback): 비어있으면 `fact_index`에서 `evidence_refs`에 해당 E-###가 포함된 모든 사실(F-###)의 `summary`를 **F-### 오름차순**으로 수집하여 세미콜론(;)로 병합 - 3순위: 그래도 0개면 `{문서명} 관련 사실 입증`(정확히 이 문구) - `대응 청구·요건`: - claim_packets 전체 elements를 순회 → 해당 E-###가 `evidence_candidates`에 포함된 모든 `(claim_id, element)` 쌍을 수집 - 표기: `{claim_id}/{element}` - 중복 제거 후 `claim_id` 오름차순 → `element` 사전순으로 정렬 - 연결: ` / ` (공백-슬래시-공백)로 병합 - 어떤 claim에도 연결되지 않으면 **"배경 증거"** - `예상다툼`: - 아래 2계층 규칙 적용(동일 문구 유지) - **1계층(doc_type 기반)**: 공문서→"형식적 증거력 추정", 처분문서→"성립 진정 시 내용 부인 곤란", 판결/결정→"공적 증거력", 거래기록→"작성 진정·정확성 다툼 가능", 기타→"별도 보강 필요" - **2계층(구체적 쟁점)**: 위 입증취지(사실 요약)에서 금액 차이, 조건부 거래, 시간적 근접성 등 쟁점이 식별되면 1계층 뒤에 추가 (예: "성립 진정 시 내용 부인 곤란; 채무인수 조건의 실질 검토 필요") - `증거능력`: 1줄 결론 #### 보강수단 (서증 목록 하단) 아래 4개 항목 각각 1줄로 판단. **판단 근거**: - `fact_index`에서 `credibility == "low"` AND `evidence_refs`가 빈 배열인 사실(F-###) 존재 여부 - + `claim_packets[].warnings[]` 내용 **형식은 아래 코드블록을 그대로 사용** (문구/순서/줄바꿈 유지): ``` ## 보강수단 - 문서제출명령: [필요/불필요] — 대상·사유 - 사실조회: [필요/불필요] — 조회처·목표사실 - 감정: [필요/불필요] — 대상물·감정목적 - 증인: [필요/불필요] — 증인명·입증사항 ``` --- ### 섹션 2: `# 리스크 평가` **데이터 소스**: `claim_packets`(warnings, paulian_actions.time), `fact_index`(날짜·credibility), 섹션 1의 보강수단 판단 결과 #### 표 | 청구 ID | 청구유형 | 시효·제척 | 집행 | 입증 | 핵심 리스크 | |---------|----------|-----------|------|------|-------------| **척도 정의** (상=위험 ↑, 하=안전 ↓): | 축 | 하 (안전) | 중 | 상 (위험) | |----|-----------|-----|-----------| | 시효·제척 | 잔여 > 총기간 50% | 잔여 10%~50% | 잔여 <10% 또는 도과 | | 집행 | 회수·원물반환 확실 | 가능하나 불확실 | 가능성 낮음/없음 | | 입증 | 핵심 서증 전부 확보 | 일부 누락·보강 필요 | 핵심 서증 부재·입증 곤란 | **`핵심 리스크` 컬럼(결정형)**: - 해당 청구의 최대 위험 1~2개를 1줄로 기재 - `claim_packets[].warnings[]`의 WARNING-### 내용을 **반드시 포함** - WARNING-###가 없으면(예외) 핵심 리스크는 데이터 기반(시효·제척/집행/입증)으로만 작성 #### 상세 분석 (리스크 표 하단) `## 상세 분석` 헤더를 두고, 각 청구 ID별로 **2~4문장**(과다 서술 금지): 1. 시효·제척 판단 근거 (기산일, 만료일, 중단 사유 유무) 2. 집행·입증 판단 핵심 논거 3. 해당 warnings 원문 인용 및 대응 방안 **warnings 원문 인용 규칙(결정형, 편차/재작성 방지)**: - `claim_packets[].warnings[]`는 문자열이며 형식은 보통 `WARNING-###: <내용>`이다. - 상세 분석에서는 반드시 아래 형식으로 인용한다: - `WARNING-### 원문: "<내용>"` - 여기서 `<내용>`은 원 문자열에서 접두 `WARNING-###: `를 제거한 본문을 사용하되, - 본문 내의 ` - ` (공백-하이픈-공백)을 ` — ` (공백-emdash-공백)으로 치환 - 문장 끝이 마침표(`.`)가 아니면 `.`를 1개 추가 - 위 규칙 외의 요약/의역/재서술 금지(동일한 인용 형식 유지). --- ### 섹션 3: `# 교차참조표` **데이터 소스**: `claim_packets[].elements[]` 마크다운 표로 작성 (**JSON 금지**): | 청구 ID | 요건요소 | 관련 사실 (F-###) | 관련 증거 (E-###) | |---------|----------|-------------------|-------------------| `claim_packets`의 각 `claim_id` > `elements[]` 배열을 행 단위로 펼친다. --- ## 실행 규칙 (MUST) 1. **단일 파일 출력**: `서증및위험성평가.md` 하나만 생성. 중간 파일(JSON, 임시 .md 등) 생성 금지. 2. **완전성**: evidence_index의 E-001~E-020 전부 서증 목록에 포함. claim_packets의 C-001~C-006 전부 리스크 평가에 포함. 3. **섹션 구분**: 3개 섹션 사이에 `---` 구분선 삽입. 4. **warnings 필수 반영**: claim_packets의 모든 WARNING-### 항목이 리스크 평가표의 `핵심 리스크` 컬럼 또는 상세 분석에 1회 이상 등장해야 한다. 5. **법률 기준 고정**: 위 "법률 판단 기준" 표의 내용을 그대로 적용. 모델 자체 법률 추론으로 대체 금지. --- ## Execution Plan (MUST, minimal calls) - 1) `read_doc(stage4_index.json)` 1회 - 2) `read_doc(stage4_claim_packets.json)` 1회 - 3) 위 스키마대로 markdown을 **한 번에 완성** (내부 메모리에서만) - 4) `write_file(서증및위험성평가.md, )` **정확히 1회** - 5) 다음 턴에서 `list_docs` 1회로 파일 존재만 확인하고 즉시 종료 ## Completion Message (after existence check) - 최종 대화 메시지는 아래 1줄만 출력: - `DONE: 서증및위험성평가.md` 완료되면 **terminate** 을 출력하세요. # DAG 기반 실행 순서 # # ┌─ Task_B ──┐ # │ │ # ├─ Task_C ──│ # IN │ │────── OUT # ├─ Task_D │ # │ │ # └─ Task_E ──┘ # task_procedure: IN: nexts: ["Task_B", "Task_C", "Task_D", "Task_E"] wait_until: [] Task_B: nexts: ["OUT"] wait_until: [] Task_C: nexts: ["OUT"] wait_until: [] Task_D: nexts: ["OUT"] wait_until: [] Task_E: nexts: ["OUT"] wait_until: [] prevs: [stage4_0_parallel-executor] nexts: [stage4_2_청구항변반박전략문서작성] - name: stage4_2_청구항변반박전략문서작성 description: 지금까지의 작업을 바탕으로 청구, 항변, 반박 구조도 작성 tools: mcpServers: code-executor: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp headers: Authorization: Bearer rR8OXqWrVZA1gFEo8oWfBkw2XgpWoGrrspw5ObsxTCM= tasks: - task_name: gen_strategy_doc mcp: code-executor tool_name: run_code parameters: language: python requirements: httpx network: agent-network timeout: 120 code: | #!/usr/bin/env python3 import httpx import asyncio import json import re import os import time from typing import List # ===== localdocs MCP client (async) ===== LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" BASE_HEADERS = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } def parse_sse(text): for line in text.strip().split("\n"): if line.startswith("data: "): return json.loads(line[6:]) try: return json.loads(text) except: return None # ===== Markdown extraction helpers ===== def _find_line_index(lines, target): t = target.strip() for i, ln in enumerate(lines): if ln.strip() == t: return i raise ValueError("Heading not found: " + repr(target)) def extract_level2_section_body(md, heading_line): lines = md.split("\n") i = _find_line_index(lines, heading_line) start = i + 1 end = len(lines) for j in range(start, len(lines)): if lines[j].startswith("## ") and lines[j].strip() != heading_line.strip(): end = j break body = lines[start:end] while body and body[0].strip() == "": body.pop(0) while body and body[-1].strip() == "": body.pop() return "\n".join(body) def extract_table_under_heading(md, heading_line): lines = md.split("\n") i = _find_line_index(lines, heading_line) j = i + 1 while j < len(lines) and lines[j].strip() == "": j += 1 if j >= len(lines) or not lines[j].lstrip().startswith("|"): raise ValueError("No markdown table found under heading: " + repr(heading_line)) start = j while j < len(lines) and lines[j].lstrip().startswith("|"): j += 1 return "\n".join(ln.rstrip() for ln in lines[start:j]) def split_md_row(row): r = row.strip() if r.startswith("|"): r = r[1:] if r.endswith("|"): r = r[:-1] return [c.strip() for c in r.split("|")] def filter_defendant_table(table_md, status_col_name="적격상태"): lines = [ln.rstrip() for ln in table_md.split("\n") if ln.strip() != ""] if len(lines) < 2: raise ValueError("Table too short to parse.") header_cells = split_md_row(lines[0]) status_idx = header_cells.index(status_col_name) kept = [lines[0], lines[1]] for ln in lines[2:]: cells = split_md_row(ln) if status_idx < len(cells) and "제외" in cells[status_idx].replace(" ", ""): continue kept.append(ln) return "\n".join(kept) # ===== Tag cleanup ===== RE_MAP_SQUARE = re.compile(r"\[\s*(?:F-\d{3}|bh\d+)(?:\s*/\s*(?:F-\d{3}|bh\d+))+\s*\]") RE_MAP_PAREN = re.compile(r"\(\s*(?:F-\d{3}|bh\d+)(?:\s*/\s*(?:F-\d{3}|bh\d+))+\s*\)") RE_F_PAREN = re.compile(r"\(\s*F-\d{3}\s*\)") RE_F_SQUARE = re.compile(r"\[\s*F-\d{3}\s*\]") RE_BH_PAREN = re.compile(r"\(\s*bh\d+\s*\)") RE_BH_SQUARE = re.compile(r"\[\s*bh\d+\s*\]") RE_MULTI_SPACE = re.compile(r"[ \t]{2,}") def clean_tags_line(line, keep_bh=False): m = re.match(r"^(\s*)", line) indent = m.group(1) if m else "" rest = line[len(indent):] rest = RE_MAP_SQUARE.sub("", rest) rest = RE_MAP_PAREN.sub("", rest) rest = RE_F_PAREN.sub("", rest) rest = RE_F_SQUARE.sub("", rest) if not keep_bh: rest = RE_BH_PAREN.sub("", rest) rest = RE_BH_SQUARE.sub("", rest) rest = RE_MULTI_SPACE.sub(" ", rest).strip() return (indent + rest).rstrip() def clean_block_tags(block, keep_bh=False): return "\n".join( ln for ln in (clean_tags_line(l, keep_bh=keep_bh) for l in block.split("\n")) if ln.strip() != "" ) def enforce_max_lines(block, max_lines): lines = [ln for ln in block.split("\n") if ln.strip() != ""] return "\n".join(lines[:max_lines]) if len(lines) > max_lines else block # ===== Output template ===== TEMPLATE = """# 청구/항변/반박 전략 보고서 ## 1. 사건 개요 (10줄 이내) {{TIMELINE_10_LINES}} ## 2. 당사자 및 소송구조 {{PARTIES_AND_STRUCTURE}} ## 3. 청구 마스터 표 {{claim_master_table.md}} ## 4. 청구 요건사실 및 세부 정보 {{claim_legal_facts_table.md}} ## 5. 항변/재반박 매트릭스 {{defense_rebuttal.md}} ## 6. 서증목록 및 입증계획 {{서증및위험성평가.md}} """ def build_report(loaded): pre_claim = loaded["pre_claim"] overview = clean_block_tags(extract_level2_section_body(pre_claim, "## 1. 사건 개요")) overview = enforce_max_lines(overview, 10) plaintiff_table = extract_table_under_heading(pre_claim, "### 5.1 원고") defendant_table = filter_defendant_table( extract_table_under_heading(pre_claim, "### 5.2 피고") ) parties = "### 2.1 원고\n\n" + plaintiff_table.strip() + "\n\n### 2.2 피고\n\n" + defendant_table.strip() out = TEMPLATE out = out.replace("{{TIMELINE_10_LINES}}", overview.strip()) out = out.replace("{{PARTIES_AND_STRUCTURE}}", parties) out = out.replace("{{claim_master_table.md}}", loaded["claim_master"].strip()) out = out.replace("{{claim_legal_facts_table.md}}", loaded["claim_legal_facts"].strip()) out = out.replace("{{defense_rebuttal.md}}", loaded["defense_rebuttal"].strip()) out = out.replace("{{서증및위험성평가.md}}", loaded["evidence_risk"].strip()) joined = "\n".join(ln.rstrip() for ln in out.split("\n")) return joined.rstrip() + "\n" # ===== Helper: safe hint builder (avoids ")).lower()" pattern) ===== def _build_hint(k, v): desc = v.get("description", "") combined = k + " " + desc return combined.lower() def _match_write_args(props, filename, content): args = {} for k, v in props.items(): hint = _build_hint(k, v) if any(x in hint for x in ["name", "file", "path", "doc_name"]): args[k] = filename elif any(x in hint for x in ["content", "data", "text", "body"]): args[k] = content return args # ===== MAIN: async parallel I/O ===== async def main(): t0 = time.perf_counter() headers = dict(BASE_HEADERS) async with httpx.AsyncClient(timeout=60) as c: # 1) localdocs init r = await c.post(LOCALDOCS_URL, json={"jsonrpc":"2.0","id":1,"method":"initialize","params":{ "protocolVersion":"2025-03-26","capabilities":{}, "clientInfo":{"name":"task-f-renderer","version":"3.1"} }}, headers=headers) sid = r.headers.get("mcp-session-id") if sid: headers["mcp-session-id"] = sid await c.post(LOCALDOCS_URL, json={"jsonrpc":"2.0","method":"notifications/initialized"}, headers=headers) r = await c.post(LOCALDOCS_URL, json={"jsonrpc":"2.0","id":2,"method":"tools/list"}, headers=headers) tools_result = parse_sse(r.text) tools = tools_result.get("result",{}).get("tools",[]) if tools_result else [] write_tool = next((t for t in tools if "write" in t["name"]), None) t1 = time.perf_counter() print("1) Init: %.3fs (session: %s)" % (t1 - t0, sid)) # 2) parallel file reads FILE_MAP = { "claim_master": "claim_master_table.md", "claim_legal_facts":"claim_legal_facts_table.md", "defense_rebuttal": "defense_rebuttal.md", "evidence_risk": "서증및위험성평가.md", "pre_claim": "청구전작업.md", } async def read_one(key, fname, msg_id): r = await c.post(LOCALDOCS_URL, json={ "jsonrpc":"2.0","id":msg_id, "method":"tools/call", "params":{"name":"read_doc","arguments":{"doc_name":fname}} }, headers=headers) result = parse_sse(r.text) if result and "result" in result: content = result["result"]["content"][0]["text"] try: content = json.loads(content) except (json.JSONDecodeError, TypeError): pass if isinstance(content, str): content = content.replace("\r\n","\n").replace("\r","\n") else: content = json.dumps(content, ensure_ascii=False) return key, content return key, None read_tasks = [ read_one(key, fname, 10 + idx) for idx, (key, fname) in enumerate(FILE_MAP.items()) ] results = await asyncio.gather(*read_tasks) loaded = {} for key, content in results: if content is None: print(" FATAL: Failed to load " + FILE_MAP[key]) else: loaded[key] = content t2 = time.perf_counter() print("2) Read %d files: %.3fs (parallel)" % (len(loaded), t2 - t1)) if len(loaded) < len(FILE_MAP): missing = [FILE_MAP[k] for k in FILE_MAP if k not in loaded] print(" Missing: " + str(missing)) import sys; sys.exit(1) # 3) build report (pure CPU) report = build_report(loaded) t3 = time.perf_counter() print("3) Build: %.3fs (%d chars, %d lines)" % (t3 - t2, len(report), len(report.splitlines()))) # 4) parallel save output_filename = "청구항변반박전략.md" async def save_localdocs(): if not write_tool: print(" No write tool found!") return props = write_tool.get("inputSchema", {}).get("properties", {}) args = _match_write_args(props, output_filename, report) r = await c.post(LOCALDOCS_URL, json={ "jsonrpc":"2.0","id":20, "method":"tools/call", "params":{"name":write_tool["name"],"arguments":args} }, headers=headers) wr = parse_sse(r.text) if wr and "result" in wr: print(" localdocs: saved") else: snippet = json.dumps(wr, ensure_ascii=False)[:200] print(" localdocs write failed: " + snippet) async def save_file(): p = os.path.join("/app/output", output_filename) with open(p, "w", encoding="utf-8") as f: f.write(report) print(" file: saved to " + p) await asyncio.gather(save_localdocs(), save_file()) t4 = time.perf_counter() print("4) Save: %.3fs" % (t4 - t3)) print("\nTotal: %.3fs" % (t4 - t0)) asyncio.run(main()) ''' 실행 예: result = mcp_call("tools/call", { "name": "run_code", "arguments": { "language": "python", "code": task_f_code, "requirements": "httpx", "network": "agent-network", "timeout": 120 } }, msg_id=10) ``` prevs: [stage4_1_청구항변반박전략_중간작업] nexts: [stage4_5_1_판례검색쿼리생성] - name: stage4_5_1_판례검색쿼리정보추출 description: 'Extract information for query search' llm_provider: openai llm_model: gpt-4o tools: mcpServers: code-executor: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp description: Run scripts of programming languages headers: Authorization: Bearer rR8OXqWrVZA1gFEo8oWfBkw2XgpWoGrrspw5ObsxTCM= localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents tasks: - task_name: information_blocks_generation mcp: code-executor tool_name: run_code parameters: language: python requirements: "httpx" network: "agent-network" code: | #!/usr/bin/env python3 """ generate_information_blocks.py Reads stage4_claim_packets.json and defense_rebuttal.md from localdocs, generates information_blocks_query.json. """ import json import re import sys from datetime import datetime import httpx # ══════════════════════════════════════════════════════════════════════ # Configuration # ══════════════════════════════════════════════════════════════════════ LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" HEADERS = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } CLAIM_PACKETS_CANDIDATES = [ "stage4_claim_packets.json", ] DEFENSE_MD_CANDIDATES = [ "defense_rebuttal.md", ] OUTPUT_NAME = "information_blocks_query.json" DB_MATCHING = { "사해행위취소": {"collection": "Analyzed_Cases", "tenant": "Cases_Actio_Pauliana"}, "대여금": {"collection": "Past_Cases", "tenant": "Cases_Loan_Claim"}, "보증금": {"collection": "Past_Cases", "tenant": "Cases_Guarantee_Claim"}, "구상금": {"collection": "Past_Cases", "tenant": "Cases_Indemnity_Claim"}, } # ══════════════════════════════════════════════════════════════════════ # MCP localdocs helpers # ══════════════════════════════════════════════════════════════════════ def parse_sse(text): for line in text.strip().split("\n"): if line.startswith("data: "): return json.loads(line[6:]) try: return json.loads(text) except Exception: return None def call_tool(c, name, arguments, msg_id=10): r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": msg_id, "method": "tools/call", "params": {"name": name, "arguments": arguments} }, headers=HEADERS) result = parse_sse(r.text) if result and "result" in result: return result _log(f"Tool {name} error: {json.dumps(result)[:300]}") return result def read_doc_json(c, doc_name, msg_id=10): result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] if not text or not text.strip(): return None try: return json.loads(text) except json.JSONDecodeError: return None return None def read_doc_text(c, doc_name, msg_id=10): result = call_tool(c, "read_doc", {"doc_name": doc_name}, msg_id) if result and "result" in result: text = result["result"]["content"][0]["text"] return text if text and text.strip() else None return None def try_read(c, candidates, reader_fn, base_msg_id=10): for i, path in enumerate(candidates): data = reader_fn(c, path, base_msg_id + i) if data is not None: return data, path return None, None def _log(msg): print(msg, file=sys.stderr) # ══════════════════════════════════════════════════════════════════════ # case_type 정규화 및 target 결정 # ══════════════════════════════════════════════════════════════════════ def normalize_case_type(claim_type_raw): """ 괄호 제거 후 DB_MATCHING 키를 문자열 안에서 검색. e.g. "대여금(연대보증채무) 청구" -> "대여금" e.g. "전득자 사해행위취소(김포 근저당)" -> "사해행위취소" """ stripped = re.sub(r'[\(（][^)）]*[\)）]', '', claim_type_raw).strip() for key in sorted(DB_MATCHING.keys(), key=len, reverse=True): if key in stripped: return key parts = stripped.split() return parts[0] if parts else stripped def get_target(normalized): if normalized in DB_MATCHING: return DB_MATCHING[normalized].copy() _log(f" WARNING: No DB match for '{normalized}'") return {"collection": "UNKNOWN", "tenant": "UNKNOWN"} # ══════════════════════════════════════════════════════════════════════ # stage4_claim_packets.json 파서 # ══════════════════════════════════════════════════════════════════════ def parse_claim_packets(data): claims = {} if isinstance(data, list): for item in data: cid = item.get("claim_id", "") if cid: claims[cid] = item elif isinstance(data, dict): if any(re.match(r'C-\d+', k) for k in data.keys()): for k, v in data.items(): if re.match(r'C-\d+', k) and isinstance(v, dict): v["claim_id"] = k claims[k] = v else: for key, val in data.items(): if isinstance(val, list): for item in val: if isinstance(item, dict): cid = item.get("claim_id", "") if cid: claims[cid] = item return dict(sorted(claims.items())) def extract_elements(claim): elements = [] raw = claim.get("elements", []) if isinstance(raw, list): for elem in raw: if isinstance(elem, dict): el_text = elem.get("element", "") if el_text: elements.append(el_text) elif isinstance(elem, str) and elem.strip(): elements.append(elem.strip()) return elements if elements else None # ══════════════════════════════════════════════════════════════════════ # defense_rebuttal.md 파서 # # 테이블 형식: 키-값 전치 형태 (행 기준) # | 항목 | 내용/세부 | # |---|---| # | 유형 | 항변 - 소멸시효 완성 | # | 상대방 예상 항변/주장 | 피고는... | # | 핵심 쟁점 | 금전소비대차... | # ══════════════════════════════════════════════════════════════════════ def find_table_blocks(text): tables = [] current = [] in_table = False for line in text.split('\n'): stripped = line.strip() if stripped.startswith('|') and '|' in stripped[1:]: current.append(stripped) in_table = True else: if in_table and current: tables.append('\n'.join(current)) current = [] in_table = False if current: tables.append('\n'.join(current)) return tables def split_table_row(line): line = line.strip() if line.startswith('|'): line = line[1:] if line.endswith('|'): line = line[:-1] return [c.strip() for c in line.split('|')] def parse_kv_table(table_text): """ 키-값 전치 테이블을 dict로 파싱. | 항목 | 내용/세부 | |---|---| | key1 | val1 | | key2 | val2 | -> {"key1": "val1", "key2": "val2"} """ kv = {} lines = [l.strip() for l in table_text.strip().split('\n') if l.strip()] for line in lines: cells = split_table_row(line) # 구분선 스킵 if cells and all(re.match(r'^[-:]+$', c) for c in cells if c): continue if len(cells) >= 2: key = cells[0].strip() val = cells[1].strip() # 헤더행 스킵 (항목/내용 등) if key in ("항목", "항목명", "구분"): continue kv[key] = val return kv def parse_defense_rebuttal(md_text): """ defense_rebuttal.md 파싱. 테이블이 키-값 전치 형태: - 행 키 "상대방 예상 항변/주장" → primary_text - 행 키 "핵심 쟁점" → issue_focus claim_id별로 항변/재반박 1, 2 테이블의 값을 \\n으로 합침. """ defenses = {} # ### 헤딩으로 분할 (각 항변/재반박 테이블 단위) sections = re.split( r'(?=^###\s+C-\d{3})', md_text, flags=re.MULTILINE ) _log(f" [DEBUG] ### split: {len(sections)} sections") for section in sections: cid_match = re.search(r'(C-\d{3})', section) if not cid_match: continue cid = cid_match.group(1) tables = find_table_blocks(section) if not tables: continue # 키-값 테이블 파싱 kv = parse_kv_table(tables[0]) _log(f" [DEBUG] {cid}: kv keys={list(kv.keys())}") # "상대방 예상 항변/주장" 값 추출 primary = "" for k, v in kv.items(): if "항변" in k or "주장" in k or "상대방" in k: primary = v break # "핵심 쟁점" 값 추출 issue = "" for k, v in kv.items(): if "쟁점" in k: issue = v break # claim_id별 병합 if cid not in defenses: defenses[cid] = {"_primaries": [], "_issues": []} if primary: defenses[cid]["_primaries"].append(primary) if issue: defenses[cid]["_issues"].append(issue) # 최종 형태로 변환 result = {} for cid, d in defenses.items(): result[cid] = { "primary_text": "\n".join(d["_primaries"]), "issue_focus": "\n".join(d["_issues"]) if d["_issues"] else None, } _log(f" {cid}: primary={len(result[cid]['primary_text'])}chars, " f"issue={'yes' if result[cid]['issue_focus'] else 'no'}") return result # ══════════════════════════════════════════════════════════════════════ # Information Blocks 조립 # ══════════════════════════════════════════════════════════════════════ def build_information_blocks(claims, defenses): blocks = [] for cid in sorted(claims.keys()): claim = claims[cid] raw_type = claim.get("claim_type", "") normalized = normalize_case_type(raw_type) target = get_target(normalized) purpose = claim.get("purpose_sentence", "") cause = claim.get("cause_sentence", "") primary = purpose + ("\n" + cause if cause else "") blocks.append({ "claim_id": cid, "unit_type": "requirement", "case_type": normalized, "target": target, "query_context": { "primary_text": primary, "elements": extract_elements(claim), "issue_focus": None, }, }) defense = defenses.get(cid, {}) blocks.append({ "claim_id": cid, "unit_type": "defense", "case_type": normalized, "target": target.copy(), "query_context": { "primary_text": defense.get("primary_text", ""), "elements": None, "issue_focus": defense.get("issue_focus"), }, }) return blocks # ══════════════════════════════════════════════════════════════════════ # Entry point # ══════════════════════════════════════════════════════════════════════ def main(): with httpx.Client(timeout=60) as c: # 1) localdocs 연결 r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "info-blocks-gen", "version": "1.0"} } }, headers=HEADERS) sid = r.headers.get("mcp-session-id") if sid: HEADERS["mcp-session-id"] = sid c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "method": "notifications/initialized" }, headers=HEADERS) _log(f"1) Connected to localdocs (session: {sid})") r = c.post(LOCALDOCS_URL, json={ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }, headers=HEADERS) tools_result = parse_sse(r.text) tools = (tools_result.get("result", {}).get("tools", []) if tools_result else []) write_tool = next( (t for t in tools if "write" in t["name"]), None) # 2) 입력 파일 로딩 _log("\n2) Loading input files...") claim_data, claim_path = try_read( c, CLAIM_PACKETS_CANDIDATES, read_doc_json, 10) defense_text, defense_path = try_read( c, DEFENSE_MD_CANDIDATES, read_doc_text, 20) if claim_data is None: raise RuntimeError( f"Failed to load claim packets: {CLAIM_PACKETS_CANDIDATES}") if defense_text is None: raise RuntimeError( f"Failed to load defense rebuttal: {DEFENSE_MD_CANDIDATES}") _log(f" claim_packets: '{claim_path}' ({type(claim_data).__name__})") _log(f" defense_rebuttal: '{defense_path}' ({len(defense_text)} chars)") # 3) 파싱 _log("\n3) Parsing inputs...") claims = parse_claim_packets(claim_data) _log(f" {len(claims)} claims: {list(claims.keys())}") for cid, claim in claims.items(): raw_type = claim.get("claim_type", "?") norm = normalize_case_type(raw_type) elems = extract_elements(claim) _log(f" {cid}: '{raw_type}' -> '{norm}', " f"{len(elems) if elems else 0} elements") defenses = parse_defense_rebuttal(defense_text) _log(f" {len(defenses)} defense entries: {list(defenses.keys())}") # 4) Information Blocks 생성 _log("\n4) Building information blocks...") blocks = build_information_blocks(claims, defenses) _log(f" Generated {len(blocks)} blocks") output = { "meta": { "generated_at": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"), "input_claim_packets": claim_path, "input_defense_md": defense_path, "block_count": len(blocks), }, "information_blocks": blocks, } output_json = json.dumps(output, ensure_ascii=False, indent=2) # 5) localdocs에 저장 if write_tool: wr = call_tool(c, write_tool["name"], { "path": OUTPUT_NAME, "content": output_json, }, 30) if wr and "result" in wr: _log(f"\n5) Written to localdocs: {OUTPUT_NAME}") else: _log(f"\n5) Write to localdocs failed") print(output_json) if __name__ == "__main__": main() task_procedure: IN: nexts: ["information_blocks_generation"] wait_until: [] information_blocks_generation: nexts: ["OUT"] wait_until: [] prevs: [stage4_2_청구항변반박전략문서작성] nexts: [stage4_5_2_판례검색_쿼리생성] - name: stage4_5_2_판례검색_쿼리생성 tools: mcpServers: localdocs: type: streamable-http url: "http://mcp-localdocs:8012/mcp" description: Get the content of local documents description: 판례검색 쿼리 집합 생성 llm_provider: anthropic llm_model: claude-opus-4-5 prompts: - role: user content: | # Goal Generate a query set JSON (hybrid search) that contains: • “topic” • “keywords” (L1/L2/L3) • “semantic_sentence” • “variants” Strictly follow the Output Format. # IO - IN: • information_blocks_query.json • Default_Agent/Keywords_Criteria.txt - OUT: • query_case_search.json ## Speed Hard Constraints (MUST) 1. **입력 파일 재읽기 금지**: `read_doc`/동등 기능으로 input files는 **1회만** 읽는다. 2. **초안/미리보기/채팅 출력 금지**: 문서 본문(json 혹은 markdown 전체)을 대화 메시지로 출력하지 말고, **오직 `write_file` 1회로만 저장**한다. 3. **출력 파일 내용 재열람 금지**: 생성된 `query_case_search.json`를 다시 열어 읽거나(format 검증 목적 포함) 부분 발췌/요약을 출력하지 않는다. 4. **검증 최소화**: `write_file` 이후에는 **파일 존재 확인만 1회** 수행(예: `list_docs`)하고 종료한다. (내용 검증/형식 검증 금지) 5. **사고과정/추론문/설명문/주석/JSON 출력 금지**: 최종 산출물은 파일로만 저장. 6. **턴/호출 최소화**: 생성(write_file) 턴 + 존재확인(list_docs) 턴으로 **총 2턴에 종료**한다. # Source facts about inputs A) information_blocks_query.json • For each claim_id (C-###), there are two blocks distinguished by unit_type: • unit_type=“requirement” • unit_type=“defense” • You must generate one query unit per block in information_blocks (i.e., if meta.block_count=N then create N sets of L1/L2/L3; practically: one per information_blocks entry). For each block: • claim_id, unit_type, case_type, target.collection, target.tenant exist. • query_context.primary_text exists. • query_context.elements may be present (mainly requirement). • query_context.issue_focus may be present (mainly defense). Parsing rules (MUST): 1. If unit_type=“requirement”: • primary_text line 1 = 청구 취지 (purpose_statement) • primary_text line 2 = 청구 원인 (cause_statement) • elements array items = 요건 요소(요건사실) 2. If unit_type=“defense”: • primary_text line 1 = 피고의 예상 항변 (defense_statement) • primary_text line 2 = 항변에 대한 원고 재반박 논리 (rebuttal_statement; if absent, omit) • issue_focus text = 핵심 법적 쟁점들 B) Keywords_Criteria.txt • It specifies criteria for generating three types of keywords to retrieve highly similar precedents: • L1 = 법리 키워드 • L2 = 사실관계 키워드 • L3 = 조문요건요소 키워드 • You MUST read and apply: • # Topic 1: 법리 키워드 추출 기준 -> L1 • # Topic 2: 사실관계 키워드 추출 기준 -> L2 • # Topic 3: 조문요건요소 키워드 추출 기준 -> L3 # Output Format (STRICT JSON) { “units”: [ { “unit_id”: “C-###-R | C-###-D”, “claim_id”: “C-###”, “unit_type”: “requirement | defense”, “case_type”: “”, “target”: { “collection”: “”, “tenant”: “” }, “queries”: [ { “qid”: “C-###-requirement | C-###-defense”, “topic”: “<20글자 이내>”, “alpha_basis”: “<법리|사실관계|조문요건|복합>”, “keywords”: { “L1”: [], “L2”: [], “L3”: [] }, “semantic_sentence”: “<35단어 이내>”, “variants”: [ { “variant”: “primary|broad|narrow”, “call”: { “tool”: “search_hybrid”, “args”: { “collection_name”: “”, “tenant”: “”, “query”: “”, “alpha”: 0.55, “limit”: 15, “bm25_operator”: “and”, “fusion_type”: “relative_score” } } } ] } ] } ] } # Call 객체 (MUST) { “tool”: “search_hybrid”, “args”: { “collection_name”: “”, “tenant”: “”, “query”: “”, “alpha”: <0.45|0.55|0.65>, “limit”: <10|15|25>, “bm25_operator”: “”, “fusion_type”: “” } } # How to write each field 1) “keywords” (L1/L2/L3) Common: • Use ONLY information_blocks_query.json + Keywords_Criteria.txt. • Apply each criteria section exactly: • Topic 1 -> L1 (<=8) • Topic 2 -> L2 (<=6) • Topic 3 -> L3 (<=6) Input text for applying criteria: A) requirement block: • purpose_statement (primary_text 1st line) • cause_statement (primary_text 2nd line) • elements (요건요소 항목들) B) defense block: • defense_statement (primary_text 1st line) • rebuttal_statement (primary_text 2nd line, if present) • issue_focus (핵심 법적 쟁점 텍스트) 2) “semantic_sentence” System Requirement (MUST APPLY) You are a legal-retrieval query writer for Korean litigation precedents. Your task is to generate up to 3 Korean semantic sentences to retrieve highly similar precedents via vector search (hybrid search context). Hard constraints: • Output MUST be no more than 3 sentences total, in Korean, as plain text (no bullets, no JSON, no headings). • Do NOT invent facts that are not present in the input. If a detail is missing, omit it rather than guessing. • Incorporate (as available) the claim type (청구취지), legal basis/cause of action (청구원인), and statutory elements (요건요소/조문요건요소 키워드) together with the core fact pattern. • Prefer legally canonical phrasing used in judgments (e.g., “채무불이행”, “불법행위”, “부당이득”, “해제/해지”, “인과관계”, “고의·과실”, “위법성”, “손해 및 상당인과관계”). • Optimize for retrieval recall: include 1–2 key synonym pairs in parentheses only when they materially broaden matching. • Always bind facts to legal elements using explicit connectors such as “~에 해당하는지”, “~요건(성립요건)”, “~이 쟁점이 되는 사안”. Quality target: • Sentence 1: compact factual pattern and dispute core. • Sentence 2: cause of action + statutory elements framed as issues to be proven. • Sentence 3 (optional): requested relief and major contested points (liability scope, defenses). How to Perform Tasks (MUST APPLY) Using ONLY the information below, write a precedent-retrieval semantic text (≤3 sentences total). [INPUT JSON] Required coverage (use what exists; omit what does not): • 법률 키워드(“L1”) • 사실관계 키워드(“L2”) • 조문요건요소 키워드(“L3”) • 청구취지(“purpose_statement”) [requirement only] • 청구원인(“cause_statement”) [requirement only] • 요건요소(요건사실)(“elements”) [requirement if present] • 항변(“defense_statement”) / 재반박(“rebuttal_statement”) / 핵심쟁점(“issue_focus”) [defense only] Hard Constraints: • If the input is long, prioritize: (1) dispute-triggering act/transaction, (2) cause of action, (3) 2–4 most discriminative elements, (4) relief type. • Do not include: “제공된 정보에 따르면”, “추정컨대”, “알 수 없음”, “N/A”, or any commentary about missing data. Output rules: • Plain Korean text, ≤3 sentences total. • No lists, no citations, no meta commentary. Example (format illustration only): • Input: 청구원인=민법 제750조 불법행위, 요건요소=고의·과실/위법성/손해/상당인과관계, 사실=온라인 게시물로 명예훼손 주장, 청구취지=손해배상 • Output (≤3 sentences): “피고의 온라인 게시물로 원고의 사회적 평가가 저하되었다고 주장하며 손해배상을 구하는 사안이다. 민법 제750조 불법행위 성립을 위해 피고의 고의·과실, 위법한 표현행위, 원고의 손해 및 상당인과관계가 쟁점이 된다. 원고는 재산상·정신적 손해에 대한 배상을 청구한다.” 3) “topic” System Requirements (MUST APPLY) You are a legal topic labeler for Korean precedent retrieval in a hybrid (keyword + vector) search system. Task: Generate a concise “topic” that best represents the current case for retrieving highly similar precedents. Hard constraints: • Do NOT invent facts not present in the input. • Avoid case-specific identifiers (names, dates, amounts, addresses, account numbers). • Prefer canonical legal taxonomy used in judgments: e.g., 채무불이행, 불법행위, 부당이득, 해제/해지, 하자, 상당인과관계, 고의·과실, 위법성, 귀책사유, 입증책임. • The topic must integrate, when available: (i) 청구취지(구제 유형), (ii) 청구원인(법적 성질), (iii) 요건요소(핵심 요건사실), plus the core fact-pattern category. • Do not output lists, bullet points, headings, citations, or meta commentary. • If the input is long, prioritize in this order: dispute-triggering transaction/act → cause of action → 2–4 key elements → relief type. • Add at most one synonym pair in parentheses only when it increases recall (e.g., 채무불이행(불완전이행)). • Never include phrases like “제공된 정보에 따르면”, “추정컨대”, “알 수 없음”, “N/A”. • Avoid overly generic topics such as “손해배상 청구”; always anchor to a fact-pattern category (e.g., 임대차/매매/도급/대여금/의료/교통사고 등) when available. Output format (choose one): Option A (default): Output exactly ONE Korean noun-phrase topic in a single line. Option B (if enabled by input flag): Output JSON with two fields: {“topic_phrase”: “…”, “topic_sentence”: “…”} In both options, keep it compact and discriminative. How to perform Task (MUST APPLY) Generate the topic using ONLY the information below. [INPUT] Rules: • If multiple claims/causes exist, prioritize the most central claim and the most discriminative elements. • Do not repeat raw keyword lists; synthesize them into a legal-topic label. • Output must follow the System output format. • 문자 수 상한(topic_phrase 90자): 초과 시 재생성 Example (format only): Input: • L1: [채무불이행, 계약해제, 손해배상] • L2: [매매계약, 목적물 하자, 대금 지급, 하자 통지] • L3: [하자, 귀책사유, 해제 요건, 손해 및 상당인과관계] • 청구취지: 매매대금 반환 및 손해배상 • 청구원인: 채무불이행(불완전이행) 및 계약해제 • 요건요소: 하자 존재, 통지, 귀책사유, 손해·인과관계 Output: “매매 목적물 하자에 따른 계약해제 및 매매대금 반환·손해배상 청구” 4) “variants” Variant parameter table (MUST): • primary: bm25_operator=“and”, limit=15, fusion_type=“relative_score” (필수: 모든 query) • broad: bm25_operator=“or”, limit=25, fusion_type=“relative_score” (쟁점 다양성 큼 또는 예외 탐색 필요) • narrow: bm25_operator=“and”, limit=10, fusion_type=“ranked” (단일 요건요소 정밀 타격) Variant inclusion rules (minimal, deterministic): • Always include primary. • Include broad if unit_type=“defense” OR issue_focus is non-empty OR elements length >=5. • Include narrow if there exists a single clearly focal element in elements or L3. Alpha defaults: • primary alpha=0.55 • broad alpha=0.45 • narrow alpha=0.65 5) “alpha_basis” (simple rule) • If L1,L2,L3 all non-empty => “복합” • Else if only L1 non-empty => “법리” • Else if only L2 non-empty => “사실관계” • Else => “조문요건” 6) Construct each variant.call.args.query (single string) • primary/broad: query = “ ” • narrow: query = “ ” Do not add labels like “L1:”. # Final hard constraints (MUST) • Output ONLY the final query_case_search.json as strict JSON. • No commentary, no headings, no markdown. • Do not execute searches or tools.