헤르메스 사례글 5 — [WEEK2] Proof Artifact & Code as Gate (상세본 v2.0)

# code_as_gate.py  (layer: 규율)
# 원칙 1: LLM 호출 금지.  2: 같은 입력 → 같은 판정.  3: 예외 = 차단.
from dataclasses import dataclass

@dataclass(frozen=True)
class GateResult:
    rule_id: str
    passed: bool
    reason: str
    severity: str          # 'block' | 'warn'

def g_ev_001(state):
    ev = state.get("evidence") or []
    ok = len(ev) >= 1
    return GateResult("G-EV-001", ok, "" if ok else "근거 0건", "block")

def g_ev_002(state):
    ev = state.get("evidence") or []
    bad = [i for i, e in enumerate(ev)
           if not e.get("source") or e.get("slide_number") in (None, "")]
    return GateResult("G-EV-002", not bad,
                      "" if not bad else f"출처 불완전 {len(bad)}건 (idx={bad})", "block")

def g_ev_003(state):
    ev = state.get("evidence") or []
    stub = [f'{e.get("source")}#{e.get("slide_number")}'
            for e in ev if not (e.get("text") or "").strip()]
    return GateResult("G-EV-003", not stub,
                      "" if not stub else f"스텁 혼입: {stub}", "block")

def g_vr_001(state):
    v = state.get("skill_versions") or {}
    missing = [n for n in ("N1", "N2", "N3") if n not in v]
    return GateResult("G-VR-001", not missing,
                      "" if not missing else f"버전 미기록: {missing}", "block")

GATE_CHAIN = [g_ev_001, g_ev_002, g_ev_003, g_vr_001]

def run_gate(state) -> list[GateResult]:
    """전 규칙을 끝까지 돌린다 — 첫 실패에서 멈추지 않는다."""
    out = []
    for rule in GATE_CHAIN:
        try:
            out.append(rule(state))
        except Exception as e:                      # 예외 = 차단
            out.append(GateResult(rule.__name__, False, f"검사 자체 실패: {e!r}", "block"))
    return out

def verdict_of(results) -> str:
    return "BLOCK" if any((not r.passed) and r.severity == "block" for r in results) else "PASS"

# 초안 (문제)
return {..., "gate_result": gate_evidence(state["evidence"])}   # ← 판정 재실행

# proof_artifact.py  (layer: 규율)
import hashlib, json, uuid
from datetime import datetime, timezone, timedelta
KST = timezone(timedelta(hours=9))

def now_kst(): return datetime.now(KST).strftime("%Y-%m-%d %H:%M:%S")

def input_hash(state) -> str:
    payload = {"question": state.get("question", ""), "saju": state.get("saju", {}),
               "lineage_plan": state.get("lineage_plan", {}),
               "skill_versions": state.get("skill_versions", {})}
    blob = json.dumps(payload, ensure_ascii=False, sort_keys=True)
    return hashlib.sha256(blob.encode("utf-8")).hexdigest()

def write_proof_artifact(state) -> dict:
    """증적을 남긴다. 판정을 다시 하지 않는다 — 상태의 결과를 옮겨 적을 뿐이다."""
    results = state["gate_results"]          # ← run_gate가 이미 넣어 둔 값
    return {
        "run_id": str(uuid.uuid4()), "timestamp_kst": now_kst(),
        "profile_id": state.get("profile_id"),        # 생년월일시 원문 미기록
        "input_hash": input_hash(state),
        "lineage_plan": state.get("lineage_plan", {}),
        "used_evidence": [{"source": e["source"], "slide_number": e["slide_number"],
                           "ts": e.get("ts")} for e in state.get("evidence", [])],
        "missing_ts": state.get("missing_ts", []),          # ★ 못 찾은 것
        "rejected": state.get("rejected_evidence", []),     # ★ 버린 것과 사유
        "retry_history": state.get("retry_history", []),
        "reroute_history": state.get("reroute_history", []),# ★ v2.0 — 4편 환류 이력
        "owner_signal": state.get("owner_signal", {}),      # ★ v2.0
        "halt_reason": state.get("halt_reason", ""),
        "gate_results": [r.__dict__ for r in results],
        "verdict": state.get("verdict"), "rtype": state.get("rtype"),
        "skill_versions": state.get("skill_versions", {}),
        "call_trace": state.get("call_trace", []),
        "human_gate": state.get("human_gate", {"required": False}),  # ★ v2.0
        "readback": state.get("readback", {"status": "not_checked"}),# ★ v2.0
    }

EXECUTE → PROOF → CROSS → CODE GATE → HUMAN GATE
 실행     증거    독립경로   기계        사람
                  확인    불변조건   미감·의미·승인

HUMAN_GATE_REQUIRED = {
    "guardrail_policy_change", "lineage_policy_change", "allowlist_add",
    "data_delete", "brief_report_release", "external_citation",
}

def needs_human_gate(action: str) -> bool:
    return action in HUMAN_GATE_REQUIRED

def readback_verify(conn, run_id: str, expected: dict) -> dict:
    """INSERT 응답을 믿지 않는다. 다시 읽어 대조한다."""
    row = conn.execute(
        "SELECT input_hash, verdict, jsonb_array_length(used_evidence) AS n "
        "FROM hermes.proof_artifact WHERE run_id = %s", (run_id,)
    ).fetchone()
    if row is None:
        return {"status": "fail", "reason": "INSERT 응답은 성공이나 행이 없음"}
    mismatch = {k: (getattr(row, k), expected[k])
                for k in ("input_hash", "verdict") if getattr(row, k) != expected[k]}
    if mismatch:
        return {"status": "fail", "reason": f"응답과 실제 상태 불일치: {mismatch}"}
    return {"status": "pass", "row_found": True, "evidence_count": row.n}

