@simplysm/sd-claude 14.0.91 → 14.0.92

package/claude/skills/sd-skill/SKILL.md

@@ -1,245 +0,0 @@
----
-name: sd-skill
-description: 사용자가 정의한 작업 도메인을 SKILL.md + (필요 시) scripts 묶음으로 생성·수정. Use when 새 스킬을 작성하거나 기존 스킬을 수정할 때.
----
-
-# 스킬 작성
-
-워크플로 = 아래 "1단계 ~ 5단계" 순서로 처음부터 끝까지 읽으며 그대로 수행.
-
-사용자에게 질문하는 시점 = 1단계(의도 정의)의 의도 합의 + 2단계(Eval 케이스 정의)의 case `input` 발화 선택. 2~5단계의 그 외 작업은 1단계 합의를 기반으로 자동 진행, 부족 발견 시 1단계로 회귀.
-
-## 1단계. 의도 정의
-
-다음 파악:
-
-- 스킬 목적은? (한 줄 동사형) + 커버 유즈케이스는?
-- 주요 사용자 입력 시나리오는? (호출 트리거 발화 형태)
-- 핵심 산출물은? (생성·수정 대상 파일·디렉토리 형태) — 2단계(Eval 케이스 정의)의 rubric 형식 검증 근거
-- 실행 스크립트 필요 / 지침만으로 충분?
-- 함께 포함할 참고 자료?
-
-## 2단계. Eval 케이스 정의
-
-채점 케이스: `evals/golden.jsonl`. 케이스 초기 워크스페이스: `evals/fixtures/<name>/`.
-
-### 자동답변 환경
-
-Eval(자동 평가) 실행 시 사용자 응답 불가. 대상 스킬은 입력 필요 시점마다 **스스로 답변**하며 끝까지 진행 (대화 흐름·산출물 형식 검증용). 케이스 설계는 이 제약을 전제로 함.
-
-- `input` = 1턴 사용자 발화. 후속 응답 가정 안 함.
-- rubric(채점 항목) = 자체 답변 가능 영역만 검증: 산출물 존재 여부·형식·구조, 흐름 진행 여부, frontmatter 키 존재 여부 등. *"사용자가 X 를 골랐을 때 Y 가 나오는가"* 처럼 특정 사용자 응답 값에 의존하는 항목 금지 (자체 답변값은 매번 달라짐).
-- **사용자 응답 발생 자체에 의존하는 rubric 금지**: 대상 스킬이 "사용자 질문"·"OPEN 처리/대기"·"임의 채움 금지" 룰을 보유해도, 룰 발현 자체는 Eval 검증 불가. 자동답변 환경은 사용자 답변을 즉시 생성·진행 → "사용자 질문/대기" 흐름 본질적으로 발생하지 않음.
-  - ❌ `"사용자에게 질문하거나 OPEN 처리하는 흐름이 등장하는가"` (자체 답변으로 채운 뒤 진행 = 위반 아니라 환경 정상 동작).
-  - ❌ `"임의 채움 흔적이 없는가"` (자체 답변 자체가 "임의 채움" 으로 보임).
-  - 대응: 케이스 재설계 또는 `input` 본문에 룰 강조 명시 (예: "모호 발견 시 보류 마커만 산출물에 박고 종료").
-- fixture = 자체 답변이 차단되지 않게 구성. 외부 시크릿·실시간 API 없이 진행 가능한 초기 상태로.
-
-### 근거 제약
-
-Eval 입력 및 rubric 의 근거 = **1단계(의도 정의)에서 합의된 의도뿐**. 이전 버전 동작·대화 메모리의 옛 맥락, **타 스킬의 `evals/golden.jsonl` rubric** 인용 금지.
-
-- 합의된 의도에 없는 동작은 입력·rubric 둘 다 등장 금지.
-- "이전 버전과 다르게 X 하는가" 형태의 부정형(negative) rubric 금지. 현재 의도상 X 가 요구되면 `"X 하는가"` 로 직접 검증.
-- **타 스킬 rubric 답습 금지**: 비슷한 도메인의 스킬이라도 rubric 은 본 스킬의 1단계에서 합의된 의도에서 직접 도출. 타 스킬 rubric 을 참고용으로 열어보는 것도 금지 (복제 유혹 차단).
-
-### 골든 케이스
-
-`evals/golden.jsonl`, 한 줄 한 케이스:
-
-```json
-{"id": "case-001", "input": "/<skill-name> ...", "rubric": ["rubric 항목 1", "rubric 항목 2"], "fixture": "<fixture-dir-name>"}
-```
-
-- `id`: 케이스 식별자.
-- `input`: 평가 대상 스킬에 전달할 사용자 입력. 1단계의 시나리오를 기반으로 LLM 이 발화 후보를 제시한 뒤 사용자가 선택.
-- `rubric`: PASS/FAIL 판정 항목 목록.
-- `fixture`: 케이스 시작 시점의 샌드박스 초기 상태 디렉토리 이름.
-
-**케이스 크기**: 한 케이스의 작업량이 단일 실행 컨텍스트를 소진할 정도로 크면 안 됨. Eval 목적 = 흐름·산출물 형식 검증 → 풀 구현·대량 분석을 요구하는 input 은 회피하고 최소 시연 수준으로 좁힘. 본질이 큰 풀 구현 스킬의 경우, input 에 평가 환경임을 알리는 단서를 포함해 rubric 검증에 불필요한 워크플로 단계를 명시적으로 건너뛰게 함.
-
-### Rubric 작성
-
-각 항목은 **PASS/FAIL 판정이 가능한 검증 항목**으로 작성. 추상 표현은 judge(채점 에이전트) 판단이 흔들리므로 회피.
-
-**모호 부사·형용사 회피** ("잘"·"적절히"·"합리적으로"·"명확히" → 기준이 사람마다 다름):
-
-- ❌ `"한국어 지원이 잘 되었는가?"` ("잘" 모호).
-- ✅ `"본문에 한국어 응답 강제 지시가 명시적 문장으로 들어갔는가?"`.
-
-**형식 검증 선호** (의미보다 형식·존재 여부 기준으로 작성하면 judge 흔들림이 줄어듦):
-
-- ❌ `"description 이 트리거 조건을 명확히 표현하는가?"`.
-- ✅ `"description 끝에 'Use when ~' 형식 문장이 포함되었는가?"`.
-
-**관찰 가능 산출물에 묶기** (파일 존재·특정 키 포함·특정 디렉토리 구조 등 tree/events 에서 직접 확인 가능한 사실):
-
-- ✅ `"기존 .claude/skills/review/SKILL.md 파일이 손실되지 않고 보존되었는가?"`.
-- ✅ `"SKILL.md frontmatter 에 name·description 키 모두 존재하는가?"`.
-
-**명세 어휘 매칭 금지**: 명세의 특정 단어를 rubric 에 그대로 박아 정확 매칭을 요구하지 말 것. LLM 응답은 동의어·다른 표현으로 동일 본질을 전달하므로, 어휘 정확 매칭은 본질과 무관한 FAIL 을 양산함. rubric 은 본질(형식·구조·존재 여부)만 검증.
-
-- ❌ `"분해 표 첫 컬럼이 '항목' 인가"` (LLM 이 'ID'·'식별자' 로 출력해도 본질 동일).
-- ✅ `"분해 표가 마크다운 표 형식으로 출력되고 컬럼 6개 모두 존재하는가"`.
-
-**도구명 매칭 금지**: "events(에이전트 이벤트 시퀀스)에 특정 도구(Glob/Grep/Read 등) 호출이 있는가" 형태의 rubric 은 그 도구 사용 자체가 본질일 때만 사용. 본질이 "탐색·조사·읽기" 등 행위라면 동등한 효과를 내는 다른 도구(Bash 의 ls/find/dir/cat 등)도 PASS 로 인정.
-
-- ❌ `"events 에 Glob 또는 Grep 호출이 1회 이상 있는가"` (Bash ls/find 로 동등 효과인데 FAIL).
-- ✅ `"events 에 코드베이스 탐색 흔적(Glob·Grep 호출 또는 Bash 의 ls/find/dir 등 동등 명령) 이 1회 이상 있는가"`.
-
-### Fixtures
-
-`evals/fixtures/<name>/` 디렉토리는 케이스 시작 시점의 샌드박스 초기 상태. 케이스 실행 시 샌드박스로 통째로 복사됨.
-
-- **빈 워크스페이스**: 디렉토리만 둠 (`.gitkeep` 등으로 자리 표시).
-- **기존 스킬 수정 케이스**: 그 스킬의 SKILL.md 및 관련 파일을 미리 배치.
-
-예: `with-existing-review/.claude/skills/review/SKILL.md` — 케이스 시작 시 review 스킬이 이미 존재하는 상태.
-
-### 케이스 커버리지
-
-골든 셋이 단순 PASS 외에 다음 분기를 커버하면 회귀 감지가 강화됨:
-
-- 신규 작성 케이스와 기존 수정 케이스 각각.
-- 워크플로 주요 분기점 (예: 스크립트 필요/불필요, 참조 파일 분리 필요/불필요).
-- 과거 실패 패턴 — FAIL 케이스의 reason(실패 사유)을 분석한 뒤 재발 방지용으로 추가.
-
-## 3단계. 스킬 작성
-
-간결·명확한 SKILL.md 와 별도 참고 파일(필요 시), 유틸리티 스크립트(필요 시)로 구성.
-
-### 디렉토리 구조
-
-```
-.claude/
-└── skills/
-    └── <skill-name>/
-        ├── SKILL.md             # 스킬 본문 (필수)
-        ├── evals/               # Eval 정의 (필수)
-        │   ├── golden.jsonl     # 케이스 목록
-        │   └── fixtures/        # 케이스별 초기 워크스페이스
-        │       └── <name>/
-        ├── references/          # 상세 문서 (선택)
-        │   └── *.md
-        └── scripts/             # 유틸리티 (선택)
-            └── *.py
-```
-
-### SKILL.md 템플릿
-
-frontmatter:
-
-```markdown
----
-name: skill-name
-description: 기능 설명. Use when [활용상황]
----
-```
-
-본문은 다음 "본문 작성 원칙" 따름.
-
-### description (frontmatter 의 description 필드)
-
-에이전트의 라우팅 진입점. 에이전트가 description 을 보고 사용자 요청에 맞는 스킬을 호출함.
-
-**전달 정보**:
-
-- 이 스킬의 목적.
-- 트리거 맥락 (언제·왜).
-- 타 스킬과 구분 단서.
-
-**형식**:
-
-- 최대 200자, 한 줄로 작성.
-- 3인칭으로 작성.
-- 첫 문장: 입력에서 산출물(또는 효과)로의 변환을 기술. 내부 처리 단계 기술 금지.
-- 두 번째 문장: "Use when [활용상황]" 형식.
-
-**금지**: 내부 단계·알고리즘·사용 도구·로직 흐름은 SKILL.md 본문 워크플로의 몫. description 은 외부에서 관찰 가능한 경계(입력·산출물·트리거)만 노출.
-
-### 본문 작성 원칙
-
-YAGNI(You Aren't Gonna Need It) 원칙 — 2단계 케이스가 통과되는 최소 본문만 작성. 케이스가 검증하지 않는 절·예시·옵션 추가 금지.
-
-- **워크플로 단위 어휘 통일**: "사이클"(반복형) 또는 "단계"(순차형) 중 하나를 선택해 본문 전체에서 일관 사용.
-- **본문 어휘 일관**: 같은 개념은 같은 단어로 표기. 동의어 혼용 금지.
-- **스스로 검증 게이트**(해당 시): 출력 직전 자문 항목을 본문에 명시하여 스킬 고유의 형식·근거·단순화 차단을 점검.
-- **모범 예시 인용**(해당 시): 형식을 따라야 할 산출물이 있으면 `references/example-X.md` 에 보관하고 본문에서 한 줄로 참조.
-- **도구명 박기 금지**: 본문에 Glob·Grep 등 도구명을 직접 박지 않음. "코드베이스 탐색"·"파일 읽기" 등 동등한 행위 표현으로 작성 (2단계 rubric 의 "도구명 매칭 금지" 와 일관).
-
-### 스크립트 추가 기준
-
-다음 조건에 해당하면 유틸리티 스크립트 추가:
-
-- 동작이 결정론적(deterministic)인 경우 (validation·formatting 등).
-- 코드 생성 결과가 매번 동일한 경우.
-- 에러를 명시적으로 처리해야 하는 경우.
-
-스크립트는 토큰 절약과 안정성 개선에 기여.
-
-**작성 원칙**:
-
-- Python(`.py`) 으로 작성.
-- 내부 에러 처리 금지. 에러는 즉시 throw.
-
-### 파일 분리 기준
-
-다음 조건에 해당하면 별도 파일로 분리:
-
-- SKILL.md 분량이 에이전트가 한 자리에서 워크플로 흐름을 인식하기 어려울 만큼 누적된 경우.
-- 명백히 다른 도메인을 다루는 경우.
-- 거의 사용되지 않는 고급 기능인 경우.
-
-**참조 깊이 한 단계 제한**: SKILL.md 에서 `references/X.md` 까지만 참조 허용. references 파일 안에서 또 다른 파일을 참조하는 것 금지.
-
-## 4단계. Eval 실행
-
-### 명령
-
-`python .claude/skills/sd-skill/scripts/run_eval.py <대상-스킬-이름>`.
-
-대상 스킬에 `evals/golden.jsonl` 과 `evals/fixtures/<fixture-name>/` 가 모두 존재해야 함.
-
-### 동작
-
-케이스마다 다음 순서로 실행:
-
-1. 격리 작업 공간 준비 (`.claude/` 복사 후 fixture 오버레이).
-2. 대상 스킬 실행. `EVAL_MODE_PREFIX`(자동 평가 모드 안내 문구)가 사용자 입력 앞에 붙어, 대상 스킬이 입력 필요 시점마다 스스로 답변하며 끝까지 진행하도록 지시. 자체 답변은 사용자의 명시적 발언과 동등하게 취급됨 (다이얼로그 기반 스킬도 평가 가능. 단, 자체 답변이므로 흐름·형식 검증용으로 한정).
-3. 에이전트 동작 기록 및 종료 시점의 파일 트리 수집.
-4. 별도의 평가 에이전트가 rubric 항목별로 PASS/FAIL 을 채점하고, 모든 항목이 PASS 일 때 케이스 PASS 로 판정.
-
-### 출력 구조
-
-stdout 으로 summary JSON 출력. 포함 필드는 다음과 같음.
-
-- `run_id`, `results_dir`.
-- `summary`: total / pass / fail / error 카운트.
-- `cases[]`: 케이스별 verdict(판정 결과)와 결과 디렉토리 경로.
-
-각 케이스 결과 파일 (`results_dir/cases/<id>/`):
-
-- `judge_output.json` — rubric 항목별 PASS/FAIL 판정과 reason(사유).
-- `events.json` — 에이전트 이벤트 시퀀스.
-- `tree.json` — 샌드박스 종료 시점의 파일 트리.
-
-## 5단계. 개선 및 리뷰
-
-### FAIL 처리
-
-- 보고: 전체 PASS/FAIL 카운트와 FAIL 케이스 목록.
-- FAIL reason(실패 사유) 분석:
-  - 결과 파일(`judge_output.json`·`events.json`·`tree.json`) 읽기.
-  - 스킬 본문과 Eval rubric 중 어느 쪽 문제인지 판단:
-    - **스킬 측 문제**: 본문 명세대로 동작했는데도 FAIL → 명세가 비어있거나 모호함 → 본문 보강.
-    - **Eval 측 문제**: 본문 명세를 만족했는데 rubric 이 본질 외 요소(어휘 매칭·도구명 매칭 등)로 FAIL → rubric 수정 (2단계 rubric 안티패턴 참조).
-    - **모호한 경우**: 사용자에게 질문.
-- 수정 후 같은 골든 셋 전체로 4단계 재실행.
-- **수렴 한도**: 같은 케이스가 3회 연속 FAIL 시 진행 중단하고 사용자에게 보고 (무한 루프 방지).
-- 새로운 실패 패턴은 골든 셋에 케이스로 추가.
-
-### 리뷰
-
-전 케이스 PASS 후 sd-review 호출. 적용 룰: 행동 규칙과 3단계의 "본문 작성 원칙"·"파일 분리 기준".
-
-리뷰 결과로 수정 발생 시 4단계 재실행.

package/claude/skills/sd-skill/scripts/run_eval.py

@@ -1,380 +0,0 @@
-"""sd-skill eval harness.
-
-지정된 대상 스킬을 평가한다. 각 케이스를 격리된 샌드박스에서 실행하고,
-MCP submit_verdict 도구로 채점한 결과를 디스크에 저장한 뒤 stdout으로 summary JSON을 출력한다.
-
-Usage: python run_eval.py <target-skill-name>
-"""
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import shutil
-import sys
-import time
-import traceback
-from datetime import datetime
-from pathlib import Path
-from typing import Annotated, Any
-
-EXCLUDED_DIRS = frozenset({"node_modules", ".git", "dist", ".cache", "__pycache__"})
-
-
-def _ensure_pip(import_name: str, pip_name: str | None = None) -> None:
-    import importlib
-    try:
-        importlib.import_module(import_name)
-    except ImportError:
-        import subprocess
-        subprocess.check_call(
-            [sys.executable, "-m", "pip", "install", pip_name or import_name]
-        )
-
-
-_ensure_pip("claude_agent_sdk", "claude-agent-sdk")
-
-from claude_agent_sdk import (
-    AssistantMessage,
-    ClaudeAgentOptions,
-    ResultMessage,
-    TextBlock,
-    ToolUseBlock,
-    create_sdk_mcp_server,
-    query,
-    tool,
-)
-
-sys.path.insert(0, ".claude/scripts")
-from sd_paths import resolve_tmp_base
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-SKILLS_DIR = SCRIPT_DIR.parent.parent  # .claude/skills/
-PROJECT_ROOT = SKILLS_DIR.parent.parent  # repo root
-
-
-def load_eval_root(target_skill_name: str) -> Path:
-    return resolve_tmp_base() / "evals" / target_skill_name
-
-
-def sweep_stale(runs_dir: Path, max_age_hours: int = 24) -> None:
-    if not runs_dir.exists():
-        return
-    cutoff = time.time() - max_age_hours * 3600
-    for d in runs_dir.iterdir():
-        try:
-            mtime = d.stat().st_mtime
-        except OSError as e:
-            sys.stderr.write(f"[sweep_stale] stat failed: {d}: {e}\n")
-            continue
-        if mtime < cutoff:
-            shutil.rmtree(d, ignore_errors=True)
-
-
-def serialize_block(block: Any) -> dict:
-    if isinstance(block, ToolUseBlock):
-        return {"type": "tool_use", "name": block.name, "input": block.input}
-    if isinstance(block, TextBlock):
-        return {"type": "text", "text": block.text}
-    return {"type": type(block).__name__}
-
-
-def serialize_message(msg: Any) -> dict:
-    if isinstance(msg, AssistantMessage):
-        return {"type": "assistant", "content": [serialize_block(b) for b in msg.content]}
-    if isinstance(msg, ResultMessage):
-        return {
-            "type": "result",
-            "subtype": getattr(msg, "subtype", None),
-            "duration_ms": getattr(msg, "duration_ms", None),
-        }
-    return {"type": type(msg).__name__}
-
-
-def walk_tree(root: Path, exclude_skill_names: set[str], max_file_bytes: int = 20000) -> dict:
-    files: dict[str, str] = {}
-    for dirpath, dirnames, filenames in os.walk(root):
-        rel_dir = Path(dirpath).relative_to(root).as_posix()
-        rel_parts = rel_dir.split("/") if rel_dir != "." else []
-        # prune .claude/skills/<excluded>/ subtrees
-        if len(rel_parts) == 2 and rel_parts[0] == ".claude" and rel_parts[1] == "skills":
-            dirnames[:] = [d for d in dirnames if d not in exclude_skill_names]
-        # prune standard excluded dirs (node_modules, .git, etc.)
-        dirnames[:] = [d for d in dirnames if d not in EXCLUDED_DIRS]
-
-        for fname in filenames:
-            p = Path(dirpath) / fname
-            rel = p.relative_to(root).as_posix()
-            try:
-                content = p.read_text(encoding="utf-8")
-                if len(content) > max_file_bytes:
-                    content = content[:max_file_bytes] + f"\n... <truncated, {p.stat().st_size} bytes total>"
-                files[rel] = content
-            except (UnicodeDecodeError, OSError):
-                try:
-                    size = p.stat().st_size
-                except OSError:
-                    size = -1
-                files[rel] = f"<binary or unreadable, {size} bytes>"
-    return files
-
-
-def copy_dot_claude(src_dot_claude: Path, dst_dot_claude: Path) -> None:
-    """Copy .claude/ to sandbox, excluding each skill's evals/ subfolder."""
-    def _ignore(dir_path: str, names: list[str]) -> list[str]:
-        ignored = {"__pycache__"}
-        d = Path(dir_path)
-        try:
-            rel = d.relative_to(src_dot_claude).as_posix()
-        except ValueError:
-            return list(ignored & set(names))
-        parts = rel.split("/") if rel != "." else []
-        # .claude/skills/<name>/  → ignore evals
-        if len(parts) == 2 and parts[0] == "skills":
-            ignored.add("evals")
-        return [n for n in names if n in ignored]
-
-    shutil.copytree(src_dot_claude, dst_dot_claude, ignore=_ignore, dirs_exist_ok=True)
-
-
-def merge_overlay(src: Path, dst: Path) -> None:
-    """Copy src tree on top of dst, overwriting files where they collide."""
-    for p in src.rglob("*"):
-        rel = p.relative_to(src)
-        target = dst / rel
-        if p.is_dir():
-            target.mkdir(parents=True, exist_ok=True)
-        else:
-            target.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(p, target)
-
-
-EVAL_MODE_PREFIX = """<eval-mode>
-- 사용자 응답을 직접 받을 수 없습니다.
-- 사용자 입력이 필요한 시점이 오면 합리적인 답변을 자체 생성해서 자동 적용하고 진행하세요.
-- 자체 생성한 답변은 **사용자가 직접 명시한 발언과 동등**하게 취급합니다. 결정 근거(사용자 답변)로 그대로 사용하고, 같은 사안을 사용자에게 다시 묻지 마세요.
-- 자동 답변한 내용은 텍스트 출력에 명시하세요 (어떤 시점에 어떻게 답변했는지).
-- 워크플로 끝까지 완수 후 종료하세요.
-</eval-mode>
-
-"""
-
-
-async def run_target(case_input: str, sandbox: Path) -> list[dict]:
-    events: list[dict] = []
-    async for msg in query(
-        prompt=EVAL_MODE_PREFIX + case_input,
-        options=ClaudeAgentOptions(
-            cwd=str(sandbox),
-            permission_mode="bypassPermissions",
-            disallowed_tools=["WebFetch", "WebSearch"],
-        ),
-    ):
-        events.append(serialize_message(msg))
-    return events
-
-
-JUDGE_TOOL_SCHEMA = {
-    "type": "object",
-    "properties": {
-        "verdict": {"type": "string", "enum": ["PASS", "FAIL"]},
-        "items": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "properties": {
-                    "check": {"type": "string"},
-                    "result": {"type": "string", "enum": ["PASS", "FAIL"]},
-                    "reason": {"type": "string"},
-                },
-                "required": ["check", "result"],
-            },
-        },
-    },
-    "required": ["verdict", "items"],
-}
-
-
-def build_judge_prompt(case: dict, events: list[dict], tree: dict) -> str:
-    rubric_lines = "\n".join(f"{i + 1}. {r}" for i, r in enumerate(case["rubric"]))
-    events_str = json.dumps(events, ensure_ascii=False, indent=2)
-    tree_str = json.dumps(tree, ensure_ascii=False, indent=2)
-    return (
-        "당신은 엄격한 평가자입니다.\n\n"
-        "[케이스 입력]\n"
-        f"{case['input']}\n\n"
-        "[에이전트가 일으킨 이벤트]\n"
-        f"{events_str}\n\n"
-        "[샌드박스 종료 시 파일트리]\n"
-        f"{tree_str}\n\n"
-        "[Rubric 항목]\n"
-        f"{rubric_lines}\n\n"
-        "각 rubric 항목을 PASS 또는 FAIL 로 판정합니다.\n"
-        "- 모든 항목 PASS → 케이스 verdict = PASS\n"
-        "- 한 항목이라도 FAIL → 케이스 verdict = FAIL\n"
-        "- FAIL 항목에는 짧은 reason 을 적습니다 (PASS는 reason 생략).\n\n"
-        "submit_verdict 호출 시 'items' 배열의 각 'check' 필드에는 위 [Rubric 항목] 의 원문 문장을 "
-        "번호 없이 그대로 복사해 넣어야 합니다. 요약·축약·번호화 금지.\n\n"
-        "submit_verdict 도구를 정확히 한 번 호출해 결과를 제출하세요. 다른 텍스트 출력 금지."
-    )
-
-
-async def run_judge(case: dict, events: list[dict], tree: dict) -> dict:
-    captured: dict = {}
-
-    @tool(
-        "submit_verdict",
-        "Submit final verdict after evaluating each rubric item.",
-        JUDGE_TOOL_SCHEMA,
-    )
-    async def submit_verdict(args):
-        captured.update(args)
-        return {"content": [{"type": "text", "text": "ok"}]}
-
-    server = create_sdk_mcp_server(name="judge", tools=[submit_verdict])
-
-    async for _ in query(
-        prompt=build_judge_prompt(case, events, tree),
-        options=ClaudeAgentOptions(
-            mcp_servers={"judge": server},
-            allowed_tools=["mcp__judge__submit_verdict"],
-            permission_mode="bypassPermissions",
-            max_turns=5,
-        ),
-    ):
-        pass
-
-    return captured
-
-
-async def run_case(
-    case: dict,
-    run_id: str,
-    eval_root: Path,
-    fixtures_dir: Path,
-) -> dict:
-    case_id = case["id"]
-    sandbox = eval_root / "runs" / run_id / case_id
-    case_results = eval_root / "results" / run_id / "cases" / case_id
-    case_results.mkdir(parents=True, exist_ok=True)
-
-    fixture_dir = fixtures_dir / case["fixture"]
-    src_dot_claude = PROJECT_ROOT / ".claude"
-    src_skills_dir = src_dot_claude / "skills"
-    fixture_skills_dir = fixture_dir / ".claude" / "skills"
-
-    pre_existing_skills = {d.name for d in src_skills_dir.iterdir() if d.is_dir()}
-    fixture_skills = (
-        {d.name for d in fixture_skills_dir.iterdir() if d.is_dir()}
-        if fixture_skills_dir.exists()
-        else set()
-    )
-    exclude_skill_names = pre_existing_skills - fixture_skills
-
-    try:
-        if sandbox.exists():
-            shutil.rmtree(sandbox, ignore_errors=True)
-        sandbox.mkdir(parents=True, exist_ok=True)
-
-        copy_dot_claude(src_dot_claude, sandbox / ".claude")
-        merge_overlay(fixture_dir, sandbox)
-
-        events = await run_target(case["input"], sandbox)
-        tree = walk_tree(sandbox, exclude_skill_names=exclude_skill_names)
-
-        (case_results / "events.json").write_text(
-            json.dumps(events, ensure_ascii=False, indent=2), encoding="utf-8"
-        )
-        (case_results / "tree.json").write_text(
-            json.dumps(tree, ensure_ascii=False, indent=2), encoding="utf-8"
-        )
-
-        verdict_data = await run_judge(case, events, tree)
-        (case_results / "judge_output.json").write_text(
-            json.dumps(verdict_data, ensure_ascii=False, indent=2), encoding="utf-8"
-        )
-
-        verdict = verdict_data.get("verdict", "ERROR")
-
-        return {
-            "id": case_id,
-            "verdict": verdict,
-            "dir": str(case_results),
-        }
-    except Exception as e:
-        (case_results / "error.txt").write_text(
-            f"{type(e).__name__}: {e}\n\n{traceback.format_exc()}",
-            encoding="utf-8",
-        )
-        return {
-            "id": case_id,
-            "verdict": "ERROR",
-            "error": f"{type(e).__name__}: {e}",
-            "dir": str(case_results),
-        }
-    finally:
-        shutil.rmtree(sandbox, ignore_errors=True)
-
-
-def load_cases(golden_path: Path) -> list[dict]:
-    cases = []
-    for line in golden_path.read_text(encoding="utf-8").splitlines():
-        line = line.strip()
-        if line:
-            cases.append(json.loads(line))
-    return cases
-
-
-async def main() -> None:
-    if len(sys.argv) < 2:
-        sys.stderr.write("Usage: python run_eval.py <target-skill-name>\n")
-        sys.exit(2)
-    target_skill_name = sys.argv[1]
-    target_skill_dir = SKILLS_DIR / target_skill_name
-    if not target_skill_dir.is_dir():
-        sys.stderr.write(f"target skill not found: {target_skill_dir}\n")
-        sys.exit(2)
-
-    target_evals_dir = target_skill_dir / "evals"
-    fixtures_dir = target_evals_dir / "fixtures"
-    golden_path = target_evals_dir / "golden.jsonl"
-
-    eval_root = load_eval_root(target_skill_name)
-    runs_dir = eval_root / "runs"
-    runs_dir.mkdir(parents=True, exist_ok=True)
-    sweep_stale(runs_dir)
-
-    run_id = datetime.now().strftime("%Y%m%d-%H%M%S")
-    results_run_dir = eval_root / "results" / run_id
-    results_run_dir.mkdir(parents=True, exist_ok=True)
-
-    cases = load_cases(golden_path)
-    case_results = await asyncio.gather(
-        *(run_case(c, run_id, eval_root, fixtures_dir) for c in cases)
-    )
-
-    pass_count = sum(1 for r in case_results if r["verdict"] == "PASS")
-    fail_count = sum(1 for r in case_results if r["verdict"] == "FAIL")
-    error_count = sum(1 for r in case_results if r["verdict"] == "ERROR")
-
-    summary = {
-        "run_id": run_id,
-        "results_dir": str(results_run_dir),
-        "summary": {
-            "total": len(case_results),
-            "pass": pass_count,
-            "fail": fail_count,
-            "error": error_count,
-        },
-        "cases": case_results,
-    }
-
-    (results_run_dir / "summary.json").write_text(
-        json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8"
-    )
-
-    sys.stdout.write(json.dumps(summary, ensure_ascii=False, indent=2))
-
-
-if __name__ == "__main__":
-    asyncio.run(main())