Eval Contract → Execute → Proof → Gate ──PASS──▶ 종료
                                    │
                                   FAIL
                                    ▼
                  Repair (가장 작은 실패 단계만)
                                    ▼
                            New Proof (새 증적)
                                    ▼
                            Gate 재판정 ──FAIL──▶ ↺ (또는 §3-9 rollback 판단)

{
  "run_id": "9f2c7a10-3b44-4d2e-9c81-6a5f0b1d77e2",
  "timestamp_kst": "2026-07-03 14:20:11",
  "profile_id": 1042,
  "input_hash": "3a7f…d91c",
  "lineage_plan": {"TS1": "①", "TS2": "①", "TS5": "②"},
  "used_evidence": [
    {"source": "박청화_정진반_下", "slide_number": 9636, "ts": 5},
    {"source": "박청화_정진반_下", "slide_number": 9640, "ts": 5}
  ],
  "missing_ts": [1, 2],
  "rejected": [
    {"source": "박청화_무엇이든물어보세요", "slide_number": 4108,
     "reason": "본문 공백 — 스텁"}
  ],
  "retry_history": [{"attempt": 0, "hits": 0}, {"attempt": 1, "hits": 3}],
  "reroute_history": [{"from": {"TS1": "②"}, "to": {"TS1": "①"}, "cause": "근거 0건"}],
  "owner_signal": {"stage": "N3", "reason": "", "repairable": true},
  "gate_results": [
    {"rule_id": "G-EV-001", "passed": true,  "reason": "", "severity": "block"},
    {"rule_id": "G-EV-002", "passed": true,  "reason": "", "severity": "block"},
    {"rule_id": "G-EV-003", "passed": true,  "reason": "", "severity": "block"},
    {"rule_id": "G-VR-001", "passed": false, "reason": "버전 미기록: ['N3']",
     "severity": "block"}
  ],
  "verdict": "BLOCK",
  "rtype": "BLOCKED",
  "skill_versions": {"N1": "0.2.0", "N2": "0.3.0"},
  "human_gate": {"required": false},
  "readback": {"status": "not_checked", "reason": "DB 미적재"},
  "cross_verification": {"status": "not_checked", "reason": "독립 경로 미구현"}
}

[v1.0 초안]
  END(성공) ──▶ 증적 ✓
  HALT(실패) ─▶       ✗   ← 추적이 가장 필요한 쪽이 비어 있다

[v2.0]
  END ──┐
  OWNER ┼─▶ GATE ─▶ PROOF ─▶ READBACK ─▶ 종료
  BLOCK ┘

CREATE SCHEMA IF NOT EXISTS hermes;

CREATE TABLE hermes.proof_artifact (
  id             bigserial PRIMARY KEY,
  run_id         uuid        NOT NULL UNIQUE,
  ts_kst         timestamptz NOT NULL DEFAULT now(),
  profile_id     bigint,
  input_hash     text        NOT NULL,
  lineage_plan   jsonb       NOT NULL,
  used_evidence  jsonb       NOT NULL,
  missing_ts     smallint[]  NOT NULL DEFAULT '{}',
  rejected       jsonb       NOT NULL DEFAULT '[]',
  retry_history  jsonb       NOT NULL DEFAULT '[]',
  reroute_history jsonb      NOT NULL DEFAULT '[]',
  gate_results   jsonb       NOT NULL,
  verdict        text        NOT NULL CHECK (verdict IN ('PASS','BLOCK')),
  rtype          text,
  halt_reason    text        NOT NULL DEFAULT '',
  skill_versions jsonb       NOT NULL,
  call_trace     jsonb       NOT NULL DEFAULT '[]',
  human_gate     jsonb       NOT NULL DEFAULT '{"required": false}',
  readback       jsonb       NOT NULL DEFAULT '{"status":"not_checked"}',
  elapsed_ms     integer
);

CREATE INDEX ON hermes.proof_artifact (ts_kst DESC);
CREATE INDEX ON hermes.proof_artifact (verdict) WHERE verdict = 'BLOCK';
CREATE INDEX ON hermes.proof_artifact (input_hash);
CREATE INDEX ON hermes.proof_artifact USING gin (used_evidence);

-- append-only 강제: 증적은 고쳐 쓸 수 없어야 한다
REVOKE UPDATE, DELETE ON hermes.proof_artifact FROM PUBLIC;

-- 최근 7일, 규칙별 차단 건수
SELECT r->>'rule_id' AS rule_id,
       COUNT(*) FILTER (WHERE (r->>'passed')::bool IS FALSE) AS blocked
FROM hermes.proof_artifact a, jsonb_array_elements(a.gate_results) r
WHERE a.ts_kst >= now() - interval '7 days'
GROUP BY 1 ORDER BY blocked DESC;

-- 재현성 검사: 같은 입력이 다른 근거를 냈는가
SELECT input_hash, COUNT(DISTINCT used_evidence::text) AS variants
FROM hermes.proof_artifact
GROUP BY 1 HAVING COUNT(DISTINCT used_evidence::text) > 1;

-- 리드백 미확인 비율 — 이 값이 0이 아니면 증적을 신뢰할 수 없다
SELECT readback->>'status' AS status, COUNT(*)
FROM hermes.proof_artifact GROUP BY 1;

실행한 것: (없음 — 게이트 미실행)
입력: 상태 픽스처 4종 (a 정상 / b 근거 0건 / c source 결손 / d 스텁 혼입)
관찰한 결과: —
완료 기준 판정: not_checked
막힌 것: hermes 스키마 미확인, 픽스처 미작성
확인하지 못한 것: 차단 케이스 증적 생성 여부, 리드백 동작, 게이트 소요 시간